WebSVN – Applications.framework – Diff – /trunk/framework/OpenIdClient.php


<?php 
/**
 * La classe OpenIdClient est une implémentation d'un client OpenId, depuis une classe Zend.
 * Elle permet d'établir une connexion avec un serveur, en fonction d'un identifiant OpenId.
 * Elle permet de communiquer de manière sécurisée avec ce serveur, et doit aboutir a une 
 * identification centralisée.
 * */
 
class OpenIdClient {
	
	//OpenID 2.0 namespace. Tous les messages OpenID 2.0 DOIVENT contenir la variable openid.ns et sa valeur
    const NS_2_0 = 'http://specs.openid.net/auth/2.0';
    
    
    // TODO : remplacer _storage par une gestion par cache ?
	/**
 
     * Variable permettant le stockage d'informations, notammenent à propos des clés DiffieHellmann
     * @var Storage $_storage
     */
    protected $_storage = null;
    
    /**
     * Tableau "cache" interne permettant d'éviter des accès inutiles au fichier storage
 
     * @var array $_cache
     */
    protected $_cache = array();
 
 
 
    // Client pour les requetes.
 
 
    private $client;
 
    
	/**
	 * Constructeur de l'application
	 * */
	function __construct()	{
		$this->client = new Client();
		$this->_storage = new StorageFile();
	}
	
	/**
	 * Fonction login
	 * 
	 * Return true ou false
	 * > Ne retourne rien si true car redirige vers l'adresse du serveur OID
	 * */
	//FIXME : le paramètre immediate ?
	// A vérifier mais ça doit permettre de passer directement le mot de passe. Il reste plus qu'à trouver le nom de la variable mot de passe.
	
	function login($id, $immediate = false)	{
		
		// L'original retourne la fonction checkId, avec le parametre immediate = true
		// Je ne comprends pas l'utilité, je fusionne les deux pour l'instant
		// FIXME : si pas de comportement étrange, valider.
		
		
		//Tests et arrêt si non validé : 
			//Normaliser (traite si XRI ou URL, normalize URL)
			//FIXME : voir avec JP pour équivalent dans framework
			if (!$this->normalize($id))	{
				return false;
			}
			
			//Discovery
			// Récupérer les informations sur le serveur OPEN ID
			/*
			 FIXME : ca change la valeur de l'id !!!
			 if (!$this->_discovery($id, $server, $version)) {
		         trigger_error('Discovery failed');
		         return false;
		    }*/
			
		    $retour_url = $this->client->consulter($id); 
		    //Le retour contient les balises suivantes :
			/*
			 * 
			 * <link rel="openid.server" href="http://www.myopenid.com/server" />
			 * <link rel="openid2.provider" href="http://www.myopenid.com/server" />
			 */
			$metaServeur = $this->verifierVersion($retour_url);
			
			//TODO : Voir avec JP : la classe client ne permet pas de vérifer le statut ?? 
			
			if ($retour_url === false) {
				trigger_error('L\'adresse $id est inacessible', E_USER_ERROR);
				return false;
			}
			if ($metaServeur === false)	{
				return false;
			}
			if (!$this->_associate($metaServeur['serveur'], $metaServeur['version'])) {
            	trigger_error('Impossible de s\'associer avec le serveur');
        	}
        	
        	
        	/*TODO : fonctionnement différent
        	 if (!$this->_getAssociation(
                $server,
                $handle,
                $macFunc,
                $secret,
                $expires)) {
            /* Use dumb mode *
            unset($handle);
            unset($macFunc);
            unset($secret);
            unset($expires);*
        }*/
 
			//on a la version, l'adresse du serveur et le realId si c'est une 2.0 dans metaServeur
			if (isset($metaServeur['realId'])) {
				$id = $metaServeur['realId']; 
			}
			
			//Associate
			//getAssociation
		
		//Organisation des paramètres :
		$params = array();
		
	
        if ($metaServeur['version'] >= 2.0) {
            $params['openid.ns'] = self::NS_2_0;
        }
 
        $params['openid.mode'] = $immediate ?
            'checkid_immediate' : 'checkid_setup';
 
        $params['openid.identity'] = $id;
 
        //FIXME : Ex : $params['openid.claimed_id'] = $claimedId; > jvois pas l'intéret
        $params['openid.claimed_id'] = $id;
        /*
         * TODO : gérer les sessions et namespace
         * if ($metaServeur['version'] <= 2.0) {
            if ($this->_session !== null) {
                $this->_session->identity = $id;
                $this->_session->claimed_id = $claimedId;
            } else if (defined('SID')) {
                $_SESSION["zend_openid"] = array(
                    "identity" => $id,
                    "claimed_id" => $claimedId);
            } else {
                require_once "Zend/Session/Namespace.php";
                $this->_session = new Zend_Session_Namespace("zend_openid");
                $this->_session->identity = $id;
                $this->_session->claimed_id = $claimedId;
            }
        }*/
 
        if (isset($handle)) {
            $params['openid.assoc_handle'] = $handle;
        }
 
        //FIXME : $params['openid.return_to'] = $this->absoluteUrl($returnTo);
        $params['openid.return_to'] = $this->absoluteUrl(null);
 
        if (empty($root)) {
            $root = $this->selfUrl();
            if ($root[strlen($root)-1] != '/') {
                $root = dirname($root);
            }
        }
        if ($metaServeur['version'] >= 2.0) {
            $params['openid.realm'] = $root;
        } else {
            $params['openid.trust_root'] = $root;
        }
 
        /*FIXME :: 
         
         if (!Zend_OpenId_Extension::forAll($extensions, 'prepareRequest', $params)) {
            $this->_setError("Extension::prepareRequest failure");
            return false;
        }*/
 
        $this->redirect($metaServeur['serveur'], $params);
        return true;
		//Renvoyer vers l'url
	}
	
