Location: PHPKode > projects > phpMyOrdering > phpMyOrdering-0.1.7-alpha/phpMyPurchasing-0.1.2-alpha/scripts/classes/class.encryption.php
<?PHP

/*
 * phpMyAuth
 * Jason Gerfen [hide@address.com]
 *
 * class.encryption.php - Handle encryption functionality
 */

class Encryption
{

 private $data;

 function ReadFolder( $folder )
 {
  if( empty( $folder ) ) {
   $this->data = -1;
  } else {
   $rand_image = array();
   if( $handle = opendir( $folder ) ) {
    while( false !== ( $file = readdir( $handle ) ) ) {
     if( ( $file != "." ) && ( $file != ".." ) && ( $file != "index.html" ) && ( !is_dir( $file ) ) ) {
      $this->value[] = $file;
     }
    }
    closedir( $handle );
   }
  }
  return $this->value;
 }

 function MakeSuperRandom()
 {
  return srand( ( double ) microtime( time() ) * 100000 );
 }

 function PickRandomImages( $array )
 {
  $num1 = count( $array );
  $num1 = $num1 - 1;
  $this->MakeSuperRandom();

  $img_num = rand( 3, $num1 );
  $this->data[] = $array[$img_num];

  $num2 = count( $array );
  $num2 = $num2 - 1;
  $this->MakeSuperRandom();

  $img_num = rand( 3, $num2 );
  $this->data[] = $array[$img_num];

  $num3 = count( $array );
  $num3 = $num3 - 1;
  $this->MakeSuperRandom();

  $img_num = rand( 3, $num3 );
  $this->data[] = $array[$img_num];
  return $this->data;
 }

 function GeneratePrivKey( $array )
 {
  if( empty( $array ) ) {
   $this->data = -1;
  } else {
   for( $x = 0; $x < count( $array ); $x++ ) {
    if( function_exists( "mhash" ) ) {
     $keys[] = mhash( MHASH_SHA1, sha1( $array[$x] ) );
    } elseif( function_exists( sha1 ) ) {
     $keys[] = sha1( sha1( $array[$x] ) );
    } else {
     $keys[] = md5( md5( $array[$x] ) );
    }
   }
   for( $y = 0; $y < count( $keys ); $y++ ) {
    if( count( $keys ) == $keys[$y] ) {
     $this->data .= $keys[$y];
    } else {
     $this->data .= $keys[$y] . ":";
    }
   }
  }
  return $this->data;
 }

 function GeneratePublicKey( $data )
 {
  return md5( $data );
 }

 function GeneratePrivateKey( $a )
 {
  $x = $this->ReadFolder( $a );
  $y = $this->PickRandomImages( $x );
  $this->data = $this->GeneratePrivKey( $y );
  return $this->data;
 }

 function EncodePrivToHex( $key )
 {
  return bin2hex( $key );
 }

 function DecodePrivToBin( $key )
 {
  $hexLenght = strlen( $key );
  if( $hexLenght % 2 != 0 || preg_match( "/[^\da-fA-F]/", $key ) ) { $binString = -1; }
  unset( $binString );
  for( $x = 1; $x <= $hexLenght/2; $x++ ) {
   $this->data .= chr( hexdec( substr( $key, 2 * $x - 2, 2 ) ) );
  }
  return $this->data;
 }

 function EncodeAuthTokenHeavy( $array, $iv, $time, $public, $server )
 {
  if( function_exists( "mcrypt_encrypt" ) ) {
   $cipher = new Cipher(MCRYPT_BLOWFISH, MCRYPT_MODE_ECB);
   // encrypt the username, password, level & group attributes (as base64_encoded values)
   $uname = base64_encode( $cipher->encrypt( $array[0]['txtUserName'], $public, $iv ) );
   $passwd = base64_encode( $cipher->encrypt( $array[0]['txtUserPassword1'], $public, $iv ) );
   $alevel = base64_encode( $cipher->encrypt( $array[0]['txtUserLevel'], $public, $iv ) );
   $agroup = base64_encode( $cipher->encrypt( $array[0]['txtUserGroup'], $public, $iv ) );
  } else {
   $uname = base64_encode( $array[0]['username'] );
   $passwd = base64_encode( $array[0]['password'] );
   $alevel = base64_encode( $array[0]['level'] );
   $agroup = base64_encode( $array[0]['group'] );
  }
  return $uname . "::" . $passwd . "::" . $alevel . "::" . $agroup . "::" . $time . "::" . md5( $server['REMOTE_ADDR'] ) . "::" . base64_encode( $_SERVER['HTTP_REFERER'] ) . "::" . md5( $server['HTTP_USER_AGENT'] ) . "::" . md5( $iv ) . "::" . $public;
 }

 function DecodeAuthTokenHeavy( $token )
 {
  $array = preg_split( "/::/", $token );
  if( function_exists( "mcrypt_encrypt" ) ) {
   $cipher = new Cipher(MCRYPT_BLOWFISH, MCRYPT_MODE_ECB);
   $array[0] = $cipher->decrypt( base64_decode( $array[0] ), $array[9], $array[8] );
   $array[1] = $cipher->decrypt( base64_decode( $array[1] ), $array[9], $array[8] );
   $array[2] = $cipher->decrypt( base64_decode( $array[2] ), $array[9], $array[8] );
   $array[3] = $cipher->decrypt( base64_decode( $array[3] ), $array[9], $array[8] );
  } else {
   $array[0] = base64_decode( $array[0] );
   $array[1] = base64_decode( $array[1] );
   $array[2] = base64_decode( $array[2] );
   $array[3] = base64_decode( $array[3] );
  }
  return $array;
 }

}

