0101_APP/APP/des/des.c

//#include "..\SourceFile\Main.h"
#include ".\des.h"

#define EN0    0    /* MODE == encrypt */
#define DE1    1    /* MODE == decrypt */



void scrunch(uint8 *, uint32 *);
void unscrun(uint32 *, uint8 *);
void desfunc(uint32 *, uint32 *);

//uint32 KnL[32] = { 0L };
//uint32 KnR[32] = { 0L };
//uint32 Kn3[32] = { 0L };

uint16 const bytebit[8] = {
      0200, 0100, 040, 020, 010, 04, 02, 01 };

uint32 const bigbyte[24] = {
   0x800000L,    0x400000L,    0x200000L,    0x100000L,
   0x80000L,    0x40000L,    0x20000L,    0x10000L,
   0x8000L,    0x4000L,    0x2000L,    0x1000L,
   0x800L,     0x400L,     0x200L,     0x100L,
   0x80L,        0x40L,        0x20L,        0x10L,
   0x8L,        0x4L,        0x2L,        0x1L };

/* Use the key schedule specified in the Standard (ANSI X3.92-1981). */

uint8 const pc1[56] = {
   56, 48, 40, 32, 24, 16,  8,     0, 57, 49, 41, 33, 25, 17,
    9,  1, 58, 50, 42, 34, 26,    18, 10,  2, 59, 51, 43, 35,
   62, 54, 46, 38, 30, 22, 14,     6, 61, 53, 45, 37, 29, 21,
   13,  5, 60, 52, 44, 36, 28,    20, 12,  4, 27, 19, 11,  3 };

uint8 const totrot[16] = {
    1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28 };

uint8 const pc2[48] = {
    13, 16, 10, 23,  0,  4,  2, 27, 14,  5, 20,  9,
    22, 18, 11,  3, 25,  7, 15,  6, 26, 19, 12,  1,
    40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,
    43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31 };

//===============================
//S Box
//{/*{{{*/
uint32 const SP1[64] = {
    0x01010400L, 0x00000000L, 0x00010000L, 0x01010404L,
    0x01010004L, 0x00010404L, 0x00000004L, 0x00010000L,
    0x00000400L, 0x01010400L, 0x01010404L, 0x00000400L,
    0x01000404L, 0x01010004L, 0x01000000L, 0x00000004L,
    0x00000404L, 0x01000400L, 0x01000400L, 0x00010400L,
    0x00010400L, 0x01010000L, 0x01010000L, 0x01000404L,
    0x00010004L, 0x01000004L, 0x01000004L, 0x00010004L,
    0x00000000L, 0x00000404L, 0x00010404L, 0x01000000L,
    0x00010000L, 0x01010404L, 0x00000004L, 0x01010000L,
    0x01010400L, 0x01000000L, 0x01000000L, 0x00000400L,
    0x01010004L, 0x00010000L, 0x00010400L, 0x01000004L,
    0x00000400L, 0x00000004L, 0x01000404L, 0x00010404L,
    0x01010404L, 0x00010004L, 0x01010000L, 0x01000404L,
    0x01000004L, 0x00000404L, 0x00010404L, 0x01010400L,
    0x00000404L, 0x01000400L, 0x01000400L, 0x00000000L,
    0x00010004L, 0x00010400L, 0x00000000L, 0x01010004L };

uint32 const SP2[64] = {
    0x80108020L, 0x80008000L, 0x00008000L, 0x00108020L,
    0x00100000L, 0x00000020L, 0x80100020L, 0x80008020L,
    0x80000020L, 0x80108020L, 0x80108000L, 0x80000000L,
    0x80008000L, 0x00100000L, 0x00000020L, 0x80100020L,
    0x00108000L, 0x00100020L, 0x80008020L, 0x00000000L,
    0x80000000L, 0x00008000L, 0x00108020L, 0x80100000L,
    0x00100020L, 0x80000020L, 0x00000000L, 0x00108000L,
    0x00008020L, 0x80108000L, 0x80100000L, 0x00008020L,
    0x00000000L, 0x00108020L, 0x80100020L, 0x00100000L,
    0x80008020L, 0x80100000L, 0x80108000L, 0x00008000L,
    0x80100000L, 0x80008000L, 0x00000020L, 0x80108020L,
    0x00108020L, 0x00000020L, 0x00008000L, 0x80000000L,
    0x00008020L, 0x80108000L, 0x00100000L, 0x80000020L,
    0x00100020L, 0x80008020L, 0x80000020L, 0x00100020L,
    0x00108000L, 0x00000000L, 0x80008000L, 0x00008020L,
    0x80000000L, 0x80100020L, 0x80108020L, 0x00108000L };