	/**
     * Verifies authentication response from OpenID server.
     *
     * This is the second step of OpenID authentication process.
     * The function returns true on successful authentication and false on
     * failure.
     *
     * @param array $params HTTP query data from OpenID server
     * @param string &$identity this argument is set to end-user's claimed
     *  identifier or OpenID provider local identifier.
     * @param mixed $extensions extension object or array of extensions objects
     * @return bool
     */
    public function verify($params, &$identity = "", $extensions = null)
    {
    	
    	echo '<pre>'.print_r($params, true).'</pre>';
    	
        $version = 1.1;
        if (isset($params['openid_ns']) &&
            $params['openid_ns'] == $this->NS_2_0) {
            $version = 2.0;
        }
 
        if (isset($params["openid_claimed_id"])) {
            $identity = $params["openid_claimed_id"];
        } else if (isset($params["openid_identity"])){
            $identity = $params["openid_identity"];
        } else {
            $identity = "";
        }
 
        if ($version < 2.0 && !isset($params["openid_claimed_id"])) {
            if ($this->_session !== null) {
                if ($this->_session->identity === $identity) {
                    $identity = $this->_session->claimed_id;
                }
            } else if (defined('SID')) {
                if (isset($_SESSION["zend_openid"]["identity"]) &&
                    isset($_SESSION["zend_openid"]["claimed_id"]) &&
                    $_SESSION["zend_openid"]["identity"] === $identity) {
                    $identity = $_SESSION["zend_openid"]["claimed_id"];
                }
            } else {
                require_once "Zend/Session/Namespace.php";
                $this->_session = new Zend_Session_Namespace("zend_openid");
                if ($this->_session->identity === $identity) {
                    $identity = $this->_session->claimed_id;
                }
            }
        }
 
        if (empty($params['openid_mode'])) {
            $this->_setError("Missing openid.mode");
            return false;
        }
        if (empty($params['openid_return_to'])) {
            $this->_setError("Missing openid.return_to");
            return false;
        }
        if (empty($params['openid_signed'])) {
            $this->_setError("Missing openid.signed");
            return false;
        }
        if (empty($params['openid_sig'])) {
            $this->_setError("Missing openid.sig");
            return false;
        }
        if ($params['openid_mode'] != 'id_res') {
            $this->_setError("Wrong openid.mode '".$params['openid_mode']."' != 'id_res'");
            return false;
        }
        if (empty($params['openid_assoc_handle'])) {
            $this->_setError("Missing openid.assoc_handle");
            return false;
        }
        
        if ($params['openid_return_to'] != $this->selfUrl()) {
            /* Ignore query part in openid.return_to */
            $pos = strpos($params['openid_return_to'], '?');
            if ($pos === false ||
                SUBSTR($params['openid_return_to'], 0 , $pos) != $this->selfUrl()) {
 
                /*$this->_setError("Wrong openid.return_to '".
                    $params['openid_return_to']."' != '" . $this->selfUrl() ."'");*/
                trigger_error('Wrong openid.return_to', E_USER_ERROR);	
                	
                return false;
            }
        }
 
        if ($version >= 2.0) {
            if (empty($params['openid_response_nonce'])) {
                trigger_error('Missing openid.response_nonce', E_USER_ERROR);
                return false;
            }
            if (empty($params['openid_op_endpoint'])) {
                trigger_error('Missing openid.op_endpoint', E_USER_ERROR);
                return false;
            /* OpenID 2.0 (11.3) Checking the Nonce */
            } else if (!$this->_storage->isUniqueNonce($params['openid_op_endpoint'], $params['openid_response_nonce'])) {
                trigger_error('Duplicate openid.response_nonce', E_USER_ERROR);
                return false;
            }
        }
 
        if (!empty($params['openid_invalidate_handle'])) {
            if ($this->_storage->getAssociationByHandle(
                $params['openid_invalidate_handle'],
                $url,
                $macFunc,
                $secret,
                $expires)) {
                $this->_storage->delAssociation($url);
            }
        }
 
        if ($this->_storage->getAssociationByHandle(
                $params['openid_assoc_handle'],
                $url,
                $macFunc,
                $secret,
                $expires)) {
            $signed = explode(',', $params['openid_signed']);
            $data = '';
            foreach ($signed as $key) {
                $data .= $key . ':' . $params['openid_' . strtr($key,'.','_')] . "\n";
            }
            if (base64_decode($params['openid_sig']) ==
                Zend_OpenId::hashHmac($macFunc, $data, $secret)) {
                /*
                 * FIXME dépendance je sais pas pour quoi : a voir :
                 * if (!Zend_OpenId_Extension::forAll($extensions, 'parseResponse', $params)) {
                    $this->_setError("Extension::parseResponse failure");
                    return false;
                }*/
                /* OpenID 2.0 (11.2) Verifying Discovered Information */
                if (isset($params['openid_claimed_id'])) {
                    $id = $params['openid_claimed_id'];
                    if (!$this->normalize($id)) {
                        $this->_setError("Normalization failed");
                        return false;
                    } else if (!$this->_discovery($id, $discovered_server, $discovered_version)) {
                        $this->_setError("Discovery failed: " . $this->getError());
                        return false;
                    } else if ((!empty($params['openid_identity']) &&
                                $params["openid_identity"] != $id) ||
                               (!empty($params['openid_op_endpoint']) &&
                                $params['openid_op_endpoint'] != $discovered_server) ||
                               $discovered_version != $version) {
                        $this->_setError("Discovery information verification failed");
                        return false;
                    }
                }
                return true;
            }
            $this->_storage->delAssociation($url);
            $this->_setError("Signature check failed");
            return false;
        }
        else
        {
            /* Use dumb mode */
            if (isset($params['openid_claimed_id'])) {
                $id = $params['openid_claimed_id'];
            } else if (isset($params['openid_identity'])) {
                $id = $params['openid_identity'];
            } else {
                $this->_setError("Missing openid.claimed_id and openid.identity");
                return false;
            }
 
            if (!$this->normalize($id)) {
              	trigger_error('Normalization failed', E_USER_ERROR);
                return false;
            } else if (!$this->_discovery($id, $server, $discovered_version)) {
                trigger_error('Discovery failed', E_USER_ERROR);
                return false;
            }
 
            /* OpenID 2.0 (11.2) Verifying Discovered Information */
            if ((isset($params['openid_identity']) &&
                 $params["openid_identity"] != $id) ||
                (isset($params['openid_op_endpoint']) &&
                 $params['openid_op_endpoint'] != $server) ||
                $discovered_version != $version) {
                trigger_error('Discovery information verification failed', E_USER_ERROR);
                return false;
            }
 
            $params2 = array();
            foreach ($params as $key => $val) {
                if (strpos($key, 'openid_ns_') === 0) {
                    $key = 'openid.ns.' . substr($key, strlen('openid_ns_'));
                } else if (strpos($key, 'openid_sreg_') === 0) {
                    $key = 'openid.sreg.' . substr($key, strlen('openid_sreg_'));
                } else if (strpos($key, 'openid_') === 0) {
                    $key = 'openid.' . substr($key, strlen('openid_'));
                }
                $params2[$key] = $val;
            }
            $params2['openid.mode'] = 'check_authentication';
            $ret = $this->client->modifier($serveur, $params2);
            
            //_httpRequest($server, 'POST', $params2, $status);
            if ($ret === false) {
                trigger_error("'Dumb' signature verification HTTP request failed", E_USER_ERROR);
                return false;
            }
            $r = array();
            if (is_string($ret)) {
                foreach(explode("\n", $ret) as $line) {
                    $line = trim($line);
                    if (!empty($line)) {
                        $x = explode(':', $line, 2);
                        if (is_array($x) && count($x) == 2) {
                            list($key, $value) = $x;
                            $r[trim($key)] = trim($value);
                        }
                    }
                }
            }
            $ret = $r;
            if (!empty($ret['invalidate_handle'])) {
                if ($this->_storage->getAssociationByHandle(
                    $ret['invalidate_handle'],
                    $url,
                    $macFunc,
                    $secret,
                    $expires)) {
                    $this->_storage->delAssociation($url);
                }
            }
            if (isset($ret['is_valid']) && $ret['is_valid'] == 'true') {
                if (!Zend_OpenId_Extension::forAll($extensions, 'parseResponse', $params)) {
                    $this->_setError("Extension::parseResponse failure");
                    return false;
                }
                return true;
            }
            $this->_setError("'Dumb' signature verification failed");
            return false;
        }
    }
	
	
	/**
     * Performs discovery of identity and finds OpenID URL, OpenID server URL
     * and OpenID protocol version. Returns true on succees and false on
     * failure.
     *
     * @param string &$id OpenID identity URL
     * @param string &$server OpenID server URL
     * @param float &$version OpenID protocol version
     * @return bool
     * @todo OpenID 2.0 (7.3) XRI and Yadis discovery
     */
    protected function _discovery(&$id, &$server, &$version)
    { 
        $realId = $id;
        if ($this->_storage->getDiscoveryInfo(
                $id,
                $realId,
                $server,
                $version,
                $expire)) {
            $id = $realId;
            return true;
        }
	
        /* TODO: OpenID 2.0 (7.3) XRI and Yadis discovery */
 
        /* HTML-based discovery */
        $clientDiscovery = new Client();
               
        //TODO : rajouter un test sur le statut de la réponse
        // Nécessite la prise en compte des entetes dans le framework
        
        /*if ($status != 200 || !is_string($response)) {
            return false;
        }*/
        $reponse = $clientDiscovery->consulter($id);
        $metaServeur = $this->verifierVersion($reponse);
        if (!isset($metaServeur) || empty($reponse))	{
        	trigger_error('Aucune donnée OpenId', E_USER_ERROR);
        	return false;
        }
        
        $expire = time() + 60 * 60;
        $this->_storage->addDiscoveryInfo($id, $metaServeur['realId'], $metaServeur['serveur'], $metaServeur['version'], $expire);
        if (!empty($metaServeur['realId'])) {
        	$id = $metaServeur['realId'];
        }
        return true;
    }
	
	
	
	
	//Parser l'HTML de réponse pour trouver la version du serveur OPEN ID
	function verifierVersion($reponseHtml)	{
		
		// TODO : remplacer l'arlgorythme suivant par cette solution : 
		//1. Chercher l'existence d'une balise openidN.provider 
		//2. Déterminer la version en fonction de la chaine : openid2.provider => 2.0; openid.provider => 1.1
		//3. Récupérer l'url du serveur href="serveur"
		//4. SI 2.0, récupérer la valeur réelle de l'ID
		
		//TODO : penser à tester les deux versions du serveur
		
		$metaServeur = Array();
		
		if (preg_match(
                '/<link[^>]*rel=(["\'])[ \t]*(?:[^ \t"\']+[ \t]+)*?openid2.provider[ \t]*[^"\']*\\1[^>]*href=(["\'])([^"\']+)\\2[^>]*\/?>/i',
                $reponseHtml,
                $r)) {
            $metaServeur['version'] = 2.0;
            $metaServeur['serveur'] = $r[3];
        } else if (preg_match(
                '/<link[^>]*href=(["\'])([^"\']+)\\1[^>]*rel=(["\'])[ \t]*(?:[^ \t"\']+[ \t]+)*?openid2.provider[ \t]*[^"\']*\\3[^>]*\/?>/i',
                $reponseHtml,
                $r)) {
            $metaServeur['version'] = 2.0;
            $metaServeur['serveur'] = $r[1];
        } else if (preg_match(
                '/<link[^>]*rel=(["\'])[ \t]*(?:[^ \t"\']+[ \t]+)*?openid.server[ \t]*[^"\']*\\1[^>]*href=(["\'])([^"\']+)\\2[^>]*\/?>/i',
                $reponseHtml,
                $r)) {
            $metaServeur['version'] = 1.1;
            $metaServeur['serveur'] = $r[3];
        } else if (preg_match(
                '/<link[^>]*href=(["\'])([^"\']+)\\1[^>]*rel=(["\'])[ \t]*(?:[^ \t"\']+[ \t]+)*?openid.server[ \t]*[^"\']*\\3[^>]*\/?>/i',
                $reponseHtml,
                $r)) {
            $metaServeur['version'] = 1.1;
            $metaServeur['serveur'] = $r[2];
        } else {
            return false;
        }
        
        if ($metaServeur['version'] >= 2.0) {
            if (preg_match(
                    '/<link[^>]*rel=(["\'])[ \t]*(?:[^ \t"\']+[ \t]+)*?openid2.local_id[ \t]*[^"\']*\\1[^>]*href=(["\'])([^"\']+)\\2[^>]*\/?>/i',
                    $reponseHtml,
                    $r)) {
                $metaServeur['realId'] = $r[3];
            } else if (preg_match(
                    '/<link[^>]*href=(["\'])([^"\']+)\\1[^>]*rel=(["\'])[ \t]*(?:[^ \t"\']+[ \t]+)*?openid2.local_id[ \t]*[^"\']*\\3[^>]*\/?>/i',
                    $reponseHtml,
                    $r)) {
                $metaServeur['realId'] = $r[2];
            }
        } else {
            if (preg_match(
                    '/<link[^>]*rel=(["\'])[ \t]*(?:[^ \t"\']+[ \t]+)*?openid.delegate[ \t]*[^"\']*\\1[^>]*href=(["\'])([^"\']+)\\2[^>]*\/?>/i',
                    $reponseHtml,
                    $r)) {
                $metaServeur['realId'] = $r[3];
            } else if (preg_match(
                    '/<link[^>]*href=(["\'])([^"\']+)\\1[^>]*rel=(["\'])[ \t]*(?:[^ \t"\']+[ \t]+)*?openid.delegate[ \t]*[^"\']*\\3[^>]*\/?>/i',
                    $reponseHtml,
                    $r)) {
                $metaServeur['realId'] = $r[2];
            }
        }
		
        return $metaServeur;
	}
	
