d3des.c

3des 算法 Richard Outerbridge 本人写的一个不错的版本

        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[ work                 & 0x3fL];
                fval |= SP5[(work >>  8) & 0x3fL];
                fval |= SP3[(work >> 16) & 0x3fL];
                fval |= SP1[(work >> 24) & 0x3fL];
                work  = right ^ *keys++;
                fval |= SP8[ work                 & 0x3fL];
                fval |= SP6[(work >>  8) & 0x3fL];
                fval |= SP4[(work >> 16) & 0x3fL];
                fval |= SP2[(work >> 24) & 0x3fL];
                leftt ^= fval;
                work  = (leftt << 28) | (leftt >> 4);
                work ^= *keys++;
                fval  = SP7[ work                 & 0x3fL];
                fval |= SP5[(work >>  8) & 0x3fL];
                fval |= SP3[(work >> 16) & 0x3fL];
                fval |= SP1[(work >> 24) & 0x3fL];
                work  = leftt ^ *keys++;
                fval |= SP8[ work                 & 0x3fL];
                fval |= SP6[(work >>  8) & 0x3fL];
                fval |= SP4[(work >> 16) & 0x3fL];
                fval |= SP2[(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;
        }

#ifdef D2_DES

void des2key(hexkey, mode)                /* stomps on Kn3 too */
unsigned char *hexkey;                        /* unsigned char[16] */
short mode;
{
        short revmod;

        revmod = (mode == EN0) ? DE1 : EN0;
        deskey(&hexkey[8], revmod);
        cpkey(KnR);
        deskey(hexkey, mode);
        cpkey(Kn3);                                        /* Kn3 = KnL */
        return;
        }
       
void Ddes(from, into)
unsigned char *from, *into;                /* unsigned char[8] */
{
        unsigned long work[2];

        scrunch(from, work);
        desfunc(work, KnL);
        desfunc(work, KnR);
        desfunc(work, Kn3);
        unscrun(work, into);
        return;
        }

void D2des(from, into)
unsigned char *from;                        /* unsigned char[16] */
unsigned char *into;                        /* unsigned char[16] */
{
        unsigned long *right, *l1, swap;
        unsigned long leftt[2], bufR[2];
       
        right = bufR;
        l1 = &leftt[1];
        scrunch(from, leftt);
        scrunch(&from[8], right);
        desfunc(leftt, KnL);
        desfunc(right, KnL);
        swap = *l1;
        *l1 = *right;
        *right = swap;
        desfunc(leftt, KnR);
        desfunc(right, KnR);
        swap = *l1;
        *l1 = *right;
        *right = swap;
        desfunc(leftt, Kn3);
        desfunc(right, Kn3);
        unscrun(leftt, into);
        unscrun(right, &into[8]);
        return;
        }

void makekey(aptr, kptr)
char *aptr;                                /* NULL-terminated  */
unsigned char *kptr;                /* unsigned char[8] */
{
        unsigned char *store;
        int first, i;
        unsigned long savek[96];

        cpDkey(savek);
        des2key(Df_Key, EN0);
        for( i = 0; i < 8; i++ ) kptr = Df_Key;
        first = 1;
        while( (*aptr != '\0') || first ) {
                store = kptr;
                for( i = 0; i < 8 && (*aptr != '\0'); i++ ) {
                        *store++ ^= *aptr & 0x7f;
                        *aptr++ = '\0';
                        }
                Ddes(kptr, kptr);
                first = 0;
                }
        useDkey(savek);
        return;
        }

void make2key(aptr, kptr)
char *aptr;                                /* NULL-terminated   */
unsigned char *kptr;                /* unsigned char[16] */
{
        unsigned char *store;
        int first, i;
        unsigned long savek[96];

        cpDkey(savek);
        des2key(Df_Key, EN0);
        for( i = 0; i < 16; i++ ) kptr = Df_Key;
        first = 1;
        while( (*aptr != '\0') || first ) {
                store = kptr;
                for( i = 0; i < 16 && (*aptr != '\0'); i++ ) {
                        *store++ ^= *aptr & 0x7f;
                        *aptr++ = '\0';
                        }
                D2des(kptr, kptr);
                first = 0;
                }
        useDkey(savek);
        return;
        }

#ifndef D3_DES        /* D2_DES only */

void cp2key(into)
unsigned long *into;        /* unsigned long[64] */
{
        unsigned long *from, *endp;

        cpkey(into);
        into = &into[32];
        from = KnR, endp = &KnR[32];
        while( from < endp ) *into++ = *from++;
        return;
        }

void use2key(from)                                /* stomps on Kn3 too */
unsigned long *from;        /* unsigned long[64] */
{
        unsigned long *to, *endp;

        usekey(from);
        from = &from[32];
        to = KnR, endp = &KnR[32];
        while( to < endp ) *to++ = *from++;
        cpkey(Kn3);                                        /* Kn3 = KnL */
        return;
        }

#else        /* D3_DES too */

void des3key(hexkey, mode)
unsigned char *hexkey;                        /* unsigned char[24] */
short mode;
{
        unsigned char *first, *third;
        short revmod;

        if( mode == EN0 ) {
                revmod = DE1;
                first = hexkey;
                third = &hexkey[16];
                }
        else {
                revmod = EN0;
                first = &hexkey[16];
                third = hexkey;
                }
        deskey(&hexkey[8], revmod);
        cpkey(KnR);
        deskey(third, mode);
        cpkey(Kn3);
        deskey(first, mode);
        return;
        }

void cp3key(into)
unsigned long *into;        /* unsigned long[96] */
{
        unsigned long *from, *endp;

        cpkey(into);
        into = &into[32];
        from = KnR, endp = &KnR[32];
        while( from < endp ) *into++ = *from++;
        from = Kn3, endp = &Kn3[32];
        while( from < endp ) *into++ = *from++;
        return;
        }

void use3key(from)
unsigned long *from;        /* unsigned long[96] */
{
        unsigned long *to, *endp;

        usekey(from);
        from = &from[32];
        to = KnR, endp = &KnR[32];
        while( to < endp ) *to++ = *from++;
        to = Kn3, endp = &Kn3[32];
        while( to < endp ) *to++ = *from++;
        return;
        }

static void D3des(unsigned char *, unsigned char *);

static void D3des(from, into)        /* amateur theatrics */
unsigned char *from;                        /* unsigned char[24] */
unsigned char *into;                        /* unsigned char[24] */
{
        unsigned long swap, leftt[2], middl[2], right[2];
       
        scrunch(from, leftt);
        scrunch(&from[8], middl);
        scrunch(&from[16], right);
        desfunc(leftt, KnL);
        desfunc(middl, KnL);
        desfunc(right, KnL);
        swap = leftt[1];
        leftt[1] = middl[0];
        middl[0] = swap;
        swap = middl[1];
        middl[1] = right[0];
        right[0] = swap;
        desfunc(leftt, KnR);
        desfunc(middl, KnR);
        desfunc(right, KnR);
        swap = leftt[1];
        leftt[1] = middl[0];
        middl[0] = swap;
        swap = middl[1];
        middl[1] = right[0];
        right[0] = swap;
        desfunc(leftt, Kn3);
        desfunc(middl, Kn3);
        desfunc(right, Kn3);
        unscrun(leftt, into);
        unscrun(middl, &into[8]);
        unscrun(right, &into[16]);
        return;
        }       
       
void make3key(aptr, kptr)
char *aptr;                                /* NULL-terminated   */
unsigned char *kptr;                /* unsigned char[24] */
{
        unsigned char *store;
        int first, i;
        unsigned long savek[96];

        cp3key(savek);
        des3key(Df_Key, EN0);
        for( i = 0; i < 24; i++ ) kptr = Df_Key;
        first = 1;
        while( (*aptr != '\0') || first ) {
                store = kptr;
                for( i = 0; i < 24 && (*aptr != '\0'); i++ ) {
                        *store++ ^= *aptr & 0x7f;
                        *aptr++ = '\0';
                        }
                D3des(kptr, kptr);
                first = 0;
                }
        use3key(savek);
        return;
        }

#endif        /* D3_DES */
#endif        /* D2_DES */

/* Validation sets:
*
* Single-length key, single-length plaintext -
* Key    : 0123 4567 89ab cdef
* Plain  : 0123 4567 89ab cde7
* Cipher : c957 4425 6a5e d31d
*
* Double-length key, single-length plaintext -
* Key    : 0123 4567 89ab cdef fedc ba98 7654 3210
* Plain  : 0123 4567 89ab cde7
* Cipher : 7f1d 0a77 826b 8aff
*
* Double-length key, double-length plaintext -
* Key    : 0123 4567 89ab cdef fedc ba98 7654 3210
* Plain  : 0123 4567 89ab cdef 0123 4567 89ab cdff
* Cipher : 27a0 8440 406a df60 278f 47cf 42d6 15d7
*
* Triple-length key, single-length plaintext -
* Key    : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567
* Plain  : 0123 4567 89ab cde7
* Cipher : de0b 7c06 ae5e 0ed5
*
* Triple-length key, double-length plaintext -
* Key    : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567
* Plain  : 0123 4567 89ab cdef 0123 4567 89ab cdff
* Cipher : ad0d 1b30 ac17 cf07 0ed1 1c63 81e4 4de5
*
* d3des V5.09 rwo 9208.04 20:31 Graven Imagery
**********************************************************************/