<?php
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
/**
* PHP Version 5
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* {@link http://gnu.org/licenses/gpl.txt}
*/
// {{{ Constants
/* Mode constants */
define('CRYPT_MODE_BINARY' , 0);
define('CRYPT_MODE_BASE64' , 1);
define('CRYPT_MODE_HEXADECIMAL', 2);
/* Hash algorithms constants */
define('CRYPT_HASH_MD5' , 'md5');
define('CRYPT_HASH_SHA1', 'sha1');
// }}}
// {{{ Crypt
/**
* Crypt class
*
* The Crypt class provides an easy and secure way to encrypt, decrypt
* and hash data. It implements a cryptography method based on private
* keys. It traverses the data to be encrypted and applies the XOR
* operation against the values of the characters of the encryption key.
* The decryption employs the same operation, so you'll need the key
* used on encryptation process to recover your original data.
*
* NOTE: All documentation available for this package is written below.
* If you have any doubts or sugestions, feel free to contact me! :)
*
* @package Crypt Class
* @name Crypt
* @author Arthur Furlan <arthur.furlan@gmail.com>
* @copyright 2006 (c) - Arthur Furlan <arthur.furlan@gmail.com>
* @license GPL v3.0 {@link http://gnu.org/licenses/gpl.txt}
* @version 2.1
*
* @todo Improve class documentation
*/
class Crypt {
// {{{ Attributes
/**
* Private key used in the creation process of the encrypted strings.
* NOTE: This value should be as strange as possible :)
*
* @name $key
* @property $Key
* @access private
* @var string
*/
private $key = __CLASS__;
/**
* Set the returning mode for the encrypted strings.
*
* @name $mode
* @property $Mode
* @access private
* @var integer
*/
private $mode = CRYPT_MODE_BASE64;
/**
* Set the hash algorithm for hash strings.
*
* @name $hash
* @property $Hash
* @access private
* @var integer
*/
private $hash = CRYPT_HASH_MD5;
// }}}
// {{{ __construct()
/**
* Constructor method.
* Set the mode to be used in the new object.
*
* @name __construct()
* @access public
* @param [$mode] integer
* @param [$hash] integer
* @return void
*/
function __construct($mode = null, $hash = null) {
$this->SetMode($mode);
$this->SetHash($hash);
}
// }}}
// {{{ __toString()
/**
* Overload to the object conversion to string.
*
* @name __toString()
* @access public
* @method void
* @return string
*/
function __toString() {
return __CLASS__ . " object\n"
. "(\n"
. " [Key] => {$this->key}\n"
. " [Mode] => {$this->mode}\n"
. " [Hash] => {$this->hash}\n"
. ")\n";
}
// }}}
// {{{ __set()
/**
* Write methods for the class properties.
*
* @name __set()
* @access public
* @param $property string
* @param $value mixed
* @return void
*/
function __set($property, $value) {
switch ($property) {
case 'Key' : return $this->SetKey($value);
case 'Mode': return $this->SetMode($value);
case 'Hash': return $this->SetHash($value);
}
}
// }}}
// {{{ __get()
/**
* Read methods for the class properties.
*
* @name __get()
* @access public
* @param $property string
* @return mixed
*/
function __get($property) {
switch ($property) {
case 'Key' : return $this->key;
case 'Mode': return $this->mode;
case 'Hash': return $this->hash;
}
}
// }}}
// {{{ SetKey()
/**
* Set the private key used in the creation process of the
* encrypted strings.
*
* @name SetMode()
* @access protected
* @param $key string
* @return void
*/
protected function SetKey($key) {
$this->key = (string) $key;
}
// }}}
// {{{ SetMode()
/**
* Set the current returning mode of the class.
*
* @name SetMode()
* @access protected
* @param $mode integer
* @return void
*/
protected function SetMode($mode) {
Crypt::IsSupportedMode($mode) && $this->mode = (int)$mode;
}
// }}}
// {{{ SetHash()
/**
* Set the current hash algorithm of the class.
*
* @name SetHash()
* @access protected
* @param $hash integer
* @return void
*/
protected function SetHash($hash) {
Crypt::IsSupportedHash($hash) && $this->hash = (int)$hash;
}
// }}}
// {{{ SupportedModes()
/**
* Return the list of supported modes.
*
* @name SupportedModes()
* @access public
* @static
* @param void
* @return void
*/
public static function SupportedModes() {
return array(CRYPT_MODE_BINARY,
CRYPT_MODE_BASE64,
CRYPT_MODE_HEXADECIMAL);
}
// }}}
// {{{ SupportedHashes()
/**
* Return the list of supported hashes.
*
* @name SupportedHashes()
* @access public
* @static
* @param void
* @return void
*/
public static function SupportedHashes() {
return array(CRYPT_HASH_MD5,
CRYPT_HASH_SHA1);
}
// }}}
// {{{ IsSupportedMode()
/**
* Checks if $mode is a valid returning mode of the class.
*
* @name IsSupportedMode()
* @access public
* @static
* @param $mode integer
* @return void
*/
public static function IsSupportedMode($mode) {
return in_array($mode, Crypt::SupportedModes());
}
// }}}
// {{{ IsSupportedHash()
/**
* Checks if $hash is a valid hash algorithm of the class.
*
* @name IsSupportedHash()
* @access public
* @static
* @param $mode integer
* @return void
*/
public static function IsSupportedHash($hash) {
return in_array($hash, Crypt::SupportedHashes());
}
// }}}
// {{{ Encrypt()
/**
* Encrypt the data using the current returning mode.
*
* @name Encrypt()
* @access public
* @param $data mixed
* @return string
*/
public function Encrypt($data) {
$data = (string) $data;
for ($i=0;$i<strlen($data);$i++)
@$encrypt .= $data[$i] ^ $this->key[$i % strlen($this->key)];
if ($this->mode == CRYPT_MODE_BINARY)
return @$encrypt;
@$encrypt = base64_encode(@$encrypt);
if ($this->mode == CRYPT_MODE_BASE64)
return @$encrypt;
if ($this->mode == CRYPT_MODE_HEXADECIMAL)
return $this->EncodeHexadecimal(@$encrypt);
}
// }}}
// {{{ Decrypt()
/**
* Decrypt the data using the current returning mode.
* NOTE: You must use the same mode of the creation process.
*
* @name Decrypt()
* @access public
* @param $crypt string
* @return string
*/
public function Decrypt($crypt) {
if ($this->mode == CRYPT_MODE_HEXADECIMAL)
$crypt = $this->DecodeHexadecimal($crypt);
if ($this->mode != CRYPT_MODE_BINARY)
$crypt = (string)base64_decode($crypt);
for ($i=0;$i<strlen($crypt);$i++)
@$data .= $crypt[$i] ^ $this->key[$i % strlen($this->key)];
return @$data;
}
// }}}
// {{{ Hash()
/**
* Create a hash string using the algorithm defined in $hash.
*
* @name Hash()
* @access public
* @param $data mixed
* @param [$binary] bool
* @return string
*/
public function Hash($data, $binary = false) {
$crypt = new Crypt(CRYPT_MODE_BINARY);
$crypt->Key = $this->key;
return hash($this->hash, $crypt->Encrypt($data), (bool)$binary);
}
// }}}
// {{{ EncodeHexadecimal()
/**
* Encode the data using hexadecimal chars.
*
* @name EncodeHexadecimal()
* @access protected
* @param $data mixed
* @return string
*/
protected function EncodeHexadecimal($data) {
$data = (string) $data;
for ($i=0;$i<strlen($data);$i++)
@$hexcrypt .= dechex(ord($data[$i]));
return @$hexcrypt;
}
// }}}
// {{{ DecodeHexadecimal()
/**
* Decode hexadecimal strings.
*
* @name DecodeHexadecimal()
* @access protected
* @param $data string
* @return string
*/
protected function DecodeHexadecimal($hexcrypt) {
$hexcrypt = (string) $hexcrypt;
for ($i=0;$i<strlen($hexcrypt);$i+=2)
@$data .= chr(hexdec(substr($hexcrypt, $i, 2)));
return @$data;
}
// }}}
}
// }}}
?>
|
Download
