2 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
5 * Pure-PHP implementation of DES.
7 * Uses mcrypt, if available, and an internal implementation, otherwise.
11 * Useful resources are as follows:
13 * - {@link http://en.wikipedia.org/wiki/DES_supplementary_material Wikipedia: DES supplementary material}
14 * - {@link http://www.itl.nist.gov/fipspubs/fip46-2.htm FIPS 46-2 - (DES), Data Encryption Standard}
15 * - {@link http://www.cs.eku.edu/faculty/styer/460/Encrypt/JS-DES.html JavaScript DES Example}
17 * Here's a short example of how to use this library:
20 * include('Crypt/DES.php');
22 * $des = new Crypt_DES();
24 * $des->setKey('abcdefgh');
28 * for ($i = 0; $i < $size; $i++) {
32 * echo $des->decrypt($des->encrypt($plaintext));
36 * LICENSE: This library is free software; you can redistribute it and/or
37 * modify it under the terms of the GNU Lesser General Public
38 * License as published by the Free Software Foundation; either
39 * version 2.1 of the License, or (at your option) any later version.
41 * This library is distributed in the hope that it will be useful,
42 * but WITHOUT ANY WARRANTY; without even the implied warranty of
43 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
44 * Lesser General Public License for more details.
46 * You should have received a copy of the GNU Lesser General Public
47 * License along with this library; if not, write to the Free Software
48 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
53 * @author Jim Wigginton <terrafrost@php.net>
54 * @copyright MMVII Jim Wigginton
55 * @license http://www.gnu.org/licenses/lgpl.txt
56 * @version $Id: DES.php,v 1.12 2010/02/09 06:10:26 terrafrost Exp $
57 * @link http://phpseclib.sourceforge.net
62 * @see Crypt_DES::_prepareKey()
63 * @see Crypt_DES::_processBlock()
66 * Contains array_reverse($keys[CRYPT_DES_DECRYPT])
68 define('CRYPT_DES_ENCRYPT', 0);
70 * Contains array_reverse($keys[CRYPT_DES_ENCRYPT])
72 define('CRYPT_DES_DECRYPT', 1);
77 * @see Crypt_DES::encrypt()
78 * @see Crypt_DES::decrypt()
81 * Encrypt / decrypt using the Counter mode.
83 * Set to -1 since that's what Crypt/Random.php uses to index the CTR mode.
85 * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Counter_.28CTR.29
87 define('CRYPT_DES_MODE_CTR', -1);
89 * Encrypt / decrypt using the Electronic Code Book mode.
91 * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Electronic_codebook_.28ECB.29
93 define('CRYPT_DES_MODE_ECB', 1);
95 * Encrypt / decrypt using the Code Book Chaining mode.
97 * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Cipher-block_chaining_.28CBC.29
99 define('CRYPT_DES_MODE_CBC', 2);
104 * @see Crypt_DES::Crypt_DES()
107 * Toggles the internal implementation
109 define('CRYPT_DES_MODE_INTERNAL', 1);
111 * Toggles the mcrypt implementation
113 define('CRYPT_DES_MODE_MCRYPT', 2);
117 * Pure-PHP implementation of DES.
119 * @author Jim Wigginton <terrafrost@php.net>
128 * @see Crypt_DES::setKey()
132 var $keys = "\0\0\0\0\0\0\0\0";
135 * The Encryption Mode
137 * @see Crypt_DES::Crypt_DES()
144 * Continuous Buffer status
146 * @see Crypt_DES::enableContinuousBuffer()
150 var $continuousBuffer = false;
155 * @see Crypt_DES::enablePadding()
162 * The Initialization Vector
164 * @see Crypt_DES::setIV()
168 var $iv = "\0\0\0\0\0\0\0\0";
171 * A "sliding" Initialization Vector
173 * @see Crypt_DES::enableContinuousBuffer()
177 var $encryptIV = "\0\0\0\0\0\0\0\0";
180 * A "sliding" Initialization Vector
182 * @see Crypt_DES::enableContinuousBuffer()
186 var $decryptIV = "\0\0\0\0\0\0\0\0";
189 * mcrypt resource for encryption
191 * The mcrypt resource can be recreated every time something needs to be created or it can be created just once.
192 * Since mcrypt operates in continuous mode, by default, it'll need to be recreated when in non-continuous mode.
194 * @see Crypt_AES::encrypt()
201 * mcrypt resource for decryption
203 * The mcrypt resource can be recreated every time something needs to be created or it can be created just once.
204 * Since mcrypt operates in continuous mode, by default, it'll need to be recreated when in non-continuous mode.
206 * @see Crypt_AES::decrypt()
213 * Does the (en|de)mcrypt resource need to be (re)initialized?
223 * Default Constructor.
225 * Determines whether or not the mcrypt extension should be used. $mode should only, at present, be
226 * CRYPT_DES_MODE_ECB or CRYPT_DES_MODE_CBC. If not explictly set, CRYPT_DES_MODE_CBC will be used.
228 * @param optional Integer $mode
232 function Crypt_DES($mode = CRYPT_MODE_DES_CBC)
234 if ( !defined('CRYPT_DES_MODE') ) {
236 case extension_loaded('mcrypt'):
237 // i'd check to see if des was supported, by doing in_array('des', mcrypt_list_algorithms('')),
238 // but since that can be changed after the object has been created, there doesn't seem to be
240 define('CRYPT_DES_MODE', CRYPT_DES_MODE_MCRYPT);
243 define('CRYPT_DES_MODE', CRYPT_DES_MODE_INTERNAL);
247 switch ( CRYPT_DES_MODE ) {
248 case CRYPT_DES_MODE_MCRYPT:
250 case CRYPT_DES_MODE_ECB:
251 $this->mode = MCRYPT_MODE_ECB;
253 case CRYPT_DES_MODE_CTR:
255 //$this->mode = in_array('ctr', mcrypt_list_modes()) ? 'ctr' : CRYPT_DES_MODE_CTR;
257 case CRYPT_DES_MODE_CBC:
259 $this->mode = MCRYPT_MODE_CBC;
265 case CRYPT_DES_MODE_ECB:
266 case CRYPT_DES_MODE_CTR:
267 case CRYPT_DES_MODE_CBC:
271 $this->mode = CRYPT_DES_MODE_CBC;
279 * Keys can be of any length. DES, itself, uses 64-bit keys (eg. strlen($key) == 8), however, we
280 * only use the first eight, if $key has more then eight characters in it, and pad $key with the
281 * null byte if it is less then eight characters long.
283 * DES also requires that every eighth bit be a parity bit, however, we'll ignore that.
285 * If the key is not explicitly set, it'll be assumed to be all zero's.
290 function setKey($key)
292 $this->keys = ( CRYPT_DES_MODE == CRYPT_DES_MODE_MCRYPT ) ? substr($key, 0, 8) : $this->_prepareKey($key);
293 $this->changed = true;
297 * Sets the initialization vector. (optional)
299 * SetIV is not required when CRYPT_DES_MODE_ECB is being used. If not explictly set, it'll be assumed
307 $this->encryptIV = $this->decryptIV = $this->iv = str_pad(substr($iv, 0, 8), 8, chr(0));
308 $this->changed = true;
312 * Generate CTR XOR encryption key
314 * Encrypt the output of this and XOR it against the ciphertext / plaintext to get the
315 * plaintext / ciphertext in CTR mode.
317 * @see Crypt_DES::decrypt()
318 * @see Crypt_DES::encrypt()
320 * @param Integer $length
323 function _generate_xor($length, &$iv)
326 $num_blocks = ($length + 7) >> 3;
327 for ($i = 0; $i < $num_blocks; $i++) {
329 for ($j = 4; $j <= 8; $j+=4) {
330 $temp = substr($iv, -$j, 4);
332 case "\xFF\xFF\xFF\xFF":
333 $iv = substr_replace($iv, "\x00\x00\x00\x00", -$j, 4);
335 case "\x7F\xFF\xFF\xFF":
336 $iv = substr_replace($iv, "\x80\x00\x00\x00", -$j, 4);
339 extract(unpack('Ncount', $temp));
340 $iv = substr_replace($iv, pack('N', $count + 1), -$j, 4);
350 * Encrypts a message.
352 * $plaintext will be padded with up to 8 additional bytes. Other DES implementations may or may not pad in the
353 * same manner. Other common approaches to padding and the reasons why it's necessary are discussed in the following
356 * {@link http://www.di-mgt.com.au/cryptopad.html http://www.di-mgt.com.au/cryptopad.html}
358 * An alternative to padding is to, separately, send the length of the file. This is what SSH, in fact, does.
359 * strlen($plaintext) will still need to be a multiple of 8, however, arbitrary values can be added to make it that
362 * @see Crypt_DES::decrypt()
364 * @param String $plaintext
366 function encrypt($plaintext)
368 if ($this->mode != CRYPT_DES_MODE_CTR && $this->mode != 'ctr') {
369 $plaintext = $this->_pad($plaintext);
372 if ( CRYPT_DES_MODE == CRYPT_DES_MODE_MCRYPT ) {
373 if ($this->changed) {
374 if (!isset($this->enmcrypt)) {
375 $this->enmcrypt = mcrypt_module_open(MCRYPT_DES, '', $this->mode, '');
377 mcrypt_generic_init($this->enmcrypt, $this->keys, $this->encryptIV);
378 $this->changed = false;
381 $ciphertext = mcrypt_generic($this->enmcrypt, $plaintext);
383 if (!$this->continuousBuffer) {
384 mcrypt_generic_init($this->enmcrypt, $this->keys, $this->encryptIV);
390 if (!is_array($this->keys)) {
391 $this->keys = $this->_prepareKey("\0\0\0\0\0\0\0\0");
395 switch ($this->mode) {
396 case CRYPT_DES_MODE_ECB:
397 for ($i = 0; $i < strlen($plaintext); $i+=8) {
398 $ciphertext.= $this->_processBlock(substr($plaintext, $i, 8), CRYPT_DES_ENCRYPT);
401 case CRYPT_DES_MODE_CBC:
402 $xor = $this->encryptIV;
403 for ($i = 0; $i < strlen($plaintext); $i+=8) {
404 $block = substr($plaintext, $i, 8);
405 $block = $this->_processBlock($block ^ $xor, CRYPT_DES_ENCRYPT);
407 $ciphertext.= $block;
409 if ($this->continuousBuffer) {
410 $this->encryptIV = $xor;
413 case CRYPT_DES_MODE_CTR:
414 $xor = $this->encryptIV;
415 for ($i = 0; $i < strlen($plaintext); $i+=8) {
416 $block = substr($plaintext, $i, 8);
417 $key = $this->_processBlock($this->_generate_xor(8, $xor), CRYPT_DES_ENCRYPT);
418 $ciphertext.= $block ^ $key;
420 if ($this->continuousBuffer) {
421 $this->encryptIV = $xor;
429 * Decrypts a message.
431 * If strlen($ciphertext) is not a multiple of 8, null bytes will be added to the end of the string until it is.
433 * @see Crypt_DES::encrypt()
435 * @param String $ciphertext
437 function decrypt($ciphertext)
439 if ($this->mode != CRYPT_DES_MODE_CTR && $this->mode != 'ctr') {
440 // we pad with chr(0) since that's what mcrypt_generic does. to quote from http://php.net/function.mcrypt-generic :
441 // "The data is padded with "\0" to make sure the length of the data is n * blocksize."
442 $ciphertext = str_pad($ciphertext, (strlen($ciphertext) + 7) & 0xFFFFFFF8, chr(0));
445 if ( CRYPT_DES_MODE == CRYPT_DES_MODE_MCRYPT ) {
446 if ($this->changed) {
447 if (!isset($this->demcrypt)) {
448 $this->demcrypt = mcrypt_module_open(MCRYPT_DES, '', $this->mode, '');
450 mcrypt_generic_init($this->demcrypt, $this->keys, $this->decryptIV);
451 $this->changed = false;
454 $plaintext = mdecrypt_generic($this->demcrypt, $ciphertext);
456 if (!$this->continuousBuffer) {
457 mcrypt_generic_init($this->demcrypt, $this->keys, $this->decryptIV);
460 return $this->mode != 'ctr' ? $this->_unpad($plaintext) : $plaintext;
463 if (!is_array($this->keys)) {
464 $this->keys = $this->_prepareKey("\0\0\0\0\0\0\0\0");
468 switch ($this->mode) {
469 case CRYPT_DES_MODE_ECB:
470 for ($i = 0; $i < strlen($ciphertext); $i+=8) {
471 $plaintext.= $this->_processBlock(substr($ciphertext, $i, 8), CRYPT_DES_DECRYPT);
474 case CRYPT_DES_MODE_CBC:
475 $xor = $this->decryptIV;
476 for ($i = 0; $i < strlen($ciphertext); $i+=8) {
477 $block = substr($ciphertext, $i, 8);
478 $plaintext.= $this->_processBlock($block, CRYPT_DES_DECRYPT) ^ $xor;
481 if ($this->continuousBuffer) {
482 $this->decryptIV = $xor;
485 case CRYPT_DES_MODE_CTR:
486 $xor = $this->decryptIV;
487 for ($i = 0; $i < strlen($ciphertext); $i+=8) {
488 $block = substr($ciphertext, $i, 8);
489 $key = $this->_processBlock($this->_generate_xor(8, $xor), CRYPT_DES_ENCRYPT);
490 $plaintext.= $block ^ $key;
492 if ($this->continuousBuffer) {
493 $this->decryptIV = $xor;
497 return $this->mode != CRYPT_DES_MODE_CTR ? $this->_unpad($plaintext) : $plaintext;
501 * Treat consecutive "packets" as if they are a continuous buffer.
503 * Say you have a 16-byte plaintext $plaintext. Using the default behavior, the two following code snippets
504 * will yield different outputs:
507 * echo $des->encrypt(substr($plaintext, 0, 8));
508 * echo $des->encrypt(substr($plaintext, 8, 8));
511 * echo $des->encrypt($plaintext);
514 * The solution is to enable the continuous buffer. Although this will resolve the above discrepancy, it creates
515 * another, as demonstrated with the following:
518 * $des->encrypt(substr($plaintext, 0, 8));
519 * echo $des->decrypt($des->encrypt(substr($plaintext, 8, 8)));
522 * echo $des->decrypt($des->encrypt(substr($plaintext, 8, 8)));
525 * With the continuous buffer disabled, these would yield the same output. With it enabled, they yield different
526 * outputs. The reason is due to the fact that the initialization vector's change after every encryption /
527 * decryption round when the continuous buffer is enabled. When it's disabled, they remain constant.
529 * Put another way, when the continuous buffer is enabled, the state of the Crypt_DES() object changes after each
530 * encryption / decryption round, whereas otherwise, it'd remain constant. For this reason, it's recommended that
531 * continuous buffers not be used. They do offer better security and are, in fact, sometimes required (SSH uses them),
532 * however, they are also less intuitive and more likely to cause you problems.
534 * @see Crypt_DES::disableContinuousBuffer()
537 function enableContinuousBuffer()
539 $this->continuousBuffer = true;
543 * Treat consecutive packets as if they are a discontinuous buffer.
545 * The default behavior.
547 * @see Crypt_DES::enableContinuousBuffer()
550 function disableContinuousBuffer()
552 $this->continuousBuffer = false;
553 $this->encryptIV = $this->iv;
554 $this->decryptIV = $this->iv;
560 * DES works by encrypting eight bytes at a time. If you ever need to encrypt or decrypt something that's not
561 * a multiple of eight, it becomes necessary to pad the input so that it's length is a multiple of eight.
563 * Padding is enabled by default. Sometimes, however, it is undesirable to pad strings. Such is the case in SSH1,
564 * where "packets" are padded with random bytes before being encrypted. Unpad these packets and you risk stripping
565 * away characters that shouldn't be stripped away. (SSH knows how many bytes are added because the length is
566 * transmitted separately)
568 * @see Crypt_DES::disablePadding()
571 function enablePadding()
573 $this->padding = true;
577 * Do not pad packets.
579 * @see Crypt_DES::enablePadding()
582 function disablePadding()
584 $this->padding = false;
590 * Pads a string using the RSA PKCS padding standards so that its length is a multiple of the blocksize (8).
591 * 8 - (strlen($text) & 7) bytes are added, each of which is equal to chr(8 - (strlen($text) & 7)
593 * If padding is disabled and $text is not a multiple of the blocksize, the string will be padded regardless
594 * and padding will, hence forth, be enabled.
596 * @see Crypt_DES::_unpad()
601 $length = strlen($text);
603 if (!$this->padding) {
604 if (($length & 7) == 0) {
607 user_error("The plaintext's length ($length) is not a multiple of the block size (8)", E_USER_NOTICE);
608 $this->padding = true;
612 $pad = 8 - ($length & 7);
613 return str_pad($text, $length + $pad, chr($pad));
619 * If padding is enabled and the reported padding length is invalid the encryption key will be assumed to be wrong
620 * and false will be returned.
622 * @see Crypt_DES::_pad()
625 function _unpad($text)
627 if (!$this->padding) {
631 $length = ord($text[strlen($text) - 1]);
633 if (!$length || $length > 8) {
637 return substr($text, 0, -$length);
641 * Encrypts or decrypts a 64-bit block
643 * $mode should be either CRYPT_DES_ENCRYPT or CRYPT_DES_DECRYPT. See
644 * {@link http://en.wikipedia.org/wiki/Image:Feistel.png Feistel.png} to get a general
645 * idea of what this function does.
648 * @param String $block
649 * @param Integer $mode
652 function _processBlock($block, $mode)
654 // s-boxes. in the official DES docs, they're described as being matrices that
655 // one accesses by using the first and last bits to determine the row and the
656 // middle four bits to determine the column. in this implementation, they've
657 // been converted to vectors
658 static $sbox = array(
660 14, 0, 4, 15, 13, 7, 1, 4, 2, 14, 15, 2, 11, 13, 8, 1,
661 3, 10 ,10, 6, 6, 12, 12, 11, 5, 9, 9, 5, 0, 3, 7, 8,
662 4, 15, 1, 12, 14, 8, 8, 2, 13, 4, 6, 9, 2, 1, 11, 7,
663 15, 5, 12, 11, 9, 3, 7, 14, 3, 10, 10, 0, 5, 6, 0, 13
666 15, 3, 1, 13, 8, 4, 14, 7, 6, 15, 11, 2, 3, 8, 4, 14,
667 9, 12, 7, 0, 2, 1, 13, 10, 12, 6, 0, 9, 5, 11, 10, 5,
668 0, 13, 14, 8, 7, 10, 11, 1, 10, 3, 4, 15, 13, 4, 1, 2,
669 5, 11, 8, 6, 12, 7, 6, 12, 9, 0, 3, 5, 2, 14, 15, 9
672 10, 13, 0, 7, 9, 0, 14, 9, 6, 3, 3, 4, 15, 6, 5, 10,
673 1, 2, 13, 8, 12, 5, 7, 14, 11, 12, 4, 11, 2, 15, 8, 1,
674 13, 1, 6, 10, 4, 13, 9, 0, 8, 6, 15, 9, 3, 8, 0, 7,
675 11, 4, 1, 15, 2, 14, 12, 3, 5, 11, 10, 5, 14, 2, 7, 12
678 7, 13, 13, 8, 14, 11, 3, 5, 0, 6, 6, 15, 9, 0, 10, 3,
679 1, 4, 2, 7, 8, 2, 5, 12, 11, 1, 12, 10, 4, 14, 15, 9,
680 10, 3, 6, 15, 9, 0, 0, 6, 12, 10, 11, 1, 7, 13, 13, 8,
681 15, 9, 1, 4, 3, 5, 14, 11, 5, 12, 2, 7, 8, 2, 4, 14
684 2, 14, 12, 11, 4, 2, 1, 12, 7, 4, 10, 7, 11, 13, 6, 1,
685 8, 5, 5, 0, 3, 15, 15, 10, 13, 3, 0, 9, 14, 8, 9, 6,
686 4, 11, 2, 8, 1, 12, 11, 7, 10, 1, 13, 14, 7, 2, 8, 13,
687 15, 6, 9, 15, 12, 0, 5, 9, 6, 10, 3, 4, 0, 5, 14, 3
690 12, 10, 1, 15, 10, 4, 15, 2, 9, 7, 2, 12, 6, 9, 8, 5,
691 0, 6, 13, 1, 3, 13, 4, 14, 14, 0, 7, 11, 5, 3, 11, 8,
692 9, 4, 14, 3, 15, 2, 5, 12, 2, 9, 8, 5, 12, 15, 3, 10,
693 7, 11, 0, 14, 4, 1, 10, 7, 1, 6, 13, 0, 11, 8, 6, 13
696 4, 13, 11, 0, 2, 11, 14, 7, 15, 4, 0, 9, 8, 1, 13, 10,
697 3, 14, 12, 3, 9, 5, 7, 12, 5, 2, 10, 15, 6, 8, 1, 6,
698 1, 6, 4, 11, 11, 13, 13, 8, 12, 1, 3, 4, 7, 10, 14, 7,
699 10, 9, 15, 5, 6, 0, 8, 15, 0, 14, 5, 2, 9, 3, 2, 12
702 13, 1, 2, 15, 8, 13, 4, 8, 6, 10, 15, 3, 11, 7, 1, 4,
703 10, 12, 9, 5, 3, 6, 14, 11, 5, 0, 0, 14, 12, 9, 7, 2,
704 7, 2, 11, 1, 4, 14, 1, 7, 9, 4, 12, 10, 14, 8, 2, 13,
705 0, 15, 6, 12, 10, 9, 13, 0, 15, 3, 3, 5, 5, 6, 8, 11
711 $temp = unpack('Na/Nb', $block);
712 $block = array($temp['a'], $temp['b']);
714 // because php does arithmetic right shifts, if the most significant bits are set, right
715 // shifting those into the correct position will add 1's - not 0's. this will intefere
716 // with the | operation unless a second & is done. so we isolate these bits and left shift
717 // them into place. we then & each block with 0x7FFFFFFF to prevennt 1's from being added
718 // for any other shifts.
720 ($block[0] >> 31) & 1,
721 ($block[1] >> 31) & 1
723 $block[0] &= 0x7FFFFFFF;
724 $block[1] &= 0x7FFFFFFF;
726 // we isolate the appropriate bit in the appropriate integer and shift as appropriate. in
727 // some cases, there are going to be multiple bits in the same integer that need to be shifted
728 // in the same way. we combine those into one shift operation.
730 (($block[1] & 0x00000040) << 25) | (($block[1] & 0x00004000) << 16) |
731 (($block[1] & 0x00400001) << 7) | (($block[1] & 0x40000100) >> 2) |
732 (($block[0] & 0x00000040) << 21) | (($block[0] & 0x00004000) << 12) |
733 (($block[0] & 0x00400001) << 3) | (($block[0] & 0x40000100) >> 6) |
734 (($block[1] & 0x00000010) << 19) | (($block[1] & 0x00001000) << 10) |
735 (($block[1] & 0x00100000) << 1) | (($block[1] & 0x10000000) >> 8) |
736 (($block[0] & 0x00000010) << 15) | (($block[0] & 0x00001000) << 6) |
737 (($block[0] & 0x00100000) >> 3) | (($block[0] & 0x10000000) >> 12) |
738 (($block[1] & 0x00000004) << 13) | (($block[1] & 0x00000400) << 4) |
739 (($block[1] & 0x00040000) >> 5) | (($block[1] & 0x04000000) >> 14) |
740 (($block[0] & 0x00000004) << 9) | ( $block[0] & 0x00000400 ) |
741 (($block[0] & 0x00040000) >> 9) | (($block[0] & 0x04000000) >> 18) |
742 (($block[1] & 0x00010000) >> 11) | (($block[1] & 0x01000000) >> 20) |
743 (($block[0] & 0x00010000) >> 15) | (($block[0] & 0x01000000) >> 24)
745 (($block[1] & 0x00000080) << 24) | (($block[1] & 0x00008000) << 15) |
746 (($block[1] & 0x00800002) << 6) | (($block[0] & 0x00000080) << 20) |
747 (($block[0] & 0x00008000) << 11) | (($block[0] & 0x00800002) << 2) |
748 (($block[1] & 0x00000020) << 18) | (($block[1] & 0x00002000) << 9) |
749 ( $block[1] & 0x00200000 ) | (($block[1] & 0x20000000) >> 9) |
750 (($block[0] & 0x00000020) << 14) | (($block[0] & 0x00002000) << 5) |
751 (($block[0] & 0x00200000) >> 4) | (($block[0] & 0x20000000) >> 13) |
752 (($block[1] & 0x00000008) << 12) | (($block[1] & 0x00000800) << 3) |
753 (($block[1] & 0x00080000) >> 6) | (($block[1] & 0x08000000) >> 15) |
754 (($block[0] & 0x00000008) << 8) | (($block[0] & 0x00000800) >> 1) |
755 (($block[0] & 0x00080000) >> 10) | (($block[0] & 0x08000000) >> 19) |
756 (($block[1] & 0x00000200) >> 3) | (($block[0] & 0x00000200) >> 7) |
757 (($block[1] & 0x00020000) >> 12) | (($block[1] & 0x02000000) >> 21) |
758 (($block[0] & 0x00020000) >> 16) | (($block[0] & 0x02000000) >> 25) |
759 ($msb[1] << 28) | ($msb[0] << 24)
762 for ($i = 0; $i < 16; $i++) {
763 // start of "the Feistel (F) function" - see the following URL:
764 // http://en.wikipedia.org/wiki/Image:Data_Encryption_Standard_InfoBox_Diagram.png
765 $temp = (($sbox[0][((($block[1] >> 27) & 0x1F) | (($block[1] & 1) << 5)) ^ $keys[$mode][$i][0]]) << 28)
766 | (($sbox[1][(($block[1] & 0x1F800000) >> 23) ^ $keys[$mode][$i][1]]) << 24)
767 | (($sbox[2][(($block[1] & 0x01F80000) >> 19) ^ $keys[$mode][$i][2]]) << 20)
768 | (($sbox[3][(($block[1] & 0x001F8000) >> 15) ^ $keys[$mode][$i][3]]) << 16)
769 | (($sbox[4][(($block[1] & 0x0001F800) >> 11) ^ $keys[$mode][$i][4]]) << 12)
770 | (($sbox[5][(($block[1] & 0x00001F80) >> 7) ^ $keys[$mode][$i][5]]) << 8)
771 | (($sbox[6][(($block[1] & 0x000001F8) >> 3) ^ $keys[$mode][$i][6]]) << 4)
772 | ( $sbox[7][((($block[1] & 0x1F) << 1) | (($block[1] >> 31) & 1)) ^ $keys[$mode][$i][7]]);
774 $msb = ($temp >> 31) & 1;
776 $newBlock = (($temp & 0x00010000) << 15) | (($temp & 0x02020120) << 5)
777 | (($temp & 0x00001800) << 17) | (($temp & 0x01000000) >> 10)
778 | (($temp & 0x00000008) << 24) | (($temp & 0x00100000) << 6)
779 | (($temp & 0x00000010) << 21) | (($temp & 0x00008000) << 9)
780 | (($temp & 0x00000200) << 12) | (($temp & 0x10000000) >> 27)
781 | (($temp & 0x00000040) << 14) | (($temp & 0x08000000) >> 8)
782 | (($temp & 0x00004000) << 4) | (($temp & 0x00000002) << 16)
783 | (($temp & 0x00442000) >> 6) | (($temp & 0x40800000) >> 15)
784 | (($temp & 0x00000001) << 11) | (($temp & 0x20000000) >> 20)
785 | (($temp & 0x00080000) >> 13) | (($temp & 0x00000004) << 3)
786 | (($temp & 0x04000000) >> 22) | (($temp & 0x00000480) >> 7)
787 | (($temp & 0x00200000) >> 19) | ($msb << 23);
788 // end of "the Feistel (F) function" - $newBlock is F's output
791 $block[1] = $block[0] ^ $newBlock;
796 ($block[0] >> 31) & 1,
797 ($block[1] >> 31) & 1
799 $block[0] &= 0x7FFFFFFF;
800 $block[1] &= 0x7FFFFFFF;
803 (($block[0] & 0x01000004) << 7) | (($block[1] & 0x01000004) << 6) |
804 (($block[0] & 0x00010000) << 13) | (($block[1] & 0x00010000) << 12) |
805 (($block[0] & 0x00000100) << 19) | (($block[1] & 0x00000100) << 18) |
806 (($block[0] & 0x00000001) << 25) | (($block[1] & 0x00000001) << 24) |
807 (($block[0] & 0x02000008) >> 2) | (($block[1] & 0x02000008) >> 3) |
808 (($block[0] & 0x00020000) << 4) | (($block[1] & 0x00020000) << 3) |
809 (($block[0] & 0x00000200) << 10) | (($block[1] & 0x00000200) << 9) |
810 (($block[0] & 0x00000002) << 16) | (($block[1] & 0x00000002) << 15) |
811 (($block[0] & 0x04000000) >> 11) | (($block[1] & 0x04000000) >> 12) |
812 (($block[0] & 0x00040000) >> 5) | (($block[1] & 0x00040000) >> 6) |
813 (($block[0] & 0x00000400) << 1) | ( $block[1] & 0x00000400 ) |
814 (($block[0] & 0x08000000) >> 20) | (($block[1] & 0x08000000) >> 21) |
815 (($block[0] & 0x00080000) >> 14) | (($block[1] & 0x00080000) >> 15) |
816 (($block[0] & 0x00000800) >> 8) | (($block[1] & 0x00000800) >> 9)
818 (($block[0] & 0x10000040) << 3) | (($block[1] & 0x10000040) << 2) |
819 (($block[0] & 0x00100000) << 9) | (($block[1] & 0x00100000) << 8) |
820 (($block[0] & 0x00001000) << 15) | (($block[1] & 0x00001000) << 14) |
821 (($block[0] & 0x00000010) << 21) | (($block[1] & 0x00000010) << 20) |
822 (($block[0] & 0x20000080) >> 6) | (($block[1] & 0x20000080) >> 7) |
823 ( $block[0] & 0x00200000 ) | (($block[1] & 0x00200000) >> 1) |
824 (($block[0] & 0x00002000) << 6) | (($block[1] & 0x00002000) << 5) |
825 (($block[0] & 0x00000020) << 12) | (($block[1] & 0x00000020) << 11) |
826 (($block[0] & 0x40000000) >> 15) | (($block[1] & 0x40000000) >> 16) |
827 (($block[0] & 0x00400000) >> 9) | (($block[1] & 0x00400000) >> 10) |
828 (($block[0] & 0x00004000) >> 3) | (($block[1] & 0x00004000) >> 4) |
829 (($block[0] & 0x00800000) >> 18) | (($block[1] & 0x00800000) >> 19) |
830 (($block[0] & 0x00008000) >> 12) | (($block[1] & 0x00008000) >> 13) |
831 ($msb[0] << 7) | ($msb[1] << 6)
834 return pack('NN', $block[0], $block[1]);
838 * Creates the key schedule.
844 function _prepareKey($key)
846 static $shifts = array( // number of key bits shifted per round
847 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
850 // pad the key and remove extra characters as appropriate.
851 $key = str_pad(substr($key, 0, 8), 8, chr(0));
853 $temp = unpack('Na/Nb', $key);
854 $key = array($temp['a'], $temp['b']);
859 $key[0] &= 0x7FFFFFFF;
860 $key[1] &= 0x7FFFFFFF;
863 (($key[1] & 0x00000002) << 26) | (($key[1] & 0x00000204) << 17) |
864 (($key[1] & 0x00020408) << 8) | (($key[1] & 0x02040800) >> 1) |
865 (($key[0] & 0x00000002) << 22) | (($key[0] & 0x00000204) << 13) |
866 (($key[0] & 0x00020408) << 4) | (($key[0] & 0x02040800) >> 5) |
867 (($key[1] & 0x04080000) >> 10) | (($key[0] & 0x04080000) >> 14) |
868 (($key[1] & 0x08000000) >> 19) | (($key[0] & 0x08000000) >> 23) |
869 (($key[0] & 0x00000010) >> 1) | (($key[0] & 0x00001000) >> 10) |
870 (($key[0] & 0x00100000) >> 19) | (($key[0] & 0x10000000) >> 28)
872 (($key[1] & 0x00000080) << 20) | (($key[1] & 0x00008000) << 11) |
873 (($key[1] & 0x00800000) << 2) | (($key[0] & 0x00000080) << 16) |
874 (($key[0] & 0x00008000) << 7) | (($key[0] & 0x00800000) >> 2) |
875 (($key[1] & 0x00000040) << 13) | (($key[1] & 0x00004000) << 4) |
876 (($key[1] & 0x00400000) >> 5) | (($key[1] & 0x40000000) >> 14) |
877 (($key[0] & 0x00000040) << 9) | ( $key[0] & 0x00004000 ) |
878 (($key[0] & 0x00400000) >> 9) | (($key[0] & 0x40000000) >> 18) |
879 (($key[1] & 0x00000020) << 6) | (($key[1] & 0x00002000) >> 3) |
880 (($key[1] & 0x00200000) >> 12) | (($key[1] & 0x20000000) >> 21) |
881 (($key[0] & 0x00000020) << 2) | (($key[0] & 0x00002000) >> 7) |
882 (($key[0] & 0x00200000) >> 16) | (($key[0] & 0x20000000) >> 25) |
883 (($key[1] & 0x00000010) >> 1) | (($key[1] & 0x00001000) >> 10) |
884 (($key[1] & 0x00100000) >> 19) | (($key[1] & 0x10000000) >> 28) |
885 ($msb[1] << 24) | ($msb[0] << 20)
889 for ($i = 0; $i < 16; $i++) {
890 $key[0] <<= $shifts[$i];
891 $temp = ($key[0] & 0xF0000000) >> 28;
892 $key[0] = ($key[0] | $temp) & 0x0FFFFFFF;
894 $key[1] <<= $shifts[$i];
895 $temp = ($key[1] & 0xF0000000) >> 28;
896 $key[1] = ($key[1] | $temp) & 0x0FFFFFFF;
899 (($key[1] & 0x00004000) >> 9) | (($key[1] & 0x00000800) >> 7) |
900 (($key[1] & 0x00020000) >> 14) | (($key[1] & 0x00000010) >> 2) |
901 (($key[1] & 0x08000000) >> 26) | (($key[1] & 0x00800000) >> 23)
903 (($key[1] & 0x02400000) >> 20) | (($key[1] & 0x00000001) << 4) |
904 (($key[1] & 0x00002000) >> 10) | (($key[1] & 0x00040000) >> 18) |
905 (($key[1] & 0x00000080) >> 6)
907 ( $key[1] & 0x00000020 ) | (($key[1] & 0x00000200) >> 5) |
908 (($key[1] & 0x00010000) >> 13) | (($key[1] & 0x01000000) >> 22) |
909 (($key[1] & 0x00000004) >> 1) | (($key[1] & 0x00100000) >> 20)
911 (($key[1] & 0x00001000) >> 7) | (($key[1] & 0x00200000) >> 17) |
912 (($key[1] & 0x00000002) << 2) | (($key[1] & 0x00000100) >> 6) |
913 (($key[1] & 0x00008000) >> 14) | (($key[1] & 0x04000000) >> 26)
915 (($key[0] & 0x00008000) >> 10) | ( $key[0] & 0x00000010 ) |
916 (($key[0] & 0x02000000) >> 22) | (($key[0] & 0x00080000) >> 17) |
917 (($key[0] & 0x00000200) >> 8) | (($key[0] & 0x00000002) >> 1)
919 (($key[0] & 0x04000000) >> 21) | (($key[0] & 0x00010000) >> 12) |
920 (($key[0] & 0x00000020) >> 2) | (($key[0] & 0x00000800) >> 9) |
921 (($key[0] & 0x00800000) >> 22) | (($key[0] & 0x00000100) >> 8)
923 (($key[0] & 0x00001000) >> 7) | (($key[0] & 0x00000088) >> 3) |
924 (($key[0] & 0x00020000) >> 14) | (($key[0] & 0x00000001) << 2) |
925 (($key[0] & 0x00400000) >> 21)
927 (($key[0] & 0x00000400) >> 5) | (($key[0] & 0x00004000) >> 10) |
928 (($key[0] & 0x00000040) >> 3) | (($key[0] & 0x00100000) >> 18) |
929 (($key[0] & 0x08000000) >> 26) | (($key[0] & 0x01000000) >> 24)
936 CRYPT_DES_ENCRYPT => $keys,
937 CRYPT_DES_DECRYPT => array_reverse($keys)
944 // vim: ts=4:sw=4:et: