Previous Next

Zend_OpenId_Provider

Zend_OpenId_Provider wird verwendet um OpenID Server zu implementieren. Dieses Kapitel bietet sehr grundsätzliche Beispiele für die Implementation eines produktiven OpenID Servers (wie » www.myopenid.com) aber es kann notwendig sein mit viel komplexeren Problemen umzugehen.

Schellstart

Die folgende Identität beinhaltet den Code für das erstellen eines Benutzerzugang indem Zend_OpenId_Provider::register verwendet wird. Das Link-Element mit rel="openid.server" zeigt auf das eigene Serverscript. Wenn diese Identität zu einer OpenID-aktivierten Seite übertragen wird, wird eine Authentifizierung zu diesem Server durchgeführt.

Der Code vor <html> ist nur ein Trick der automatisch den Benutzerzugang erstellt. Man benötigt solchen Code nicht wenn echte Identitäten verwendet werden.

Example #1 Die Identität

hasUser(TEST_ID)) {
    $server->register(TEST_ID, TEST_PASSWORD);
}
?>




Das folgende Identitäts-Serverscript behandelt zwei Arten von Anfragen von OpenID-aktivierten Sites (for Assoziation und Authentifizierung). Beide von Ihnen werden von der gleichen Methode Zend_OpenId_Provider::handle behandelt. Die zwei Argumente für Zend_OpenId_Provider sind die URLs des Logins und der Vertrauten Seite, welche die Interaktion vom End-Benutzer abfragen.

Bei Erfolg gibt die Methode Zend_OpenId_Provider::handle einen String zurück der zur OpenID-aktivierten Seite zurück übergeben werden sollte. Bei einem fehler wird false zurückgegeben - in diesem Beispiel wird eine HTTP 403 Antwort zurückgegeben. Man erhält diese wenn man versucht diese Seite von einem Web-Browser zu öffnen, weil diese eine nicht-OpenID konforme Anfrage sendet.

Example #2 Einfacher Identitäts Provider

$server = new Zend_OpenId_Provider("example-8-login.php",
                                   "example-8-trust.php");
$ret = $server->handle();
if (is_string($ret)) {
    echo $ret;
} else if ($ret !== true) {
    header('HTTP/1.0 403 Forbidden');
    echo 'Verboten';
}

Es ist eine gute Idee eine sichere Verbindung (HTTPS) hierfür zu verwenden und speziell für die folgenden interaktiven Scripts, um den Diebstahl von Passwörtern zu verhindern.

Das folgende Skript implementiert einen Login Schirm für einen Identitäts Server Zend_OpenId_Provider und leitet zu dieser Seite weiter wenn ein benötigter Benutzer sich noch nicht eingeloggt hat. Auf dieser Seite gibt der Benutzer ein Passwort an um sich anzumelden.

Es sollte das Passwort "123" verwendet werden das wärend einer trickreichen Benutzerregistration von einem Identitäts Skript verwendet wurde.

Bei Abschicken, ruft das Skript Zend_OpenId_Provider::login mit der akzeptierten End-Benutzer Identität und dem Passwort auf, und leitet anschließend zum Hauptskript des Identitäts Providers zurück. Bei Erfolg baut Zend_OpenId_Provider::login eine Session zwischen dem End-Benutzer und dem Identitäts-Provider auf und speichert die Informationen über eingeloggte Benutzer. Damit benötigen alle folgenden Anfragen vom gleichen End-Benutzer keine Login-Prozedur (selbst wenn diese von einer anderen OpenID aktivierten Web-Seite kommen).

Es ist zu beachten das die Session nur zwischen den End-Benutzer und dem Identitäts-Provider existiert. OpenID aktivierte Seiten wissen nichts darüber.

Example #3 Einfacher Login Schirm

login($_POST['openid_identifier'],
                   $_POST['openid_password']);
    Zend_OpenId::redirect("example-8.php", $_GET);
}
?>

OpenID Login
Name:
Passwort:
 

