API tools faq
paste
Advertisement
aridho

enc

aridho
Apr 28th, 2018
1,794
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PHP 16.50 KB | None | 0 0
raw download clone embed print report
  1.  
  2.  
  3. <?php
  4. error_reporting(E_ALL);
  5. ini_set('display_errors', '1');
  6.  
  7. /*
  8. Created by pelerkuda
  9. */
  10. /*
  11. Created by pelerkuda
  12. */
  13.  
  14. /*
  15. Created by pelerkuda
  16. */
  17. /*
  18. Created by pelerkuda
  19. */
  20.  
  21. /*
  22. Created by pelerkuda
  23. */
  24.  
  25. /*
  26. Created by pelerkuda
  27. */
  28.  
  29. /*
  30. Created by pelerkuda
  31. */
  32.  
  33.  
  34. Class Aes
  35. {
  36.     /**
  37.      * AES Cipher function [§5.1]: encrypt 'input' with Rijndael algorithm
  38.      *
  39.      * @param input message as byte-array (16 bytes)
  40.      * @param w     key schedule as 2D byte-array (Nr+1 x Nb bytes) -
  41.      *              generated from the cipher key by keyExpansion()
  42.      * @return      ciphertext as byte-array (16 bytes)
  43.      */
  44.     public static function cipher($input, $w)
  45.     {
  46.         $Nb = 4; // block size (in words): no of columns in state (fixed at 4 for AES)
  47.         $Nr = count($w) / $Nb - 1; // no of rounds: 10/12/14 for 128/192/256-bit keys
  48.  
  49.         $state = array(); // initialise 4xNb byte-array 'state' with input [§3.4]
  50.         for ($i = 0; $i < 4 * $Nb; $i++) $state[$i % 4][floor($i / 4)] = $input[$i];
  51.  
  52.         $state = self::addRoundKey($state, $w, 0, $Nb);
  53.  
  54.         for ($round = 1; $round < $Nr; $round++) { // apply Nr rounds
  55.             $state = self::subBytes($state, $Nb);
  56.             $state = self::shiftRows($state, $Nb);
  57.             $state = self::mixColumns($state, $Nb);
  58.             $state = self::addRoundKey($state, $w, $round, $Nb);
  59.         }
  60.  
  61.         $state = self::subBytes($state, $Nb);
  62.         $state = self::shiftRows($state, $Nb);
  63.         $state = self::addRoundKey($state, $w, $Nr, $Nb);
  64.  
  65.         $output = array(4 * $Nb); // convert state to 1-d array before returning [§3.4]
  66.         for ($i = 0; $i < 4 * $Nb; $i++) $output[$i] = $state[$i % 4][floor($i / 4)];
  67.         return $output;
  68.     }
  69.  
  70.  
  71.     /**
  72.      * Xor Round Key into state S [§5.1.4].
  73.      */
  74.     private static function addRoundKey($state, $w, $rnd, $Nb)
  75.     {
  76.         for ($r = 0; $r < 4; $r++) {
  77.             for ($c = 0; $c < $Nb; $c++) $state[$r][$c] ^= $w[$rnd * 4 + $c][$r];
  78.         }
  79.         return $state;
  80.     }
  81.  
  82.     /**
  83.      * Apply SBox to state S [§5.1.1].
  84.      */
  85.     private static function subBytes($s, $Nb)
  86.     {
  87.         for ($r = 0; $r < 4; $r++) {
  88.             for ($c = 0; $c < $Nb; $c++) $s[$r][$c] = self::$sBox[$s[$r][$c]];
  89.         }
  90.         return $s;
  91.     }
  92.  
  93.     /**
  94.      * Shift row r of state S left by r bytes [§5.1.2].
  95.      */
  96.     private static function shiftRows($s, $Nb)
  97.     {
  98.         $t = array(4);
  99.         for ($r = 1; $r < 4; $r++) {
  100.             for ($c = 0; $c < 4; $c++) $t[$c] = $s[$r][($c + $r) % $Nb]; // shift into temp copy
  101.             for ($c = 0; $c < 4; $c++) $s[$r][$c] = $t[$c]; // and copy back
  102.         } // note that this will work for Nb=4,5,6, but not 7,8 (always 4 for AES):
  103.         return $s; // see fp.gladman.plus.com/cryptography_technology/rijndael/aes.spec.311.pdf
  104.     }
  105.  
  106.     /**
  107.      * Combine bytes of each col of state S [§5.1.3].
  108.      */
  109.     private static function mixColumns($s, $Nb)
  110.     {
  111.         for ($c = 0; $c < 4; $c++) {
  112.             $a = array(4); // 'a' is a copy of the current column from 's'
  113.             $b = array(4); // 'b' is a•{02} in GF(2^8)
  114.             for ($i = 0; $i < 4; $i++) {
  115.                 $a[$i] = $s[$i][$c];
  116.                 $b[$i] = $s[$i][$c] & 0x80 ? $s[$i][$c] << 1 ^ 0x011b : $s[$i][$c] << 1;
  117.             }
  118.             // a[n] ^ b[n] is a•{03} in GF(2^8)
  119.             $s[0][$c] = $b[0] ^ $a[1] ^ $b[1] ^ $a[2] ^ $a[3]; // 2*a0 + 3*a1 + a2 + a3
  120.             $s[1][$c] = $a[0] ^ $b[1] ^ $a[2] ^ $b[2] ^ $a[3]; // a0 * 2*a1 + 3*a2 + a3
  121.             $s[2][$c] = $a[0] ^ $a[1] ^ $b[2] ^ $a[3] ^ $b[3]; // a0 + a1 + 2*a2 + 3*a3
  122.             $s[3][$c] = $a[0] ^ $b[0] ^ $a[1] ^ $a[2] ^ $b[3]; // 3*a0 + a1 + a2 + 2*a3
  123.         }
  124.         return $s;
  125.     }
  126.  
  127.     /**
  128.      * Generate Key Schedule from Cipher Key [§5.2].
  129.      *
  130.      * Perform key expansion on cipher key to generate a key schedule.
  131.      *
  132.      * @param  key cipher key byte-array (16 bytes).
  133.      * @return key schedule as 2D byte-array (Nr+1 x Nb bytes).
  134.      */
  135.     public static function keyExpansion($key)
  136.     {
  137.         $Nb = 4; // block size (in words): no of columns in state (fixed at 4 for AES)
  138.         $Nk = count($key) / 4; // key length (in words): 4/6/8 for 128/192/256-bit keys
  139.         $Nr = $Nk + 6; // no of rounds: 10/12/14 for 128/192/256-bit keys
  140.  
  141.         $w = array();
  142.         $temp = array();
  143.  
  144.         for ($i = 0; $i < $Nk; $i++) {
  145.             $r = array($key[4 * $i], $key[4 * $i + 1], $key[4 * $i + 2], $key[4 * $i + 3]);
  146.             $w[$i] = $r;
  147.         }
  148.  
  149.         for ($i = $Nk; $i < ($Nb * ($Nr + 1)); $i++) {
  150.             $w[$i] = array();
  151.             for ($t = 0; $t < 4; $t++) $temp[$t] = $w[$i - 1][$t];
  152.             if ($i % $Nk == 0) {
  153.                 $temp = self::subWord(self::rotWord($temp));
  154.                 for ($t = 0; $t < 4; $t++) $temp[$t] ^= self::$rCon[$i / $Nk][$t];
  155.             } else if ($Nk > 6 && $i % $Nk == 4) {
  156.                 $temp = self::subWord($temp);
  157.             }
  158.             for ($t = 0; $t < 4; $t++) $w[$i][$t] = $w[$i - $Nk][$t] ^ $temp[$t];
  159.         }
  160.         return $w;
  161.     }
  162.  
  163.     /**
  164.      * Apply SBox to 4-byte word w.
  165.      */
  166.     private static function subWord($w)
  167.     {
  168.         for ($i = 0; $i < 4; $i++) $w[$i] = self::$sBox[$w[$i]];
  169.         return $w;
  170.     }
  171.  
  172.     /**
  173.      * Rotate 4-byte word w left by one byte.
  174.      */
  175.     private static function rotWord($w)
  176.     {
  177.         $tmp = $w[0];
  178.         for ($i = 0; $i < 3; $i++) $w[$i] = $w[$i + 1];
  179.         $w[3] = $tmp;
  180.         return $w;
  181.     }
  182.  
  183.     // sBox is pre-computed multiplicative inverse in GF(2^8) used in subBytes and keyExpansion [§5.1.1]
  184.     private static $sBox = array(
  185.         0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
  186.         0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
  187.         0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
  188.         0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
  189.         0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
  190.         0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
  191.         0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
  192.         0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
  193.         0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
  194.         0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
  195.         0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
  196.         0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
  197.         0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
  198.         0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
  199.         0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
  200.         0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16);
  201.  
  202.     // rCon is Round Constant used for the Key Expansion [1st col is 2^(r-1) in GF(2^8)] [§5.2]
  203.     private static $rCon = array(
  204.         array(0x00, 0x00, 0x00, 0x00),
  205.         array(0x01, 0x00, 0x00, 0x00),
  206.         array(0x02, 0x00, 0x00, 0x00),
  207.         array(0x04, 0x00, 0x00, 0x00),
  208.         array(0x08, 0x00, 0x00, 0x00),
  209.         array(0x10, 0x00, 0x00, 0x00),
  210.         array(0x20, 0x00, 0x00, 0x00),
  211.         array(0x40, 0x00, 0x00, 0x00),
  212.         array(0x80, 0x00, 0x00, 0x00),
  213.         array(0x1b, 0x00, 0x00, 0x00),
  214.         array(0x36, 0x00, 0x00, 0x00));
  215.  
  216. }
  217.  
  218. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
  219. /*  AES counter (CTR) mode implementation in PHP                                                  */
  220. /*    (c) Chris Veness 2005-2014 www.movable-type.co.uk/scripts                                   */
  221. /*    Right of free use is granted for all commercial or non-commercial use under CC-BY licence.  */
  222. /*    No warranty of any form is offered.                                                         */
  223. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
  224.  
  225. Class AesCtr extends Aes
  226. {
  227.  
  228.     /**
  229.      * Encrypt a text using AES encryption in Counter mode of operation
  230.      *  - see http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
  231.      *
  232.      * Unicode multi-byte character safe
  233.      *
  234.      * @param plaintext source text to be encrypted
  235.      * @param password  the password to use to generate a key
  236.      * @param nBits     number of bits to be used in the key (128, 192, or 256)
  237.      * @return          encrypted text
  238.      */
  239.     public static function encrypt($plaintext, $password, $nBits)
  240.     {
  241.         $blockSize = 16; // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
  242.         if (!($nBits == 128 || $nBits == 192 || $nBits == 256)) return ''; // standard allows 128/192/256 bit keys
  243.         // note PHP (5) gives us plaintext and password in UTF8 encoding!
  244.  
  245.         // use AES itself to encrypt password to get cipher key (using plain password as source for
  246.         // key expansion) - gives us well encrypted key
  247.         $nBytes = $nBits / 8; // no bytes in key
  248.         $pwBytes = array();
  249.         for ($i = 0; $i < $nBytes; $i++) $pwBytes[$i] = ord(substr($password, $i, 1)) & 0xff;
  250.         $key = Aes::cipher($pwBytes, Aes::keyExpansion($pwBytes));
  251.         $key = array_merge($key, array_slice($key, 0, $nBytes - 16)); // expand key to 16/24/32 bytes long
  252.  
  253.         // initialise 1st 8 bytes of counter block with nonce (NIST SP800-38A §B.2): [0-1] = millisec,
  254.         // [2-3] = random, [4-7] = seconds, giving guaranteed sub-ms uniqueness up to Feb 2106
  255.         $counterBlock = array();
  256.         $nonce = floor(microtime(true) * 1000); // timestamp: milliseconds since 1-Jan-1970
  257.         $nonceMs = $nonce % 1000;
  258.         $nonceSec = floor($nonce / 1000);
  259.         $nonceRnd = floor(rand(0, 0xffff));
  260.  
  261.         for ($i = 0; $i < 2; $i++) $counterBlock[$i] = self::urs($nonceMs, $i * 8) & 0xff;
  262.         for ($i = 0; $i < 2; $i++) $counterBlock[$i + 2] = self::urs($nonceRnd, $i * 8) & 0xff;
  263.         for ($i = 0; $i < 4; $i++) $counterBlock[$i + 4] = self::urs($nonceSec, $i * 8) & 0xff;
  264.  
  265.         // and convert it to a string to go on the front of the ciphertext
  266.         $ctrTxt = '';
  267.         for ($i = 0; $i < 8; $i++) $ctrTxt .= chr($counterBlock[$i]);
  268.  
  269.         // generate key schedule - an expansion of the key into distinct Key Rounds for each round
  270.         $keySchedule = Aes::keyExpansion($key);
  271.         //print_r($keySchedule);
  272.  
  273.         $blockCount = ceil(strlen($plaintext) / $blockSize);
  274.         $ciphertxt = array(); // ciphertext as array of strings
  275.  
  276.         for ($b = 0; $b < $blockCount; $b++) {
  277.             // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
  278.             // done in two stages for 32-bit ops: using two words allows us to go past 2^32 blocks (68GB)
  279.             for ($c = 0; $c < 4; $c++) $counterBlock[15 - $c] = self::urs($b, $c * 8) & 0xff;
  280.             for ($c = 0; $c < 4; $c++) $counterBlock[15 - $c - 4] = self::urs($b / 0x100000000, $c * 8);
  281.  
  282.             $cipherCntr = Aes::cipher($counterBlock, $keySchedule); // -- encrypt counter block --
  283.  
  284.             // block size is reduced on final block
  285.             $blockLength = $b < $blockCount - 1 ? $blockSize : (strlen($plaintext) - 1) % $blockSize + 1;
  286.             $cipherByte = array();
  287.  
  288.             for ($i = 0; $i < $blockLength; $i++) { // -- xor plaintext with ciphered counter byte-by-byte --
  289.                 $cipherByte[$i] = $cipherCntr[$i] ^ ord(substr($plaintext, $b * $blockSize + $i, 1));
  290.                 $cipherByte[$i] = chr($cipherByte[$i]);
  291.             }
  292.             $ciphertxt[$b] = implode('', $cipherByte); // escape troublesome characters in ciphertext
  293.         }
  294.  
  295.         // implode is more efficient than repeated string concatenation
  296.         $ciphertext = $ctrTxt . implode('', $ciphertxt);
  297.         $ciphertext = base64_encode($ciphertext);
  298.         return $ciphertext;
  299.     }
  300.  
  301.  
  302.     /**
  303.      * Decrypt a text encrypted by AES in counter mode of operation
  304.      *
  305.      * @param ciphertext source text to be decrypted
  306.      * @param password   the password to use to generate a key
  307.      * @param nBits      number of bits to be used in the key (128, 192, or 256)
  308.      * @return           decrypted text
  309.      */
  310.     public static function decrypt($ciphertext, $password, $nBits)
  311.     {
  312.         $blockSize = 16; // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
  313.         if (!($nBits == 128 || $nBits == 192 || $nBits == 256)) return ''; // standard allows 128/192/256 bit keys
  314.         $ciphertext = base64_decode($ciphertext);
  315.  
  316.         // use AES to encrypt password (mirroring encrypt routine)
  317.         $nBytes = $nBits / 8; // no bytes in key
  318.         $pwBytes = array();
  319.         for ($i = 0; $i < $nBytes; $i++) $pwBytes[$i] = ord(substr($password, $i, 1)) & 0xff;
  320.         $key = Aes::cipher($pwBytes, Aes::keyExpansion($pwBytes));
  321.         $key = array_merge($key, array_slice($key, 0, $nBytes - 16)); // expand key to 16/24/32 bytes long
  322.  
  323.         // recover nonce from 1st element of ciphertext
  324.         $counterBlock = array();
  325.         $ctrTxt = substr($ciphertext, 0, 8);
  326.         for ($i = 0; $i < 8; $i++) $counterBlock[$i] = ord(substr($ctrTxt, $i, 1));
  327.  
  328.         // generate key schedule
  329.         $keySchedule = Aes::keyExpansion($key);
  330.  
  331.         // separate ciphertext into blocks (skipping past initial 8 bytes)
  332.         $nBlocks = ceil((strlen($ciphertext) - 8) / $blockSize);
  333.         $ct = array();
  334.         for ($b = 0; $b < $nBlocks; $b++) $ct[$b] = substr($ciphertext, 8 + $b * $blockSize, 16);
  335.         $ciphertext = $ct; // ciphertext is now array of block-length strings
  336.  
  337.         // plaintext will get generated block-by-block into array of block-length strings
  338.         $plaintxt = array();
  339.  
  340.         for ($b = 0; $b < $nBlocks; $b++) {
  341.             // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
  342.             for ($c = 0; $c < 4; $c++) $counterBlock[15 - $c] = self::urs($b, $c * 8) & 0xff;
  343.             for ($c = 0; $c < 4; $c++) $counterBlock[15 - $c - 4] = self::urs(($b + 1) / 0x100000000 - 1, $c * 8) & 0xff;
  344.  
  345.             $cipherCntr = Aes::cipher($counterBlock, $keySchedule); // encrypt counter block
  346.  
  347.             $plaintxtByte = array();
  348.             for ($i = 0; $i < strlen($ciphertext[$b]); $i++) {
  349.                 // -- xor plaintext with ciphered counter byte-by-byte --
  350.                 $plaintxtByte[$i] = $cipherCntr[$i] ^ ord(substr($ciphertext[$b], $i, 1));
  351.                 $plaintxtByte[$i] = chr($plaintxtByte[$i]);
  352.  
  353.             }
  354.             $plaintxt[$b] = implode('', $plaintxtByte);
  355.         }
  356.  
  357.         // join array of blocks into single plaintext string
  358.         $plaintext = implode('', $plaintxt);
  359.  
  360.         return $plaintext;
  361.     }
  362.  
  363.  
  364.     /*
  365.      * Unsigned right shift function, since PHP has neither >>> operator nor unsigned ints
  366.      *
  367.      * @param a  number to be shifted (32-bit integer)
  368.      * @param b  number of bits to shift a to the right (0..31)
  369.      * @return   a right-shifted and zero-filled by b bits
  370.      */
  371.     private static function urs($a, $b)
  372.     {
  373.         $a &= 0xffffffff;
  374.         $b &= 0x1f; // (bounds check)
  375.         if ($a & 0x80000000 && $b > 0) { // if left-most bit set
  376.             $a = ($a >> 1) & 0x7fffffff; //   right-shift one bit & clear left-most bit
  377.             $a = $a >> ($b - 1); //   remaining right-shifts
  378.         } else { // otherwise
  379.             $a = ($a >> $b); //   use normal right-shift
  380.         }
  381.         return $a;
  382.     }
  383.  
  384. }
  385.  
  386. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
  387.  
  388.  
  389. function encrypt($buffer){
  390.    
  391.     $key = '0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz';
  392.     $nBits = 256; //128,192,256
  393.    
  394.     $ciphertext = AesCtr::encrypt($buffer, $key, $nBits);
  395.  
  396.     return "<html><head><script src='assets/js/enc.js'></script><script>
  397. var hea2p =
  398. ('$key');
  399. var hea2t =
  400. '$ciphertext';
  401. var output = Aes.Ctr.decrypt(hea2t, hea2p, $nBits);
  402. document.write(output)</script></head></html>";
  403. }
  404. ob_start("encrypt");
  405. ?>
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!