uint32 const SP3[64] = {
    0x00000208L, 0x08020200L, 0x00000000L, 0x08020008L,
    0x08000200L, 0x00000000L, 0x00020208L, 0x08000200L,
    0x00020008L, 0x08000008L, 0x08000008L, 0x00020000L,
    0x08020208L, 0x00020008L, 0x08020000L, 0x00000208L,
    0x08000000L, 0x00000008L, 0x08020200L, 0x00000200L,
    0x00020200L, 0x08020000L, 0x08020008L, 0x00020208L,
    0x08000208L, 0x00020200L, 0x00020000L, 0x08000208L,
    0x00000008L, 0x08020208L, 0x00000200L, 0x08000000L,
    0x08020200L, 0x08000000L, 0x00020008L, 0x00000208L,
    0x00020000L, 0x08020200L, 0x08000200L, 0x00000000L,
    0x00000200L, 0x00020008L, 0x08020208L, 0x08000200L,
    0x08000008L, 0x00000200L, 0x00000000L, 0x08020008L,
    0x08000208L, 0x00020000L, 0x08000000L, 0x08020208L,
    0x00000008L, 0x00020208L, 0x00020200L, 0x08000008L,
    0x08020000L, 0x08000208L, 0x00000208L, 0x08020000L,
    0x00020208L, 0x00000008L, 0x08020008L, 0x00020200L };

uint32 const SP4[64] = {
    0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,
    0x00802080L, 0x00800081L, 0x00800001L, 0x00002001L,
    0x00000000L, 0x00802000L, 0x00802000L, 0x00802081L,
    0x00000081L, 0x00000000L, 0x00800080L, 0x00800001L,
    0x00000001L, 0x00002000L, 0x00800000L, 0x00802001L,
    0x00000080L, 0x00800000L, 0x00002001L, 0x00002080L,
    0x00800081L, 0x00000001L, 0x00002080L, 0x00800080L,
    0x00002000L, 0x00802080L, 0x00802081L, 0x00000081L,
    0x00800080L, 0x00800001L, 0x00802000L, 0x00802081L,
    0x00000081L, 0x00000000L, 0x00000000L, 0x00802000L,
    0x00002080L, 0x00800080L, 0x00800081L, 0x00000001L,
    0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,
    0x00802081L, 0x00000081L, 0x00000001L, 0x00002000L,
    0x00800001L, 0x00002001L, 0x00802080L, 0x00800081L,
    0x00002001L, 0x00002080L, 0x00800000L, 0x00802001L,
    0x00000080L, 0x00800000L, 0x00002000L, 0x00802080L };

uint32 const SP5[64] = {
    0x00000100L, 0x02080100L, 0x02080000L, 0x42000100L,
    0x00080000L, 0x00000100L, 0x40000000L, 0x02080000L,
    0x40080100L, 0x00080000L, 0x02000100L, 0x40080100L,
    0x42000100L, 0x42080000L, 0x00080100L, 0x40000000L,
    0x02000000L, 0x40080000L, 0x40080000L, 0x00000000L,
    0x40000100L, 0x42080100L, 0x42080100L, 0x02000100L,
    0x42080000L, 0x40000100L, 0x00000000L, 0x42000000L,
    0x02080100L, 0x02000000L, 0x42000000L, 0x00080100L,
    0x00080000L, 0x42000100L, 0x00000100L, 0x02000000L,
    0x40000000L, 0x02080000L, 0x42000100L, 0x40080100L,
    0x02000100L, 0x40000000L, 0x42080000L, 0x02080100L,
    0x40080100L, 0x00000100L, 0x02000000L, 0x42080000L,
    0x42080100L, 0x00080100L, 0x42000000L, 0x42080100L,
    0x02080000L, 0x00000000L, 0x40080000L, 0x42000000L,
    0x00080100L, 0x02000100L, 0x40000100L, 0x00080000L,
    0x00000000L, 0x40080000L, 0x02080100L, 0x40000100L };

