0x08020020, 0x08000000, 0x00020000, 0x08000820,
0x00000000, 0x08020820, 0x00020020, 0x08000020,
0x08020000, 0x08000800, 0x08000820, 0x00000000,
0x08020820, 0x00020800, 0x00020800, 0x00000820,
0x00000820, 0x00020020, 0x08000000, 0x08020800
};

#define INITIAL_PERMUTATION(t, regL, regR) \
        INITIAL_PERMUTATION_AUX(t[0], t[1], regL, regR)

#define FINAL_PERMUTATION(regR, regL, t) \
        FINAL_PERMUTATION_AUX(regR, regL, t[0], t[1])

#define PC1(k, regC, regD) \
        PC1_AUX(k[0], k[1], regC, regD)

#define PC2(regC, regD, k) \
        PC2_AUX(regC, regD, k[0], k[1])

unsigned char G_padChar = (char) 0; /* Default pad charcater */

static Word ROTATE_LEFT(Word x) 
{
	Word	a;
	a = (x & 0x80000000) >> 27;
	return (x << 1) | a;
}

static Word ROTATE_RIGHT(Word x) 
{
	Word	a;
	a = x & 0x00000010;
	return (x >> 1) | (a << 27);
}

/*
** The S Box transformations and the permutation P are combined in the vectors
** s_p0 - s_p7. Permutation E and the MOD 2 addition with the intermediate key
** are then done "inline" on each round. The intermediate key is already in a
** a 8x6bit form because of the modified permuation PC2 used.
*/

#if !defined(WORDS_BIGENDIAN)

#define DES(t, ik) \
{ \
    register Word l, r, reg32, round; \
    register unsigned char *bb; \
    INITIAL_PERMUTATION(t, l, r); \
    for(bb = (unsigned char *) ik, round = 0x8000; round; bb += 8, round >>= 1) { \
        register Word w = (r << 1) | (r >> 31); \
        reg32  = s_p7[( w        & 0x3f) ^ bb[4]]; \
        reg32 |= s_p6[((w >>= 4) & 0x3f) ^ bb[5]]; \
        reg32 |= s_p5[((w >>= 4) & 0x3f) ^ bb[6]]; \
        reg32 |= s_p4[((w >>= 4) & 0x3f) ^ bb[7]]; \
        reg32 |= s_p3[((w >>= 4) & 0x3f) ^ bb[0]]; \
        reg32 |= s_p2[((w >>= 4) & 0x3f) ^ bb[1]]; \
        reg32 |= s_p1[((w >>  4) & 0x3f) ^ bb[2]]; \
        reg32 |= s_p0[(((r & 0x1) << 5) | ((r & 0xf8000000) >> 27)) ^ bb[3]]; \
        reg32 ^= l; \
        l = r; \
        r = reg32; \
    } \
    FINAL_PERMUTATION(r, l, t); \
}


#define MAKE_LITTLE_ENDIAN(t, s) \
{ \
    register unsigned int z, l = s/4; \
    register Word *tp = (Word *) t; \
    for(z = 0; z < l; ++z) tp[z] = htonl(tp[z]); \
}

#else /* WORDS_BIGENDIAN */

#define DES(t, ik) \
{ \
    register Word l, r, reg32, round; \
    register unsigned char *bb; \
    INITIAL_PERMUTATION(t, l, r); \
    for(bb = (unsigned char *) ik, round = 0x8000; round; bb += 8, round >>= 1) { \
        register Word w = (r << 1) | (r >> 31); \
        reg32  = s_p7[( w        & 0x3f) ^ bb[7]]; \
        reg32 |= s_p6[((w >>= 4) & 0x3f) ^ bb[6]]; \
        reg32 |= s_p5[((w >>= 4) & 0x3f) ^ bb[5]]; \
        reg32 |= s_p4[((w >>= 4) & 0x3f) ^ bb[4]]; \
        reg32 |= s_p3[((w >>= 4) & 0x3f) ^ bb[3]]; \
        reg32 |= s_p2[((w >>= 4) & 0x3f) ^ bb[2]]; \
        reg32 |= s_p1[((w >>  4) & 0x3f) ^ bb[1]]; \
        reg32 |= s_p0[(((r & 0x1) << 5) | ((r & 0xf8000000) >> 27)) ^ bb[0]]; \
        reg32 ^= l; \
        l = r; \
        r = reg32; \
    } \
    FINAL_PERMUTATION(r, l, t); \
}