	/**
     * Create (or reuse existing) association between OpenID consumer and
     * OpenID server based on Diffie-Hellman key agreement. Returns true
     * on success and false on failure.
     *
     * @param string $url OpenID server url
     * @param float $version OpenID protocol version
     * @param string $priv_key for testing only
     * @return bool
     */
    protected function _associate($url, $version, $priv_key=null)
    {
        /* Check if we already have association in chace or storage */
       /* 
        * TODO : Utiliser le stockage plutot
        * */
        if ($this->_getAssociation(
                $url,
                $handle,
                $macFunc,
                $secret,
                $expires)) {
            return true;
        }
 
       /*
        * TODO : utiliser le fichier de config
        * if ($this->_dumbMode) {
	       return true;
       }*/
 
        $params = array();
 
        if ($version >= 2.0) {
            $params = array(
                'openid.ns'           => $this->NS_2_0,
                'openid.mode'         => 'associate',
                'openid.assoc_type'   => 'HMAC-SHA256',
                'openid.session_type' => 'DH-SHA256',
            );
        } else {
            $params = array(
                'openid.mode'         => 'associate',
                'openid.assoc_type'   => 'HMAC-SHA1',
                'openid.session_type' => 'DH-SHA1',
            );
        }
 
        $dh = DiffieHellmanUtil::createDhKey(pack('H*', DiffieHellmanUtil::DH_P),
                                       pack('H*', DiffieHellmanUtil::DH_G),
                                       $priv_key);
        $dh_details = DiffieHellmanUtil::getDhKeyDetails($dh);
 
        $params['openid.dh_modulus']         = base64_encode(
            DiffieHellmanUtil::btwoc($dh_details['p']));
        $params['openid.dh_gen']             = base64_encode(
            DiffieHellmanUtil::btwoc($dh_details['g']));
        $params['openid.dh_consumer_public'] = base64_encode(
            DiffieHellmanUtil::btwoc($dh_details['pub_key']));
 
        while(1) {
        	//FIXME : c'est pas une modification ...
            $ret = $this->client->modifier($url, $params); // FIXME : a quoi sert status ?, $status);
            if ($ret === false) {
                //$this->_setError("HTTP request failed");
                trigger_error('La requête a échoué', E_USER_ERROR);
                return false;
            }
 
            $r = array();
            $bad_response = false;
            foreach(explode("\n", $ret) as $line) {
                $line = trim($line);
                if (!empty($line)) {
                    $x = explode(':', $line, 2);
                    if (is_array($x) && count($x) == 2) {
                        list($key, $value) = $x;
                        $r[trim($key)] = trim($value);
                    } else {
                        $bad_response = true;
                    }
                }
            }
            if ($bad_response && strpos($ret, 'Unknown session type') !== false) {
                $r['error_code'] = 'unsupported-type';
            }
            $ret = $r;
 
            if (isset($ret['error_code']) &&
                $ret['error_code'] == 'unsupported-type') {
                if ($params['openid.session_type'] == 'DH-SHA256') {
                    $params['openid.session_type'] = 'DH-SHA1';
                    $params['openid.assoc_type'] = 'HMAC-SHA1';
                } else if ($params['openid.session_type'] == 'DH-SHA1') {
                    $params['openid.session_type'] = 'no-encryption';
                } else {
                    trigger_error("The OpenID service responded with: " . $ret['error_code'], E_USER_ERROR);
                    return false;
                }
            } else {
                break;
            }
        }
 
        /*
        FIXME : gestion du statut avec la classe client ??
        if ($status != 200) {
            $this->_setError("The server responded with status code: " . $status);
            return false;
        }*/
 
        if ($version >= 2.0 &&
            isset($ret['ns']) &&
            $ret['ns'] != $this->NS_2_0) {
            $this->_setError("Wrong namespace definition in the server response");
            return false;
        }
 
        if (!isset($ret['assoc_handle']) ||
            !isset($ret['expires_in']) ||
            !isset($ret['assoc_type']) ||
            $params['openid.assoc_type'] != $ret['assoc_type']) {
            if ($params['openid.assoc_type'] != $ret['assoc_type']) {
                $this->_setError("The returned assoc_type differed from the supplied openid.assoc_type");
            } else {
                $this->_setError("Missing required data from provider (assoc_handle, expires_in, assoc_type are required)");
            }
            return false;
        }
 
        $handle     = $ret['assoc_handle'];
        $expiresIn = $ret['expires_in'];
 
        if ($ret['assoc_type'] == 'HMAC-SHA1') {
            $macFunc = 'sha1';
        } else if ($ret['assoc_type'] == 'HMAC-SHA256' &&
            $version >= 2.0) {
            $macFunc = 'sha256';
        } else {
            $this->_setError("Unsupported assoc_type");
            return false;
        }
 
        if ((empty($ret['session_type']) ||
             ($version >= 2.0 && $ret['session_type'] == 'no-encryption')) &&
             isset($ret['mac_key'])) {
            $secret = base64_decode($ret['mac_key']);
        } else if (isset($ret['session_type']) &&
            $ret['session_type'] == 'DH-SHA1' &&
            !empty($ret['dh_server_public']) &&
            !empty($ret['enc_mac_key'])) {
            $dhFunc = 'sha1';
        } else if (isset($ret['session_type']) &&
            $ret['session_type'] == 'DH-SHA256' &&
            $version >= 2.0 &&
            !empty($ret['dh_server_public']) &&
            !empty($ret['enc_mac_key'])) {
            $dhFunc = 'sha256';
        } else {
            $this->_setError("Unsupported session_type");
            return false;
        }
        if (isset($dhFunc)) {
            $serverPub = base64_decode($ret['dh_server_public']);
            $dhSec = DiffieHellmanUtil::computeDhSecret($serverPub, $dh);
            if ($dhSec === false) {
                $this->_setError("DH secret comutation failed");
                return false;
            }
            $sec = $this->digest($dhFunc, $dhSec);
            if ($sec === false) {
                $this->_setError("Could not create digest");
                return false;
            }
            $secret = $sec ^ base64_decode($ret['enc_mac_key']);
        }
        if ($macFunc == 'sha1') {
            if (DiffieHellmanUtil::strlen($secret) != 20) {
                $this->_setError("The length of the sha1 secret must be 20");
                return false;
            }
        } else if ($macFunc == 'sha256') {
            if (DiffieHellmanUtil::strlen($secret) != 32) {
                $this->_setError("The length of the sha256 secret must be 32");
                return false;
            }
        }
        
        $this->_addAssociation(
            $url,
            $handle,
            $macFunc,
            $secret,
            time() + $expiresIn);
       /* $this->association['url'] = $url;
        $this->association['handle'] = $handle;
        $this->association['macFunc'] = $macFunc;
        $this->association['secret'] = $secret;
        $this->association['expiresIn'] = time() + $expiresIn;*/
        
        return true;
    }
    
	/**
     * Store assiciation in internal chace and external storage
     *
     * @param string $url OpenID server url
     * @param string $handle association handle
     * @param string $macFunc HMAC function (sha1 or sha256)
     * @param string $secret shared secret
     * @param integer $expires expiration UNIX time
     * @return void
     */
    protected function _addAssociation($url, $handle, $macFunc, $secret, $expires)
    {
        $this->_cache[$url] = array($handle, $macFunc, $secret, $expires);
        return $this->_storage->addAssociation(
            $url,
            $handle,
            $macFunc,
            $secret,
            $expires);
    }
    
	/**
     * Retrive assiciation information for given $url from internal cahce or
     * external storage
     *
     * @param string $url OpenID server url
     * @param string &$handle association handle
     * @param string &$macFunc HMAC function (sha1 or sha256)
     * @param string &$secret shared secret
     * @param integer &$expires expiration UNIX time
     * @return void
     */
    protected function _getAssociation($url, &$handle, &$macFunc, &$secret, &$expires)
    {
        if (isset($this->_cache[$url])) {
            $handle   = $this->_cache[$url][0];
            $macFunc = $this->_cache[$url][1];
            $secret   = $this->_cache[$url][2];
            $expires  = $this->_cache[$url][3];
            return true;
        }
        if ($this->_storage->getAssociation(
                $url,
                $handle,
                $macFunc,
                $secret,
                $expires)) {
            $this->_cache[$url] = array($handle, $macFunc, $secret, $expires);
            return true;
        }
        return false;
    }
    
