0x00001000,0x10001000,0x00011000,0x10011000,0x00001004,0x10001004,0x00011004,0x10011004,0x20001000,0x30001000,0x20011000,0x30011000,0x20001004,0x30001004,0x20011004,0x30011004,0x00101000,0x10101000,0x00111000,0x10111000,0x00101004,0x10101004,0x00111004,0x10111004,0x20101000,0x30101000,0x20111000,0x30111000,0x20101004,0x30101004,0x20111004,0x30111004,/* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */0x00000000,0x08000000,0x00000008,0x08000008,0x00000400,0x08000400,0x00000408,0x08000408,0x00020000,0x08020000,0x00020008,0x08020008,0x00020400,0x08020400,0x00020408,0x08020408,0x00000001,0x08000001,0x00000009,0x08000009,0x00000401,0x08000401,0x00000409,0x08000409,0x00020001,0x08020001,0x00020009,0x08020009,0x00020401,0x08020401,0x00020409,0x08020409,0x02000000,0x0A000000,0x02000008,0x0A000008,0x02000400,0x0A000400,0x02000408,0x0A000408,0x02020000,0x0A020000,0x02020008,0x0A020008,0x02020400,0x0A020400,0x02020408,0x0A020408,0x02000001,0x0A000001,0x02000009,0x0A000009,0x02000401,0x0A000401,0x02000409,0x0A000409,0x02020001,0x0A020001,0x02020009,0x0A020009,0x02020401,0x0A020401,0x02020409,0x0A020409,/* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */0x00000000,0x00000100,0x00080000,0x00080100,0x01000000,0x01000100,0x01080000,0x01080100,0x00000010,0x00000110,0x00080010,0x00080110,0x01000010,0x01000110,0x01080010,0x01080110,0x00200000,0x00200100,0x00280000,0x00280100,0x01200000,0x01200100,0x01280000,0x01280100,0x00200010,0x00200110,0x00280010,0x00280110,0x01200010,0x01200110,0x01280010,0x01280110,0x00000200,0x00000300,0x00080200,0x00080300,0x01000200,0x01000300,0x01080200,0x01080300,0x00000210,0x00000310,0x00080210,0x00080310,0x01000210,0x01000310,0x01080210,0x01080310,0x00200200,0x00200300,0x00280200,0x00280300,0x01200200,0x01200300,0x01280200,0x01280300,0x00200210,0x00200310,0x00280210,0x00280310,0x01200210,0x01200310,0x01280210,0x01280310,/* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */0x00000000,0x04000000,0x00040000,0x04040000,0x00000002,0x04000002,0x00040002,0x04040002,0x00002000,0x04002000,0x00042000,0x04042000,0x00002002,0x04002002,0x00042002,0x04042002,0x00000020,0x04000020,0x00040020,0x04040020,0x00000022,0x04000022,0x00040022,0x04040022,0x00002020,0x04002020,0x00042020,0x04042020,0x00002022,0x04002022,0x00042022,0x04042022,0x00000800,0x04000800,0x00040800,0x04040800,0x00000802,0x04000802,0x00040802,0x04040802,0x00002800,0x04002800,0x00042800,0x04042800,0x00002802,0x04002802,0x00042802,0x04042802,0x00000820,0x04000820,0x00040820,0x04040820,0x00000822,0x04000822,0x00040822,0x04040822,0x00002820,0x04002820,0x00042820,0x04042820,0x00002822,0x04002822,0x00042822,0x04042822,};/* The changes to this macro may help or hinder, depending on the * compiler and the achitecture.  gcc2 always seems to do well :-). * Inspired by Dana How <how@isl.stanford.edu> * DO NOT use the alternative version on machines with 8 byte longs. */#ifdef ALT_ECB#define D_ENCRYPT(L,R,S) \	u=((R^s[S  ])<<2);	\	t= R^s[S+1]; \	t=((t>>2)+(t<<30)); \	L^= \	*(unsigned long *)(des_SP+0x0100+((t    )&0xfc))+ \	*(unsigned long *)(des_SP+0x0300+((t>> 8)&0xfc))+ \	*(unsigned long *)(des_SP+0x0500+((t>>16)&0xfc))+ \	*(unsigned long *)(des_SP+0x0700+((t>>24)&0xfc))+ \	*(unsigned long *)(des_SP+       ((u    )&0xfc))+ \	*(unsigned long *)(des_SP+0x0200+((u>> 8)&0xfc))+ \	*(unsigned long *)(des_SP+0x0400+((u>>16)&0xfc))+ \	*(unsigned long *)(des_SP+0x0600+((u>>24)&0xfc));#else /* original version */#define D_ENCRYPT(L,R,S)	\	u=(R^s[S  ]); \	t=R^s[S+1]; \	t=((t>>4)+(t<<28)); \	L^=	des_SPtrans[1][(t    )&0x3f]| \		des_SPtrans[3][(t>> 8)&0x3f]| \		des_SPtrans[5][(t>>16)&0x3f]| \		des_SPtrans[7][(t>>24)&0x3f]| \		des_SPtrans[0][(u    )&0x3f]| \		des_SPtrans[2][(u>> 8)&0x3f]| \		des_SPtrans[4][(u>>16)&0x3f]| \		des_SPtrans[6][(u>>24)&0x3f];#endif	/* IP and FP	 * The problem is more of a geometric problem that random bit fiddling.	 0  1  2  3  4  5  6  7      62 54 46 38 30 22 14  6	 8  9 10 11 12 13 14 15      60 52 44 36 28 20 12  4        16 17 18 19 20 21 22 23      58 50 42 34 26 18 10  2	24 25 26 27 28 29 30 31  to  56 48 40 32 24 16  8  0	32 33 34 35 36 37 38 39      63 55 47 39 31 23 15  7	40 41 42 43 44 45 46 47      61 53 45 37 29 21 13  5	48 49 50 51 52 53 54 55      59 51 43 35 27 19 11  3	56 57 58 59 60 61 62 63      57 49 41 33 25 17  9  1	The output has been subject to swaps of the form	0 1 -> 3 1 but the odd and even bits have been put into	2 3    2 0 	different words.  The main trick is to remember that	t=((l>>size)^r)&(mask);	r^=t;	l^=(t<<size);	can be used to swap and move bits between words.	So l =  0  1  2  3  r = 16 17 18 19	        4  5  6  7      20 21 22 23	        8  9 10 11      24 25 26 27	       12 13 14 15      28 29 30 31	becomes (for size == 2 and mask == 0x3333)	   t =   2^16  3^17 -- --   l =  0  1 16 17  r =  2  3 18 19		 6^20  7^21 -- --        4  5 20 21       6  7 22 23		10^24 11^25 -- --        8  9 24 25      10 11 24 25                14^28 15^29 -- --       12 13 28 29      14 15 28 29	Thanks for hints from Richard Outerbridge - he told me IP&FP	could be done in 15 xor, 10 shifts and 5 ands.	When I finally started to think of the problem in 2D	I first got ~42 operations without xors.  When I remembered	how to use xors :-) I got it to its final state.	*/#define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\	(b)^=(t),\	(a)^=((t)<<(n)))voiddes_crypt(des_cblock input, des_cblock output, des_ks ks, int encrypt){	unsigned long l,r,t,u;#ifdef ALT_ECB	unsigned char *des_SP=(unsigned char *)des_SPtrans;#endif	int i;	unsigned long * s;	l=input[0];	r=input[1];	/* do IP */	PERM_OP(r,l,t, 4,0x0f0f0f0f);	PERM_OP(l,r,t,16,0x0000ffff);	PERM_OP(r,l,t, 2,0x33333333);	PERM_OP(l,r,t, 8,0x00ff00ff);	PERM_OP(r,l,t, 1,0x55555555);	/* r and l are reversed - remember that :-) - fix	 * it in the next step */	/* Things have been modified so that the initial rotate is	 * done outside the loop.  This required the 	 * des_SPtrans values in sp.h to be rotated 1 bit to the right.	 * One perl script later and things have a 5% speed up on a sparc2.	 * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>	 * for pointing this out. */	t=(r<<1)|(r>>31);	r=(l<<1)|(l>>31); 	l=t;	/* clear the top bits on machines with 8byte longs */	l&=0xffffffff;	r&=0xffffffff;	s=(unsigned long *)ks;	/* I don't know if it is worth the effort of loop unrolling the	 * inner loop */	if (encrypt)	{		for (i=0; i<32; i+=4)		{			D_ENCRYPT(l,r,i+0); /*  1 */			D_ENCRYPT(r,l,i+2); /*  2 */		}	}	else	{		for (i=30; i>0; i-=4)		{			D_ENCRYPT(l,r,i-0); /* 16 */			D_ENCRYPT(r,l,i-2); /* 15 */		}	}	l=(l>>1)|(l<<31);	r=(r>>1)|(r<<31);	/* clear the top bits on machines with 8byte longs */	l&=0xffffffff;	r&=0xffffffff;	/* swap l and r	 * we will not do the swap so just remember they are	 * reversed for the rest of the subroutine	 * luckily FP fixes this problem :-) */	PERM_OP(r,l,t, 1,0x55555555);	PERM_OP(l,r,t, 8,0x00ff00ff);	PERM_OP(r,l,t, 2,0x33333333);	PERM_OP(l,r,t,16,0x0000ffff);	PERM_OP(r,l,t, 4,0x0f0f0f0f);	output[0]=l;	output[1]=r;}voiddes_expand_key(des_user_key userKey, des_ks ks){	unsigned long c,d,t,s; 	unsigned char * in;	unsigned long * k;	int i;	static unsigned char shifts2[16]={0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0};	k=(unsigned long *)ks;	in=(unsigned char *)userKey;	c2l(in,c);	c2l(in,d);/* do PC1 in 60 simple operations *//*	PERM_OP(d,c,t,4,0x0f0f0f0f);	HPERM_OP(c,t,-2, 0xcccc0000);	HPERM_OP(c,t,-1, 0xaaaa0000);	HPERM_OP(c,t, 8, 0x00ff0000);	HPERM_OP(c,t,-1, 0xaaaa0000);	HPERM_OP(d,t,-8, 0xff000000);	HPERM_OP(d,t, 8, 0x00ff0000);	HPERM_OP(d,t, 2, 0x33330000);	d=((d&0x00aa00aa)<<7)|((d&0x55005500)>>7)|(d&0xaa55aa55);	d=(d>>8)|((c&0xf0000000)>>4);	c&=0x0fffffff; */	/* I now do it in 47 simple operations :-)	 * Thanks to John Fletcher (john_fletcher@lccmail.ocf.llnl.gov)	 * for the inspiration. :-) */	PERM_OP (d,c,t,4,0x0f0f0f0f);	HPERM_OP(c,t,-2,0xcccc0000);	HPERM_OP(d,t,-2,0xcccc0000);	PERM_OP (d,c,t,1,0x55555555);	PERM_OP (c,d,t,8,0x00ff00ff);	PERM_OP (d,c,t,1,0x55555555);	d=	(((d&0x000000ff)<<16)| (d&0x0000ff00)     |		 ((d&0x00ff0000)>>16)|((c&0xf0000000)>>4));	c&=0x0fffffff;	for (i=0; i<ITERATIONS; i++)	{		if (shifts2[i])			{ c=((c>>2)|(c<<26)); d=((d>>2)|(d<<26)); }		else			{ c=((c>>1)|(c<<27)); d=((d>>1)|(d<<27)); }		c&=0x0fffffff;		d&=0x0fffffff;		/* could be a few less shifts but I am to lazy at this		 * point in time to investigate */		s=des_skb[0][ (c    )&0x3f                ]|			des_skb[1][((c>> 6)&0x03)|((c>> 7)&0x3c)]|			des_skb[2][((c>>13)&0x0f)|((c>>14)&0x30)]|			des_skb[3][((c>>20)&0x01)|((c>>21)&0x06) |								 ((c>>22)&0x38)];		t=des_skb[4][ (d    )&0x3f                ]|			des_skb[5][((d>> 7)&0x03)|((d>> 8)&0x3c)]|			des_skb[6][ (d>>15)&0x3f                ]|			des_skb[7][((d>>21)&0x0f)|((d>>22)&0x30)];		/* table contained 0213 4657 */		*(k++)=((t<<16)|(s&0x0000ffff))&0xffffffff;		s=     ((s>>16)|(t&0xffff0000));				s=(s<<4)|(s>>28);		*(k++)=s&0xffffffff;	}}