OpenId Klassenreferenz

Aufstellung aller Elemente

Öffentliche Methoden

 OpenId ($user='')
 serverOk ()
 login ()
 redirect ()
 getIdentityFromYadis ()
 getIdentityFromHtmlMetaData ()
 getUserFromIdentiy ()
 checkAuthentication ()

Öffentliche Attribute

 $server
 $info
 $identity
 $error
 $user

Ausführliche Beschreibung

Open-Id Authentisierung gemäß OpenId-Spezifikation 1.0.

Definiert in Zeile 8 der Datei OpenId.class.php.

Dokumentation der Elementfunktionen

OpenId::checkAuthentication (  ) 

Open-Id Login, Überprüfen der Anmeldung.
Spezifikation: http://openid.net/specs/openid-authentication-1_1.html
Kapitel "4.4. check_authentication"

Im 2. Schritt (Mode "id_res") erfolgte ein Redirect vom Open-Id Provider an OpenRat zurück.
Wir befinden uns nun im darauf folgenden Request des Browsers.

Es muss noch beim OpenId-Provider die Bestätigung eingeholt werden, danach ist der Benutzer angemeldet.

Definiert in Zeile 257 der Datei OpenId.class.php.

Benutzt $conf, $REQ und Session::get().

00258      {
00259           global $REQ,
00260                  $conf;
00261                  
00262           $this->user      = Session::get('openid_user'    );
00263           $this->server    = Session::get('openid_server'  );
00264           $this->identity  = Session::get('openid_identity');
00265           $openid_handle   = Session::get('openid_handle'  );
00266 
00267           if   ( $REQ['openid_invalidate_handle'] != $openid_handle )
00268           {
00269                $this->error = 'Association-Handle mismatch.';
00270                return false;
00271           }
00272 
00273           if   ( $REQ['openid_identity'] != $this->identity )
00274           {
00275                $this->error ='Open-Id: Identity mismatch. Wrong identity:'.$REQ['openid_identity'];
00276                return false;
00277           }
00278           
00279 
00280           $params = array();
00281           
00282           foreach( $REQ as $request_key=>$request_value )
00283           {
00284                if   ( substr($request_key,0,12)=='openid_sreg_' )
00285                {
00286                     $params['openid.sreg.'.substr($request_key,12) ] = $request_value;              
00287                     $this->info[ substr($request_key,12) ] = $request_value;
00288                }              
00289                elseif    ( substr($request_key,0,7)=='openid_' )
00290                     $params['openid.'.substr($request_key,7) ] = $request_value;               
00291           }
00292           $params['openid.mode'] = 'check_authentication';
00293           
00294           $checkRequest = new Http($this->server);
00295           
00296           $checkRequest->method = 'POST'; // Spezifikation verlangt POST.
00297           $checkRequest->requestParameter = $params;
00298           
00299           if   ( ! $checkRequest->request() )
00300           {
00301                // Der HTTP-Request ging in die Hose.
00302                $this->error = $checkRequest->error;
00303                return false;
00304           }
00305 
00306           // Analyse der HTTP-Antwort, Parsen des BODYs.
00307           // Die Anmeldung ist bestätigt, wenn im BODY die Zeile "is_valid:true" vorhanden ist.
00308           // Siehe Spezifikation Kapitel 4.4.2
00309           $valid = null;
00310           foreach( explode("\n",$checkRequest->body) as $line )
00311           {
00312                $pair = explode(':',trim($line));
00313                if   (count($pair)==2 && strtolower($pair[0])=='is_valid')
00314                     $valid = (strtolower($pair[1])=='true');
00315           }
00316           
00317           if   ( is_null($valid) )
00318           {
00319                // Zeile nicht gefunden.
00320                $this->error = 'Undefined Open-Id response: '.$response;
00321                return false;
00322           }
00323           elseif    ( $valid )
00324           {
00325                // Anmeldung wurde mit "is_valid:true" bestätigt.
00326                return true;
00327           }
00328           else
00329           {
00330                // Bestätigung wurde durch den OpenId-Provider abgelehnt.
00331                $this->error = 'Server refused login.';
00332                return false;
00333           }
00334      }

