•  0
    PHP

    Encryption and decryption using DES algorithm in PHP

      Asmin Jismun    281        0        Report content

    This function can be used to encrypt and decrypt URL data. The encryption and decryption in DES used the same key.

    
    class encryption{
    sEncryptionKey = 1234abcd;//example key, you can changed this with your own key in hexadecimal
    
    public function doConvertHex($text)
    {
    for($i=0;$i '0000',
    '1' => '0001',
    '2' => '0010',
    '3' => '0011',
    '4' => '0100',
    '5' => '0101',
    '6' => '0110',
    '7' => '0111',
    '8' => '1000',
    '9' => '1001',
    'A' => '1010',
    'B' => '1011',
    'C' => '1100',
    'D' => '1101',
    'E' => '1110',
    'F' => '1111');
    
    $binary = '';
    foreach($hex as $value)
    {
    foreach($bits as $i => $value2)
    {
    if($value == $i)
    {
    $binary = $value2;
    }
    }
    $resultBinary .= $binary;
    }
    return $resultBinary;
    }
    
    public function doConvertToHex($binary)
    {
    $bits = array(
    '0000' => '0',
    '0001' => '1',
    '0010' => '2',
    '0011' => '3',
    '0100' => '4',
    '0101' => '5',
    '0110' => '6',
    '0111' => '7',
    '1000' => '8',
    '1001' => '9',
    '1010' => 'A',
    '1011' => 'B',
    '1100' => 'C',
    '1101' => 'D',
    '1110' => 'E',
    '1111' => 'F');
    
    $bin = str_split($binary,4);
    
    foreach($bin as $value)
    {
    foreach($bits as $i=>$value2)
    {
    if($value == $i)
    {
    $result .= $value2;
    }
    }
    }
    return $result;
    }
    
    public function doCalculate($hexMsg,$subKeys2)
    {
    //permutaion for message(hex)
    $initialPermutation = array(
    58,50,42,34,26,18,10,2,
    60,52,44,36,28,20,12,4,
    62,54,46,38,30,22,14,6,
    64,56,48,40,32,24,16,8,
    57,49,41,33,25,17,9,1,
    59,51,43,35,27,19,11,3,
    61,53,45,37,29,21,13,5,
    63,55,47,39,31,23,15,7);
    
    //number of hexadecimal in message must be devided by 16
    $hexMessage = strtoupper($hexMsg);
    $hexMessage = str_split($hexMessage,16);//convert string hex to an array
    
    foreach($hexMessage as $msgHex)
    {
    $msgHex2 = $msgHex;
    if(count(str_split($msgHex)) < 16)
    {
    $r = 16 - count(str_split($msgHex));
    for($i=0;$i<$r;$i++)
    {
    $msgHex2 .= '0';
    }
    }
    
    /*
    $msgBinary = str_split($this->doConvertToBinary(str_split($msgHex)));
    if(count($msgBinary) < 64)
    {
    $r = fmod(count($msgBinary),64);
    for($i=0;$i<$r;$i++)
    {
    array_push($msgBinary,0);
    }
    }*/
    
    $msgBinary = str_split($this->doConvertToBinary(str_split($msgHex2)));
    
    //inital permutation for message for every 16 bit of hexadecimal msg or 56 bit of binary msg
    foreach($initialPermutation as $value)
    {
    $index = $value-1;
    $msg .= strval($msgBinary[$index]);
    }
    
    $ipMsg[] = $msg;//each bin msg of 56 bit stored in array
    $msg = '';
    }
    
    //$subKeys2 -> key used for encryption
    //$ipMsg -> message that will be encoded
    
    $Ebit = array(
    32, 1, 2, 3, 4, 5,
    4, 5, 6, 7, 8, 9,
    8, 9, 10, 11, 12, 13,
    12, 13, 14, 15, 16, 17,
    16, 17, 18, 19, 20, 21,
    20, 21, 22, 23, 24, 25,
    24, 25, 26, 27, 28, 29,
    28, 29, 30, 31, 32, 1);
    
    $inverseIP = array (
    40, 8, 48, 16, 56, 24, 64, 32,
    39, 7, 47, 15, 55, 23, 63, 31,
    38, 6, 46, 14, 54, 22, 62, 30,
    37, 5, 45, 13, 53, 21, 61, 29,
    36, 4, 44, 12, 52, 20, 60, 28,
    35, 3, 43, 11, 51, 19, 59, 27,
    34, 2, 42, 10, 50, 18, 58, 26,
    33, 1, 41, 9, 49, 17, 57, 25 );
    
    foreach($ipMsg as $value)
    {
    //separate msg into 2 array contain 32 bit binary code
    $msgSplit = str_split($value,32);
    $L = str_split($msgSplit[0]);//Ln where n=0,1,2,3,...
    $R = str_split($msgSplit[1]);//Rn where n=0,1,2,3,...
    $LR = array();
    array_push($LR,array($L,$R));
    
    foreach($subKeys2 as $j=>$value2)//Kn where n=0,1,2,3,...
    {
    $tempL = $LR[$j][0];
    $tempR = $LR[$j][1];
    
    //convert 32 bits message to 48 bits message for XOR function
    foreach($Ebit as $value3)
    {
    $index = $value3-1;
    $ER .= strval($tempR[$index]);//E(Rn) where n=0,1,2,3,...
    }
    
    $ERK = $this->doXOR($ER,strval($value2));//Kn + E(Rn) where n=0,1,2,3,...
    $convert4bits = str_split($ERK,6);
    $convert4bits2 = array();
    foreach($convert4bits as $i=>$value4)
    {
    $convert4bits2[] = str_split($value4);
    }
    $resultConvert = $this->doConvert4bits($convert4bits2);
    
    $R = $this->doXOR($resultConvert,$tempL);
    
    foreach($inverseIP as $value5)
    {
    $index = $value5 - 1;
    $resultR .= $R[$index];
    }
    
    array_push($LR,array($tempR,$R));
    
    $ER = '';
    $resultR = '';
    }
    
    $R16L16 = $LR[16][1].$LR[16][0];
    
    //final permutation
    foreach($inverseIP as $value6)
    {
    $index = $value6 - 1;
    $resultFinal .= $R16L16[$index];
    }
    
    $final .= $this->doConvertToHex(strtoupper($resultFinal));
    $resultFinal = '';
    }
    
    return $final;
    }
    
    //////////////////////////////ENCRYPTION/////////////////////////////////////////
    public function doEncrypt($plainText)
    {
    $textMessage = str_split(trim($plainText));
    $hexMsg = $this->doConvertHex($textMessage);
    $hexMsg = strtoupper($hexMsg);
    
    $key = str_split(strtoupper(sEncryptionKey));//key in hexadecimal
    $keyBinary = str_split($this->doConvertToBinary($key));//key in binary( 64 bit key)
    
    $permutation1 = array(
    57,49,41,33,25,17,9,
    1,58,50,42,34,26,18,
    10,2,59,51,43,35,27,
    19,11,3,60,52,44,36,
    63,55,47,39,31,23,15,
    7,62,54,46,38,30,22,
    14,6,61,53,45,37,29,
    21,13,5,28,20,12,4
    );
    
    $permutation2 = array(
    14,17,11,24,1,5,
    3,28,15,6,21,10,
    23,19,12,4,26,8,
    16,7,27,20,13,2,
    41,52,31,37,47,55,
    30,40,51,45,33,48,
    44,49,39,56,34,53,
    46,42,50,36,29,32 );
    
    foreach($permutation1 as $value)
    {
    $index = $value-1;
    $k1 .= strval($keyBinary[$index]);//56 bit permutation for initial key
    }
    
    $k1 = str_split($k1,28);
    $c0 = $k1[0];
    $d0 = $k1[1];
    $subKeys = array();
    array_push($subKeys,array('C'=>$c0,'D'=>$d0));
    
    $shifts = array(1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1);
    
    foreach($shifts as $j=>$value)
    {
    $cTemp = str_split($subKeys[$j]['C']);
    $dTemp = str_split($subKeys[$j]['D']);
    
    for($i = 0;$i<$value;$i++)
    {
    $leftC = $cTemp[$i];
    $leftD = $dTemp[$i];
    unset($cTemp[$i]);
    array_push($cTemp,$leftC);
    unset($dTemp[$i]);
    array_push($dTemp,$leftD);
    }
    
    $cString = implode("",$cTemp);
    $dString = implode("",$dTemp);
    
    array_push($subKeys,array('C'=>$cString,'D'=>$dString));
    }
    
    //Create 16 subkeys, each of which is 48-bits long
    foreach($subKeys as $m=>$value)
    {
    if($m > 0)
    {
    $keyBinary2 = $value['C'].$value['D'];
    $keyBinary2 = str_split($keyBinary2);
    foreach($permutation2 as $value2)//48 bit permutation for 16 subkeys
    {
    $index = $value2-1;
    $k .= strval($keyBinary2[$index]);//form key combination of C and D from subkeys
    }
    $subKeys2[] = $k; //keys used for encryption
    $k = '';
    }
    }
    
    $final = $this->doCalculate($hexMsg,$subKeys2);
    
    return $final;
    }
    
    //////////////////////////////DECRYPTION/////////////////////////////////////////
    public function doDecrypt($chiperText)
    {
    $key = str_split(strtoupper(sEncryptionKey));//key in hexadecimal
    $keyBinary = str_split($this->doConvertToBinary($key));//key in binary( 64 bit key)
    
    $permutation1 = array(
    57,49,41,33,25,17,9,
    1,58,50,42,34,26,18,
    10,2,59,51,43,35,27,
    19,11,3,60,52,44,36,
    63,55,47,39,31,23,15,
    7,62,54,46,38,30,22,
    14,6,61,53,45,37,29,
    21,13,5,28,20,12,4
    );
    
    foreach($permutation1 as $value)
    {
    $index = $value-1;
    $k1 .= strval($keyBinary[$index]);//56 bit permutation for initial key
    }
    
    $k1 = str_split($k1,28);
    $c0 = $k1[0];
    $d0 = $k1[1];
    $subKeys = array();
    array_push($subKeys,array('C'=>$c0,'D'=>$d0));
    
    $shifts = array(1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1);
    
    foreach($shifts as $j=>$value)
    {
    $cTemp = str_split($subKeys[$j]['C']);
    $dTemp = str_split($subKeys[$j]['D']);
    
    for($i = 0;$i<$value;$i++)
    {
    $leftC = $cTemp[$i];
    $leftD = $dTemp[$i];
    unset($cTemp[$i]);
    array_push($cTemp,$leftC);
    unset($dTemp[$i]);
    array_push($dTemp,$leftD);
    }
    
    $cString = implode("",$cTemp);
    $dString = implode("",$dTemp);
    
    array_push($subKeys,array('C'=>$cString,'D'=>$dString));
    }
    
    $permutation2 = array(
    14,17,11,24,1,5,
    3,28,15,6,21,10,
    23,19,12,4,26,8,
    16,7,27,20,13,2,
    41,52,31,37,47,55,
    30,40,51,45,33,48,
    44,49,39,56,34,53,
    46,42,50,36,29,32 );
    
    //Create 16 subkeys, each of which is 48-bits long
    foreach($subKeys as $m=>$value)
    {
    if($m > 0)
    {
    $keyBinary2 = $value['C'].$value['D'];
    $keyBinary2 = str_split($keyBinary2);
    foreach($permutation2 as $value2)//48 bit permutation for 16 subkeys
    {
    $index = $value2-1;
    $k .= strval($keyBinary2[$index]);//form key combination of C and D from subkeys
    }
    $subKeys2[] = $k; //keys used for encryption
    $k = '';
    }
    }
    
    $subKeys2 = array_reverse($subKeys2);
    
    $final = $this->doCalculate($chiperText,$subKeys2);
    $final = str_split($final,2);
    $final = $this->doConvertText($final);
    return $final;
    }
    
    public function doConvert4bits($convert4bits)
    {
    
    $s1 = array (
    array(14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7),
    array(0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8),
    array(4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0),
    array(15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 ));
    
    $s2 = array (
    array(15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10),
    array(3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5),
    array(0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15),
    array(13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 ));
    
    $s3 = array (
    array(10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8),
    array(13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1),
    array(13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7),
    array(1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 ));
    
    $s4 = array (
    array(7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15),
    array(13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9),
    array(10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4),
    array(3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 ));
    
    $s5 = array (
    array(2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9),
    array(14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6),
    array(4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14),
    array(11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 ));
    
    $s6 = array (
    array(12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11),
    array(10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8),
    array(9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6),
    array(4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 ));
    
    $s7 = array (
    array(4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1),
    array(13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6),
    array(1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2),
    array(6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 ));
    
    $s8 = array (
    array(13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7),
    array(1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2),
    array(7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8),
    array(2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 ));
    
    $arrayConvert = array();
    array_push($arrayConvert,$s1);
    array_push($arrayConvert,$s2);
    array_push($arrayConvert,$s3);
    array_push($arrayConvert,$s4);
    array_push($arrayConvert,$s5);
    array_push($arrayConvert,$s6);
    array_push($arrayConvert,$s7);
    array_push($arrayConvert,$s8);
    
    foreach($arrayConvert as $i=>$value)
    {
    $row = base_convert($convert4bits[$i][0].$convert4bits[$i][5],2,10);
    $middleBits = $convert4bits[$i][1].$convert4bits[$i][2].$convert4bits[$i][3].$convert4bits[$i][4];
    $column = base_convert($middleBits,2,10);
    
    $result .= $this->doConvertToBinary(str_split(strtoupper(base_convert($value[$row][$column],10,16))));
    }
    //inverse for the final value
    $permutationP = array (
    16, 7, 20, 21,
    29, 12, 28, 17,
    1, 15, 23, 26,
    5, 18, 31, 10,
    2, 8, 24, 14,
    32, 27, 3, 9,
    19, 13, 30, 6,
    22, 11, 4, 25 );
    
    foreach($permutationP as $value2)
    {
    $index = $value2 - 1;
    $result2 .= $result[$index];
    }
    
    return $result2;
    }
    
    public function doXOR($text,$key)
    {
    for($i=0; $idoEncrypt($urlKey);
    return $chiperText;
    }
    
    public function doUrlDecryption()
    {
    $objDecrypt = new cls_encryption();
    
    //get value from url(decryption)
    $urlKey = $objDecrypt->doDecrypt($_GET[‘key’]);
    $urlKey = explode(‘&’,$urlKey);
    foreach($urlKey as $value)
    {
    $keyValue = explode(‘=’,$value);
    $urlKeyList[$keyValue[0]] = trim($keyValue[1]);
    }
    $decryptedMyId = $urlKeyList[‘myId’];
    $decryptedMyPassword = $urlKeyList[‘myPassword’];
    }
    ?>
    

     

     


  •  


Leave a Comment

Please Login to insert comment.

 

Facebook Conversations