tdes.c

用C语言写的TDES算法

        // Permute - E
        aucWorka[ 0] = aucBuffer[31];
        aucWorka[ 1] = aucBuffer[ 0];
        aucWorka[ 2] = aucBuffer[ 1];
        aucWorka[ 3] = aucBuffer[ 2];
        aucWorka[ 4] = aucBuffer[ 3];
        aucWorka[ 5] = aucBuffer[ 4];
        aucWorka[ 6] = aucBuffer[ 3];
        aucWorka[ 7] = aucBuffer[ 4];
        aucWorka[ 8] = aucBuffer[ 5];
        aucWorka[ 9] = aucBuffer[ 6];
        aucWorka[10] = aucBuffer[ 7];
        aucWorka[11] = aucBuffer[ 8];
        aucWorka[12] = aucBuffer[ 7];
        aucWorka[13] = aucBuffer[ 8];
        aucWorka[14] = aucBuffer[ 9];
        aucWorka[15] = aucBuffer[10];
        aucWorka[16] = aucBuffer[11];
        aucWorka[17] = aucBuffer[12];
        aucWorka[18] = aucBuffer[11];
        aucWorka[19] = aucBuffer[12];
        aucWorka[20] = aucBuffer[13];
        aucWorka[21] = aucBuffer[14];
        aucWorka[22] = aucBuffer[15];
        aucWorka[23] = aucBuffer[16];
        aucWorka[24] = aucBuffer[15];
        aucWorka[25] = aucBuffer[16];
        aucWorka[26] = aucBuffer[17];
        aucWorka[27] = aucBuffer[18];
        aucWorka[28] = aucBuffer[19];
        aucWorka[29] = aucBuffer[20];
        aucWorka[30] = aucBuffer[19];
        aucWorka[31] = aucBuffer[20];
        aucWorka[32] = aucBuffer[21];
        aucWorka[33] = aucBuffer[22];
        aucWorka[34] = aucBuffer[23];
        aucWorka[35] = aucBuffer[24];
        aucWorka[36] = aucBuffer[23];
        aucWorka[37] = aucBuffer[24];
        aucWorka[38] = aucBuffer[25];
        aucWorka[39] = aucBuffer[26];
        aucWorka[40] = aucBuffer[27];
        aucWorka[41] = aucBuffer[28];
        aucWorka[42] = aucBuffer[27];
        aucWorka[43] = aucBuffer[28];
        aucWorka[44] = aucBuffer[29];
        aucWorka[45] = aucBuffer[30];
        aucWorka[46] = aucBuffer[31];
        aucWorka[47] = aucBuffer[ 0];

        // KS Function Begin
        if (iFlag) 
        {
            ucBrofaucShift = aucShift[iter-1];

            for (i = 0; i < (int)ucBrofaucShift; i++) 
            {
                ucTmp1 = aucKwork[0];
                ucTmp2 = aucKwork[28];

                for (j = 0; j < 27; j++) 
                {
                  aucKwork[j] = aucKwork[j+1];
                  aucKwork[j+28] = aucKwork[j+29];
                }

                aucKwork[27] = ucTmp1;
                aucKwork[55] = ucTmp2;
            }
        }
        else if (iter > 1) 
        {
            ucBrofaucShift = aucShift[17-iter];

            for (i = 0; i < (int)ucBrofaucShift; i++) 
            {
                ucTmp1 = aucKwork[27];
                ucTmp2 = aucKwork[55];

                for (j = 27; j > 0; j--) 
                {
                    aucKwork[j] = aucKwork[j-1];
                    aucKwork[j+28] = aucKwork[j+27];
                }

                aucKwork[0]  = ucTmp1;
                aucKwork[28] = ucTmp2;
            }
        }

        // Permute aucKwork - PC2
        aucKn[ 0] = aucKwork[13];
        aucKn[ 1] = aucKwork[16];
        aucKn[ 2] = aucKwork[10];
        aucKn[ 3] = aucKwork[23];
        aucKn[ 4] = aucKwork[ 0];
        aucKn[ 5] = aucKwork[ 4];
        aucKn[ 6] = aucKwork[ 2];
        aucKn[ 7] = aucKwork[27];
        aucKn[ 8] = aucKwork[14];
        aucKn[ 9] = aucKwork[ 5];
        aucKn[10] = aucKwork[20];
        aucKn[11] = aucKwork[ 9];
        aucKn[12] = aucKwork[22];
        aucKn[13] = aucKwork[18];
        aucKn[14] = aucKwork[11];
        aucKn[15] = aucKwork[ 3];
        aucKn[16] = aucKwork[25];
        aucKn[17] = aucKwork[ 7];
        aucKn[18] = aucKwork[15];
        aucKn[19] = aucKwork[ 6];
        aucKn[20] = aucKwork[26];
        aucKn[21] = aucKwork[19];
        aucKn[22] = aucKwork[12];
        aucKn[23] = aucKwork[ 1];
        aucKn[24] = aucKwork[40];
        aucKn[25] = aucKwork[51];
        aucKn[26] = aucKwork[30];
        aucKn[27] = aucKwork[36];
        aucKn[28] = aucKwork[46];
        aucKn[29] = aucKwork[54];
        aucKn[30] = aucKwork[29];
        aucKn[31] = aucKwork[39];
        aucKn[32] = aucKwork[50];
        aucKn[33] = aucKwork[44];
        aucKn[34] = aucKwork[32];
        aucKn[35] = aucKwork[47];
        aucKn[36] = aucKwork[43];
        aucKn[37] = aucKwork[48];
        aucKn[38] = aucKwork[38];
        aucKn[39] = aucKwork[55];
        aucKn[40] = aucKwork[33];
        aucKn[41] = aucKwork[52];
        aucKn[42] = aucKwork[45];
        aucKn[43] = aucKwork[41];
        aucKn[44] = aucKwork[49];
        aucKn[45] = aucKwork[35];
        aucKn[46] = aucKwork[28];
        aucKn[47] = aucKwork[31];
        /* KS Function End */

        /* aucWorka XOR aucKn */
        for (i = 0; i < 48; i++)
        {
            aucWorka[i] = aucWorka[i] ^ aucKn[i];
        }

        // 8 s-functions
        m = 2 * aucWorka[0] + aucWorka[5];
        n = 2 * (2 * (2 * aucWorka[1] + aucWorka[2]) + aucWorka[3]) + aucWorka[4];

        valindex = aucTab1[m][n] * 4;
        
        aucKn[0] = aucBinary[0 + valindex];
        aucKn[1] = aucBinary[1 + valindex];
        aucKn[2] = aucBinary[2 + valindex];
        aucKn[3] = aucBinary[3 + valindex];
        
        m = 2 * aucWorka[6] + aucWorka[11];
        n = 2 * (2 * (2 * aucWorka[7] + aucWorka[8]) + aucWorka[9]) + aucWorka[10];
        
        valindex = aucTab2[m][n] * 4;

        aucKn[4] = aucBinary[0 + valindex];
        aucKn[5] = aucBinary[1 + valindex];
        aucKn[6] = aucBinary[2 + valindex];
        aucKn[7] = aucBinary[3 + valindex];
        
        m = 2 * aucWorka[12] + aucWorka[17];
        n = 2 * (2 * (2 * aucWorka[13] + aucWorka[14]) + aucWorka[15]) + aucWorka[16];

        valindex = aucTab3[m][n] * 4;

        aucKn[ 8] = aucBinary[0 + valindex];
        aucKn[ 9] = aucBinary[1 + valindex];
        aucKn[10] = aucBinary[2 + valindex];
        aucKn[11] = aucBinary[3 + valindex];

        m = 2 * aucWorka[18] + aucWorka[23];
        n = 2 * (2 * (2 * aucWorka[19] + aucWorka[20]) + aucWorka[21]) + aucWorka[22];

        valindex = aucTab4[m][n] * 4;

        aucKn[12] = aucBinary[0 + valindex];
        aucKn[13] = aucBinary[1 + valindex];
        aucKn[14] = aucBinary[2 + valindex];
        aucKn[15] = aucBinary[3 + valindex];
        
        m = 2 * aucWorka[24] + aucWorka[29];
        n = 2 * (2 * (2 * aucWorka[25] + aucWorka[26]) + aucWorka[27]) + aucWorka[28];

        valindex = aucTab5[m][n] * 4;

        aucKn[16] = aucBinary[0 + valindex];
        aucKn[17] = aucBinary[1 + valindex];
        aucKn[18] = aucBinary[2 + valindex];
        aucKn[19] = aucBinary[3 + valindex];

        m = 2 * aucWorka[30] + aucWorka[35];
        n = 2 * (2 * (2 * aucWorka[31] + aucWorka[32]) + aucWorka[33]) + aucWorka[34];

        valindex = aucTab6[m][n] * 4;

        aucKn[20] = aucBinary[0+valindex];
        aucKn[21] = aucBinary[1+valindex];
        aucKn[22] = aucBinary[2+valindex];
        aucKn[23] = aucBinary[3+valindex];
        
        m = 2 * aucWorka[36] + aucWorka[41];
        n = 2 * (2 * (2 * aucWorka[37] + aucWorka[38]) + aucWorka[39]) + aucWorka[40];

        valindex = aucTab7[m][n] * 4;

        aucKn[24] = aucBinary[0 + valindex];
        aucKn[25] = aucBinary[1 + valindex];
        aucKn[26] = aucBinary[2 + valindex];
        aucKn[27] = aucBinary[3 + valindex];

         m = 2 * aucWorka[42] + aucWorka[47];
        n = 2 * (2 * (2 * aucWorka[43] + aucWorka[44]) + aucWorka[45]) + aucWorka[46];

        valindex = aucTab7[m][n] * 4;

        aucKn[28] = aucBinary[0 + valindex];
        aucKn[29] = aucBinary[1 + valindex];
        aucKn[30] = aucBinary[2 + valindex];
        aucKn[31] = aucBinary[3 + valindex];

        // Permute - P
        aucWorka[ 0] = aucKn[15];
        aucWorka[ 1] = aucKn[ 6];
        aucWorka[ 2] = aucKn[19];
        aucWorka[ 3] = aucKn[20];
        aucWorka[ 4] = aucKn[28];
        aucWorka[ 5] = aucKn[11];
        aucWorka[ 6] = aucKn[27];
        aucWorka[ 7] = aucKn[16];
        aucWorka[ 8] = aucKn[ 0];
        aucWorka[ 9] = aucKn[14];
        aucWorka[10] = aucKn[22];
        aucWorka[11] = aucKn[25];
        aucWorka[12] = aucKn[ 4];
        aucWorka[13] = aucKn[17];
        aucWorka[14] = aucKn[30];
        aucWorka[15] = aucKn[ 9];
        aucWorka[16] = aucKn[ 1];
        aucWorka[17] = aucKn[ 7];
        aucWorka[18] = aucKn[23];
        aucWorka[19] = aucKn[13];
        aucWorka[20] = aucKn[31];
        aucWorka[21] = aucKn[26];
        aucWorka[22] = aucKn[ 2];
        aucWorka[23] = aucKn[ 8];
        aucWorka[24] = aucKn[18];
        aucWorka[25] = aucKn[12];
        aucWorka[26] = aucKn[29];
        aucWorka[27] = aucKn[ 5];
        aucWorka[28] = aucKn[21];
        aucWorka[29] = aucKn[10];
        aucWorka[30] = aucKn[ 3];
        aucWorka[31] = aucKn[24];

        // aucBufOut XOR aucWorka
        for (i = 0; i < 32; i++) 
        {
            aucBufOut[i+32] = aucBufOut[i] ^ aucWorka[i];
            aucBufOut[i] = aucBuffer[i];
        }
    } 

    // Prepare Output
    for (i = 0; i < 32; i++) 
    {
        j = aucBufOut[i];

        aucBufOut[i] = aucBufOut[32 + i];

        aucBufOut[32 + i] = j;
    }

    // Inverse Initial Permutation
    aucBuffer[ 0] = aucBufOut[39];
    aucBuffer[ 1] = aucBufOut[ 7];
    aucBuffer[ 2] = aucBufOut[47];
    aucBuffer[ 3] = aucBufOut[15];
    aucBuffer[ 4] = aucBufOut[55];
    aucBuffer[ 5] = aucBufOut[23];
    aucBuffer[ 6] = aucBufOut[63];
    aucBuffer[ 7] = aucBufOut[31];
    aucBuffer[ 8] = aucBufOut[38];
    aucBuffer[ 9] = aucBufOut[ 6];
    aucBuffer[10] = aucBufOut[46];
    aucBuffer[11] = aucBufOut[14];
    aucBuffer[12] = aucBufOut[54];
    aucBuffer[13] = aucBufOut[22];
    aucBuffer[14] = aucBufOut[62];
    aucBuffer[15] = aucBufOut[30];
    aucBuffer[16] = aucBufOut[37];
    aucBuffer[17] = aucBufOut[ 5];
    aucBuffer[18] = aucBufOut[45];
    aucBuffer[19] = aucBufOut[13];
    aucBuffer[20] = aucBufOut[53];
    aucBuffer[21] = aucBufOut[21];
    aucBuffer[22] = aucBufOut[61];
    aucBuffer[23] = aucBufOut[29];
    aucBuffer[24] = aucBufOut[36];
    aucBuffer[25] = aucBufOut[ 4];
    aucBuffer[26] = aucBufOut[44];
    aucBuffer[27] = aucBufOut[12];
    aucBuffer[28] = aucBufOut[52];
    aucBuffer[29] = aucBufOut[20];
    aucBuffer[30] = aucBufOut[60];
    aucBuffer[31] = aucBufOut[28];
    aucBuffer[32] = aucBufOut[35];
    aucBuffer[33] = aucBufOut[ 3];
    aucBuffer[34] = aucBufOut[43];
    aucBuffer[35] = aucBufOut[11];
    aucBuffer[36] = aucBufOut[51];
    aucBuffer[37] = aucBufOut[19];
    aucBuffer[38] = aucBufOut[59];
    aucBuffer[39] = aucBufOut[27];
    aucBuffer[40] = aucBufOut[34];
    aucBuffer[41] = aucBufOut[ 2];
    aucBuffer[42] = aucBufOut[42];
    aucBuffer[43] = aucBufOut[10];
    aucBuffer[44] = aucBufOut[50];
    aucBuffer[45] = aucBufOut[18];
    aucBuffer[46] = aucBufOut[58];
    aucBuffer[47] = aucBufOut[26];
    aucBuffer[48] = aucBufOut[33];
    aucBuffer[49] = aucBufOut[ 1];
    aucBuffer[50] = aucBufOut[41];
    aucBuffer[51] = aucBufOut[ 9];
    aucBuffer[52] = aucBufOut[49];
    aucBuffer[53] = aucBufOut[17];
    aucBuffer[54] = aucBufOut[57];
    aucBuffer[55] = aucBufOut[25];
    aucBuffer[56] = aucBufOut[32];
    aucBuffer[57] = aucBufOut[ 0];
    aucBuffer[58] = aucBufOut[40];
    aucBuffer[59] = aucBufOut[ 8];
    aucBuffer[60] = aucBufOut[48];
    aucBuffer[61] = aucBufOut[16];
    aucBuffer[62] = aucBufOut[56];
    aucBuffer[63] = aucBufOut[24];

    j = 0;

    for (i = 0; i < 8; i++) 
    {
        pucOutput[i] = 0x00;

        for (k = 0; k < 7; k++)
        {
            pucOutput[i] = (pucOutput[i] + aucBuffer[j + k]) * 2;
        }

        pucOutput[i] = pucOutput[i] + aucBuffer[j + 7];
        
        j += 8;
    }

    return 0;
}

/******************************************************************************
* 文件结束
******************************************************************************/