crypt.php

Go to the documentation of this file.

<?php
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

// {{{ Crypt

class Crypt {

    // {{{ Constants
    
    /* Returning modes */
    const MODE_BIN = 0;     // same length of the original data
    const MODE_B64 = 1;     // about 66% bigger
    const MODE_HEX = 2;     // exactly 100% bigger

    // }}}
    // {{{ Attributes

    private $_key  = __CLASS__;

    private $_mode = Crypt::MODE_HEX;

    // }}}
    // {{{ function __construct()

    function __construct($mode = null, $key = null) {
        is_null($mode) || ($this->Mode = $mode);
        is_null($key)  || ($this->Key  = $key);
    }

    // }}}
    // {{{ function __toString()

    function __toString() {
        return __CLASS__ . " object\n"
            . "(\n"
            . "    [Key]  => {$this->_key}\n"
            . "    [Mode] => {$this->_mode}\n"
            . ")\n";
    }

    // }}}
    // {{{ function __set()

    function __set($property, $value) {
        switch ($property) {
                    case 'Key' : return $this->_setKey($value);
            case 'Mode': return $this->_setMode($value);
        }
    }

    // }}}
    // {{{ function __get()

    function __get($property) {
        switch ($property) {
            case 'Key' : return $this->_key;
            case 'Mode': return $this->_mode;
        }
    }

    // }}}
    // {{{ public function encrypt()

    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_B64)
            return base64_encode(@$encrypt);
        if ($this->_mode === Crypt::MODE_HEX)
            return $this->_encodeHexadecimal(@$encrypt);
        return @$encrypt;
    }

    // }}}
    // {{{ public function decrypt()

    public function decrypt($crypt) {
        if ($this->_mode === Crypt::MODE_HEX)
            $crypt = $this->_decodeHexadecimal($crypt);
        if ($this->_mode === Crypt::MODE_B64)
            $crypt = (string)base64_decode($crypt);
        for ($i=0;$i<strlen($crypt);$i++)
            @$data .= $crypt[$i] ^ $this->_key[$i % strlen($this->_key)];
        return @$data;
    }

    // }}}
    // {{{ public static function supportedModes()

    public static function supportedModes() {
        return array(
            Crypt::MODE_BIN,
            Crypt::MODE_B64,
            Crypt::MODE_HEX
        );
    }

    // }}}
    // {{{ protected static function _isSupportedMode()

    public static function _isSupportedMode($mode) { 
        return in_array($mode, Crypt::supportedModes());
    }

    // }}}
    // {{{ protected function _setKey()

    protected function _setKey($key) {
        $this->_key = (string) $key;
    }

    // }}}
    // {{{ protected function _setMode()

    protected function _setMode($mode) {
        Crypt::_isSupportedMode($mode)
            && ($this->_mode = (int)$mode);
    }

    // }}}
    // {{{ protected function _encodeHexadecimal()

    protected function _encodeHexadecimal($data) {
        $data = (string) $data;
        for ($i=0;$i<strlen($data);$i++)
            @$hexcrypt .= str_pad(dechex(ord(
                $data[$i])), 2, 0, STR_PAD_LEFT);
        return @$hexcrypt;
    }

    // }}}
    // {{{ protected function _decodeHexadecimal()

    protected function _decodeHexadecimal($hexcrypt) {
        $hexcrypt = (string) $hexcrypt;
        for ($i=0;$i<strlen($hexcrypt);$i+=2)
            @$data .= chr(hexdec(substr($hexcrypt, $i, 2)));
        return @$data;
    }

    // }}}

}

// }}}
?>