/**
* Cipher
*
* Simple mcrypt interface.
*
* Cipher is a simple class for working with mcrypt.
*
* @package     Cipher
* @author      Nathan Lucas <hide@address.com>
* @link        http://www.gimpstraw.com/
* @copyright   Copyright (c) 2008, Nathan Lucas
* @version     2.0.0
*
* Added $iv to both encrypt() and decrypt() allowing you to use preset IVs
* while encrypting/decrypting data.
*
* Also added getIV(), which returns the instance's current IV in base64
* allowing you to store this IV for use on other instances of Cipher.
*/
class Cipher {

    /**
     * Algorithm to use.
     *
     * @access  private
     * @var     string
     */
    private $algo;

    /**
     * Encryption mode.
     *
     * @access  private
     * @var     string
     */
    private $mode;
    
    /**
     * Randomization source.
     *
     * @access  private
     * @var     integer
     */
    private $source;

    /**
     * Initialization vector.
     *
     * @access  private
     * @var     string
     */
    private $iv = null;

    /**
     * Encryption key.
     *
     * @access  private
     * @var     string
     */
    private $key = null;


    /**
     * Cipher($algo, $mode, $source)
     *
     * Cipher constructor. Sets the algorithm being used, the encryption
     * mode, and the IV.
     *
     * @param   string $algo
     * @param   string $mode
     * @param   integer $source (randomization source)
     * @access  public
     * @return  void
     */
    public function __construct($algo = MCRYPT_3DES, $mode = MCRYPT_MODE_CBC, $source = MCRYPT_RAND) {
        $this->algo = $algo;
        $this->mode = $mode;
        $this->source = $source;
        
        if (is_null($this->algo) || (strlen($this->algo) == 0)) {
            $this->algo = MCRYPT_3DES;
        }
        if (is_null($this->mode) || (strlen($this->mode) == 0)) {
            $this->mode = MCRYPT_MODE_CBC;
        }
    }

    /**
     * encrypt($data, $key, $iv)
     *
     * Returns encrpyted $data, base64 encoded. $key must be specified at
     * least once, it can be changed at any point.
     *
     * @param   string $data
     * @param   mixed $key
     * @param   string $iv
     * @access  public
     * @return  string
     */
    public function encrypt($data, $key = null, $iv = null) {
        $key = (strlen($key) == 0) ? $key = null : $key;
        
        $this->setKey($key);
        $this->setIV($iv);
        
        $out = mcrypt_encrypt($this->algo, $this->key, $data, $this->mode, $this->iv);
        return base64_encode($out);
    }

    /**
     * decrypt($data, $key, $iv)
     *
     * Returns decrypted $data. $key must be specified at least once, it can
     * be changed at any point.
     *
     * @param   mixed $data
     * @param   mixed $key
     * @param   string $iv
     * @access  public
     * @return  string
     */
    public function decrypt($data, $key = null, $iv = null) {
        $key = (strlen($key) == 0) ? $key = null : $key;
        
        $this->setKey($key);
        $this->setIV($iv);

        $data = base64_decode($data);
        $out = mcrypt_decrypt($this->algo, $this->key, $data, $this->mode, $this->iv);
        return trim($out);
    }
    
    /**
     * getIV()
     *
     * Returns the IV used for encryption so you can use it again in another
     * Cipher instance to decrypt data.
     *
     * @access  public
     * @return  string
     */
    public function getIV() {
        return base64_encode($this->iv);
    }
    
    /**
     * setIV($iv)
     *
     * Sets IV. If $iv is specified, the instance IV will be set to this. If not,
     * the instance will generate an IV.
     *
     * @param   string $iv
     * @access  private
     * @return  void
     */
    public function setIV($iv) {
        if (!is_null($iv)) {
            $this->iv = base64_decode($iv);
        }
        if (is_null($this->iv)) {
            $iv_size = mcrypt_get_iv_size($this->algo, $this->mode);
            $this->iv = mcrypt_create_iv($iv_size, $this->source);
        }
    }

    /**
     * setKey($data, $key)
     *
     * Sets Cipher::key. This will be the key used for the encrypt and decrypt
     * methods until another $key is specified. This will trigger an error if
     * no initial key is set.
     *
     * @param   mixed $key
     * @access  private
     * @return  void
     */
    private function setKey($key) {
        if (!is_null($key)) {
            $key_size = mcrypt_get_key_size($this->algo, $this->mode);
            $this->key = hash("sha256", $key, true);
            $this->key = substr($this->key, 0, $key_size);
        }
        if (is_null($this->key)) {
            trigger_error("You must specify a key at least once in either Cipher::encrpyt() or Cipher::decrypt().", E_USER_ERROR);
        }
    }
} 

?>
Return current item: phpMyOrdering