Thread: [wpdev-commits] wolfpack/twofish aes.h,1.5,1.6 debug.h,1.3,1.4 table.h,1.3,1.4 twofish2.c,1.3,1.4

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/wpdev/wolfpack/twofish
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv20217

Modified Files:
	aes.h debug.h table.h twofish2.c 
Log Message:
applied coding standard rules.

Index: table.h
===================================================================
RCS file: /cvsroot/wpdev/wolfpack/twofish/table.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** table.h	24 Jun 2003 18:30:45 -0000	1.3
--- table.h	12 Aug 2004 12:13:33 -0000	1.4
***************
*** 48,64 ****
  *
  * Min Hamming weight (one byte difference) =  8. Max=26.  Total =  1020.
! * Prob[8]:      7    23    42    20    52    95    88    94   121   128    91
! *             102    76    41    24     8     4     1     3     0     0     0
! * Runs[8]:      2     4     5     6     7     8     9    11
! * MSBs[8]:      1     4    15     8    18    38    40    43
  * HW= 8: 05040705 0A080E0A 14101C14 28203828 50407050 01499101 A080E0A0 
  * HW= 9: 04050707 080A0E0E 10141C1C 20283838 40507070 80A0E0E0 C6432020 07070504 
! *        0E0E0A08 1C1C1410 38382820 70705040 E0E0A080 202043C6 05070407 0A0E080E 
! *        141C101C 28382038 50704070 A0E080E0 4320C620 02924B02 089A4508 
  * Min Hamming weight (two byte difference) =  3. Max=28.  Total = 390150.
! * Prob[3]:      7    18    55   149   270   914  2185  5761 11363 20719 32079
! *           43492 51612 53851 52098 42015 31117 20854 11538  6223  2492  1033
  * MDS OK, ROR:   6+  7+  8+  9+ 10+ 11+ 12+ 13+ 14+ 15+ 16+
! *               17+ 18+ 19+ 20+ 21+ 22+ 23+ 24+ 25+ 26+
  */
  #define	MDS_GF_FDBK		0x169	/* primitive polynomial for GF(256)*/
--- 48,64 ----
  *
  * Min Hamming weight (one byte difference) =  8. Max=26.  Total =  1020.
! * Prob[8]:  	7    23    42    20    52    95    88    94   121   128    91
! *   		  102    76    41    24 	8     4 	1     3 	0     0 	0
! * Runs[8]:  	2     4 	5     6 	7     8 	9    11
! * MSBs[8]:  	1     4    15     8    18    38    40    43
  * HW= 8: 05040705 0A080E0A 14101C14 28203828 50407050 01499101 A080E0A0 
  * HW= 9: 04050707 080A0E0E 10141C1C 20283838 40507070 80A0E0E0 C6432020 07070504 
! *   	 0E0E0A08 1C1C1410 38382820 70705040 E0E0A080 202043C6 05070407 0A0E080E 
! *   	 141C101C 28382038 50704070 A0E080E0 4320C620 02924B02 089A4508 
  * Min Hamming weight (two byte difference) =  3. Max=28.  Total = 390150.
! * Prob[3]:  	7    18    55   149   270   914  2185  5761 11363 20719 32079
! *   		43492 51612 53851 52098 42015 31117 20854 11538  6223  2492  1033
  * MDS OK, ROR:   6+  7+  8+  9+ 10+ 11+ 12+ 13+ 14+ 15+ 16+
! *   			17+ 18+ 19+ 20+ 21+ 22+ 23+ 24+ 25+ 26+
  */
  #define	MDS_GF_FDBK		0x169	/* primitive polynomial for GF(256)*/
***************
*** 68,72 ****

  #define	Mx_1(x) ((DWORD)  (x))		/* force result to dword so << will work */
! #define	Mx_X(x) ((DWORD) ((x) ^            LFSR2(x)))	/* 5B */
  #define	Mx_Y(x) ((DWORD) ((x) ^ LFSR1(x) ^ LFSR2(x)))	/* EF */

--- 68,72 ----

  #define	Mx_1(x) ((DWORD)  (x))		/* force result to dword so << will work */
! #define	Mx_X(x) ((DWORD) ((x) ^ 		   LFSR2(x)))	/* 5B */
  #define	Mx_Y(x) ((DWORD) ((x) ^ LFSR1(x) ^ LFSR2(x)))	/* EF */

***************
*** 138,145 ****
  * log2(skDup[ 0.. 6])=   ---  2.37  0.44  3.94  8.36 13.04 17.99
  ***********************************************************************/
