[qemu.git] / d3des.c

/*
 * This is D3DES (V5.09) by Richard Outerbridge with the double and
 * triple-length support removed for use in VNC.  Also the bytebit[] array
 * has been reversed so that the most significant bit in each byte of the
 * key is ignored, not the least significant.
 *
 * These changes are:
 *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 */

/* D3DES (V5.09) -
 *
 * A portable, public domain, version of the Data Encryption Standard.
 *
 * Written with Symantec's THINK (Lightspeed) C by Richard Outerbridge.
 * Thanks to: Dan Hoey for his excellent Initial and Inverse permutation
 * code;  Jim Gillogly & Phil Karn for the DES key schedule code; Dennis
 * Ferguson, Eric Young and Dana How for comparing notes; and Ray Lau,
 * for humouring me on.
 *
 * Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge.
 * (GEnie : OUTER; CIS : [71755,204]) Graven Imagery, 1992.
 */

#include "d3des.h"

static void scrunch(unsigned char *, unsigned long *);
static void unscrun(unsigned long *, unsigned char *);
static void desfunc(unsigned long *, unsigned long *);
static void cookey(unsigned long *);

static unsigned long KnL[32] = { 0L };

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

static const unsigned long 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). */

static const unsigned char 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 };

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

static const unsigned char 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 };

/* Thanks to James Gillogly & Phil Karn! */
void deskey(unsigned char *key, int edf)
{
	register int i, j, l, m, n;
	unsigned char pc1m[56], pcr[56];
	unsigned long 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);
	return;
	}

static void cookey(register unsigned long *raw1)
{
	register unsigned long *cook, *raw0;
	unsigned long dough[32];
	register int i;

	cook = dough;
	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);
		}
	usekey(dough);
	return;
	}

void cpkey(register unsigned long *into)
{
	register unsigned long *from, *endp;

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

void usekey(register unsigned long *from)
{
	register unsigned long *to, *endp;

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

void des(unsigned char *inblock, unsigned char *outblock)
{
	unsigned long work[2];

	scrunch(inblock, work);
	desfunc(work, KnL);
	unscrun(work, outblock);
	return;
	}

static void scrunch(register unsigned char *outof, register unsigned long *into)
{
	*into	 = (*outof++ & 0xffL) << 24;
	*into	|= (*outof++ & 0xffL) << 16;
	*into	|= (*outof++ & 0xffL) << 8;
	*into++ |= (*outof++ & 0xffL);
	*into	 = (*outof++ & 0xffL) << 24;
	*into	|= (*outof++ & 0xffL) << 16;
	*into	|= (*outof++ & 0xffL) << 8;
	*into	|= (*outof   & 0xffL);
	return;
	}

static void unscrun(register unsigned long *outof, register unsigned char *into)
{
	*into++ = (unsigned char)((*outof >> 24) & 0xffL);
	*into++ = (unsigned char)((*outof >> 16) & 0xffL);
	*into++ = (unsigned char)((*outof >>  8) & 0xffL);
	*into++ = (unsigned char)(*outof++	 & 0xffL);
	*into++ = (unsigned char)((*outof >> 24) & 0xffL);
	*into++ = (unsigned char)((*outof >> 16) & 0xffL);
	*into++ = (unsigned char)((*outof >>  8) & 0xffL);
	*into	=  (unsigned char)(*outof	 & 0xffL);
	return;
	}

static const unsigned long 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 };

static const unsigned long 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 };

static const unsigned long 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 };

static const unsigned long 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 };

static const unsigned long 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 };

static const unsigned long 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 };

static const unsigned long 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 };

static const unsigned long 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 };

