Auth_OpenID_RAND_SOURCE as null, and
+ * the code will fall back on a pseudo-random number generator.
+ *
+ * @param int $num_bytes The length of the return value
+ * @return string $bytes random bytes
+ */
+ function getBytes($num_bytes)
+ {
+ static $f = null;
+ $bytes = '';
+ if ($f === null) {
+ if (Auth_OpenID_RAND_SOURCE === null) {
+ $f = false;
+ } else {
+ $f = @fopen(Auth_OpenID_RAND_SOURCE, "r");
+ if ($f === false) {
+ $msg = 'Define Auth_OpenID_RAND_SOURCE as null to ' .
+ ' continue with an insecure random number generator.';
+ trigger_error($msg, E_USER_ERROR);
+ }
+ }
+ }
+ if ($f === false) {
+ // pseudorandom used
+ $bytes = '';
+ for ($i = 0; $i < $num_bytes; $i += 4) {
+ $bytes .= pack('L', mt_rand());
+ }
+ $bytes = substr($bytes, 0, $num_bytes);
+ } else {
+ $bytes = fread($f, $num_bytes);
+ }
+ return $bytes;
+ }
+
+ /**
+ * Produce a string of length random bytes, chosen from chrs. If
+ * $chrs is null, the resulting string may contain any characters.
+ *
+ * @param integer $length The length of the resulting
+ * randomly-generated string
+ * @param string $chrs A string of characters from which to choose
+ * to build the new string
+ * @return string $result A string of randomly-chosen characters
+ * from $chrs
+ */
+ function randomString($length, $population = null)
+ {
+ if ($population === null) {
+ return Auth_OpenID_CryptUtil::getBytes($length);
+ }
+
+ $popsize = strlen($population);
+
+ if ($popsize > 256) {
+ $msg = 'More than 256 characters supplied to ' . __FUNCTION__;
+ trigger_error($msg, E_USER_ERROR);
+ }
+
+ $duplicate = 256 % $popsize;
+
+ $str = "";
+ for ($i = 0; $i < $length; $i++) {
+ do {
+ $n = ord(Auth_OpenID_CryptUtil::getBytes(1));
+ } while ($n < $duplicate);
+
+ $n %= $popsize;
+ $str .= $population[$n];
+ }
+
+ return $str;
+ }
+}
+
+?>
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/Auth/OpenID/DatabaseConnection.php b/modules/member/php-openid-1.2.3/Auth/OpenID/DatabaseConnection.php
new file mode 100644
index 000000000..3f4515fa5
--- /dev/null
+++ b/modules/member/php-openid-1.2.3/Auth/OpenID/DatabaseConnection.php
@@ -0,0 +1,131 @@
+
+ * @copyright 2005 Janrain, Inc.
+ * @license http://www.gnu.org/copyleft/lesser.html LGPL
+ */
+
+/**
+ * An empty base class intended to emulate PEAR connection
+ * functionality in applications that supply their own database
+ * abstraction mechanisms. See {@link Auth_OpenID_SQLStore} for more
+ * information. You should subclass this class if you need to create
+ * an SQL store that needs to access its database using an
+ * application's database abstraction layer instead of a PEAR database
+ * connection. Any subclass of Auth_OpenID_DatabaseConnection MUST
+ * adhere to the interface specified here.
+ *
+ * @package OpenID
+ */
+class Auth_OpenID_DatabaseConnection {
+ /**
+ * Sets auto-commit mode on this database connection.
+ *
+ * @param bool $mode True if auto-commit is to be used; false if
+ * not.
+ */
+ function autoCommit($mode)
+ {
+ }
+
+ /**
+ * Run an SQL query with the specified parameters, if any.
+ *
+ * @param string $sql An SQL string with placeholders. The
+ * placeholders are assumed to be specific to the database engine
+ * for this connection.
+ *
+ * @param array $params An array of parameters to insert into the
+ * SQL string using this connection's escaping mechanism.
+ *
+ * @return mixed $result The result of calling this connection's
+ * internal query function. The type of result depends on the
+ * underlying database engine. This method is usually used when
+ * the result of a query is not important, like a DDL query.
+ */
+ function query($sql, $params = array())
+ {
+ }
+
+ /**
+ * Starts a transaction on this connection, if supported.
+ */
+ function begin()
+ {
+ }
+
+ /**
+ * Commits a transaction on this connection, if supported.
+ */
+ function commit()
+ {
+ }
+
+ /**
+ * Performs a rollback on this connection, if supported.
+ */
+ function rollback()
+ {
+ }
+
+ /**
+ * Run an SQL query and return the first column of the first row
+ * of the result set, if any.
+ *
+ * @param string $sql An SQL string with placeholders. The
+ * placeholders are assumed to be specific to the database engine
+ * for this connection.
+ *
+ * @param array $params An array of parameters to insert into the
+ * SQL string using this connection's escaping mechanism.
+ *
+ * @return mixed $result The value of the first column of the
+ * first row of the result set. False if no such result was
+ * found.
+ */
+ function getOne($sql, $params = array())
+ {
+ }
+
+ /**
+ * Run an SQL query and return the first row of the result set, if
+ * any.
+ *
+ * @param string $sql An SQL string with placeholders. The
+ * placeholders are assumed to be specific to the database engine
+ * for this connection.
+ *
+ * @param array $params An array of parameters to insert into the
+ * SQL string using this connection's escaping mechanism.
+ *
+ * @return array $result The first row of the result set, if any,
+ * keyed on column name. False if no such result was found.
+ */
+ function getRow($sql, $params = array())
+ {
+ }
+
+ /**
+ * Run an SQL query with the specified parameters, if any.
+ *
+ * @param string $sql An SQL string with placeholders. The
+ * placeholders are assumed to be specific to the database engine
+ * for this connection.
+ *
+ * @param array $params An array of parameters to insert into the
+ * SQL string using this connection's escaping mechanism.
+ *
+ * @return array $result An array of arrays representing the
+ * result of the query; each array is keyed on column name.
+ */
+ function getAll($sql, $params = array())
+ {
+ }
+}
+
+?>
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/Auth/OpenID/DiffieHellman.php b/modules/member/php-openid-1.2.3/Auth/OpenID/DiffieHellman.php
new file mode 100644
index 000000000..2b845b78b
--- /dev/null
+++ b/modules/member/php-openid-1.2.3/Auth/OpenID/DiffieHellman.php
@@ -0,0 +1,181 @@
+
+ * @copyright 2005 Janrain, Inc.
+ * @license http://www.gnu.org/copyleft/lesser.html LGPL
+ */
+
+require_once 'Auth/OpenID/BigMath.php';
+require_once 'Auth/OpenID/HMACSHA1.php';
+
+function Auth_OpenID_getDefaultMod()
+{
+ return '155172898181473697471232257763715539915724801'.
+ '966915404479707795314057629378541917580651227423'.
+ '698188993727816152646631438561595825688188889951'.
+ '272158842675419950341258706556549803580104870537'.
+ '681476726513255747040765857479291291572334510643'.
+ '245094715007229621094194349783925984760375594985'.
+ '848253359305585439638443';
+}
+
+function Auth_OpenID_getDefaultGen()
+{
+ return '2';
+}
+
+/**
+ * The Diffie-Hellman key exchange class. This class relies on
+ * {@link Auth_OpenID_MathLibrary} to perform large number operations.
+ *
+ * @access private
+ * @package OpenID
+ */
+class Auth_OpenID_DiffieHellman {
+
+ var $mod;
+ var $gen;
+ var $private;
+ var $lib = null;
+
+ function Auth_OpenID_DiffieHellman($mod = null, $gen = null,
+ $private = null, $lib = null)
+ {
+ if ($lib === null) {
+ $this->lib =& Auth_OpenID_getMathLib();
+ } else {
+ $this->lib =& $lib;
+ }
+
+ if ($mod === null) {
+ $this->mod = $this->lib->init(Auth_OpenID_getDefaultMod());
+ } else {
+ $this->mod = $mod;
+ }
+
+ if ($gen === null) {
+ $this->gen = $this->lib->init(Auth_OpenID_getDefaultGen());
+ } else {
+ $this->gen = $gen;
+ }
+
+ if ($private === null) {
+ $r = $this->lib->rand($this->mod);
+ $this->private = $this->lib->add($r, 1);
+ } else {
+ $this->private = $private;
+ }
+
+ $this->public = $this->lib->powmod($this->gen, $this->private,
+ $this->mod);
+ }
+
+ function getSharedSecret($composite)
+ {
+ return $this->lib->powmod($composite, $this->private, $this->mod);
+ }
+
+ function getPublicKey()
+ {
+ return $this->public;
+ }
+
+ /**
+ * Generate the arguments for an OpenID Diffie-Hellman association
+ * request
+ */
+ function getAssocArgs()
+ {
+ $cpub = $this->lib->longToBase64($this->getPublicKey());
+ $args = array(
+ 'openid.dh_consumer_public' => $cpub,
+ 'openid.session_type' => 'DH-SHA1'
+ );
+
+ if ($this->lib->cmp($this->mod, Auth_OpenID_getDefaultMod()) ||
+ $this->lib->cmp($this->gen, Auth_OpenID_getDefaultGen())) {
+ $args['openid.dh_modulus'] = $this->lib->longToBase64($this->mod);
+ $args['openid.dh_gen'] = $this->lib->longToBase64($this->gen);
+ }
+
+ return $args;
+ }
+
+ function usingDefaultValues()
+ {
+ return ($this->mod == Auth_OpenID_getDefaultMod() &&
+ $this->gen == Auth_OpenID_getDefaultGen());
+ }
+
+ /**
+ * Perform the server side of the OpenID Diffie-Hellman association
+ */
+ function serverAssociate($consumer_args, $assoc_secret)
+ {
+ $lib =& Auth_OpenID_getMathLib();
+
+ if (isset($consumer_args['openid.dh_modulus'])) {
+ $mod = $lib->base64ToLong($consumer_args['openid.dh_modulus']);
+ } else {
+ $mod = null;
+ }
+
+ if (isset($consumer_args['openid.dh_gen'])) {
+ $gen = $lib->base64ToLong($consumer_args['openid.dh_gen']);
+ } else {
+ $gen = null;
+ }
+
+ $cpub64 = @$consumer_args['openid.dh_consumer_public'];
+ if (!isset($cpub64)) {
+ return false;
+ }
+
+ $dh = new Auth_OpenID_DiffieHellman($mod, $gen);
+ $cpub = $lib->base64ToLong($cpub64);
+ $mac_key = $dh->xorSecret($cpub, $assoc_secret);
+ $enc_mac_key = base64_encode($mac_key);
+ $spub64 = $lib->longToBase64($dh->getPublicKey());
+
+ $server_args = array(
+ 'session_type' => 'DH-SHA1',
+ 'dh_server_public' => $spub64,
+ 'enc_mac_key' => $enc_mac_key
+ );
+
+ return $server_args;
+ }
+
+ function consumerFinish($reply)
+ {
+ $spub = $this->lib->base64ToLong($reply['dh_server_public']);
+ if ($this->lib->cmp($spub, 0) <= 0) {
+ return false;
+ }
+ $enc_mac_key = base64_decode($reply['enc_mac_key']);
+ return $this->xorSecret($spub, $enc_mac_key);
+ }
+
+ function xorSecret($composite, $secret)
+ {
+ $dh_shared = $this->getSharedSecret($composite);
+ $dh_shared_str = $this->lib->longToBinary($dh_shared);
+ $sha1_dh_shared = Auth_OpenID_SHA1($dh_shared_str);
+
+ $xsecret = "";
+ for ($i = 0; $i < strlen($secret); $i++) {
+ $xsecret .= chr(ord($secret[$i]) ^ ord($sha1_dh_shared[$i]));
+ }
+
+ return $xsecret;
+ }
+}
diff --git a/modules/member/php-openid-1.2.3/Auth/OpenID/Discover.php b/modules/member/php-openid-1.2.3/Auth/OpenID/Discover.php
new file mode 100644
index 000000000..d87d47d16
--- /dev/null
+++ b/modules/member/php-openid-1.2.3/Auth/OpenID/Discover.php
@@ -0,0 +1,258 @@
+identity_url = null;
+ $this->server_url = null;
+ $this->type_uris = array();
+ $this->delegate = null;
+ $this->canonicalID = null;
+ $this->used_yadis = false; // whether this came from an XRDS
+ }
+
+ function usesExtension($extension_uri)
+ {
+ return in_array($extension_uri, $this->type_uris);
+ }
+
+ function parseService($yadis_url, $uri, $type_uris, $service_element)
+ {
+ // Set the state of this object based on the contents of the
+ // service element.
+ $this->type_uris = $type_uris;
+ $this->identity_url = $yadis_url;
+ $this->server_url = $uri;
+ $this->delegate = Auth_OpenID_ServiceEndpoint::findDelegate(
+ $service_element);
+ $this->used_yadis = true;
+ }
+
+ function findDelegate($service)
+ {
+ // Extract a openid:Delegate value from a Yadis Service
+ // element. If no delegate is found, returns null.
+
+ // Try to register new namespace.
+ $service->parser->registerNamespace('openid',
+ 'http://openid.net/xmlns/1.0');
+
+ // XXX: should this die if there is more than one delegate
+ // element?
+ $delegates = $service->getElements("openid:Delegate");
+
+ if ($delegates) {
+ return $service->parser->content($delegates[0]);
+ } else {
+ return null;
+ }
+ }
+
+ function getServerID()
+ {
+ // Return the identifier that should be sent as the
+ // openid.identity_url parameter to the server.
+ if ($this->delegate === null) {
+ if ($this->canonicalID) {
+ return $this->canonicalID;
+ } else {
+ return $this->identity_url;
+ }
+ } else {
+ return $this->delegate;
+ }
+ }
+
+ function fromHTML($uri, $html)
+ {
+ // Parse the given document as HTML looking for an OpenID
+ $urls = Auth_OpenID_legacy_discover($html);
+ if ($urls === false) {
+ return null;
+ }
+
+ list($delegate_url, $server_url) = $urls;
+
+ $service = new Auth_OpenID_ServiceEndpoint();
+ $service->identity_url = $uri;
+ $service->delegate = $delegate_url;
+ $service->server_url = $server_url;
+ $service->type_uris = array(_OPENID_1_0_TYPE);
+ return $service;
+ }
+}
+
+function filter_MatchesAnyOpenIDType(&$service)
+{
+ $uris = $service->getTypes();
+
+ foreach ($uris as $uri) {
+ if (in_array($uri,
+ array(_OPENID_1_0_TYPE,
+ _OPENID_1_1_TYPE,
+ _OPENID_1_2_TYPE))) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+function Auth_OpenID_makeOpenIDEndpoints($uri, $endpoints)
+{
+ $s = array();
+
+ if (!$endpoints) {
+ return $s;
+ }
+
+ foreach ($endpoints as $service) {
+ $type_uris = $service->getTypes();
+ $uris = $service->getURIs();
+
+ // If any Type URIs match and there is an endpoint URI
+ // specified, then this is an OpenID endpoint
+ if ($type_uris &&
+ $uris) {
+
+ foreach ($uris as $service_uri) {
+ $openid_endpoint = new Auth_OpenID_ServiceEndpoint();
+ $openid_endpoint->parseService($uri,
+ $service_uri,
+ $type_uris,
+ $service);
+
+ $s[] = $openid_endpoint;
+ }
+ }
+ }
+
+ return $s;
+}
+
+function Auth_OpenID_discoverWithYadis($uri, &$fetcher)
+{
+ // Discover OpenID services for a URI. Tries Yadis and falls back
+ // on old-style discovery if Yadis fails.
+
+ // Might raise a yadis.discover.DiscoveryFailure if no document
+ // came back for that URI at all. I don't think falling back to
+ // OpenID 1.0 discovery on the same URL will help, so don't bother
+ // to catch it.
+ $openid_services = array();
+
+ $http_response = null;
+ $response = Services_Yadis_Yadis::discover($uri, $http_response,
+ $fetcher);
+
+ if ($response) {
+ $identity_url = $response->uri;
+ $openid_services =
+ $response->xrds->services(array('filter_MatchesAnyOpenIDType'));
+ }
+
+ if (!$openid_services) {
+ return @Auth_OpenID_discoverWithoutYadis($uri,
+ $fetcher);
+ }
+
+ if (!$openid_services) {
+ $body = $response->body;
+
+ // Try to parse the response as HTML to get OpenID 1.0/1.1
+ //
+ $service = Auth_OpenID_ServiceEndpoint::fromHTML($identity_url,
+ $body);
+
+ if ($service !== null) {
+ $openid_services = array($service);
+ }
+ } else {
+ $openid_services = Auth_OpenID_makeOpenIDEndpoints($response->uri,
+ $openid_services);
+ }
+
+ return array($identity_url, $openid_services, $http_response);
+}
+
+function _Auth_OpenID_discoverServiceList($uri, &$fetcher)
+{
+ list($url, $services, $resp) = Auth_OpenID_discoverWithYadis($uri,
+ $fetcher);
+
+ return $services;
+}
+
+function _Auth_OpenID_discoverXRIServiceList($uri, &$fetcher)
+{
+ list($url, $services, $resp) = _Auth_OpenID_discoverXRI($uri,
+ $fetcher);
+ return $services;
+}
+
+function Auth_OpenID_discoverWithoutYadis($uri, &$fetcher)
+{
+ $http_resp = @$fetcher->get($uri);
+
+ if ($http_resp->status != 200) {
+ return array(null, array(), $http_resp);
+ }
+
+ $identity_url = $http_resp->final_url;
+
+ // Try to parse the response as HTML to get OpenID 1.0/1.1
+ $endpoint =& new Auth_OpenID_ServiceEndpoint();
+ $service = $endpoint->fromHTML($identity_url, $http_resp->body);
+ if ($service === null) {
+ $openid_services = array();
+ } else {
+ $openid_services = array($service);
+ }
+
+ return array($identity_url, $openid_services, $http_resp);
+}
+
+function _Auth_OpenID_discoverXRI($iname, &$fetcher)
+{
+ $services = new Services_Yadis_ProxyResolver($fetcher);
+ list($canonicalID, $service_list) = $services->query($iname,
+ array(_OPENID_1_0_TYPE,
+ _OPENID_1_1_TYPE,
+ _OPENID_1_2_TYPE),
+ array('filter_MatchesAnyOpenIDType'));
+
+ $endpoints = Auth_OpenID_makeOpenIDEndpoints($iname, $service_list);
+
+ for ($i = 0; $i < count($endpoints); $i++) {
+ $endpoints[$i]->canonicalID = $canonicalID;
+ }
+
+ // FIXME: returned xri should probably be in some normal form
+ return array($iname, $endpoints, null);
+}
+
+function Auth_OpenID_discover($uri, &$fetcher)
+{
+ return @Auth_OpenID_discoverWithYadis($uri, $fetcher);
+}
+
+?>
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/Auth/OpenID/DumbStore.php b/modules/member/php-openid-1.2.3/Auth/OpenID/DumbStore.php
new file mode 100644
index 000000000..d4d8a8b42
--- /dev/null
+++ b/modules/member/php-openid-1.2.3/Auth/OpenID/DumbStore.php
@@ -0,0 +1,116 @@
+
+ * @copyright 2005 Janrain, Inc.
+ * @license http://www.gnu.org/copyleft/lesser.html LGPL
+ */
+
+/**
+ * Import the interface for creating a new store class.
+ */
+require_once 'Auth/OpenID/Interface.php';
+require_once 'Auth/OpenID/HMACSHA1.php';
+
+/**
+ * This is a store for use in the worst case, when you have no way of
+ * saving state on the consumer site. Using this store makes the
+ * consumer vulnerable to replay attacks, as it's unable to use
+ * nonces. Avoid using this store if it is at all possible.
+ *
+ * Most of the methods of this class are implementation details.
+ * Users of this class need to worry only about the constructor.
+ *
+ * @package OpenID
+ */
+class Auth_OpenID_DumbStore extends Auth_OpenID_OpenIDStore {
+
+ /**
+ * Creates a new {@link Auth_OpenID_DumbStore} instance. For the security
+ * of the tokens generated by the library, this class attempts to
+ * at least have a secure implementation of getAuthKey.
+ *
+ * When you create an instance of this class, pass in a secret
+ * phrase. The phrase is hashed with sha1 to make it the correct
+ * length and form for an auth key. That allows you to use a long
+ * string as the secret phrase, which means you can make it very
+ * difficult to guess.
+ *
+ * Each {@link Auth_OpenID_DumbStore} instance that is created for use by
+ * your consumer site needs to use the same $secret_phrase.
+ *
+ * @param string secret_phrase The phrase used to create the auth
+ * key returned by getAuthKey
+ */
+ function Auth_OpenID_DumbStore($secret_phrase)
+ {
+ $this->auth_key = Auth_OpenID_SHA1($secret_phrase);
+ }
+
+ /**
+ * This implementation does nothing.
+ */
+ function storeAssociation($server_url, $association)
+ {
+ }
+
+ /**
+ * This implementation always returns null.
+ */
+ function getAssociation($server_url, $handle = null)
+ {
+ return null;
+ }
+
+ /**
+ * This implementation always returns false.
+ */
+ function removeAssociation($server_url, $handle)
+ {
+ return false;
+ }
+
+ /**
+ * This implementation does nothing.
+ */
+ function storeNonce($nonce)
+ {
+ }
+
+ /**
+ * In a system truly limited to dumb mode, nonces must all be
+ * accepted. This therefore always returns true, which makes
+ * replay attacks feasible.
+ */
+ function useNonce($nonce)
+ {
+ return true;
+ }
+
+ /**
+ * This method returns the auth key generated by the constructor.
+ */
+ function getAuthKey()
+ {
+ return $this->auth_key;
+ }
+
+ /**
+ * This store is a dumb mode store, so this method is overridden
+ * to return true.
+ */
+ function isDumb()
+ {
+ return true;
+ }
+}
+
+?>
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/Auth/OpenID/FileStore.php b/modules/member/php-openid-1.2.3/Auth/OpenID/FileStore.php
new file mode 100644
index 000000000..6ce88568e
--- /dev/null
+++ b/modules/member/php-openid-1.2.3/Auth/OpenID/FileStore.php
@@ -0,0 +1,674 @@
+
+ * @copyright 2005 Janrain, Inc.
+ * @license http://www.gnu.org/copyleft/lesser.html LGPL
+ *
+ */
+
+/**
+ * Require base class for creating a new interface.
+ */
+require_once 'Auth/OpenID.php';
+require_once 'Auth/OpenID/Interface.php';
+require_once 'Auth/OpenID/HMACSHA1.php';
+
+/**
+ * This is a filesystem-based store for OpenID associations and
+ * nonces. This store should be safe for use in concurrent systems on
+ * both windows and unix (excluding NFS filesystems). There are a
+ * couple race conditions in the system, but those failure cases have
+ * been set up in such a way that the worst-case behavior is someone
+ * having to try to log in a second time.
+ *
+ * Most of the methods of this class are implementation details.
+ * People wishing to just use this store need only pay attention to
+ * the constructor.
+ *
+ * @package OpenID
+ */
+class Auth_OpenID_FileStore extends Auth_OpenID_OpenIDStore {
+
+ /**
+ * Initializes a new {@link Auth_OpenID_FileStore}. This
+ * initializes the nonce and association directories, which are
+ * subdirectories of the directory passed in.
+ *
+ * @param string $directory This is the directory to put the store
+ * directories in.
+ */
+ function Auth_OpenID_FileStore($directory)
+ {
+ if (!Auth_OpenID::ensureDir($directory)) {
+ trigger_error('Not a directory and failed to create: '
+ . $directory, E_USER_ERROR);
+ }
+ $directory = realpath($directory);
+
+ $this->directory = $directory;
+ $this->active = true;
+
+ $this->nonce_dir = $directory . DIRECTORY_SEPARATOR . 'nonces';
+
+ $this->association_dir = $directory . DIRECTORY_SEPARATOR .
+ 'associations';
+
+ // Temp dir must be on the same filesystem as the assciations
+ // $directory and the $directory containing the auth key file.
+ $this->temp_dir = $directory . DIRECTORY_SEPARATOR . 'temp';
+
+ $this->auth_key_name = $directory . DIRECTORY_SEPARATOR . 'auth_key';
+
+ $this->max_nonce_age = 6 * 60 * 60; // Six hours, in seconds
+
+ if (!$this->_setup()) {
+ trigger_error('Failed to initialize OpenID file store in ' .
+ $directory, E_USER_ERROR);
+ }
+ }
+
+ function destroy()
+ {
+ Auth_OpenID_FileStore::_rmtree($this->directory);
+ $this->active = false;
+ }
+
+ /**
+ * Make sure that the directories in which we store our data
+ * exist.
+ *
+ * @access private
+ */
+ function _setup()
+ {
+ return (Auth_OpenID::ensureDir(dirname($this->auth_key_name)) &&
+ Auth_OpenID::ensureDir($this->nonce_dir) &&
+ Auth_OpenID::ensureDir($this->association_dir) &&
+ Auth_OpenID::ensureDir($this->temp_dir));
+ }
+
+ /**
+ * Create a temporary file on the same filesystem as
+ * $this->auth_key_name and $this->association_dir.
+ *
+ * The temporary directory should not be cleaned if there are any
+ * processes using the store. If there is no active process using
+ * the store, it is safe to remove all of the files in the
+ * temporary directory.
+ *
+ * @return array ($fd, $filename)
+ * @access private
+ */
+ function _mktemp()
+ {
+ $name = Auth_OpenID_FileStore::_mkstemp($dir = $this->temp_dir);
+ $file_obj = @fopen($name, 'wb');
+ if ($file_obj !== false) {
+ return array($file_obj, $name);
+ } else {
+ Auth_OpenID_FileStore::_removeIfPresent($name);
+ }
+ }
+
+ /**
+ * Read the auth key from the auth key file. Will return None if
+ * there is currently no key.
+ *
+ * @return mixed
+ */
+ function readAuthKey()
+ {
+ if (!$this->active) {
+ trigger_error("FileStore no longer active", E_USER_ERROR);
+ return null;
+ }
+
+ $auth_key_file = @fopen($this->auth_key_name, 'rb');
+ if ($auth_key_file === false) {
+ return null;
+ }
+
+ $key = fread($auth_key_file, filesize($this->auth_key_name));
+ fclose($auth_key_file);
+
+ return $key;
+ }
+
+ /**
+ * Generate a new random auth key and safely store it in the
+ * location specified by $this->auth_key_name.
+ *
+ * @return string $key
+ */
+ function createAuthKey()
+ {
+ if (!$this->active) {
+ trigger_error("FileStore no longer active", E_USER_ERROR);
+ return null;
+ }
+
+ $auth_key = Auth_OpenID_CryptUtil::randomString($this->AUTH_KEY_LEN);
+
+ list($file_obj, $tmp) = $this->_mktemp();
+
+ fwrite($file_obj, $auth_key);
+ fflush($file_obj);
+ fclose($file_obj);
+
+ if (function_exists('link')) {
+ // Posix filesystem
+ $saved = link($tmp, $this->auth_key_name);
+ Auth_OpenID_FileStore::_removeIfPresent($tmp);
+ } else {
+ // Windows filesystem
+ $saved = rename($tmp, $this->auth_key_name);
+ }
+
+ if (!$saved) {
+ // The link failed, either because we lack the permission,
+ // or because the file already exists; try to read the key
+ // in case the file already existed.
+ $auth_key = $this->readAuthKey();
+ }
+
+ return $auth_key;
+ }
+
+ /**
+ * Retrieve the auth key from the file specified by
+ * $this->auth_key_name, creating it if it does not exist.
+ *
+ * @return string $key
+ */
+ function getAuthKey()
+ {
+ if (!$this->active) {
+ trigger_error("FileStore no longer active", E_USER_ERROR);
+ return null;
+ }
+
+ $auth_key = $this->readAuthKey();
+ if ($auth_key === null) {
+ $auth_key = $this->createAuthKey();
+
+ if (strlen($auth_key) != $this->AUTH_KEY_LEN) {
+ $fmt = 'Got an invalid auth key from %s. Expected '.
+ '%d-byte string. Got: %s';
+ $msg = sprintf($fmt, $this->auth_key_name, $this->AUTH_KEY_LEN,
+ $auth_key);
+ trigger_error($msg, E_USER_WARNING);
+ return null;
+ }
+ }
+ return $auth_key;
+ }
+
+ /**
+ * Create a unique filename for a given server url and
+ * handle. This implementation does not assume anything about the
+ * format of the handle. The filename that is returned will
+ * contain the domain name from the server URL for ease of human
+ * inspection of the data directory.
+ *
+ * @return string $filename
+ */
+ function getAssociationFilename($server_url, $handle)
+ {
+ if (!$this->active) {
+ trigger_error("FileStore no longer active", E_USER_ERROR);
+ return null;
+ }
+
+ if (strpos($server_url, '://') === false) {
+ trigger_error(sprintf("Bad server URL: %s", $server_url),
+ E_USER_WARNING);
+ return null;
+ }
+
+ list($proto, $rest) = explode('://', $server_url, 2);
+ $parts = explode('/', $rest);
+ $domain = Auth_OpenID_FileStore::_filenameEscape($parts[0]);
+ $url_hash = Auth_OpenID_FileStore::_safe64($server_url);
+ if ($handle) {
+ $handle_hash = Auth_OpenID_FileStore::_safe64($handle);
+ } else {
+ $handle_hash = '';
+ }
+
+ $filename = sprintf('%s-%s-%s-%s', $proto, $domain, $url_hash,
+ $handle_hash);
+
+ return $this->association_dir. DIRECTORY_SEPARATOR . $filename;
+ }
+
+ /**
+ * Store an association in the association directory.
+ */
+ function storeAssociation($server_url, $association)
+ {
+ if (!$this->active) {
+ trigger_error("FileStore no longer active", E_USER_ERROR);
+ return false;
+ }
+
+ $association_s = $association->serialize();
+ $filename = $this->getAssociationFilename($server_url,
+ $association->handle);
+ list($tmp_file, $tmp) = $this->_mktemp();
+
+ if (!$tmp_file) {
+ trigger_error("_mktemp didn't return a valid file descriptor",
+ E_USER_WARNING);
+ return false;
+ }
+
+ fwrite($tmp_file, $association_s);
+
+ fflush($tmp_file);
+
+ fclose($tmp_file);
+
+ if (@rename($tmp, $filename)) {
+ return true;
+ } else {
+ // In case we are running on Windows, try unlinking the
+ // file in case it exists.
+ @unlink($filename);
+
+ // Now the target should not exist. Try renaming again,
+ // giving up if it fails.
+ if (@rename($tmp, $filename)) {
+ return true;
+ }
+ }
+
+ // If there was an error, don't leave the temporary file
+ // around.
+ Auth_OpenID_FileStore::_removeIfPresent($tmp);
+ return false;
+ }
+
+ /**
+ * Retrieve an association. If no handle is specified, return the
+ * association with the most recent issue time.
+ *
+ * @return mixed $association
+ */
+ function getAssociation($server_url, $handle = null)
+ {
+ if (!$this->active) {
+ trigger_error("FileStore no longer active", E_USER_ERROR);
+ return null;
+ }
+
+ if ($handle === null) {
+ $handle = '';
+ }
+
+ // The filename with the empty handle is a prefix of all other
+ // associations for the given server URL.
+ $filename = $this->getAssociationFilename($server_url, $handle);
+
+ if ($handle) {
+ return $this->_getAssociation($filename);
+ } else {
+ $association_files =
+ Auth_OpenID_FileStore::_listdir($this->association_dir);
+ $matching_files = array();
+
+ // strip off the path to do the comparison
+ $name = basename($filename);
+ foreach ($association_files as $association_file) {
+ if (strpos($association_file, $name) === 0) {
+ $matching_files[] = $association_file;
+ }
+ }
+
+ $matching_associations = array();
+ // read the matching files and sort by time issued
+ foreach ($matching_files as $name) {
+ $full_name = $this->association_dir . DIRECTORY_SEPARATOR .
+ $name;
+ $association = $this->_getAssociation($full_name);
+ if ($association !== null) {
+ $matching_associations[] = array($association->issued,
+ $association);
+ }
+ }
+
+ $issued = array();
+ $assocs = array();
+ foreach ($matching_associations as $key => $assoc) {
+ $issued[$key] = $assoc[0];
+ $assocs[$key] = $assoc[1];
+ }
+
+ array_multisort($issued, SORT_DESC, $assocs, SORT_DESC,
+ $matching_associations);
+
+ // return the most recently issued one.
+ if ($matching_associations) {
+ list($issued, $assoc) = $matching_associations[0];
+ return $assoc;
+ } else {
+ return null;
+ }
+ }
+ }
+
+ /**
+ * @access private
+ */
+ function _getAssociation($filename)
+ {
+ if (!$this->active) {
+ trigger_error("FileStore no longer active", E_USER_ERROR);
+ return null;
+ }
+
+ $assoc_file = @fopen($filename, 'rb');
+
+ if ($assoc_file === false) {
+ return null;
+ }
+
+ $assoc_s = fread($assoc_file, filesize($filename));
+ fclose($assoc_file);
+
+ if (!$assoc_s) {
+ return null;
+ }
+
+ $association =
+ Auth_OpenID_Association::deserialize('Auth_OpenID_Association',
+ $assoc_s);
+
+ if (!$association) {
+ Auth_OpenID_FileStore::_removeIfPresent($filename);
+ return null;
+ }
+
+ if ($association->getExpiresIn() == 0) {
+ Auth_OpenID_FileStore::_removeIfPresent($filename);
+ return null;
+ } else {
+ return $association;
+ }
+ }
+
+ /**
+ * Remove an association if it exists. Do nothing if it does not.
+ *
+ * @return bool $success
+ */
+ function removeAssociation($server_url, $handle)
+ {
+ if (!$this->active) {
+ trigger_error("FileStore no longer active", E_USER_ERROR);
+ return null;
+ }
+
+ $assoc = $this->getAssociation($server_url, $handle);
+ if ($assoc === null) {
+ return false;
+ } else {
+ $filename = $this->getAssociationFilename($server_url, $handle);
+ return Auth_OpenID_FileStore::_removeIfPresent($filename);
+ }
+ }
+
+ /**
+ * Mark this nonce as present.
+ */
+ function storeNonce($nonce)
+ {
+ if (!$this->active) {
+ trigger_error("FileStore no longer active", E_USER_ERROR);
+ return null;
+ }
+
+ $filename = $this->nonce_dir . DIRECTORY_SEPARATOR . $nonce;
+ $nonce_file = fopen($filename, 'w');
+ if ($nonce_file === false) {
+ return false;
+ }
+ fclose($nonce_file);
+ return true;
+ }
+
+ /**
+ * Return whether this nonce is present. As a side effect, mark it
+ * as no longer present.
+ *
+ * @return bool $present
+ */
+ function useNonce($nonce)
+ {
+ if (!$this->active) {
+ trigger_error("FileStore no longer active", E_USER_ERROR);
+ return null;
+ }
+
+ $filename = $this->nonce_dir . DIRECTORY_SEPARATOR . $nonce;
+ $st = @stat($filename);
+
+ if ($st === false) {
+ return false;
+ }
+
+ // Either it is too old or we are using it. Either way, we
+ // must remove the file.
+ if (!unlink($filename)) {
+ return false;
+ }
+
+ $now = time();
+ $nonce_age = $now - $st[9];
+
+ // We can us it if the age of the file is less than the
+ // expiration time.
+ return $nonce_age <= $this->max_nonce_age;
+ }
+
+ /**
+ * Remove expired entries from the database. This is potentially
+ * expensive, so only run when it is acceptable to take time.
+ */
+ function clean()
+ {
+ if (!$this->active) {
+ trigger_error("FileStore no longer active", E_USER_ERROR);
+ return null;
+ }
+
+ $nonces = Auth_OpenID_FileStore::_listdir($this->nonce_dir);
+ $now = time();
+
+ // Check all nonces for expiry
+ foreach ($nonces as $nonce) {
+ $filename = $this->nonce_dir . DIRECTORY_SEPARATOR . $nonce;
+ $st = @stat($filename);
+
+ if ($st !== false) {
+ // Remove the nonce if it has expired
+ $nonce_age = $now - $st[9];
+ if ($nonce_age > $this->max_nonce_age) {
+ Auth_OpenID_FileStore::_removeIfPresent($filename);
+ }
+ }
+ }
+
+ $association_filenames =
+ Auth_OpenID_FileStore::_listdir($this->association_dir);
+
+ foreach ($association_filenames as $association_filename) {
+ $association_file = fopen($association_filename, 'rb');
+
+ if ($association_file !== false) {
+ $assoc_s = fread($association_file,
+ filesize($association_filename));
+ fclose($association_file);
+
+ // Remove expired or corrupted associations
+ $association =
+ Auth_OpenID_Association::deserialize(
+ 'Auth_OpenID_Association', $assoc_s);
+
+ if ($association === null) {
+ Auth_OpenID_FileStore::_removeIfPresent(
+ $association_filename);
+ } else {
+ if ($association->getExpiresIn() == 0) {
+ Auth_OpenID_FileStore::_removeIfPresent(
+ $association_filename);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * @access private
+ */
+ function _rmtree($dir)
+ {
+ if ($dir[strlen($dir) - 1] != DIRECTORY_SEPARATOR) {
+ $dir .= DIRECTORY_SEPARATOR;
+ }
+
+ if ($handle = opendir($dir)) {
+ while ($item = readdir($handle)) {
+ if (!in_array($item, array('.', '..'))) {
+ if (is_dir($dir . $item)) {
+
+ if (!Auth_OpenID_FileStore::_rmtree($dir . $item)) {
+ return false;
+ }
+ } else if (is_file($dir . $item)) {
+ if (!unlink($dir . $item)) {
+ return false;
+ }
+ }
+ }
+ }
+
+ closedir($handle);
+
+ if (!@rmdir($dir)) {
+ return false;
+ }
+
+ return true;
+ } else {
+ // Couldn't open directory.
+ return false;
+ }
+ }
+
+ /**
+ * @access private
+ */
+ function _mkstemp($dir)
+ {
+ foreach (range(0, 4) as $i) {
+ $name = tempnam($dir, "php_openid_filestore_");
+
+ if ($name !== false) {
+ return $name;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * @access private
+ */
+ function _mkdtemp($dir)
+ {
+ foreach (range(0, 4) as $i) {
+ $name = $dir . strval(DIRECTORY_SEPARATOR) . strval(getmypid()) .
+ "-" . strval(rand(1, time()));
+ if (!mkdir($name, 0700)) {
+ return false;
+ } else {
+ return $name;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * @access private
+ */
+ function _listdir($dir)
+ {
+ $handle = opendir($dir);
+ $files = array();
+ while (false !== ($filename = readdir($handle))) {
+ $files[] = $filename;
+ }
+ return $files;
+ }
+
+ /**
+ * @access private
+ */
+ function _isFilenameSafe($char)
+ {
+ $_Auth_OpenID_filename_allowed = Auth_OpenID_letters .
+ Auth_OpenID_digits . ".";
+ return (strpos($_Auth_OpenID_filename_allowed, $char) !== false);
+ }
+
+ /**
+ * @access private
+ */
+ function _safe64($str)
+ {
+ $h64 = base64_encode(Auth_OpenID_SHA1($str));
+ $h64 = str_replace('+', '_', $h64);
+ $h64 = str_replace('/', '.', $h64);
+ $h64 = str_replace('=', '', $h64);
+ return $h64;
+ }
+
+ /**
+ * @access private
+ */
+ function _filenameEscape($str)
+ {
+ $filename = "";
+ for ($i = 0; $i < strlen($str); $i++) {
+ $c = $str[$i];
+ if (Auth_OpenID_FileStore::_isFilenameSafe($c)) {
+ $filename .= $c;
+ } else {
+ $filename .= sprintf("_%02X", ord($c));
+ }
+ }
+ return $filename;
+ }
+
+ /**
+ * Attempt to remove a file, returning whether the file existed at
+ * the time of the call.
+ *
+ * @access private
+ * @return bool $result True if the file was present, false if not.
+ */
+ function _removeIfPresent($filename)
+ {
+ return @unlink($filename);
+ }
+}
+
+?>
diff --git a/modules/member/php-openid-1.2.3/Auth/OpenID/HMACSHA1.php b/modules/member/php-openid-1.2.3/Auth/OpenID/HMACSHA1.php
new file mode 100644
index 000000000..6daadb5f8
--- /dev/null
+++ b/modules/member/php-openid-1.2.3/Auth/OpenID/HMACSHA1.php
@@ -0,0 +1,72 @@
+
+ * @copyright 2005 Janrain, Inc.
+ * @license http://www.gnu.org/copyleft/lesser.html LGPL
+ */
+
+/**
+ * SHA1_BLOCKSIZE is this module's SHA1 blocksize used by the fallback
+ * implementation.
+ */
+define('Auth_OpenID_SHA1_BLOCKSIZE', 64);
+
+if (!function_exists('sha1')) {
+ /**
+ * Return a raw SHA1 hash of the given string
+ *
+ * XXX: include the SHA1 code from Dan Libby's OpenID library
+ */
+ function Auth_OpenID_SHA1($text)
+ {
+ trigger_error('No SHA1 function found', E_USER_ERROR);
+ }
+} else {
+ /**
+ * @ignore
+ */
+ function Auth_OpenID_SHA1($text)
+ {
+ $hex = sha1($text);
+ $raw = '';
+ for ($i = 0; $i < 40; $i += 2) {
+ $hexcode = substr($hex, $i, 2);
+ $charcode = (int)base_convert($hexcode, 16, 10);
+ $raw .= chr($charcode);
+ }
+ return $raw;
+ }
+}
+
+/**
+ * Compute an HMAC/SHA1 hash.
+ *
+ * @access private
+ * @param string $key The HMAC key
+ * @param string $text The message text to hash
+ * @return string $mac The MAC
+ */
+function Auth_OpenID_HMACSHA1($key, $text)
+{
+ if (strlen($key) > Auth_OpenID_SHA1_BLOCKSIZE) {
+ $key = Auth_OpenID_SHA1($key, true);
+ }
+
+ $key = str_pad($key, Auth_OpenID_SHA1_BLOCKSIZE, chr(0x00));
+ $ipad = str_repeat(chr(0x36), Auth_OpenID_SHA1_BLOCKSIZE);
+ $opad = str_repeat(chr(0x5c), Auth_OpenID_SHA1_BLOCKSIZE);
+ $hash1 = Auth_OpenID_SHA1(($key ^ $ipad) . $text, true);
+ $hmac = Auth_OpenID_SHA1(($key ^ $opad) . $hash1, true);
+ return $hmac;
+}
+
+?>
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/Auth/OpenID/Interface.php b/modules/member/php-openid-1.2.3/Auth/OpenID/Interface.php
new file mode 100644
index 000000000..ce9fa1feb
--- /dev/null
+++ b/modules/member/php-openid-1.2.3/Auth/OpenID/Interface.php
@@ -0,0 +1,188 @@
+
+ * @copyright 2005 Janrain, Inc.
+ * @license http://www.gnu.org/copyleft/lesser.html LGPL
+ */
+
+/**
+ * This is the interface for the store objects the OpenID library
+ * uses. It is a single class that provides all of the persistence
+ * mechanisms that the OpenID library needs, for both servers and
+ * consumers. If you want to create an SQL-driven store, please see
+ * then {@link Auth_OpenID_SQLStore} class.
+ *
+ * @package OpenID
+ * @author JanRain, Inc. Blah blah blah blah blah blah blah
+ + + +header +Status: 200 OK +Content-Type: text/html +YADIS_HEADER: URL_BASE/xrds + + + +Blah blah blah blah blah blah blah
+ + +xrds +Status: 200 OK +Content-Type: application/xrds+xml + +Blah blah blah blah blah blah blah
+ + +404_server_response +Status: 404 Not Found + +EEk! + +500_server_response +Status: 500 Server error + +EEk! + +201_server_response +Status: 201 Created + +EEk! + +404_with_header +Status: 404 Not Found +YADIS_HEADER: URL_BASE/xrds + +EEk! + +404_with_meta +Status: 404 Not Found +Content-Type: text/html + + + + +Blah blah blah blah blah blah blah
+ + diff --git a/modules/member/php-openid-1.2.3/Tests/Services/Yadis/data/test1-parsehtml.txt b/modules/member/php-openid-1.2.3/Tests/Services/Yadis/data/test1-parsehtml.txt new file mode 100644 index 000000000..b005c253c --- /dev/null +++ b/modules/member/php-openid-1.2.3/Tests/Services/Yadis/data/test1-parsehtml.txt @@ -0,0 +1,133 @@ +found + + + +found + + + +found + + + +found + + + +found + + + +found + + + +found + + + + + +& + + + +found + + + + + + + +found + + + + + + + +/ + + + + + + + + + + + +EOF + + +None + + + +There's really nothing interesting about this
+ + + +EOF + + + +EOF + + + +None + + + +None + + + +None + + + +None + + + + + + + +None + + + +This is my blog
+An error that indicates that a response was already signed.
++ Located in /Auth/OpenID/Server.php (line 1193) +
+ + +Auth_OpenID_EncodingError + | + --Auth_OpenID_AlreadySigned+ +
Inherited From Auth_OpenID_EncodingError
++ Auth_OpenID_EncodingError::Auth_OpenID_EncodingError()+ +
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+This class represents an association between a server and a consumer. In general, users of this library will never see instances of this object. The only exception is if you implement a custom Auth_OpenID_OpenIDStore.
+If you do implement such a store, it will need to store the values of the handle, secret, issued, lifetime, and assoc_type instance variables.
++ Located in /Auth/OpenID/Association.php (line 39) +
+ + + + +Parse an association as stored by serialize(). This is the inverse of serialize.
+ + + + +This checks to see if two Auth_OpenID_Association instances represent the same association.
+ + +This returns the number of seconds this association is still valid for, or 0 if the association is no longer valid.
+ + +Convert an association to KV form.
+ + ++ Documentation generated on Mon, 10 Sep 2007 13:29:27 -0700 by phpDocumentor 1.3.2 +
+This class represents an authentication request from a consumer to an OpenID server.
++ Located in /Auth/OpenID/Consumer.php (line 934) +
+ + + + +Initialize an authentication request with the specified token, association, and endpoint.
+Users of this library should not create instances of this class. Instances of this class are created by the library when needed.
+ +Add an extension argument to this OpenID authentication request.
+Use caution when adding arguments, because they will be URL-escaped and appended to the redirect URL, which can easily get quite long.
+ +Compute the appropriate redirection URL for this request based on a specified trust root and return-to.
+ + ++ Documentation generated on Mon, 10 Sep 2007 13:29:27 -0700 by phpDocumentor 1.3.2 +
+A response with a status of Auth_OpenID_CANCEL. Indicates that the user cancelled the OpenID authentication request. This has two relevant attributes:
+identity_url - The identity URL for which authentication was attempted, if it can be determined. Otherwise, null.
status - Auth_OpenID_SUCCESS.
++ Located in /Auth/OpenID/Consumer.php (line 1147) +
+ + +Auth_OpenID_ConsumerResponse + | + --Auth_OpenID_CancelResponse+ +
+ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
+An OpenID consumer implementation that performs discovery and does session management. See the Consumer.php file documentation for more information.
++ Located in /Auth/OpenID/Consumer.php (line 222) +
+ + + + +Initialize a Consumer instance.
+You should create a new instance of the Consumer object with every HTTP request that handles OpenID transactions.
+ +Start the OpenID authentication process. See steps 1-2 in the overview at the top of this file.
+ + + + +Start OpenID verification without doing OpenID server
+discovery. This method is used internally by Consumer.begin after discovery is performed, and exists to provide an interface for library users needing to perform their own discovery.
+ + + + +Called to interpret the server's response to an OpenID request. It is called in step 4 of the flow described in the consumer overview.
+ + + + ++ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
+The base class for responses from the Auth_OpenID_Consumer.
++ Located in /Auth/OpenID/Consumer.php (line 1022) +
+ + + + +| Class | +Description | +
|---|---|
| Auth_OpenID_SuccessResponse | ++ A response with a status of Auth_OpenID_SUCCESS. Indicates that + | +
| Auth_OpenID_FailureResponse | ++ A response with a status of Auth_OpenID_FAILURE. Indicates that the OpenID protocol has failed. This could be locally or remotely triggered. This has three relevant attributes: + | +
| Auth_OpenID_CancelResponse | ++ A response with a status of Auth_OpenID_CANCEL. Indicates that the user cancelled the OpenID authentication request. This has two relevant attributes: + | +
| Auth_OpenID_SetupNeededResponse | ++ A response with a status of Auth_OpenID_SETUP_NEEDED. Indicates that the request was in immediate mode, and the server is unable to authenticate the user without further interaction. + | +
+ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
+An empty base class intended to emulate PEAR connection
+functionality in applications that supply their own database abstraction mechanisms. See Auth_OpenID_SQLStore for more information. You should subclass this class if you need to create an SQL store that needs to access its database using an application's database abstraction layer instead of a PEAR database connection. Any subclass of Auth_OpenID_DatabaseConnection MUST adhere to the interface specified here.
++ Located in /Auth/OpenID/DatabaseConnection.php (line 25) +
+ + + + +Sets auto-commit mode on this database connection.
+ +Starts a transaction on this connection, if supported.
+ +Commits a transaction on this connection, if supported.
+ +Run an SQL query with the specified parameters, if any.
+ + +Run an SQL query and return the first column of the first row of the result set, if any.
+ + +Run an SQL query and return the first row of the result set, if any.
+ + +Run an SQL query with the specified parameters, if any.
+ + +Performs a rollback on this connection, if supported.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
+Decode an incoming Auth_OpenID_WebResponse into an Auth_OpenID_Request.
++ Located in /Auth/OpenID/Server.php (line 1114) +
+ + + + +Given an HTTP query in an array (key-value pairs), decode it into an Auth_OpenID_Request object.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
++ Located in /Auth/OpenID/Consumer.php (line 403) +
+ + + + ++ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
++ Located in /Auth/OpenID/Server.php (line 391) +
+ + + + ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+This is a store for use in the worst case, when you have no way of saving state on the consumer site. Using this store makes the consumer vulnerable to replay attacks, as it's unable to use nonces. Avoid using this store if it is at all possible.
+Most of the methods of this class are implementation details. Users of this class need to worry only about the constructor.
+ ++ Located in /Auth/OpenID/DumbStore.php (line 34) +
+ + +Auth_OpenID_OpenIDStore + | + --Auth_OpenID_DumbStore+ +
Inherited from Auth_OpenID_OpenIDStore
++ + Auth_OpenID_OpenIDStore::$AUTH_KEY_LEN+ +
+ +
Creates a new Auth_OpenID_DumbStore instance. For the security of the tokens generated by the library, this class attempts to at least have a secure implementation of getAuthKey.
+When you create an instance of this class, pass in a secret phrase. The phrase is hashed with sha1 to make it the correct length and form for an auth key. That allows you to use a long string as the secret phrase, which means you can make it very difficult to guess.
Each Auth_OpenID_DumbStore instance that is created for use by your consumer site needs to use the same $secret_phrase.
+ +This implementation always returns null.
+ +This method returns the auth key generated by the constructor.
+ +This store is a dumb mode store, so this method is overridden to return true.
+ +This implementation always returns false.
+ +This implementation does nothing.
+ +This implementation does nothing.
+ +In a system truly limited to dumb mode, nonces must all be accepted. This therefore always returns true, which makes replay attacks feasible.
+ +Inherited From Auth_OpenID_OpenIDStore
++ Auth_OpenID_OpenIDStore::getAssociation()+ +
+ Auth_OpenID_OpenIDStore::getAuthKey()
+ Auth_OpenID_OpenIDStore::isDumb()
+ Auth_OpenID_OpenIDStore::removeAssociation()
+ Auth_OpenID_OpenIDStore::reset()
+ Auth_OpenID_OpenIDStore::storeAssociation()
+ Auth_OpenID_OpenIDStore::storeNonce()
+ Auth_OpenID_OpenIDStore::useNonce()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
+Encode an Auth_OpenID_Response to an Auth_OpenID_WebResponse.
++ Located in /Auth/OpenID/Server.php (line 1028) +
+ + + + +| Class | +Description | +
|---|---|
| Auth_OpenID_SigningEncoder | ++ An encoder which also takes care of signing fields when required. + | +
Encode an Auth_OpenID_Response and return an Auth_OpenID_WebResponse.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+An error that indicates an encoding problem occurred.
++ Located in /Auth/OpenID/Server.php (line 1181) +
+ + + + +| Class | +Description | +
|---|---|
| Auth_OpenID_AlreadySigned | ++ An error that indicates that a response was already signed. + | +
+ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+A response with a status of Auth_OpenID_FAILURE. Indicates that the OpenID protocol has failed. This could be locally or remotely triggered. This has three relevant attributes:
+identity_url - The identity URL for which authentication was attempted, if it can be determined. Otherwise, null.
message - A message indicating why the request failed, if one is supplied. Otherwise, null.
status - Auth_OpenID_FAILURE.
++ Located in /Auth/OpenID/Consumer.php (line 1120) +
+ + +Auth_OpenID_ConsumerResponse + | + --Auth_OpenID_FailureResponse+ +
+ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
+This is a filesystem-based store for OpenID associations and
+nonces. This store should be safe for use in concurrent systems on both windows and unix (excluding NFS filesystems). There are a couple race conditions in the system, but those failure cases have been set up in such a way that the worst-case behavior is someone having to try to log in a second time.
Most of the methods of this class are implementation details. People wishing to just use this store need only pay attention to the constructor.
+ ++ Located in /Auth/OpenID/FileStore.php (line 39) +
+ + +Auth_OpenID_OpenIDStore + | + --Auth_OpenID_FileStore+ +
Inherited from Auth_OpenID_OpenIDStore
++ + Auth_OpenID_OpenIDStore::$AUTH_KEY_LEN+ +
+ +
Initializes a new Auth_OpenID_FileStore. This initializes the nonce and association directories, which are subdirectories of the directory passed in.
+ +Remove expired entries from the database. This is potentially expensive, so only run when it is acceptable to take time.
+ +Generate a new random auth key and safely store it in the location specified by $this->auth_key_name.
+ +Retrieve an association. If no handle is specified, return the association with the most recent issue time.
+ +Create a unique filename for a given server url and
+handle. This implementation does not assume anything about the format of the handle. The filename that is returned will contain the domain name from the server URL for ease of human inspection of the data directory.
+ +Retrieve the auth key from the file specified by $this->auth_key_name, creating it if it does not exist.
+ +Read the auth key from the auth key file. Will return None if there is currently no key.
+ +Remove an association if it exists. Do nothing if it does not.
+ +Store an association in the association directory.
+ +Mark this nonce as present.
+ +Return whether this nonce is present. As a side effect, mark it as no longer present.
+ +Inherited From Auth_OpenID_OpenIDStore
++ Auth_OpenID_OpenIDStore::getAssociation()+ +
+ Auth_OpenID_OpenIDStore::getAuthKey()
+ Auth_OpenID_OpenIDStore::isDumb()
+ Auth_OpenID_OpenIDStore::removeAssociation()
+ Auth_OpenID_OpenIDStore::reset()
+ Auth_OpenID_OpenIDStore::storeAssociation()
+ Auth_OpenID_OpenIDStore::storeNonce()
+ Auth_OpenID_OpenIDStore::useNonce()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
+An error indicating that the return_to URL is malformed.
++ Located in /Auth/OpenID/Server.php (line 249) +
+ + +Auth_OpenID_ServerError + | + --Auth_OpenID_MalformedReturnURL+ +
Inherited From Auth_OpenID_ServerError
++ Auth_OpenID_ServerError::encodeToKVForm()+ +
+ Auth_OpenID_ServerError::encodeToURL()
+ Auth_OpenID_ServerError::hasReturnTo()
+ Auth_OpenID_ServerError::toString()
+ Auth_OpenID_ServerError::whichEncoding()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+This error is returned when the trust_root value is malformed.
++ Located in /Auth/OpenID/Server.php (line 262) +
+ + +Auth_OpenID_ServerError + | + --Auth_OpenID_MalformedTrustRoot+ +
Inherited From Auth_OpenID_ServerError
++ Auth_OpenID_ServerError::encodeToKVForm()+ +
+ Auth_OpenID_ServerError::encodeToURL()
+ Auth_OpenID_ServerError::hasReturnTo()
+ Auth_OpenID_ServerError::toString()
+ Auth_OpenID_ServerError::whichEncoding()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+An SQL store that uses MySQL as its backend.
+ ++ Located in /Auth/OpenID/MySQLStore.php (line 19) +
+ + +Auth_OpenID_OpenIDStore + | + --Auth_OpenID_SQLStore + | + --Auth_OpenID_MySQLStore+ +
Inherited from Auth_OpenID_OpenIDStore
++ + Auth_OpenID_OpenIDStore::$AUTH_KEY_LEN+ +
+ +
Inherited From Auth_OpenID_SQLStore
++ Auth_OpenID_SQLStore::Auth_OpenID_SQLStore()+ +
+ Auth_OpenID_SQLStore::blobDecode()
+ Auth_OpenID_SQLStore::blobEncode()
+ Auth_OpenID_SQLStore::createTables()
+ Auth_OpenID_SQLStore::create_assoc_table()
+ Auth_OpenID_SQLStore::create_nonce_table()
+ Auth_OpenID_SQLStore::create_settings_table()
+ Auth_OpenID_SQLStore::getAssociation()
+ Auth_OpenID_SQLStore::getAuthKey()
+ Auth_OpenID_SQLStore::isError()
+ Auth_OpenID_SQLStore::removeAssociation()
+ Auth_OpenID_SQLStore::reset()
+ Auth_OpenID_SQLStore::resultToBool()
+ Auth_OpenID_SQLStore::setSQL()
+ Auth_OpenID_SQLStore::storeAssociation()
+ Auth_OpenID_SQLStore::tableExists()
+ Auth_OpenID_SQLStore::useNonce()
+
Inherited From Auth_OpenID_OpenIDStore
++ Auth_OpenID_OpenIDStore::getAssociation()+ +
+ Auth_OpenID_OpenIDStore::getAuthKey()
+ Auth_OpenID_OpenIDStore::isDumb()
+ Auth_OpenID_OpenIDStore::removeAssociation()
+ Auth_OpenID_OpenIDStore::reset()
+ Auth_OpenID_OpenIDStore::storeAssociation()
+ Auth_OpenID_OpenIDStore::storeNonce()
+ Auth_OpenID_OpenIDStore::useNonce()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+This is the interface for the store objects the OpenID library
+uses. It is a single class that provides all of the persistence mechanisms that the OpenID library needs, for both servers and consumers. If you want to create an SQL-driven store, please see then Auth_OpenID_SQLStore class.
+ ++ Located in /Auth/OpenID/Interface.php (line 26) +
+ + + + +| Class | +Description | +
|---|---|
| Auth_OpenID_DumbStore | ++ This is a store for use in the worst case, when you have no way of saving state on the consumer site. Using this store makes the consumer vulnerable to replay attacks, as it's unable to use nonces. Avoid using this store if it is at all possible. + | +
| Auth_OpenID_FileStore | ++ This is a filesystem-based store for OpenID associations and + | +
| Auth_OpenID_SQLStore | ++ This is the parent class for the SQL stores, which contains the logic common to all of the SQL stores. + | +
This method returns an Association object from storage that matches the server URL and, if specified, handle. It returns null if no such association is found or if the matching association is expired.
+If no handle is specified, the store may return any association which matches the server URL. If multiple associations are valid, the recommended return value for this method is the one that will remain valid for the longest duration.
This method is allowed (and encouraged) to garbage collect expired associations when found. This method must not return expired associations.
+ + +This method returns a key used to sign the tokens, to ensure that they haven't been tampered with in transit. It should return the same key every time it is called. The key returned should be AUTH_KEY_LEN bytes long.
+ + +This method must return true if the store is a dumb-mode-style store. Unlike all other methods in this class, this one provides a default implementation, which returns false.
+In general, any custom subclass of Auth_OpenID_OpenIDStore won't override this method, as custom subclasses are only likely to be created when the store is fully functional.
+ + +This method removes the matching association if it's found, and returns whether the association was removed or not.
+ + +Removes all entries from the store; implementation is optional.
+ +This method puts an Association object into storage, retrievable by server URL and handle.
+ +Stores a nonce. This is used by the consumer to prevent replay attacks.
+ +This method is called when the library is attempting to use a nonce. If the nonce is in the store, this method removes it and returns a value which evaluates as true. Otherwise it returns a value which evaluates as false.
+This method is allowed and encouraged to treat nonces older than some period (a very conservative window would be 6 hours, for example) as no longer existing, and return False and remove them.
+ + ++ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
++ Located in /Auth/OpenID/Consumer.php (line 452) +
+ + + + ++ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
++ Located in /Auth/OpenID/Server.php (line 373) +
+ + + + ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+An SQL store that uses PostgreSQL as its backend.
+ ++ Located in /Auth/OpenID/PostgreSQLStore.php (line 19) +
+ + +Auth_OpenID_OpenIDStore + | + --Auth_OpenID_SQLStore + | + --Auth_OpenID_PostgreSQLStore+ +
Inherited from Auth_OpenID_OpenIDStore
++ + Auth_OpenID_OpenIDStore::$AUTH_KEY_LEN+ +
+ +
Inherited From Auth_OpenID_SQLStore
++ Auth_OpenID_SQLStore::Auth_OpenID_SQLStore()+ +
+ Auth_OpenID_SQLStore::blobDecode()
+ Auth_OpenID_SQLStore::blobEncode()
+ Auth_OpenID_SQLStore::createTables()
+ Auth_OpenID_SQLStore::create_assoc_table()
+ Auth_OpenID_SQLStore::create_nonce_table()
+ Auth_OpenID_SQLStore::create_settings_table()
+ Auth_OpenID_SQLStore::getAssociation()
+ Auth_OpenID_SQLStore::getAuthKey()
+ Auth_OpenID_SQLStore::isError()
+ Auth_OpenID_SQLStore::removeAssociation()
+ Auth_OpenID_SQLStore::reset()
+ Auth_OpenID_SQLStore::resultToBool()
+ Auth_OpenID_SQLStore::setSQL()
+ Auth_OpenID_SQLStore::storeAssociation()
+ Auth_OpenID_SQLStore::tableExists()
+ Auth_OpenID_SQLStore::useNonce()
+
Inherited From Auth_OpenID_OpenIDStore
++ Auth_OpenID_OpenIDStore::getAssociation()+ +
+ Auth_OpenID_OpenIDStore::getAuthKey()
+ Auth_OpenID_OpenIDStore::isDumb()
+ Auth_OpenID_OpenIDStore::removeAssociation()
+ Auth_OpenID_OpenIDStore::reset()
+ Auth_OpenID_OpenIDStore::storeAssociation()
+ Auth_OpenID_OpenIDStore::storeNonce()
+ Auth_OpenID_OpenIDStore::useNonce()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+This is the parent class for the SQL stores, which contains the logic common to all of the SQL stores.
+The table names used are determined by the class variables settings_table_name, associations_table_name, and nonces_table_name. To change the name of the tables used, pass new table names into the constructor.
To create the tables with the proper schema, see the createTables method.
This class shouldn't be used directly. Use one of its subclasses instead, as those contain the code necessary to use a specific database. If you're an OpenID integrator and you'd like to create an SQL-driven store that wraps an application's database abstraction, be sure to create a subclass of Auth_OpenID_DatabaseConnection that calls the application's database abstraction calls. Then, pass an instance of your new database connection class to your SQLStore subclass constructor.
All methods other than the constructor and createTables should be considered implementation details.
+ ++ Located in /Auth/OpenID/SQLStore.php (line 57) +
+ + +Auth_OpenID_OpenIDStore + | + --Auth_OpenID_SQLStore+ +
| Class | +Description | +
|---|---|
| Auth_OpenID_SQLiteStore | ++ An SQL store that uses SQLite as its backend. + | +
| Auth_OpenID_PostgreSQLStore | ++ An SQL store that uses PostgreSQL as its backend. + | +
| Auth_OpenID_MySQLStore | ++ An SQL store that uses MySQL as its backend. + | +
Inherited from Auth_OpenID_OpenIDStore
++ + Auth_OpenID_OpenIDStore::$AUTH_KEY_LEN+ +
+ +
This creates a new SQLStore instance. It requires an established database connection be given to it, and it allows overriding the default table names.
+ +Returns true if $value constitutes a database error; returns false otherwise.
+ +Resets the store by removing all records from the store's tables.
+ +Converts a query result to a boolean. If the result is a database error according to $this->isError(), this returns false; otherwise, this returns true.
+ +This method should be overridden by subclasses. This method is called by the constructor to set values in $this->sql, which is an array keyed on sql name.
+ +Inherited From Auth_OpenID_OpenIDStore
++ Auth_OpenID_OpenIDStore::getAssociation()+ +
+ Auth_OpenID_OpenIDStore::getAuthKey()
+ Auth_OpenID_OpenIDStore::isDumb()
+ Auth_OpenID_OpenIDStore::removeAssociation()
+ Auth_OpenID_OpenIDStore::reset()
+ Auth_OpenID_OpenIDStore::storeAssociation()
+ Auth_OpenID_OpenIDStore::storeNonce()
+ Auth_OpenID_OpenIDStore::useNonce()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+An SQL store that uses SQLite as its backend.
+ ++ Located in /Auth/OpenID/SQLiteStore.php (line 19) +
+ + +Auth_OpenID_OpenIDStore + | + --Auth_OpenID_SQLStore + | + --Auth_OpenID_SQLiteStore+ +
Inherited from Auth_OpenID_OpenIDStore
++ + Auth_OpenID_OpenIDStore::$AUTH_KEY_LEN+ +
+ +
Inherited From Auth_OpenID_SQLStore
++ Auth_OpenID_SQLStore::Auth_OpenID_SQLStore()+ +
+ Auth_OpenID_SQLStore::blobDecode()
+ Auth_OpenID_SQLStore::blobEncode()
+ Auth_OpenID_SQLStore::createTables()
+ Auth_OpenID_SQLStore::create_assoc_table()
+ Auth_OpenID_SQLStore::create_nonce_table()
+ Auth_OpenID_SQLStore::create_settings_table()
+ Auth_OpenID_SQLStore::getAssociation()
+ Auth_OpenID_SQLStore::getAuthKey()
+ Auth_OpenID_SQLStore::isError()
+ Auth_OpenID_SQLStore::removeAssociation()
+ Auth_OpenID_SQLStore::reset()
+ Auth_OpenID_SQLStore::resultToBool()
+ Auth_OpenID_SQLStore::setSQL()
+ Auth_OpenID_SQLStore::storeAssociation()
+ Auth_OpenID_SQLStore::tableExists()
+ Auth_OpenID_SQLStore::useNonce()
+
Inherited From Auth_OpenID_OpenIDStore
++ Auth_OpenID_OpenIDStore::getAssociation()+ +
+ Auth_OpenID_OpenIDStore::getAuthKey()
+ Auth_OpenID_OpenIDStore::isDumb()
+ Auth_OpenID_OpenIDStore::removeAssociation()
+ Auth_OpenID_OpenIDStore::reset()
+ Auth_OpenID_OpenIDStore::storeAssociation()
+ Auth_OpenID_OpenIDStore::storeNonce()
+ Auth_OpenID_OpenIDStore::useNonce()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+An object that implements the OpenID protocol for a single URL.
+Use this object by calling getOpenIDResponse when you get any request for the server URL.
++ Located in /Auth/OpenID/Server.php (line 1235) +
+ + + + +Decodes a query args array into the appropriate Auth_OpenID_Request object.
+ +Encodes as response in the appropriate format suitable for sending to the user agent.
+ +Handle a request. Given an Auth_OpenID_Request object, call the appropriate Auth_OpenID_Server method to process the request and generate a response.
+ + ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+An error class which gets instantiated and returned whenever an OpenID protocol error occurs. Be prepared to use this in place of an ordinary server response.
++ Located in /Auth/OpenID/Server.php (line 148) +
+ + + + +| Class | +Description | +
|---|---|
| Auth_OpenID_MalformedReturnURL | ++ An error indicating that the return_to URL is malformed. + | +
| Auth_OpenID_MalformedTrustRoot | ++ This error is returned when the trust_root value is malformed. + | +
| Auth_OpenID_UntrustedReturnURL | ++ An error that indicates that the given return_to is not under the given trust_root. + | +
Encodes the response to key-value form. This is a machine-readable format used to respond to messages which came directly from the consumer and not through the user-agent. See the OpenID specification.
+ +Encodes this error's response as a URL suitable for redirection. If the response has no return_to, another Auth_OpenID_ServerError is returned.
+ +Returns the return_to URL for the request which caused this error.
+ +Returns this error message.
+ +Returns one of $_Auth_OpenID_Encode_Url, $_Auth_OpenID_Encode_Kvform, or null, depending on the type of encoding expected for this error's payload.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+Object that holds the state of a request to the OpenID server
+With accessor functions to get at the internal request data.
+ ++ Located in /Auth/OpenID/ServerRequest.php (line 30) +
+ + + + ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+A response with a status of Auth_OpenID_SETUP_NEEDED. Indicates that the request was in immediate mode, and the server is unable to authenticate the user without further interaction.
+identity_url - The identity URL for which authentication was attempted.
setup_url - A URL that can be used to send the user to the server to set up for authentication. The user should be redirected in to the setup_url, either in the current window or in a new browser window.
status - Auth_OpenID_SETUP_NEEDED.
++ Located in /Auth/OpenID/Consumer.php (line 1174) +
+ + +Auth_OpenID_ConsumerResponse + | + --Auth_OpenID_SetupNeededResponse+ +
+ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
+Responsible for the signature of query data and the verification of OpenID signature values.
++ Located in /Auth/OpenID/Server.php (line 893) +
+ + + + +Create a new signatory using a given store.
+ +Make a new association.
+ +Given an association handle, get the association from the store, or return a ServerError or null if something goes wrong.
+ +Invalidate a given association handle.
+ +Given a response, sign the fields in the response's 'signed' list, and insert the signature into the response.
+ +Verify, using a given association handle, a signature with signed key-value pairs from an HTTP request.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+An encoder which also takes care of signing fields when required.
++ Located in /Auth/OpenID/Server.php (line 1077) +
+ + +Auth_OpenID_Encoder + | + --Auth_OpenID_SigningEncoder+ +
Inherited from Auth_OpenID_Encoder
++ + Auth_OpenID_Encoder::$responseFactory+ +
+ +
Sign an Auth_OpenID_Response and return an Auth_OpenID_WebResponse.
+ +Inherited From Auth_OpenID_Encoder
++ Auth_OpenID_Encoder::encode()+ +
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+A response with a status of Auth_OpenID_SUCCESS. Indicates that
+this request is a successful acknowledgement from the OpenID server that the supplied URL is, indeed controlled by the requesting agent. This has three relevant attributes:
identity_url - The identity URL that has been authenticated
signed_args - The arguments in the server's response that were signed and verified.
status - Auth_OpenID_SUCCESS.
++ Located in /Auth/OpenID/Consumer.php (line 1041) +
+ + +Auth_OpenID_ConsumerResponse + | + --Auth_OpenID_SuccessResponse+ +
Extract signed extension data from the server's response.
+ +Get the openid.return_to argument from this response.
+This is useful for verifying that this request was initiated by this consumer.
+ + ++ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
+An error that indicates that the given return_to is not under the given trust_root.
++ Located in /Auth/OpenID/Server.php (line 1203) +
+ + +Auth_OpenID_ServerError + | + --Auth_OpenID_UntrustedReturnURL+ +
Inherited From Auth_OpenID_ServerError
++ Auth_OpenID_ServerError::encodeToKVForm()+ +
+ Auth_OpenID_ServerError::encodeToURL()
+ Auth_OpenID_ServerError::hasReturnTo()
+ Auth_OpenID_ServerError::toString()
+ Auth_OpenID_ServerError::whichEncoding()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+A web-capable response object which you can use to generate a user-agent response.
++ Located in /Auth/OpenID/Server.php (line 864) +
+ + + + ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+This module contains code for dealing with associations between consumers and servers.
+PHP versions 4 and 5
LICENSE: See the COPYING file included in this distribution.
+ + +| Class | +Description | +
|---|---|
| + Auth_OpenID_Association + | ++ This class represents an association between a server and a consumer. In general, users of this library will never see instances of this object. The only exception is if you implement a custom Auth_OpenID_OpenIDStore. + | +
+ Documentation generated on Mon, 10 Sep 2007 13:29:27 -0700 by phpDocumentor 1.3.2 +
+This module documents the main interface with the OpenID consumer
+library. The only part of the library which has to be used and isn't documented in full here is the store required to create an Auth_OpenID_Consumer instance. More on the abstract store type and concrete implementations of it that are provided in the documentation for the Auth_OpenID_Consumer constructor.
OVERVIEW
The OpenID identity verification process most commonly uses the following steps, as visible to the user of this library:
LIBRARY DESIGN
This consumer library is designed with that flow in mind. The goal is to make it as easy as possible to perform the above steps securely.
At a high level, there are two important parts in the consumer library. The first important part is this module, which contains the interface to actually use this library. The second is the Auth_OpenID_Interface class, which describes the interface to use if you need to create a custom method for storing the state this library needs to maintain between requests.
In general, the second part is less important for users of the library to know about, as several implementations are provided which cover a wide variety of situations in which consumers may use the library.
This module contains a class, Auth_OpenID_Consumer, with methods corresponding to the actions necessary in each of steps 2, 3, and 4 described in the overview. Use of this library should be as easy as creating an Auth_OpenID_Consumer instance and calling the methods appropriate for the action the site wants to take.
STORES AND DUMB MODE
OpenID is a protocol that works best when the consumer site is able to store some state. This is the normal mode of operation for the protocol, and is sometimes referred to as smart mode. There is also a fallback mode, known as dumb mode, which is available when the consumer site is not able to store state. This mode should be avoided when possible, as it leaves the implementation more vulnerable to replay attacks.
The mode the library works in for normal operation is determined by the store that it is given. The store is an abstraction that handles the data that the consumer needs to manage between http requests in order to operate efficiently and securely.
Several store implementation are provided, and the interface is fully documented so that custom stores can be used as well. See the documentation for the Auth_OpenID_Consumer class for more information on the interface for stores. The implementations that are provided allow the consumer site to store the necessary data in several different ways, including several SQL databases and normal files on disk.
There is an additional concrete store provided that puts the system in dumb mode. This is not recommended, as it removes the library's ability to stop replay attacks reliably. It still uses time-based checking to make replay attacks only possible within a small window, but they remain possible within that window. This store should only be used if the consumer site has no way to retain data between requests at all.
IMMEDIATE MODE
In the flow described above, the user may need to confirm to the lidentity server that it's ok to authorize his or her identity. The server may draw pages asking for information from the user before it redirects the browser back to the consumer's site. This is generally transparent to the consumer site, so it is typically ignored as an implementation detail.
There can be times, however, where the consumer site wants to get a response immediately. When this is the case, the consumer can put the library in immediate mode. In immediate mode, there is an extra response possible from the server, which is essentially the server reporting that it doesn't have enough information to answer the question yet. In addition to saying that, the identity server provides a URL to which the user can be sent to provide the needed information and let the server finish handling the original request.
USING THIS LIBRARY
Integrating this library into an application is usually a relatively straightforward process. The process should basically follow this plan:
Add an OpenID login field somewhere on your site. When an OpenID is entered in that field and the form is submitted, it should make a request to the your site which includes that OpenID URL.
First, the application should instantiate the Auth_OpenID_Consumer class using the store of choice (Auth_OpenID_FileStore or one of the SQL-based stores). If the application has any sort of session framework that provides per-client state management, a dict-like object to access the session should be passed as the optional second parameter. (The default behavior is to use PHP's standard session machinery.)
Next, the application should call the Auth_OpenID_Consumer object's 'begin' method. This method takes the OpenID URL. The 'begin' method returns an Auth_OpenID_AuthRequest object.
Next, the application should call the 'redirectURL' method of the Auth_OpenID_AuthRequest object. The 'return_to' URL parameter is the URL that the OpenID server will send the user back to after attempting to verify his or her identity. The 'trust_root' is the URL (or URL pattern) that identifies your web site to the user when he or she is authorizing it. Send a redirect to the resulting URL to the user's browser.
That's the first half of the authentication process. The second half of the process is done after the user's ID server sends the user's browser a redirect back to your site to complete their login.
When that happens, the user will contact your site at the URL given as the 'return_to' URL to the Auth_OpenID_AuthRequest::redirectURL call made above. The request will have several query parameters added to the URL by the identity server as the information necessary to finish the request.
Lastly, instantiate an Auth_OpenID_Consumer instance as above and call its 'complete' method, passing in all the received query arguments.
There are multiple possible return types possible from that method. These indicate the whether or not the login was successful, and include any additional information appropriate for their type.
PHP versions 4 and 5
LICENSE: See the COPYING file included in this distribution.
+ + +| Class | +Description | +
|---|---|
| + Auth_OpenID_Consumer + | ++ An OpenID consumer implementation that performs discovery and does session management. See the Consumer.php file documentation for more information. + | +
| + Auth_OpenID_DiffieHellmanConsumerSession + | ++ + | +
| + Auth_OpenID_PlainTextConsumerSession + | ++ + | +
| + Auth_OpenID_AuthRequest + | ++ This class represents an authentication request from a consumer to an OpenID server. + | +
| + Auth_OpenID_ConsumerResponse + | ++ The base class for responses from the Auth_OpenID_Consumer. + | +
| + Auth_OpenID_SuccessResponse + | ++ A response with a status of Auth_OpenID_SUCCESS. Indicates that + | +
| + Auth_OpenID_FailureResponse + | ++ A response with a status of Auth_OpenID_FAILURE. Indicates that the OpenID protocol has failed. This could be locally or remotely triggered. This has three relevant attributes: + | +
| + Auth_OpenID_CancelResponse + | ++ A response with a status of Auth_OpenID_CANCEL. Indicates that the user cancelled the OpenID authentication request. This has two relevant attributes: + | +
| + Auth_OpenID_SetupNeededResponse + | ++ A response with a status of Auth_OpenID_SETUP_NEEDED. Indicates that the request was in immediate mode, and the server is unable to authenticate the user without further interaction. + | +
Require utility classes and functions for the consumer.
+ +Status to indicate cancellation of OpenID authentication.
+ + +This is the characters that the nonces are made from.
+ + +This is the status code completeAuth returns when the value it received indicated an invalid login.
+ + +This is the status code beginAuth returns when the page fetched from the entered OpenID URL doesn't contain the necessary link tags to function as an identity page.
+ + +This is the status code completeAuth returns when the Auth_OpenID_Consumer instance is in immediate mode, and the identity server sends back a URL to send the user to to complete his or her login.
+ + +This is the status code returned when the complete method returns successfully.
+ + ++ Documentation generated on Mon, 10 Sep 2007 13:29:27 -0700 by phpDocumentor 1.3.2 +
+The Auth_OpenID_DatabaseConnection class, which is used to emulate a PEAR database connection.
+ + +| Class | +Description | +
|---|---|
| + Auth_OpenID_DatabaseConnection + | ++ An empty base class intended to emulate PEAR connection + | +
+ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
+This file supplies a dumb store backend for OpenID servers and consumers.
+PHP versions 4 and 5
LICENSE: See the COPYING file included in this distribution.
+ + +| Class | +Description | +
|---|---|
| + Auth_OpenID_DumbStore + | ++ This is a store for use in the worst case, when you have no way of saving state on the consumer site. Using this store makes the consumer vulnerable to replay attacks, as it's unable to use nonces. Avoid using this store if it is at all possible. + | +
Import the interface for creating a new store class.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
+This file supplies a Memcached store backend for OpenID servers and consumers.
+PHP versions 4 and 5
LICENSE: See the COPYING file included in this distribution.
+ + +| Class | +Description | +
|---|---|
| + Auth_OpenID_FileStore + | ++ This is a filesystem-based store for OpenID associations and + | +
Require base class for creating a new interface.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:28 -0700 by phpDocumentor 1.3.2 +
+This file specifies the interface for PHP OpenID store implementations.
+PHP versions 4 and 5
LICENSE: See the COPYING file included in this distribution.
+ + +| Class | +Description | +
|---|---|
| + Auth_OpenID_OpenIDStore + | ++ This is the interface for the store objects the OpenID library + | +
+ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+A MySQL store.
+ +| Class | +Description | +
|---|---|
| + Auth_OpenID_MySQLStore + | ++ An SQL store that uses MySQL as its backend. + | +
Require the base class file.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+A PostgreSQL store.
+ +| Class | +Description | +
|---|---|
| + Auth_OpenID_PostgreSQLStore + | ++ An SQL store that uses PostgreSQL as its backend. + | +
Require the base class file.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+SQL-backed OpenID stores.
+PHP versions 4 and 5
LICENSE: See the COPYING file included in this distribution.
+ + +| Class | +Description | +
|---|---|
| + Auth_OpenID_SQLStore + | ++ This is the parent class for the SQL stores, which contains the logic common to all of the SQL stores. + | +
Require the PEAR DB module because we'll need it for the SQL-based
+stores implemented here. We silence any errors from the inclusion because it might not be present, and a user of the SQL stores may supply an Auth_OpenID_DatabaseConnection instance that implements its own storage.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+An SQLite store.
+ +| Class | +Description | +
|---|---|
| + Auth_OpenID_SQLiteStore + | ++ An SQL store that uses SQLite as its backend. + | +
Require the base class file.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+OpenID server protocol and logic.
+Overview
An OpenID server must perform three tasks:
If it's a request to authenticate a user (a 'checkid_setup' or 'checkid_immediate' request), you need to decide if you will assert that this user may claim the identity in question. Exactly how you do that is a matter of application policy, but it generally involves making sure the user has an account with your system and is logged in, checking to see if that identity is hers to claim, and verifying with the user that she does consent to releasing that information to the party making the request.
Examine the properties of the Auth_OpenID_CheckIDRequest object, and if and when you've come to a decision, form a response by calling Auth_OpenID_CheckIDRequest::answer.
Other types of requests relate to establishing associations between client and server and verifing the authenticity of previous communications. Auth_OpenID_Server contains all the logic and data necessary to respond to such requests; just pass it to Auth_OpenID_Server::handleRequest.
OpenID Extensions
Do you want to provide other information for your users in addition to authentication? Version 1.2 of the OpenID protocol allows consumers to add extensions to their requests. For example, with sites using the Simple Registration Extension (http://www.openidenabled.com/openid/simple-registration-extension/), a user can agree to have their nickname and e-mail address sent to a site when they sign up.
Since extensions do not change the way OpenID authentication works, code to handle extension requests may be completely separate from the Auth_OpenID_Request class here. But you'll likely want data sent back by your extension to be signed. Auth_OpenID_Response provides methods with which you can add data to it which can be signed with the other data in the OpenID signature.
For example:
// when request is a checkid_* request response = request.answer(True) // this will a signed 'openid.sreg.timezone' parameter to the response response.addField('sreg', 'timezone', 'America/Los_Angeles')
Stores
The OpenID server needs to maintain state between requests in order to function. Its mechanism for doing this is called a store. The store interface is defined in Interface.php. Additionally, several concrete store implementations are provided, so that most sites won't need to implement a custom store. For a store backed by flat files on disk, see Auth_OpenID_FileStore. For stores based on MySQL, SQLite, or PostgreSQL, see the Auth_OpenID_SQLStore subclasses.
Upgrading
The keys by which a server looks up associations in its store have changed in version 1.2 of this library. If your store has entries created from version 1.0 code, you should empty it.
PHP versions 4 and 5
LICENSE: See the COPYING file included in this distribution.
+ + +| Class | +Description | +
|---|---|
| + Auth_OpenID_ServerError + | ++ An error class which gets instantiated and returned whenever an OpenID protocol error occurs. Be prepared to use this in place of an ordinary server response. + | +
| + Auth_OpenID_MalformedReturnURL + | ++ An error indicating that the return_to URL is malformed. + | +
| + Auth_OpenID_MalformedTrustRoot + | ++ This error is returned when the trust_root value is malformed. + | +
| + Auth_OpenID_PlainTextServerSession + | ++ + | +
| + Auth_OpenID_DiffieHellmanServerSession + | ++ + | +
| + Auth_OpenID_WebResponse + | ++ A web-capable response object which you can use to generate a user-agent response. + | +
| + Auth_OpenID_Signatory + | ++ Responsible for the signature of query data and the verification of OpenID signature values. + | +
| + Auth_OpenID_Encoder + | ++ Encode an Auth_OpenID_Response to an Auth_OpenID_WebResponse. + | +
| + Auth_OpenID_SigningEncoder + | ++ An encoder which also takes care of signing fields when required. + | +
| + Auth_OpenID_Decoder + | ++ Decode an incoming Auth_OpenID_WebResponse into an Auth_OpenID_Request. + | +
| + Auth_OpenID_EncodingError + | ++ An error that indicates an encoding problem occurred. + | +
| + Auth_OpenID_AlreadySigned + | ++ An error that indicates that a response was already signed. + | +
| + Auth_OpenID_UntrustedReturnURL + | ++ An error that indicates that the given return_to is not under the given trust_root. + | +
| + Auth_OpenID_Server + | ++ An object that implements the OpenID protocol for a single URL. + | +
Required imports
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+OpenID Server Request
+ + +| Class | +Description | +
|---|---|
| + Auth_OpenID_ServerRequest + | ++ Object that holds the state of a request to the OpenID server + | +
Imports
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+This is the PHP OpenID library by JanRain, Inc.
+This module contains core utility functionality used by the library. See Consumer.php and Server.php for the consumer and server implementations.
PHP versions 4 and 5
LICENSE: See the COPYING file included in this distribution.
+ + +Status code returned when there were no OpenID arguments passed. This code indicates that the caller should return a 200 OK response and display an HTML page that says that this is an OpenID server endpoint.
+ + + +Status code returned when the caller needs to authenticate the
+user. The associated value is a Auth_OpenID_ServerRequest object that can be used to complete the authentication. If the user has taken some authentication action, use the retry() method of the Auth_OpenID_ServerRequest object to complete the request.
+ + + +Defines for regexes and format checking.
+ + +Status code returned by the server when the only option is to show an error page, since we do not have enough information to redirect back to the consumer. The associated value is an error message that should be displayed on an HTML error page.
+ + + +Status code returned when there is a redirect back to the consumer. The value is the URL to redirect back to. The caller should return a 302 Found redirect with a Location: header containing the URL.
+ + + +Status code returned when there is an error to return in key-value form to the consumer. The caller should return a 400 Bad Request response with content-type text/plain and the value as the body.
+ + + +Status code returned when there is a key-value form OK response to the consumer. The value associated with this code is the response. The caller should return a 200 OK response with content-type text/plain and the value as the body.
+ + + ++ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+This is a complete implementation of the OpenID authentication + protocol. This package contains: + +
To install this package, copy the Auth/
+ directory in this package to a directory in your PHP include path.
+ Alternatively, modify your PHP include path to include the
+ directory that contains Auth/. Any
+ applications that need this package will then be able to use it.
See the server and consumer examples in the
+ examples/ directory of the package. For
+ details on how to run the examples, see
+ examples/README. If you want to create your
+ own OpenID data storage class, please see the Auth_OpenID_OpenIDStore
+ class.
+ Documentation generated on Mon, 10 Sep 2007 13:29:26 -0700 by phpDocumentor 1.3.2 +
+A session helper class designed to translate between arrays and
+objects. Note that the class used must have a constructor that takes no parameters. This is not a general solution, but it works for dumb objects that just need to have attributes set. The idea is that you'll subclass this and override $this->check($data) -> bool to implement your own session data validation.
++ Located in /Services/Yadis/Manager.php (line 177) +
+ + +Services_Yadis_SessionLoader + | + --Auth_OpenID_ServiceEndpointLoader+ +
Inherited From Services_Yadis_SessionLoader
++ Services_Yadis_SessionLoader::check()+ +
+ Services_Yadis_SessionLoader::fromSession()
+ Services_Yadis_SessionLoader::newObject()
+ Services_Yadis_SessionLoader::prepareForLoad()
+ Services_Yadis_SessionLoader::prepareForSave()
+ Services_Yadis_SessionLoader::toSession()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+State management for discovery.
+High-level usage pattern is to call .getNextService(discover) in order to find the next available service for this user for this session. Once a request completes, call .finish() to clean up the session state.
++ Located in /Services/Yadis/Manager.php (line 345) +
+ + + + +Initialize a discovery object.
+ +Clean up Yadis-related services in the session and return the most-recently-attempted service from the manager, if one exists.
+ +Return the next authentication service for the pair of user_input and session. This function handles fallback.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+The Yadis service manager which stores state in a session and iterates over <Service> elements in a Yadis XRDS document and lets a caller attempt to use each one. This is used by the Yadis library internally.
++ Located in /Services/Yadis/Manager.php (line 252) +
+ + + + ++ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+A session helper class designed to translate between arrays and
+objects. Note that the class used must have a constructor that takes no parameters. This is not a general solution, but it works for dumb objects that just need to have attributes set. The idea is that you'll subclass this and override $this->check($data) -> bool to implement your own session data validation.
++ Located in /Services/Yadis/Manager.php (line 199) +
+ + +Services_Yadis_SessionLoader + | + --Services_Yadis_ManagerLoader+ +
Inherited From Services_Yadis_SessionLoader
++ Services_Yadis_SessionLoader::check()+ +
+ Services_Yadis_SessionLoader::fromSession()
+ Services_Yadis_SessionLoader::newObject()
+ Services_Yadis_SessionLoader::prepareForLoad()
+ Services_Yadis_SessionLoader::prepareForSave()
+ Services_Yadis_SessionLoader::toSession()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+The base session class used by the Services_Yadis_Manager. This class wraps the default PHP session machinery and should be subclassed if your application doesn't use PHP sessioning.
++ Located in /Services/Yadis/Manager.php (line 17) +
+ + + + +Return the contents of the session in array form.
+ +Remove a key/value pair from the session.
+ +Get a key's value from the session.
+ + +Set a session key/value pair.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+This class represents a <Service> element in an XRDS document.
+Objects of this type are returned by Services_Yadis_XRDS::services() and Services_Yadis_Yadis::services(). Each object corresponds directly to a <Service> element in the XRDS and supplies a getElements($name) method which you should use to inspect the element's contents. See Services_Yadis_Yadis for more information on the role this class plays in Yadis discovery.
++ Located in /Services/Yadis/XRDS.php (line 73) +
+ + + + +Creates an empty service object.
+ +Used to get XML elements from this object's <Service> element.
+This is what you should use to get all custom information out of this element. This is used by service filter functions to determine whether a service element contains specific tags, etc. NOTE: this only considers elements which are direct children of the <Service> element for this object.
+ + +Returns the "priority" attribute value of this <Service> element, if the attribute is present. Returns null if not.
+ + +Return the URIs in the "Type" elements, if any, of this Service element.
+ + +Return the URIs in the "URI" elements, if any, of this Service element. The URIs are returned sorted in priority order.
+ + ++ Documentation generated on Mon, 10 Sep 2007 13:29:31 -0700 by phpDocumentor 1.3.2 +
+A session helper class designed to translate between arrays and
+objects. Note that the class used must have a constructor that takes no parameters. This is not a general solution, but it works for dumb objects that just need to have attributes set. The idea is that you'll subclass this and override $this->check($data) -> bool to implement your own session data validation.
++ Located in /Services/Yadis/Manager.php (line 74) +
+ + + + +| Class | +Description | +
|---|---|
| Auth_OpenID_ServiceEndpointLoader | ++ A session helper class designed to translate between arrays and + | +
| Services_Yadis_ManagerLoader | ++ A session helper class designed to translate between arrays and + | +
Override this.
+ +Given a session data value (an array), this creates an object
+(returned by $this->newObject()) whose attributes and values are those in $data. Returns null if $data lacks keys found in $this->requiredKeys(). Returns null if $this->check($data) evaluates to false. Returns null if $this->newObject() evaluates to false.
+ +Returns a new instance of this loader's class, using the session data to construct it if necessary. The object need only be created; $this->fromSession() will take care of setting the object's attributes.
+ +Prepares the data array by making any necessary changes.
+Returns an array whose keys and values will be used to update the original data array before calling $this->newObject($data).
+ +Override this.
+ +Returns an array of keys and values built from the attributes of $obj. If $this->prepareForSave($obj) returns an array, its keys and values are used to update the $data array of attributes from $obj.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+The base class for wrappers for available PHP XML-parsing
+extensions. To work with this Yadis library, subclasses of this class MUST implement the API as defined in the remarks for this class. Subclasses of Services_Yadis_XMLParser are used to wrap particular PHP XML extensions such as 'domxml'. These are used internally by the library depending on the availability of supported PHP XML extensions.
++ Located in /Services/Yadis/XML.php (line 21) +
+ + + + +| Class | +Description | +
|---|---|
| Services_Yadis_domxml | ++ This concrete implementation of Services_Yadis_XMLParser implements + | +
| Services_Yadis_dom | ++ This concrete implementation of Services_Yadis_XMLParser implements + | +
Return the attributes of a specified node.
+ + +Return the textual content of a specified node.
+ + +Evaluate an XPath expression and return the resulting node list. This should be overridden by subclasses.
+ + +Initialize an instance of Services_Yadis_XMLParser with some XML and namespaces. This SHOULD NOT be overridden by subclasses.
+ + +Register a namespace with the XML parser. This should be overridden by subclasses.
+ + +Set this parser object's XML payload. This should be overridden by subclasses.
+ + ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+This class performs parsing of XRDS documents.
+You should not instantiate this class directly; rather, call parseXRDS statically:
$xrds = Services_Yadis_XRDS::parseXRDS($xml_string);
If the XRDS can be parsed and is valid, an instance of Services_Yadis_XRDS will be returned. Otherwise, null will be returned. This class is used by the Services_Yadis_Yadis::discover method.
++ Located in /Services/Yadis/XRDS.php (line 199) +
+ + + + +Instantiate a Services_Yadis_XRDS object. Requires an XPath instance which has been used to parse a valid XRDS document.
+ +Parse an XML string (XRDS document) and return either a Services_Yadis_XRDS object or null, depending on whether the XRDS XML is valid.
+ + +Returns a list of service objects which correspond to <Service> elements in the XRDS XML document for this object.
+Optionally, an array of filter callbacks may be given to limit the list of returned service objects. Furthermore, the default mode is to return all service objects which match ANY of the specified filters, but $filter_mode may be SERVICES_YADIS_MATCH_ALL if you want to be sure that the returned services match all the given filters. See Services_Yadis_Yadis for detailed usage information on filter functions.
+ + ++ Documentation generated on Mon, 10 Sep 2007 13:29:31 -0700 by phpDocumentor 1.3.2 +
+This is the core of the PHP Yadis library. This is the only class a user needs to use to perform Yadis discovery. This class performs the discovery AND stores the result of the discovery.
+First, require this library into your program source:
require_once "Services/Yadis/Yadis.php";
To perform Yadis discovery, first call the "discover" method statically with a URI parameter:
$http_response = array(); + $fetcher = Services_Yadis_Yadis::getHTTPFetcher(); + $yadis_object = Services_Yadis_Yadis::discover($uri, + $http_response, $fetcher);
If the discovery succeeds, $yadis_object will be an instance of Services_Yadis_Yadis. If not, it will be null. The XRDS document found during discovery should have service descriptions, which can be accessed by calling
$service_list = $yadis_object->services();
which returns an array of objects which describe each service. These objects are instances of Services_Yadis_Service. Each object describes exactly one whole Service element, complete with all of its Types and URIs (no expansion is performed). The common use case for using the service objects returned by services() is to write one or more filter functions and pass those to services():
$service_list = $yadis_object->services(
+ array("filterByURI",
+ "filterByExtension"));The filter functions (whose names appear in the array passed to services()) take the following form:
function myFilter(&$service) {
+ // Query $service object here. Return true if the service
+ // matches your query; false if not.
+ }This is an example of a filter which uses a regular expression to match the content of URI tags (note that the Services_Yadis_Service class provides a getURIs() method which you should use instead of this contrived example):
function URIMatcher(&$service) {
+ foreach ($service->getElements('xrd:URI') as $uri) {
+ if (preg_match("/some_pattern/",
+ $service->parser->content($uri))) {
+ return true;
+ }
+ }
+ return false;
+ }The filter functions you pass will be called for each service object to determine which ones match the criteria your filters specify. The default behavior is that if a given service object matches ANY of the filters specified in the services() call, it will be returned. You can specify that a given service object will be returned ONLY if it matches ALL specified filters by changing the match mode of services():
$yadis_object->services(array("filter1", "filter2"),
+ SERVICES_YADIS_MATCH_ALL);See SERVICES_YADIS_MATCH_ALL and SERVICES_YADIS_MATCH_ANY.
Services described in an XRDS should have a library which you'll probably be using. Those libraries are responsible for defining filters that can be used with the "services()" call. If you need to write your own filter, see the documentation for Services_Yadis_Service.
++ Located in /Services/Yadis/Yadis.php (line 114) +
+ + + + +Instantiates an empty Services_Yadis_Yadis object. This constructor should not be used by any user of the library.
+This constructor results in a completely useless object which must be populated with valid discovery information. Instead of using this constructor, call Services_Yadis_Yadis::discover($uri).
+ +This should be called statically and will build a Yadis instance if the discovery process succeeds. This implements Yadis discovery as specified in the Yadis specification.
+ + +Returns an HTTP fetcher object. If the CURL extension is present, an instance of Services_Yadis_ParanoidHTTPFetcher is returned. If not, an instance of Services_Yadis_PlainHTTPFetcher is returned.
+ +Returns the list of service objects as described by the XRDS document, if this yadis object represents a successful Yadis discovery.
+ + ++ Documentation generated on Mon, 10 Sep 2007 13:29:31 -0700 by phpDocumentor 1.3.2 +
+This concrete implementation of Services_Yadis_XMLParser implements
+the appropriate API for the 'dom' extension which is typically packaged with PHP 5. This class will be used whenever the 'dom' extension is detected. See the Services_Yadis_XMLParser class for details on this class's methods.
++ Located in /Services/Yadis/XML.php (line 214) +
+ + +Services_Yadis_XMLParser + | + --Services_Yadis_dom+ +
Inherited From Services_Yadis_XMLParser
++ Services_Yadis_XMLParser::attributes()+ +
+ Services_Yadis_XMLParser::content()
+ Services_Yadis_XMLParser::evalXPath()
+ Services_Yadis_XMLParser::init()
+ Services_Yadis_XMLParser::registerNamespace()
+ Services_Yadis_XMLParser::setXML()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+This concrete implementation of Services_Yadis_XMLParser implements
+the appropriate API for the 'domxml' extension which is typically packaged with PHP 4. This class will be used whenever the 'domxml' extension is detected. See the Services_Yadis_XMLParser class for details on this class's methods.
++ Located in /Services/Yadis/XML.php (line 136) +
+ + +Services_Yadis_XMLParser + | + --Services_Yadis_domxml+ +
Inherited From Services_Yadis_XMLParser
++ Services_Yadis_XMLParser::attributes()+ +
+ Services_Yadis_XMLParser::content()
+ Services_Yadis_XMLParser::evalXPath()
+ Services_Yadis_XMLParser::init()
+ Services_Yadis_XMLParser::registerNamespace()
+ Services_Yadis_XMLParser::setXML()
+
+ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+Yadis service manager to be used during yadis-driven authentication attempts.
+ +| Class | +Description | +
|---|---|
| + Services_Yadis_PHPSession + | ++ The base session class used by the Services_Yadis_Manager. This class wraps the default PHP session machinery and should be subclassed if your application doesn't use PHP sessioning. + | +
| + Services_Yadis_SessionLoader + | ++ A session helper class designed to translate between arrays and + | +
| + Auth_OpenID_ServiceEndpointLoader + | ++ A session helper class designed to translate between arrays and + | +
| + Services_Yadis_ManagerLoader + | ++ A session helper class designed to translate between arrays and + | +
| + Services_Yadis_Manager + | ++ The Yadis service manager which stores state in a session and iterates over <Service> elements in a Yadis XRDS document and lets a caller attempt to use each one. This is used by the Yadis library internally. + | +
| + Services_Yadis_Discovery + | ++ State management for discovery. + | +
+ Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2 +
+XML-parsing classes to wrap the domxml and DOM extensions for PHP 4 and 5, respectively.
+ +| Class | +Description | +
|---|---|
| + Services_Yadis_XMLParser + | ++ The base class for wrappers for available PHP XML-parsing + | +
| + Services_Yadis_domxml + | ++ This concrete implementation of Services_Yadis_XMLParser implements + | +
| + Services_Yadis_dom + | ++ This concrete implementation of Services_Yadis_XMLParser implements + | +
Returns an instance of a Services_Yadis_XMLParser subclass based on the availability of PHP extensions for XML parsing. If Services_Yadis_setDefaultParser has been called, the parser used in that call will be returned instead.
+ +Set a default parser to override the extension-driven selection of available parser classes. This is helpful in a test environment or one in which multiple parsers can be used but one is more desirable.
+ + + ++ Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2 +
+This module contains the XRDS parsing code.
+PHP versions 4 and 5
LICENSE: See the COPYING file included in this distribution.
+ + +| Class | +Description | +
|---|---|
| + Services_Yadis_Service + | ++ This class represents a <Service> element in an XRDS document. + | +
| + Services_Yadis_XRDS + | ++ This class performs parsing of XRDS documents. + | +
Require the XPath implementation.
+ +This match mode means a given service must match ALL filters passed to the Services_Yadis_XRDS::services() call.
+ + +This match mode means a given service must match ANY filters (at least one) passed to the Services_Yadis_XRDS::services() call.
+ + +The priority value used for service elements with no priority specified.
+ + ++ Documentation generated on Mon, 10 Sep 2007 13:29:31 -0700 by phpDocumentor 1.3.2 +
+The core PHP Yadis implementation.
+PHP versions 4 and 5
LICENSE: See the COPYING file included in this distribution.
+ + +| Class | +Description | +
|---|---|
| + Services_Yadis_Yadis + | ++ This is the core of the PHP Yadis library. This is the only class a user needs to use to perform Yadis discovery. This class performs the discovery AND stores the result of the discovery. + | +
Need both fetcher types so we can use the right one based on the presence or absence of CURL.
+ +Need this for parsing HTML (looking for META tags).
+ +Need this to parse the XRDS document during Yadis discovery.
+ ++ Documentation generated on Mon, 10 Sep 2007 13:29:31 -0700 by phpDocumentor 1.3.2 +
++ Documentation generated on Mon, 10 Sep 2007 13:29:27 -0700 by phpDocumentor 1.3.2 +
+ + \ No newline at end of file diff --git a/modules/member/php-openid-1.2.3/doc/classtrees_Yadis.html b/modules/member/php-openid-1.2.3/doc/classtrees_Yadis.html new file mode 100644 index 000000000..600e2b521 --- /dev/null +++ b/modules/member/php-openid-1.2.3/doc/classtrees_Yadis.html @@ -0,0 +1,56 @@ + + + + + ++ Documentation generated on Mon, 10 Sep 2007 13:29:27 -0700 by phpDocumentor 1.3.2 +
+ + \ No newline at end of file diff --git a/modules/member/php-openid-1.2.3/doc/elementindex.html b/modules/member/php-openid-1.2.3/doc/elementindex.html new file mode 100644 index 000000000..791a66d88 --- /dev/null +++ b/modules/member/php-openid-1.2.3/doc/elementindex.html @@ -0,0 +1,1998 @@ + + + + + ++ Documentation generated on Mon, 10 Sep 2007 13:29:31 -0700 by phpDocumentor 1.3.2 +
+ + \ No newline at end of file diff --git a/modules/member/php-openid-1.2.3/doc/index.html b/modules/member/php-openid-1.2.3/doc/index.html new file mode 100644 index 000000000..8361d1f57 --- /dev/null +++ b/modules/member/php-openid-1.2.3/doc/index.html @@ -0,0 +1,24 @@ + + + + + ++ This example consumer uses the PHP + OpenID library. It just verifies that the URL that you enter + is your identity URL. +
+ + $msg"; } ?> + $error"; } ?> + $success"; } ?> + +' . $text . '';
+ }
+
+ function contentType()
+ {
+ return 'text/html';
+ }
+
+ function b($text)
+ {
+ return '' . $text . '';
+ }
+
+ function p($text)
+ {
+ return '' . wordwrap($text) . "
\n"; + } + + function pre($text) + { + return '' . $text . "\n"; + } + + function ol($items) + { + $out = '
' . $what . '
' . $what . '
'; + } + return sprintf('', $s); +} + +/** + * Render an HTML page + */ +function page_render($body, $user, $title, $h1=null, $login=false) +{ + $h1 = $h1 ? $h1 : $title; + + if ($user) { + $msg = sprintf(logged_in_pat, link_render($user)); + $nav = array('logout' => 'Log Out', + 'sites' => 'Remembered Sites', + ); + $navigation = navigation_render($msg, $nav); + } else { + if (!$login) { + $msg = link_render(buildURL('login'), 'Log In'); + $navigation = navigation_render($msg, array()); + } else { + $navigation = ''; + } + } + + $style = getStyle(); + $text = sprintf(page_template, $title, $style, $navigation, $h1, $body); + // No special headers here + $headers = array(); + return array($headers, $text); +} + +?> \ No newline at end of file diff --git a/modules/member/php-openid-1.2.3/examples/server/lib/render/about.php b/modules/member/php-openid-1.2.3/examples/server/lib/render/about.php new file mode 100644 index 000000000..bd358369e --- /dev/null +++ b/modules/member/php-openid-1.2.3/examples/server/lib/render/about.php @@ -0,0 +1,58 @@ + +An error occurred when processing your request: ++ This is an OpenID server + endpoint. This server is built on the JanRain PHP OpenID + library. Since OpenID consumer sites will need to directly contact this + server, it must be accessible over the Internet (not behind a firewall). +
+
+ To use this server, you will have to set up a URL to use as an identifier.
+ Insert the following markup into the <head> of the HTML
+ document at that URL:
+
<link rel="openid.server" href="%s" />+
+ Then configure this server so that you can log in with that URL. Once you + have configured the server, and marked up your identity URL, you can verify + that it is working by using the openidenabled.com + OpenID + Checkup tool: +
+ +'); + +/** + * Render the about page, potentially with an error message + */ +function about_render($error=false, $internal=true) +{ + $headers = array(); + $body = sprintf(about_body, buildURL()); + if ($error) { + $headers[] = $internal ? http_internal_error : http_bad_request; + $body .= sprintf(about_error_template, htmlspecialchars($error)); + } + $current_user = getLoggedInUser(); + return page_render($body, $current_user, 'OpenID Server Endpoint'); +} + +?> \ No newline at end of file diff --git a/modules/member/php-openid-1.2.3/examples/server/lib/render/login.php b/modules/member/php-openid-1.2.3/examples/server/lib/render/login.php new file mode 100644 index 000000000..9e8f37072 --- /dev/null +++ b/modules/member/php-openid-1.2.3/examples/server/lib/render/login.php @@ -0,0 +1,65 @@ + ++ Enter your identity URL and password into this form to log in to + this server. This server must be configured to accept your identity URL. +
+ + + +'); + +define('login_needed_pat', + 'You must be logged in as %s to approve this request.'); + +function login_render($errors=null, $input=null, $needed=null) +{ + $current_user = getLoggedInUser(); + if ($input === null) { + $input = $current_user; + } + if ($needed) { + $errors[] = sprintf(login_needed_pat, link_render($needed)); + } + + $esc_input = htmlspecialchars($input, ENT_QUOTES); + $login_url = buildURL('login', true); + $body = sprintf(login_form_pat, $login_url, $esc_input); + if ($errors) { + $body = loginError_render($errors) . $body; + } + return page_render($body, $current_user, 'Log In', null, true); +} + +function loginError_render($errors) +{ + $text = ''; + foreach ($errors as $error) { + $text .= sprintf("
+ No sites are remembered for this session. When you authenticate with a site,
+ you can choose to add it to this list by choosing Remember this
+ decision
.
+
%s
+'); + +define('sites_row', + 'Do you wish to confirm your identity URL (%s) with %s?
+ This server needs to be configured before it can be used. Edit
+ config.php to reflect your server's setup, then
+ load this page again.
+
open_basedir setting.";
+ $bad_path = true;
+ }
+ }
+ break;
+
+ case "SQLite":
+ if (!$_SESSION['store_data']['sqlite_path']) {
+ $messages[] = "Please specify a SQLite database path.";
+ } else {
+ if (!check_open_basedir($_SESSION['store_data']['sqlite_path'])) {
+ $messages[] = "The SQLite store path violates PHP's open_basedir setting.";
+ $bad_path = true;
+ }
+ }
+ break;
+
+ default:
+ if (!($_SESSION['store_data']['host'] &&
+ $_SESSION['store_data']['database'] &&
+ $_SESSION['store_data']['username'] &&
+ $_SESSION['store_data']['password'])) {
+ $messages[] = "Please specify database connection details.";
+ }
+ }
+ }
+ }
+
+ if ($_SESSION['store_type'] &&
+ $_SESSION['server_url'] &&
+ (parse_url($_SESSION['server_url']) !== false) &&
+ ((($_SESSION['store_type'] == 'Filesystem') &&
+ $_SESSION['store_data']['fs_path']) ||
+ (($_SESSION['store_type'] == 'SQLite') &&
+ $_SESSION['store_data']['sqlite_path']) ||
+ ($_SESSION['store_data']['host'] &&
+ $_SESSION['store_data']['username'] &&
+ $_SESSION['store_data']['database'] &&
+ $_SESSION['store_data']['password'])) &&
+ !$bad_path) {
+
+ return true;
+ }
+
+ return false;
+}
+
+function render_form() {
+
+ global $store_types, $fields, $messages;
+
+ $basedir_msg = "";
+
+ if (ini_get('open_basedir')) {
+ $basedir_msg = "Note: Due to the ".
+ "open_basedir php.ini setting, be sure to ".
+ "choose a path in one of the following directories:+Your browser has been redirected to this page so you can configure the +server example. This form will auto-generate an OpenID example server +configuration for use with the OpenID server example. +
+ + + + + + + + ++Put the following text into config.php. +
+ ++Back to form (resets settings) +
+ ++Download this configuration +
+ +
+
+
+/**
+ * Set any extra include paths needed to use the library
+ */
+set_include_path(get_include_path() . PATH_SEPARATOR . "");
+
+
+/**
+ * The URL for the server.
+ *
+ * This is the location of server.php. For example:
+ *
+ * $server_url = 'http://example.com/~user/server.php';
+ *
+ * This must be a full URL.
+ */
+$server_url = "";
+
+/**
+ * Initialize an OpenID store
+ *
+ * @return object $store an instance of OpenID store (see the
+ * documentation for how to create one)
+ */
+function getOpenIDStore()
+{
+ require_once 'Auth/OpenID/MySQLStore.php';
+ require_once 'DB.php';
+
+ $dsn = array(
+ 'phptype' => 'mysql',
+ 'username' => '',
+ 'password' => '',
+ 'hostspec' => ''
+ );
+
+ $db =& DB::connect($dsn);
+
+ if (PEAR::isError($db)) {
+ return null;
+ }
+
+ $db->query("USE ");
+
+ return new Auth_OpenID_MySQLStore($db);
+require_once 'Auth/OpenID/PostgreSQLStore.php';
+ require_once 'DB.php';
+
+ $dsn = array(
+ 'phptype' => 'pgsql',
+ 'username' => '',
+ 'password' => '',
+ 'hostspec' => '',
+ 'database' => ''
+ );
+
+ $db =& DB::connect($dsn);
+
+ if (PEAR::isError($db)) {
+ return null;
+ }
+
+ return new Auth_OpenID_PostgreSQLStore($db);
+
+}
+
+/**
+ * Users who are allowed to log in to this OpenID server.
+ *
+ * This is an array from URL to password hash. The URL must include
+ * the proper OpenID server information in order to work with this
+ * server.
+ *
+ * This must be set for the server to be usable. If it is not set, no
+ * users will be able to log in.
+ *
+ * Example:
+ * $openid_users = array(
+ * 'http://joe.example.com/' => sha1('foo')
+ * )
+ */
+$openid_users = array( $hash) {
+ $i++;
+ print "\n '$url' => '$hash'";
+ if ($i < count($_SESSION['users'])) {
+ print ",";
+ }
+}
+?>
+
+);
+
+/**
+ * Trusted sites is an array of trust roots.
+ *
+ * Sites in this list will not have to be approved by the user in
+ * order to be used. It is OK to leave this value as-is.
+ *
+ * In a more robust server, this should be a per-user setting.
+ */
+$trusted_sites = array(
+
+);
+
+
+
+
+