! CONST BYTE P8x8[2][256]=
! 	{
  /*  p0:   */
! /*  dpMax      = 10.  lpMax      = 64.  cycleCnt=   1  1  1  0.         */
  /* 817D6F320B59ECA4.ECB81235F4A6709D.BA5E6D90C8F32471.D7F4126E9B3085CA. */
  /* Karnaugh maps:
--- 138,145 ----
  * log2(skDup[ 0.. 6])=   ---  2.37  0.44  3.94  8.36 13.04 17.99
  ***********************************************************************/
! CONST BYTE P8x8[2][256] =
! {
  /*  p0:   */
! /*  dpMax      = 10.  lpMax 	 = 64.  cycleCnt=   1  1  1  0. 		*/
  /* 817D6F320B59ECA4.ECB81235F4A6709D.BA5E6D90C8F32471.D7F4126E9B3085CA. */
  /* Karnaugh maps:
***************
*** 149,188 ****
  *  0111 0100 0001 0110. 1000 1011 1110 1001. 0011 0011 1001 1101. 1101 0101 0000 1100. 
  */
! 	{
! 	0xA9, 0x67, 0xB3, 0xE8, 0x04, 0xFD, 0xA3, 0x76, 
! 	0x9A, 0x92, 0x80, 0x78, 0xE4, 0xDD, 0xD1, 0x38, 
! 	0x0D, 0xC6, 0x35, 0x98, 0x18, 0xF7, 0xEC, 0x6C, 
! 	0x43, 0x75, 0x37, 0x26, 0xFA, 0x13, 0x94, 0x48, 
! 	0xF2, 0xD0, 0x8B, 0x30, 0x84, 0x54, 0xDF, 0x23, 
! 	0x19, 0x5B, 0x3D, 0x59, 0xF3, 0xAE, 0xA2, 0x82, 
! 	0x63, 0x01, 0x83, 0x2E, 0xD9, 0x51, 0x9B, 0x7C, 
! 	0xA6, 0xEB, 0xA5, 0xBE, 0x16, 0x0C, 0xE3, 0x61, 
! 	0xC0, 0x8C, 0x3A, 0xF5, 0x73, 0x2C, 0x25, 0x0B, 
! 	0xBB, 0x4E, 0x89, 0x6B, 0x53, 0x6A, 0xB4, 0xF1, 
! 	0xE1, 0xE6, 0xBD, 0x45, 0xE2, 0xF4, 0xB6, 0x66, 
! 	0xCC, 0x95, 0x03, 0x56, 0xD4, 0x1C, 0x1E, 0xD7, 
! 	0xFB, 0xC3, 0x8E, 0xB5, 0xE9, 0xCF, 0xBF, 0xBA, 
! 	0xEA, 0x77, 0x39, 0xAF, 0x33, 0xC9, 0x62, 0x71, 
! 	0x81, 0x79, 0x09, 0xAD, 0x24, 0xCD, 0xF9, 0xD8, 
! 	0xE5, 0xC5, 0xB9, 0x4D, 0x44, 0x08, 0x86, 0xE7, 
! 	0xA1, 0x1D, 0xAA, 0xED, 0x06, 0x70, 0xB2, 0xD2, 
! 	0x41, 0x7B, 0xA0, 0x11, 0x31, 0xC2, 0x27, 0x90, 
! 	0x20, 0xF6, 0x60, 0xFF, 0x96, 0x5C, 0xB1, 0xAB, 
! 	0x9E, 0x9C, 0x52, 0x1B, 0x5F, 0x93, 0x0A, 0xEF, 
! 	0x91, 0x85, 0x49, 0xEE, 0x2D, 0x4F, 0x8F, 0x3B, 
! 	0x47, 0x87, 0x6D, 0x46, 0xD6, 0x3E, 0x69, 0x64, 
! 	0x2A, 0xCE, 0xCB, 0x2F, 0xFC, 0x97, 0x05, 0x7A, 
! 	0xAC, 0x7F, 0xD5, 0x1A, 0x4B, 0x0E, 0xA7, 0x5A, 
! 	0x28, 0x14, 0x3F, 0x29, 0x88, 0x3C, 0x4C, 0x02, 
! 	0xB8, 0xDA, 0xB0, 0x17, 0x55, 0x1F, 0x8A, 0x7D, 
! 	0x57, 0xC7, 0x8D, 0x74, 0xB7, 0xC4, 0x9F, 0x72, 
! 	0x7E, 0x15, 0x22, 0x12, 0x58, 0x07, 0x99, 0x34, 
! 	0x6E, 0x50, 0xDE, 0x68, 0x65, 0xBC, 0xDB, 0xF8, 
! 	0xC8, 0xA8, 0x2B, 0x40, 0xDC, 0xFE, 0x32, 0xA4, 
! 	0xCA, 0x10, 0x21, 0xF0, 0xD3, 0x5D, 0x0F, 0x00, 
! 	0x6F, 0x9D, 0x36, 0x42, 0x4A, 0x5E, 0xC1, 0xE0
! 	},
  /*  p1:   */
! /*  dpMax      = 10.  lpMax      = 64.  cycleCnt=   2  0  0  1.         */
  /* 28BDF76E31940AC5.1E2B4C376DA5F908.4C75169A0ED82B3F.B951C3DE647F208A. */
  /* Karnaugh maps:
--- 149,188 ----
  *  0111 0100 0001 0110. 1000 1011 1110 1001. 0011 0011 1001 1101. 1101 0101 0000 1100. 
  */
! {
! 0xA9, 0x67, 0xB3, 0xE8, 0x04, 0xFD, 0xA3, 0x76, 
! 0x9A, 0x92, 0x80, 0x78, 0xE4, 0xDD, 0xD1, 0x38, 
! 0x0D, 0xC6, 0x35, 0x98, 0x18, 0xF7, 0xEC, 0x6C, 
! 0x43, 0x75, 0x37, 0x26, 0xFA, 0x13, 0x94, 0x48, 
! 0xF2, 0xD0, 0x8B, 0x30, 0x84, 0x54, 0xDF, 0x23, 
! 0x19, 0x5B, 0x3D, 0x59, 0xF3, 0xAE, 0xA2, 0x82, 
! 0x63, 0x01, 0x83, 0x2E, 0xD9, 0x51, 0x9B, 0x7C, 
! 0xA6, 0xEB, 0xA5, 0xBE, 0x16, 0x0C, 0xE3, 0x61, 
! 0xC0, 0x8C, 0x3A, 0xF5, 0x73, 0x2C, 0x25, 0x0B, 
! 0xBB, 0x4E, 0x89, 0x6B, 0x53, 0x6A, 0xB4, 0xF1, 
! 0xE1, 0xE6, 0xBD, 0x45, 0xE2, 0xF4, 0xB6, 0x66, 
! 0xCC, 0x95, 0x03, 0x56, 0xD4, 0x1C, 0x1E, 0xD7, 
! 0xFB, 0xC3, 0x8E, 0xB5, 0xE9, 0xCF, 0xBF, 0xBA, 
! 0xEA, 0x77, 0x39, 0xAF, 0x33, 0xC9, 0x62, 0x71, 
! 0x81, 0x79, 0x09, 0xAD, 0x24, 0xCD, 0xF9, 0xD8, 
! 0xE5, 0xC5, 0xB9, 0x4D, 0x44, 0x08, 0x86, 0xE7, 
! 0xA1, 0x1D, 0xAA, 0xED, 0x06, 0x70, 0xB2, 0xD2, 
! 0x41, 0x7B, 0xA0, 0x11, 0x31, 0xC2, 0x27, 0x90, 
! 0x20, 0xF6, 0x60, 0xFF, 0x96, 0x5C, 0xB1, 0xAB, 
! 0x9E, 0x9C, 0x52, 0x1B, 0x5F, 0x93, 0x0A, 0xEF, 
! 0x91, 0x85, 0x49, 0xEE, 0x2D, 0x4F, 0x8F, 0x3B, 
! 0x47, 0x87, 0x6D, 0x46, 0xD6, 0x3E, 0x69, 0x64, 
! 0x2A, 0xCE, 0xCB, 0x2F, 0xFC, 0x97, 0x05, 0x7A, 
! 0xAC, 0x7F, 0xD5, 0x1A, 0x4B, 0x0E, 0xA7, 0x5A, 
! 0x28, 0x14, 0x3F, 0x29, 0x88, 0x3C, 0x4C, 0x02, 
! 0xB8, 0xDA, 0xB0, 0x17, 0x55, 0x1F, 0x8A, 0x7D, 
! 0x57, 0xC7, 0x8D, 0x74, 0xB7, 0xC4, 0x9F, 0x72, 
! 0x7E, 0x15, 0x22, 0x12, 0x58, 0x07, 0x99, 0x34, 
! 0x6E, 0x50, 0xDE, 0x68, 0x65, 0xBC, 0xDB, 0xF8, 
! 0xC8, 0xA8, 0x2B, 0x40, 0xDC, 0xFE, 0x32, 0xA4, 
! 0xCA, 0x10, 0x21, 0xF0, 0xD3, 0x5D, 0x0F, 0x00, 
! 0x6F, 0x9D, 0x36, 0x42, 0x4A, 0x5E, 0xC1, 0xE0
! },
  /*  p1:   */
! /*  dpMax      = 10.  lpMax 	 = 64.  cycleCnt=   2  0  0  1. 		*/
  /* 28BDF76E31940AC5.1E2B4C376DA5F908.4C75169A0ED82B3F.B951C3DE647F208A. */
  /* Karnaugh maps:
***************
*** 192,228 ****
  *  1101 1000 0010 0001. 0110 1001 1110 0101. 0001 0100 0101 0111. 0011 1011 1111 0010. 
  */
! 	{
! 	0x75, 0xF3, 0xC6, 0xF4, 0xDB, 0x7B, 0xFB, 0xC8, 
! 	0x4A, 0xD3, 0xE6, 0x6B, 0x45, 0x7D, 0xE8, 0x4B, 
! 	0xD6, 0x32, 0xD8, 0xFD, 0x37, 0x71, 0xF1, 0xE1, 
! 	0x30, 0x0F, 0xF8, 0x1B, 0x87, 0xFA, 0x06, 0x3F, 
! 	0x5E, 0xBA, 0xAE, 0x5B, 0x8A, 0x00, 0xBC, 0x9D, 
! 	0x6D, 0xC1, 0xB1, 0x0E, 0x80, 0x5D, 0xD2, 0xD5, 
! 	0xA0, 0x84, 0x07, 0x14, 0xB5, 0x90, 0x2C, 0xA3, 
! 	0xB2, 0x73, 0x4C, 0x54, 0x92, 0x74, 0x36, 0x51, 
! 	0x38, 0xB0, 0xBD, 0x5A, 0xFC, 0x60, 0x62, 0x96, 
! 	0x6C, 0x42, 0xF7, 0x10, 0x7C, 0x28, 0x27, 0x8C, 
! 	0x13, 0x95, 0x9C, 0xC7, 0x24, 0x46, 0x3B, 0x70, 
! 	0xCA, 0xE3, 0x85, 0xCB, 0x11, 0xD0, 0x93, 0xB8, 
! 	0xA6, 0x83, 0x20, 0xFF, 0x9F, 0x77, 0xC3, 0xCC, 
! 	0x03, 0x6F, 0x08, 0xBF, 0x40, 0xE7, 0x2B, 0xE2, 
! 	0x79, 0x0C, 0xAA, 0x82, 0x41, 0x3A, 0xEA, 0xB9, 
! 	0xE4, 0x9A, 0xA4, 0x97, 0x7E, 0xDA, 0x7A, 0x17, 
! 	0x66, 0x94, 0xA1, 0x1D, 0x3D, 0xF0, 0xDE, 0xB3, 
! 	0x0B, 0x72, 0xA7, 0x1C, 0xEF, 0xD1, 0x53, 0x3E, 
! 	0x8F, 0x33, 0x26, 0x5F, 0xEC, 0x76, 0x2A, 0x49, 
! 	0x81, 0x88, 0xEE, 0x21, 0xC4, 0x1A, 0xEB, 0xD9, 
! 	0xC5, 0x39, 0x99, 0xCD, 0xAD, 0x31, 0x8B, 0x01, 
! 	0x18, 0x23, 0xDD, 0x1F, 0x4E, 0x2D, 0xF9, 0x48, 
! 	0x4F, 0xF2, 0x65, 0x8E, 0x78, 0x5C, 0x58, 0x19, 
! 	0x8D, 0xE5, 0x98, 0x57, 0x67, 0x7F, 0x05, 0x64, 
! 	0xAF, 0x63, 0xB6, 0xFE, 0xF5, 0xB7, 0x3C, 0xA5, 
! 	0xCE, 0xE9, 0x68, 0x44, 0xE0, 0x4D, 0x43, 0x69, 
! 	0x29, 0x2E, 0xAC, 0x15, 0x59, 0xA8, 0x0A, 0x9E, 
! 	0x6E, 0x47, 0xDF, 0x34, 0x35, 0x6A, 0xCF, 0xDC, 
! 	0x22, 0xC9, 0xC0, 0x9B, 0x89, 0xD4, 0xED, 0xAB, 
! 	0x12, 0xA2, 0x0D, 0x52, 0xBB, 0x02, 0x2F, 0xA9, 
! 	0xD7, 0x61, 0x1E, 0xB4, 0x50, 0x04, 0xF6, 0xC2, 
! 	0x16, 0x25, 0x86, 0x56, 0x55, 0x09, 0xBE, 0x91
! 	}
! 	};
--- 192,228 ----
  *  1101 1000 0010 0001. 0110 1001 1110 0101. 0001 0100 0101 0111. 0011 1011 1111 0010. 
  */
! {
! 0x75, 0xF3, 0xC6, 0xF4, 0xDB, 0x7B, 0xFB, 0xC8, 
! 0x4A, 0xD3, 0xE6, 0x6B, 0x45, 0x7D, 0xE8, 0x4B, 
! 0xD6, 0x32, 0xD8, 0xFD, 0x37, 0x71, 0xF1, 0xE1, 
! 0x30, 0x0F, 0xF8, 0x1B, 0x87, 0xFA, 0x06, 0x3F, 
! 0x5E, 0xBA, 0xAE, 0x5B, 0x8A, 0x00, 0xBC, 0x9D, 
! 0x6D, 0xC1, 0xB1, 0x0E, 0x80, 0x5D, 0xD2, 0xD5, 
! 0xA0, 0x84, 0x07, 0x14, 0xB5, 0x90, 0x2C, 0xA3, 
! 0xB2, 0x73, 0x4C, 0x54, 0x92, 0x74, 0x36, 0x51, 
! 0x38, 0xB0, 0xBD, 0x5A, 0xFC, 0x60, 0x62, 0x96, 
! 0x6C, 0x42, 0xF7, 0x10, 0x7C, 0x28, 0x27, 0x8C, 
! 0x13, 0x95, 0x9C, 0xC7, 0x24, 0x46, 0x3B, 0x70, 
! 0xCA, 0xE3, 0x85, 0xCB, 0x11, 0xD0, 0x93, 0xB8, 
! 0xA6, 0x83, 0x20, 0xFF, 0x9F, 0x77, 0xC3, 0xCC, 
! 0x03, 0x6F, 0x08, 0xBF, 0x40, 0xE7, 0x2B, 0xE2, 
! 0x79, 0x0C, 0xAA, 0x82, 0x41, 0x3A, 0xEA, 0xB9, 
! 0xE4, 0x9A, 0xA4, 0x97, 0x7E, 0xDA, 0x7A, 0x17, 
! 0x66, 0x94, 0xA1, 0x1D, 0x3D, 0xF0, 0xDE, 0xB3, 
! 0x0B, 0x72, 0xA7, 0x1C, 0xEF, 0xD1, 0x53, 0x3E, 
! 0x8F, 0x33, 0x26, 0x5F, 0xEC, 0x76, 0x2A, 0x49, 
! 0x81, 0x88, 0xEE, 0x21, 0xC4, 0x1A, 0xEB, 0xD9, 
! 0xC5, 0x39, 0x99, 0xCD, 0xAD, 0x31, 0x8B, 0x01, 
! 0x18, 0x23, 0xDD, 0x1F, 0x4E, 0x2D, 0xF9, 0x48, 
! 0x4F, 0xF2, 0x65, 0x8E, 0x78, 0x5C, 0x58, 0x19, 
! 0x8D, 0xE5, 0x98, 0x57, 0x67, 0x7F, 0x05, 0x64, 
! 0xAF, 0x63, 0xB6, 0xFE, 0xF5, 0xB7, 0x3C, 0xA5, 
! 0xCE, 0xE9, 0x68, 0x44, 0xE0, 0x4D, 0x43, 0x69, 
! 0x29, 0x2E, 0xAC, 0x15, 0x59, 0xA8, 0x0A, 0x9E, 
! 0x6E, 0x47, 0xDF, 0x34, 0x35, 0x6A, 0xCF, 0xDC, 
! 0x22, 0xC9, 0xC0, 0x9B, 0x89, 0xD4, 0xED, 0xAB, 
! 0x12, 0xA2, 0x0D, 0x52, 0xBB, 0x02, 0x2F, 0xA9, 
! 0xD7, 0x61, 0x1E, 0xB4, 0x50, 0x04, 0xF6, 0xC2, 
! 0x16, 0x25, 0x86, 0x56, 0x55, 0x09, 0xBE, 0x91
! }
! };

