crypt_des.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	qfDES_CBC_d(_key, _data, _size, _initVec)
#define	qfDES_CBC_e(_key, _data, _size, _initVec)
#define	qfDES_CFB_d(_key, _data, _size, _initVec)
#define	qfDES_CFB_e(_key, _data, _size, _initVec)
#define	qfDES_ECB_d(_key, _data, _size)
#define	qfDES_ECB_e(_key, _data, _size)
#define	qfDES_generateIV()
#define	qfDES_generateKey()
#define	qfDES_OFB_d(_key, _data, _size, _initVec)
#define	qfDES_OFB_e(_key, _data, _size, _initVec)
#define	qfDES_padSpace()
#define	qfDES_padZero()
#define	qfDES_plainTextSize(_ptr, _size)

Enumerations
enum	QFDES_generate { qfDES_key , qfDES_iv }
enum	QFDES_mode { qfDES_ecb , qfDES_cbc , qfDES_cfb , qfDES_ofb }
enum	QFDES_parity { qfDES_even , qfDES_odd }
enum	QFDES_what { qfDES_encrypt , qfDES_decrypt }

Functions
int	qfDES (unsigned char *key, unsigned char *data, unsigned int size, const QFDES_what what, const QFDES_mode mode, unsigned char *initVec)
unsigned int	qfDES_checkParity (unsigned char *ptr, unsigned int size, const QFDES_parity parity)
int	qfDES_checkWeakKeys (unsigned char *key)
unsigned char *	qfDES_generate (const QFDES_generate what)
unsigned char	qfDES_setPad (unsigned char pad)
void	qfDES_setParity (unsigned char *ptr, unsigned int size, const QFDES_parity parity)

Macro Definition Documentation

qfDES_CBC_d

#define qfDES_CBC_d	(		_key,
			_data,
			_size,
			_initVec )

Value:

qfDES(_key, _data, _size, qfDES_decrypt, qfDES_cbc, _initVec)

Definition at line 38 of file crypt_des.h.

Referenced by des_decrypt(), and test_des().

qfDES_CBC_e

#define qfDES_CBC_e	(		_key,
			_data,
			_size,
			_initVec )

Value:

qfDES(_key, _data, _size, qfDES_encrypt, qfDES_cbc, _initVec)

Definition at line 37 of file crypt_des.h.

Referenced by des_encrypt(), and test_des().

qfDES_CFB_d

#define qfDES_CFB_d	(		_key,
			_data,
			_size,
			_initVec )

Value:

qfDES(_key, _data, _size, qfDES_decrypt, qfDES_cfb, _initVec)

Definition at line 41 of file crypt_des.h.

qfDES_CFB_e

#define qfDES_CFB_e	(		_key,
			_data,
			_size,
			_initVec )

Value:

qfDES(_key, _data, _size, qfDES_encrypt, qfDES_cfb, _initVec)

Definition at line 40 of file crypt_des.h.

qfDES_ECB_d

#define qfDES_ECB_d	(		_key,
			_data,
			_size )

Value:

qfDES(_key, _data, _size, qfDES_decrypt, qfDES_ecb, (unsigned char *) 0)

Definition at line 35 of file crypt_des.h.

Referenced by test_des().

qfDES_ECB_e

#define qfDES_ECB_e	(		_key,
			_data,
			_size )

Value:

qfDES(_key, _data, _size, qfDES_encrypt, qfDES_ecb, (unsigned char *) 0)

Definition at line 34 of file crypt_des.h.

Referenced by test_des().

qfDES_generateIV

#define qfDES_generateIV

(

)

Value:

qfDES_generate(qfDES_iv)

Definition at line 62 of file crypt_des.h.

qfDES_generateKey

#define qfDES_generateKey

(

)

Value:

qfDES_generate(qfDES_key)

Definition at line 61 of file crypt_des.h.

qfDES_OFB_d

#define qfDES_OFB_d	(		_key,
			_data,
			_size,
			_initVec )

Value:

qfDES(_key, _data, _size, qfDES_decrypt, qfDES_ofb, _initVec)

Definition at line 44 of file crypt_des.h.

qfDES_OFB_e

#define qfDES_OFB_e	(		_key,
			_data,
			_size,
			_initVec )

Value:

qfDES(_key, _data, _size, qfDES_encrypt, qfDES_ofb, _initVec)

Definition at line 43 of file crypt_des.h.

qfDES_padSpace

#define qfDES_padSpace

(

)

Value:

qfDES_setPad((unsigned char) ' ')

Definition at line 49 of file crypt_des.h.