#endif /* WORDS_BIGENDIAN */

int
qfDES(unsigned char	*key,
      unsigned char	*data,
      unsigned int 	 size,
const QFDES_what   	 what,
const QFDES_mode   	 mode,
      unsigned char	*initVec)
{
    /* Store some info to optimise for multiple calls ... */
    static unsigned char desKey[8], desKeys[128];
    static Word 	*oldKey = (Word *) desKey,
         		*keys   = (Word *) desKeys;
    static QFDES_what 	oldWhat;
    static QFDES_mode 	oldMode;
    unsigned char 	b0[8], b1[8]; /* feedback blocks */
    Word 		*newKey = (Word *) key, /* key from user */
         		*text,                  /* text to be [en|de]crypted */
         		*cb     = (Word *) b0,  /* the chained block in CBC mode */
         		*cb1    = (Word *) b1;  /* a copy for use when decrypting */

#if !defined(WORDS_BIGENDIAN)
    unsigned int origSize = size;
    MAKE_LITTLE_ENDIAN(key, 8);
    MAKE_LITTLE_ENDIAN(data, origSize);
#endif

    /*
    ** Check new key against old key
    ** and set up intermediate keys.
    */
    if (newKey[0] != oldKey[0] || newKey[1] != oldKey[1]) {
        Word c, d;  /* C and D registers */

        oldKey[0] = newKey[0]; oldKey[1] = newKey[1];
        oldWhat   = what;
        oldMode   = mode;

        PC1(newKey, c, d);

        if ((what == qfDES_encrypt) || (mode == qfDES_cfb) || (mode == qfDES_ofb)) {
		int 	 z;
		Word	 r; 
		Word	*k = keys; 
		Word 	 rol[16] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};

		for(z = 0; z < 16; z++, k += 2) { 
			for (r = 0; r < rol[z]; r++) {
				c = ROTATE_LEFT(c); 
				d = ROTATE_LEFT(d);
			}
			PC2(c, d, k); 
		}
        } else {
		int 	 z;
		Word	 r; 
		Word	*k = keys; 
		Word 	 ror[16] = {0, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};

		for(z = 0; z < 16; z++, k += 2) { 
			r = 0;
			while (ror[z] > r) {
				r++;
				c = ROTATE_RIGHT(c); 
				d = ROTATE_RIGHT(d);
			}
			PC2(c, d, k); 
		} 
	}
    } else if ((what != oldWhat) && ((mode == qfDES_ecb) || (mode == qfDES_cbc))) {
        /*
        ** Same key but different direction.
        ** Reverse intermediate key sequence (ECB and CBC).
        */
        Word *ik1, *ik2, ik3[2];

        for(ik1 = keys, ik2 = &(keys[30]); ik1 < ik2; ik1 += 2, ik2 -= 2) {
            ik3[0] = ik1[0]; ik3[1] = ik1[1];
            ik1[0] = ik2[0]; ik1[1] = ik2[1];
            ik2[0] = ik3[0]; ik2[1] = ik3[1];
        }

        oldWhat = what;
    }

    /* Set up initilaisation vector */
    if (mode != qfDES_ecb) {
        if (initVec) {
            { cb[0] = ((Word *) initVec)[0]; cb[1] = ((Word *) initVec)[1]; }
        } else {
            cb[0] = 0;
	    cb[1] = 0;
	}
#if !defined(WORDS_BIGENDIAN)
        MAKE_LITTLE_ENDIAN(cb, 8);
#endif
    }

    /*
    ** Lots of gotos and code duplication follow (arrgh) but it speeds
    ** it up a wee bit!
    ** What would be more useful is looking more carefully at the DES
    ** permutations to produce more efficient versions of the macros
    ** of the "auto-generated" versions used in qfDES-aux.c.
    */

    size >>= 3; /* this is always a multpile of 8 */

    if (what == qfDES_encrypt) {
        switch ((int) mode) {
        case ((int) qfDES_ecb): goto _ECB_;
        case ((int) qfDES_cbc): goto _CBC_encrypt_;
        case ((int) qfDES_cfb): goto _CFB_encrypt_;
        case ((int) qfDES_ofb): goto _OFB_;
        }
    }
    else {
        switch ((int) mode) {
        case ((int) qfDES_ecb): goto _ECB_;
        case ((int) qfDES_cbc): goto _CBC_decrypt_;
        case ((int) qfDES_cfb): goto _CFB_decrypt_;
        case ((int) qfDES_ofb): goto _OFB_;
        }
    }

