odd_job/extend/OneSm/Sm4.php

<?php
namespace OneSm;

class SM4
{
	private $sbox = [
        0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05,
        0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
        0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62,
        0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6,
        0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8,
        0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35,
        0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87,
        0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e,
        0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1,
        0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3,
        0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f,
        0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51,
        0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8,
        0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0,
        0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84,
        0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48
    ];

    private $ck = [
        0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
        0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
        0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,
        0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
        0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,
        0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
        0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,
        0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279
    ];

    private $fk = [0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC];

    private $len = 16;

    private $key;

    private $iv;

    private $encryptRoundKeys;

    private $decryptRoundKeys;

    private $revLookup;

    public function __construct($key, $iv)
    {
        $keyBuffer = $this->stringToArrayBufferInUtf8($key);

        if(count($keyBuffer) != $this->len){
        	throw new \Exception('秘钥长度必须为16位');
        }

        $this->key = $keyBuffer;

        $ivBuffer = $this->stringToArrayBufferInUtf8($iv);

        if(count($ivBuffer) != $this->len){
        	throw new \Exception('偏移量长度必须为16位');
        }

        $this->iv = $ivBuffer;

        $encryptRoundKeys = [];

        $this->encryptRoundKeys = array_pad($encryptRoundKeys, 32, 0);

        $this->spawnEncryptRoundKeys();

        $this->decryptRoundKeys = array_reverse($this->encryptRoundKeys);
        

        $code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
		for ($i = 0, $len = strlen($code); $i < $len; ++$i) {
			$this->revLookup[$this->get_bianma(substr($code, $i, 1))] = $i;
		}
		$this->revLookup[$this->get_bianma(substr('-', 0, 1))] = 62;
		$this->revLookup[$this->get_bianma(substr('_', 0, 1))] = 63;
    }

    private function stringToArrayBufferInUtf8($str)
    {
    	$arr = str_split($str);
    	foreach ($arr as &$v) {
    		$v = ord($v);
    	}

        return $arr;
    }

    private function spawnEncryptRoundKeys()
    {
    	$mk = [];

    	$mk[0] = ($this->ll($this->key[0],24)) | ($this->ll($this->key[1],16)) | ($this->ll($this->key[2],8)) | $this->key[3];

    	$mk[1] = ($this->ll($this->key[4],24)) | ($this->ll($this->key[5],16)) | ($this->ll($this->key[6],8)) | $this->key[7];

    	$mk[2] = ($this->ll($this->key[8],24)) | ($this->ll($this->key[9],16)) | ($this->ll($this->key[10],8)) | $this->key[11];

    	$mk[3] = ($this->ll($this->key[12],24)) | ($this->ll($this->key[13],16)) | ($this->ll($this->key[14],8)) | $this->key[15];

    	$k = [];

    	$k[0] = $mk[0] ^ $this->fk[0];
	    $k[1] = $mk[1] ^ $this->fk[1];
	    $k[2] = $mk[2] ^ $this->fk[2];
	    $k[3] = $mk[3] ^ $this->fk[3];

	    for ($i = 0; $i < 32; $i++) {
			$k[$i + 4] =
			$k[$i] ^ $this->tTransform2($k[$i + 1] ^ $k[$i + 2] ^ $k[$i + 3] ^ $this->ck[$i]);
			$this->encryptRoundKeys[$i] = $k[$i + 4];
		}
    }

    private function tauTransform($a)
    {
    	return ($this->ll($this->sbox[$this->uright($a, 24) & 0xff],24)) | ($this->ll($this->sbox[$this->uright($a, 16) & 0xff],16)) | ($this->ll($this->sbox[$this->uright($a, 8) & 0xff],8)) | $this->sbox[$a & 0xff];
    }

    private function tTransform1($z)
    {
    	$b = $this->tauTransform($z);
	    $c = $this->linearTransform1($b);
	    return $c;
    }

    private function tTransform2($z)
    {
    	$b = $this->tauTransform($z);
	    $c = $this->linearTransform2($b);
	    return $c;
    }

    private function linearTransform1($b)
    {
    	return ($b ^ $this->rotateLeft($b, 2) ^ $this->rotateLeft($b, 10) ^ $this->rotateLeft($b, 18) ^ $this->rotateLeft($b, 24));
    }

    private function linearTransform2($b)
    {
    	return $b ^ $this->rotateLeft($b, 13) ^ $this->rotateLeft($b, 23);
    }

    private function rotateLeft($x, $y)
    {
		return ($this->ll($x,$y)) | $this->uright($x, (32 - $y));
    }

    private function dePadding($paddedBuffer)
    {
    	if ($paddedBuffer === null) {
	      	return null;
	    }
	    $paddingLength = $paddedBuffer[count($paddedBuffer) - 1];
	    $originalBuffer = array_slice($paddedBuffer,0,count($paddedBuffer) - $paddingLength);
	    return $originalBuffer;
    }