Index: aes.h
===================================================================
RCS file: /cvsroot/wpdev/wolfpack/twofish/aes.h,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -d -r1.5 -r1.6
*** aes.h	30 Jun 2003 00:39:14 -0000	1.5
--- aes.h	12 Aug 2004 12:13:33 -0000	1.6
***************
*** 82,141 ****

  /* The structure for key information */
! typedef struct 
! 	{
  	BYTE direction;					/* Key used for encrypting or decrypting? */
  #if ALIGN32
  	BYTE dummyAlign[3];				/* keep 32-bit alignment */
  #endif
! 	int  keyLen;					/* Length of the key */
! 	char keyMaterial[MAX_KEY_SIZE+4];/* Raw key data in ASCII */

  	/* Twofish-specific parameters: */
  	DWORD keySig;					/* set to VALID_SIG by makeKey() */
! 	int	  numRounds;				/* number of rounds in cipher */
! 	DWORD key32[MAX_KEY_BITS/32];	/* actual key bits, in dwords */
! 	DWORD sboxKeys[MAX_KEY_BITS/64];/* key bits used for S-boxes */
  	DWORD subKeys[TOTAL_SUBKEYS];	/* round subkeys, input/output whitening bits */
  #if REENTRANT
  	fullSbox sBox8x32;				/* fully expanded S-box */
!   #if defined(COMPILE_KEY) && defined(USE_ASM)
  #undef	VALID_SIG
  #define	VALID_SIG	 0x504D4F43		/* 'COMP':  C is compiled with -DCOMPILE_KEY */
  	DWORD cSig1;					/* set after first "compile" (zero at "init") */
! 	void *encryptFuncPtr;			/* ptr to asm encrypt function */
! 	void *decryptFuncPtr;			/* ptr to asm decrypt function */
  	DWORD codeSize;					/* size of compiledCode */
  	DWORD cSig2;					/* set after first "compile" */
! 	BYTE  compiledCode[5000];		/* make room for the code itself */
!   #endif
  #endif
! 	} keyInstance;

  /* The structure for cipher information */