qfDES_padZero

#define qfDES_padZero

(

)

Value:

qfDES_setPad((unsigned char) '\0')

Definition at line 50 of file crypt_des.h.

qfDES_plainTextSize

#define qfDES_plainTextSize	(		_ptr,
			_size )

Value:

(unsigned int) ((_size) - (unsigned int) (_ptr)[(_size) - 1])

Definition at line 53 of file crypt_des.h.

Enumeration Type Documentation

QFDES_generate

enum QFDES_generate

Enumerator
qfDES_key
qfDES_iv

Definition at line 27 of file crypt_des.h.

{qfDES_key, qfDES_iv} QFDES_generate;

QFDES_mode

enum QFDES_mode

Enumerator
qfDES_ecb
qfDES_cbc
qfDES_cfb
qfDES_ofb

Definition at line 21 of file crypt_des.h.

{qfDES_ecb, qfDES_cbc, qfDES_cfb, qfDES_ofb} QFDES_mode;

QFDES_parity

enum QFDES_parity

Enumerator
qfDES_even
qfDES_odd

Definition at line 24 of file crypt_des.h.

{qfDES_even, qfDES_odd} QFDES_parity;

QFDES_what

enum QFDES_what

Enumerator
qfDES_encrypt
qfDES_decrypt

Definition at line 18 of file crypt_des.h.

{qfDES_encrypt, qfDES_decrypt} QFDES_what;

Function Documentation

qfDES()

int qfDES	(	unsigned char *	key,
		unsigned char *	data,
		unsigned int	size,
		const QFDES_what	what,
		const QFDES_mode	mode,
		unsigned char *	initVec )

Definition at line 558 of file crypt_des.c.

{
        /* Store some info to optimise for multiple calls ... */
        static unsigned char desKey[8], desKeys[128];
        static Word *oldKey = (Word *)(void *) desKey, *keys = (Word *) desKeys;
        static QFDES_what oldWhat;
        static QFDES_mode oldMode __attribute__((unused));
        unsigned char b0[8] = "", b1[8];     /* feedback blocks */
        Word *newKey = (Word *)(void *) key,    /* key from user */
            *text,              /* text to be [en|de]crypted */
            *cb = (Word *)(void *) b0,  /* the chained block in CBC mode */
            *cb1 = (Word *)(void *) 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 *)(void *) initVec)[0];
                                cb[1] = ((Word *)(void *) 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 *)(void *) data; size; --size, text += 2) {
                DES(text, keys);
        }
 
        goto _exit_qfDES_;
 
 _CBC_encrypt_:
 
        /* CBC Encryption */
        for (text = (Word *)(void *) 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 *)(void *) 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 *)(void *) 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 *)(void *) 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 *)(void *) 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 *)(void *) initVec)[0] = cb[0];
                ((Word *)(void *) 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;
}

References __attribute__(), DES, key, MAKE_LITTLE_ENDIAN, mode, PC1, PC2, qfDES_cbc, qfDES_cfb, qfDES_ecb, qfDES_encrypt, qfDES_ofb, ROTATE_LEFT(), and ROTATE_RIGHT().

Here is the call graph for this function:

qfDES_checkParity()

unsigned int qfDES_checkParity	(	unsigned char *	ptr,
		unsigned int	size,
		const QFDES_parity	parity )

Definition at line 856 of file crypt_des.c.

{
        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;
}

qfDES_checkWeakKeys()

int qfDES_checkWeakKeys

(

unsigned char *

key

)

Definition at line 902 of file crypt_des.c.

{
        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;
}

References key, and weakKeys.

Referenced by qfDES_generate().

qfDES_generate()

unsigned char * qfDES_generate

(

const QFDES_generate

what

)

Definition at line 921 of file crypt_des.c.

{
        static
        unsigned char buffer[8];
        static
        int flag = 0;
 
        unsigned char *bp;
        int 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;
}

References lbl_random(), lbl_srandom(), qfDES_checkWeakKeys(), qfDES_key, qfDES_odd, and qfDES_setParity().

Here is the call graph for this function:

qfDES_setPad()

unsigned char qfDES_setPad

(

unsigned char

pad

)

Definition at line 949 of file crypt_des.c.

{
        unsigned char b = G_padChar;
        G_padChar = pad;
        return b;
}

References G_padChar.

qfDES_setParity()

void qfDES_setParity	(	unsigned char *	ptr,
		unsigned int	size,
		const QFDES_parity	parity )

Definition at line 842 of file crypt_des.c.

{
        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;
        }
}

Referenced by qfDES_generate().