    public function encrypt($str)
    {
    	$strBuffer = $this->stringToArrayBufferInUtf8($str);
    	$padded = $this->padding($strBuffer); 
    	$blockTimes = count($padded) / 16;
    	$outArray = [];
    	$outArray = array_pad($outArray,count($padded),0);
    	$chainBlock = $this->uint8ToUint32Block($this->iv);

    	for ($i = 0; $i < $blockTimes; $i++){
    		$roundIndex = $i * 16;

        	$block = $this->uint8ToUint32Block($padded, $roundIndex);

        	$chainBlock[0] = $chainBlock[0] ^ $block[0];
	        $chainBlock[1] = $chainBlock[1] ^ $block[1];
	        $chainBlock[2] = $chainBlock[2] ^ $block[2];
	        $chainBlock[3] = $chainBlock[3] ^ $block[3];

	        // use chain block to crypt
	        $cipherBlock = $this->doBlockCrypt($chainBlock, $this->encryptRoundKeys);

	        // make the cipher block be part of next chain block
	        $chainBlock = $cipherBlock;

	        for ($l = 0; $l < 16; $l++) {

	          	$outArray[$roundIndex + $l] = ($this->rr($cipherBlock[intval($l / 4)],(((3 - $l) % 4) * 8))) & 0xff;

	        }
    	}

    	return base64_encode(base64_encode($this->tostr($outArray)));
    }

    public function decrypt($str){
    	$cipherByteArray = $this->getbytes(base64_decode($str));
    	$blockTimes = count($cipherByteArray) / 16;
    	$outArray = [];
    	$outArray = array_pad($outArray,count($cipherByteArray),0);
    	$chainBlock = $this->uint8ToUint32Block($this->iv);
    	for ($i = 0; $i < $blockTimes; $i++) {
    		// extract the 16 bytes block data for this round to encrypt
	        $roundIndex = $i * 16;
	        // make Uint8Array to Uint32Array block
	        $block = $this->uint8ToUint32Block($cipherByteArray, $roundIndex);

	        // reverse the round keys to decrypt
	        $plainBlockBeforeXor = $this->doBlockCrypt($block,$this->decryptRoundKeys);

	        $plainBlock = [];
	        $plainBlock[0] = $chainBlock[0] ^ $plainBlockBeforeXor[0];
        	$plainBlock[1] = $chainBlock[1] ^ $plainBlockBeforeXor[1];
        	$plainBlock[2] = $chainBlock[2] ^ $plainBlockBeforeXor[2];
        	$plainBlock[3] = $chainBlock[3] ^ $plainBlockBeforeXor[3];

        	$chainBlock = $block;

        	for ($l = 0; $l < 16; $l++) {
	          	$outArray[$roundIndex + $l] = ($this->rr($plainBlock[intval($l / 4)],(((3 - $l) % 4) * 8))) & 0xff;
	        }
    	}

    	$depaddedPlaintext = $this->dePadding($outArray);

    	return $this->tostr($depaddedPlaintext);
    }

    public function uright($a, $n)
    {
    	$c = $this->rr(2147483647,$n-1);
     	return $c&($this->rr($a,$n));
    }

    private function padding($originalBuffer)
    {
    	if ($originalBuffer === null) {
	      return null;
	    }
    	$paddingLength = 16 - (count($originalBuffer) % 16);
    	$paddedBuffer = [];
    	$length = count($originalBuffer) + $paddingLength;
		$paddedBuffer = array_pad($paddedBuffer, $length, $paddingLength);
		$paddedBuffer = $originalBuffer+$paddedBuffer;

		return $paddedBuffer;
    }

    private function uint8ToUint32Block($arr,$baseIndex = 0)
    {
    	$block = [
    		($this->ll($arr[$baseIndex],24)) | ($this->ll($arr[$baseIndex + 1],16)) | ($this->ll($arr[$baseIndex + 2],8)) | $arr[$baseIndex + 3],
    		($this->ll($arr[$baseIndex + 4],24)) | ($this->ll($arr[$baseIndex + 5],16)) | ($this->ll($arr[$baseIndex + 6],8)) | $arr[$baseIndex + 7],
    		($this->ll($arr[$baseIndex + 8],24)) | ($this->ll($arr[$baseIndex + 9],16)) | ($this->ll($arr[$baseIndex + 10],8)) | $arr[$baseIndex + 11],
    		($this->ll($arr[$baseIndex + 12],24)) | ($this->ll($arr[$baseIndex + 13],16)) | ($this->ll($arr[$baseIndex + 14],8)) | $arr[$baseIndex + 15]
    	];
    	return $block;
    }

    private function doBlockCrypt($blockData, $roundKeys)
    {
    	$xBlock = [];
    	$xBlock = array_pad($xBlock, 36, 0);
    	
    	$xBlock = $blockData + $xBlock;
   
    	// loop to process 32 rounds crypt
	    for ($i = 0; $i < 32; $i++) {
	      	$xBlock[$i + 4] = $xBlock[$i] ^ $this->tTransform1($xBlock[$i + 1] ^ $xBlock[$i + 2] ^ $xBlock[$i + 3] ^ $roundKeys[$i]);
	    }



    	$yBlock = [];
	    // reverse last 4 xBlock member
	    $yBlock[0] = $xBlock[35];
	    $yBlock[1] = $xBlock[34];
	    $yBlock[2] = $xBlock[33];
	    $yBlock[3] = $xBlock[32];
	    return $yBlock;
    }