uint32 const SP6[64] = {
    0x20000010L, 0x20400000L, 0x00004000L, 0x20404010L,
    0x20400000L, 0x00000010L, 0x20404010L, 0x00400000L,
    0x20004000L, 0x00404010L, 0x00400000L, 0x20000010L,
    0x00400010L, 0x20004000L, 0x20000000L, 0x00004010L,
    0x00000000L, 0x00400010L, 0x20004010L, 0x00004000L,
    0x00404000L, 0x20004010L, 0x00000010L, 0x20400010L,
    0x20400010L, 0x00000000L, 0x00404010L, 0x20404000L,
    0x00004010L, 0x00404000L, 0x20404000L, 0x20000000L,
    0x20004000L, 0x00000010L, 0x20400010L, 0x00404000L,
    0x20404010L, 0x00400000L, 0x00004010L, 0x20000010L,
    0x00400000L, 0x20004000L, 0x20000000L, 0x00004010L,
    0x20000010L, 0x20404010L, 0x00404000L, 0x20400000L,
    0x00404010L, 0x20404000L, 0x00000000L, 0x20400010L,
    0x00000010L, 0x00004000L, 0x20400000L, 0x00404010L,
    0x00004000L, 0x00400010L, 0x20004010L, 0x00000000L,
    0x20404000L, 0x20000000L, 0x00400010L, 0x20004010L };

uint32 const SP7[64] = {
    0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L,
    0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L,
    0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L,
    0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L,
    0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L,
    0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L,
    0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L,
    0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L,
    0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L,
    0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L,
    0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L,
    0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L,
    0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L,
    0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L,
    0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L,
    0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L };

uint32 const SP8[64] = {
    0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L,
    0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L,
    0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L,
    0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L,
    0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L,
    0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L,
    0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L,
    0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L,
    0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L,
    0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L,
    0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L,
    0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L,
    0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L,
    0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L,
    0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L,
    0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L };
///}/*}}}*/
//===============================

void MyMemCopy(uint8 * _aimMem,uint8 * _surMem,uint32 _len)
{/*{{{*/
    uint32 i;
    for(i=0;i<_len;i++)
        _aimMem[i]=_surMem[i];
}/*}}}*/

void MyMemSet(uint8 * _mem,uint32 _val,uint32 _len)
{/*{{{*/
    uint32 i;
    for(i=0;i<_len;i++)
        _mem[i]=_val;
}/*}}}*/

void cookey(uint32 * raw1,uint32 * _knBuff)
{/*{{{*/
    uint32 * cook, * raw0;
    //uint32 dough[32];
    int i;

    cook = _knBuff;
    for (i = 0; i < 16; i++, raw1++)
    {
        raw0 = raw1++;
        *cook = (*raw0 & 0x00fc0000L) << 6;
        *cook |= (*raw0 & 0x00000fc0L) << 10;
        *cook |= (*raw1 & 0x00fc0000L) >> 10;
        *cook++ |= (*raw1 & 0x00000fc0L) >> 6;
        *cook = (*raw0 & 0x0003f000L) << 12;
        *cook |= (*raw0 & 0x0000003fL) << 16;
        *cook |= (*raw1 & 0x0003f000L) >> 4;
        *cook++ |= (*raw1 & 0x0000003fL);
    }
    //MyMemCopy((uint8 *)_knBuff,(uint8 *)dough, 32 * 4);
    return;
}/*}}}*/

void deskey(uint8 * key,uint32 * _knBuff,uint8 edf) 
{/*{{{*/
    uint8 i, j, l, m, n;
    uint8 pc1m[56], pcr[56];
    uint32 kn[32];

    for (j = 0; j < 56; j++)
    {
        l = pc1[j];
        m = l & 07;
        pc1m[j] = (key[l >> 3] & bytebit[m]) ? 1 : 0;
    }
    for (i = 0; i < 16; i++)
    {
        if (edf == DE1)
            m = (15 - i) << 1;
        else
            m = i << 1;
        n = m + 1;
        kn[m] = kn[n] = 0L;
        for (j = 0; j < 28; j++)
        {
            l = j + totrot[i];
            if (l < 28)
                pcr[j] = pc1m[l];
            else
                pcr[j] = pc1m[l - 28];
        }
        for (j = 28; j < 56; j++)
        {
            l = j + totrot[i];
            if (l < 56)
                pcr[j] = pc1m[l];
            else
                pcr[j] = pc1m[l - 28];
        }
        for (j = 0; j < 24; j++)
        {
            if (pcr[pc2[j]])
                kn[m] |= bigbyte[j];
            if (pcr[pc2[j + 24]])
                kn[n] |= bigbyte[j];
        }
    }
    cookey(kn,_knBuff);
    return;
}/*}}}*/

