Source for file Association.php

Documentation is available at Association.php

  1. <?php
  2. /**
  3.  * OpenID_Association
  4.  * 
  5.  * PHP Version 5.2.0+
  6.  * 
  7.  * @category  Auth
  8.  * @package   OpenID
  9.  * @author    Bill Shupp <hostmaster@shupp.org>
  10.  * @copyright 2009 Bill Shupp
  11.  * @license   http://www.opensource.org/licenses/bsd-license.php FreeBSD
  12.  * @link      http://pearopenid.googlecode.com
  13.  */
  14.  
  15. /**
  16.  * Required files
  17.  */
  18. require_once 'OpenID/Association/Exception.php';
  19. require_once 'OpenID.php';
  20. require_once 'OpenID/Message.php';
  21. require_once 'Validate.php';
  22.  
  23. /**
  24.  * OpenID_Association
  25.  * 
  26.  * A class that represents an association.  This class can be serialized for
  27.  * storage.  It also allows you to add and check signatures of an OpenID_Message.
  28.  * 
  29.  * @category  Auth
  30.  * @package   OpenID
  31.  * @author    Bill Shupp <hostmaster@shupp.org>
  32.  * @copyright 2009 Bill Shupp
  33.  * @license   http://www.opensource.org/licenses/bsd-license.php FreeBSD
  34.  * @link      http://pearopenid.googlecode.com
  35.  * @see       OpenID_Association_Request::buildRequest()
  36.  */
  37. class OpenID_Association
  38. {
  39.     /**
  40.      * URI of the OP Endpoint
  41.      * 
  42.      * @var string 
  43.      */
  44.     protected $uri = null;
  45.  
  46.     /**
  47.      * expires_in paramater of the association.  Time is in seconds.
  48.      * 
  49.      * @var mixed 
  50.      */
  51.     protected $expiresIn = null;
  52.  
  53.     /**
  54.      * Unix timestamp of when this association was created.
  55.      * 
  56.      * @var int 
  57.      */
  58.     protected $created = null;
  59.  
  60.     /**
  61.      * assoc_type parameter of the association.  Should be one of HMAC-SHA1 or
  62.      * HMAC-SHA256
  63.      * 
  64.      * @var string 
  65.      */
  66.     protected $assocType = null;
  67.  
  68.     /**
  69.      * assoc_handle parameter of the association.
  70.      * 
  71.      * @var string 
  72.      */
  73.     protected $assocHandle = null;
  74.  
  75.     /**
  76.      * In the association response, this is also referred to as the "mac_key", or is
  77.      * derived from the "enc_mac_key" if the session used encryption.
  78.      * 
  79.      * @var mixed 
  80.      */
  81.     protected $sharedSecret = null;
  82.  
  83.     /**
  84.      * Required parameters for storing an association.
  85.      * 
  86.      * @see __construct()
  87.      * @var array 
  88.      */
  89.     protected $requiredParams = array(
  90.         'uri',
  91.         'expiresIn',
  92.         'created',
  93.         'assocType',
  94.         'assocHandle',
  95.         'sharedSecret'
  96.     );
  97.  
  98.     /**
  99.      * Local list of supported association types.
  100.      * 
  101.      * @see $assocType
  102.      * @see __construct()
  103.      * @var array 
  104.      */
  105.     protected $supportedTypes = array(
  106.         OpenID::ASSOC_TYPE_HMAC_SHA1,
  107.         OpenID::ASSOC_TYPE_HMAC_SHA256
  108.     );
  109.  
  110.     /**
  111.      * Validates some association values before setting them as member variables.
  112.      * 
  113.      * @param array $params Array of relevant parameters from the association
  114.      *                       response
  115.      * 
  116.      * @throws OpenID_Association_Exception if the response is not valid
  117.      * @return void 
  118.      */
  119.     public function __construct(array $params)
  120.     {
  121.         // Make sure required params are present
  122.         foreach ($this->requiredParams as $key) {
  123.             if (!isset($params[$key])) {
  124.                 throw new OpenID_Association_Exception(
  125.                     "Missing parameter: $key"
  126.                 );
  127.             }
  128.         }
  129.  
  130.         // Validate URI
  131.         if (!Validate::uri($params['uri'])) {
  132.             throw new OpenID_Association_Exception(
  133.                 "Invalid uri: " . $params['uri']
  134.             );
  135.         }
  136.  
  137.         // Validate assocType
  138.         if (!in_array(strtoupper($params['assocType']), $this->supportedTypes)) {
  139.             throw new OpenID_Association_Exception(
  140.                 "Invalid association type: " . $params['assocType']
  141.             );
  142.         }
  143.  
  144.         // Set values
  145.         reset($this->requiredParams);
  146.         foreach ($this->requiredParams as $key) {
  147.             $this->$key = $params[$key];
  148.         }
  149.     }
  150.  
  151.     /**
  152.      * Allows access to association data via $assoc->name
  153.      * 
  154.      * @param string $name Name of the item to get
  155.      * 
  156.      * @return mixed Value
  157.      */
  158.     public function __get($name)
  159.     {
  160.         return $this->$name;
  161.     }
  162.  
  163.     /**
  164.      * Gets the algo part of the assoc_type (strips 'HMAC-')
  165.      * 
  166.      * @return string Algorithm part of the assoc_type handle
  167.      */
  168.     public function getAlgorithm()
  169.     {
  170.         return str_replace('HMAC-', '', $this->assocType);
  171.     }
  172.  
  173.     /**
  174.      * Checks the signature of an OpenID_Message using this association
  175.      * 
  176.      * @param OpenID_Message $message Instance of OpenID_Message
  177.      * 
  178.      * @throws OpenID_Association_Exception if the handles don't match
  179.      * @return bool true if the signatures match, false otherwise
  180.      */
  181.     public function checkMessageSignature(OpenID_Message $message)
  182.     {
  183.         // Make sure the handles match for this OP and response
  184.         if ($this->assocHandle != $message->get('openid.assoc_handle')) {
  185.  
  186.             throw new OpenID_Association_Exception(
  187.                 'Association handles do not match'
  188.             );
  189.         }
  190.  
  191.         // Make sure the OP Endpoints match for this association and response
  192.         if ($this->uri != $message->get('openid.op_endpoint')) {
  193.  
  194.             throw new OpenID_Association_Exception(
  195.                 'Endpoint URLs do not match'
  196.             );
  197.         }
  198.  
  199.         if (!strlen($message->get('openid.signed'))) {
  200.             OpenID::setLastEvent(__METHOD__, 'openid.signed is empty');
  201.             return false;
  202.         }
  203.         $list = explode(',', $message->get('openid.signed'));
  204.  
  205.         // Create a message with only keys in the signature
  206.         $signedOnly = $this->getMessageForSigning($message);
  207.  
  208.         $signedOnlyDigest = base64_encode($this->hashHMAC($signedOnly));
  209.  
  210.         $event = array(
  211.             'assocHandle'       => $this->assocHandle,
  212.             'algo'              => $this->getAlgorithm(),
  213.             'secret'            => $this->sharedSecret,
  214.             'openid.sig'        => $message->get('openid.sig'),
  215.             'signature'         => $signedOnlyDigest,
  216.             'SignedKVFormat'    => $signedOnly,
  217.             'MessageHTTPFormat' => $message->getHTTPFormat(),
  218.             'phpInput'          => file_get_contents('php://input')
  219.         );
  220.         OpenID::setLastEvent(__METHOD__, print_r($event, true));
  221.  
  222.         return $signedOnlyDigest == $message->get('openid.sig');
  223.     }
  224.  
  225.     /**
  226.      * Returns a KV formatted message for signing based on the contents of the
  227.      * openid.signed key.  This allows for duplicate entries, which
  228.      * OpenID_Message::getKVFormat() doesn't.  (Yahoo! uses duplicates)
  229.      * 
  230.      * @param OpenID_Message $message An instance of the OpenID_Message you want to
  231.      *                                 sign
  232.      * 
  233.      * @return string The openid.signed items in KV form
  234.      */
  235.     public function getMessageForSigning(OpenID_Message $message)
  236.     {
  237.         $list = explode(',', $message->get('openid.signed'));
  238.  
  239.         $signedOnly = '';
  240.         foreach ($list as $key) {
  241.             $signedOnly .= "$key:" . $message->get('openid.' . $key) . "\n";
  242.         }
  243.         return $signedOnly;
  244.     }
  245.  
  246.     /**
  247.      * Signs an OpenID_Message instance
  248.      * 
  249.      * @param OpenID_Message $message Message to be signed
  250.      * 
  251.      * @throws OpenID_Association_Exception if the message is already signed,
  252.                or the association handles do not match
  253.      * @return void 
  254.      */
  255.     public function signMessage(OpenID_Message $message)
  256.     {
  257.         if ($message->get('openid.sig') !== null ||
  258.             $message->get('openid.signed') !== null) {
  259.             throw new OpenID_Association_Exception(
  260.                 'This message appears to be already signed'
  261.             );
  262.         }
  263.  
  264.         // Make sure the handles match for this OP and response
  265.         if ($this->assocHandle != $message->get('openid.assoc_handle')) {
  266.  
  267.             throw new OpenID_Association_Exception(
  268.                 'Association handles do not match'
  269.             );
  270.         }
  271.  
  272.         $keys = array('signed');
  273.         foreach ($message->getArrayFormat() as $key => $val) {
  274.             if (strncmp('openid.', $key, 7) == 0) {
  275.                 $keys[] = substr($key, 7);
  276.             }
  277.         }
  278.         sort($keys);
  279.         $message->set('openid.signed', implode(',', $keys));
  280.  
  281.         $signedMessage = new OpenID_Message;
  282.  
  283.         foreach ($keys as $key) {
  284.             $signedMessage->set($key, $message->get('openid.' . $key));
  285.         }
  286.  
  287.         $rawSignature = $this->hashHMAC($signedMessage->getKVFormat());
  288.  
  289.         $message->set('openid.sig', base64_encode($rawSignature));
  290.     }
  291.  
  292.     /**
  293.      * Gets a an HMAC hash of an OpenID_Message using this association.
  294.      * 
  295.      * @param OpenID_Message $message The message format of the items to hash
  296.      * 
  297.      * @return string The HMAC hash
  298.      */
  299.     protected function hashHMAC($message)
  300.     {
  301.         return hash_hmac($this->getAlgorithm(),
  302.                          $message,
  303.                          base64_decode($this->sharedSecret),
  304.                          true);
  305.     }
  306. }
  307. ?>

Documentation generated on Tue, 15 Dec 2009 19:00:51 -0800 by phpDocumentor 1.4.3