Der Fakt das der Benutzer angemeldet ist bedeutet nicht das die Authentifizierung erfolgreich sein muß. Der Benutzer kann entscheiden ob er dem speziellen OpenID aktivierten Seite vertraut oder nicht. Der folgende Vertrauens-Schirm erlaubt dem End-Benutzer diese Wahl zu treffen. Diese Wahl kann nur für die aktuelle Anfrage oder für "immer" gemacht werden. Im letzteren Fall werden Informationen über vertrauenswürdige/nicht vertrauenswürdige Seiten in einer internen Datenbank gespeichert und alle folgenden Authentifizierungs Anfragen von dieser Seite werden automatisch gehandhabt, ohne einer Interaktion des Benutzers.

Example #4 Einfacher Vertrauens Schirm

allowSite($server->getSiteRoot($_GET));
        }
        $server->respondToConsumer($_GET);
    } else if (isset($_POST['deny'])) {
        if (isset($_POST['forever'])) {
            $server->denySite($server->getSiteRoot($_GET));
        }
        Zend_OpenId::redirect($_GET['openid_return_to'],
                              array('openid.mode'=>'cancel'));
    }
}
?>

Eine Seite die sich als getLoggedInUser());?>"> getLoggedInUser());?> Ihre Identitäts URL ist.


Produktive OpenID Server unterstützen normalerweise die einfache Registrierungs Erweiterung die es Benutzern erlaubt nach einigen Informationen über Benutzer vom Provider nachzufragen. In dem Fall wird die Vertraute Seite normalerweise mit der Möglichkeit erweitert benötigte Felder anzugeben oder Benutzerprofile auszuwählen.

Alles zusammen kombinieren

Es ist möglich alle Provider Funktionalitäten in einem Skript zusammen zu kombinieren. In diesem Fall werden Login und Vertraute URLs unterdrückt, und Zend_OpenId_Provider nimmt an das diese auf die gleiche Seite zeigen mit einem zusätzlichen "openid.action" GET Argument.

Das folgende Beispiel ist nicht komplett. Es bietet kein GUI für End-Benutzer wie es sein sollte, aber es führt automatisches Login und Vertrauen durch. Das wird getan um das Beispiel zu vereinfachen, und echte Server müssen Code von den vorherigen Beispielen inkludieren.

Example #5 Alles zusammen

$server = new Zend_OpenId_Provider();

define("TEST_ID", Zend_OpenId::absoluteURL("example-9-id.php"));
define("TEST_PASSWORD", "123");

if ($_SERVER['REQUEST_METHOD'] == 'GET' &&
    isset($_GET['openid_action']) &&
    $_GET['openid_action'] === 'login') {
    $server->login(TEST_ID, TEST_PASSWORD);
    unset($_GET['openid_action']);
    Zend_OpenId::redirect(Zend_OpenId::selfUrl(), $_GET);
} else if ($_SERVER['REQUEST_METHOD'] == 'GET' &&
    isset($_GET['openid_action']) &&
    $_GET['openid_action'] === 'trust') {
    unset($_GET['openid_action']);
    $server->respondToConsumer($_GET);
} else {
    $ret = $server->handle();
    if (is_string($ret)) {
        echo $ret;
    } else if ($ret !== true) {
        header('HTTP/1.0 403 Forbidden');
        echo 'Verboten';
    }
}

Wenn dieses Beispiel mit dem vorherigen Beispiel das in verschiedene Seiten aufgeteilt ist, vergleicht sieht man, zusätzlich zum Dispatch Code, nur einen Unterschied - unset($_GET['openid_action']). Dieses unset ist notwendig um die nächste Anfrage zum Haupthandler zu routen.

Einfache Registrierungs Erweiterung (SREG)

Die folgende Identitäts Seite führt wieder einen Trick aus. Sie erstelt einen neuen Benutzerzugang und assoziiert Ihn mit einem Profil (Spitzname und Passwort). Solche Tricks werden im wirklichen Leben nicht benötigt wo sich End-Benutzer auf OpenID Servern registrieren und Ihre Profile eintragen, aber die Implementierung dieser GUI ist nicht Bestandteil dieses Handbuches.

Example #6 Identität mit Profil