void des(uint8 * inblock, uint8 * outblock,uint32 * _knBuff)
{/*{{{*/
    uint32 work[2];

    scrunch(inblock, work);
    desfunc(work, _knBuff);
    unscrun(work, outblock);
    return;
}/*}}}*/

void scrunch(uint8 * outof, uint32 * into)
{/*{{{*/
    uint8 * p = (uint8 *)into;

    p[0] = outof[3];
    p[1] = outof[2];
    p[2] = outof[1];
    p[3] = outof[0];

    p += 4;
    outof += 4;

    p[0] = outof[3];
    p[1] = outof[2];
    p[2] = outof[1];
    p[3] = outof[0];

}/*}}}*/

void unscrun(uint32 * outof, uint8 * into)
{/*{{{*/
    uint8 * p = (uint8 *)outof;

    into[0] = p[3];
    into[1] = p[2];
    into[2] = p[1];
    into[3] = p[0];

    into += 4;
    p += 4;

    into[0] = p[3];
    into[1] = p[2];
    into[2] = p[1];
    into[3] = p[0];
}/*}}}*/

void desfunc(uint32 * block, uint32 * keys)
{/*{{{*/
    uint32 fval, work, right, leftt;
    int round;

    leftt = block[0];
    right = block[1];
    work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;
    right ^= work;
    leftt ^= (work << 4);
    work = ((leftt >> 16) ^ right) & 0x0000ffffL;
    right ^= work;
    leftt ^= (work << 16);
    work = ((right >> 2) ^ leftt) & 0x33333333L;
    leftt ^= work;
    right ^= (work << 2);
    work = ((right >> 8) ^ leftt) & 0x00ff00ffL;
    leftt ^= work;
    right ^= (work << 8);
    right = ((right << 1) | ((right >> 31) & 1L)) & 0xffffffffL;
    work = (leftt ^ right) & 0xaaaaaaaaL;
    leftt ^= work;
    right ^= work;
    leftt = ((leftt << 1) | ((leftt >> 31) & 1L)) & 0xffffffffL;

    for (round = 0; round < 8; round++)
    {
        work = (right << 28) | (right >> 4);
        work ^= *keys++;
        fval = SP7[(int)(work & 0x3fL)];
        fval |= SP5[(int)((work >> 8) & 0x3fL)];
        fval |= SP3[(int)((work >> 16) & 0x3fL)];
        fval |= SP1[(int)((work >> 24) & 0x3fL)];
        work = right ^ *keys++;
        fval |= SP8[(int)(work & 0x3fL)];
        fval |= SP6[(int)((work >> 8) & 0x3fL)];
        fval |= SP4[(int)((work >> 16) & 0x3fL)];
        fval |= SP2[(int)((work >> 24) & 0x3fL)];
        leftt ^= fval;
        work = (leftt << 28) | (leftt >> 4);
        work ^= *keys++;
        fval = SP7[(int)(work & 0x3fL)];
        fval |= SP5[(int)((work >> 8) & 0x3fL)];
        fval |= SP3[(int)((work >> 16) & 0x3fL)];
        fval |= SP1[(int)((work >> 24) & 0x3fL)];
        work = leftt ^ *keys++;
        fval |= SP8[(int)(work & 0x3fL)];
        fval |= SP6[(int)((work >> 8) & 0x3fL)];
        fval |= SP4[(int)((work >> 16) & 0x3fL)];
        fval |= SP2[(int)((work >> 24) & 0x3fL)];
        right ^= fval;
    }

    right = (right << 31) | (right >> 1);
    work = (leftt ^ right) & 0xaaaaaaaaL;
    leftt ^= work;
    right ^= work;
    leftt = (leftt << 31) | (leftt >> 1);
    work = ((leftt >> 8) ^ right) & 0x00ff00ffL;
    right ^= work;
    leftt ^= (work << 8);
    work = ((leftt >> 2) ^ right) & 0x33333333L;
    right ^= work;
    leftt ^= (work << 2);
    work = ((right >> 16) ^ leftt) & 0x0000ffffL;
    leftt ^= work;
    right ^= (work << 16);
    work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL;
    leftt ^= work;
    right ^= (work << 4);
    *block++ = right;
    *block = leftt;
    return;
}/*}}}*/