	/**
     * Normalizes URL according to RFC 3986 to use it in comparison operations.
     * The function gets URL argument by reference and modifies it.
     * It returns true on success and false of failure.
     *
     * @param string &$id url to be normalized
     * @return bool
     */
    static public function normalizeUrl(&$id)
    {
        // RFC 3986, 6.2.2.  Syntax-Based Normalization
 
        // RFC 3986, 6.2.2.2 Percent-Encoding Normalization
        $i = 0;
        $n = strlen($id);
        $res = '';
        while ($i < $n) {
            if ($id[$i] == '%') {
                if ($i + 2 >= $n) {
                    return false;
                }
                ++$i;
                if ($id[$i] >= '0' && $id[$i] <= '9') {
                    $c = ord($id[$i]) - ord('0');
                } else if ($id[$i] >= 'A' && $id[$i] <= 'F') {
                    $c = ord($id[$i]) - ord('A') + 10;
                } else if ($id[$i] >= 'a' && $id[$i] <= 'f') {
                    $c = ord($id[$i]) - ord('a') + 10;
                } else {
                    return false;
                }
                ++$i;
                if ($id[$i] >= '0' && $id[$i] <= '9') {
                    $c = ($c << 4) | (ord($id[$i]) - ord('0'));
                } else if ($id[$i] >= 'A' && $id[$i] <= 'F') {
                    $c = ($c << 4) | (ord($id[$i]) - ord('A') + 10);
                } else if ($id[$i] >= 'a' && $id[$i] <= 'f') {
                    $c = ($c << 4) | (ord($id[$i]) - ord('a') + 10);
                } else {
                    return false;
                }
                ++$i;
                $ch = chr($c);
                if (($ch >= 'A' && $ch <= 'Z') ||
                    ($ch >= 'a' && $ch <= 'z') ||
                    $ch == '-' ||
                    $ch == '.' ||
                    $ch == '_' ||
                    $ch == '~') {
                    $res .= $ch;
                } else {
                    $res .= '%';
                    if (($c >> 4) < 10) {
                        $res .= chr(($c >> 4) + ord('0'));
                    } else {
                        $res .= chr(($c >> 4) - 10 + ord('A'));
                    }
                    $c = $c & 0xf;
                    if ($c < 10) {
                        $res .= chr($c + ord('0'));
                    } else {
                        $res .= chr($c - 10 + ord('A'));
                    }
                }
            } else {
                $res .= $id[$i++];
            }
        }
 
        if (!preg_match('|^([^:]+)://([^:@]*(?:[:][^@]*)?@)?([^/:@?#]*)(?:[:]([^/?#]*))?(/[^?#]*)?((?:[?](?:[^#]*))?)((?:#.*)?)$|', $res, $reg)) {
            return false;
        }
        $scheme = $reg[1];
        $auth = $reg[2];
        $host = $reg[3];
        $port = $reg[4];
        $path = $reg[5];
        $query = $reg[6];
        $fragment = $reg[7]; /* strip it */
 
        if (empty($scheme) || empty($host)) {
            return false;
        }
 
        // RFC 3986, 6.2.2.1.  Case Normalization
        $scheme = strtolower($scheme);
        $host = strtolower($host);
 
        // RFC 3986, 6.2.2.3.  Path Segment Normalization
        if (!empty($path)) {
            $i = 0;
            $n = strlen($path);
            $res = "";
            while ($i < $n) {
                if ($path[$i] == '/') {
                    ++$i;
                    while ($i < $n && $path[$i] == '/') {
                        ++$i;
                    }
                    if ($i < $n && $path[$i] == '.') {
                        ++$i;
                        if ($i < $n && $path[$i] == '.') {
                            ++$i;
                            if ($i == $n || $path[$i] == '/') {
                                if (($pos = strrpos($res, '/')) !== false) {
                                    $res = substr($res, 0, $pos);
                                }
                            } else {
                                    $res .= '/..';
                            }
                        } else if ($i != $n && $path[$i] != '/') {
                            $res .= '/.';
                        }
                    } else {
                        $res .= '/';
                    }
                } else {
                    $res .= $path[$i++];
                }
            }
            $path = $res;
        }
 
        // RFC 3986,6.2.3.  Scheme-Based Normalization
        if ($scheme == 'http') {
            if ($port == 80) {
                $port = '';
            }
        } else if ($scheme == 'https') {
            if ($port == 443) {
                $port = '';
            }
        }
        if (empty($path)) {
            $path = '/';
        }
 
        $id = $scheme
            . '://'
            . $auth
            . $host
            . (empty($port) ? '' : (':' . $port))
            . $path
            . $query;
        return true;
    }
 
    
    /**
     * Normaliser l'identifiant OpenId qui peut être une URL ou nom XRI
     * Retourne true ou false en cas d'erreur.
     *
     * Règles de normalisation : 
     * 1. If the user's input starts with one of the "xri://", "xri://$ip*",
     *    or "xri://$dns*" prefixes, they MUST be stripped off, so that XRIs
     *    are used in the canonical form, and URI-authority XRIs are further
     *    considered URL identifiers.
     * 2. If the first character of the resulting string is an XRI Global
     *    Context Symbol ("=", "@", "+", "$", "!"), then the input SHOULD be
     *    treated as an XRI.
     * 3. Otherwise, the input SHOULD be treated as an http URL; if it does
     *    not include a "http" or "https" scheme, the Identifier MUST be
     *    prefixed with the string "http://".
     * 4. URL identifiers MUST then be further normalized by both following
     *    redirects when retrieving their content and finally applying the
     *    rules in Section 6 of [RFC3986] to the final destination URL.
     * @param string &$id identifier to be normalized
     * @return bool
     */
    static public function normalize(&$id)
    {
        $id = trim($id);
        if (strlen($id) === 0) {
            return true;
        }
 
        // 7.2.1
        if (strpos($id, 'xri://$ip*') === 0) {
            $id = substr($id, strlen('xri://$ip*'));
        } else if (strpos($id, 'xri://$dns*') === 0) {
            $id = substr($id, strlen('xri://$dns*'));
        } else if (strpos($id, 'xri://') === 0) {
            $id = substr($id, strlen('xri://'));
        }
 
        // 7.2.2
        if ($id[0] == '=' ||
            $id[0] == '@' ||
            $id[0] == '+' ||
            $id[0] == '$' ||
            $id[0] == '!') {
            return true;
        }
 
        // 7.2.3
        if (strpos($id, "://") === false) {
            $id = 'http://' . $id;
        }
 
        // 7.2.4
        return self::normalizeURL($id);
    }
    
	/**
     * Generates a hash value (message digest) according to given algorithm.
     * It returns RAW binary string.
     *
     * This is a wrapper function that uses one of available internal function
     * dependent on given PHP configuration. It may use various functions from
     *  ext/openssl, ext/hash, ext/mhash or ext/standard.
     *
     * @param string $func digest algorithm
     * @param string $data data to sign
     * @return string RAW digital signature
     * @throws Zend_OpenId_Exception
     */
    public function digest($func, $data)
    {
        if (function_exists('openssl_digest')) {
            return openssl_digest($data, $func, true);
        } else if (function_exists('hash')) {
            return hash($func, $data, true);
        } else if ($func === 'sha1') {
            return sha1($data, true);
        } else if ($func === 'sha256') {
            if (function_exists('mhash')) {
                return mhash(MHASH_SHA256 , $data);
            }
        }
        /*require_once "Zend/OpenId/Exception.php";
        throw new Zend_OpenId_Exception(
            'Unsupported digest algorithm "' . $func . '".',
            Zend_OpenId_Exception::UNSUPPORTED_DIGEST);*/
        trigger_error('Unsupported digest algorithm '.$func , E_USER_ERROR);
    }
    
    
    
    
	
    
    
    
 	/**
     * Returns a full URL that was requested on current HTTP request.
     *
     * @return string
     */
    public function selfUrl()
    {
        /*FIXME : 
         * if ($this->$selfUrl !== null) {
            return $this->$selfUrl;
        } */
        
        if (isset($_SERVER['SCRIPT_URI'])) {
            return $_SERVER['SCRIPT_URI'];
        }
        $url = '';
        $port = '';
        if (isset($_SERVER['HTTP_HOST'])) {
            if (($pos = strpos($_SERVER['HTTP_HOST'], ':')) === false) {
                if (isset($_SERVER['SERVER_PORT'])) {
                    $port = ':' . $_SERVER['SERVER_PORT'];
                }
                $url = $_SERVER['HTTP_HOST'];
            } else {
                $url = substr($_SERVER['HTTP_HOST'], 0, $pos);
                $port = substr($_SERVER['HTTP_HOST'], $pos);
            }
        } else if (isset($_SERVER['SERVER_NAME'])) {
            $url = $_SERVER['SERVER_NAME'];
            if (isset($_SERVER['SERVER_PORT'])) {
                $port = ':' . $_SERVER['SERVER_PORT'];
            }
        }
        if (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on') {
            $url = 'https://' . $url;
            if ($port == ':443') {
                $port = '';
            }
        } else {
            $url = 'http://' . $url;
            if ($port == ':80') {
                $port = '';
            }
        }
 
        $url .= $port;
        if (isset($_SERVER['HTTP_X_REWRITE_URL'])) {
            $url .= $_SERVER['HTTP_X_REWRITE_URL'];
        } elseif (isset($_SERVER['REQUEST_URI'])) {
            $query = strpos($_SERVER['REQUEST_URI'], '?');
            if ($query === false) {
                $url .= $_SERVER['REQUEST_URI'];
            } else {
                $url .= substr($_SERVER['REQUEST_URI'], 0, $query);
            }
        } else if (isset($_SERVER['SCRIPT_URL'])) {
            $url .= $_SERVER['SCRIPT_URL'];
        } else if (isset($_SERVER['REDIRECT_URL'])) {
            $url .= $_SERVER['REDIRECT_URL'];
        } else if (isset($_SERVER['PHP_SELF'])) {
            $url .= $_SERVER['PHP_SELF'];
        } else if (isset($_SERVER['SCRIPT_NAME'])) {
            $url .= $_SERVER['SCRIPT_NAME'];
            if (isset($_SERVER['PATH_INFO'])) {
                $url .= $_SERVER['PATH_INFO'];
            }
        }
        return $url;
    }
    
    
    //TODO : vérifier si les fonctions FWK & ZEND sont bien équivalente
	/**
     * Retourne l'url absolue d'une url donnée
     *
     * @param string $url absilute or relative URL
     * @return string
     */
    public function absoluteUrl($url)
    {
    	if (!empty($ur))	{
    		$urlAbsolue = new Url($url);
    		$urlAbsolue->normaliser();
    		$url = $urlAbsolue->getUrl();
    	} else {
    		$url = $this->selfUrl();
    	}
    	
    	return $url;
    	/*
        if (empty($url)) {
            return $this->selfUrl();
        } else if (!preg_match('|^([^:]+)://|', $url)) {
            if (preg_match('|^([^:]+)://([^:@]*(?:[:][^@]*)?@)?([^/:@?#]*)(?:[:]([^/?#]*))?(/[^?]*)?((?:[?](?:[^#]*))?(?:#.*)?)$|', $this->selfUrl(), $reg)) {
                $scheme = $reg[1];
                $auth = $reg[2];
                $host = $reg[3];
                $port = $reg[4];
                $path = $reg[5];
                $query = $reg[6];
                if ($url[0] == '/') {
                    return $scheme
                        . '://'
                        . $auth
                        . $host
                        . (empty($port) ? '' : (':' . $port))
                        . $url;
                } else {
                    $dir = dirname($path);
                    return $scheme
                        . '://'
                        . $auth
                        . $host
                        . (empty($port) ? '' : (':' . $port))
                        . (strlen($dir) > 1 ? $dir : '')
                        . '/'
                        . $url;
                }
            }
        }
        return $url;*/
    }
    
    
    //TODO : voir si on ne peut pas glisser ça dans client ?
	//FIXME : je met une fonction SIMPLISSIME a améliorer et reécrire
    // La fonction de Zend est plus poussée est prend en compte le cas ou l'header ne peut pas etre envoyé
    /**
     * Rediriger vers la page du serveur avec les paramètres de confiration
     *
     * @param string $url URL de retour
     * @param array $params paramètres additionnels
     */
    public function redirect($url, $params)	{
    	//1. fabriquer l'url Get
    	$urlRedirection = new Url($url);
    	$urlRedirection->setRequete($params);
    	//echo $urlRedirection->getUrl();
    	try {
    		header('Location:'.$urlRedirection->getUrl());
    	} catch (Exception $e) {
    		//TODO : voir autres méthodes de redirection
    		// > balise META
    		// > formulaire HTML
    		// > JS
    	}
    }
}
?>

