API tools faq
paste
Advertisement
Guest User

PHP Rijndael

a guest
Sep 11th, 2012
924
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PHP 12.63 KB | None | 0 0
raw download clone embed print report
  1. <?php
  2. /* *
  3. * Encrypts and decrypts text with the Rijndael algorithm.
  4. */
  5.  
  6.  
  7. function strSlice($str, $start, $end) {
  8.     $end = $end - $start;
  9.     return substr($str, $start, $end);
  10. }
  11.  
  12.  
  13. function slice($object, $start=0, $end=9999) {
  14.         $type = gettype($object);
  15.         if($type == "array") {
  16.             //slice array
  17.             $ret_a = Array();
  18.             if($end == 9999) $end = count($object);
  19.             for($i = $start; $i < $end; $i++)
  20.                 $ret_a[] = $object[$i];
  21.             return $ret_a;
  22.         }
  23.         else {
  24.             //slice string
  25.             $ret_a = strSlice($object, $start, $end);
  26.             if($end == 9999) $end = strlen($object);
  27.             return $ret_a;
  28.         }
  29.     }
  30.    
  31.     function concat($firstObject, $secondObject) {
  32.         $type = gettype($firstObject);
  33.         $type2 = gettype($secondObject);
  34.         if($type == "array" && $type == $type2) {
  35.             //concat array
  36.             $ret_a = array_merge($firstObject, $secondObject);
  37.            
  38.             return $ret_a;
  39.         }
  40.         else {
  41.             //concat string
  42.             $ret_a = $firstObject . $secondObject;
  43.             return $ret_a;
  44.         }
  45.     }
  46.    
  47.     function length($obj) {
  48.         $type = gettype($obj);
  49.         if($type == "array") {
  50.             //length of array
  51.             return count($obj);
  52.         }
  53.         else {
  54.             //length of  string
  55.             return strlen($obj);
  56.         }
  57.     }
  58.  
  59. class TRijndael {
  60.  
  61.     /**
  62.     * Variables
  63.     * @exclude
  64.     */
  65.     private $roundsArray = Array(); //array
  66.     private $shiftOffsets = Array(); //array
  67.     private $Nr, $Nk, $Nb; //ints
  68.     private $Rcon = Array(0x01, 0x02, 0x04, 0x08, 0x10, 0x20,0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc,0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4,0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91 );
  69.     private $SBox = Array ( 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132,  83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22);
  70.     private $SBoxInverse = Array( 82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, 243, 215, 251, 124, 227, 57, 130, 155, 47, 255, 135, 52, 142, 67, 68, 196, 222, 233, 203, 84, 123, 148, 50, 166, 194, 35, 61, 238, 76, 149, 11, 66, 250, 195, 78, 8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, 109, 139, 209, 37, 114, 248, 246, 100, 134, 104, 152, 22, 212, 164, 92, 204, 93, 101, 182, 146, 108, 112, 72, 80, 253, 237, 185, 218, 94, 21, 70, 87, 167, 141, 157, 132, 144, 216, 171, 0, 140, 188, 211, 10, 247, 228, 88, 5, 184, 179, 69, 6, 208, 44, 30, 143, 202, 63, 15, 2, 193, 175, 189, 3, 1, 19, 138, 107, 58, 145, 17, 65, 79, 103,220, 234, 151, 242, 207, 206, 240, 180, 230, 115, 150, 172, 116, 34, 231, 173, 53, 133, 226, 249, 55, 232, 28, 117, 223, 110, 71, 241, 26, 113, 29, 41, 197, 137, 111, 183, 98, 14, 170, 24, 190, 27, 252, 86, 62, 75, 198, 210, 121, 32, 154, 219, 192, 254, 120, 205, 90, 244, 31, 221, 168, 51, 136, 7, 199, 49, 177, 18, 16, 89, 39, 128, 236, 95, 96, 81, 127, 169, 25, 181, 74, 13, 45, 229, 122, 159, 147, 201, 156, 239, 160, 224, 59, 77, 174, 42, 245, 176, 200, 235, 187, 60, 131, 83, 153, 97, 23, 43, 4, 126, 186, 119, 214, 38, 225, 105, 20, 99, 85, 33, 12, 125);
  71.     private $blockSize = 128; //int
  72.     private $keySize = 128; //int
  73.  
  74.     /**
  75.     * Constructor
  76.     * @exclude
  77.     */
  78.     public function TRijndael($keySize2, $blockSize2){ //two int parameters
  79.         if ($keySize2 != null) $this->keySize = $keySize2;
  80.         if ($blockSize2 != null) $this->blockSize = $blockSize2;
  81.         $this->roundsArray = Array(Array(0),Array(0),Array(0),Array(0),Array(0,0,0,0,10,0,12,0,14),0,Array(0,0,0,0,12,0,12,0,14),Array(0),Array(0,0,0,0,14,0,14,0,14));
  82.         $this->shiftOffsets = Array(Array(0),Array(0),Array(0),Array(0),Array(0,1,2,3),Array(0),Array(0,1,2,3),Array(0),Array(0,1,3,4));
  83.         $this->Nb = $this->blockSize / 32; $this->Nk = $this->keySize / 32;
  84.         $this->Nr = $this->roundsArray[$this->Nk][$this->Nb];
  85.     }
  86.  
  87.     /**
  88.     * Encrypts a string with the specified key and mode.
  89.     * take three strings, and return STRING
  90.     */
  91.     public function encrypt($src, $key, $mode) {
  92.         $ct = Array();
  93.         $aBlock = Array();
  94.         $bpb = $this->blockSize / 8; //integer
  95.         if ($mode == "CBC") $ct = $this->getRandomBytes($bpb);
  96.         $chars = $this->formatPlaintext($this->strToChars($src));        //ARRAY
  97.         $expandedKey = $this->keyExpansion($this->strToChars($key));     //ARRAY
  98.         for ($block = 0; $block < length($chars) / $bpb; $block++) {
  99.             $aBlock = slice($chars, $block*$bpb, ($block+1)*$bpb);
  100.             if ($mode == "CBC") {
  101.                 for ($i = 0; $i<$bpb; $i++) {
  102.                     $aBlock[$i] ^= $ct[$block*$bpb + $i];
  103.                 }
  104.             }
  105.             $ct = concat($ct, $this->encryption($aBlock, $expandedKey) );
  106.         }
  107.         return $this->charsToHex($ct);
  108.     }
  109.  
  110.     /**
  111.     * Decrypts a string with the specified key and mode.
  112.     */
  113.     public function decrypt($src, $key, $mode) {
  114.         $pt = Array();
  115.         $aBlock = Array();
  116.         $chars = $this->hexToChars($src); //ARRAY
  117.         $bpb = $this->blockSize / 8;
  118.         $expandedKey = $this->keyExpansion($this->strToChars($key));
  119.         for ($block = (length($chars)/$bpb)-1; $block>0; $block--) {
  120.             $aBlock = $this->decryption( slice($chars, $block*$bpb, ($block+1)*$bpb), $expandedKey );
  121.             if($mode == "CBC") {
  122.                 for ($i = 0; $i<$bpb; $i++) {
  123.                     $pt[($block-1)*$bpb+$i] = $aBlock[$i] ^ $chars[($block-1)*$bpb+$i];
  124.                 }
  125.             }
  126.             else $pt = concat($aBlock, $pt);
  127.         }
  128.         if ($mode == "ECB") {
  129.             $pt = concat($this->decryption( slice($chars, 0, $bpb), $expandedKey), $pt);
  130.         }
  131.         return $this->charsToStr($pt);
  132.     }
  133.    
  134.     private function cyclicShiftLeft($src, $pos) {
  135.         $temp = slice($src, 0, $pos); //array
  136.         $src = concat(slice($src, $pos), $temp);
  137.         return $src;
  138.     }
  139.    
  140.     private function xtime($poly) {
  141.         $poly <<= 1;
  142.         return (($poly & 0x100) ? ($poly ^ 0x11B) : ($poly));
  143.     }
  144.     private function mult_GF256($x, $y) {
  145.         $result = 0;
  146.         for ($bit = 1; $bit<256; $bit *= 2, $y = $this->xtime($y)) {
  147.             if($x & $bit) $result ^= $y;
  148.         }
  149.         return $result;
  150.     }
  151.    
  152.    
  153.     private function byteSub(&$state, $dir) {
  154.         $S = Array();
  155.         if($dir == "encrypt") $S = $this->SBox;
  156.         else $S = $this->SBoxInverse;
  157.         for ($i = 0; $i<4; $i++) {
  158.             for ($j = 0; $j<$this->Nb; $j++) $state[$i][$j] = $S[$state[$i][$j]];
  159.         }
  160.     }
  161.    
  162.    
  163.     private function shiftRow(&$state, $dir) {
  164.         for ($i = 1; $i<4; $i++) {
  165.             if ($dir == "encrypt") $state[$i] = $this->cyclicShiftLeft($state[$i], $this->shiftOffsets[$this->Nb][$i]);
  166.             else $state[$i] = $this->cyclicShiftLeft($state[$i], $this->Nb - $this->shiftOffsets[$this->Nb][$i]);
  167.         }
  168.     }
  169.    
  170.    
  171.     private function mixColumn(&$state, $dir) {
  172.         $b = Array();
  173.         for ($j = 0; $j<$this->Nb; $j++) {
  174.             for($i = 0; $i<4; $i++) {
  175.                 if ($dir == "encrypt") $b[$i] = $this->mult_GF256($state[$i][$j], 2) ^ $this->mult_GF256($state[($i+1)%4][$j], 3) ^ $state[($i+2)%4][$j] ^ $state[($i+3)%4][$j];
  176.                 else $b[$i] = $this->mult_GF256($state[$i][$j], 0xE) ^ $this->mult_GF256($state[($i+1)%4][$j], 0xB) ^ $this->mult_GF256($state[($i+2)%4][$j], 0xD) ^ $this->mult_GF256($state[($i+3)%4][$j], 9);
  177.             }
  178.             for ($i = 0; $i<4; $i++) {
  179.                 $state[$i][$j] = $b[$i];
  180.             }
  181.         }
  182.     }
  183.    
  184.    
  185.     private function addRoundKey(&$state, $roundKey) {
  186.         for ($j = 0; $j<$this->Nb; $j++) {
  187.             $state[0][$j] ^= ($roundKey[$j] & 0xFF);
  188.             $state[1][$j] ^= (($roundKey[$j]>>8) &0xFF);
  189.             $state[2][$j] ^= (($roundKey[$j]>>16) &0xFF);
  190.             $state[3][$j] ^= (($roundKey[$j]>>24) &0xFF);
  191.         }
  192.     }
  193.    
  194.    
  195.     private function keyExpansion($key) {
  196.         $temp = 0;
  197.         $this->Nk = $this->keySize/32;
  198.         $this->Nb = $this->blockSize/32;
  199.         $expandedKey = Array();
  200.         $this->Nr = $this->roundsArray[$this->Nk][$this->Nb];
  201.         for ($j = 0; $j<$this->Nk; $j++) $expandedKey[$j] = ($key[4*$j]) | ($key[4*$j+1]<<8) | ($key[4*$j+2]<<16) | ($key[4*$j+3]<<24);
  202.         for ($j = $this->Nk; $j<$this->Nb*($this->Nr+1); $j++) {
  203.             $temp = $expandedKey[$j-1];
  204.             if ($j % $this->Nk == 0) $temp = ( ($this->SBox[($temp>>8) & 0xFF]) | ($this->SBox[($temp>>16) & 0xFF]<<8) | ($this->SBox[($temp>>24) & 0xFF]<<16) | ($this->SBox[$temp & 0xFF]<<24) ) ^ $this->Rcon[floor($j / $this->Nk) - 1];
  205.             else if ($this->Nk > 6 && $j % $this->Nk == 4) $temp = ($this->SBox[($temp>>24) & 0xFF]<<24) | ($this->SBox[($temp>>16) & 0xFF]<<16) | ($this->SBox[($temp>>8) & 0xFF]<<8) | ($this->SBox[$temp & 0xFF]);
  206.             $expandedKey[$j] = $expandedKey[$j-$this->Nk] ^ $temp;
  207.         }
  208.         return $expandedKey;
  209.     }
  210.    
  211.    
  212.     private function Round(&$state, $roundKey) {
  213.         $this->byteSub($state, "encrypt");
  214.         $this->shiftRow($state, "encrypt");
  215.         $this->mixColumn($state, "encrypt");
  216.         $this->addRoundKey($state, $roundKey);
  217.     }
  218.    
  219.     private function InverseRound(&$state, $roundKey) {
  220.         $this->addRoundKey($state, $roundKey);
  221.         $this->mixColumn($state, "decrypt");
  222.         $this->shiftRow($state, "decrypt");
  223.         $this->byteSub($state, "decrypt");
  224.     }
  225.     private function FinalRound(&$state, $roundKey) {
  226.         $this->byteSub($state, "encrypt");
  227.         $this->shiftRow($state, "encrypt");
  228.         $this->addRoundKey($state, $roundKey);
  229.     }
  230.     private function InverseFinalRound(&$state, $roundKey) {
  231.         $this->addRoundKey($state, $roundKey);
  232.         $this->shiftRow($state, "decrypt");
  233.         $this->byteSub($state, "decrypt");
  234.     }
  235.    
  236.    
  237.     private function encryption($block, $expandedKey) {
  238.         $block = $this->packBytes($block);
  239.         $this->addRoundKey($block, $expandedKey);
  240.         for ($i = 1; $i<$this->Nr; $i++) {
  241.             $this->Round($block, slice($expandedKey, $this->Nb*$i, $this->Nb*($i+1)));
  242.         }
  243.         $this->FinalRound($block, slice($expandedKey, $this->Nb * $this->Nr));
  244.         return $this->unpackBytes($block);
  245.     }
  246.    
  247.     private function decryption($block, $expandedKey) {
  248.         $block = $this->packBytes($block);
  249.         $this->InverseFinalRound($block, slice($expandedKey, $this->Nb * $this->Nr));
  250.         for ($i = $this->Nr-1; $i>0; $i--) {
  251.             $this->InverseRound($block, slice($expandedKey, $this->Nb*$i, $this->Nb*($i+1)));
  252.         }
  253.         $this->addRoundKey($block, $expandedKey);
  254.         return $this->unpackBytes($block);
  255.     }
  256.    
  257.     private function packBytes($octets) {
  258.         $state = Array();
  259.         $state[0] = Array(); $state[1] = Array();
  260.         $state[2] = Array(); $state[3] = Array();
  261.         for ($j = 0; $j< length($octets); $j+= 4) {
  262.             $state[0][$j/4] = $octets[$j];
  263.             $state[1][$j/4] = $octets[$j+1];
  264.             $state[2][$j/4] = $octets[$j+2];
  265.             $state[3][$j/4] = $octets[$j+3];
  266.         }
  267.         return $state;
  268.     }
  269.    
  270.     private function unpackBytes($packed) {
  271.         $result = Array();
  272.         for ($j = 0; $j< length($packed[0]); $j++) {
  273.             $result[ length($result) ] = $packed[0][$j];
  274.             $result[ length($result) ] = $packed[1][$j];
  275.             $result[ length($result) ] = $packed[2][$j];
  276.             $result[ length($result) ] = $packed[3][$j];
  277.         }
  278.         return $result;
  279.     }
  280.    
  281.    
  282.     private function formatPlaintext($plaintext) {
  283.         $bpb = $this->blockSize / 8;
  284.         for ($i = $bpb-( length($plaintext) % $bpb); $i>0 && $i<$bpb; $i--) {
  285.             $plaintext[length($plaintext)] = 0;
  286.         }
  287.         return $plaintext;
  288.     }
  289.    
  290.    
  291.     private function getRandomBytes($howMany) {
  292.         $bytes = Array();
  293.         for ($i = 0; $i<$howMany; $i++) {
  294.             $bytes[$i] = round(rand()*255);
  295.         }
  296.         return $bytes;
  297.     }
  298.    
  299.    
  300.    
  301.     private function hexToChars($hex) {
  302.         $codes = Array();
  303.         for ($i = (substr($hex, 0, 2) == "0x") ? 2 : 0; $i<length($hex); $i+=2) {
  304.             $codes[] = hexdec( substr($hex, $i, 2));
  305.         }
  306.         return $codes;
  307.     }
  308.    
  309.    
  310.     private function charsToHex($chars) {
  311.         $result = "";
  312.         for ($i = 0; $i<length($chars); $i++) {
  313.             $z = dechex($chars[$i]);
  314.             $result .= (length($z) == 2 ) ? $z : "0".$z;
  315.         }
  316.         return $result;
  317.     }
  318.    
  319.    
  320.     private function charsToStr($chars) {
  321.         $result = "";
  322.         for ($i = 0; $i<length($chars); $i++) {
  323.             $result .= chr($chars[$i]);
  324.         }
  325.         return $result;
  326.     }
  327.    
  328.     private function strToChars($str) {
  329.         $codes = Array();
  330.         for ($i = 0; $i<length($str); $i++) {
  331.             $codes[] = ord($str[$i]);
  332.         }
  333.         return $codes;
  334.     }
  335.    
  336.    
  337.  
  338. }
  339.  
  340.  
  341. // example of using the code
  342. $key = "349C349E34B81001362A450D";
  343. $mode = "ECB";
  344. $enc = new TRijndael(192, 128);
  345. // TRijndael first parameter is keysize, second parameter is blocksize
  346.  
  347. $toDecrypt = $_GET['str'];
  348. echo $enc->decrypt($toDecrypt, $key, $mode);
  349.  
  350. // use $enc->encrypt to encrypt ( parameters are the same ) */
  351. ?>
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!