DES algorithm

/**
 * class DEC_algorithm
 *
 * Шифрует текст 64-битным ключом алгоритмом DEC методом ECB
 *
 * @author Тупалов Дмитрий
 *
 * @param string $plainText
 * @param string $theKey
 * @param bool $base64
 * @return string;
 *
 */
class DEC_algorithm{

    public $plainText;
    public $theKey;
    public $base64;

    /**
     * __construct
     *
     * @param string $plainText
     * @param string $theKey
     * @param bool $base64
     *
     */
    function __construct($plainText,$theKey,$base64=false){

        $this->plainText    = $plainText;
        $this->theKey       = $theKey;
        $this->base64       = $base64;


    }

    /**
     * function keyToBitArray
     *
     * Преобразует ключ в 64-битовый массив.
     *
     * @access private
     * @param string $keyOriginal
     * @return array
     */
    private function keyToBitArray($keyOriginal){

        $keyArrBin = array();
        $key_IP = array();
        $keyBin = "";
        for ($i=0; $i<strlen($keyOriginal); $i++){
            $keyBin .= str_pad( decbin(ord($keyOriginal[$i])), 8, "0", STR_PAD_LEFT );
        }

        for ($i=0; $i<=strlen($keyBin)-1; $i++){
            $keyArrBin[] = intval($keyBin[$i]);
        }

        return $keyArrBin;

    }

    /**
     * function keyPermutation1
     *
     * Реализует перестановку 64-битного ключа, согласно таблице, после чего ключ преобразуется в 56-битный массив.
     *
     * @access private
     * @param array $keyArrBin
     * @return array
     */
    private function keyPermutation1($keyArrBin){

        //
        //
        //

        $key_IP_tab = 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 ($key_IP_tab as $el){
            $key_IP[] = /*($el).' = '.*/intval($keyArrBin[($el-1)]);
        }

        return $key_IP;

    }

    /**
     * function shiftKeys
     *
     * 1. 56-битный ключ разделяется на два блока C и D по 28 бит каждый.
     *
     * 2. Каждый 28-битный блок C и D сдвигаем влево на 1 или 2 бита согласно таблице,
     * где 1,2,9 и 16 итерация сдвигается по 1 биту влево, остальные итерации сдвигают
     * по 2 бита влево каждого блока.
     *
     * @access private
     * @param array $key_IP
     * @return array
     */
    private function shiftKeys($key_IP){

        $key_C[] = array();
        $key_D[] = array();

        for ($i=0; $i<=27; $i++){
            $key_C[0][] = intval($key_IP[$i]);
        }

        for ($i=28; $i<=55; $i++){
            $key_D[0][] = intval($key_IP[$i]);
        }

        for ($i=1; $i<=16; $i++){

            $temp_str_C_start = "";
            $temp_str_C_end = "";

            $temp_str_D_start = "";
            $temp_str_D_end = "";

            if ($i==1 || $i==2 || $i==9 || $i==16){

                $temp_str_C_start = join("",$key_C[$i-1]);
                $temp_str_C_end = substr($temp_str_C_start,1,strlen($temp_str_C_start)).$temp_str_C_start[0];

                $temp_str_D_start = join("",$key_D[$i-1]);
                $temp_str_D_end = substr($temp_str_D_start,1,strlen($temp_str_D_start)).$temp_str_D_start[0];

                for ($j=0; $j<strlen($temp_str_C_end); $j++){
                    $key_C[$i][] = intval($temp_str_C_end[$j]);
                }

                for ($j=0; $j<strlen($temp_str_D_end); $j++){
                    $key_D[$i][] = intval($temp_str_D_end[$j]);
                }

            } else {

                $temp_str_C_start = join("",$key_C[$i-1]);
                $temp_str_C_end = substr($temp_str_C_start,1,strlen($temp_str_C_start)).$temp_str_C_start[0];
                $temp_str_C_end = substr($temp_str_C_end,1,strlen($temp_str_C_end)).$temp_str_C_end[0];

                $temp_str_D_start = join("",$key_D[$i-1]);
                $temp_str_D_end = substr($temp_str_D_start,1,strlen($temp_str_D_start)).$temp_str_D_start[0];
                $temp_str_D_end = substr($temp_str_D_end,1,strlen($temp_str_D_end)).$temp_str_D_end[0];

                for ($j=0; $j<strlen($temp_str_C_end); $j++){
                    $key_C[$i][] = intval($temp_str_C_end[$j]);
                }

                for ($j=0; $j<strlen($temp_str_D_end); $j++){
                    $key_D[$i][] = intval($temp_str_D_end[$j]);
                }

            }

        }

        for ($i=1; $i<=16; $i++){

            $keyShifted[$i] = explode(",", join(",",$key_C[$i]).",".join(",",$key_D[$i]) );
        }

        return $keyShifted;

    }