void des2key(uint8 * hexkey,uint32 * _knBuff, uint8 mode)  /* stomps on Kn3 too */
{/*{{{*/
    uint8 revmod;

    revmod = (mode == EN0) ? DE1 : EN0;
    deskey(hexkey,_knBuff,mode);
    MyMemCopy((uint8 *)(&_knBuff[64]), (uint8 *)_knBuff, 32 * 4);  // Kn3 = KnL
    deskey(&hexkey[8],&_knBuff[32],revmod);
    return;
}/*}}}*/

void des3key(uint8 * hexkey, uint32 * _knBuff,uint8 mode)  /* stomps on Kn3 too */
{/*{{{*/
    uint8 revmod;

    revmod = (mode == EN0) ? DE1 : EN0;
    deskey(hexkey,_knBuff,mode);
    deskey(&hexkey[8],&_knBuff[32],revmod);
    deskey(&hexkey[16],&_knBuff[64],mode);
    return;
}/*}}}*/

void Ddes(uint8 * from, uint8 * into,uint32 * _knBuff)
{/*{{{*/
    uint32 work[2];

    scrunch(from, work);
    desfunc(work, _knBuff);
    desfunc(work, _knBuff+32);
    desfunc(work, _knBuff+64);
    unscrun(work, into);
    return;
}/*}}}*/

void D2des(uint8 * from, uint8 * into,uint32 * _knBuff)
{/*{{{*/
    uint32 * right, * l1, swap;
    uint32 leftt[2], bufR[2];

    right = bufR;
    l1 = &leftt[1];
    scrunch(from, leftt);
    scrunch(&from[8], right);
    desfunc(leftt, _knBuff);
    desfunc(right, _knBuff);
    swap = *l1;
    *l1 = *right;
    *right = swap;
    desfunc(leftt, _knBuff+32);
    desfunc(right, _knBuff+32);
    swap = *l1;
    *l1 = *right;
    *right = swap;
    desfunc(leftt, _knBuff+64);
    desfunc(right, _knBuff+64);
    unscrun(leftt, into);
    unscrun(right, &into[8]);
    return;
}/*}}}*/

void D3des(uint8 * from, uint8 * into,uint32 * _knBuff) /* amateur theatrics */
{/*{{{*/
    uint32 swap, leftt[2], middl[2], right[2];

    scrunch(from, leftt);
    scrunch(&from[8], middl);
    scrunch(&from[16], right);
    desfunc(leftt, _knBuff);
    desfunc(middl, _knBuff);
    desfunc(right, _knBuff);
    swap = leftt[1];
    leftt[1] = middl[0];
    middl[0] = swap;
    swap = middl[1];
    middl[1] = right[0];
    right[0] = swap;
    desfunc(leftt, _knBuff+32);
    desfunc(middl, _knBuff+32);
    desfunc(right, _knBuff+32);
    swap = leftt[1];
    leftt[1] = middl[0];
    middl[0] = swap;
    swap = middl[1];
    middl[1] = right[0];
    right[0] = swap;
    desfunc(leftt, _knBuff+64);
    desfunc(middl, _knBuff+64);
    desfunc(right, _knBuff+64);
    unscrun(leftt, into);
    unscrun(middl, &into[8]);
    unscrun(right, &into[16]);
    return;
}/*}}}*/

#if 0
void DesOperate(uint8 * _inData,uint8 * _outData,uint8 * _key,uint32 _mode)
{/*{{{*/
    uint8 des_key[8];
    uint8 plain[8];
    uint8 encipher[8];
    uint32 knBuff[32];

    //MyMemSet(des_key, 0, sizeof(des_key));
    //MyMemSet(plain, 0, 8);
    MyMemSet(encipher, 0, 8);
    MyMemCopy(plain, _inData, 8);
    //MyMemCopy(encipher, _outData, 8);

    MyMemCopy(des_key, _key, 8);
    deskey(des_key,knBuff,_mode);
    des(plain, encipher,knBuff);
    MyMemCopy(_outData, encipher, 8);
}/*}}}*/

uint32 DesEncrypt(uint8 * _inData,uint8 * _outData,uint8 * _key,uint32 _len)
{/*{{{*/
    uint32 loops;
    uint32 offset;

    if((_len&0x07)!=0x00)
        return False;
    loops=(_len>>3);
    offset=0;

    do{
        DesOperate(_inData+offset,_outData+offset,_key,EN0);
        loops--;
        offset+=8;
    }while(loops>0);
    return True;
}/*}}}*/