hasUser(TEST_ID)) {
    $server->register(TEST_ID, TEST_PASSWORD);
    $server->login(TEST_ID, TEST_PASSWORD);
    $sreg = new Zend_OpenId_Extension_Sreg(array(
        'nickname' =>'test',
        'email' => 'test@test.com'
    ));
    $root = Zend_OpenId::absoluteURL(".");
    Zend_OpenId::normalizeUrl($root);
    $server->allowSite($root, $sreg);
    $server->logout();
}
?>




Diese Identität sollte der OpenID-aktivierten Seite übergeben werden (verwende das einfache Registrierungs Erweiterung Beispiel aus dem vorherigen Kapitel) und es wird das folgende OpenID Server Skript verwenden.

Es ist eine Variation des vorherigen "Alles zusammen" Beispiels. Es verwendet den gleichen automatischen Login Mechanismus, aber es enthält keinen Code für die Vertrauens-Seite. Der Benutzer vertraut bereits "für immer" im Beispielskript. Dieses Vertrauen wurde von der Zend_OpenId_Provider::alowSite Methode im Identitäts Skript durchgeführt. Die gleiche Methode assoziiert Profile mit der vertrauten Seite und dieses Profil wird automatisch bei einer Anfrage von dieser vertrauten URL zurückgegeben.

Die einzige Sache die notwendig ist um die einfache Registrierungs Erweiterung funktionsfähig zu machen ist die Übergabe eines Objekts von Zend_OpenId_Extension_Sreg als zweites Argument zu Zend_OpenId_Provider::handle.

Example #7 Provider mit SREG

$server = new Zend_OpenId_Provider();
$sreg = new Zend_OpenId_Extension_Sreg();

define("TEST_ID", Zend_OpenId::absoluteURL("example-10-id.php"));
define("TEST_PASSWORD", "123");

if ($_SERVER['REQUEST_METHOD'] == 'GET' &&
    isset($_GET['openid_action']) &&
    $_GET['openid_action'] === 'login') {
    $server->login(TEST_ID, TEST_PASSWORD);
    unset($_GET['openid_action']);
    Zend_OpenId::redirect(Zend_OpenId::selfUrl(), $_GET);
} else if ($_SERVER['REQUEST_METHOD'] == 'GET' &&
    isset($_GET['openid_action']) &&
    $_GET['openid_action'] === 'trust') {
   echo "UNTRUSTED DATA" ;
} else {
    $ret = $server->handle(null, $sreg);
    if (is_string($ret)) {
        echo $ret;
    } else if ($ret !== true) {
        header('HTTP/1.0 403 Forbidden');
        echo 'Verboten';
    }
}

Was noch ?

Das erstellen von OpenID Servern ist eine seltenere Aufgabe als das erstellen von OpenID-aktivierten Sites, weswegen dieses Handbuch nicht versucht alle Zend_OpenId_Provider Features abzudecken wie es für Zend_OpenId_Consumer getan wurde.

Zwei Worte darüber was zusätzlich geboten wird:

  • ein Set von Methoden um End-Benutzer GUI Interfaces zu erstellen die dem Benutzer erlauben sich zu registrieren, und Ihre vertrauten Seiten und Profile zu managen.

  • einen Abstraktions Speicher Layer um Informationen über Benutzer, Ihre Seiten und Profile zu speichern. Es werden auch Assoziationen zwischen Providern und OpenID-aktivierten Seiten gespeichert. Dieser Layer ist ähnlich dem von Zend_OpenId_Consumer. Er verwendet standardmäßg auch den Dateispeicher kann aber mit anderen Implementationen abgeleitet werden.

  • einen Abtraktions Benutzer-Assoziierungs Layer der Web-Browser von End-Benutzern mit eingeloggten Identitäten verknüpfen kann.

Zend_OpenId_Provider versucht nicht alle möglichen Features abzudecken die von OpenID Servern implementiert werden können (wie digitale Zertifikate), kann aber einfach durch Zend_OpenId_Extensions oder durch Erstellung einer Kind-Klasse erweitert werden.