Rev 260	Rev 263
1	`<?php`	1	`<?php`
-		2	`/**`
-		3	`* La classe OpenIdClient est une implémentation d'un client OpenId, depuis une classe Zend.`
-		4	`* Elle permet d'établir une connexion avec un serveur, en fonction d'un identifiant OpenId.`
-		5	`* Elle permet de communiquer de manière sécurisée avec ce serveur, et doit aboutir a une`
-		6	`* identification centralisée.`
-		7	`* */`
-		8
2	`class OpenIdClient {`	9	`class OpenIdClient {`
3		10
4	`//OpenID 2.0 namespace. Tous les messages OpenID 2.0 DOIVENT contenir la variable openid.ns et sa valeur`	11	`//OpenID 2.0 namespace. Tous les messages OpenID 2.0 DOIVENT contenir la variable openid.ns et sa valeur`
5	`const NS_2_0 = 'http://specs.openid.net/auth/2.0';`	12	`const NS_2_0 = 'http://specs.openid.net/auth/2.0';`
6		13
-		14
7		15	`// TODO : remplacer _storage par une gestion par cache ?`
8	`/**`	16	`/**`
9	`* Reference to an implementation of storage object`	-
10	`*`	17	`* Variable permettant le stockage d'informations, notammenent à propos des clés DiffieHellmann`
11	`* @var Zend_OpenId_Consumer_Storage $_storage`	18	`* @var Storage $_storage`
12	`*/`	19	`*/`
13	`protected $_storage = null;`	20	`protected $_storage = null;`
14		21
15	`/**`	22	`/**`
16	`* Internal cache to prevent unnecessary access to storage`	23	`* Tableau "cache" interne permettant d'éviter des accès inutiles au fichier storage`
17	`*`	-
18	`* @var array $_cache`	24	`* @var array $_cache`
19	`*/`	25	`*/`
20	`protected $_cache = array();`	26	`protected $_cache = array();`
21		-
22		27
23	`// TODO : les associations dans ZEND sont gérées avec le fichier Stockage, faire pareil`	-
24	`//Association`	28	`// Client pour les requetes.`
25	`private $association = Array('url' => '', 'handle' => '', 'macFunc' => '', 'secret' => '', 'expires' => 0);`	-
26		-
27	`private $client;`	29	`private $client;`
28		-
29		30
30	`/**`	31	`/**`
31	`* Constructeur de l'application`	32	`* Constructeur de l'application`
32	`* */`	33	`* */`
33	`function __construct() {`	34	`function __construct() {`
34	`$this->client = new Client();`	35	`$this->client = new Client();`
35	`$this->_storage = new StorageFile();`	36	`$this->_storage = new StorageFile();`
36	`}`	37	`}`
37		38
38	`/**`	39	`/**`
39	`* Fonction login`	40	`* Fonction login`
40	`*`	41	`*`
41	`* Return true ou false`	42	`* Return true ou false`
42	`* > Ne retourne rien si true car redirige vers l'adresse du serveur OID`	43	`* > Ne retourne rien si true car redirige vers l'adresse du serveur OID`
43	`* */`	44	`* */`
44	`//FIXME : le paramètre immediate ?`	45	`//FIXME : le paramètre immediate ?`
45	`// ATTENTION : ca marche en false mais pas en true !!!`	46	`// A vérifier mais ça doit permettre de passer directement le mot de passe. Il reste plus qu'à trouver le nom de la variable mot de passe.`
46		47
47	`function login($id, $immediate = false) {`	48	`function login($id, $immediate = false) {`
48		49
49	`// FIXME : l'original retourne la fonction checkId, avec le parametre immediate = true`	50	`// L'original retourne la fonction checkId, avec le parametre immediate = true`
-		51	`// Je ne comprends pas l'utilité, je fusionne les deux pour l'instant`
-		52	`// FIXME : si pas de comportement étrange, valider.`
50	`// Je ne comprends pas l'utilité, je fusionne les deux pour l'instant`	53
51		54
52	`//Tests et arrêt si non validé :`	55	`//Tests et arrêt si non validé :`
53	`//Normaliser (traite si XRI ou URL, normalize URL)`	56	`//Normaliser (traite si XRI ou URL, normalize URL)`
54	`//FIXME : voir avec JP pour équivalent dans framework`	57	`//FIXME : voir avec JP pour équivalent dans framework`
55	`if (!$this->normalize($id)) {`	58	`if (!$this->normalize($id)) {`
56	`return false;`	59	`return false;`
57	`}`	60	`}`
58		61
59	`//Discovery`	62	`//Discovery`
60	`// Récupérer les informations sur le serveur OPEN ID`	63	`// Récupérer les informations sur le serveur OPEN ID`
61	`/*`	64	`/*`
62	`FIXME : ca change la valeur de l'id !!!`	65	`FIXME : ca change la valeur de l'id !!!`
63	`if (!$this->_discovery($id, $server, $version)) {`	66	`if (!$this->_discovery($id, $server, $version)) {`
64	`trigger_error('Discovery failed');`	67	`trigger_error('Discovery failed');`
65	`return false;`	68	`return false;`
66	`}*/`	69	`}*/`
67		70
68	`$retour_url = $this->client->consulter($id);`	71	`$retour_url = $this->client->consulter($id);`
69	`//Le retour contient les balises suivantes :`	72	`//Le retour contient les balises suivantes :`
70	`/*`	73	`/*`
71	`*`	74	`*`
72	`* <link rel="openid.server" href="http://www.myopenid.com/server" />`	75	`* <link rel="openid.server" href="http://www.myopenid.com/server" />`
73	`* <link rel="openid2.provider" href="http://www.myopenid.com/server" />`	76	`* <link rel="openid2.provider" href="http://www.myopenid.com/server" />`
74	`*/`	77	`*/`
75	`$metaServeur = $this->verifierVersion($retour_url);`	78	`$metaServeur = $this->verifierVersion($retour_url);`
76		79
77	`//TODO : Voir avec JP : la classe client ne permet pas de vérifer le statut ??`	80	`//TODO : Voir avec JP : la classe client ne permet pas de vérifer le statut ??`
78		81
79	`if ($retour_url === false) {`	82	`if ($retour_url === false) {`
80	`trigger_error('L\'adresse $id est inacessible', E_USER_ERROR);`	83	`trigger_error('L\'adresse $id est inacessible', E_USER_ERROR);`
81	`return false;`	84	`return false;`
82	`}`	85	`}`
83	`if ($metaServeur === false) {`	86	`if ($metaServeur === false) {`
84	`return false;`	87	`return false;`
85	`}`	88	`}`
86	`if (!$this->_associate($metaServeur['serveur'], $metaServeur['version'])) {`	89	`if (!$this->_associate($metaServeur['serveur'], $metaServeur['version'])) {`
87	`trigger_error('Impossible de s\'associer avec le serveur');`	90	`trigger_error('Impossible de s\'associer avec le serveur');`
88	`}`	91	`}`
89		92
90		93
91	`/*TODO : fonctionnement différent`	94	`/*TODO : fonctionnement différent`
92	`if (!$this->_getAssociation(`	95	`if (!$this->_getAssociation(`
93	`$server,`	96	`$server,`
94	`$handle,`	97	`$handle,`
95	`$macFunc,`	98	`$macFunc,`
96	`$secret,`	99	`$secret,`
97	`$expires)) {`	100	`$expires)) {`
98	`/* Use dumb mode *`	101	`/* Use dumb mode *`
99	`unset($handle);`	102	`unset($handle);`
100	`unset($macFunc);`	103	`unset($macFunc);`
101	`unset($secret);`	104	`unset($secret);`
102	`unset($expires);*`	105	`unset($expires);*`
103	`}*/`	106	`}*/`
104		107
105	`//on a la version, l'adresse du serveur et le realId si c'est une 2.0 dans metaServeur`	108	`//on a la version, l'adresse du serveur et le realId si c'est une 2.0 dans metaServeur`
106	`if (isset($metaServeur['realId'])) {`	109	`if (isset($metaServeur['realId'])) {`
107	`$id = $metaServeur['realId'];`	110	`$id = $metaServeur['realId'];`
108	`}`	111	`}`
109		112
110	`//Associate`	113	`//Associate`
111	`//getAssociation`	114	`//getAssociation`
112		115
113	`//Organisation des paramètres :`	116	`//Organisation des paramètres :`
114	`$params = array();`	117	`$params = array();`
115		118
116		119
117	`if ($metaServeur['version'] >= 2.0) {`	120	`if ($metaServeur['version'] >= 2.0) {`
118	`$params['openid.ns'] = self::NS_2_0;`	121	`$params['openid.ns'] = self::NS_2_0;`
119	`}`	122	`}`
120		123
121	`$params['openid.mode'] = $immediate ?`	124	`$params['openid.mode'] = $immediate ?`
122	`'checkid_immediate' : 'checkid_setup';`	125	`'checkid_immediate' : 'checkid_setup';`
123		126
124	`$params['openid.identity'] = $id;`	127	`$params['openid.identity'] = $id;`
125		128
126	`//FIXME : Ex : $params['openid.claimed_id'] = $claimedId; > jvois pas l'intéret`	129	`//FIXME : Ex : $params['openid.claimed_id'] = $claimedId; > jvois pas l'intéret`
127	`$params['openid.claimed_id'] = $id;`	130	`$params['openid.claimed_id'] = $id;`
128	`/*`	131	`/*`
129	`* TODO : gérer les sessions et namespace`	132	`* TODO : gérer les sessions et namespace`
130	`* if ($metaServeur['version'] <= 2.0) {`	133	`* if ($metaServeur['version'] <= 2.0) {`
131	`if ($this->_session !== null) {`	134	`if ($this->_session !== null) {`
132	`$this->_session->identity = $id;`	135	`$this->_session->identity = $id;`
133	`$this->_session->claimed_id = $claimedId;`	136	`$this->_session->claimed_id = $claimedId;`
134	`} else if (defined('SID')) {`	137	`} else if (defined('SID')) {`
135	`$_SESSION["zend_openid"] = array(`	138	`$_SESSION["zend_openid"] = array(`
136	`"identity" => $id,`	139	`"identity" => $id,`
137	`"claimed_id" => $claimedId);`	140	`"claimed_id" => $claimedId);`
138	`} else {`	141	`} else {`
139	`require_once "Zend/Session/Namespace.php";`	142	`require_once "Zend/Session/Namespace.php";`
140	`$this->_session = new Zend_Session_Namespace("zend_openid");`	143	`$this->_session = new Zend_Session_Namespace("zend_openid");`
141	`$this->_session->identity = $id;`	144	`$this->_session->identity = $id;`
142	`$this->_session->claimed_id = $claimedId;`	145	`$this->_session->claimed_id = $claimedId;`
143	`}`	146	`}`
144	`}*/`	147	`}*/`
145		148
146	`if (isset($handle)) {`	149	`if (isset($handle)) {`
147	`$params['openid.assoc_handle'] = $handle;`	150	`$params['openid.assoc_handle'] = $handle;`
148	`}`	151	`}`
149		152
150	`//FIXME : $params['openid.return_to'] = $this->absoluteUrl($returnTo);`	153	`//FIXME : $params['openid.return_to'] = $this->absoluteUrl($returnTo);`
151	`$params['openid.return_to'] = $this->absoluteUrl(null);`	154	`$params['openid.return_to'] = $this->absoluteUrl(null);`
152		155
153	`if (empty($root)) {`	156	`if (empty($root)) {`
154	`$root = $this->selfUrl();`	157	`$root = $this->selfUrl();`
155	`if ($root[strlen($root)-1] != '/') {`	158	`if ($root[strlen($root)-1] != '/') {`
156	`$root = dirname($root);`	159	`$root = dirname($root);`
157	`}`	160	`}`
158	`}`	161	`}`
159	`if ($metaServeur['version'] >= 2.0) {`	162	`if ($metaServeur['version'] >= 2.0) {`
160	`$params['openid.realm'] = $root;`	163	`$params['openid.realm'] = $root;`
161	`} else {`	164	`} else {`
162	`$params['openid.trust_root'] = $root;`	165	`$params['openid.trust_root'] = $root;`
163	`}`	166	`}`
164		167
165	`/*FIXME ::`	168	`/*FIXME ::`
166		169
167	`if (!Zend_OpenId_Extension::forAll($extensions, 'prepareRequest', $params)) {`	170	`if (!Zend_OpenId_Extension::forAll($extensions, 'prepareRequest', $params)) {`
168	`$this->_setError("Extension::prepareRequest failure");`	171	`$this->_setError("Extension::prepareRequest failure");`
169	`return false;`	172	`return false;`
170	`}*/`	173	`}*/`
171		174
172	`$this->redirect($metaServeur['serveur'], $params);`	175	`$this->redirect($metaServeur['serveur'], $params);`
173	`return true;`	176	`return true;`
174	`//Renvoyer vers l'url`	177	`//Renvoyer vers l'url`
175	`}`	178	`}`
176		179
177	`/**`	180	`/**`
178	`* Verifies authentication response from OpenID server.`	181	`* Verifies authentication response from OpenID server.`
179	`*`	182	`*`
180	`* This is the second step of OpenID authentication process.`	183	`* This is the second step of OpenID authentication process.`
181	`* The function returns true on successful authentication and false on`	184	`* The function returns true on successful authentication and false on`
182	`* failure.`	185	`* failure.`
183	`*`	186	`*`
184	`* @param array $params HTTP query data from OpenID server`	187	`* @param array $params HTTP query data from OpenID server`
185	`* @param string &$identity this argument is set to end-user's claimed`	188	`* @param string &$identity this argument is set to end-user's claimed`
186	`* identifier or OpenID provider local identifier.`	189	`* identifier or OpenID provider local identifier.`
187	`* @param mixed $extensions extension object or array of extensions objects`	190	`* @param mixed $extensions extension object or array of extensions objects`
188	`* @return bool`	191	`* @return bool`
189	`*/`	192	`*/`
190	`public function verify($params, &$identity = "", $extensions = null)`	193	`public function verify($params, &$identity = "", $extensions = null)`
191	`{`	194	`{`
192		195
193	`echo '<pre>'.print_r($params, true).'</pre>';`	196	`echo '<pre>'.print_r($params, true).'</pre>';`
194		197
195	`$version = 1.1;`	198	`$version = 1.1;`
196	`if (isset($params['openid_ns']) &&`	199	`if (isset($params['openid_ns']) &&`
197	`$params['openid_ns'] == $this->NS_2_0) {`	200	`$params['openid_ns'] == $this->NS_2_0) {`
198	`$version = 2.0;`	201	`$version = 2.0;`
199	`}`	202	`}`
200		203
201	`if (isset($params["openid_claimed_id"])) {`	204	`if (isset($params["openid_claimed_id"])) {`
202	`$identity = $params["openid_claimed_id"];`	205	`$identity = $params["openid_claimed_id"];`
203	`} else if (isset($params["openid_identity"])){`	206	`} else if (isset($params["openid_identity"])){`
204	`$identity = $params["openid_identity"];`	207	`$identity = $params["openid_identity"];`
205	`} else {`	208	`} else {`
206	`$identity = "";`	209	`$identity = "";`
207	`}`	210	`}`
208		211
209	`if ($version < 2.0 && !isset($params["openid_claimed_id"])) {`	212	`if ($version < 2.0 && !isset($params["openid_claimed_id"])) {`
210	`if ($this->_session !== null) {`	213	`if ($this->_session !== null) {`
211	`if ($this->_session->identity === $identity) {`	214	`if ($this->_session->identity === $identity) {`
212	`$identity = $this->_session->claimed_id;`	215	`$identity = $this->_session->claimed_id;`
213	`}`	216	`}`
214	`} else if (defined('SID')) {`	217	`} else if (defined('SID')) {`
215	`if (isset($_SESSION["zend_openid"]["identity"]) &&`	218	`if (isset($_SESSION["zend_openid"]["identity"]) &&`
216	`isset($_SESSION["zend_openid"]["claimed_id"]) &&`	219	`isset($_SESSION["zend_openid"]["claimed_id"]) &&`
217	`$_SESSION["zend_openid"]["identity"] === $identity) {`	220	`$_SESSION["zend_openid"]["identity"] === $identity) {`
218	`$identity = $_SESSION["zend_openid"]["claimed_id"];`	221	`$identity = $_SESSION["zend_openid"]["claimed_id"];`
219	`}`	222	`}`
220	`} else {`	223	`} else {`
221	`require_once "Zend/Session/Namespace.php";`	224	`require_once "Zend/Session/Namespace.php";`
222	`$this->_session = new Zend_Session_Namespace("zend_openid");`	225	`$this->_session = new Zend_Session_Namespace("zend_openid");`
223	`if ($this->_session->identity === $identity) {`	226	`if ($this->_session->identity === $identity) {`
224	`$identity = $this->_session->claimed_id;`	227	`$identity = $this->_session->claimed_id;`
225	`}`	228	`}`
226	`}`	229	`}`
227	`}`	230	`}`
228		231
229	`if (empty($params['openid_mode'])) {`	232	`if (empty($params['openid_mode'])) {`
230	`$this->_setError("Missing openid.mode");`	233	`$this->_setError("Missing openid.mode");`
231	`return false;`	234	`return false;`
232	`}`	235	`}`
233	`if (empty($params['openid_return_to'])) {`	236	`if (empty($params['openid_return_to'])) {`
234	`$this->_setError("Missing openid.return_to");`	237	`$this->_setError("Missing openid.return_to");`
235	`return false;`	238	`return false;`
236	`}`	239	`}`
237	`if (empty($params['openid_signed'])) {`	240	`if (empty($params['openid_signed'])) {`
238	`$this->_setError("Missing openid.signed");`	241	`$this->_setError("Missing openid.signed");`
239	`return false;`	242	`return false;`
240	`}`	243	`}`
241	`if (empty($params['openid_sig'])) {`	244	`if (empty($params['openid_sig'])) {`
242	`$this->_setError("Missing openid.sig");`	245	`$this->_setError("Missing openid.sig");`
243	`return false;`	246	`return false;`
244	`}`	247	`}`
245	`if ($params['openid_mode'] != 'id_res') {`	248	`if ($params['openid_mode'] != 'id_res') {`
246	`$this->_setError("Wrong openid.mode '".$params['openid_mode']."' != 'id_res'");`	249	`$this->_setError("Wrong openid.mode '".$params['openid_mode']."' != 'id_res'");`
247	`return false;`	250	`return false;`
248	`}`	251	`}`
249	`if (empty($params['openid_assoc_handle'])) {`	252	`if (empty($params['openid_assoc_handle'])) {`
250	`$this->_setError("Missing openid.assoc_handle");`	253	`$this->_setError("Missing openid.assoc_handle");`
251	`return false;`	254	`return false;`
252	`}`	255	`}`
253		256
254	`if ($params['openid_return_to'] != $this->selfUrl()) {`	257	`if ($params['openid_return_to'] != $this->selfUrl()) {`
255	`/* Ignore query part in openid.return_to */`	258	`/* Ignore query part in openid.return_to */`
256	`$pos = strpos($params['openid_return_to'], '?');`	259	`$pos = strpos($params['openid_return_to'], '?');`
257	`if ($pos === false \|\|`	260	`if ($pos === false \|\|`
258	`SUBSTR($params['openid_return_to'], 0 , $pos) != $this->selfUrl()) {`	261	`SUBSTR($params['openid_return_to'], 0 , $pos) != $this->selfUrl()) {`
259		262
260	`/*$this->_setError("Wrong openid.return_to '".`	263	`/*$this->_setError("Wrong openid.return_to '".`
261	`$params['openid_return_to']."' != '" . $this->selfUrl() ."'");*/`	264	`$params['openid_return_to']."' != '" . $this->selfUrl() ."'");*/`
262	`trigger_error('Wrong openid.return_to', E_USER_ERROR);`	265	`trigger_error('Wrong openid.return_to', E_USER_ERROR);`
263		266
264	`return false;`	267	`return false;`
265	`}`	268	`}`
266	`}`	269	`}`
267		270
268	`if ($version >= 2.0) {`	271	`if ($version >= 2.0) {`
269	`if (empty($params['openid_response_nonce'])) {`	272	`if (empty($params['openid_response_nonce'])) {`
270	`trigger_error('Missing openid.response_nonce', E_USER_ERROR);`	273	`trigger_error('Missing openid.response_nonce', E_USER_ERROR);`
271	`return false;`	274	`return false;`
272	`}`	275	`}`
273	`if (empty($params['openid_op_endpoint'])) {`	276	`if (empty($params['openid_op_endpoint'])) {`
274	`trigger_error('Missing openid.op_endpoint', E_USER_ERROR);`	277	`trigger_error('Missing openid.op_endpoint', E_USER_ERROR);`
275	`return false;`	278	`return false;`
276	`/* OpenID 2.0 (11.3) Checking the Nonce */`	279	`/* OpenID 2.0 (11.3) Checking the Nonce */`
277	`} else if (!$this->_storage->isUniqueNonce($params['openid_op_endpoint'], $params['openid_response_nonce'])) {`	280	`} else if (!$this->_storage->isUniqueNonce($params['openid_op_endpoint'], $params['openid_response_nonce'])) {`
278	`trigger_error('Duplicate openid.response_nonce', E_USER_ERROR);`	281	`trigger_error('Duplicate openid.response_nonce', E_USER_ERROR);`
279	`return false;`	282	`return false;`
280	`}`	283	`}`
281	`}`	284	`}`
282		285
283	`if (!empty($params['openid_invalidate_handle'])) {`	286	`if (!empty($params['openid_invalidate_handle'])) {`
284	`if ($this->_storage->getAssociationByHandle(`	287	`if ($this->_storage->getAssociationByHandle(`
285	`$params['openid_invalidate_handle'],`	288	`$params['openid_invalidate_handle'],`
286	`$url,`	289	`$url,`
287	`$macFunc,`	290	`$macFunc,`
288	`$secret,`	291	`$secret,`
289	`$expires)) {`	292	`$expires)) {`
290	`$this->_storage->delAssociation($url);`	293	`$this->_storage->delAssociation($url);`
291	`}`	294	`}`
292	`}`	295	`}`
293		296
294	`if ($this->_storage->getAssociationByHandle(`	297	`if ($this->_storage->getAssociationByHandle(`
295	`$params['openid_assoc_handle'],`	298	`$params['openid_assoc_handle'],`
296	`$url,`	299	`$url,`
297	`$macFunc,`	300	`$macFunc,`
298	`$secret,`	301	`$secret,`
299	`$expires)) {`	302	`$expires)) {`
300	`$signed = explode(',', $params['openid_signed']);`	303	`$signed = explode(',', $params['openid_signed']);`
301	`$data = '';`	304	`$data = '';`
302	`foreach ($signed as $key) {`	305	`foreach ($signed as $key) {`
303	`$data .= $key . ':' . $params['openid_' . strtr($key,'.','_')] . "\n";`	306	`$data .= $key . ':' . $params['openid_' . strtr($key,'.','_')] . "\n";`
304	`}`	307	`}`
305	`if (base64_decode($params['openid_sig']) ==`	308	`if (base64_decode($params['openid_sig']) ==`
306	`Zend_OpenId::hashHmac($macFunc, $data, $secret)) {`	309	`Zend_OpenId::hashHmac($macFunc, $data, $secret)) {`
307	`/*`	310	`/*`
308	`* FIXME dépendance je sais pas pour quoi : a voir :`	311	`* FIXME dépendance je sais pas pour quoi : a voir :`
309	`* if (!Zend_OpenId_Extension::forAll($extensions, 'parseResponse', $params)) {`	312	`* if (!Zend_OpenId_Extension::forAll($extensions, 'parseResponse', $params)) {`
310	`$this->_setError("Extension::parseResponse failure");`	313	`$this->_setError("Extension::parseResponse failure");`
311	`return false;`	314	`return false;`
312	`}*/`	315	`}*/`
313	`/* OpenID 2.0 (11.2) Verifying Discovered Information */`	316	`/* OpenID 2.0 (11.2) Verifying Discovered Information */`
314	`if (isset($params['openid_claimed_id'])) {`	317	`if (isset($params['openid_claimed_id'])) {`
315	`$id = $params['openid_claimed_id'];`	318	`$id = $params['openid_claimed_id'];`
316	`if (!$this->normalize($id)) {`	319	`if (!$this->normalize($id)) {`
317	`$this->_setError("Normalization failed");`	320	`$this->_setError("Normalization failed");`
318	`return false;`	321	`return false;`
319	`} else if (!$this->_discovery($id, $discovered_server, $discovered_version)) {`	322	`} else if (!$this->_discovery($id, $discovered_server, $discovered_version)) {`
320	`$this->_setError("Discovery failed: " . $this->getError());`	323	`$this->_setError("Discovery failed: " . $this->getError());`
321	`return false;`	324	`return false;`
322	`} else if ((!empty($params['openid_identity']) &&`	325	`} else if ((!empty($params['openid_identity']) &&`
323	`$params["openid_identity"] != $id) \|\|`	326	`$params["openid_identity"] != $id) \|\|`
324	`(!empty($params['openid_op_endpoint']) &&`	327	`(!empty($params['openid_op_endpoint']) &&`
325	`$params['openid_op_endpoint'] != $discovered_server) \|\|`	328	`$params['openid_op_endpoint'] != $discovered_server) \|\|`
326	`$discovered_version != $version) {`	329	`$discovered_version != $version) {`
327	`$this->_setError("Discovery information verification failed");`	330	`$this->_setError("Discovery information verification failed");`
328	`return false;`	331	`return false;`
329	`}`	332	`}`
330	`}`	333	`}`
331	`return true;`	334	`return true;`
332	`}`	335	`}`
333	`$this->_storage->delAssociation($url);`	336	`$this->_storage->delAssociation($url);`
334	`$this->_setError("Signature check failed");`	337	`$this->_setError("Signature check failed");`
335	`return false;`	338	`return false;`
336	`}`	339	`}`
337	`else`	340	`else`
338	`{`	341	`{`
339	`/* Use dumb mode */`	342	`/* Use dumb mode */`
340	`if (isset($params['openid_claimed_id'])) {`	343	`if (isset($params['openid_claimed_id'])) {`
341	`$id = $params['openid_claimed_id'];`	344	`$id = $params['openid_claimed_id'];`
342	`} else if (isset($params['openid_identity'])) {`	345	`} else if (isset($params['openid_identity'])) {`
343	`$id = $params['openid_identity'];`	346	`$id = $params['openid_identity'];`
344	`} else {`	347	`} else {`
345	`$this->_setError("Missing openid.claimed_id and openid.identity");`	348	`$this->_setError("Missing openid.claimed_id and openid.identity");`
346	`return false;`	349	`return false;`
347	`}`	350	`}`
348		351
349	`if (!$this->normalize($id)) {`	352	`if (!$this->normalize($id)) {`
350	`trigger_error('Normalization failed', E_USER_ERROR);`	353	`trigger_error('Normalization failed', E_USER_ERROR);`
351	`return false;`	354	`return false;`
352	`} else if (!$this->_discovery($id, $server, $discovered_version)) {`	355	`} else if (!$this->_discovery($id, $server, $discovered_version)) {`
353	`trigger_error('Discovery failed', E_USER_ERROR);`	356	`trigger_error('Discovery failed', E_USER_ERROR);`
354	`return false;`	357	`return false;`
355	`}`	358	`}`
356		359
357	`/* OpenID 2.0 (11.2) Verifying Discovered Information */`	360	`/* OpenID 2.0 (11.2) Verifying Discovered Information */`
358	`if ((isset($params['openid_identity']) &&`	361	`if ((isset($params['openid_identity']) &&`
359	`$params["openid_identity"] != $id) \|\|`	362	`$params["openid_identity"] != $id) \|\|`
360	`(isset($params['openid_op_endpoint']) &&`	363	`(isset($params['openid_op_endpoint']) &&`
361	`$params['openid_op_endpoint'] != $server) \|\|`	364	`$params['openid_op_endpoint'] != $server) \|\|`
362	`$discovered_version != $version) {`	365	`$discovered_version != $version) {`
363	`trigger_error('Discovery information verification failed', E_USER_ERROR);`	366	`trigger_error('Discovery information verification failed', E_USER_ERROR);`
364	`return false;`	367	`return false;`
365	`}`	368	`}`
366		369
367	`$params2 = array();`	370	`$params2 = array();`
368	`foreach ($params as $key => $val) {`	371	`foreach ($params as $key => $val) {`
369	`if (strpos($key, 'openid_ns_') === 0) {`	372	`if (strpos($key, 'openid_ns_') === 0) {`
370	`$key = 'openid.ns.' . substr($key, strlen('openid_ns_'));`	373	`$key = 'openid.ns.' . substr($key, strlen('openid_ns_'));`
371	`} else if (strpos($key, 'openid_sreg_') === 0) {`	374	`} else if (strpos($key, 'openid_sreg_') === 0) {`
372	`$key = 'openid.sreg.' . substr($key, strlen('openid_sreg_'));`	375	`$key = 'openid.sreg.' . substr($key, strlen('openid_sreg_'));`
373	`} else if (strpos($key, 'openid_') === 0) {`	376	`} else if (strpos($key, 'openid_') === 0) {`
374	`$key = 'openid.' . substr($key, strlen('openid_'));`	377	`$key = 'openid.' . substr($key, strlen('openid_'));`
375	`}`	378	`}`
376	`$params2[$key] = $val;`	379	`$params2[$key] = $val;`
377	`}`	380	`}`
378	`$params2['openid.mode'] = 'check_authentication';`	381	`$params2['openid.mode'] = 'check_authentication';`
379	`$ret = $this->client->modifier($serveur, $params2);`	382	`$ret = $this->client->modifier($serveur, $params2);`
380		383
381	`//_httpRequest($server, 'POST', $params2, $status);`	384	`//_httpRequest($server, 'POST', $params2, $status);`
382	`if ($ret === false) {`	385	`if ($ret === false) {`
383	`trigger_error("'Dumb' signature verification HTTP request failed", E_USER_ERROR);`	386	`trigger_error("'Dumb' signature verification HTTP request failed", E_USER_ERROR);`
384	`return false;`	387	`return false;`
385	`}`	388	`}`
386	`$r = array();`	389	`$r = array();`
387	`if (is_string($ret)) {`	390	`if (is_string($ret)) {`
388	`foreach(explode("\n", $ret) as $line) {`	391	`foreach(explode("\n", $ret) as $line) {`
389	`$line = trim($line);`	392	`$line = trim($line);`
390	`if (!empty($line)) {`	393	`if (!empty($line)) {`
391	`$x = explode(':', $line, 2);`	394	`$x = explode(':', $line, 2);`
392	`if (is_array($x) && count($x) == 2) {`	395	`if (is_array($x) && count($x) == 2) {`
393	`list($key, $value) = $x;`	396	`list($key, $value) = $x;`
394	`$r[trim($key)] = trim($value);`	397	`$r[trim($key)] = trim($value);`
395	`}`	398	`}`
396	`}`	399	`}`
397	`}`	400	`}`
398	`}`	401	`}`
399	`$ret = $r;`	402	`$ret = $r;`
400	`if (!empty($ret['invalidate_handle'])) {`	403	`if (!empty($ret['invalidate_handle'])) {`
401	`if ($this->_storage->getAssociationByHandle(`	404	`if ($this->_storage->getAssociationByHandle(`
402	`$ret['invalidate_handle'],`	405	`$ret['invalidate_handle'],`
403	`$url,`	406	`$url,`
404	`$macFunc,`	407	`$macFunc,`
405	`$secret,`	408	`$secret,`
406	`$expires)) {`	409	`$expires)) {`
407	`$this->_storage->delAssociation($url);`	410	`$this->_storage->delAssociation($url);`
408	`}`	411	`}`
409	`}`	412	`}`
410	`if (isset($ret['is_valid']) && $ret['is_valid'] == 'true') {`	413	`if (isset($ret['is_valid']) && $ret['is_valid'] == 'true') {`
411	`if (!Zend_OpenId_Extension::forAll($extensions, 'parseResponse', $params)) {`	414	`if (!Zend_OpenId_Extension::forAll($extensions, 'parseResponse', $params)) {`
412	`$this->_setError("Extension::parseResponse failure");`	415	`$this->_setError("Extension::parseResponse failure");`
413	`return false;`	416	`return false;`
414	`}`	417	`}`
415	`return true;`	418	`return true;`
416	`}`	419	`}`
417	`$this->_setError("'Dumb' signature verification failed");`	420	`$this->_setError("'Dumb' signature verification failed");`
418	`return false;`	421	`return false;`
419	`}`	422	`}`
420	`}`	423	`}`
421		424
422		425
423	`/**`	426	`/**`
424	`* Performs discovery of identity and finds OpenID URL, OpenID server URL`	427	`* Performs discovery of identity and finds OpenID URL, OpenID server URL`
425	`* and OpenID protocol version. Returns true on succees and false on`	428	`* and OpenID protocol version. Returns true on succees and false on`
426	`* failure.`	429	`* failure.`
427	`*`	430	`*`
428	`* @param string &$id OpenID identity URL`	431	`* @param string &$id OpenID identity URL`
429	`* @param string &$server OpenID server URL`	432	`* @param string &$server OpenID server URL`
430	`* @param float &$version OpenID protocol version`	433	`* @param float &$version OpenID protocol version`
431	`* @return bool`	434	`* @return bool`
432	`* @todo OpenID 2.0 (7.3) XRI and Yadis discovery`	435	`* @todo OpenID 2.0 (7.3) XRI and Yadis discovery`
433	`*/`	436	`*/`
434	`protected function _discovery(&$id, &$server, &$version)`	437	`protected function _discovery(&$id, &$server, &$version)`
435	`{`	438	`{`
436	`$realId = $id;`	439	`$realId = $id;`
437	`if ($this->_storage->getDiscoveryInfo(`	440	`if ($this->_storage->getDiscoveryInfo(`
438	`$id,`	441	`$id,`
439	`$realId,`	442	`$realId,`
440	`$server,`	443	`$server,`
441	`$version,`	444	`$version,`
442	`$expire)) {`	445	`$expire)) {`
443	`$id = $realId;`	446	`$id = $realId;`
444	`return true;`	447	`return true;`
445	`}`	448	`}`
446		449
447	`/* TODO: OpenID 2.0 (7.3) XRI and Yadis discovery */`	450	`/* TODO: OpenID 2.0 (7.3) XRI and Yadis discovery */`
448		451
449	`/* HTML-based discovery */`	452	`/* HTML-based discovery */`
450	`$clientDiscovery = new Client();`	453	`$clientDiscovery = new Client();`
451		454
452	`//TODO : rajouter un test sur le statut de la réponse`	455	`//TODO : rajouter un test sur le statut de la réponse`
453	`// Nécessite la prise en compte des entetes dans le framework`	456	`// Nécessite la prise en compte des entetes dans le framework`
454		457
455	`/*if ($status != 200 \|\| !is_string($response)) {`	458	`/*if ($status != 200 \|\| !is_string($response)) {`
456	`return false;`	459	`return false;`
457	`}*/`	460	`}*/`
458	`$reponse = $clientDiscovery->consulter($id);`	461	`$reponse = $clientDiscovery->consulter($id);`
459	`$metaServeur = $this->verifierVersion($reponse);`	462	`$metaServeur = $this->verifierVersion($reponse);`
460	`if (!isset($metaServeur) \|\| empty($reponse)) {`	463	`if (!isset($metaServeur) \|\| empty($reponse)) {`
461	`trigger_error('Aucune donnée OpenId', E_USER_ERROR);`	464	`trigger_error('Aucune donnée OpenId', E_USER_ERROR);`
462	`return false;`	465	`return false;`
463	`}`	466	`}`
464		467
465	`$expire = time() + 60 * 60;`	468	`$expire = time() + 60 * 60;`
466	`$this->_storage->addDiscoveryInfo($id, $metaServeur['realId'], $metaServeur['serveur'], $metaServeur['version'], $expire);`	469	`$this->_storage->addDiscoveryInfo($id, $metaServeur['realId'], $metaServeur['serveur'], $metaServeur['version'], $expire);`
467	`if (!empty($metaServeur['realId'])) {`	470	`if (!empty($metaServeur['realId'])) {`
468	`$id = $metaServeur['realId'];`	471	`$id = $metaServeur['realId'];`
469	`}`	472	`}`
470	`return true;`	473	`return true;`
471	`}`	474	`}`
472		475
473		476
474		477
475		478
476	`//Parser l'HTML de réponse pour trouver la version du serveur OPEN ID`	479	`//Parser l'HTML de réponse pour trouver la version du serveur OPEN ID`
477	`function verifierVersion($reponseHtml) {`	480	`function verifierVersion($reponseHtml) {`
478		481
479	`// TODO : remplacer l'arlgorythme suivant par cette solution :`	482	`// TODO : remplacer l'arlgorythme suivant par cette solution :`
480	`//1. Chercher l'existence d'une balise openidN.provider`	483	`//1. Chercher l'existence d'une balise openidN.provider`
481	`//2. Déterminer la version en fonction de la chaine : openid2.provider => 2.0; openid.provider => 1.1`	484	`//2. Déterminer la version en fonction de la chaine : openid2.provider => 2.0; openid.provider => 1.1`
482	`//3. Récupérer l'url du serveur href="serveur"`	485	`//3. Récupérer l'url du serveur href="serveur"`
483	`//4. SI 2.0, récupérer la valeur réelle de l'ID`	486	`//4. SI 2.0, récupérer la valeur réelle de l'ID`
484		487
485	`//TODO : penser à tester les deux versions du serveur`	488	`//TODO : penser à tester les deux versions du serveur`
486		489
487	`$metaServeur = Array();`	490	`$metaServeur = Array();`
488		491
489	`if (preg_match(`	492	`if (preg_match(`
490	`'/<link[^>]rel=(["\'])[ \t](?:[^ \t"\']+[ \t]+)?openid2.provider[ \t][^"\']\\1[^>]href=(["\'])([^"\']+)\\2[^>]*\/?>/i',`	493	`'/<link[^>]rel=(["\'])[ \t](?:[^ \t"\']+[ \t]+)?openid2.provider[ \t][^"\']\\1[^>]href=(["\'])([^"\']+)\\2[^>]*\/?>/i',`

Subversion Repositories Applications.framework

(root)/trunk/framework/OpenIdClient.php – Rev 260 → 263