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’];
}
?>