Previous Next
Introduction to Zend Framework
Übersicht
Installation
Zend_Acl
Einführung
Verfeinern der Zugriffskontrolle
Fortgeschrittene Verwendung
Zend_Amf
Einführung
Zend_Amf_Server
Zend_Auth
Einführung
Datenbanktabellen Authentifizierung
Digest Authentication
HTTP Authentication Adapter
LDAP Authentifizierung
Open ID Authentifikation
Zend_Cache
Einführung
Die Theorie des Cachens
Zend_Cache Frontends
Zend_Cache Backends
Zend_Captcha
Einführung
Captcha Anwendung
Captcha Adapter
Zend_Config
Einleitung
Theory of Operation
Zend_Config_Ini
Zend_Config_Xml
Zend_Config_Writer
Zend_Config_Writer
Zend_Console_Getopt
Einführung in Getopt
Definieren von Getopt Regeln
Holen von Optionen und Argumenten
Konfigurieren von Zend_Console_Getopt
Zend_Controller
Zend_Controller Schnellstart
Zend_Controller Grundlagen
Der Front Controller
Das Request Objekt
Der Standard Router
Der Dispatcher
Action Kontroller
Action Helfer
Das Response Objekt
Plugins
Eine konventionelle modulare Verzeichnis Struktur verwenden
MVC Ausnahmen
Migration von vorhergehenden Versionen
Zend_Currency
Einführung in Zend_Currency
Arbeiten mit Währungen
Migration von vorhergehenden Versionen
Zend_Date
Einführung
Theorie der Arbeitsweise
Basis Methoden
Zend_Date API Übersicht
Erstellen von Datumswerten
Konstanten für generelle Datums Funktionen
Funktionierende Beispiele
Zend_Db
Zend_Db_Adapter
Zend_Db_Statement
Zend_Db_Profiler
Zend_Db_Select
Zend_Db_Table
Zend_Db_Table_Row
Zend_Db_Table_Rowset
Zend_Db_Table Relationships
Zend_Debug
Variablen ausgeben
Zend_Dojo
Einführung
Zend_Dojo_Data: dojo.data Envelopes
Dojo View Helfer
Dojo Form Elemente und Dekoratore
Zend_Dom
Einführung
Zend_Dom_Query
Zend_Exception
Verwenden von Ausnahmen
Zend_Feed
Einführung
Feeds importieren
Feeds von Websites abrufen
Einen RSS Feed konsumieren
Einen Atom Feed konsumieren
Einen einzelnen Atom Eintrag konsumieren
Verändern der Feed- und Eintragsstruktur
Eigene Klassen für Feeds und Einträge
Zend_File
Zend_File_Transfer
Prüfungen für Zend_File_Transfer
Filter für Zend_File_Transfer
Migration von vorhergehenden Versionen
Zend_Filter
Einführung
Standard Filter Klassen
Filter Ketten
Filter schreiben
Zend_Filter_Input
Zend_Filter_Inflector
Zend_Form
Zend_Form
Schnellstart mit Zend_Form
Erstellen von Form Elementen mit Hilfe von Zend_Form_Element
Erstellen von Form durch Verwendung von Zend_Form
Erstellen von eigenem Form Markup durch Zend_Form_Decorator
Standard Form Elemente die mit dem With Zend Framework ausgeliefert werden
Standard Form Dekoratore die mit dem Zend Framework ausgeliefert werden
Internationalisierung von Zend_Form
Fortgeschrittene Verwendung von Zend_Form
Zend_Gdata
Einführung zu Gdata
Authentifizierung mit AuthSub
Die Buchsuche Daten API verwenden
Authentifizieren mit ClientLogin
Google Kalender verwenden
Verwenden der Google Dokumente Listen Daten API
Using Google Health
Google Tabellenkalkulation verwenden
Google Apps Provisionierung verwenden
Google Base verwenden
Picasa Web Alben verwenden
Verwenden der YouTube Daten API
Gdata Ausnahmen auffangen
Zend_Http
Zend_Http_Client - Einführung
Zend_Http_Client - Fortgeschrittende Nutzung
Zend_Http_Client - Verbindungsadapter
Zend_Http_Cookie und Zend_Http_CookieJar
Zend_Http_Response
Zend_InfoCard
Einführung
Zend_Json
Einführung
Grundlegende Verwendung
JSON Objects
XML zu JSON Konvertierung
Zend_Json_Server - JSON-RPC server
Zend_Layout
Einführung
Zend_Layout Schnellstart
Zend_Layout Konfigurations Optionen
Erweiterte Verwendung von Zend_Layout
Zend_Ldap
Einleitung
Zend_Loader
Dynamisches Laden von Dateien und Klassen
Plugins laden
Zend_Locale
Einführung
Zend_Locale verwenden
Normalisierung und Lokalisierung
Arbeiten mit Daten und Zeiten
Unterstützte Gebietsschemata
Migrieren von vorhergehenden Versionen
Zend_Log
Übersicht
Writer
Formatter
Filter
Zend_Mail
Einführung
Versand über SMTP
Versand von mehreren E-Mails über eine SMTP Verbindung
Verwendung von unterschiedlichen Versandwegen
HTML E-Mail
Anhänge
Empfänger hinzufügen
Die MIME Abgrenzung kontrollieren
Zusätzliche Kopfzeilen
Zeichensätze
Kodierung
SMTP Authentifizierung
SMTP Übertragungen sichern
Lesen von Mail Nachrichten
Zend_Measure
Einführung
Erstellung einer Maßeinheit
Ausgabe von Maßeinheiten
Manipulation von Maßeinheiten
Arten von Maßeinheiten
Zend_Memory
Übersicht
Memory Manager
Memory Objekte
Zend_Mime
Zend_Mime
Zend_Mime_Message
Zend_Mime_Part
Zend_OpenId
Einführung
Zend_OpenId_Consumer Grundlagen
Zend_OpenId_Provider
Zend_Paginator
Einführung
Verwendung
Konfiguration
Advanced usage
Zend_Pdf
Einführung
Erstellen und Laden von PDF Dokumenten
Änderungen von PDF Dokumenten speichern
Dokument Seiten
Zeichnen
Dokument Informationen und Metadaten
Anwendungsbeispiel für die Zend_Pdf Komponente
Zend_ProgressBar
Zend_ProgressBar
Zend_Registry
Die Registry verwenden
Zend_Rest
Einführung
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Überblick
Indexerstellung
Einen Index durchsuchen
Abfragesprache
Abfrage Erzeugungs API
Zeichensätze
Erweiterbarkeit
Zusammenarbeit Mit Java Lucene
Erweitert
Die besten Anwendungen
Zend_Server
Einführung
Zend_Server_Reflection
Zend_Service
Einführung
Zend_Service_Akismet
Zend_Service_Amazon
Zend_Service_Audioscrobbler
Zend_Service_Delicious
Zend_Service_Flickr
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_Simpy
Einführung
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Mitgelieferte Services
Zend_Service_StrikeIron: Erweiterte Verwendung
Zend_Service_Technorati
Zend_Service_Twitter
Zend_Service_Yahoo
Zend_Session
Einführung
Grundsätzliche Verwendung
Fortgeschrittene Benutzung
Globales Session Management
Zend_Session_SaveHandler_DbTable
Zend_Soap
Zend_Soap_Server
Zend_Soap_Client
WSDL Zugriffsmethoden
AutoDiscovery
Zend_Test
Einführung
Zend_Test_PHPUnit
Zend_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Einführung
Arbeiten mit Zend_TimeSync
Zend_Translate
Einführung
Adapter für Zend_Translate
Benutzen von Übersetzungs Adaptoren
Migration von vorhergehenden Versionen
Zend_Uri
Zend_Uri
Zend_Validate
Einführung
Standard Prüfklassen
Kettenprüfungen
Schreiben von Prüfern
Zend_Version
Auslesen der Version des Zend Frameworks
Zend_View
Einführung
Controller Skripte
View Scripte
View Helfer
Zend_View_Abstract
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Einführung
Zend_XmlRpc_Client
Zend_XmlRpc_Server
Zend Framework Voraussetzungen
PHP Version
PHP Erweiterungen
Zend Framework Komponenten
Zend Framework Abhängigkeiten
Zend Framework Coding Standard für PHP
Übersicht
PHP Dateiformatierung
Namens Konventionen
Code Stil
Zend Framework Performance Guide
Einführung
Laden von Klassen
Internationalisierung (I18n) und Lokalisierung (L10n)
Darstellen der View
Urheberrecht Informationen