    /**
     * function keyPermutation2
     *
     * Реализуется перестановка 56-битных ключей Kn, согласно таблице, где на выходе получаем массив из 16 элементов,
     * в которых находятся 48-битные ключи Kn, для шифрования функцией Фейстеля.
     *
     * @access private
     * @param array $keyShifted
     * @return array
     */
    private function keyPermutation2($keyShifted){
        //
        // Делаем перестановку 56-битного ключа Kn, согласно таблице, где на выходе получаем 48-битный ключ Kn.
        //

        $key_IP2_tab = 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);

        for ($i=1; $i<=16; $i++){
            foreach ($key_IP2_tab as $el){
                $keyArrEnd[$i][] = intval($keyShifted[$i][$el-1]);
            }
        }

        return $keyArrEnd;
    }


    /**
     * function createCryptKeysArray
     *
     * Создает массив ключей для конечного шифрования.
     *
     * @access private
     * @param string $keyOriginal
     * @return array
     */
    private function createCryptKeysArray($keyOriginal){

        $bitKey                 = $this->keyToBitArray($keyOriginal);

        $keyPermutation1Array   = $this->keyPermutation1($bitKey);

        $shiftKeysArray         = $this->shiftKeys($keyPermutation1Array);
        $enryptedKeysArray      = $this->keyPermutation2($shiftKeysArray);


        return $enryptedKeysArray;
    }

    /**
     * function textToBitArray
     *
     * Преобразование исходного текста в 64-битовый массив.
     *
     * @access private
     * @param string $plainText
     * @return array
     */
    private function textToBitArray($plainText){

        $textBin        = "";
        $textBinArr     = array();
        $IP1            = array();
        $el             = 1;
        $count          = 1;

        for ($i=0; $i<strlen($plainText); $i++){
            $textBin .= str_pad( decbin(ord($plainText[$i])), 8, "0", STR_PAD_LEFT );
        }

        for ($i=0; $i<strlen($textBin); $i++){

            $textBinArr[$el][] = intval($textBin[$i]);

            if ($count!=1 && $count%64==0){
                $el++;
            }

            $count++;
        }

        $countArray = count($textBinArr[$el]);
        if (count($textBinArr[$el]) < 64 && count($textBinArr[$el]) > 0){
            for ($i=1;$i<=64-$countArray;$i++){
                $textBinArr[$el][] = intval(0);
            }
        }

        return $textBinArr;

    }

    /**
     * function textPermutation
     *
     * Перестановка 64-битного блока, согласно таблице.
     *
     * @access private
     * @param array $textBitArray
     * @return array
     */
    private function textPermutation($textBitArray){

        $IP_arr_tab = 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);

//      foreach ($textBitArray as $_key => $textBitArrayVal){
            foreach ($IP_arr_tab as $el){
                $IP1[] = intval($textBitArray[($el-1)]);
            }