! typedef struct 
! 	{
! 	BYTE  mode;						/* MODE_ECB, MODE_CBC, or MODE_CFB1 */
  #if ALIGN32
  	BYTE dummyAlign[3];				/* keep 32-bit alignment */
  #endif
! 	BYTE  IV[MAX_IV_SIZE];			/* CFB1 iv bytes  (CBC uses iv32) */

  	/* Twofish-specific parameters: */
  	DWORD cipherSig;				/* set to VALID_SIG by cipherInit() */
! 	DWORD iv32[BLOCK_SIZE/32];		/* CBC IV bytes arranged as dwords */
! 	} cipherInstance;

  /* Function protoypes */
! int makeKey(keyInstance *key, BYTE direction, int keyLen, char *keyMaterial);

! int cipherInit(cipherInstance *cipher, BYTE mode, char *IV);

! int blockEncrypt(cipherInstance *cipher, keyInstance *key, BYTE *input,
! 				int inputLen, BYTE *outBuffer);

! int blockDecrypt(cipherInstance *cipher, keyInstance *key, BYTE *input,
! 				int inputLen, BYTE *outBuffer);

! int	reKey(keyInstance *key);	/* do key schedule using modified key.keyDwords */

  /* API to check table usage, for use in ECB_TBL KAT */
