• 0

    Encryption and decryption using DES algorithm in PHP

    by Asmin

    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.