phpBB/includes/libraries/sftp/hash.php

   1 <?php
   2 /**
   3 *
   4 * @package sftp
   5 * @version $Id$
   6 * @copyright (c) 2006 phpBB Group
   7 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
   8 *
   9 */
  10
  11 /**
  12 * @ignore
  13 */
  14 if (!defined('IN_PHPBB'))
  15 {
  16         exit;
  17 }
  18
  19 /**
  20 * Code from http://phpseclib.sourceforge.net/
  21 *
  22 * Modified by phpBB Group to meet our coding standards
  23 * and being able to integrate into phpBB
  24 *
  25 * Pure-PHP implementations of keyed-hash message authentication codes (HMACs) and various cryptographic hashing functions.
  26 *
  27 * Copyright 2007-2009 TerraFrost <terrafrost@php.net>
  28 * Copyright 2009+ phpBB
  29 *
  30 * @package sftp
  31 * @author  TerraFrost <terrafrost@php.net>
  32 */
  33
  34 /**#@+
  35  * @access private
  36  * @see hash::__construct()
  37  */
  38 /**
  39  * Toggles the internal implementation
  40  */
  41 define('CRYPT_HASH_MODE_INTERNAL', 1);
  42 /**
  43  * Toggles the mhash() implementation, which has been deprecated on PHP 5.3.0+.
  44  */
  45 define('CRYPT_HASH_MODE_MHASH', 2);
  46 /**
  47  * Toggles the hash() implementation, which works on PHP 5.1.2+.
  48  */
  49 define('CRYPT_HASH_MODE_HASH',   3);
  50 /**#@-*/
  51
  52 /**
  53  * Pure-PHP implementations of keyed-hash message authentication codes (HMACs) and various cryptographic hashing functions.
  54  *
  55  * @author  Jim Wigginton <terrafrost@php.net>
  56  * @version 0.1.0
  57  * @access  public
  58  * @package hash
  59  */
  60 class hash
  61 {
  62         /**
  63          * Byte-length of compression blocks / key (Internal HMAC)
  64          *
  65          * @see hash::set_algorithm()
  66          * @var Integer
  67          * @access private
  68          */
  69         var $b;
  70
  71         /**
  72          * Byte-length of hash output (Internal HMAC)
  73          *
  74          * @see hash::set_hash()
  75          * @var Integer
  76          * @access private
  77          */
  78         var $l;
  79
  80         /**
  81          * Hash Algorithm
  82          *
  83          * @see hash::set_hash()
  84          * @var String
  85          * @access private
  86          */
  87         var $hash;
  88
  89         /**
  90          * Key
  91          *
  92          * @see hash::setKey()
  93          * @var String
  94          * @access private
  95          */
  96         var $key = '';
  97
  98         /**
  99          * Outer XOR (Internal HMAC)
 100          *
 101          * @see hash::setKey()
 102          * @var String
 103          * @access private
 104          */
 105         var $opad;
 106
 107         /**
 108          * Inner XOR (Internal HMAC)
 109          *
 110          * @see hash::setKey()
 111          * @var String
 112          * @access private
 113          */
 114         var $ipad;
 115
 116         /**
 117          * Default Constructor.
 118          *
 119          * @param optional String $hash
 120          * @return hash
 121          * @access public
 122          */
 123         function __construct($hash = 'sha1')
 124         {
 125                 if ( !defined('CRYPT_HASH_MODE') )
 126                 {
 127                         switch (true)
 128                         {
 129                                 case extension_loaded('hash'):
 130                                         define('CRYPT_HASH_MODE', CRYPT_HASH_MODE_HASH);
 131                                         break;
 132                                 case extension_loaded('mhash'):
 133                                         define('CRYPT_HASH_MODE', CRYPT_HASH_MODE_MHASH);
 134                                         break;
 135                                 default:
 136                                         define('CRYPT_HASH_MODE', CRYPT_HASH_MODE_INTERNAL);
 137                         }
 138                 }
 139
 140                 $this->set_hash($hash);
 141         }
 142
 143         /**
 144          * Sets the key for HMACs
 145          *
 146          * Keys can be of any length.
 147          *
 148          * @access public
 149          * @param String $key
 150          */
 151         function set_key($key)
 152         {
 153                 $this->key = $key;
 154         }
 155
 156         /**
 157          * Sets the hash function.
 158          *
 159          * @access public
 160          * @param String $hash
 161          */
 162         function set_hash($hash)
 163         {
 164                 switch ($hash)
 165                 {
 166                         case 'md5-96':
 167                         case 'sha1-96':
 168                                 $this->l = 12; // 96 / 8 = 12
 169                                 break;
 170                         case 'md5':
 171                                 $this->l = 16;
 172                                 break;
 173                         case 'sha1':
 174                                 $this->l = 20;
 175                 }
 176
 177                 switch (CRYPT_HASH_MODE)
 178                 {
 179                         case CRYPT_HASH_MODE_MHASH:
 180                                 switch ($hash)
 181                                 {
 182                                         case 'md5':
 183                                         case 'md5-96':
 184                                                 $this->hash = MHASH_MD5;
 185                                                 break;
 186                                         case 'sha1':
 187                                         case 'sha1-96':
 188                                         default:
 189                                                 $this->hash = MHASH_SHA1;
 190                                 }
 191                                 return;
 192                         case CRYPT_HASH_MODE_HASH:
 193                                 switch ($hash)
 194                                 {
 195                                         case 'md5':
 196                                         case 'md5-96':
 197                                                 $this->hash = 'md5';
 198                                                 return;
 199                                         case 'sha1':
 200                                         case 'sha1-96':
 201                                         default:
 202                                                 $this->hash = 'sha1';
 203                                 }
 204                                 return;
 205                 }
 206
 207                 switch ($hash)
 208                 {
 209                         case 'md5':
 210                         case 'md5-96':
 211                                  $this->b = 64;
 212                                  $this->hash = 'md5';
 213                                  break;
 214                         case 'sha1':
 215                         case 'sha1-96':
 216                         default:
 217                                  $this->b = 64;
 218                                  $this->hash = 'sha1';
 219                 }
 220
 221                 $this->ipad = str_repeat(chr(0x36), $this->b);
 222                 $this->opad = str_repeat(chr(0x5C), $this->b);
 223         }
 224
 225         /**
 226          * Compute the HMAC.
 227          *
 228          * @access public
 229          * @param String $text
 230          */
 231         function create($text)
 232         {
 233                 if (!empty($this->key))
 234                 {
 235                         switch (CRYPT_HASH_MODE)
 236                         {
 237                                 case CRYPT_HASH_MODE_MHASH:
 238                                         $output = mhash($this->hash, $text, $this->key);
 239                                         break;
 240                                 case CRYPT_HASH_MODE_HASH:
 241                                         $output = hash_hmac($this->hash, $text, $this->key, true);
 242                                         break;
 243                                 case CRYPT_HASH_MODE_INTERNAL:
 244                                         $hash = $this->hash;
 245                                         /* "Applications that use keys longer than B bytes will first hash the key using H and then use the
 246                                                 resultant L byte string as the actual key to HMAC."
 247
 248                                                 -- http://tools.ietf.org/html/rfc2104#section-2 */
 249                                         $key = strlen($this->key) > $this->b ? $hash($this->key) : $this->key;
 250
 251                                         $key    = str_pad($key, $this->b, chr(0));// step 1
 252                                         $temp   = $this->ipad ^ $key;                    // step 2
 253                                         $temp  .= $text;                                                  // step 3
 254                                         $temp   = pack('H*', $hash($temp));        // step 4
 255                                         $output = $this->opad ^ $key;                    // step 5
 256                                         $output.= $temp;                                                  // step 6
 257                                         $output = pack('H*', $hash($output));    // step 7
 258                         }
 259                 }
 260                 else
 261                 {
 262                         switch (CRYPT_HASH_MODE)
 263                         {
 264                                 case CRYPT_HASH_MODE_MHASH:
 265                                         $output = mhash($this->hash, $text);
 266                                         break;
 267                                 case CRYPT_HASH_MODE_MHASH:
 268                                         $output = hash($this->hash, $text, true);
 269                                         break;
 270                                 case CRYPT_HASH_MODE_INTERNAL:
 271                                         $hash = $this->hash;
 272                                         $output = pack('H*', $hash($output));
 273                         }
 274                 }
 275
 276                 return substr($output, 0, $this->l);
 277         }
 278 }