uint32 DesDecrypt(uint8 * _inData,uint8 * _outData,uint8 * _key,uint32 _len)
{/*{{{*/
    uint32 loops;
    uint32 offset;

    if((_len&0x07)!=0x00)
        return False;
    loops=(_len>>3);
    offset=0;

    do{
        DesOperate(_inData+offset,_outData+offset,_key,DE1);
        loops--;
        offset+=8;
    }while(loops>0);
    return True;
}/*}}}*/
#else
uint32 DesOperate(uint8 * _inData,uint8 * _outData,uint8 * _key, uint32 _len,uint32 _mode)
{/*{{{*/
    uint32 loops;
    uint32 offset;

    uint8 des_key[8];
    uint8 plain[8];
    uint8 encipher[8];
    uint32 knBuff[32];

    if((_len&0x07)!=0x00)
        return False;
    loops=(_len>>3);
    offset=0;

    MyMemCopy(des_key, _key, 8);
    deskey(des_key,knBuff,_mode);
    do{

        //MyMemSet(_outData+offset, 0, 8);
        MyMemSet(encipher, 0, 8);
        MyMemCopy(plain, _inData+offset, 8);

        des(plain, encipher,knBuff);
        MyMemCopy(_outData+offset,encipher, 8);
        //TripleDesOperate(_inData+offset,_outData+offset,_key,EN0);
        loops--;
        offset+=8;
    }while(loops>0);
    return True;
}/*}}}*/
#endif

#if 0
void TripleDesOperate(uint8 * _inData,uint8 * _outData,uint8 * _key,uint32 _mode)
{/*{{{*/
    uint8 des_key[16];
    uint8 plain[8];
    uint8 encipher[8];
    uint32 knBuff[32*3];

    //MyMemSet(des_key, 0, sizeof(des_key));
    //MyMemSet(plain, 0, 8);
    MyMemSet(encipher, 0, 8);
    MyMemCopy(plain, _inData, 8);
    //MyMemCopy(encipher, _outData, 8);
    MyMemCopy(des_key, _key, 16);
    des2key(des_key,knBuff,_mode);
    Ddes(plain, encipher,knBuff);
    MyMemCopy(_outData, encipher, 8);
}/*}}}*/

uint32 TripleDesEncrypt(uint8 * _inData,uint8 * _outData,uint8 * _key, uint32 _len)
{/*{{{*/
    uint32 loops;
    uint32 offset;

    if((_len&0x07)!=0x00)
        return False;
    loops=(_len>>3);
    offset=0;

    do{
        TripleDesOperate(_inData+offset,_outData+offset,_key,EN0);
        loops--;
        offset+=8;
    }while(loops>0);
    return True;
}/*}}}*/

uint32 TripleDesDecrypt(uint8 * _inData,uint8 * _outData, uint8 * _key, uint32 _len)
{/*{{{*/
    uint32 loops;
    uint32 offset;

    if((_len&0x07)!=0x00)
        return False;
    loops=(_len>>3);
    offset=0;

    do{
        TripleDesOperate(_inData+offset,_outData+offset,_key,DE1);
        loops--;
        offset+=8;
    }while(loops>0);
    return True;
}/*}}}*/

#else
uint32 TripleDesOperate(uint8 * _inData,uint8 * _outData,uint8 * _key, uint32 _len,uint32 _mode)
{/*{{{*/
    uint32 loops;
    uint32 offset;

    uint8 des_key[16];
    uint8 plain[8];
    uint8 encipher[8];
    uint32 knBuff[32*3];

    if((_len&0x07)!=0x00)
        return False;
    loops=(_len>>3);
    offset=0;

    MyMemCopy(des_key, _key, 16);
    des2key(des_key,knBuff,_mode);
    do{

        //MyMemSet(_outData+offset, 0, 8);
        MyMemSet(encipher, 0, 8);
        MyMemCopy(plain, _inData+offset, 8);

        Ddes(plain,encipher,knBuff);
        MyMemCopy(_outData+offset,encipher, 8);
        //TripleDesOperate(_inData+offset,_outData+offset,_key,EN0);
        loops--;
        offset+=8;
    }while(loops>0);
    return True;
}/*}}}*/
#endif