--- 82,139 ----

  /* The structure for key information */
! typedef struct
! {
  	BYTE direction;					/* Key used for encrypting or decrypting? */
  #if ALIGN32
  	BYTE dummyAlign[3];				/* keep 32-bit alignment */
  #endif
! 	int keyLen;					/* Length of the key */
! 	char keyMaterial[MAX_KEY_SIZE + 4];/* Raw key data in ASCII */

  	/* Twofish-specific parameters: */
  	DWORD keySig;					/* set to VALID_SIG by makeKey() */
! 	int numRounds;				/* number of rounds in cipher */
! 	DWORD key32[MAX_KEY_BITS / 32];	/* actual key bits, in dwords */
! 	DWORD sboxKeys[MAX_KEY_BITS / 64];/* key bits used for S-boxes */
  	DWORD subKeys[TOTAL_SUBKEYS];	/* round subkeys, input/output whitening bits */
  #if REENTRANT
  	fullSbox sBox8x32;				/* fully expanded S-box */
! #if defined(COMPILE_KEY) && defined(USE_ASM)
  #undef	VALID_SIG
  #define	VALID_SIG	 0x504D4F43		/* 'COMP':  C is compiled with -DCOMPILE_KEY */
  	DWORD cSig1;					/* set after first "compile" (zero at "init") */
! 	void* encryptFuncPtr;			/* ptr to asm encrypt function */
! 	void* decryptFuncPtr;			/* ptr to asm decrypt function */
  	DWORD codeSize;					/* size of compiledCode */
  	DWORD cSig2;					/* set after first "compile" */
! 	BYTE compiledCode[5000];		/* make room for the code itself */
  #endif
! #endif
! } keyInstance;

  /* The structure for cipher information */
! typedef struct
! {
! 	BYTE mode;						/* MODE_ECB, MODE_CBC, or MODE_CFB1 */
  #if ALIGN32
  	BYTE dummyAlign[3];				/* keep 32-bit alignment */
  #endif
! 	BYTE IV[MAX_IV_SIZE];			/* CFB1 iv bytes  (CBC uses iv32) */

  	/* Twofish-specific parameters: */
  	DWORD cipherSig;				/* set to VALID_SIG by cipherInit() */
! 	DWORD iv32[BLOCK_SIZE / 32];		/* CBC IV bytes arranged as dwords */
! } cipherInstance;

  /* Function protoypes */
