home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 April / PCWorld_2005-04_cd.bin / akce / web / phptriad / phptriad2-2-1.exe / php / pear / Crypt / HCEMD5.php < prev   
PHP Script  |  2001-08-02  |  10KB  |  289 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP version 4.0                                                      |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2001 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.02 of the PHP license,      |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Authors: Manon Goo <manon@passionet.de>                              |
  17. // |          Chuck Hagenbuch <chuck@horde.org>                           |
  18. // +----------------------------------------------------------------------+
  19.  
  20. /**
  21. * Class to emulate Perl's Crypt::HCE_MD5 module
  22. * 
  23. * The MIME Functions are tested and work symmetrically with the
  24. * Crypt::HCE_MD5 package (0.45) (without the KEYBUG Flag ..).
  25. * 
  26. * Shamelessly stolen from Eric Estabrooks, eric@urbanrage.com
  27. * Crypt::HCE_MD5 package:
  28. * 
  29. * This package implements a chaining block cipher using a one way
  30. * hash. This method of encryption is the same that is used by radius
  31. * (RFC2138) and is also described in Applied Cryptography by Bruce
  32. * Schneider (p. 353 / "Karn").
  33. * 
  34. * Two interfaces are provided in the package. The first is straight
  35. * block encryption/decryption the second does base64 mime
  36. * encoding/decoding of the encrypted/decrypted blocks.
  37. * 
  38. * The idea is the the two sides have a shared secret that supplies one
  39. * of the keys and a randomly generated block of bytes provides the
  40. * second key. The random key is passed in cleartext between the two
  41. * sides.
  42. * 
  43. * Usage:
  44. * require_once 'Crypt/HCEMD5.php';
  45. * $key = 'my secret key';
  46. * srand((double)microtime()*32767);
  47. * $rand = rand(1, 32767);
  48. * $rand = pack('i*', $rand);
  49. * $message = 'text to encrypt';
  50. * $hcemd5 = new Crypt_HCEMD5($key, $rand);
  51. * 
  52. * // These Functions work with mime decoded Data
  53. * $ciphertext = $hcemd5->encodeMime($message);
  54. * $cleartext = $hcemd5->decodeMime($ciphertext);
  55. * 
  56. * // These Functions work with binary Data
  57. * $ciphertext = $hcemd5->encrypt($message);
  58. * $cleartext = $hcemd5->decrypt($ciphertext);
  59. * 
  60. * // These Functions work with mime decoded Data the selfrand
  61. * // functions put the random value infront of the encrypted data to
  62. * // be restored later
  63. * $ciphertext = $hcemd5->encodeMimeSelfRand($message);
  64. * $new_hcemd5 = new Crypt_HCEMD5($key, '');
  65. * $cleartext = $new_hcemd5->DecodeMimeSelfRand($ciphertext);
  66. *
  67. * @version $Id: HCEMD5.php,v 1.6 2001/08/02 15:23:00 alexmerz Exp $
  68. * @access public
  69. * @package Crypt
  70. */
  71. class Crypt_HCEMD5 {
  72.     
  73.     /**
  74.      * The first key to use. This should be a shared secret.
  75.      * @var string
  76.      */
  77.     var $key;
  78.     
  79.     /**
  80.      * The second key to use. This should be a randomly generated
  81.      * block of bytes.
  82.      * @var long
  83.      */
  84.     var $rand;
  85.     
  86.     
  87.     /**
  88.      * Creates a Crypt_HCEMD5 object.
  89.      *
  90.      * @param string The shared secret key
  91.      * @param long   (optional) The randomly generated key
  92.      *
  93.      * @access public
  94.      */
  95.     function Crypt_HCEMD5($key, $rand = null) {
  96.         $this->key = $key;
  97.         
  98.         if (!isset($rand)) {
  99.             srand((double)microtime() * 32767);
  100.             $rand = rand(1, 32767);
  101.             $rand = pack('i*', $rand);
  102.         }
  103.         $this->rand = $rand;
  104.     }
  105.     
  106.     
  107.     /**
  108.      * Encrypt a block of data.
  109.      *
  110.      * @param string The data to encrypt.
  111.      * @return string The encrypted binary data.
  112.      * @access public
  113.      */
  114.     function encrypt($data)
  115.     {
  116.         $data = unpack('C*', $data);
  117.         $ans = array();
  118.         $ans1 = array(); 
  119.         $eblock = 1;
  120.         $e_block = $this->newKey($this->rand);
  121.         $data_size = count($data);
  122.         for ($i = 0; $i < $data_size; $i++) {
  123.             $mod = $i % 16;
  124.             if (($mod == 0) && ($i > 15)) {
  125.                    $tmparr = array($ans[$i - 15],  $ans[$i - 14], $ans[$i - 13], $ans[$i - 12], $ans[$i - 11], $ans[$i - 10], $ans[$i - 9], $ans[$i - 8], $ans[$i - 7], $ans[$i - 6], $ans[$i - 5], $ans[$i - 4], $ans[$i - 3], $ans[$i - 2], $ans[$i - 1], $ans[$i] );
  126.                 $tmparr = $this->array2pack($tmparr);
  127.                 $tmparr = implode('', $tmparr);
  128.                 $e_block = $this->newKey($tmparr);
  129.             }
  130.             
  131.             $mod++;
  132.             $i++;
  133.             $ans[$i] = $e_block[$mod] ^ $data[$i];
  134.             $ans1[$i] = pack('C*', $ans[$i]);
  135.             $i--;
  136.             $mod--;
  137.         }
  138.         return implode('', $ans1);
  139.     }
  140.     
  141.     /**
  142.      * Decrypt a block of data.
  143.      *
  144.      * @param string The data to decrypt.
  145.      * @return string The decrypted binary data.
  146.      * @access public
  147.      */
  148.     function decrypt($data)
  149.     {
  150.         $data = unpack('C*', $data);
  151.         $ans = array();
  152.         $ans1 = array(); 
  153.         $eblock = 1;
  154.         $e_block = $this->newKey($this->rand);
  155.         $data_size = count($data);
  156.         for ($i = 0; $i < $data_size; $i++) {
  157.             $mod = $i % 16;
  158.             if (($mod == 0) && ($i > 15)) {
  159.                    $tmparr = array($data[$i - 15], $data[$i - 14], $data[$i - 13], $data[$i - 12], $data[$i - 11], $data[$i - 10], $data[$i - 9], $data[$i - 8], $data[$i - 7], $data[$i - 6], $data[$i - 5], $data[$i - 4], $data[$i - 3], $data[$i - 2], $data[$i - 1], $data[$i]);
  160.                 $tmparr = $this->array2pack($tmparr);
  161.                 $tmparr = implode('', $tmparr);
  162.                 $e_block = $this->newKey($tmparr);
  163.             }
  164.             
  165.             $mod++;
  166.             $i++;
  167.             $ans[$i] = $e_block[$mod] ^ $data[$i];
  168.             $ans1[$i] = pack('C*', $ans[$i]);
  169.             $i--;
  170.         }
  171.         return implode('', $ans1);
  172.     }
  173.     
  174.     /**
  175.      * Encrypt a block of data after MIME-encoding it.
  176.      *
  177.      * @param string The data to encrypt.
  178.      * @return string The encrypted mime-encoded data.
  179.      * @access public
  180.      */
  181.     function encodeMime($data)
  182.     {
  183.         return base64_encode($this->encrypt($data));
  184.     }
  185.     
  186.     /**
  187.      * Decrypt a block of data and then MIME-decode it.
  188.      *
  189.      * @param string The data to decrypt.
  190.      * @return string The decrypted mime-decoded data.
  191.      * @access public
  192.      */
  193.     function decodeMime($data)
  194.     {
  195.         return $this->decrypt(base64_decode($data));
  196.     }
  197.     
  198.     /**
  199.      * Encrypt a block of data after MIME-encoding it, and include the
  200.      * random hash in the final output in plaintext so it can be
  201.      * retrieved and decrypted with only the secret key by
  202.      * decodeMimeSelfRand().
  203.      *
  204.      * @param string The data to encrypt.
  205.      * @param string The encrypted mime-encoded data, in the format: randkey#encrypted_data.
  206.      * @access public
  207.      */
  208.     function encodeMimeSelfRand($data) {
  209.         return base64_encode($this->rand) . '#' . $this->encodeMime($data);
  210.     }
  211.     
  212.     /**
  213.      * Decrypt a block of data and then MIME-decode it, using the
  214.      * random key stored in beginning of the ciphertext generated by
  215.      * encodeMimeSelfRand().
  216.      *
  217.      * @param string The data to decrypt, in the format: randkey#encrypted_data.
  218.      * @return string The decrypted, mime-decoded data.
  219.      * @access public
  220.      */
  221.     function decodeMimeSelfRand($data)
  222.     {
  223.         if (strpos($data, '#') === false) {
  224.             return false;
  225.         }
  226.         
  227.         list($rand, $data_crypt) = explode('#', $data);
  228.         if (isset($data_crypt)) {
  229.             $rand = base64_decode($rand);
  230.             $this->rand = $rand;
  231.             return $this->decodeMime($data_crypt);
  232.         } else {
  233.             return false;
  234.         }
  235.     }
  236.     
  237.     
  238.     /**
  239.      ** Support Functions
  240.      **/
  241.     
  242.     /**
  243.      * Implment md5 hashing in php, though use the mhash() function if it is available.
  244.      *
  245.      * @param string The string to hash.
  246.      * @return string The md5 mhash of the string.
  247.      * @access private
  248.      */
  249.     function binmd5($string)
  250.     {
  251.         if (extension_loaded('mhash')) {
  252.             return mhash(MHASH_MD5, $string);
  253.         }
  254.         
  255.         return pack('H*', md5(pack('H*', preg_replace('|00$|', '', bin2hex($string)))));
  256.     }
  257.     
  258.     /**
  259.      * Turn an array into a binary packed string.
  260.      *
  261.      * @param array The array to pack.
  262.      * @return string The binary packed representation of the array.
  263.      * @access private
  264.      */
  265.     function array2pack($array)
  266.     {
  267.         $pack = array();
  268.         foreach ($array as $val) {
  269.             $pack[] = pack('C*', $val);
  270.         }
  271.         return $pack;
  272.     }
  273.     
  274.     /**
  275.      * Generate a new key for a new encryption block.
  276.      *
  277.      * @param string The basis for the key.
  278.      * @param string The new key.
  279.      * @access private
  280.      */
  281.     function newKey($round)
  282.     {
  283.         $digest = $this->binmd5($this->key . $round);
  284.         return unpack('C*', $digest);
  285.     }
  286.     
  287. }
  288. ?>
  289.