static void desfunc(register unsigned long *block, register unsigned long *keys)
{
	register unsigned long fval, work, right, leftt;
	register 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[ 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;
	}

/* 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.0a rwo 9208.07 18:44 Graven Imagery
 **********************************************************************/
Commit	Line	Data
	1	/*
	2	* This is D3DES (V5.09) by Richard Outerbridge with the double and
	3	* triple-length support removed for use in VNC. Also the bytebit[] array
	4	* has been reversed so that the most significant bit in each byte of the
	5	* key is ignored, not the least significant.
	6	*
	7	* These changes are:
	8	* Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved.
	9	*
	10	* This software is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	13	*/
	14
	15	/* D3DES (V5.09) -
	16	*
	17	* A portable, public domain, version of the Data Encryption Standard.
	18	*
	19	* Written with Symantec's THINK (Lightspeed) C by Richard Outerbridge.
	20	* Thanks to: Dan Hoey for his excellent Initial and Inverse permutation
	21	* code; Jim Gillogly & Phil Karn for the DES key schedule code; Dennis
	22	* Ferguson, Eric Young and Dana How for comparing notes; and Ray Lau,
	23	* for humouring me on.
	24	*
	25	* Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge.
	26	* (GEnie : OUTER; CIS : [71755,204]) Graven Imagery, 1992.
	27	*/
	28
	29	#include "d3des.h"
	30
	31	static void scrunch(unsigned char , unsigned long );
	32	static void unscrun(unsigned long , unsigned char );
	33	static void desfunc(unsigned long , unsigned long );
	34	static void cookey(unsigned long *);
	35
	36	static unsigned long KnL[32] = { 0L };
	37
	38	static const unsigned short bytebit[8] = {
	39	01, 02, 04, 010, 020, 040, 0100, 0200 };
	40
	41	static const unsigned long bigbyte[24] = {
	42	0x800000L, 0x400000L, 0x200000L, 0x100000L,
	43	0x80000L, 0x40000L, 0x20000L, 0x10000L,
	44	0x8000L, 0x4000L, 0x2000L, 0x1000L,
	45	0x800L, 0x400L, 0x200L, 0x100L,
	46	0x80L, 0x40L, 0x20L, 0x10L,
	47	0x8L, 0x4L, 0x2L, 0x1L };
	48
	49	/* Use the key schedule specified in the Standard (ANSI X3.92-1981). */
	50
	51	static const unsigned char pc1[56] = {
	52	56, 48, 40, 32, 24, 16, 8, 0, 57, 49, 41, 33, 25, 17,
	53	9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35,
	54	62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21,
	55	13, 5, 60, 52, 44, 36, 28, 20, 12, 4, 27, 19, 11, 3 };
	56
	57	static const unsigned char totrot[16] = {
	58	1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28 };
	59
	60	static const unsigned char pc2[48] = {
	61	13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9,
	62	22, 18, 11, 3, 25, 7, 15, 6, 26, 19, 12, 1,
	63	40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,
	64	43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31 };
	65
	66	/* Thanks to James Gillogly & Phil Karn! */
	67	void deskey(unsigned char *key, int edf)
	68	{
	69	register int i, j, l, m, n;
	70	unsigned char pc1m[56], pcr[56];
	71	unsigned long kn[32];
	72
	73	for ( j = 0; j < 56; j++ ) {
	74	l = pc1[j];
	75	m = l & 07;
	76	pc1m[j] = (key[l >> 3] & bytebit[m]) ? 1 : 0;
	77	}
	78	for( i = 0; i < 16; i++ ) {
	79	if( edf == DE1 ) m = (15 - i) << 1;
	80	else m = i << 1;
	81	n = m + 1;
	82	kn[m] = kn[n] = 0L;
	83	for( j = 0; j < 28; j++ ) {
	84	l = j + totrot[i];
	85	if( l < 28 ) pcr[j] = pc1m[l];
	86	else pcr[j] = pc1m[l - 28];
	87	}
	88	for( j = 28; j < 56; j++ ) {
	89	l = j + totrot[i];
	90	if( l < 56 ) pcr[j] = pc1m[l];
	91	else pcr[j] = pc1m[l - 28];
	92	}
	93	for( j = 0; j < 24; j++ ) {
	94	if( pcr[pc2[j]] ) kn[m] \|= bigbyte[j];
	95	if( pcr[pc2[j+24]] ) kn[n] \|= bigbyte[j];
	96	}
	97	}
	98	cookey(kn);
	99	return;
	100	}
	101
	102	static void cookey(register unsigned long *raw1)
	103	{
	104	register unsigned long cook, raw0;
	105	unsigned long dough[32];
	106	register int i;
	107
	108	cook = dough;
	109	for( i = 0; i < 16; i++, raw1++ ) {
	110	raw0 = raw1++;
	111	cook = (raw0 & 0x00fc0000L) << 6;
	112	cook \|= (raw0 & 0x00000fc0L) << 10;
	113	cook \|= (raw1 & 0x00fc0000L) >> 10;
	114	cook++ \|= (raw1 & 0x00000fc0L) >> 6;
	115	cook = (raw0 & 0x0003f000L) << 12;
	116	cook \|= (raw0 & 0x0000003fL) << 16;
	117	cook \|= (raw1 & 0x0003f000L) >> 4;
	118	cook++ \|= (raw1 & 0x0000003fL);
	119	}
	120	usekey(dough);
	121	return;
	122	}
	123
	124	void cpkey(register unsigned long *into)
	125	{
	126	register unsigned long from, endp;
	127
	128	from = KnL, endp = &KnL[32];
	129	while( from < endp ) into++ = from++;
	130	return;
	131	}
	132
	133	void usekey(register unsigned long *from)
	134	{
	135	register unsigned long to, endp;
	136
	137	to = KnL, endp = &KnL[32];
	138	while( to < endp ) to++ = from++;
	139	return;
	140	}
	141
	142	void des(unsigned char inblock, unsigned char outblock)
	143	{
	144	unsigned long work[2];
	145
	146	scrunch(inblock, work);
	147	desfunc(work, KnL);
	148	unscrun(work, outblock);
	149	return;
	150	}
	151
	152	static void scrunch(register unsigned char outof, register unsigned long into)
	153	{
	154	into = (outof++ & 0xffL) << 24;
	155	into \|= (outof++ & 0xffL) << 16;
	156	into \|= (outof++ & 0xffL) << 8;
	157	into++ \|= (outof++ & 0xffL);
	158	into = (outof++ & 0xffL) << 24;
	159	into \|= (outof++ & 0xffL) << 16;
	160	into \|= (outof++ & 0xffL) << 8;
	161	into \|= (outof & 0xffL);
	162	return;
	163	}
	164
	165	static void unscrun(register unsigned long outof, register unsigned char into)
	166	{
	167	into++ = (unsigned char)((outof >> 24) & 0xffL);
	168	into++ = (unsigned char)((outof >> 16) & 0xffL);
	169	into++ = (unsigned char)((outof >> 8) & 0xffL);
	170	into++ = (unsigned char)(outof++ & 0xffL);
	171	into++ = (unsigned char)((outof >> 24) & 0xffL);
	172	into++ = (unsigned char)((outof >> 16) & 0xffL);
	173	into++ = (unsigned char)((outof >> 8) & 0xffL);
	174	into = (unsigned char)(outof & 0xffL);
	175	return;
	176	}
	177
	178	static const unsigned long SP1[64] = {
	179	0x01010400L, 0x00000000L, 0x00010000L, 0x01010404L,
	180	0x01010004L, 0x00010404L, 0x00000004L, 0x00010000L,
	181	0x00000400L, 0x01010400L, 0x01010404L, 0x00000400L,
	182	0x01000404L, 0x01010004L, 0x01000000L, 0x00000004L,
	183	0x00000404L, 0x01000400L, 0x01000400L, 0x00010400L,
	184	0x00010400L, 0x01010000L, 0x01010000L, 0x01000404L,
	185	0x00010004L, 0x01000004L, 0x01000004L, 0x00010004L,
	186	0x00000000L, 0x00000404L, 0x00010404L, 0x01000000L,
	187	0x00010000L, 0x01010404L, 0x00000004L, 0x01010000L,
	188	0x01010400L, 0x01000000L, 0x01000000L, 0x00000400L,
	189	0x01010004L, 0x00010000L, 0x00010400L, 0x01000004L,
	190	0x00000400L, 0x00000004L, 0x01000404L, 0x00010404L,
	191	0x01010404L, 0x00010004L, 0x01010000L, 0x01000404L,
	192	0x01000004L, 0x00000404L, 0x00010404L, 0x01010400L,
	193	0x00000404L, 0x01000400L, 0x01000400L, 0x00000000L,
	194	0x00010004L, 0x00010400L, 0x00000000L, 0x01010004L };
	195
	196	static const unsigned long SP2[64] = {
	197	0x80108020L, 0x80008000L, 0x00008000L, 0x00108020L,
	198	0x00100000L, 0x00000020L, 0x80100020L, 0x80008020L,
	199	0x80000020L, 0x80108020L, 0x80108000L, 0x80000000L,
	200	0x80008000L, 0x00100000L, 0x00000020L, 0x80100020L,
	201	0x00108000L, 0x00100020L, 0x80008020L, 0x00000000L,
	202	0x80000000L, 0x00008000L, 0x00108020L, 0x80100000L,
	203	0x00100020L, 0x80000020L, 0x00000000L, 0x00108000L,
	204	0x00008020L, 0x80108000L, 0x80100000L, 0x00008020L,
	205	0x00000000L, 0x00108020L, 0x80100020L, 0x00100000L,
	206	0x80008020L, 0x80100000L, 0x80108000L, 0x00008000L,
	207	0x80100000L, 0x80008000L, 0x00000020L, 0x80108020L,
	208	0x00108020L, 0x00000020L, 0x00008000L, 0x80000000L,
	209	0x00008020L, 0x80108000L, 0x00100000L, 0x80000020L,
	210	0x00100020L, 0x80008020L, 0x80000020L, 0x00100020L,
	211	0x00108000L, 0x00000000L, 0x80008000L, 0x00008020L,
	212	0x80000000L, 0x80100020L, 0x80108020L, 0x00108000L };
	213
	214	static const unsigned long SP3[64] = {
	215	0x00000208L, 0x08020200L, 0x00000000L, 0x08020008L,
	216	0x08000200L, 0x00000000L, 0x00020208L, 0x08000200L,
	217	0x00020008L, 0x08000008L, 0x08000008L, 0x00020000L,
	218	0x08020208L, 0x00020008L, 0x08020000L, 0x00000208L,
	219	0x08000000L, 0x00000008L, 0x08020200L, 0x00000200L,
	220	0x00020200L, 0x08020000L, 0x08020008L, 0x00020208L,
	221	0x08000208L, 0x00020200L, 0x00020000L, 0x08000208L,
	222	0x00000008L, 0x08020208L, 0x00000200L, 0x08000000L,
	223	0x08020200L, 0x08000000L, 0x00020008L, 0x00000208L,
	224	0x00020000L, 0x08020200L, 0x08000200L, 0x00000000L,
	225	0x00000200L, 0x00020008L, 0x08020208L, 0x08000200L,
	226	0x08000008L, 0x00000200L, 0x00000000L, 0x08020008L,
	227	0x08000208L, 0x00020000L, 0x08000000L, 0x08020208L,
	228	0x00000008L, 0x00020208L, 0x00020200L, 0x08000008L,
	229	0x08020000L, 0x08000208L, 0x00000208L, 0x08020000L,
	230	0x00020208L, 0x00000008L, 0x08020008L, 0x00020200L };
	231
	232	static const unsigned long SP4[64] = {
	233	0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,
	234	0x00802080L, 0x00800081L, 0x00800001L, 0x00002001L,
	235	0x00000000L, 0x00802000L, 0x00802000L, 0x00802081L,
	236	0x00000081L, 0x00000000L, 0x00800080L, 0x00800001L,
	237	0x00000001L, 0x00002000L, 0x00800000L, 0x00802001L,
	238	0x00000080L, 0x00800000L, 0x00002001L, 0x00002080L,
	239	0x00800081L, 0x00000001L, 0x00002080L, 0x00800080L,
	240	0x00002000L, 0x00802080L, 0x00802081L, 0x00000081L,
	241	0x00800080L, 0x00800001L, 0x00802000L, 0x00802081L,
	242	0x00000081L, 0x00000000L, 0x00000000L, 0x00802000L,
	243	0x00002080L, 0x00800080L, 0x00800081L, 0x00000001L,
	244	0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,
	245	0x00802081L, 0x00000081L, 0x00000001L, 0x00002000L,
	246	0x00800001L, 0x00002001L, 0x00802080L, 0x00800081L,
	247	0x00002001L, 0x00002080L, 0x00800000L, 0x00802001L,
	248	0x00000080L, 0x00800000L, 0x00002000L, 0x00802080L };
	249
	250	static const unsigned long SP5[64] = {
	251	0x00000100L, 0x02080100L, 0x02080000L, 0x42000100L,
	252	0x00080000L, 0x00000100L, 0x40000000L, 0x02080000L,
	253	0x40080100L, 0x00080000L, 0x02000100L, 0x40080100L,
	254	0x42000100L, 0x42080000L, 0x00080100L, 0x40000000L,
	255	0x02000000L, 0x40080000L, 0x40080000L, 0x00000000L,
	256	0x40000100L, 0x42080100L, 0x42080100L, 0x02000100L,
	257	0x42080000L, 0x40000100L, 0x00000000L, 0x42000000L,
	258	0x02080100L, 0x02000000L, 0x42000000L, 0x00080100L,
	259	0x00080000L, 0x42000100L, 0x00000100L, 0x02000000L,
	260	0x40000000L, 0x02080000L, 0x42000100L, 0x40080100L,
	261	0x02000100L, 0x40000000L, 0x42080000L, 0x02080100L,
	262	0x40080100L, 0x00000100L, 0x02000000L, 0x42080000L,
	263	0x42080100L, 0x00080100L, 0x42000000L, 0x42080100L,
	264	0x02080000L, 0x00000000L, 0x40080000L, 0x42000000L,
	265	0x00080100L, 0x02000100L, 0x40000100L, 0x00080000L,
	266	0x00000000L, 0x40080000L, 0x02080100L, 0x40000100L };
	267
	268	static const unsigned long SP6[64] = {
	269	0x20000010L, 0x20400000L, 0x00004000L, 0x20404010L,
	270	0x20400000L, 0x00000010L, 0x20404010L, 0x00400000L,
	271	0x20004000L, 0x00404010L, 0x00400000L, 0x20000010L,
	272	0x00400010L, 0x20004000L, 0x20000000L, 0x00004010L,
	273	0x00000000L, 0x00400010L, 0x20004010L, 0x00004000L,
	274	0x00404000L, 0x20004010L, 0x00000010L, 0x20400010L,
	275	0x20400010L, 0x00000000L, 0x00404010L, 0x20404000L,
	276	0x00004010L, 0x00404000L, 0x20404000L, 0x20000000L,
	277	0x20004000L, 0x00000010L, 0x20400010L, 0x00404000L,
	278	0x20404010L, 0x00400000L, 0x00004010L, 0x20000010L,
	279	0x00400000L, 0x20004000L, 0x20000000L, 0x00004010L,
	280	0x20000010L, 0x20404010L, 0x00404000L, 0x20400000L,
	281	0x00404010L, 0x20404000L, 0x00000000L, 0x20400010L,
	282	0x00000010L, 0x00004000L, 0x20400000L, 0x00404010L,
	283	0x00004000L, 0x00400010L, 0x20004010L, 0x00000000L,
	284	0x20404000L, 0x20000000L, 0x00400010L, 0x20004010L };
	285
	286	static const unsigned long SP7[64] = {
	287	0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L,
	288	0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L,
	289	0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L,
	290	0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L,
	291	0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L,
	292	0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L,
	293	0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L,
	294	0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L,
	295	0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L,
	296	0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L,
	297	0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L,
	298	0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L,
	299	0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L,
	300	0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L,
	301	0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L,
	302	0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L };
	303
	304	static const unsigned long SP8[64] = {
	305	0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L,
	306	0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L,
	307	0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L,
	308	0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L,
	309	0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L,
	310	0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L,
	311	0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L,
	312	0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L,
	313	0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L,
	314	0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L,
	315	0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L,
	316	0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L,
	317	0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L,
	318	0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L,
	319	0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L,
	320	0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L };
	321
	322	static void desfunc(register unsigned long block, register unsigned long keys)
	323	{
	324	register unsigned long fval, work, right, leftt;
	325	register int round;
	326
	327	leftt = block[0];
	328	right = block[1];
	329	work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;
	330	right ^= work;
	331	leftt ^= (work << 4);
	332	work = ((leftt >> 16) ^ right) & 0x0000ffffL;
	333	right ^= work;
	334	leftt ^= (work << 16);
	335	work = ((right >> 2) ^ leftt) & 0x33333333L;
	336	leftt ^= work;
	337	right ^= (work << 2);
	338	work = ((right >> 8) ^ leftt) & 0x00ff00ffL;
	339	leftt ^= work;
	340	right ^= (work << 8);
	341	right = ((right << 1) \| ((right >> 31) & 1L)) & 0xffffffffL;
	342	work = (leftt ^ right) & 0xaaaaaaaaL;
	343	leftt ^= work;
	344	right ^= work;
	345	leftt = ((leftt << 1) \| ((leftt >> 31) & 1L)) & 0xffffffffL;
	346
	347	for( round = 0; round < 8; round++ ) {
	348	work = (right << 28) \| (right >> 4);
	349	work ^= *keys++;
	350	fval = SP7[ work & 0x3fL];
	351	fval \|= SP5[(work >> 8) & 0x3fL];
	352	fval \|= SP3[(work >> 16) & 0x3fL];
	353	fval \|= SP1[(work >> 24) & 0x3fL];
	354	work = right ^ *keys++;
	355	fval \|= SP8[ work & 0x3fL];
	356	fval \|= SP6[(work >> 8) & 0x3fL];
	357	fval \|= SP4[(work >> 16) & 0x3fL];
	358	fval \|= SP2[(work >> 24) & 0x3fL];
	359	leftt ^= fval;
	360	work = (leftt << 28) \| (leftt >> 4);
	361	work ^= *keys++;
	362	fval = SP7[ work & 0x3fL];
	363	fval \|= SP5[(work >> 8) & 0x3fL];
	364	fval \|= SP3[(work >> 16) & 0x3fL];
	365	fval \|= SP1[(work >> 24) & 0x3fL];
	366	work = leftt ^ *keys++;
	367	fval \|= SP8[ work & 0x3fL];
	368	fval \|= SP6[(work >> 8) & 0x3fL];
	369	fval \|= SP4[(work >> 16) & 0x3fL];
	370	fval \|= SP2[(work >> 24) & 0x3fL];
	371	right ^= fval;
	372	}
	373
	374	right = (right << 31) \| (right >> 1);
	375	work = (leftt ^ right) & 0xaaaaaaaaL;
	376	leftt ^= work;
	377	right ^= work;
	378	leftt = (leftt << 31) \| (leftt >> 1);
	379	work = ((leftt >> 8) ^ right) & 0x00ff00ffL;
	380	right ^= work;
	381	leftt ^= (work << 8);
	382	work = ((leftt >> 2) ^ right) & 0x33333333L;
	383	right ^= work;
	384	leftt ^= (work << 2);
	385	work = ((right >> 16) ^ leftt) & 0x0000ffffL;
	386	leftt ^= work;
	387	right ^= (work << 16);
	388	work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL;
	389	leftt ^= work;
	390	right ^= (work << 4);
	391	*block++ = right;
	392	*block = leftt;
	393	return;
	394	}
	395
	396	/* Validation sets:
	397	*
	398	* Single-length key, single-length plaintext -
	399	* Key : 0123 4567 89ab cdef
	400	* Plain : 0123 4567 89ab cde7
	401	* Cipher : c957 4425 6a5e d31d
	402	*
	403	* Double-length key, single-length plaintext -
	404	* Key : 0123 4567 89ab cdef fedc ba98 7654 3210
	405	* Plain : 0123 4567 89ab cde7
	406	* Cipher : 7f1d 0a77 826b 8aff
	407	*
	408	* Double-length key, double-length plaintext -
	409	* Key : 0123 4567 89ab cdef fedc ba98 7654 3210
	410	* Plain : 0123 4567 89ab cdef 0123 4567 89ab cdff
	411	* Cipher : 27a0 8440 406a df60 278f 47cf 42d6 15d7
	412	*
	413	* Triple-length key, single-length plaintext -
	414	* Key : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567
	415	* Plain : 0123 4567 89ab cde7
	416	* Cipher : de0b 7c06 ae5e 0ed5
	417	*
	418	* Triple-length key, double-length plaintext -
	419	* Key : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567
	420	* Plain : 0123 4567 89ab cdef 0123 4567 89ab cdff
	421	* Cipher : ad0d 1b30 ac17 cf07 0ed1 1c63 81e4 4de5
	422	*
	423	* d3des V5.0a rwo 9208.07 18:44 Graven Imagery
	424	**********************************************************************/