! int makeKey( keyInstance* key, BYTE direction, int keyLen, char* keyMaterial );

! int cipherInit( cipherInstance* cipher, BYTE mode, char* IV );

! int blockEncrypt( cipherInstance* cipher, keyInstance* key, BYTE* input, int inputLen, BYTE* outBuffer );

! int blockDecrypt( cipherInstance* cipher, keyInstance* key, BYTE* input, int inputLen, BYTE* outBuffer );

! int reKey( keyInstance* key );	/* do key schedule using modified key.keyDwords */

  /* API to check table usage, for use in ECB_TBL KAT */
***************
*** 145,149 ****
  #define		TAB_QUERY			3
  #define		TAB_MIN_QUERY		50
! int TableOp(int op);

  #ifndef CONST // warning C4005: 'CONST' : macro redefinition \microsoft visual studio\vc98\include\windef.h(138) : see previous definition of 'CONST'
--- 143,147 ----
  #define		TAB_QUERY			3
  #define		TAB_MIN_QUERY		50
! int TableOp( int op );

  #ifndef CONST // warning C4005: 'CONST' : macro redefinition \microsoft visual studio\vc98\include\windef.h(138) : see previous definition of 'CONST'
***************
*** 200,269 ****

  #define MAX_BLK_CNT		4		/* max # blocks per call in TestTwofish */
! int TestTwofish(int mode,int keySize) /* keySize must be 128, 192, or 256 */
! 	{							/* return 0 iff test passes */
! 	keyInstance    ki;			/* key information, including tables */
  	cipherInstance ci;			/* keeps mode (ECB, CBC) and IV */
! 	BYTE  plainText[MAX_BLK_CNT*(BLOCK_SIZE/8)];
! 	BYTE cipherText[MAX_BLK_CNT*(BLOCK_SIZE/8)];
! 	BYTE decryptOut[MAX_BLK_CNT*(BLOCK_SIZE/8)];
! 	BYTE iv[BLOCK_SIZE/8];
! 	int  i,byteCnt;

! 	if (makeKey(&ki,DIR_ENCRYPT,keySize,NULL) != TRUE)
  		return 1;				/* 'dummy' setup for a 128-bit key */
! 	if (cipherInit(&ci,mode,NULL) != TRUE)
  		return 1;				/* 'dummy' setup for cipher */
- 	
- 	for (i=0;i<keySize/32;i++)	/* select key bits */
- 		ki.key32[i]=0x10003 * rand();
- 	reKey(&ki);					/* run the key schedule */

! 	if (mode != MODE_ECB)		/* set up random iv (if needed)*/
! 		{
! 		for (i=0;i<sizeof(iv);i++)
! 			iv[i]=(BYTE) rand();
! 		memcpy(ci.iv32,iv,sizeof(ci.iv32));	/* copy the IV to ci */
! 		}

  	/* select number of bytes to encrypt (multiple of block) */
  	/* e.g., byteCnt = 16, 32, 48, 64 */
! 	byteCnt = (BLOCK_SIZE/8) * (1 + (rand() % MAX_BLK_CNT));

- 	for (i=0;i<byteCnt;i++)		/* generate test data */
- 		plainText[i]=(BYTE) rand();
- 	
  	/* encrypt the bytes */
! 	if (blockEncrypt(&ci,&ki, plainText,byteCnt*8,cipherText) != byteCnt*8)
  		return 1;

  	/* decrypt the bytes */
! 	if (mode != MODE_ECB)		/* first re-init the IV (if needed) */
! 		memcpy(ci.iv32,iv,sizeof(ci.iv32));

! 	if (blockDecrypt(&ci,&ki,cipherText,byteCnt*8,decryptOut) != byteCnt*8)
  		return 1;				
! 	
  	/* make sure the decrypt output matches original plaintext */
! 	if (memcmp(plainText,decryptOut,byteCnt))
  		return 1;		

  	return 0;					/* tests passed! */
! 	}

! void main(void)
! 	{
! 	int testCnt,keySize;

! 	srand((unsigned) time(NULL));	/* randomize */

! 	for (keySize=128;keySize<=256;keySize+=64)
! 		for (testCnt=0;testCnt<10;testCnt++)
  			{
! 			if (TestTwofish(MODE_ECB,keySize))
! 				{ printf("ECB Failure at keySize=%d",keySize); return; }
! 			if (TestTwofish(MODE_CBC,keySize))
! 				{ printf("CBC Failure at keySize=%d",keySize); return; }
  			}
! 	printf("Tests passed");
! 	}
  #endif /* TEST_2FISH */
\ No newline at end of file
--- 198,272 ----

  #define MAX_BLK_CNT		4		/* max # blocks per call in TestTwofish */