#if 0
void TripleDesOperate3Key(uint8 * _inData,uint8 * _outData,uint8 * _key,uint32 _mode)
{/*{{{*/
    uint8 des_key[24];
    uint8 plain[8];
    uint8 encipher[8];
    uint32 knBuff[32*3];

    //MyMemSet(des_key, 0, sizeof(des_key));
    //MyMemSet(plain, 0, 10);
    MyMemSet(encipher, 0, 8);
    MyMemCopy(plain, _inData, 8);
    //MyMemCopy(encipher, _outData, 8);
    MyMemCopy(des_key, _key, 24);
    des3key(des_key,knBuff,_mode);
    Ddes(plain, encipher,knBuff);
    MyMemCopy(_outData, encipher, 8);
}/*}}}*/

uint32 TripleDesEncrypt3Key(uint8 * _inData,uint8 * _outData,uint8 * _key, uint32 _len)
{/*{{{*/
    uint32 loops;
    uint32 offset;

    if((_len&0x07)!=0x00)
        return False;
    loops=(_len>>3);
    offset=0;

    do{
        TripleDesOperate3Key(_inData+offset,_outData+offset,_key,EN0);
        loops--;
        offset+=8;
    }while(loops>0);
    return True;
}/*}}}*/

uint32 TripleDesDecrypt3Key(uint8 * _inData,uint8 * _outData, uint8 * _key, uint32 _len)
{/*{{{*/
    uint32 loops;
    uint32 offset;

    if((_len&0x07)!=0x00)
        return False;
    loops=(_len>>3);
    offset=0;

    do{
        TripleDesOperate3Key(_inData+offset,_outData+offset,_key,DE1);
        loops--;
        offset+=8;
    }while(loops>0);
    return True;
}/*}}}*/
#else
uint32 TripleDesOperate3Key(uint8 * _inData,uint8 * _outData,uint8 * _key, uint32 _len,uint32 _mode)
{/*{{{*/
    uint32 loops;
    uint32 offset;

    uint8 des_key[24];
    uint8 plain[8];
    uint8 encipher[8];
    uint32 knBuff[32*3];

    if((_len&0x07)!=0x00)
        return False;
    loops=(_len>>3);
    offset=0;

    MyMemCopy(des_key, _key, 24);
    des3key(des_key,knBuff,_mode);
    do{

        //MyMemSet(_outData+offset, 0, 8);
        MyMemSet(encipher, 0, 8);
        MyMemCopy(plain, _inData+offset, 8);

        Ddes(plain,encipher,knBuff);
        MyMemCopy(_outData+offset,encipher, 8);
        //TripleDesOperate(_inData+offset,_outData+offset,_key,EN0);
        loops--;
        offset+=8;
    }while(loops>0);
    return True;
}/*}}}*/
#endif

uint32 DesEncryptFunc(uint8 * _inData,uint8 *_outData,uint8 * _key,uint32 _len,uint32 _keyLen)
{/*{{{*/
    if(_keyLen==E_DKL_DES)
        return DesOperate(_inData,_outData,_key,_len,EN0);
        //return DesEncrypt(_inData,_outData,_key,_len);
    else if(_keyLen==E_DKL_TRIPLE16)
        return TripleDesOperate(_inData,_outData,_key,_len,EN0);
        //return TripleDesEncrypt(_inData,_outData,_key,_len);
    else if(_keyLen==E_DKL_TRIPLE24)
        return TripleDesOperate3Key(_inData,_outData,_key,_len,EN0);
        //return TripleDesEncrypt3Key(_inData,_outData,_key,_len);
    else 
        return False;
}/*}}}*/

uint32 DesDecryptFunc(uint8 * _inData,uint8 *_outData,uint8 * _key,uint32 _len,uint32 _keyLen)
{/*{{{*/
    if(_keyLen==E_DKL_DES)
        return DesOperate(_inData,_outData,_key,_len,DE1);
        //return DesDecrypt(_inData,_outData,_key,_len);
    else if(_keyLen==E_DKL_TRIPLE16)
        return TripleDesOperate(_inData,_outData,_key,_len,DE1);
        //return TripleDesDecrypt(_inData,_outData,_key,_len,DE1);
    else if(_keyLen==E_DKL_TRIPLE24)
        return TripleDesOperate3Key(_inData,_outData,_key,_len,DE1);
        //return TripleDesDecrypt3Key(_inData,_outData,_key,_len);
    else 
        return False;
}/*}}}*/