    /**
	 * >>> javascript operator in php x86_64
	 * @param int $v
	 * @param int $n
	 * @return int
	 */
	private function rrr($v, $n)
	{
	  return ($v & 0xFFFFFFFF) >> ($n & 0x1F);
	}
	 
	/**
	 * >> javascript operator in php x86_64
	 * @param int $v
	 * @param int $n
	 * @return int
	 */
	private function rr($v, $n)
	{
	  $v = $v & 0x80000000 ? $v | 0xFFFFFFFF00000000 : $v & 0xFFFFFFFF;
	 
	  return $v >> ($n & 0x1F);
	}
	 
	 
	/**
	 * << javascript operator in php x86_64
	 * @param int $v
	 * @param int $n
	 * @return int
	 */
	private function ll($v, $n)
	{
	  $t = ($v & 0xFFFFFFFF) << ($n & 0x1F);
	 
	  return $t & 0x80000000 ? $t | 0xFFFFFFFF00000000 : $t & 0xFFFFFFFF;
	}

	private function f($x0, $x1, $x2, $x3, $r)
    {
        return $x0 ^ $this->t($x1 ^ $x2 ^ $x3 ^ $r);
    }

    /**

     * 将字节数组转化为string类型的数据

     * @param $bytes 字节数组

     * @param $str 目标字符串

     * @return 一个string类型的数据

     */

    public function tostr($bytes) {

        $str = '';

        foreach($bytes as $ch) {

            $str .= chr($ch);

        }

        return $str;

    }

    /**

     * 转换一个string字符串为byte数组

     * @param $str 需要转换的字符串

     * @param $bytes 目标byte数组

     */

    public function getbytes($str) {

        $len = strlen($str);

        if ($len % 4 > 0) {
		    throw new Error('Invalid string. Length must be a multiple of 4');
		}

		$validLen = stripos($str,'=');
  		if ($validLen === -1) $validLen = $len;

  		$placeHoldersLen = $validLen === $len ? 0 : 4 - ($validLen % 4);

  		$array_length = (($validLen + $placeHoldersLen) * 3 / 4) - $placeHoldersLen;

    	$bytes = array();
    	$bytes = array_pad($bytes, $array_length, 0);

    	$curByte = 0;

    	$len = $placeHoldersLen > 0 ? $validLen - 4 : $validLen;

        for($i=0;$i<$len;$i += 4) {

        	$tmp = 
        		($this->ll($this->revLookup[$this->get_bianma(substr($str, $i, 1))],18)) | 
        		($this->ll($this->revLookup[$this->get_bianma(substr($str, $i + 1, 1))],12)) | 
        		($this->ll($this->revLookup[$this->get_bianma(substr($str, $i + 2, 1))],6)) | 
        		($this->revLookup[$this->get_bianma(substr($str, $i + 3, 1))]);
        	//$tmp = $this->ll('sdfasdf',18);
    		$bytes[$curByte++] = ($this->rr($tmp, 16)) & 0xFF;
    		$bytes[$curByte++] = ($this->rr($tmp, 8)) & 0xFF;
    		$bytes[$curByte++] = $tmp & 0xFF;
        	

            // if(ord($str[$i]) >= 128){

            //     $byte = ord($str[$i]) - 256;

            // }else{

            //     $byte = ord($str[$i]);

            // }

            // $bytes[] =  $byte ;

        }
        if ($placeHoldersLen === 2) {
		    $tmp = ($this->ll($this->revLookup[$this->get_bianma(substr($str, $i, 1))],2)) | ($this->rr($this->revLookup[$this->get_bianma(substr($str, $i + 1, 1))],4));
		    $bytes[$curByte++] = $tmp & 0xFF;
		}

		if ($placeHoldersLen === 1) {
		    $tmp = ($this->ll($this->revLookup[$this->get_bianma(substr($str, $i, 1))],10)) | ($this->ll($this->revLookup[$this->get_bianma(substr($str, $i + 1, 1))],4)) | ($this->rr($this->revLookup[$this->get_bianma(substr($str, $i + 2, 1))],2));
		    $bytes[$curByte++] = ($this->rr($tmp, 8)) & 0xFF;
		    $bytes[$curByte++] = $tmp & 0xFF;
		}


        return $bytes;

    }

    private function get_bianma($str)//等同于js的charCodeAt()  
	{  
	    $result = array();  
	    for($i = 0, $l = mb_strlen($str, 'utf-8');$i < $l;++$i)  
	    {  
	        $result[] = $this->uniord(mb_substr($str, $i, 1, 'utf-8'));  
	    }  
	    return join(",", $result);  
	} 

	private function uniord($str, $from_encoding = false)  
	{  
	    $from_encoding = $from_encoding ? $from_encoding : 'UTF-8';  
	    if (strlen($str) == 1)  
	        return ord($str);  
	    $str = mb_convert_encoding($str, 'UCS-4BE', $from_encoding);  
	    $tmp = unpack('N', $str);  
	    return $tmp[1];  
	}  

}