! int TestTwofish( int mode, int keySize ) /* keySize must be 128, 192, or 256 */
! {
! 	/* return 0 iff test passes */
! 	keyInstance ki;			/* key information, including tables */
  	cipherInstance ci;			/* keeps mode (ECB, CBC) and IV */
! 	BYTE plainText[MAX_BLK_CNT*( BLOCK_SIZE / 8 )];
! 	BYTE cipherText[MAX_BLK_CNT*( BLOCK_SIZE / 8 )];
! 	BYTE decryptOut[MAX_BLK_CNT*( BLOCK_SIZE / 8 )];
! 	BYTE iv[BLOCK_SIZE / 8];
! 	int i, byteCnt;

! 	if ( makeKey( &ki, DIR_ENCRYPT, keySize, NULL ) != TRUE )
  		return 1;				/* 'dummy' setup for a 128-bit key */
! 	if ( cipherInit( &ci, mode, NULL ) != TRUE )
  		return 1;				/* 'dummy' setup for cipher */

! 	for ( i = 0; i < keySize / 32; i++ )	/* select key bits */
! 		ki.key32[i] = 0x10003 * rand();
! 	reKey( &ki );					/* run the key schedule */
! 
! 	if ( mode != MODE_ECB )		/* set up random iv (if needed)*/
! 	{
! 		for ( i = 0; i < sizeof( iv ); i++ )
! 			iv[i] = ( BYTE ) rand();
! 		memcpy( ci.iv32, iv, sizeof( ci.iv32 ) );	/* copy the IV to ci */
! 	}

  	/* select number of bytes to encrypt (multiple of block) */
  	/* e.g., byteCnt = 16, 32, 48, 64 */
! 	byteCnt = ( BLOCK_SIZE / 8 ) * ( 1 + ( rand() % MAX_BLK_CNT ) );
! 
! 	for ( i = 0; i < byteCnt; i++ )		/* generate test data */
! 		plainText[i] = ( BYTE ) rand();

  	/* encrypt the bytes */
! 	if ( blockEncrypt( &ci, &ki, plainText, byteCnt * 8, cipherText ) != byteCnt * 8 )
  		return 1;

  	/* decrypt the bytes */
! 	if ( mode != MODE_ECB )		/* first re-init the IV (if needed) */
! 		memcpy( ci.iv32, iv, sizeof( ci.iv32 ) );

! 	if ( blockDecrypt( &ci, &ki, cipherText, byteCnt * 8, decryptOut ) != byteCnt * 8 )
  		return 1;				
! 
  	/* make sure the decrypt output matches original plaintext */
! 	if ( memcmp( plainText, decryptOut, byteCnt ) )
  		return 1;		

  	return 0;					/* tests passed! */
! }

! void main( void )
! {
! 	int testCnt, keySize;

! 	srand( ( unsigned ) time( NULL ) );	/* randomize */

! 	for ( keySize = 128; keySize <= 256; keySize += 64 )
! 		for ( testCnt = 0; testCnt < 10; testCnt++ )
! 		{
! 			if ( TestTwofish( MODE_ECB, keySize ) )
  			{
! 				printf( "ECB Failure at keySize=%d", keySize ); return;
  			}
! 			if ( TestTwofish( MODE_CBC, keySize ) )
! 			{
! 				printf( "CBC Failure at keySize=%d", keySize ); return;
! 			}
! 		}
! 	printf( "Tests passed" );
! }
  #endif /* TEST_2FISH */
\ No newline at end of file

Index: debug.h
===================================================================
RCS file: /cvsroot/wpdev/wolfpack/twofish/debug.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** debug.h	24 Jun 2003 18:30:45 -0000	1.3
--- debug.h	12 Aug 2004 12:13:33 -0000	1.4
***************
*** 1,6 ****
  #ifdef DEBUG	/* keep these macros common so they are same for both versions */
! CONST int debugCompile	=	1;
! extern  int	debug;
! extern  void DebugIO(CONST char *s);	/* display the debug output */

  #define DebugDump(x,s,R,XOR,doRot,showT,needBswap)	\
--- 1,6 ----
  #ifdef DEBUG	/* keep these macros common so they are same for both versions */
! CONST int debugCompile = 1;
! extern  int debug;
! extern  void DebugIO( CONST char* s );	/* display the debug output */

  #define DebugDump(x,s,R,XOR,doRot,showT,needBswap)	\
***************
*** 8,76 ****
  #define	DebugDumpKey(key) { if (debug) _DumpKey(key); }
  #define	IV_ROUND	-100
! 	
! void _Dump(CONST void *p,CONST char *s,int R,int XOR,int doRot,int showT,int needBswap,
! 		   DWORD t0,DWORD t1)
! 	{
  	char line[512];	/* build output here */
! 	int  i,n;
  	DWORD q[4];

! 	if (R == IV_ROUND)
! 		sprintf(line,"%sIV:    ",s);
  	else
! 		sprintf(line,"%sR[%2d]: ",s,R);
! 	for (n=0;line[n];n++) ;
! 	
! 	for (i=0;i<4;i++)
! 		{
! 		q[i]=((CONST DWORD *)p)[i^(XOR)];
! 		if (needBswap) q[i]=Bswap(q[i]);
! 		}

! 	sprintf(line+n,"x= %08lX  %08lX  %08lX  %08lX.",
! 			ROR(q[0],doRot*(R  )/2),
! 			ROL(q[1],doRot*(R  )/2),
! 			ROR(q[2],doRot*(R+1)/2),
! 			ROL(q[3],doRot*(R+1)/2));
! 	for (;line[n];n++) ;

! 	if (showT)
! 		sprintf(line+n,"    t0=%08lX. t1=%08lX.",t0,t1);
! 	for (;line[n];n++) ;

! 	sprintf(line+n,"\n");
! 	DebugIO(line);
! 	}

