ここの情報は古いです。ご理解頂いた上でお取り扱いください。

Changeset 252


Ignore:
Timestamp:
Sep 26, 2006, 4:16:59 PM (14 years ago)
Author:
ogawa
Message:

Crypt_Blowfish version 1.1.0RC1

Location:
OpenPNE/trunk
Files:
7 added
5 edited

Legend:

Unmodified
Added
Removed
  • OpenPNE/trunk/config.php.sample

    r241 r252  
    5050// -1   : URL変更お知らせ画面を表示、自動的に移動しない
    5151define('WAIT_REDIRECT_TIME', 5);
     52
     53// Crypt_Blowfish ライブラリの旧バージョン使用設定
     54//2.2以前からのアップグレードで暗号化まわりで不具合が起こった場合はtrueに設定
     55define('OPENPNE_USE_OLD_CRYPT_BLOWFISH', false);
    5256
    5357// ファンクションキャッシュ使用設定
  • OpenPNE/trunk/lib/include/Crypt/Blowfish.php

    r2 r252  
    44/**
    55 * Crypt_Blowfish allows for encryption and decryption on the fly using
    6  * the Blowfish algorithm. Crypt_Blowfish does not require the mcrypt
    7  * PHP extension, it uses only PHP.
    8  * Crypt_Blowfish support encryption/decryption with or without a secret key.
     6 * the Blowfish algorithm. Crypt_Blowfish does not require the MCrypt
     7 * PHP extension, but uses it if available, otherwise it uses only PHP.
     8 * Crypt_Blowfish supports encryption/decryption with or without a secret key.
    99 *
    1010 *
     
    2222 * @copyright  2005 Matthew Fonda
    2323 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
    24  * @version    CVS: $Id: Blowfish.php,v 1.81 2005/05/30 18:40:36 mfonda Exp $
     24 * @version    CVS: $Id: Blowfish.php,v 1.85 2006/05/29 17:16:43 jausions Exp $
    2525 * @link       http://pear.php.net/package/Crypt_Blowfish
    2626 */
    2727
    28 
     28/**
     29 * Required PEAR package(s)
     30 */
    2931require_once 'PEAR.php';
    3032
    31 
    32 /**
    33  *
    34  * Example usage:
    35  * $bf = new Crypt_Blowfish('some secret key!');
     33/**
     34 * Engine choice constants
     35 */
     36/**
     37 * To let the Crypt_Blowfish package decide which engine to use
     38 * @since 1.1.0
     39 */
     40define('CRYPT_BLOWFISH_AUTO',   1);
     41/**
     42 * To use the MCrypt PHP extension.
     43 * @since 1.1.0
     44 */
     45define('CRYPT_BLOWFISH_MCRYPT', 2);
     46/**
     47 * To use the PHP-only engine.
     48 * @since 1.1.0
     49 */
     50define('CRYPT_BLOWFISH_PHP',    3);
     51
     52
     53/**
     54 * Example using the factory method in CBC mode
     55 * <code>
     56 * $bf =& Crypt_Blowfish::factory('cbc');
     57 * if (PEAR::isError($bf)) {
     58 *     echo $bf->getMessage();
     59 *     exit;
     60 * }
     61 * $iv = 'abc123+=';
     62 * $key = 'My secret key';
     63 * $bf->setKey($key, $iv);
    3664 * $encrypted = $bf->encrypt('this is some example plain text');
     65 * $bf->setKey($key, $iv);
    3766 * $plaintext = $bf->decrypt($encrypted);
    38  * echo "plain text: $plaintext";
    39  *
     67 * if (PEAR::isError($plaintext)) {
     68 *     echo $plaintext->getMessage();
     69 *     exit;
     70 * }
     71 * // Encrypted text is padded prior to encryption
     72 * // so you may need to trim the decrypted result.
     73 * echo 'plain text: ' . trim($plaintext);
     74 * </code>
     75 *
     76 * To disable using the mcrypt library, define the CRYPT_BLOWFISH_NOMCRYPT
     77 * constant. This is useful for instance on Windows platform with a buggy
     78 * mdecrypt_generic() function.
     79 * <code>
     80 * define('CRYPT_BLOWFISH_NOMCRYPT', true);
     81 * </code>
    4082 *
    4183 * @category   Encryption
    4284 * @package    Crypt_Blowfish
    4385 * @author     Matthew Fonda <mfonda@php.net>
    44  * @copyright  2005 Matthew Fonda
     86 * @author     Philippe Jausions <jausions@php.net>
     87 * @copyright  2005-2006 Matthew Fonda
    4588 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
    4689 * @link       http://pear.php.net/package/Crypt_Blowfish
    47  * @version    1.0.1
     90 * @version    1.1.0RC1
    4891 * @access     public
    4992 */
     
    5194{
    5295    /**
    53      * P-Array contains 18 32-bit subkeys
    54      *
    55      * @var array
     96     * Implementation-specific Crypt_Blowfish object
     97     *
     98     * @var object
    5699     * @access private
    57100     */
    58     var $_P = array();
    59    
    60    
    61     /**
    62      * Array of four S-Blocks each containing 256 32-bit entries
    63      *
    64      * @var array
    65      * @access private
    66      */
    67     var $_S = array();
    68 
    69     /**
    70      * Mcrypt td resource
    71      *
    72      * @var resource
    73      * @access private
    74      */
    75     var $_td = null;
     101    var $_crypt = null;
    76102
    77103    /**
     
    79105     *
    80106     * @var string
    81      * @access private
     107     * @access protected
    82108     */
    83109    var $_iv = null;
    84110
    85    
     111    /**
     112     * Holds block size
     113     *
     114     * @var integer
     115     * @access protected
     116     */
     117    var $_block_size = 8;
     118
     119    /**
     120     * Holds IV size
     121     *
     122     * @var integer
     123     * @access protected
     124     */
     125    var $_iv_size = 8;
     126
     127    /**
     128     * Holds max key size
     129     *
     130     * @var integer
     131     * @access protected
     132     */
     133    var $_key_size = 56;
     134
    86135    /**
    87136     * Crypt_Blowfish Constructor
    88      * Initializes the Crypt_Blowfish object, and gives a sets
     137     * Initializes the Crypt_Blowfish object (in EBC mode), and sets
    89138     * the secret key
    90139     *
    91140     * @param string $key
    92141     * @access public
     142     * @deprecated Since 1.1.0
     143     * @see Crypt_Blowfish::factory()
    93144     */
    94145    function Crypt_Blowfish($key)
    95146    {
    96         if (extension_loaded('mcrypt')) {
    97             $this->_td = mcrypt_module_open(MCRYPT_BLOWFISH, '', 'ecb', '');
    98             $this->_iv = mcrypt_create_iv(8, MCRYPT_RAND);
     147        $this->_crypt =& Crypt_Blowfish::factory('ecb', $key);
     148        if (!PEAR::isError($this->_crypt)) {
     149            $this->_crypt->setKey($key);
    99150        }
    100         $this->setKey($key);
    101     }
    102    
     151    }
     152
     153    /**
     154     * Crypt_Blowfish object factory
     155     *
     156     * This is the recommended method to create a Crypt_Blowfish instance.
     157     *
     158     * When using CRYPT_BLOWFISH_AUTO, you can force the package to ignore
     159     * the MCrypt extension, by defining CRYPT_BLOWFISH_NOMCRYPT.
     160     *
     161     * @param string $mode operating mode 'ecb' or 'cbc' (case insensitive)
     162     * @param string $key
     163     * @param string $iv initialization vector (must be provided for CBC mode)
     164     * @param integer $engine one of CRYPT_BLOWFISH_AUTO, CRYPT_BLOWFISH_PHP
     165     *                or CRYPT_BLOWFISH_MCRYPT
     166     * @return object Crypt_Blowfish object or PEAR_Error object on error
     167     * @access public
     168     * @static
     169     * @since 1.1.0
     170     */
     171    function &factory($mode = 'ecb', $key = null, $iv = null, $engine = CRYPT_BLOWFISH_AUTO)
     172    {
     173        switch ($engine) {
     174            case CRYPT_BLOWFISH_AUTO:
     175                if (!defined('CRYPT_BLOWFISH_NOMCRYPT')
     176                    && extension_loaded('mcrypt')) {
     177                    $engine = CRYPT_BLOWFISH_MCRYPT;
     178                } else {
     179                    $engine = CRYPT_BLOWFISH_PHP;
     180                }
     181                break;
     182            case CRYPT_BLOWFISH_MCRYPT:
     183                if (!PEAR::loadExtension('mcrypt')) {
     184                    return PEAR::raiseError('MCrypt extension is not available.');
     185                }
     186                break;
     187        }
     188
     189        switch ($engine) {
     190            case CRYPT_BLOWFISH_PHP:
     191                $mode = strtoupper($mode);
     192                $class = 'Crypt_Blowfish_' . $mode;
     193                include_once 'Crypt/Blowfish/' . $mode . '.php';
     194                $crypt = new $class(null);
     195                break;
     196
     197            case CRYPT_BLOWFISH_MCRYPT:
     198                include_once 'Crypt/Blowfish/MCrypt.php';
     199                $crypt = new Crypt_Blowfish_MCrypt(null, $mode);
     200                break;
     201        }
     202
     203        if (!is_null($key) || !is_null($iv)) {
     204            $result = $crypt->setKey($key, $iv);
     205            if (PEAR::isError($result)) {
     206                return $result;
     207            }
     208        }
     209
     210        return $crypt;
     211    }
     212
     213    /**
     214     * Returns the algorithm's block size
     215     *
     216     * @return integer
     217     * @access public
     218     * @since 1.1.0
     219     */
     220    function getBlockSize()
     221    {
     222        return $this->_block_size;
     223    }
     224
     225    /**
     226     * Returns the algorithm's IV size
     227     *
     228     * @return integer
     229     * @access public
     230     * @since 1.1.0
     231     */
     232    function getIVSize()
     233    {
     234        return $this->_iv_size;
     235    }
     236
     237    /**
     238     * Returns the algorithm's maximum key size
     239     *
     240     * @return integer
     241     * @access public
     242     * @since 1.1.0
     243     */
     244    function getMaxKeySize()
     245    {
     246        return $this->_key_size;
     247    }
     248
    103249    /**
    104250     * Deprecated isReady method
     
    112258        return true;
    113259    }
    114    
     260
    115261    /**
    116262     * Deprecated init method - init is now a private
     
    120266     * @access public
    121267     * @deprecated
    122      * @see Crypt_Blowfish::_init()
    123268     */
    124269    function init()
    125270    {
    126         $this->_init();
    127     }
    128    
    129     /**
    130      * Initializes the Crypt_Blowfish object
    131      *
    132      * @access private
    133      */
    134     function _init()
    135     {
    136         $defaults = new Crypt_Blowfish_DefaultKey();
    137         $this->_P = $defaults->P;
    138         $this->_S = $defaults->S;
    139     }
    140            
    141     /**
    142      * Enciphers a single 64 bit block
    143      *
    144      * @param int &$Xl
    145      * @param int &$Xr
    146      * @access private
    147      */
    148     function _encipher(&$Xl, &$Xr)
    149     {
    150         for ($i = 0; $i < 16; $i++) {
    151             $temp = $Xl ^ $this->_P[$i];
    152             $Xl = ((($this->_S[0][($temp>>24) & 255] +
    153                             $this->_S[1][($temp>>16) & 255]) ^
    154                             $this->_S[2][($temp>>8) & 255]) +
    155                             $this->_S[3][$temp & 255]) ^ $Xr;
    156             $Xr = $temp;
    157         }
    158         $Xr = $Xl ^ $this->_P[16];
    159         $Xl = $temp ^ $this->_P[17];
    160     }
    161    
    162    
    163     /**
    164      * Deciphers a single 64 bit block
    165      *
    166      * @param int &$Xl
    167      * @param int &$Xr
    168      * @access private
    169      */
    170     function _decipher(&$Xl, &$Xr)
    171     {
    172         for ($i = 17; $i > 1; $i--) {
    173             $temp = $Xl ^ $this->_P[$i];
    174             $Xl = ((($this->_S[0][($temp>>24) & 255] +
    175                             $this->_S[1][($temp>>16) & 255]) ^
    176                             $this->_S[2][($temp>>8) & 255]) +
    177                             $this->_S[3][$temp & 255]) ^ $Xr;
    178             $Xr = $temp;
    179         }
    180         $Xr = $Xl ^ $this->_P[1];
    181         $Xl = $temp ^ $this->_P[0];
    182     }
    183    
    184    
     271        return $this->_crypt->init();
     272    }
     273
    185274    /**
    186275     * Encrypts a string
    187276     *
    188      * @param string $plainText
    189      * @return string Returns cipher text on success, PEAR_Error on failure
     277     * Value is padded with NUL characters prior to encryption. You may
     278     * need to trim or cast the type when you decrypt.
     279     *
     280     * @param string $plainText the string of characters/bytes to encrypt
     281     * @return string|PEAR_Error Returns cipher text on success, PEAR_Error on failure
    190282     * @access public
    191283     */
    192284    function encrypt($plainText)
    193285    {
    194         if (!is_string($plainText)) {
    195             PEAR::raiseError('Plain text must be a string', 0, PEAR_ERROR_DIE);
    196         }
    197 
    198         if (extension_loaded('mcrypt')) {
    199             return mcrypt_generic($this->_td, $plainText);
    200         }
    201 
    202         $cipherText = '';
    203         $len = strlen($plainText);
    204         $plainText .= str_repeat(chr(0),(8 - ($len%8))%8);
    205         for ($i = 0; $i < $len; $i += 8) {
    206             list(,$Xl,$Xr) = unpack("N2",substr($plainText,$i,8));
    207             $this->_encipher($Xl, $Xr);
    208             $cipherText .= pack("N2", $Xl, $Xr);
    209         }
    210         return $cipherText;
    211     }
    212    
    213    
     286        return $this->_crypt->encrypt($plainText);
     287    }
     288
     289
    214290    /**
    215291     * Decrypts an encrypted string
    216292     *
    217      * @param string $cipherText
    218      * @return string Returns plain text on success, PEAR_Error on failure
     293     * The value was padded with NUL characters when encrypted. You may
     294     * need to trim the result or cast its type.
     295     *
     296     * @param string $cipherText the binary string to decrypt
     297     * @return string|PEAR_Error Returns plain text on success, PEAR_Error on failure
    219298     * @access public
    220299     */
    221300    function decrypt($cipherText)
    222301    {
    223         if (!is_string($cipherText)) {
    224             PEAR::raiseError('Chiper text must be a string', 1, PEAR_ERROR_DIE);
    225         }
    226 
    227         if (extension_loaded('mcrypt')) {
    228             return mdecrypt_generic($this->_td, $cipherText);
    229         }
    230 
    231         $plainText = '';
    232         $len = strlen($cipherText);
    233         $cipherText .= str_repeat(chr(0),(8 - ($len%8))%8);
    234         for ($i = 0; $i < $len; $i += 8) {
    235             list(,$Xl,$Xr) = unpack("N2",substr($cipherText,$i,8));
    236             $this->_decipher($Xl, $Xr);
    237             $plainText .= pack("N2", $Xl, $Xr);
    238         }
    239         return $plainText;
    240     }
    241    
    242    
     302        return $this->_crypt->decrypt($cipherText);
     303    }
     304
    243305    /**
    244306     * Sets the secret key
    245307     * The key must be non-zero, and less than or equal to
    246      * 56 characters in length.
     308     * 56 characters (bytes) in length.
     309     *
     310     * If you are making use of the PHP MCrypt extension, you must call this
     311     * method before each encrypt() and decrypt() call.
    247312     *
    248313     * @param string $key
    249      * @return bool  Returns true on success, PEAR_Error on failure
     314     * @return boolean|PEAR_Error  Returns TRUE on success, PEAR_Error on failure
    250315     * @access public
    251316     */
    252317    function setKey($key)
    253318    {
    254         if (!is_string($key)) {
    255             PEAR::raiseError('Key must be a string', 2, PEAR_ERROR_DIE);
    256         }
    257 
    258         $len = strlen($key);
    259 
    260         if ($len > 56 || $len == 0) {
    261             PEAR::raiseError('Key must be less than 56 characters and non-zero. Supplied key length: ' . $len, 3, PEAR_ERROR_DIE);
    262         }
    263 
    264         if (extension_loaded('mcrypt')) {
    265             mcrypt_generic_init($this->_td, $key, $this->_iv);
    266             return true;
    267         }
    268 
    269         require_once 'Crypt/Blowfish/DefaultKey.php';
    270         $this->_init();
    271        
    272         $k = 0;
    273         $data = 0;
    274         $datal = 0;
    275         $datar = 0;
    276        
    277         for ($i = 0; $i < 18; $i++) {
    278             $data = 0;
    279             for ($j = 4; $j > 0; $j--) {
    280                     $data = $data << 8 | ord($key{$k});
    281                     $k = ($k+1) % $len;
    282             }
    283             $this->_P[$i] ^= $data;
    284         }
    285        
    286         for ($i = 0; $i <= 16; $i += 2) {
    287             $this->_encipher($datal, $datar);
    288             $this->_P[$i] = $datal;
    289             $this->_P[$i+1] = $datar;
    290         }
    291         for ($i = 0; $i < 256; $i += 2) {
    292             $this->_encipher($datal, $datar);
    293             $this->_S[0][$i] = $datal;
    294             $this->_S[0][$i+1] = $datar;
    295         }
    296         for ($i = 0; $i < 256; $i += 2) {
    297             $this->_encipher($datal, $datar);
    298             $this->_S[1][$i] = $datal;
    299             $this->_S[1][$i+1] = $datar;
    300         }
    301         for ($i = 0; $i < 256; $i += 2) {
    302             $this->_encipher($datal, $datar);
    303             $this->_S[2][$i] = $datal;
    304             $this->_S[2][$i+1] = $datar;
    305         }
    306         for ($i = 0; $i < 256; $i += 2) {
    307             $this->_encipher($datal, $datar);
    308             $this->_S[3][$i] = $datal;
    309             $this->_S[3][$i+1] = $datar;
    310         }
    311        
    312         return true;
    313     }
    314    
     319        return $this->_crypt->setKey($key);
     320    }
    315321}
    316322
  • OpenPNE/trunk/lib/include/Crypt/Blowfish/DefaultKey.php

    r2 r252  
    3636 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
    3737 * @link       http://pear.php.net/package/Crypt_Blowfish
    38  * @version    1.0.1
     38 * @version    1.1.0RC1
    3939 * @access     public
    4040 */
  • OpenPNE/trunk/webapp/lib/OpenPNE/Config.php

    r221 r252  
    149149            'OPENPNE_USE_FLASH_LIST' => true,
    150150            'OPENPNE_USE_COMMU_MAP' => true,
     151            'OPENPNE_USE_OLD_CRYPT_BLOWFISH' => false,
    151152        // 固定値
    152153            'AMAZON_TOKEN'   => '1WZYY1W9YF49AGM0RTG2',
  • OpenPNE/trunk/webapp/lib/util/util.php

    r116 r252  
    237237    static $singleton;
    238238    if (empty($singleton)) {
    239         include_once 'Crypt/Blowfish.php';
    240         $singleton = new Crypt_Blowfish(ENCRYPT_KEY);
     239        if (OPENPNE_USE_OLD_CRYPT_BLOWFISH) {
     240            include_once 'Crypt/BlowfishOld.php';
     241            $singleton = new Crypt_BlowfishOld(ENCRYPT_KEY);
     242        } else {
     243            include_once 'Crypt/Blowfish.php';
     244            $singleton = new Crypt_Blowfish(ENCRYPT_KEY);
     245        }
    241246    }
    242247    return $singleton;
Note: See TracChangeset for help on using the changeset viewer.