OpenId::getIdentityFromHtmlMetaData (  ) 

Ermittelt OpenId-Server und OpenId-Identity aus HTML Meta-Tags.

Definiert in Zeile 206 der Datei OpenId.class.php.

Wird benutzt von login().

00207      {
00208           $http = new Http($this->user);
00209 //        $http = new Http();
00210 //        $http->url['host'] = $this->user;
00211           $http->header[] = 'Accept: text/html';
00212 
00213           if   ( ! $http->request() )
00214           {
00215                $this->error = 'Unable to get HTML delegate information';
00216                return false;
00217           }
00218           
00219           $seite = $http->body;
00220           
00221           // Die Meta-Tags mit regulärem Ausdruck auslesen.
00222           $treffer = array();
00223           preg_match('/rel="openid.server"\s+href="(\S+)"/',$seite,$treffer);
00224           if   ( count($treffer) >= 1 )
00225                $this->server = $treffer[1];
00226 
00227           $treffer = array();
00228           preg_match('/rel="openid.delegate"\s+href="(\S+)"/',$seite,$treffer);
00229           if   ( count($treffer) >= 1 )
00230                $this->identity = $treffer[1];
00231      }

OpenId::getIdentityFromYadis (  ) 

Ermittelt OpenId-Server und OpenId-Identity aus Yadis-Dokument.

Rückgabe:
unknown

Definiert in Zeile 170 der Datei OpenId.class.php.

Wird benutzt von login().

00171      {
00172           $http = new Http($this->user);
00173 //        $http->url['host'] = $this->user;
00174 
00175           $http->header[] = 'Accept: application/xrds+xml';
00176           if   ( ! $http->request() )
00177           {
00178                $this->error = 'Unable to get XML delegate information';
00179                return false;
00180           }
00181           
00182 //        Html::debug(htmlentities($http->body));
00183           $p = xml_parser_create();
00184           $ok = xml_parse_into_struct($p, $http->body, $vals, $index);
00185           xml_parser_free($p);
00186 
00187           foreach( $vals as $tag )
00188           {
00189                if   ( strtolower($tag['tag']) == 'uri' )
00190                {
00191                     $this->server = $tag['value'];
00192                }
00193 
00194                if   ( strtolower($tag['tag']) == 'openid:delegate' )
00195                {
00196                     $this->identity = $tag['value'];
00197                }
00198           }
00199      }

OpenId::getUserFromIdentiy (  ) 

Ermittelt den Hostnamen aus der Identity.

Rückgabe:
String

Definiert in Zeile 239 der Datei OpenId.class.php.

00240      {
00241           $http = new Http($this->identity);
00242           return $http->url['host'];
00243      }

OpenId::login (  ) 

Authentisierung Schritt 1.
Ermitteln der Identity.

Rückgabe:
boolean TRUE, wenn Identity ermittelt wurde.

Definiert in Zeile 97 der Datei OpenId.class.php.

Benutzt getIdentityFromHtmlMetaData(), getIdentityFromYadis() und serverOk().

00098      {
00099           // Schritt 1: Identity aus Yadis-Dokument laden.
00100           $this->getIdentityFromYadis();
00101           
00102           // Schritt 2: Fallback auf HTML-Dokument.
00103           if   ( empty($this->server) )
00104           {
00105                $this->getIdentityFromHtmlMetaData();
00106           }
00107           
00108           // Falls immer noch kein Servername gefunden wurde, dann Abbruch.
00109           if   ( empty($this->server) )
00110           {
00111                if   ( empty($this->error) )
00112                     $this->error = 'Unable to locate OpenId-Server in URL';
00113                return false;
00114           }
00115           
00116           if   ( !$this->serverOk() )
00117                return false; // Server nicht vertrauenswürdig.
00118           
00119           if   ( empty($this->identity) )
00120                // Falls die Identity bis hierher nicht deligiert wurde...
00121                // Lt. Spezifikation mit Prefix "http://".
00122                $this->identity = 'http://'.$this->user;
00123           
00124           return true;
00125      }