! void _DumpKey(CONST keyInstance *key)
! 	{
! 	char	line[512];
! 	int		i;
! 	int		k64Cnt=(key->keyLen+63)/64;	/* round up to next multiple of 64 bits */
! 	int		subkeyCnt = ROUND_SUBKEYS + 2*key->numRounds;

! 	sprintf(line,";\n;makeKey:   Input key            -->  S-box key     [%s]\n",
! 		   (key->direction == DIR_ENCRYPT) ? "Encrypt" : "Decrypt");
! 	DebugIO(line);
! 	for (i=0;i<k64Cnt;i++)	/* display in RS format */
! 		{
! 		sprintf(line,";%12s %08lX %08lX  -->  %08lX\n","",
! 			   key->key32[2*i+1],key->key32[2*i],key->sboxKeys[k64Cnt-1-i]);
! 		DebugIO(line);
! 		}
! 	sprintf(line,";%11sSubkeys\n","");
! 	DebugIO(line);
! 	for (i=0;i<subkeyCnt/2;i++)
! 		{
! 		sprintf(line,";%12s %08lX %08lX%s\n","",key->subKeys[2*i],key->subKeys[2*i+1],
! 			  (2*i ==  INPUT_WHITEN) ? "   Input whiten" :
! 			  (2*i == OUTPUT_WHITEN) ? "  Output whiten" :
! 		      (2*i == ROUND_SUBKEYS) ? "  Round subkeys" : "");
! 		DebugIO(line);
! 		}
! 	DebugIO(";\n");
  	}
  #else
! CONST int debugCompile	=	0;
  #define DebugDump(x,s,R,XOR,doRot,showT,needBswap)
  #define	DebugDumpKey(key)
--- 8,70 ----
  #define	DebugDumpKey(key) { if (debug) _DumpKey(key); }
  #define	IV_ROUND	-100
! 
! void _Dump( CONST void* p, CONST char* s, int R, int XOR, int doRot, int showT, int needBswap, DWORD t0, DWORD t1 )
! {
  	char line[512];	/* build output here */
! 	int i, n;
  	DWORD q[4];

! 	if ( R == IV_ROUND )
! 		sprintf( line, "%sIV:    ", s );
  	else
! 		sprintf( line, "%sR[%2d]: ", s, R );
! 	for ( n = 0; line[n]; n++ )
! 		;

! 	for ( i = 0; i < 4; i++ )
! 	{
! 		q[i] = ( ( CONST DWORD * ) p )[i ^ ( XOR )];
! 		if ( needBswap )
! 			q[i] = Bswap( q[i] );
! 	}

! 	sprintf( line + n, "x= %08lX  %08lX  %08lX  %08lX.", ROR( q[0], doRot * ( R ) / 2 ), ROL( q[1], doRot * ( R ) / 2 ), ROR( q[2], doRot * ( R + 1 ) / 2 ), ROL( q[3], doRot * ( R + 1 ) / 2 ) );
! 	for ( ; line[n]; n++ )
! 		;

! 	if ( showT )
! 		sprintf( line + n, "    t0=%08lX. t1=%08lX.", t0, t1 );
! 	for ( ; line[n]; n++ )
! 		;

! 	sprintf( line + n, "\n" );
! 	DebugIO( line );
! }

! void _DumpKey( CONST keyInstance* key )
! {
! 	char line[512];
! 	int i;
! 	int k64Cnt = ( key->keyLen + 63 ) / 64;	/* round up to next multiple of 64 bits */
! 	int subkeyCnt = ROUND_SUBKEYS + 2 * key->numRounds;
! 
! 	sprintf( line, ";\n;makeKey:   Input key            -->  S-box key     [%s]\n", ( key->direction == DIR_ENCRYPT ) ? "Encrypt" : "Decrypt" );
! 	DebugIO( line );
! 	for ( i = 0; i < k64Cnt; i++ )	/* display in RS format */
! 	{
! 		sprintf( line, ";%12s %08lX %08lX  -->  %08lX\n", "", key->key32[2 * i + 1], key->key32[2 * i], key->sboxKeys[k64Cnt - 1 - i] );
! 		DebugIO( line );
  	}
+ 	sprintf( line, ";%11sSubkeys\n", "" );
+ 	DebugIO( line );
+ 	for ( i = 0; i < subkeyCnt / 2; i++ )
+ 	{
+ 		sprintf( line, ";%12s %08lX %08lX%s\n", "", key->subKeys[2 * i], key->subKeys[2 * i + 1], ( 2 * i == INPUT_WHITEN ) ? "   Input whiten" : ( 2 * i == OUTPUT_WHITEN ) ? "  Output whiten" : ( 2 * i == ROUND_SUBKEYS ) ? "  Round subkeys" : "" );
+ 		DebugIO( line );
+ 	}
+ 	DebugIO( ";\n" );
+ }
  #else
! CONST int debugCompile = 0;
  #define DebugDump(x,s,R,XOR,doRot,showT,needBswap)
  #define	DebugDumpKey(key)

Index: twofish2.c
===================================================================
RCS file: /cvsroot/wpdev/wolfpack/twofish/twofish2.c,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** twofish2.c	24 Jun 2003 18:30:45 -0000	1.3
--- twofish2.c	12 Aug 2004 12:13:33 -0000	1.4
***************
*** 36,49 ****

  #ifdef USE_ASM
! extern	int	useAsm;				/* ok to use ASM code? */

! typedef	int cdecl CipherProc
!    (cipherInstance *cipher, keyInstance *key,BYTE *input,int inputLen,BYTE *outBuffer);
! typedef int	cdecl KeySetupProc(keyInstance *key);

! extern CipherProc	*blockEncrypt_86;	/* ptr to ASM functions */
! extern CipherProc	*blockDecrypt_86;
[...1616 lines suppressed...]
  		}
! 	}
! 	if ( mode == MODE_CBC )	/* restore iv32 to cipher */
! 		BlockCopy( cipher->iv32, IV )

  	return inputLen;
! }

  #ifdef GetCodeSize
! DWORD TwofishCodeSize( void )
! {
! 	DWORD x = Here( 0 );
  #ifdef USE_ASM
! 	if ( useAsm & 3 )
  		return TwofishAsmCodeSize();
  #endif
  	return x - TwofishCodeStart();
! };
  #endif
\ No newline at end of file