PHP implementation AES256 Encryption algorithm instance _php skill

This article describes the PHP implementation of AES256 encryption algorithm, is a more common encryption algorithm. Share to everyone for your reference. Specifically as follows:

aes.class.php files are as follows:

<?php/*--------------------------------------* * * AES IMP Lementation in PHP (c) Chris Veness 2005-2011. Right's free to use is granted to all/* commercial or non-commercial use under cc-by licence.  No warranty of any of the form is offered. 
  
 * */*------------------------------------------------/class Aes { /** * AES Cipher function:encrypt ' input ' with Rijndael algorithm * * @param input message as Byte-array (16 bytes) * @param w key schedule as 2D Byte-array (nr+1 x Nb bytes)-* generated from the cipher key by Keyex Pansion () * @return ciphertext as Byte-array (bytes) */public static function cipher ($input, $w) {//Main         cipher function [§5.1] $Nb = 4; Block size (in words): No to Columns in state (fixed at 4 for AES) $Nr = count ($w)/$Nb-1; No of ROUNDS:10/12/14 for 128/192/256-bit keys $state = Array (); Initialise 4xNb byte-array ' state ' with input [§3.4] for ($i =0; $i <4* $Nb; $i + +) $state [$i%4][floor ($i/4)] = $inpu 
  
  t[$i]; 
  
  $state = Self::addroundkey ($state, $w, 0, $Nb); 
   For ($round =1 $round < $Nr; $round + +) {//apply Nr rounds $state = Self::subbytes ($state, $Nb); 
   $state = Self::shiftrows ($state, $Nb); 
   $state = Self::mixcolumns ($state, $Nb); 
  $state = Self::addroundkey ($state, $w, $round, $Nb); 
  } $state = Self::subbytes ($state, $Nb); 
  $state = Self::shiftrows ($state, $Nb); 
  
  $state = Self::addroundkey ($state, $w, $Nr, $Nb); $output = Array (4* $Nb); Convert state to 1-d array before returning [§3.4] for ($i =0; $i <4* $Nb; $i + +) $output [$i] = $state [$i%4][floor ($i 
  /4)]; 
 return $output; private static function AddRoundKey ($state, $w, $rnd, $Nb) {//XOR Round Key into state S [§5.1.4] for ($r =0 ; $r <4; 
  $r + +) {for ($c =0; $c < $Nb; $c + +) $state [$r] [$c] ^= $w [$rnd *4+ $c] [$r]; Return $state; private static function subbytes ($s, $Nb) {//apply Sbox to state S [§5.1.1] for ($r =0; $r <4; $r + +) {F 
  or ($c =0; $c < $Nb; $c + +) $s [$r] [$c] = self:: $sBox [$s [$r] [$c]]; 
 return $s; 
  The private static function shiftrows ($s, $Nb) {//shift row R of state s left by R bytes [§5.1.2] $t = Array (4);  For ($r =1 $r <4; $r + +) {for ($c =0; $c <4; $c + +) $t [$c] = $s [$r] [($c + $r)% $Nb];//shift in temp copy for      ($c =0 $c <4; $c + +) $s [$r] [$c] = $t [$c]; and copy back}//"This'll work for nb=4,5,6, but not 7,8 (always 4 for AES): return $s; Fp.gladman.plus.com/cryptography_technology/rijndael/aes.spec.311.pdf} private static function Mixcolumns (  $s, $Nb) {//combine bytes of each col of the state S [§5.1.3] for ($c =0; $c <4; $c + +) {$a = array (4);//' A ' is a Copy of the current column from ' s ' $b = Array (4); ' B ' is a {02} into GF (2^8) for ($i =0; $i <4; $i + +) {$a [$i] = $s [$i] [$C]; $b [$i] = $s [$i] [$c]&0x80? 
   $s [$i] [$c]<<1 ^ 0x011b: $s [$i] [$c]]<<1; }//A[n] ^ b[n] is a {03} in GF (2^8) $s [0][$c] = $b [0] ^ $a [1] ^ $b [1] ^ $a [2] ^ $a [3]; 2*A0 + 3*a1 + a2 + A3 $s [1][$c] = $a [0] ^ $b [1] ^ $a [2] ^ $b [2] ^ $a [3]; A0 * 2*A1 + 3*A2 + A3 $s [2][$c] = $a [0] ^ $a [1] ^ $b [2] ^ $a [3] ^ $b [3]; A0 + A1 + 2*a2 + 3*a3 $s [3][$c] = $a [0] ^ $b [0] ^ $a [1] ^ $a [2] ^ $b [3]; 
 3*A0 + A1 + a2 + 2*a3} return $s; 
  }/** * Key expansion for Rijndael cipher (): Performs key expansion in cipher key * to generate a key schedule 
 * @param key Cipher Key Byte-array (bytes) * @return Key Schedule as 2D Byte-array (nr+1 x Nb bytes) * *       public static function Keyexpansion ($key) {//Generate key Schedule from Cipher key [§5.2] $Nb = 4; Block size (in words): No to Columns in state (fixed at 4 for AES) $Nk = count ($key)/4; Key length (in words): 4/6/8 for 128/192/256-bit keys $Nr = $Nk+ 6; 
  No of ROUNDS:10/12/14 for 128/192/256-bit keys $w = Array (); 
  
  $temp = Array (); 
   For ($i =0 $i < $Nk $i + +) {$r = Array ($key [4* $i], $key [4* $i +1], $key [4* $i +2], $key [4* $i +3]); 
  $w [$i] = $r; 
   for ($i = $Nk; $i < ($NB * ($Nr + 1); $i + +) {$w [$i] = array (); 
   For ($t =0 $t <4; $t + +) $temp [$t] = $w [$i -1][$t]; 
    if ($i% $Nk = = 0) {$temp = Self::subword (Self::rotword ($temp)); 
   For ($t =0 $t <4; $t + +) $temp [$t] ^= self:: $rCon [$i/$Nk] [$t]; 
   else if ($Nk > 6 && $i% $Nk = = 4) {$temp = Self::subword ($temp); 
  For ($t =0 $t <4; $t + +) $w [$i] [$t] = $w [$i-$Nk] [$t] ^ $temp [$t]; 
 return $w; private static function Subword ($w) {//apply Sbox to 4-byte Word w for ($i =0; $i <4; $i + +) $w [$i] = self::$ 
  sbox[$w [$i]]; 
 return $w; 
  The private static function Rotword ($w) {//rotate 4-byte word w left by one byte $tmp = $w [0]; 
  For ($i =0 $i <3; $i + +) $w [$i] = $w [$i +1]; $w [3] = $tmP 
 return $w; }//Sbox is pre-computed multiplicative inverse in GF (2^8) used in Subbytes and Keyexpansion [§5.1.1] Private stat IC $sBox = Array (0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76, 0xca,0x82,0xc9,0 X7D,0XFA,0X59,0X47,0XF0,0XAD,0XD4,0XA2,0XAF,0X9C,0XA4,0X72,0XC0, 0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34, 0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15, 0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2, 0x75, 0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84, 0x53,0xd1,0x00,0xed,0x20, 0XFC,0XB1,0X5B,0X6A,0XCB,0XBE,0X39,0X4A,0X4C,0X58,0XCF, 0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02, 0x7f,0x50,0x3c,0x9f,0xa8, 0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2, 0xCD, 0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73, 0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90, 
0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,  0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79, 0xe7,0xc8,0x37,0x6d,0x8d,0xd5, 0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08, 0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f, 0x4b,0xbd,0x8b,0x8a, 0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e, 0xe1,0xf8, 0X98,0X11,0X69,0XD9,0X8E,0X94,0X9B,0X1E,0X87,0XE9,0XCE,0X55,0X28,0XDF, 0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68, 
  
 0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16); RCon is Round Constant used for the Key expansion [1st Col-2^ (r-1) in GF (2^8)] [§5.2] private static $rCon = array (Array (0x00, 0x00, 0x00, 0x00), Array (0x01, 0x00, 0x00, 0x00), Array (0x02, 0x00, 0x00, 0x00), Array (0x04, 0x 
  0x00, 0x00), Array (0x08, 0x00, 0x00, 0x00), Array (0x10, 0x00, 0x00, 0x00), Array (0x20, 0x00, 0x00, 0x00), Array (0x40, 0x00, 0x00, 0x00), Array (0x80, 0x00, 0x00, 0x00), Array (0x1b, 0x00, 0x00, 0x00), Array (0x36, 0x00, 0x 10M 0x00));

 }?>

The

aesctr.class.php file is as follows:

<?php/*-----------------------------------------------*//AES Cou Nter (CTR) mode implementation in PHP (c) Chris Veness 2005-2011. Right's free use is////* Granted for all commercial or non-commercial use under cc-by licence.                                      No warranty of any *///* form is offered. */*---------------------------------------------------------------aesctr Xtends Aes {/** * Encrypt a text using Aes encryption in Counter mode of operation *- V/publications/nistpubs/800-38a/sp800-38a.pdf * * Unicode multi-byte Character Safe * * @param plaintext SOURC  E-Text to is encrypted * @param password the password to-generate a key * @param nbits number of bits to IS Used in the key (128, 256) * @param keep keep 1:each not change 0:each change (default) * @return ENCR ypted text */PUBlic static function Encrypt ($plaintext, $password, $nBits, $keep =0) {$blockSize = N//block size fixed at bytes /128 bits (nb=4) for AES if (!) ( $nBits ==128 | | $nBits ==192 | | $nBits ==256)) return "; 
   
  Standard allows 128/192/256 bit keys//PHP (5) gives us plaintext and password in UTF8 encoding! Use AES itself to encrypt password to get cipher key (using plain password as source for//key expansion)-gives US-encrypted key $nBytes = $nBits/8; 
  No bytes in key $pwBytes = Array (); 
  For ($i =0 $i < $nBytes; $i + +) $pwBytes [$i] = Ord (substr ($password, $i, 1)) & 0xFF; 
  $key = Aes::cipher ($pwBytes, Aes::keyexpansion ($pwBytes)); $key = Array_merge ($key, Array_slice ($key, 0, $nBytes-16)); Expand key to 16/24/32 bytes Long//initialise 1st 8 bytes of counter of blocks with Nonce (NIST sp800-38a§b.2): [ 0-1] = millisec,//[2-3] = random, [4-7] = seconds, giving guaranteed sub-ms up to uniqueness Feb $counterBlo Ck= Array ();  if ($keep ==0) {$nonce = Floor (Microtime (true) *1000); 
    Timestamp:milliseconds since 1-jan-1970 $nonceMs = $nonce% 1000; 
    $nonceSec = Floor ($nonce/1000); 
  $nonceRnd = Floor (rand (0, 0xFFFF)); 
    }else{$nonce = 10000; 
    $nonceMs = $nonce% 1000; 
    $nonceSec = Floor ($nonce/1000); 
  $nonceRnd = 10000; 
  For ($i =0 $i <2; $i + +) $counterBlock [$i] = Self::urs ($nonceMs, $i *8) & 0xFF; 
  For ($i =0 $i <2; $i + +) $counterBlock [$i +2] = self::urs ($nonceRnd, $i *8) & 0xFF; 
   
  For ($i =0 $i <4; $i + +) $counterBlock [$i +4] = self::urs ($nonceSec, $i *8) & 0xFF; 
  and convert it to a string "go" on the front of the ciphertext $ctrTxt = '; 
  
  For ($i =0 $i <8; $i + +) $ctrTxt. = Chr ($counterBlock [$i]); Generate key Schedule-an expansion of the key into distinct key Rounds to each round $keySchedule = Aes::keyexpan 
  Sion ($key); 
   
  Print_r ($keySchedule); $blockCount = Ceil (strlen ($plaintext)/$blockSize); $ciphertxt = Array (); Ciphertext as array of strings for ($b =0; $b < $blockCount; $b + +) {//Set counter (Block #) at last 8 byte S of counter block (leaving Nonce in 1st 8 bytes)/Do in two stages for 32-bit ops:using Two words allows us to G 
   O Past 2^32 blocks (68GB) for ($c =0; $c <4; $c + +) $counterBlock [15-$c] = self::urs ($b, $c *8) & 0xFF; 
  
   For ($c =0 $c <4; $c + +) $counterBlock [15-$c-4] = self::urs ($b/0x100000000, $c *8); $cipherCntr = Aes::cipher ($counterBlock, $keySchedule); --Encrypt counter block--//blocks size is reduced on final block $blockLength = $b < $blockCount-1? 
   $blockSize: (strlen ($plaintext)-1)% $blockSize +1; 
    
   $cipherByte = Array (); For ($i =0 $i < $blockLength; $i + +) {//--XOR plaintext with ciphered counter byte-by-byte--$cipherByte [$i] = $c 
    iphercntr[$i] ^ ord (substr ($plaintext, $b * $blockSize + $i, 1)); 
   $cipherByte [$i] = Chr ($cipherByte [$i]); } $ciphertxt [$b] = ImplOde (", $cipherByte); 
  Escape troublesome characters in ciphertext}//implode are more efficient than string repeated $ciphertext = $ctrTxt. 
  Implode (", $ciphertxt); 
  $ciphertext = Base64_encode ($ciphertext); 
 return $ciphertext;  }/** * Decrypt a text encrypted by AES in counter mode of operation * * @param ciphertext source text to IS decrypted * @param password the password to "generate a key * @param nbits number of bits to is used in th E Key (128, 256) * @return decrypted text */public static function decrypt ($ciphertext, $password, $ nbits) {$blockSize =//block size fixed in bytes/128 bits (nb=4) for AES if (! $nBits ==128 | | $nBits ==192 | | $nBits ==256)) return "; 
  
  Standard allows 128/192/256 bit keys $ciphertext = Base64_decode ($ciphertext); Use AES to encrypt password (mirroring encrypt routine) $nBytes = $nBits/8; 
 No bytes in key $pwBytes = Array (); For ($i =0 $i < $nBytes; $i + +) $pwBytes [$i] = Ord (substr ($password, $i, 1)) & 0xFF; 
  $key = Aes::cipher ($pwBytes, Aes::keyexpansion ($pwBytes)); $key = Array_merge ($key, Array_slice ($key, 0, $nBytes-16)); 
  Expand key to 16/24/32 bytes long//recover Nonce from 1st element of ciphertext $counterBlock = Array (); 
  $CTRTXT = substr ($ciphertext, 0, 8); 
   
  For ($i =0 $i <8; $i + +) $counterBlock [$i] = Ord (substr ($ctrTxt, $i, 1)); 
  
  Generate key Schedule $keySchedule = Aes::keyexpansion ($key); Separate ciphertext into blocks (skipping past initial 8 bytes) $nBlocks = Ceil ((strlen ($ciphertext) -8)/$blockSize 
  ); 
  $CT = Array (); 
  For ($b =0 $b < $nBlocks; $b + +) $ct [$b] = substr ($ciphertext, 8+ $b * $blockSize, 16); $ciphertext = $CT; Ciphertext is now array block-length strings//plaintext'll get generated block-by-block to array of bloc 
   
  K-length Strings $plaintxt = Array (); for ($b =0; $b < $nBlocks; $b + +) {//Set COunter (Block #) in the last 8 bytes of counter blocks (leaving nonce in 1st 8 bytes) for ($c =0; $c <4; $c + +) $counterBlo 
   ck[15-$c] = self::urs ($b, $c *8) & 0xFF; 
  
   For ($c =0 $c <4; $c + +) $counterBlock [15-$c-4] = Self::urs (($b + 1)/0x100000000-1, $c *8) & 0xFF; $cipherCntr = Aes::cipher ($counterBlock, $keySchedule); 
   Encrypt counter block $plaintxtByte = Array (); For ($i =0 $i <strlen ($ciphertext [$b]); $i + +) {//--XOR plaintext with ciphered counter byte-by-byte--$pla 
    intxtbyte[$i] = $cipherCntr [$i] ^ ord (substr ($ciphertext [$b], $i, 1)); 
    
   $plaintxtByte [$i] = Chr ($plaintxtByte [$i]);  
  $plaintxt [$b] = implode (', $plaintxtByte); 
   
  }//join array of blocks into single plaintext string $plaintext = Implode (', $plaintxt); 
 return $plaintext; } * * Unsigned right shift function, since PHP has neither >>> operator nor Unsigned ints * * @par Am a number to is shifted (32-bit integer) * @parAm B number of bits to shift a to the right (0..31) * @return a right-shifted and zero-filled by b bits * * privat e static function urs ($a, $b) {$a &= 0xffffffff; $b &= 0x1f;//(Bounds check) if ($a &0x80000000 && Amp  $b >0) {//if left-most bit set $a = ($a >>1) & 0x7fffffff;      Right-shift one bit & clear left-most bit $a = $a >> ($b-1);        Remaining Right-shifts} else {//otherwise $a = ($a >> $b);  
 Use normal right-shift} return $a;

 }}?>

Demo Example program is as follows:

<?php  
require ' aes.class.php ';   AES PHP implementation 
require ' aesctr.class.php '//AES Counter Mode implementation  
 
Echo ' each change<br& gt; '; 
 
$mstr = Aesctr::encrypt (' Hello world ', ' key ', 256); 
echo "Encrypt String: $mstr <br/>"; 
 
$dstr = aesctr::d ecrypt ($mstr, ' key ', 256); 
echo "Decrypt String: $dstr <br/>"; 
 
Echo ' Each not change<br> '; 
 
$mstr = Aesctr::encrypt (' Hello world ', ' key ', 256, 1); Keep=1 
echo "Encrypt String: $mstr <br/>"; 
 
$dstr = aesctr::d ecrypt ($mstr, ' key ', 256); 
echo "Decrypt String: $dstr <br/>"; 
? > 

Here's another way to use PHP mcrypt plus decryption:

/* AES 256 Encrypt 
* @param string $ostr 
* @param string $securekey 
* @param string $type encrypt, decrypt
   
    */ 
function Aes ($OSTR, $securekey, $type = ' encrypt ') { 
  if ($ostr = = ') {return 
    '; 
  } 
   
  $key = $securekey; 
  $iv = Strrev ($securekey); 
  $TD = Mcrypt_module_open (' rijndael-256 ', ', ', ' ofb ', '); 
  Mcrypt_generic_init ($TD, $key, $iv); 
 
  $str = '; 
 
  Switch ($type) {case 
    ' encrypt ': 
      $str = Base64_encode (Mcrypt_generic ($TD, $ostr)); 
      break; 
 
    Case ' decrypt ': 
      $str = Mdecrypt_generic ($TD, Base64_decode ($OSTR)); 
      break; 
 
  Mcrypt_generic_deinit ($TD); 
 
  return $str; 
} 
 
Demo 
$key = "fdipzone201314showmethemoney!@#$"; 
$str = "Show Me the Money"; 
 
$OSTR = AES ($STR, $key); 
echo "String 1: $ostr <br/>"; 
 
$DSTR = AES ($OSTR, $key, ' decrypt '); 
echo "String 2: $dstr <br/>";


   

I hope this article will help you with the learning of PHP programming.