_ECB_:

    /* ECB */
    for(text = (Word *) data; size; --size, text += 2)
        { DES(text, keys); }

    goto _exit_qfDES_;

_CBC_encrypt_:

    /* CBC Encryption */
    for(text = (Word *) data; size; --size, text += 2) {

        /* chaining block */
        text[0] ^= cb[0]; text[1] ^= cb[1];

        DES(text, keys);

        /* set up chaining block for next round */
        cb[0] = text[0]; cb[1] = text[1];
    }

    goto _initVec_;

_CBC_decrypt_:

    /* CBC Decryption */
    for(text = (Word *) data; size; --size, text += 2) {

        /* set up chaining block */
        /*
        ** The decryption is done in place so I need
        ** to copy this text block for the next round.
        */
        cb1[0] = text[0]; cb1[1] = text[1];

        DES(text, keys);

        /* chaining block for next round */
        text[0] ^= cb[0]; text[1] ^= cb[1];

        /*
        ** Copy back the saved encrypted text - this makes
        ** CBC decryption slower than CBC encryption.
        */
        cb[0] = cb1[0]; cb[1] = cb1[1];
    }

    goto _initVec_;

_CFB_encrypt_:

    /* CFB Encryption */
    for(text = (Word *) data; size; --size, text += 2) {

        /* use cb as the feedback block */
        DES(cb, keys);

        text[0] ^= cb[0]; text[1] ^= cb[1];

        /* set up feedback block for next round */
        cb[0] = text[0]; cb[1] = text[1];
    }

    goto _initVec_;

_CFB_decrypt_:

    /* CFB Decryption */
    for(text = (Word *) data; size; --size, text += 2) {

        /* set up feedback block */
        /*
        ** The decryption is done in place so I need
        ** to copy this text block for the next round.
        */
        cb1[0] = text[0]; cb1[1] = text[1];

        /* use cb as the feedback block */
        DES(cb, keys);

        text[0] ^= cb[0]; text[1] ^= cb[1];

        /* set up feedback block for next round */
        cb[0] = cb1[0]; cb[1] = cb1[1];
    }

    goto _initVec_;

_OFB_:

    /* OFB */
    for(text = (Word *) data; size; --size, text += 2) {

        /* use cb as the feed back block */
        DES(cb, keys);

        text[0] ^= cb[0]; text[1] ^= cb[1];
    }

_initVec_:

    /*
    ** Copy the final chained block back to initVec (CBC, CFB and OFB).
    ** This allows the [en|de]cryption of large amounts of data in small
    ** chunks.
    */
    if (initVec) {
        ((Word *) initVec)[0] = cb[0];
        ((Word *) initVec)[1] = cb[1];

#if !defined(WORDS_BIGENDIAN)
        MAKE_LITTLE_ENDIAN(initVec, 8);
#endif
    }

_exit_qfDES_:

#if !defined(WORDS_BIGENDIAN)
    MAKE_LITTLE_ENDIAN(key, 8);
    MAKE_LITTLE_ENDIAN(data, origSize);
#endif

    return 0;
}

/*
** This function sets bit 8 of each byte to odd or even parity as requested.
** It is assumed that the right-most bit of each byte is the parity bit.
** Although this is really only used by the two key generation functions below,
** it may be useful to someone.
*/

