Changeset 32340 in spip-zone


Ignore:
Timestamp:
Oct 24, 2009, 3:38:01 PM (11 years ago)
Author:
cedric@…
Message:

authentification openid fonctionnelle en 2.1
on change la signature de terminier_authentification_openid qui se contente de renvoyer une chaine d'erreur ou un tableau decrivant l'internaute identifie, charge a l'appelant d'en faire bon usage.
Cela casse le process en 2.0, reparation a suivre.

Une fonction verifier_openid permet de verifier qu'une url est valide en interrogeant le serveur.

Location:
_plugins_/authentification/openid
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/authentification/openid/inc/openid.php

    r32324 r32340  
    11<?php
     2/**
     3 * Plugin OpenID
     4 * Licence GPL (c) 2007-2009 Edouard Lafargue, Mathieu Marcillaud, Cedric Morin, Fil
     5 *
     6 */
    27
    38@define('_OPENID_LOG', true);
    49
    5 
     10/**
     11 * Ajout au formulaire de login
     12 *
     13 * @param string $texte
     14 * @param array $contexte
     15 * @return string
     16 */
    617function openid_login_form($texte,$contexte){
    718        $scriptopenid = "";
     
    3748}
    3849
    39 // determine si un login est de type openid (une url avec http ou https)
     50
     51/**
     52 * determine si un login est de type openid (une url avec http ou https)
     53 * @param <type> $login
     54 * @return <type>
     55 */
    4056function is_openid($login){
    4157        // Detection s'il s'agit d'un URL à traiter comme un openID
     
    5470}
    5571
    56 function nettoyer_openid($openid){
    57         $openid = vider_url($openid, false);
    58         $openid = rtrim($openid,'/');
     72/**
     73 * Nettoyer et mettre en forme une url OpenID
     74 *
     75 * @param string $url_openid
     76 * @return string
     77 */
     78function nettoyer_openid($url_openid){
     79        include_spip('inc/filtres');
     80        $url_openid = vider_url($url_openid, false);
     81        $url_openid = rtrim($url_openid,'/');
    5982        // si pas de protocole et que ca ne semble pas un email style gmail,
    6083        // mettre http://
    61         if ($openid  AND !preg_match(';^[a-z]{3,6}://;i',$openid ) AND strpos($openid,'@')===FALSE)
    62                 $openid = "http://".$openid;
     84        if ($url_openid  AND !preg_match(';^[a-z]{3,6}://;i',$url_openid ) AND strpos($url_openid,'@')===FALSE)
     85                $url_openid = "http://".$url_openid;
    6386
    6487        // pas d'ancre dans une url openid !
    65         $openid = preg_replace(',#[^#]*$,','',$openid);
    66 
    67         return $openid;
    68 }
    69 /*****
    70  * Initialisation de l'authent OpenID
    71  ****/
    72 
    73 function init_auth_openid() {
    74         session_start();
    75        
    76         $cwd = getcwd();
    77         //chdir(dirname(dirname(__FILE__)));
    78         chdir(realpath(_DIR_OPENID_LIB));
    79         require_once "Auth/OpenID/Consumer.php";
    80         require_once "Auth/OpenID/FileStore.php";
    81     require_once "Auth/OpenID/SReg.php"; // Require the Simple Registration extension API.
    82         chdir($cwd);
    83 
    84         /****
    85          * Répertoire temporaire où auth_openid stocke ses données
    86          * afin de suivre les sessions.
    87          ****/
    88 
    89         $store = new Auth_OpenID_FileStore(sous_repertoire(_DIR_TMP, 'auth_openid'));
    90 
    91         /**
    92          * Create a consumer object using the store object created earlier.
    93          */
    94         return new Auth_OpenID_Consumer($store);
    95 }
    96 
    97 
    98 /**
    99  * Logs pour openID, avec plusieurs niveaux pour le debug (1 a 3)
     88        // (Yahoo ajoute une ancre a l'url a son retour)
     89        $url_openid = preg_replace(',#[^#]*$,','',$url_openid);
     90
     91        return $url_openid;
     92}
     93
     94/**
     95 * Verifier qu'une url OpenID est valide
     96 *
     97 * @param string $url_openid
     98 */
     99function verifier_openid($url_openid){
     100        // Begin the OpenID authentication process.
     101        $consumer = init_auth_openid();
     102        openid_log("Initialisation faite", 3);
     103        if ($auth_request = $consumer->begin($url_openid))
     104                return true;
     105        return false;
     106}
     107
     108
     109/**
     110 * Logs pour openID, avec plusieurs niveaux pour le debug (1 a 3)
    100111 *
    101112 * @param mixed $data : contenu du log
     
    110121
    111122
    112 function demander_authentification_openid($login, $cible){
    113         openid_log("Traitement login OpenID pour $login",2);
     123/**
     124 * Initialisation de l'authent OpenID
     125 *
     126 * @return Auth_OpenID_Consumer
     127 */
     128function init_auth_openid() {
     129        session_start();
     130       
     131        $cwd = getcwd();
     132        //chdir(dirname(dirname(__FILE__)));
     133        chdir(realpath(_DIR_OPENID_LIB));
     134        require_once "Auth/OpenID/Consumer.php";
     135        require_once "Auth/OpenID/FileStore.php";
     136        require_once "Auth/OpenID/SReg.php"; // Require the Simple Registration extension API.
     137        chdir($cwd);
     138
     139        /****
     140         * Répertoire temporaire où auth_openid stocke ses données
     141         * afin de suivre les sessions.
     142         ****/
     143
     144        $store = new Auth_OpenID_FileStore(sous_repertoire(_DIR_TMP, 'auth_openid'));
     145
     146        /**
     147         * Create a consumer object using the store object created earlier.
     148         */
     149        return new Auth_OpenID_Consumer($store);
     150}
     151
     152
     153/**
     154 * Lancer une demande d'auth par OpenID
     155 * consiste a verifier que l'url est legitime,
     156 * et a rediriger vers le serveur OpenID,
     157 * qui renverra sur l'url $retour apres identification
     158 *
     159 * Si tout se passe bien, la fonction quitte par une redirection+exit
     160 * En cas d'echec, la fonction renvoie une erreur
     161 *
     162 * @param string $url_openid
     163 * @param string $retour
     164 * @return string
     165 */
     166function demander_authentification_openid($url_openid, $retour){
     167        openid_log("Traitement login OpenID pour $url_openid",2);
    114168
    115169        // Begin the OpenID authentication process.
    116170        $consumer = init_auth_openid();
    117171        openid_log("Initialisation faite", 3);
    118         $auth_request = $consumer->begin($login);
     172        $auth_request = $consumer->begin($url_openid);
    119173
    120174        // Handle failure status return values.
     
    122176                // ici, on peut rentrer dire que l'openid n'est pas connu...
    123177                // plutot que de rediriger et passer la main a d'autres methodes d'auth
    124                 openid_log("Ce login ($login) n'est pas connu", 2);
     178                openid_log("Ce login ($url_openid) n'est pas connu", 2);
    125179                return _T('openid:erreur_openid');
    126180        }
     
    133187        // - une url de redirection, sur laquelle OPENID reviendra une fois l'authentification faite (réussie ou non)
    134188        else {
    135                 openid_log("Le login $login existe", 2);
     189                openid_log("Le login $url_openid existe", 2);
    136190                // argument de redirection : cette url doit etre identique
    137191                // ici et au retour (au moins le premier parametre de l'url)
     
    141195                // vers laquelle le bonhomme souhaite aller (url=$cible)
    142196               
    143                 // attention, il ne faut pas utiliser parametre_url() afin
    144                 // d'encoder $cible, ce qui casserait la transaction...
    145                 $retour = parametre_url(openid_url_reception(), "url", url_absolue($cible), '&');
    146197                openid_log("Adresse de retour : $retour", 2);
    147198                // on demande quelques informations, dont le login obligatoire
     
    168219                                openid_log("Erreur sur l'adresse de redirection : $redirect", 2);
    169220                                $erreur = openid_url_erreur(_L("Could not redirect to server: " . $redirect->message), $cible);
     221                        }
     222                        // pas d'erreur : redirection par entete
     223                        else {
     224                                openid_log("Redirection par entete", 3);
     225                                include_spip('inc/headers');
     226                                #redirige_par_entete($redirect);
     227                                echo redirige_formulaire($redirect);
     228                                exit;
    170229                        }
    171230                }
     
    208267        }
    209268       
    210         openid_log("Redirection par entete", 3);
    211         include_spip('inc/headers');
    212         #redirige_par_entete($redirect);               
    213         echo redirige_formulaire($redirect);
    214         exit;
    215 }
    216 
    217 
    218 
    219 // analyse le retour de la requete openID
    220 // et redirige vers une url en fonction
    221 function terminer_authentification_openid($cible){
    222         $redirect=""; // redirection sur erreur
    223         openid_log("Retour du fournisseur OpenId avec : $cible", 2);
     269}
     270
     271
     272/**
     273 * Finir l'authentification apres le retour depuis le serveur openID
     274 * analyse le retour de la requete openID
     275 * utilise l'url de retour pour verifier la demande
     276 * renvoie une chaine d'erreur en cas d'erreur
     277 * un tableau decrivant l'utilisateur en cas de succes
     278 *
     279 * @param string $retour
     280 * @return mixed
     281 */
     282function terminer_authentification_openid($retour){
     283        openid_log("Retour du fournisseur OpenId", 2);
    224284       
    225285        // Complete the authentication process using the server's response.
    226286        $consumer = init_auth_openid();
    227287        openid_log("Initialisation faite. analyse de la reponse rendue", 2);
    228         $response = $consumer->complete(openid_url_reception());
    229 
    230         // This means the authentication was cancelled.
     288        $response = $consumer->complete($retour);
     289
     290        // Authentification annulee par l'utilisateur
    231291        if ($response->status == Auth_OpenID_CANCEL) {
    232292                openid_log("Processus annule par l'utilisateur", 2);
    233             $redirect = openid_url_erreur(_T('openid:verif_refusee'), $cible);
     293                return _T('openid:verif_refusee');
    234294        }
    235295       
     
    237297        elseif ($response->status == Auth_OpenID_FAILURE) {
    238298                openid_log("Echec de l'authentification chez le fournisseur", 2);
    239             $redirect = openid_url_erreur("Authentication failed: " . $response->message, $cible);
     299          return _L("Authentication failed: " . $response->message);
    240300        }
    241301       
    242         // This means the authentication succeeded.
     302        // Authentification reussie
    243303        elseif ($response->status == Auth_OpenID_SUCCESS) {
    244304               
    245305                $openid = nettoyer_openid($response->identity_url); // pas de / final dans l'openid
    246306               
    247                 $esc_identity = htmlspecialchars($openid, ENT_QUOTES);
    248307                openid_log("Succes de l'authentification $openid chez le fournisseur d'identification", 1);
    249 
    250                 // identification dans SPIP
    251                 // (charge inc/auth_openid)
    252                 openid_log("Verification de l'identite '$openid' dans SPIP", 2);
    253 
    254                 $auth = charger_fonction('openid','auth');
    255                 if (!$ok = $auteur = $auth($openid, "","","",'ok')){ // pas de mot de passe
    256                         // c'est ici que l'on peut ajouter un utilisateur inconnu dans SPIP
    257                         // en plus, on connait (si la personne l'a autorise) son nom et email
    258                         // en plus du login
    259                         openid_log("Identite '$openid' inconnue SPIP", 2);
    260                        
    261                         // recuperer login, nom, email
    262                         $sreg_resp = Auth_OpenID_SRegResponse::fromSuccessResponse($response);
    263                         $sreg = $sreg_resp->contents();
    264                         $couples = array(
    265                                 'login' => isset($sreg['nickname']) ? $sreg['nickname'] : '',
    266                                 'email' => isset($sreg['email']) ? $sreg['email'] : '',
    267                                 // login a defaut du nom, sinon c'est 'Nouvel auteur' qui est enregistre
    268                                 'nom' => isset($sreg['fullname']) ? $sreg['fullname'] : $sreg['nickname'],
    269                                 'openid' => $openid
    270                         );
    271 
     308                // recuperer login, nom, email
     309                $sreg_resp = Auth_OpenID_SRegResponse::fromSuccessResponse($response);
     310                $sreg = $sreg_resp->contents();
     311                $identite = array(
     312                        'login' => isset($sreg['nickname']) ? $sreg['nickname'] : '',
     313                        'email' => isset($sreg['email']) ? $sreg['email'] : '',
     314                        // login a defaut du nom, sinon c'est 'Nouvel auteur' qui est enregistre
     315                        'nom' => isset($sreg['fullname']) ? $sreg['fullname'] : $sreg['nickname'],
     316                        'openid' => $openid
     317                );
     318                return $identite;
     319        }
     320        return false;
     321}
     322/*
    272323                        #openid_log("sreg ".var_export($sreg_resp,true), 2);
    273324
     
    349400        redirige_par_entete($redirect?$redirect:$cible);       
    350401}
    351 
     402*/
    352403
    353404function openid_url_reception(){
  • _plugins_/authentification/openid/spip_2_0/auth/openid.php

    r32326 r32340  
    4444                // pour d'autres methodes d'identification
    4545                include_spip('inc/openid');
     46                $retour = parametre_url(openid_url_reception(), "url", url_absolue($cible), '&');
    4647                $erreurs_openid = demander_authentification_openid($auteur['openid'], url_absolue(self()));
    4748                // potentiellement, on arrive ici avec une erreur si l'openid donne n'existe pas
  • _plugins_/authentification/openid/spip_2_1/auth/openid.php

    r32326 r32340  
    1616 * @param string $pass
    1717 * @param string $serveur
    18  * @param string $log_step
    1918 * @return <type>
    2019 */
    21 function auth_openid_dist ($login, $pass, $serveur='', $log_step='check') {
     20function auth_openid_dist ($login, $pass, $serveur='') {
    2221
    2322        // il faut un login non vide ET un pass vide (sinon cela ne concerne pas OpenID)
     
    3029                return false;
    3130       
    32         if ($log_step=='check') {
    33                 // * Si l'openid existe, la procedure continue en redirigeant
    34                 // vers le fournisseur d'identite. En cas d'erreur, il y a une redirection de faite
    35                 // sur la page login, en cas de reussite, sur l'action controler_openid
    36                 // * S'il l'openid n'existe pas, on est de retour ici, et on continue
    37                 // pour d'autres methodes d'identification
    38                 include_spip('inc/openid');
    39                 $erreurs_openid = demander_authentification_openid($idurl, url_absolue(self()));
    40                 // potentiellement, on arrive ici avec une erreur si l'openid donne n'existe pas
    41                 // on la renvoie
    42                 return $erreurs_openid;
     31        // * Si l'openid existe, la procedure continue en redirigeant
     32        // vers le fournisseur d'identite. En cas d'erreur, il y a une redirection de faite
     33        // sur la page login, en cas de reussite, sur l'action controler_openid
     34        // * S'il l'openid n'existe pas, on est de retour ici, et on continue
     35        // pour d'autres methodes d'identification
     36        include_spip('inc/openid');
     37        $retour = auth_url_retour_login('openid', $login, url_absolue(self()));
     38        $erreurs_openid = demander_authentification_openid($idurl, $retour);
     39        // potentiellement, on arrive ici avec une erreur si l'openid donne n'existe pas
     40        // on la renvoie
     41        return $erreurs_openid;
     42}
     43
     44function auth_openid_terminer_identifier_login($login, $serveur=''){
     45        include_spip('inc/openid');
     46        $retour = auth_url_retour_login('openid', $login);
     47        $auteur = terminer_authentification_openid($retour);
     48
     49        if (is_string($auteur))
     50                return $auteur; // erreur !
     51
     52        if (is_array($auteur)
     53                AND isset($auteur['openid'])
     54                AND $openid = $auteur['openid']
     55          AND $auteur = sql_fetsel("*", "spip_auteurs", "login=" . sql_quote($login)." AND openid=".sql_quote($openid),"","","","",$serveur)){
     56
     57                $auteur['auth'] = 'openid'; // on se log avec cette methode, donc
     58                return $auteur;
    4359        }
    44         elseif ($log_step=='ok'){
    45                 $auteur = sql_fetsel("*", "spip_auteurs", "login=" . sql_quote($login),"","","","",$serveur);
    46                 $auteur['auth'] = 'openid'; // on se log avec cette methode, donc
    47         }
    48 
    49         return $auteur;
     60        return false;
    5061}
    5162
Note: See TracChangeset for help on using the changeset viewer.