//      }

        return $IP1;

    }

    /**
     * function feistel
     *
     * Функция Фейстеля
     *
     * @access private
     * @param array $Rb
     * @param array $k
     * @return array
     */
    private function feistel($Rb,$k){

        $Rb_E = array();
        $B_arr_xor = array();

        $func_E_tab = 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);


        foreach ($func_E_tab as $el){
            $Rb_E[] = /*($el).' = '.*/intval($Rb[($el-1)]);
        }

        $count = 1;
        $s_el = 0;
        for($i=0;$i<count($Rb_E);$i++){

            $B_arr_xor[$s_el][] = intval($k[$i])^intval($Rb_E[$i]);

            if ($count!=1 && $count%6==0){
                $s_el++;
            }

            $count++;
        }

        $S_tabs =
                array(
                    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
                            )
                        ),
                    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
                            )
                        ),
                    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
                            )
                        ),
                    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
                            )
                        ),
                    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
                            )
                        ),
                    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
                            )
                        ),
                    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
                            )
                        ),
                    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
                            )
                        )
                    );

        for ($i=0; $i<=7; $i++){
            $a = bindec($B_arr_xor[$i][0].$B_arr_xor[$i][5]);
            $b = bindec($B_arr_xor[$i][1].$B_arr_xor[$i][2].$B_arr_xor[$i][3].$B_arr_xor[$i][4]);

            $val = str_pad( decbin($S_tabs[$i][$a][$b]), 4, "0", STR_PAD_LEFT );
            for ($j=0;$j<strlen($val);$j++){
                $B_arr_after_S[] = intval($val[$j]);
            }

        }

        $P_tab = 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);


        $result = array();

        foreach ($P_tab as $el){
            $result[] = /*($el).' = '.*/intval($B_arr_after_S[($el-1)]);
        }

        return $result;

    }

    /**
     * function bit_sum_mod_2
     *
     * Сложение двух массивов по модулю 2
     *
     * @access private
     * @param array $B1
     * @param array $B2
     * @return array
     */
    private function bit_sum_mod_2($B1,$B2){

        $result = array();

        foreach ($B1 as $key => $value){
            $result[] = intval(intval($value)^intval($B2[$key]));
        }

        return $result;
    }

    /**
     * function textPermutation2
     *
     * Конечная перестановка
     *
     * @access private
     * @param array $textBitArray
     * @return array
     */
    private function textPermutation2($textBitArray){

        $IP_reverse_tab = 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 ($IP_reverse_tab as $el){
            $IP1[] = intval($textBitArray[($el-1)]);
        }

        return $IP1;
    }

    /**
     * function encrypt
     *
     * Шифрование DES
     *
     * @access public
     * @return string
     */
    public function encrypt(){

        $textBitArray       = $this->textToBitArray($this->plainText);

        foreach ($textBitArray as $tpKey => $textBitEl){


            $textPermutation[$tpKey] = $this->textPermutation($textBitEl);

        }

        $keyArrEnd          = $this->createCryptKeysArray($this->theKey);

        $encodedData = "";

        foreach ($textPermutation as $tpKey => $textPermutationVal){
            $IP1_32b_L = array();
            $IP1_32b_R = array();

            for ($i=0; $i<=31; $i++){
                $IP1_32b_L[0][] = intval($textPermutationVal[$i]);
            }

            for ($i=32; $i<=63; $i++){
                $IP1_32b_R[0][] = intval($textPermutationVal[$i]);
            }


            for ($i=1;$i<=16;$i++){

                $IP1_32b_L[$i] = $IP1_32b_R[$i-1];
                $IP1_32b_R[$i] = $this->bit_sum_mod_2( $IP1_32b_L[$i-1], $this->feistel( $IP1_32b_R[$i-1],$keyArrEnd[$i] ) );

            }

            $IP1_64_bit = array();

            foreach ($IP1_32b_R[16] as $key => $value){
                $IP1_64_bit[] = intval($value);
            }
            foreach ($IP1_32b_L[16] as $key => $value){
                $IP1_64_bit[] = intval($value);
            }

            $IP1_reverse_64_bit = array();

            $IP1_reverse_64_bit = $this->textPermutation2($IP1_64_bit);

            $endByte = array();

            $count = 1;
            $el = 1;
            foreach ($IP1_reverse_64_bit as $val){
                $num[$val]++;
                $endByte[$el] .= $val;
                if ($count!=1 && $count%8==0){
                    $el++;
                }
                $count++;
            }

            $endByteChr = array();
            foreach ($endByte as $_key=>$byte){
                $endByteChr[$_key] = chr(bindec($byte));
                $encodedData .= chr(bindec($byte));
            }
        }

        return ($this->base64 ? base64_encode($encodedData) : $encodedData);

    }

    /**
     * function decrypt
     *
     * @access public
     * @return string
     */
    public function decrypt($encryptText){

        if ($this->base64){
            $encryptText = base64_decode($encryptText);
        }

        $textBitArray       = $this->textToBitArray($encryptText);

        foreach ($textBitArray as $tpKey => $textBitEl){
            $textPermutation[$tpKey] = $this->textPermutation2($textBitEl);
        }

        $keyArrEnd          = $this->createCryptKeysArray($this->theKey);

        $encodedData = "";

        foreach ($textPermutation as $tpKey => $textPermutationVal){

            $IP1_32b_L = array();
            $IP1_32b_R = array();

            for ($i=0; $i<=31; $i++){
                $IP1_32b_L[16][] = intval($textPermutationVal[$i]);
            }

            for ($i=32; $i<=63; $i++){
                $IP1_32b_R[16][] = intval($textPermutationVal[$i]);
            }

            for ($i=16;$i>=1;$i--){

                $IP1_32b_R[$i-1] = $IP1_32b_L[$i];
                $IP1_32b_L[$i-1] = $this->bit_sum_mod_2( $IP1_32b_R[$i], $this->feistel( $IP1_32b_L[$i],$keyArrEnd[$i] ) );

            }

            $IP1_64_bit = array();

            foreach ($IP1_32b_L[0] as $key => $value){
                $IP1_64_bit[] = intval($value);
            }

            foreach ($IP1_32b_R[0] as $key => $value){
                $IP1_64_bit[] = intval($value);
            }

            $IP1_reverse_64_bit = array();

            $IP1_reverse_64_bit = $this->textPermutation($IP1_64_bit);

            $endByte = array();

            $count = 1;
            $el = 1;
            foreach ($IP1_reverse_64_bit as $val){
                $num[$val]++;
                $endByte[$el] .= $val;
                if ($count!=1 && $count%8==0){
                    $el++;
                }
                $count++;
            }

            $endByteChr = array();
            foreach ($endByte as $_key=>$byte){
                $endByteChr[$_key] = chr(bindec($byte));
                $encodedData .= chr(bindec($byte));
            }
        }

        return ($encodedData);

    }

}