void qfDES_setParity(unsigned char *ptr, unsigned int size, const QFDES_parity parity)
{
    unsigned int i, mask, bits;

    for(i = 0; i < size; ++i, ++ptr) {
        for(mask = 0x80, bits = 0; mask > 0x01; mask >>= 1)
            if (((unsigned int) *ptr) & mask) ++bits;

        *ptr |= bits % 2 == (unsigned int) parity ? 0x00 : 0x01;
    }
}

unsigned int qfDES_checkParity(unsigned char *ptr, unsigned int size, const QFDES_parity parity)
{
    unsigned int i, mask, bits, parityBit, parityErrors = 0;

    for(i = 0; i < size; ++i, ++ptr) {
        for(mask = 0x80, bits = 0; mask > 0x01; mask >>= 1)
            if (((unsigned int) *ptr) & mask) ++bits;

        parityBit = bits % 2 == (unsigned int) parity ? 0 : 1;

        if ((((unsigned int) *ptr) & 0x1) != parityBit)
            ++parityErrors;
    }

    return parityErrors;
}

static
unsigned char weakKeys[18][8] =
{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
 {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 {0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe},
 {0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e},
 {0xe0, 0xe0, 0xe0, 0xe0, 0xf1, 0xf1, 0xf1, 0xf1},
 {0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe},
 {0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01},
 {0x1f, 0xe0, 0x1f, 0xe0, 0x0e, 0xf1, 0x0e, 0xf1},
 {0xe0, 0x1f, 0xe0, 0x1f, 0xf1, 0x0e, 0xf1, 0x0e},
 {0x01, 0xe0, 0x01, 0xe0, 0x01, 0xf1, 0x01, 0xf1},
 {0xe0, 0x01, 0xe0, 0x01, 0xf1, 0x01, 0xf1, 0x01},
 {0x1f, 0xfe, 0x1f, 0xfe, 0x0e, 0xfe, 0x0e, 0xfe},
 {0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x0e, 0xfe, 0x0e},
 {0x01, 0x1f, 0x01, 0x1f, 0x01, 0x0e, 0x01, 0x0e},
 {0x1f, 0x01, 0x1f, 0x01, 0x0e, 0x01, 0x0e, 0x01},
 {0xe0, 0xfe, 0xe0, 0xfe, 0xf1, 0xfe, 0xf1, 0xfe},
 {0xfe, 0xe0, 0xfe, 0xe0, 0xfe, 0xf1, 0xfe, 0xf1}};

/*
** Although this is really only used by the key generation function below,
** it may be handy to someone.
*/

int qfDES_checkWeakKeys(unsigned char *key)
{
    unsigned char *bp;
    int i;

    for(bp = weakKeys[i = 0]; i < 18; bp = weakKeys[++i])
        if (memcmp((void *) key, (void *) bp, 8) == 0) return -1;

    return 0;
}

/*
** The following function attempts to genreate a random key or IV.
** It relies on the randomness of the  of the random(3) function. Although
** it is probably not particularly fast, keys and IV will most probably be
** generated off-line so it does not matter too much.
*/

unsigned char *qfDES_generate(const QFDES_generate what)
{
    static
    unsigned char buffer[8];
    static
    int flag = 0;

    unsigned char *bp;
    long mask = what == qfDES_key ? 0xfe : 0xff;

    /* Set up a seed - 42 is the answer ... */
    if (!flag) {
        lbl_srandom((int) (getpid() * 42) ^ (int) time((time_t *) 0));
        flag = 1;
    }
    do {

        for(bp = buffer; bp <= &(buffer[7]); *bp++ = (unsigned char) (lbl_random() & mask));

        if (what ==  qfDES_key)
            qfDES_setParity(buffer, 8, qfDES_odd);

    } while(what == qfDES_key ? qfDES_checkWeakKeys(buffer) : 0);

    return buffer;
}

unsigned char
qfDES_setPad(unsigned char pad)
{ 
    unsigned char b = G_padChar; G_padChar = pad; return b; 
}