OpenId::OpenId ( $  user = ''  ) 

Neue Open-Id Anfrage.

Parameter:
String $user
Rückgabe:
OpenId

Definiert in Zeile 53 der Datei OpenId.class.php.

Benutzt $user.

00054      {
00055           $this->user = $user;
00056      }

OpenId::redirect (  ) 

Erzeugt einen HTTP-Redirect auf den OpenId-Provider.

Definiert in Zeile 132 der Datei OpenId.class.php.

Benutzt $conf, $server, Http::getServer(), Session::set() und slashify().

00133      {
00134           global $conf;
00135           
00136           $openid_handle = md5(microtime().session_id());
00137           Session::set('openid_user'    ,$this->user     );
00138           Session::set('openid_server'  ,$this->server   );
00139           Session::set('openid_identity',$this->identity );
00140           Session::set('openid_handle'  ,$openid_handle  );
00141 
00142           $redirHttp = new Http($this->server);
00143           $redirHttp->requestParameter['openid.mode'         ] = 'checkid_setup';
00144           $redirHttp->requestParameter['openid.identity'     ] = $this->identity;
00145 
00146           // Profilangaben anfordern. E-Mail wird benötigt, Name und Sprache sind optional.
00147           $redirHttp->requestParameter['openid.sreg.required'] = 'email';
00148           $redirHttp->requestParameter['openid.sreg.optional'] = 'fullname,language';
00149           
00150           $trustRoot = @$conf['security']['openid']['trust_root'];
00151           $server = Http::getServer();
00152           if   ( empty($trustRoot) )
00153                $trustRoot = $server;
00154                
00155           $redirHttp->requestParameter['openid.trust_root'   ] = slashify($trustRoot);
00156           $redirHttp->requestParameter['openid.return_to'    ] = slashify($server).'openid.'.PHP_EXT;
00157           $redirHttp->requestParameter['openid.assoc_handle' ] = $openid_handle;
00158 
00159           $redirHttp->sendRedirect(); // Browser umleiten.
00160           exit;                       // Ende.
00161      }

OpenId::serverOk (  ) 

Stellt fest, ob der Server vertrauenswürdig ist.

Rückgabe:
true, wenn vertrauenswürdig.

Definiert in Zeile 64 der Datei OpenId.class.php.

Benutzt $conf.

Wird benutzt von login().

00065      {
00066           global $conf;
00067           $servers = $conf['security']['openid']['trusted_server'];
00068           
00069           if   ( empty($servers) )
00070           {
00071                return true;
00072           }
00073           else
00074           {
00075                $serverList = explode(',',$servers);
00076                
00077                $http = new Http($this->server);
00078                if   ( !in_array($http->url['host'],$serverList) )
00079                {
00080                     $this->error = 'Server '.$this->server.' is not trusted';
00081                     return false;
00082                }
00083                else
00084                     return true;
00085           }
00086           
00087      }

Dokumentation der Datenelemente

OpenId::$error

Definiert in Zeile 37 der Datei OpenId.class.php.

OpenId::$identity

Definiert in Zeile 30 der Datei OpenId.class.php.

OpenId::$info

Definiert in Zeile 23 der Datei OpenId.class.php.

OpenId::$server

Definiert in Zeile 15 der Datei OpenId.class.php.

Wird benutzt von redirect().

OpenId::$user

Definiert in Zeile 44 der Datei OpenId.class.php.

Wird benutzt von OpenId().

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:
Erzeugt am Thu May 14 00:55:50 2009 für OpenRat von  doxygen 1.5.8