rijndael: refactor to reduce number of #ifdefs and branches
[libgcrypt.git] / cipher / twofish.c
1 /* Twofish for GPG
2  * Copyright (C) 1998, 2002, 2003 Free Software Foundation, Inc.
3  * Written by Matthew Skala <mskala@ansuz.sooke.bc.ca>, July 26, 1998
4  * 256-bit key length added March 20, 1999
5  * Some modifications to reduce the text size by Werner Koch, April, 1998
6  *
7  * This file is part of Libgcrypt.
8  *
9  * Libgcrypt is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU Lesser General Public License as
11  * published by the Free Software Foundation; either version 2.1 of
12  * the License, or (at your option) any later version.
13  *
14  * Libgcrypt is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
22  ********************************************************************
23  *
24  * This code is a "clean room" implementation, written from the paper
25  * _Twofish: A 128-Bit Block Cipher_ by Bruce Schneier, John Kelsey,
26  * Doug Whiting, David Wagner, Chris Hall, and Niels Ferguson, available
27  * through http://www.counterpane.com/twofish.html
28  *
29  * For background information on multiplication in finite fields, used for
30  * the matrix operations in the key schedule, see the book _Contemporary
31  * Abstract Algebra_ by Joseph A. Gallian, especially chapter 22 in the
32  * Third Edition.
33  *
34  * Only the 128- and 256-bit key sizes are supported.  This code is intended
35  * for GNU C on a 32-bit system, but it should work almost anywhere.  Loops
36  * are unrolled, precomputation tables are used, etc., for maximum speed at
37  * some cost in memory consumption. */
38
39 #include <config.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h> /* for memcmp() */
43
44 #include "types.h"  /* for byte and u32 typedefs */
45 #include "g10lib.h"
46 #include "cipher.h"
47 #include "bufhelp.h"
48 #include "cipher-selftest.h"
49
50
51 #define TWOFISH_BLOCKSIZE 16
52
53
54 /* USE_AMD64_ASM indicates whether to use AMD64 assembly code. */
55 #undef USE_AMD64_ASM
56 #if defined(__x86_64__) && defined(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS)
57 # define USE_AMD64_ASM 1
58 #endif
59
60 /* USE_ARM_ASM indicates whether to use ARM assembly code. */
61 #undef USE_ARM_ASM
62 #if defined(__ARMEL__)
63 # if defined(HAVE_COMPATIBLE_GCC_ARM_PLATFORM_AS)
64 #  define USE_ARM_ASM 1
65 # endif
66 #endif
67
68
69 /* Prototype for the self-test function. */
70 static const char *selftest(void);
71
72 /* Structure for an expanded Twofish key.  s contains the key-dependent
73  * S-boxes composed with the MDS matrix; w contains the eight "whitening"
74  * subkeys, K[0] through K[7].  k holds the remaining, "round" subkeys.  Note
75  * that k[i] corresponds to what the Twofish paper calls K[i+8]. */
76 typedef struct {
77    u32 s[4][256], w[8], k[32];
78 } TWOFISH_context;
79 \f
80 /* These two tables are the q0 and q1 permutations, exactly as described in
81  * the Twofish paper. */
82
83 static const byte q0[256] = {
84    0xA9, 0x67, 0xB3, 0xE8, 0x04, 0xFD, 0xA3, 0x76, 0x9A, 0x92, 0x80, 0x78,
85    0xE4, 0xDD, 0xD1, 0x38, 0x0D, 0xC6, 0x35, 0x98, 0x18, 0xF7, 0xEC, 0x6C,
86    0x43, 0x75, 0x37, 0x26, 0xFA, 0x13, 0x94, 0x48, 0xF2, 0xD0, 0x8B, 0x30,
87    0x84, 0x54, 0xDF, 0x23, 0x19, 0x5B, 0x3D, 0x59, 0xF3, 0xAE, 0xA2, 0x82,
88    0x63, 0x01, 0x83, 0x2E, 0xD9, 0x51, 0x9B, 0x7C, 0xA6, 0xEB, 0xA5, 0xBE,
89    0x16, 0x0C, 0xE3, 0x61, 0xC0, 0x8C, 0x3A, 0xF5, 0x73, 0x2C, 0x25, 0x0B,
90    0xBB, 0x4E, 0x89, 0x6B, 0x53, 0x6A, 0xB4, 0xF1, 0xE1, 0xE6, 0xBD, 0x45,
91    0xE2, 0xF4, 0xB6, 0x66, 0xCC, 0x95, 0x03, 0x56, 0xD4, 0x1C, 0x1E, 0xD7,
92    0xFB, 0xC3, 0x8E, 0xB5, 0xE9, 0xCF, 0xBF, 0xBA, 0xEA, 0x77, 0x39, 0xAF,
93    0x33, 0xC9, 0x62, 0x71, 0x81, 0x79, 0x09, 0xAD, 0x24, 0xCD, 0xF9, 0xD8,
94    0xE5, 0xC5, 0xB9, 0x4D, 0x44, 0x08, 0x86, 0xE7, 0xA1, 0x1D, 0xAA, 0xED,
95    0x06, 0x70, 0xB2, 0xD2, 0x41, 0x7B, 0xA0, 0x11, 0x31, 0xC2, 0x27, 0x90,
96    0x20, 0xF6, 0x60, 0xFF, 0x96, 0x5C, 0xB1, 0xAB, 0x9E, 0x9C, 0x52, 0x1B,
97    0x5F, 0x93, 0x0A, 0xEF, 0x91, 0x85, 0x49, 0xEE, 0x2D, 0x4F, 0x8F, 0x3B,
98    0x47, 0x87, 0x6D, 0x46, 0xD6, 0x3E, 0x69, 0x64, 0x2A, 0xCE, 0xCB, 0x2F,
99    0xFC, 0x97, 0x05, 0x7A, 0xAC, 0x7F, 0xD5, 0x1A, 0x4B, 0x0E, 0xA7, 0x5A,
100    0x28, 0x14, 0x3F, 0x29, 0x88, 0x3C, 0x4C, 0x02, 0xB8, 0xDA, 0xB0, 0x17,
101    0x55, 0x1F, 0x8A, 0x7D, 0x57, 0xC7, 0x8D, 0x74, 0xB7, 0xC4, 0x9F, 0x72,
102    0x7E, 0x15, 0x22, 0x12, 0x58, 0x07, 0x99, 0x34, 0x6E, 0x50, 0xDE, 0x68,
103    0x65, 0xBC, 0xDB, 0xF8, 0xC8, 0xA8, 0x2B, 0x40, 0xDC, 0xFE, 0x32, 0xA4,
104    0xCA, 0x10, 0x21, 0xF0, 0xD3, 0x5D, 0x0F, 0x00, 0x6F, 0x9D, 0x36, 0x42,
105    0x4A, 0x5E, 0xC1, 0xE0
106 };
107
108 static const byte q1[256] = {
109    0x75, 0xF3, 0xC6, 0xF4, 0xDB, 0x7B, 0xFB, 0xC8, 0x4A, 0xD3, 0xE6, 0x6B,
110    0x45, 0x7D, 0xE8, 0x4B, 0xD6, 0x32, 0xD8, 0xFD, 0x37, 0x71, 0xF1, 0xE1,
111    0x30, 0x0F, 0xF8, 0x1B, 0x87, 0xFA, 0x06, 0x3F, 0x5E, 0xBA, 0xAE, 0x5B,
112    0x8A, 0x00, 0xBC, 0x9D, 0x6D, 0xC1, 0xB1, 0x0E, 0x80, 0x5D, 0xD2, 0xD5,
113    0xA0, 0x84, 0x07, 0x14, 0xB5, 0x90, 0x2C, 0xA3, 0xB2, 0x73, 0x4C, 0x54,
114    0x92, 0x74, 0x36, 0x51, 0x38, 0xB0, 0xBD, 0x5A, 0xFC, 0x60, 0x62, 0x96,
115    0x6C, 0x42, 0xF7, 0x10, 0x7C, 0x28, 0x27, 0x8C, 0x13, 0x95, 0x9C, 0xC7,
116    0x24, 0x46, 0x3B, 0x70, 0xCA, 0xE3, 0x85, 0xCB, 0x11, 0xD0, 0x93, 0xB8,
117    0xA6, 0x83, 0x20, 0xFF, 0x9F, 0x77, 0xC3, 0xCC, 0x03, 0x6F, 0x08, 0xBF,
118    0x40, 0xE7, 0x2B, 0xE2, 0x79, 0x0C, 0xAA, 0x82, 0x41, 0x3A, 0xEA, 0xB9,
119    0xE4, 0x9A, 0xA4, 0x97, 0x7E, 0xDA, 0x7A, 0x17, 0x66, 0x94, 0xA1, 0x1D,
120    0x3D, 0xF0, 0xDE, 0xB3, 0x0B, 0x72, 0xA7, 0x1C, 0xEF, 0xD1, 0x53, 0x3E,
121    0x8F, 0x33, 0x26, 0x5F, 0xEC, 0x76, 0x2A, 0x49, 0x81, 0x88, 0xEE, 0x21,
122    0xC4, 0x1A, 0xEB, 0xD9, 0xC5, 0x39, 0x99, 0xCD, 0xAD, 0x31, 0x8B, 0x01,
123    0x18, 0x23, 0xDD, 0x1F, 0x4E, 0x2D, 0xF9, 0x48, 0x4F, 0xF2, 0x65, 0x8E,
124    0x78, 0x5C, 0x58, 0x19, 0x8D, 0xE5, 0x98, 0x57, 0x67, 0x7F, 0x05, 0x64,
125    0xAF, 0x63, 0xB6, 0xFE, 0xF5, 0xB7, 0x3C, 0xA5, 0xCE, 0xE9, 0x68, 0x44,
126    0xE0, 0x4D, 0x43, 0x69, 0x29, 0x2E, 0xAC, 0x15, 0x59, 0xA8, 0x0A, 0x9E,
127    0x6E, 0x47, 0xDF, 0x34, 0x35, 0x6A, 0xCF, 0xDC, 0x22, 0xC9, 0xC0, 0x9B,
128    0x89, 0xD4, 0xED, 0xAB, 0x12, 0xA2, 0x0D, 0x52, 0xBB, 0x02, 0x2F, 0xA9,
129    0xD7, 0x61, 0x1E, 0xB4, 0x50, 0x04, 0xF6, 0xC2, 0x16, 0x25, 0x86, 0x56,
130    0x55, 0x09, 0xBE, 0x91
131 };
132 \f
133 /* These MDS tables are actually tables of MDS composed with q0 and q1,
134  * because it is only ever used that way and we can save some time by
135  * precomputing.  Of course the main saving comes from precomputing the
136  * GF(2^8) multiplication involved in the MDS matrix multiply; by looking
137  * things up in these tables we reduce the matrix multiply to four lookups
138  * and three XORs.  Semi-formally, the definition of these tables is:
139  * mds[0][i] = MDS (q1[i] 0 0 0)^T  mds[1][i] = MDS (0 q0[i] 0 0)^T
140  * mds[2][i] = MDS (0 0 q1[i] 0)^T  mds[3][i] = MDS (0 0 0 q0[i])^T
141  * where ^T means "transpose", the matrix multiply is performed in GF(2^8)
142  * represented as GF(2)[x]/v(x) where v(x)=x^8+x^6+x^5+x^3+1 as described
143  * by Schneier et al, and I'm casually glossing over the byte/word
144  * conversion issues. */
145
146 static const u32 mds[4][256] = {
147    {0xBCBC3275, 0xECEC21F3, 0x202043C6, 0xB3B3C9F4, 0xDADA03DB, 0x02028B7B,
148     0xE2E22BFB, 0x9E9EFAC8, 0xC9C9EC4A, 0xD4D409D3, 0x18186BE6, 0x1E1E9F6B,
149     0x98980E45, 0xB2B2387D, 0xA6A6D2E8, 0x2626B74B, 0x3C3C57D6, 0x93938A32,
150     0x8282EED8, 0x525298FD, 0x7B7BD437, 0xBBBB3771, 0x5B5B97F1, 0x474783E1,
151     0x24243C30, 0x5151E20F, 0xBABAC6F8, 0x4A4AF31B, 0xBFBF4887, 0x0D0D70FA,
152     0xB0B0B306, 0x7575DE3F, 0xD2D2FD5E, 0x7D7D20BA, 0x666631AE, 0x3A3AA35B,
153     0x59591C8A, 0x00000000, 0xCDCD93BC, 0x1A1AE09D, 0xAEAE2C6D, 0x7F7FABC1,
154     0x2B2BC7B1, 0xBEBEB90E, 0xE0E0A080, 0x8A8A105D, 0x3B3B52D2, 0x6464BAD5,
155     0xD8D888A0, 0xE7E7A584, 0x5F5FE807, 0x1B1B1114, 0x2C2CC2B5, 0xFCFCB490,
156     0x3131272C, 0x808065A3, 0x73732AB2, 0x0C0C8173, 0x79795F4C, 0x6B6B4154,
157     0x4B4B0292, 0x53536974, 0x94948F36, 0x83831F51, 0x2A2A3638, 0xC4C49CB0,
158     0x2222C8BD, 0xD5D5F85A, 0xBDBDC3FC, 0x48487860, 0xFFFFCE62, 0x4C4C0796,
159     0x4141776C, 0xC7C7E642, 0xEBEB24F7, 0x1C1C1410, 0x5D5D637C, 0x36362228,
160     0x6767C027, 0xE9E9AF8C, 0x4444F913, 0x1414EA95, 0xF5F5BB9C, 0xCFCF18C7,
161     0x3F3F2D24, 0xC0C0E346, 0x7272DB3B, 0x54546C70, 0x29294CCA, 0xF0F035E3,
162     0x0808FE85, 0xC6C617CB, 0xF3F34F11, 0x8C8CE4D0, 0xA4A45993, 0xCACA96B8,
163     0x68683BA6, 0xB8B84D83, 0x38382820, 0xE5E52EFF, 0xADAD569F, 0x0B0B8477,
164     0xC8C81DC3, 0x9999FFCC, 0x5858ED03, 0x19199A6F, 0x0E0E0A08, 0x95957EBF,
165     0x70705040, 0xF7F730E7, 0x6E6ECF2B, 0x1F1F6EE2, 0xB5B53D79, 0x09090F0C,
166     0x616134AA, 0x57571682, 0x9F9F0B41, 0x9D9D803A, 0x111164EA, 0x2525CDB9,
167     0xAFAFDDE4, 0x4545089A, 0xDFDF8DA4, 0xA3A35C97, 0xEAEAD57E, 0x353558DA,
168     0xEDEDD07A, 0x4343FC17, 0xF8F8CB66, 0xFBFBB194, 0x3737D3A1, 0xFAFA401D,
169     0xC2C2683D, 0xB4B4CCF0, 0x32325DDE, 0x9C9C71B3, 0x5656E70B, 0xE3E3DA72,
170     0x878760A7, 0x15151B1C, 0xF9F93AEF, 0x6363BFD1, 0x3434A953, 0x9A9A853E,
171     0xB1B1428F, 0x7C7CD133, 0x88889B26, 0x3D3DA65F, 0xA1A1D7EC, 0xE4E4DF76,
172     0x8181942A, 0x91910149, 0x0F0FFB81, 0xEEEEAA88, 0x161661EE, 0xD7D77321,
173     0x9797F5C4, 0xA5A5A81A, 0xFEFE3FEB, 0x6D6DB5D9, 0x7878AEC5, 0xC5C56D39,
174     0x1D1DE599, 0x7676A4CD, 0x3E3EDCAD, 0xCBCB6731, 0xB6B6478B, 0xEFEF5B01,
175     0x12121E18, 0x6060C523, 0x6A6AB0DD, 0x4D4DF61F, 0xCECEE94E, 0xDEDE7C2D,
176     0x55559DF9, 0x7E7E5A48, 0x2121B24F, 0x03037AF2, 0xA0A02665, 0x5E5E198E,
177     0x5A5A6678, 0x65654B5C, 0x62624E58, 0xFDFD4519, 0x0606F48D, 0x404086E5,
178     0xF2F2BE98, 0x3333AC57, 0x17179067, 0x05058E7F, 0xE8E85E05, 0x4F4F7D64,
179     0x89896AAF, 0x10109563, 0x74742FB6, 0x0A0A75FE, 0x5C5C92F5, 0x9B9B74B7,
180     0x2D2D333C, 0x3030D6A5, 0x2E2E49CE, 0x494989E9, 0x46467268, 0x77775544,
181     0xA8A8D8E0, 0x9696044D, 0x2828BD43, 0xA9A92969, 0xD9D97929, 0x8686912E,
182     0xD1D187AC, 0xF4F44A15, 0x8D8D1559, 0xD6D682A8, 0xB9B9BC0A, 0x42420D9E,
183     0xF6F6C16E, 0x2F2FB847, 0xDDDD06DF, 0x23233934, 0xCCCC6235, 0xF1F1C46A,
184     0xC1C112CF, 0x8585EBDC, 0x8F8F9E22, 0x7171A1C9, 0x9090F0C0, 0xAAAA539B,
185     0x0101F189, 0x8B8BE1D4, 0x4E4E8CED, 0x8E8E6FAB, 0xABABA212, 0x6F6F3EA2,
186     0xE6E6540D, 0xDBDBF252, 0x92927BBB, 0xB7B7B602, 0x6969CA2F, 0x3939D9A9,
187     0xD3D30CD7, 0xA7A72361, 0xA2A2AD1E, 0xC3C399B4, 0x6C6C4450, 0x07070504,
188     0x04047FF6, 0x272746C2, 0xACACA716, 0xD0D07625, 0x50501386, 0xDCDCF756,
189     0x84841A55, 0xE1E15109, 0x7A7A25BE, 0x1313EF91},
190
191    {0xA9D93939, 0x67901717, 0xB3719C9C, 0xE8D2A6A6, 0x04050707, 0xFD985252,
192     0xA3658080, 0x76DFE4E4, 0x9A084545, 0x92024B4B, 0x80A0E0E0, 0x78665A5A,
193     0xE4DDAFAF, 0xDDB06A6A, 0xD1BF6363, 0x38362A2A, 0x0D54E6E6, 0xC6432020,
194     0x3562CCCC, 0x98BEF2F2, 0x181E1212, 0xF724EBEB, 0xECD7A1A1, 0x6C774141,
195     0x43BD2828, 0x7532BCBC, 0x37D47B7B, 0x269B8888, 0xFA700D0D, 0x13F94444,
196     0x94B1FBFB, 0x485A7E7E, 0xF27A0303, 0xD0E48C8C, 0x8B47B6B6, 0x303C2424,
197     0x84A5E7E7, 0x54416B6B, 0xDF06DDDD, 0x23C56060, 0x1945FDFD, 0x5BA33A3A,
198     0x3D68C2C2, 0x59158D8D, 0xF321ECEC, 0xAE316666, 0xA23E6F6F, 0x82165757,
199     0x63951010, 0x015BEFEF, 0x834DB8B8, 0x2E918686, 0xD9B56D6D, 0x511F8383,
200     0x9B53AAAA, 0x7C635D5D, 0xA63B6868, 0xEB3FFEFE, 0xA5D63030, 0xBE257A7A,
201     0x16A7ACAC, 0x0C0F0909, 0xE335F0F0, 0x6123A7A7, 0xC0F09090, 0x8CAFE9E9,
202     0x3A809D9D, 0xF5925C5C, 0x73810C0C, 0x2C273131, 0x2576D0D0, 0x0BE75656,
203     0xBB7B9292, 0x4EE9CECE, 0x89F10101, 0x6B9F1E1E, 0x53A93434, 0x6AC4F1F1,
204     0xB499C3C3, 0xF1975B5B, 0xE1834747, 0xE66B1818, 0xBDC82222, 0x450E9898,
205     0xE26E1F1F, 0xF4C9B3B3, 0xB62F7474, 0x66CBF8F8, 0xCCFF9999, 0x95EA1414,
206     0x03ED5858, 0x56F7DCDC, 0xD4E18B8B, 0x1C1B1515, 0x1EADA2A2, 0xD70CD3D3,
207     0xFB2BE2E2, 0xC31DC8C8, 0x8E195E5E, 0xB5C22C2C, 0xE9894949, 0xCF12C1C1,
208     0xBF7E9595, 0xBA207D7D, 0xEA641111, 0x77840B0B, 0x396DC5C5, 0xAF6A8989,
209     0x33D17C7C, 0xC9A17171, 0x62CEFFFF, 0x7137BBBB, 0x81FB0F0F, 0x793DB5B5,
210     0x0951E1E1, 0xADDC3E3E, 0x242D3F3F, 0xCDA47676, 0xF99D5555, 0xD8EE8282,
211     0xE5864040, 0xC5AE7878, 0xB9CD2525, 0x4D049696, 0x44557777, 0x080A0E0E,
212     0x86135050, 0xE730F7F7, 0xA1D33737, 0x1D40FAFA, 0xAA346161, 0xED8C4E4E,
213     0x06B3B0B0, 0x706C5454, 0xB22A7373, 0xD2523B3B, 0x410B9F9F, 0x7B8B0202,
214     0xA088D8D8, 0x114FF3F3, 0x3167CBCB, 0xC2462727, 0x27C06767, 0x90B4FCFC,
215     0x20283838, 0xF67F0404, 0x60784848, 0xFF2EE5E5, 0x96074C4C, 0x5C4B6565,
216     0xB1C72B2B, 0xAB6F8E8E, 0x9E0D4242, 0x9CBBF5F5, 0x52F2DBDB, 0x1BF34A4A,
217     0x5FA63D3D, 0x9359A4A4, 0x0ABCB9B9, 0xEF3AF9F9, 0x91EF1313, 0x85FE0808,
218     0x49019191, 0xEE611616, 0x2D7CDEDE, 0x4FB22121, 0x8F42B1B1, 0x3BDB7272,
219     0x47B82F2F, 0x8748BFBF, 0x6D2CAEAE, 0x46E3C0C0, 0xD6573C3C, 0x3E859A9A,
220     0x6929A9A9, 0x647D4F4F, 0x2A948181, 0xCE492E2E, 0xCB17C6C6, 0x2FCA6969,
221     0xFCC3BDBD, 0x975CA3A3, 0x055EE8E8, 0x7AD0EDED, 0xAC87D1D1, 0x7F8E0505,
222     0xD5BA6464, 0x1AA8A5A5, 0x4BB72626, 0x0EB9BEBE, 0xA7608787, 0x5AF8D5D5,
223     0x28223636, 0x14111B1B, 0x3FDE7575, 0x2979D9D9, 0x88AAEEEE, 0x3C332D2D,
224     0x4C5F7979, 0x02B6B7B7, 0xB896CACA, 0xDA583535, 0xB09CC4C4, 0x17FC4343,
225     0x551A8484, 0x1FF64D4D, 0x8A1C5959, 0x7D38B2B2, 0x57AC3333, 0xC718CFCF,
226     0x8DF40606, 0x74695353, 0xB7749B9B, 0xC4F59797, 0x9F56ADAD, 0x72DAE3E3,
227     0x7ED5EAEA, 0x154AF4F4, 0x229E8F8F, 0x12A2ABAB, 0x584E6262, 0x07E85F5F,
228     0x99E51D1D, 0x34392323, 0x6EC1F6F6, 0x50446C6C, 0xDE5D3232, 0x68724646,
229     0x6526A0A0, 0xBC93CDCD, 0xDB03DADA, 0xF8C6BABA, 0xC8FA9E9E, 0xA882D6D6,
230     0x2BCF6E6E, 0x40507070, 0xDCEB8585, 0xFE750A0A, 0x328A9393, 0xA48DDFDF,
231     0xCA4C2929, 0x10141C1C, 0x2173D7D7, 0xF0CCB4B4, 0xD309D4D4, 0x5D108A8A,
232     0x0FE25151, 0x00000000, 0x6F9A1919, 0x9DE01A1A, 0x368F9494, 0x42E6C7C7,
233     0x4AECC9C9, 0x5EFDD2D2, 0xC1AB7F7F, 0xE0D8A8A8},
234
235    {0xBC75BC32, 0xECF3EC21, 0x20C62043, 0xB3F4B3C9, 0xDADBDA03, 0x027B028B,
236     0xE2FBE22B, 0x9EC89EFA, 0xC94AC9EC, 0xD4D3D409, 0x18E6186B, 0x1E6B1E9F,
237     0x9845980E, 0xB27DB238, 0xA6E8A6D2, 0x264B26B7, 0x3CD63C57, 0x9332938A,
238     0x82D882EE, 0x52FD5298, 0x7B377BD4, 0xBB71BB37, 0x5BF15B97, 0x47E14783,
239     0x2430243C, 0x510F51E2, 0xBAF8BAC6, 0x4A1B4AF3, 0xBF87BF48, 0x0DFA0D70,
240     0xB006B0B3, 0x753F75DE, 0xD25ED2FD, 0x7DBA7D20, 0x66AE6631, 0x3A5B3AA3,
241     0x598A591C, 0x00000000, 0xCDBCCD93, 0x1A9D1AE0, 0xAE6DAE2C, 0x7FC17FAB,
242     0x2BB12BC7, 0xBE0EBEB9, 0xE080E0A0, 0x8A5D8A10, 0x3BD23B52, 0x64D564BA,
243     0xD8A0D888, 0xE784E7A5, 0x5F075FE8, 0x1B141B11, 0x2CB52CC2, 0xFC90FCB4,
244     0x312C3127, 0x80A38065, 0x73B2732A, 0x0C730C81, 0x794C795F, 0x6B546B41,
245     0x4B924B02, 0x53745369, 0x9436948F, 0x8351831F, 0x2A382A36, 0xC4B0C49C,
246     0x22BD22C8, 0xD55AD5F8, 0xBDFCBDC3, 0x48604878, 0xFF62FFCE, 0x4C964C07,
247     0x416C4177, 0xC742C7E6, 0xEBF7EB24, 0x1C101C14, 0x5D7C5D63, 0x36283622,
248     0x672767C0, 0xE98CE9AF, 0x441344F9, 0x149514EA, 0xF59CF5BB, 0xCFC7CF18,
249     0x3F243F2D, 0xC046C0E3, 0x723B72DB, 0x5470546C, 0x29CA294C, 0xF0E3F035,
250     0x088508FE, 0xC6CBC617, 0xF311F34F, 0x8CD08CE4, 0xA493A459, 0xCAB8CA96,
251     0x68A6683B, 0xB883B84D, 0x38203828, 0xE5FFE52E, 0xAD9FAD56, 0x0B770B84,
252     0xC8C3C81D, 0x99CC99FF, 0x580358ED, 0x196F199A, 0x0E080E0A, 0x95BF957E,
253     0x70407050, 0xF7E7F730, 0x6E2B6ECF, 0x1FE21F6E, 0xB579B53D, 0x090C090F,
254     0x61AA6134, 0x57825716, 0x9F419F0B, 0x9D3A9D80, 0x11EA1164, 0x25B925CD,
255     0xAFE4AFDD, 0x459A4508, 0xDFA4DF8D, 0xA397A35C, 0xEA7EEAD5, 0x35DA3558,
256     0xED7AEDD0, 0x431743FC, 0xF866F8CB, 0xFB94FBB1, 0x37A137D3, 0xFA1DFA40,
257     0xC23DC268, 0xB4F0B4CC, 0x32DE325D, 0x9CB39C71, 0x560B56E7, 0xE372E3DA,
258     0x87A78760, 0x151C151B, 0xF9EFF93A, 0x63D163BF, 0x345334A9, 0x9A3E9A85,
259     0xB18FB142, 0x7C337CD1, 0x8826889B, 0x3D5F3DA6, 0xA1ECA1D7, 0xE476E4DF,
260     0x812A8194, 0x91499101, 0x0F810FFB, 0xEE88EEAA, 0x16EE1661, 0xD721D773,
261     0x97C497F5, 0xA51AA5A8, 0xFEEBFE3F, 0x6DD96DB5, 0x78C578AE, 0xC539C56D,
262     0x1D991DE5, 0x76CD76A4, 0x3EAD3EDC, 0xCB31CB67, 0xB68BB647, 0xEF01EF5B,
263     0x1218121E, 0x602360C5, 0x6ADD6AB0, 0x4D1F4DF6, 0xCE4ECEE9, 0xDE2DDE7C,
264     0x55F9559D, 0x7E487E5A, 0x214F21B2, 0x03F2037A, 0xA065A026, 0x5E8E5E19,
265     0x5A785A66, 0x655C654B, 0x6258624E, 0xFD19FD45, 0x068D06F4, 0x40E54086,
266     0xF298F2BE, 0x335733AC, 0x17671790, 0x057F058E, 0xE805E85E, 0x4F644F7D,
267     0x89AF896A, 0x10631095, 0x74B6742F, 0x0AFE0A75, 0x5CF55C92, 0x9BB79B74,
268     0x2D3C2D33, 0x30A530D6, 0x2ECE2E49, 0x49E94989, 0x46684672, 0x77447755,
269     0xA8E0A8D8, 0x964D9604, 0x284328BD, 0xA969A929, 0xD929D979, 0x862E8691,
270     0xD1ACD187, 0xF415F44A, 0x8D598D15, 0xD6A8D682, 0xB90AB9BC, 0x429E420D,
271     0xF66EF6C1, 0x2F472FB8, 0xDDDFDD06, 0x23342339, 0xCC35CC62, 0xF16AF1C4,
272     0xC1CFC112, 0x85DC85EB, 0x8F228F9E, 0x71C971A1, 0x90C090F0, 0xAA9BAA53,
273     0x018901F1, 0x8BD48BE1, 0x4EED4E8C, 0x8EAB8E6F, 0xAB12ABA2, 0x6FA26F3E,
274     0xE60DE654, 0xDB52DBF2, 0x92BB927B, 0xB702B7B6, 0x692F69CA, 0x39A939D9,
275     0xD3D7D30C, 0xA761A723, 0xA21EA2AD, 0xC3B4C399, 0x6C506C44, 0x07040705,
276     0x04F6047F, 0x27C22746, 0xAC16ACA7, 0xD025D076, 0x50865013, 0xDC56DCF7,
277     0x8455841A, 0xE109E151, 0x7ABE7A25, 0x139113EF},
278
279    {0xD939A9D9, 0x90176790, 0x719CB371, 0xD2A6E8D2, 0x05070405, 0x9852FD98,
280     0x6580A365, 0xDFE476DF, 0x08459A08, 0x024B9202, 0xA0E080A0, 0x665A7866,
281     0xDDAFE4DD, 0xB06ADDB0, 0xBF63D1BF, 0x362A3836, 0x54E60D54, 0x4320C643,
282     0x62CC3562, 0xBEF298BE, 0x1E12181E, 0x24EBF724, 0xD7A1ECD7, 0x77416C77,
283     0xBD2843BD, 0x32BC7532, 0xD47B37D4, 0x9B88269B, 0x700DFA70, 0xF94413F9,
284     0xB1FB94B1, 0x5A7E485A, 0x7A03F27A, 0xE48CD0E4, 0x47B68B47, 0x3C24303C,
285     0xA5E784A5, 0x416B5441, 0x06DDDF06, 0xC56023C5, 0x45FD1945, 0xA33A5BA3,
286     0x68C23D68, 0x158D5915, 0x21ECF321, 0x3166AE31, 0x3E6FA23E, 0x16578216,
287     0x95106395, 0x5BEF015B, 0x4DB8834D, 0x91862E91, 0xB56DD9B5, 0x1F83511F,
288     0x53AA9B53, 0x635D7C63, 0x3B68A63B, 0x3FFEEB3F, 0xD630A5D6, 0x257ABE25,
289     0xA7AC16A7, 0x0F090C0F, 0x35F0E335, 0x23A76123, 0xF090C0F0, 0xAFE98CAF,
290     0x809D3A80, 0x925CF592, 0x810C7381, 0x27312C27, 0x76D02576, 0xE7560BE7,
291     0x7B92BB7B, 0xE9CE4EE9, 0xF10189F1, 0x9F1E6B9F, 0xA93453A9, 0xC4F16AC4,
292     0x99C3B499, 0x975BF197, 0x8347E183, 0x6B18E66B, 0xC822BDC8, 0x0E98450E,
293     0x6E1FE26E, 0xC9B3F4C9, 0x2F74B62F, 0xCBF866CB, 0xFF99CCFF, 0xEA1495EA,
294     0xED5803ED, 0xF7DC56F7, 0xE18BD4E1, 0x1B151C1B, 0xADA21EAD, 0x0CD3D70C,
295     0x2BE2FB2B, 0x1DC8C31D, 0x195E8E19, 0xC22CB5C2, 0x8949E989, 0x12C1CF12,
296     0x7E95BF7E, 0x207DBA20, 0x6411EA64, 0x840B7784, 0x6DC5396D, 0x6A89AF6A,
297     0xD17C33D1, 0xA171C9A1, 0xCEFF62CE, 0x37BB7137, 0xFB0F81FB, 0x3DB5793D,
298     0x51E10951, 0xDC3EADDC, 0x2D3F242D, 0xA476CDA4, 0x9D55F99D, 0xEE82D8EE,
299     0x8640E586, 0xAE78C5AE, 0xCD25B9CD, 0x04964D04, 0x55774455, 0x0A0E080A,
300     0x13508613, 0x30F7E730, 0xD337A1D3, 0x40FA1D40, 0x3461AA34, 0x8C4EED8C,
301     0xB3B006B3, 0x6C54706C, 0x2A73B22A, 0x523BD252, 0x0B9F410B, 0x8B027B8B,
302     0x88D8A088, 0x4FF3114F, 0x67CB3167, 0x4627C246, 0xC06727C0, 0xB4FC90B4,
303     0x28382028, 0x7F04F67F, 0x78486078, 0x2EE5FF2E, 0x074C9607, 0x4B655C4B,
304     0xC72BB1C7, 0x6F8EAB6F, 0x0D429E0D, 0xBBF59CBB, 0xF2DB52F2, 0xF34A1BF3,
305     0xA63D5FA6, 0x59A49359, 0xBCB90ABC, 0x3AF9EF3A, 0xEF1391EF, 0xFE0885FE,
306     0x01914901, 0x6116EE61, 0x7CDE2D7C, 0xB2214FB2, 0x42B18F42, 0xDB723BDB,
307     0xB82F47B8, 0x48BF8748, 0x2CAE6D2C, 0xE3C046E3, 0x573CD657, 0x859A3E85,
308     0x29A96929, 0x7D4F647D, 0x94812A94, 0x492ECE49, 0x17C6CB17, 0xCA692FCA,
309     0xC3BDFCC3, 0x5CA3975C, 0x5EE8055E, 0xD0ED7AD0, 0x87D1AC87, 0x8E057F8E,
310     0xBA64D5BA, 0xA8A51AA8, 0xB7264BB7, 0xB9BE0EB9, 0x6087A760, 0xF8D55AF8,
311     0x22362822, 0x111B1411, 0xDE753FDE, 0x79D92979, 0xAAEE88AA, 0x332D3C33,
312     0x5F794C5F, 0xB6B702B6, 0x96CAB896, 0x5835DA58, 0x9CC4B09C, 0xFC4317FC,
313     0x1A84551A, 0xF64D1FF6, 0x1C598A1C, 0x38B27D38, 0xAC3357AC, 0x18CFC718,
314     0xF4068DF4, 0x69537469, 0x749BB774, 0xF597C4F5, 0x56AD9F56, 0xDAE372DA,
315     0xD5EA7ED5, 0x4AF4154A, 0x9E8F229E, 0xA2AB12A2, 0x4E62584E, 0xE85F07E8,
316     0xE51D99E5, 0x39233439, 0xC1F66EC1, 0x446C5044, 0x5D32DE5D, 0x72466872,
317     0x26A06526, 0x93CDBC93, 0x03DADB03, 0xC6BAF8C6, 0xFA9EC8FA, 0x82D6A882,
318     0xCF6E2BCF, 0x50704050, 0xEB85DCEB, 0x750AFE75, 0x8A93328A, 0x8DDFA48D,
319     0x4C29CA4C, 0x141C1014, 0x73D72173, 0xCCB4F0CC, 0x09D4D309, 0x108A5D10,
320     0xE2510FE2, 0x00000000, 0x9A196F9A, 0xE01A9DE0, 0x8F94368F, 0xE6C742E6,
321     0xECC94AEC, 0xFDD25EFD, 0xAB7FC1AB, 0xD8A8E0D8}
322 };
323 \f
324 /* The exp_to_poly and poly_to_exp tables are used to perform efficient
325  * operations in GF(2^8) represented as GF(2)[x]/w(x) where
326  * w(x)=x^8+x^6+x^3+x^2+1.  We care about doing that because it's part of the
327  * definition of the RS matrix in the key schedule.  Elements of that field
328  * are polynomials of degree not greater than 7 and all coefficients 0 or 1,
329  * which can be represented naturally by bytes (just substitute x=2).  In that
330  * form, GF(2^8) addition is the same as bitwise XOR, but GF(2^8)
331  * multiplication is inefficient without hardware support.  To multiply
332  * faster, I make use of the fact x is a generator for the nonzero elements,
333  * so that every element p of GF(2)[x]/w(x) is either 0 or equal to (x)^n for
334  * some n in 0..254.  Note that that caret is exponentiation in GF(2^8),
335  * *not* polynomial notation.  So if I want to compute pq where p and q are
336  * in GF(2^8), I can just say:
337  *    1. if p=0 or q=0 then pq=0
338  *    2. otherwise, find m and n such that p=x^m and q=x^n
339  *    3. pq=(x^m)(x^n)=x^(m+n), so add m and n and find pq
340  * The translations in steps 2 and 3 are looked up in the tables
341  * poly_to_exp (for step 2) and exp_to_poly (for step 3).  To see this
342  * in action, look at the CALC_S macro.  As additional wrinkles, note that
343  * one of my operands is always a constant, so the poly_to_exp lookup on it
344  * is done in advance; I included the original values in the comments so
345  * readers can have some chance of recognizing that this *is* the RS matrix
346  * from the Twofish paper.  I've only included the table entries I actually
347  * need; I never do a lookup on a variable input of zero and the biggest
348  * exponents I'll ever see are 254 (variable) and 237 (constant), so they'll
349  * never sum to more than 491.  I'm repeating part of the exp_to_poly table
350  * so that I don't have to do mod-255 reduction in the exponent arithmetic.
351  * Since I know my constant operands are never zero, I only have to worry
352  * about zero values in the variable operand, and I do it with a simple
353  * conditional branch.  I know conditionals are expensive, but I couldn't
354  * see a non-horrible way of avoiding them, and I did manage to group the
355  * statements so that each if covers four group multiplications. */
356
357 static const byte poly_to_exp[255] = {
358    0x00, 0x01, 0x17, 0x02, 0x2E, 0x18, 0x53, 0x03, 0x6A, 0x2F, 0x93, 0x19,
359    0x34, 0x54, 0x45, 0x04, 0x5C, 0x6B, 0xB6, 0x30, 0xA6, 0x94, 0x4B, 0x1A,
360    0x8C, 0x35, 0x81, 0x55, 0xAA, 0x46, 0x0D, 0x05, 0x24, 0x5D, 0x87, 0x6C,
361    0x9B, 0xB7, 0xC1, 0x31, 0x2B, 0xA7, 0xA3, 0x95, 0x98, 0x4C, 0xCA, 0x1B,
362    0xE6, 0x8D, 0x73, 0x36, 0xCD, 0x82, 0x12, 0x56, 0x62, 0xAB, 0xF0, 0x47,
363    0x4F, 0x0E, 0xBD, 0x06, 0xD4, 0x25, 0xD2, 0x5E, 0x27, 0x88, 0x66, 0x6D,
364    0xD6, 0x9C, 0x79, 0xB8, 0x08, 0xC2, 0xDF, 0x32, 0x68, 0x2C, 0xFD, 0xA8,
365    0x8A, 0xA4, 0x5A, 0x96, 0x29, 0x99, 0x22, 0x4D, 0x60, 0xCB, 0xE4, 0x1C,
366    0x7B, 0xE7, 0x3B, 0x8E, 0x9E, 0x74, 0xF4, 0x37, 0xD8, 0xCE, 0xF9, 0x83,
367    0x6F, 0x13, 0xB2, 0x57, 0xE1, 0x63, 0xDC, 0xAC, 0xC4, 0xF1, 0xAF, 0x48,
368    0x0A, 0x50, 0x42, 0x0F, 0xBA, 0xBE, 0xC7, 0x07, 0xDE, 0xD5, 0x78, 0x26,
369    0x65, 0xD3, 0xD1, 0x5F, 0xE3, 0x28, 0x21, 0x89, 0x59, 0x67, 0xFC, 0x6E,
370    0xB1, 0xD7, 0xF8, 0x9D, 0xF3, 0x7A, 0x3A, 0xB9, 0xC6, 0x09, 0x41, 0xC3,
371    0xAE, 0xE0, 0xDB, 0x33, 0x44, 0x69, 0x92, 0x2D, 0x52, 0xFE, 0x16, 0xA9,
372    0x0C, 0x8B, 0x80, 0xA5, 0x4A, 0x5B, 0xB5, 0x97, 0xC9, 0x2A, 0xA2, 0x9A,
373    0xC0, 0x23, 0x86, 0x4E, 0xBC, 0x61, 0xEF, 0xCC, 0x11, 0xE5, 0x72, 0x1D,
374    0x3D, 0x7C, 0xEB, 0xE8, 0xE9, 0x3C, 0xEA, 0x8F, 0x7D, 0x9F, 0xEC, 0x75,
375    0x1E, 0xF5, 0x3E, 0x38, 0xF6, 0xD9, 0x3F, 0xCF, 0x76, 0xFA, 0x1F, 0x84,
376    0xA0, 0x70, 0xED, 0x14, 0x90, 0xB3, 0x7E, 0x58, 0xFB, 0xE2, 0x20, 0x64,
377    0xD0, 0xDD, 0x77, 0xAD, 0xDA, 0xC5, 0x40, 0xF2, 0x39, 0xB0, 0xF7, 0x49,
378    0xB4, 0x0B, 0x7F, 0x51, 0x15, 0x43, 0x91, 0x10, 0x71, 0xBB, 0xEE, 0xBF,
379    0x85, 0xC8, 0xA1
380 };
381
382 static const byte exp_to_poly[492] = {
383    0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x4D, 0x9A, 0x79, 0xF2,
384    0xA9, 0x1F, 0x3E, 0x7C, 0xF8, 0xBD, 0x37, 0x6E, 0xDC, 0xF5, 0xA7, 0x03,
385    0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0xCD, 0xD7, 0xE3, 0x8B, 0x5B, 0xB6,
386    0x21, 0x42, 0x84, 0x45, 0x8A, 0x59, 0xB2, 0x29, 0x52, 0xA4, 0x05, 0x0A,
387    0x14, 0x28, 0x50, 0xA0, 0x0D, 0x1A, 0x34, 0x68, 0xD0, 0xED, 0x97, 0x63,
388    0xC6, 0xC1, 0xCF, 0xD3, 0xEB, 0x9B, 0x7B, 0xF6, 0xA1, 0x0F, 0x1E, 0x3C,
389    0x78, 0xF0, 0xAD, 0x17, 0x2E, 0x5C, 0xB8, 0x3D, 0x7A, 0xF4, 0xA5, 0x07,
390    0x0E, 0x1C, 0x38, 0x70, 0xE0, 0x8D, 0x57, 0xAE, 0x11, 0x22, 0x44, 0x88,
391    0x5D, 0xBA, 0x39, 0x72, 0xE4, 0x85, 0x47, 0x8E, 0x51, 0xA2, 0x09, 0x12,
392    0x24, 0x48, 0x90, 0x6D, 0xDA, 0xF9, 0xBF, 0x33, 0x66, 0xCC, 0xD5, 0xE7,
393    0x83, 0x4B, 0x96, 0x61, 0xC2, 0xC9, 0xDF, 0xF3, 0xAB, 0x1B, 0x36, 0x6C,
394    0xD8, 0xFD, 0xB7, 0x23, 0x46, 0x8C, 0x55, 0xAA, 0x19, 0x32, 0x64, 0xC8,
395    0xDD, 0xF7, 0xA3, 0x0B, 0x16, 0x2C, 0x58, 0xB0, 0x2D, 0x5A, 0xB4, 0x25,
396    0x4A, 0x94, 0x65, 0xCA, 0xD9, 0xFF, 0xB3, 0x2B, 0x56, 0xAC, 0x15, 0x2A,
397    0x54, 0xA8, 0x1D, 0x3A, 0x74, 0xE8, 0x9D, 0x77, 0xEE, 0x91, 0x6F, 0xDE,
398    0xF1, 0xAF, 0x13, 0x26, 0x4C, 0x98, 0x7D, 0xFA, 0xB9, 0x3F, 0x7E, 0xFC,
399    0xB5, 0x27, 0x4E, 0x9C, 0x75, 0xEA, 0x99, 0x7F, 0xFE, 0xB1, 0x2F, 0x5E,
400    0xBC, 0x35, 0x6A, 0xD4, 0xE5, 0x87, 0x43, 0x86, 0x41, 0x82, 0x49, 0x92,
401    0x69, 0xD2, 0xE9, 0x9F, 0x73, 0xE6, 0x81, 0x4F, 0x9E, 0x71, 0xE2, 0x89,
402    0x5F, 0xBE, 0x31, 0x62, 0xC4, 0xC5, 0xC7, 0xC3, 0xCB, 0xDB, 0xFB, 0xBB,
403    0x3B, 0x76, 0xEC, 0x95, 0x67, 0xCE, 0xD1, 0xEF, 0x93, 0x6B, 0xD6, 0xE1,
404    0x8F, 0x53, 0xA6, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x4D,
405    0x9A, 0x79, 0xF2, 0xA9, 0x1F, 0x3E, 0x7C, 0xF8, 0xBD, 0x37, 0x6E, 0xDC,
406    0xF5, 0xA7, 0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0xCD, 0xD7, 0xE3,
407    0x8B, 0x5B, 0xB6, 0x21, 0x42, 0x84, 0x45, 0x8A, 0x59, 0xB2, 0x29, 0x52,
408    0xA4, 0x05, 0x0A, 0x14, 0x28, 0x50, 0xA0, 0x0D, 0x1A, 0x34, 0x68, 0xD0,
409    0xED, 0x97, 0x63, 0xC6, 0xC1, 0xCF, 0xD3, 0xEB, 0x9B, 0x7B, 0xF6, 0xA1,
410    0x0F, 0x1E, 0x3C, 0x78, 0xF0, 0xAD, 0x17, 0x2E, 0x5C, 0xB8, 0x3D, 0x7A,
411    0xF4, 0xA5, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0, 0x8D, 0x57, 0xAE, 0x11,
412    0x22, 0x44, 0x88, 0x5D, 0xBA, 0x39, 0x72, 0xE4, 0x85, 0x47, 0x8E, 0x51,
413    0xA2, 0x09, 0x12, 0x24, 0x48, 0x90, 0x6D, 0xDA, 0xF9, 0xBF, 0x33, 0x66,
414    0xCC, 0xD5, 0xE7, 0x83, 0x4B, 0x96, 0x61, 0xC2, 0xC9, 0xDF, 0xF3, 0xAB,
415    0x1B, 0x36, 0x6C, 0xD8, 0xFD, 0xB7, 0x23, 0x46, 0x8C, 0x55, 0xAA, 0x19,
416    0x32, 0x64, 0xC8, 0xDD, 0xF7, 0xA3, 0x0B, 0x16, 0x2C, 0x58, 0xB0, 0x2D,
417    0x5A, 0xB4, 0x25, 0x4A, 0x94, 0x65, 0xCA, 0xD9, 0xFF, 0xB3, 0x2B, 0x56,
418    0xAC, 0x15, 0x2A, 0x54, 0xA8, 0x1D, 0x3A, 0x74, 0xE8, 0x9D, 0x77, 0xEE,
419    0x91, 0x6F, 0xDE, 0xF1, 0xAF, 0x13, 0x26, 0x4C, 0x98, 0x7D, 0xFA, 0xB9,
420    0x3F, 0x7E, 0xFC, 0xB5, 0x27, 0x4E, 0x9C, 0x75, 0xEA, 0x99, 0x7F, 0xFE,
421    0xB1, 0x2F, 0x5E, 0xBC, 0x35, 0x6A, 0xD4, 0xE5, 0x87, 0x43, 0x86, 0x41,
422    0x82, 0x49, 0x92, 0x69, 0xD2, 0xE9, 0x9F, 0x73, 0xE6, 0x81, 0x4F, 0x9E,
423    0x71, 0xE2, 0x89, 0x5F, 0xBE, 0x31, 0x62, 0xC4, 0xC5, 0xC7, 0xC3, 0xCB
424 };
425 \f
426
427 /* The table constants are indices of
428  * S-box entries, preprocessed through q0 and q1. */
429 static byte calc_sb_tbl[512] = {
430     0xA9, 0x75, 0x67, 0xF3, 0xB3, 0xC6, 0xE8, 0xF4,
431     0x04, 0xDB, 0xFD, 0x7B, 0xA3, 0xFB, 0x76, 0xC8,
432     0x9A, 0x4A, 0x92, 0xD3, 0x80, 0xE6, 0x78, 0x6B,
433     0xE4, 0x45, 0xDD, 0x7D, 0xD1, 0xE8, 0x38, 0x4B,
434     0x0D, 0xD6, 0xC6, 0x32, 0x35, 0xD8, 0x98, 0xFD,
435     0x18, 0x37, 0xF7, 0x71, 0xEC, 0xF1, 0x6C, 0xE1,
436     0x43, 0x30, 0x75, 0x0F, 0x37, 0xF8, 0x26, 0x1B,
437     0xFA, 0x87, 0x13, 0xFA, 0x94, 0x06, 0x48, 0x3F,
438     0xF2, 0x5E, 0xD0, 0xBA, 0x8B, 0xAE, 0x30, 0x5B,
439     0x84, 0x8A, 0x54, 0x00, 0xDF, 0xBC, 0x23, 0x9D,
440     0x19, 0x6D, 0x5B, 0xC1, 0x3D, 0xB1, 0x59, 0x0E,
441     0xF3, 0x80, 0xAE, 0x5D, 0xA2, 0xD2, 0x82, 0xD5,
442     0x63, 0xA0, 0x01, 0x84, 0x83, 0x07, 0x2E, 0x14,
443     0xD9, 0xB5, 0x51, 0x90, 0x9B, 0x2C, 0x7C, 0xA3,
444     0xA6, 0xB2, 0xEB, 0x73, 0xA5, 0x4C, 0xBE, 0x54,
445     0x16, 0x92, 0x0C, 0x74, 0xE3, 0x36, 0x61, 0x51,
446     0xC0, 0x38, 0x8C, 0xB0, 0x3A, 0xBD, 0xF5, 0x5A,
447     0x73, 0xFC, 0x2C, 0x60, 0x25, 0x62, 0x0B, 0x96,
448     0xBB, 0x6C, 0x4E, 0x42, 0x89, 0xF7, 0x6B, 0x10,
449     0x53, 0x7C, 0x6A, 0x28, 0xB4, 0x27, 0xF1, 0x8C,
450     0xE1, 0x13, 0xE6, 0x95, 0xBD, 0x9C, 0x45, 0xC7,
451     0xE2, 0x24, 0xF4, 0x46, 0xB6, 0x3B, 0x66, 0x70,
452     0xCC, 0xCA, 0x95, 0xE3, 0x03, 0x85, 0x56, 0xCB,
453     0xD4, 0x11, 0x1C, 0xD0, 0x1E, 0x93, 0xD7, 0xB8,
454     0xFB, 0xA6, 0xC3, 0x83, 0x8E, 0x20, 0xB5, 0xFF,
455     0xE9, 0x9F, 0xCF, 0x77, 0xBF, 0xC3, 0xBA, 0xCC,
456     0xEA, 0x03, 0x77, 0x6F, 0x39, 0x08, 0xAF, 0xBF,
457     0x33, 0x40, 0xC9, 0xE7, 0x62, 0x2B, 0x71, 0xE2,
458     0x81, 0x79, 0x79, 0x0C, 0x09, 0xAA, 0xAD, 0x82,
459     0x24, 0x41, 0xCD, 0x3A, 0xF9, 0xEA, 0xD8, 0xB9,
460     0xE5, 0xE4, 0xC5, 0x9A, 0xB9, 0xA4, 0x4D, 0x97,
461     0x44, 0x7E, 0x08, 0xDA, 0x86, 0x7A, 0xE7, 0x17,
462     0xA1, 0x66, 0x1D, 0x94, 0xAA, 0xA1, 0xED, 0x1D,
463     0x06, 0x3D, 0x70, 0xF0, 0xB2, 0xDE, 0xD2, 0xB3,
464     0x41, 0x0B, 0x7B, 0x72, 0xA0, 0xA7, 0x11, 0x1C,
465     0x31, 0xEF, 0xC2, 0xD1, 0x27, 0x53, 0x90, 0x3E,
466     0x20, 0x8F, 0xF6, 0x33, 0x60, 0x26, 0xFF, 0x5F,
467     0x96, 0xEC, 0x5C, 0x76, 0xB1, 0x2A, 0xAB, 0x49,
468     0x9E, 0x81, 0x9C, 0x88, 0x52, 0xEE, 0x1B, 0x21,
469     0x5F, 0xC4, 0x93, 0x1A, 0x0A, 0xEB, 0xEF, 0xD9,
470     0x91, 0xC5, 0x85, 0x39, 0x49, 0x99, 0xEE, 0xCD,
471     0x2D, 0xAD, 0x4F, 0x31, 0x8F, 0x8B, 0x3B, 0x01,
472     0x47, 0x18, 0x87, 0x23, 0x6D, 0xDD, 0x46, 0x1F,
473     0xD6, 0x4E, 0x3E, 0x2D, 0x69, 0xF9, 0x64, 0x48,
474     0x2A, 0x4F, 0xCE, 0xF2, 0xCB, 0x65, 0x2F, 0x8E,
475     0xFC, 0x78, 0x97, 0x5C, 0x05, 0x58, 0x7A, 0x19,
476     0xAC, 0x8D, 0x7F, 0xE5, 0xD5, 0x98, 0x1A, 0x57,
477     0x4B, 0x67, 0x0E, 0x7F, 0xA7, 0x05, 0x5A, 0x64,
478     0x28, 0xAF, 0x14, 0x63, 0x3F, 0xB6, 0x29, 0xFE,
479     0x88, 0xF5, 0x3C, 0xB7, 0x4C, 0x3C, 0x02, 0xA5,
480     0xB8, 0xCE, 0xDA, 0xE9, 0xB0, 0x68, 0x17, 0x44,
481     0x55, 0xE0, 0x1F, 0x4D, 0x8A, 0x43, 0x7D, 0x69,
482     0x57, 0x29, 0xC7, 0x2E, 0x8D, 0xAC, 0x74, 0x15,
483     0xB7, 0x59, 0xC4, 0xA8, 0x9F, 0x0A, 0x72, 0x9E,
484     0x7E, 0x6E, 0x15, 0x47, 0x22, 0xDF, 0x12, 0x34,
485     0x58, 0x35, 0x07, 0x6A, 0x99, 0xCF, 0x34, 0xDC,
486     0x6E, 0x22, 0x50, 0xC9, 0xDE, 0xC0, 0x68, 0x9B,
487     0x65, 0x89, 0xBC, 0xD4, 0xDB, 0xED, 0xF8, 0xAB,
488     0xC8, 0x12, 0xA8, 0xA2, 0x2B, 0x0D, 0x40, 0x52,
489     0xDC, 0xBB, 0xFE, 0x02, 0x32, 0x2F, 0xA4, 0xA9,
490     0xCA, 0xD7, 0x10, 0x61, 0x21, 0x1E, 0xF0, 0xB4,
491     0xD3, 0x50, 0x5D, 0x04, 0x0F, 0xF6, 0x00, 0xC2,
492     0x6F, 0x16, 0x9D, 0x25, 0x36, 0x86, 0x42, 0x56,
493     0x4A, 0x55, 0x5E, 0x09, 0xC1, 0xBE, 0xE0, 0x91
494 };
495 /* Macro to perform one column of the RS matrix multiplication.  The
496  * parameters a, b, c, and d are the four bytes of output; i is the index
497  * of the key bytes, and w, x, y, and z, are the column of constants from
498  * the RS matrix, preprocessed through the poly_to_exp table. */
499
500 #define CALC_S(a, b, c, d, i, w, x, y, z) \
501    if (key[i]) { \
502       tmp = poly_to_exp[key[i] - 1]; \
503       (a) ^= exp_to_poly[tmp + (w)]; \
504       (b) ^= exp_to_poly[tmp + (x)]; \
505       (c) ^= exp_to_poly[tmp + (y)]; \
506       (d) ^= exp_to_poly[tmp + (z)]; \
507    }
508
509 /* Macros to calculate the key-dependent S-boxes for a 128-bit key using
510  * the S vector from CALC_S.  CALC_SB_2 computes a single entry in all
511  * four S-boxes, where i is the index of the entry to compute, and a and b
512  * are the index numbers preprocessed through the q0 and q1 tables
513  * respectively.  CALC_SB is simply a convenience to make the code shorter;
514  * it calls CALC_SB_2 four times with consecutive indices from i to i+3,
515  * using the remaining parameters two by two. */
516
517 #define CALC_SB_2(i, a, b) \
518    ctx->s[0][i] = mds[0][q0[(a) ^ sa] ^ se]; \
519    ctx->s[1][i] = mds[1][q0[(b) ^ sb] ^ sf]; \
520    ctx->s[2][i] = mds[2][q1[(a) ^ sc] ^ sg]; \
521    ctx->s[3][i] = mds[3][q1[(b) ^ sd] ^ sh]
522
523 #define CALC_SB(i, a, b, c, d, e, f, g, h) \
524    CALC_SB_2 (i, a, b); CALC_SB_2 ((i)+1, c, d); \
525    CALC_SB_2 ((i)+2, e, f); CALC_SB_2 ((i)+3, g, h)
526
527 /* Macros exactly like CALC_SB and CALC_SB_2, but for 256-bit keys. */
528
529 #define CALC_SB256_2(i, a, b) \
530    ctx->s[0][i] = mds[0][q0[q0[q1[(b) ^ sa] ^ se] ^ si] ^ sm]; \
531    ctx->s[1][i] = mds[1][q0[q1[q1[(a) ^ sb] ^ sf] ^ sj] ^ sn]; \
532    ctx->s[2][i] = mds[2][q1[q0[q0[(a) ^ sc] ^ sg] ^ sk] ^ so]; \
533    ctx->s[3][i] = mds[3][q1[q1[q0[(b) ^ sd] ^ sh] ^ sl] ^ sp];
534
535 #define CALC_SB256(i, a, b, c, d, e, f, g, h) \
536    CALC_SB256_2 (i, a, b); CALC_SB256_2 ((i)+1, c, d); \
537    CALC_SB256_2 ((i)+2, e, f); CALC_SB256_2 ((i)+3, g, h)
538
539 /* Macros to calculate the whitening and round subkeys.  CALC_K_2 computes the
540  * last two stages of the h() function for a given index (either 2i or 2i+1).
541  * a, b, c, and d are the four bytes going into the last two stages.  For
542  * 128-bit keys, this is the entire h() function and a and c are the index
543  * preprocessed through q0 and q1 respectively; for longer keys they are the
544  * output of previous stages.  j is the index of the first key byte to use.
545  * CALC_K computes a pair of subkeys for 128-bit Twofish, by calling CALC_K_2
546  * twice, doing the Pseudo-Hadamard Transform, and doing the necessary
547  * rotations.  Its parameters are: a, the array to write the results into,
548  * j, the index of the first output entry, k and l, the preprocessed indices
549  * for index 2i, and m and n, the preprocessed indices for index 2i+1.
550  * CALC_K256_2 expands CALC_K_2 to handle 256-bit keys, by doing two
551  * additional lookup-and-XOR stages.  The parameters a and b are the index
552  * preprocessed through q0 and q1 respectively; j is the index of the first
553  * key byte to use.  CALC_K256 is identical to CALC_K but for using the
554  * CALC_K256_2 macro instead of CALC_K_2. */
555
556 #define CALC_K_2(a, b, c, d, j) \
557      mds[0][q0[a ^ key[(j) + 8]] ^ key[j]] \
558    ^ mds[1][q0[b ^ key[(j) + 9]] ^ key[(j) + 1]] \
559    ^ mds[2][q1[c ^ key[(j) + 10]] ^ key[(j) + 2]] \
560    ^ mds[3][q1[d ^ key[(j) + 11]] ^ key[(j) + 3]]
561
562 #define CALC_K(a, j, k, l, m, n) \
563    x = CALC_K_2 (k, l, k, l, 0); \
564    y = CALC_K_2 (m, n, m, n, 4); \
565    y = (y << 8) + (y >> 24); \
566    x += y; y += x; ctx->a[j] = x; \
567    ctx->a[(j) + 1] = (y << 9) + (y >> 23)
568
569 #define CALC_K256_2(a, b, j) \
570    CALC_K_2 (q0[q1[b ^ key[(j) + 24]] ^ key[(j) + 16]], \
571              q1[q1[a ^ key[(j) + 25]] ^ key[(j) + 17]], \
572              q0[q0[a ^ key[(j) + 26]] ^ key[(j) + 18]], \
573              q1[q0[b ^ key[(j) + 27]] ^ key[(j) + 19]], j)
574
575 #define CALC_K256(a, j, k, l, m, n) \
576    x = CALC_K256_2 (k, l, 0); \
577    y = CALC_K256_2 (m, n, 4); \
578    y = (y << 8) + (y >> 24); \
579    x += y; y += x; ctx->a[j] = x; \
580    ctx->a[(j) + 1] = (y << 9) + (y >> 23)
581 \f
582
583
584 /* Perform the key setup.  Note that this works only with 128- and 256-bit
585  * keys, despite the API that looks like it might support other sizes. */
586
587 static gcry_err_code_t
588 do_twofish_setkey (TWOFISH_context *ctx, const byte *key, const unsigned keylen)
589 {
590   int i, j, k;
591
592   /* Temporaries for CALC_K. */
593   u32 x, y;
594
595   /* The S vector used to key the S-boxes, split up into individual bytes.
596    * 128-bit keys use only sa through sh; 256-bit use all of them. */
597   byte sa = 0, sb = 0, sc = 0, sd = 0, se = 0, sf = 0, sg = 0, sh = 0;
598   byte si = 0, sj = 0, sk = 0, sl = 0, sm = 0, sn = 0, so = 0, sp = 0;
599
600   /* Temporary for CALC_S. */
601   byte tmp;
602
603   /* Flags for self-test. */
604   static int initialized = 0;
605   static const char *selftest_failed=0;
606
607   /* Check key length. */
608   if( ( ( keylen - 16 ) | 16 ) != 16 )
609     return GPG_ERR_INV_KEYLEN;
610
611   /* Do self-test if necessary. */
612   if (!initialized)
613     {
614       initialized = 1;
615       selftest_failed = selftest ();
616       if( selftest_failed )
617         log_error("%s\n", selftest_failed );
618     }
619   if( selftest_failed )
620     return GPG_ERR_SELFTEST_FAILED;
621
622   /* Compute the first two words of the S vector.  The magic numbers are
623    * the entries of the RS matrix, preprocessed through poly_to_exp.    The
624    * numbers in the comments are the original (polynomial form) matrix
625    * entries. */
626   CALC_S (sa, sb, sc, sd, 0, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
627   CALC_S (sa, sb, sc, sd, 1, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
628   CALC_S (sa, sb, sc, sd, 2, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
629   CALC_S (sa, sb, sc, sd, 3, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
630   CALC_S (sa, sb, sc, sd, 4, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
631   CALC_S (sa, sb, sc, sd, 5, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
632   CALC_S (sa, sb, sc, sd, 6, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
633   CALC_S (sa, sb, sc, sd, 7, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
634   CALC_S (se, sf, sg, sh, 8, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
635   CALC_S (se, sf, sg, sh, 9, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
636   CALC_S (se, sf, sg, sh, 10, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
637   CALC_S (se, sf, sg, sh, 11, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
638   CALC_S (se, sf, sg, sh, 12, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
639   CALC_S (se, sf, sg, sh, 13, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
640   CALC_S (se, sf, sg, sh, 14, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
641   CALC_S (se, sf, sg, sh, 15, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
642
643   if (keylen == 32)  /* 256-bit key */
644     {
645       /* Calculate the remaining two words of the S vector */
646       CALC_S (si, sj, sk, sl, 16, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
647       CALC_S (si, sj, sk, sl, 17, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
648       CALC_S (si, sj, sk, sl, 18, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
649       CALC_S (si, sj, sk, sl, 19, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
650       CALC_S (si, sj, sk, sl, 20, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
651       CALC_S (si, sj, sk, sl, 21, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
652       CALC_S (si, sj, sk, sl, 22, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
653       CALC_S (si, sj, sk, sl, 23, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
654       CALC_S (sm, sn, so, sp, 24, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
655       CALC_S (sm, sn, so, sp, 25, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
656       CALC_S (sm, sn, so, sp, 26, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
657       CALC_S (sm, sn, so, sp, 27, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
658       CALC_S (sm, sn, so, sp, 28, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
659       CALC_S (sm, sn, so, sp, 29, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
660       CALC_S (sm, sn, so, sp, 30, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
661       CALC_S (sm, sn, so, sp, 31, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
662
663       /* Compute the S-boxes. */
664       for(i=j=0,k=1; i < 256; i++, j += 2, k += 2 )
665         {
666           CALC_SB256_2( i, calc_sb_tbl[j], calc_sb_tbl[k] );
667         }
668
669       /* Calculate whitening and round subkeys.  The constants are
670        * indices of subkeys, preprocessed through q0 and q1. */
671       CALC_K256 (w, 0, 0xA9, 0x75, 0x67, 0xF3);
672       CALC_K256 (w, 2, 0xB3, 0xC6, 0xE8, 0xF4);
673       CALC_K256 (w, 4, 0x04, 0xDB, 0xFD, 0x7B);
674       CALC_K256 (w, 6, 0xA3, 0xFB, 0x76, 0xC8);
675       CALC_K256 (k, 0, 0x9A, 0x4A, 0x92, 0xD3);
676       CALC_K256 (k, 2, 0x80, 0xE6, 0x78, 0x6B);
677       CALC_K256 (k, 4, 0xE4, 0x45, 0xDD, 0x7D);
678       CALC_K256 (k, 6, 0xD1, 0xE8, 0x38, 0x4B);
679       CALC_K256 (k, 8, 0x0D, 0xD6, 0xC6, 0x32);
680       CALC_K256 (k, 10, 0x35, 0xD8, 0x98, 0xFD);
681       CALC_K256 (k, 12, 0x18, 0x37, 0xF7, 0x71);
682       CALC_K256 (k, 14, 0xEC, 0xF1, 0x6C, 0xE1);
683       CALC_K256 (k, 16, 0x43, 0x30, 0x75, 0x0F);
684       CALC_K256 (k, 18, 0x37, 0xF8, 0x26, 0x1B);
685       CALC_K256 (k, 20, 0xFA, 0x87, 0x13, 0xFA);
686       CALC_K256 (k, 22, 0x94, 0x06, 0x48, 0x3F);
687       CALC_K256 (k, 24, 0xF2, 0x5E, 0xD0, 0xBA);
688       CALC_K256 (k, 26, 0x8B, 0xAE, 0x30, 0x5B);
689       CALC_K256 (k, 28, 0x84, 0x8A, 0x54, 0x00);
690       CALC_K256 (k, 30, 0xDF, 0xBC, 0x23, 0x9D);
691     }
692   else
693     {
694       /* Compute the S-boxes. */
695       for(i=j=0,k=1; i < 256; i++, j += 2, k += 2 )
696         {
697           CALC_SB_2( i, calc_sb_tbl[j], calc_sb_tbl[k] );
698         }
699
700       /* Calculate whitening and round subkeys.  The constants are
701        * indices of subkeys, preprocessed through q0 and q1. */
702       CALC_K (w, 0, 0xA9, 0x75, 0x67, 0xF3);
703       CALC_K (w, 2, 0xB3, 0xC6, 0xE8, 0xF4);
704       CALC_K (w, 4, 0x04, 0xDB, 0xFD, 0x7B);
705       CALC_K (w, 6, 0xA3, 0xFB, 0x76, 0xC8);
706       CALC_K (k, 0, 0x9A, 0x4A, 0x92, 0xD3);
707       CALC_K (k, 2, 0x80, 0xE6, 0x78, 0x6B);
708       CALC_K (k, 4, 0xE4, 0x45, 0xDD, 0x7D);
709       CALC_K (k, 6, 0xD1, 0xE8, 0x38, 0x4B);
710       CALC_K (k, 8, 0x0D, 0xD6, 0xC6, 0x32);
711       CALC_K (k, 10, 0x35, 0xD8, 0x98, 0xFD);
712       CALC_K (k, 12, 0x18, 0x37, 0xF7, 0x71);
713       CALC_K (k, 14, 0xEC, 0xF1, 0x6C, 0xE1);
714       CALC_K (k, 16, 0x43, 0x30, 0x75, 0x0F);
715       CALC_K (k, 18, 0x37, 0xF8, 0x26, 0x1B);
716       CALC_K (k, 20, 0xFA, 0x87, 0x13, 0xFA);
717       CALC_K (k, 22, 0x94, 0x06, 0x48, 0x3F);
718       CALC_K (k, 24, 0xF2, 0x5E, 0xD0, 0xBA);
719       CALC_K (k, 26, 0x8B, 0xAE, 0x30, 0x5B);
720       CALC_K (k, 28, 0x84, 0x8A, 0x54, 0x00);
721       CALC_K (k, 30, 0xDF, 0xBC, 0x23, 0x9D);
722     }
723
724   return 0;
725 }
726
727 static gcry_err_code_t
728 twofish_setkey (void *context, const byte *key, unsigned int keylen)
729 {
730   TWOFISH_context *ctx = context;
731   int rc = do_twofish_setkey (ctx, key, keylen);
732   _gcry_burn_stack (23+6*sizeof(void*));
733   return rc;
734 }
735
736
737 \f
738 #ifdef USE_AMD64_ASM
739
740 /* Assembly implementations of Twofish. */
741 extern void _gcry_twofish_amd64_encrypt_block(const TWOFISH_context *c,
742                                               byte *out, const byte *in);
743
744 extern void _gcry_twofish_amd64_decrypt_block(const TWOFISH_context *c,
745                                               byte *out, const byte *in);
746
747 /* These assembly implementations process three blocks in parallel. */
748 extern void _gcry_twofish_amd64_ctr_enc(const TWOFISH_context *c, byte *out,
749                                         const byte *in, byte *ctr);
750
751 extern void _gcry_twofish_amd64_cbc_dec(const TWOFISH_context *c, byte *out,
752                                         const byte *in, byte *iv);
753
754 extern void _gcry_twofish_amd64_cfb_dec(const TWOFISH_context *c, byte *out,
755                                         const byte *in, byte *iv);
756
757 #elif defined(USE_ARM_ASM)
758
759 /* Assembly implementations of Twofish. */
760 extern void _gcry_twofish_arm_encrypt_block(const TWOFISH_context *c,
761                                               byte *out, const byte *in);
762
763 extern void _gcry_twofish_arm_decrypt_block(const TWOFISH_context *c,
764                                               byte *out, const byte *in);
765
766 #else /*!USE_AMD64_ASM && !USE_ARM_ASM*/
767
768 /* Macros to compute the g() function in the encryption and decryption
769  * rounds.  G1 is the straight g() function; G2 includes the 8-bit
770  * rotation for the high 32-bit word. */
771
772 #define G1(a) \
773      (ctx->s[0][(a) & 0xFF]) ^ (ctx->s[1][((a) >> 8) & 0xFF]) \
774    ^ (ctx->s[2][((a) >> 16) & 0xFF]) ^ (ctx->s[3][(a) >> 24])
775
776 #define G2(b) \
777      (ctx->s[1][(b) & 0xFF]) ^ (ctx->s[2][((b) >> 8) & 0xFF]) \
778    ^ (ctx->s[3][((b) >> 16) & 0xFF]) ^ (ctx->s[0][(b) >> 24])
779
780 /* Encryption and decryption Feistel rounds.  Each one calls the two g()
781  * macros, does the PHT, and performs the XOR and the appropriate bit
782  * rotations.  The parameters are the round number (used to select subkeys),
783  * and the four 32-bit chunks of the text. */
784
785 #define ENCROUND(n, a, b, c, d) \
786    x = G1 (a); y = G2 (b); \
787    x += y; y += x + ctx->k[2 * (n) + 1]; \
788    (c) ^= x + ctx->k[2 * (n)]; \
789    (c) = ((c) >> 1) + ((c) << 31); \
790    (d) = (((d) << 1)+((d) >> 31)) ^ y
791
792 #define DECROUND(n, a, b, c, d) \
793    x = G1 (a); y = G2 (b); \
794    x += y; y += x; \
795    (d) ^= y + ctx->k[2 * (n) + 1]; \
796    (d) = ((d) >> 1) + ((d) << 31); \
797    (c) = (((c) << 1)+((c) >> 31)); \
798    (c) ^= (x + ctx->k[2 * (n)])
799
800 /* Encryption and decryption cycles; each one is simply two Feistel rounds
801  * with the 32-bit chunks re-ordered to simulate the "swap" */
802
803 #define ENCCYCLE(n) \
804    ENCROUND (2 * (n), a, b, c, d); \
805    ENCROUND (2 * (n) + 1, c, d, a, b)
806
807 #define DECCYCLE(n) \
808    DECROUND (2 * (n) + 1, c, d, a, b); \
809    DECROUND (2 * (n), a, b, c, d)
810
811 /* Macros to convert the input and output bytes into 32-bit words,
812  * and simultaneously perform the whitening step.  INPACK packs word
813  * number n into the variable named by x, using whitening subkey number m.
814  * OUTUNPACK unpacks word number n from the variable named by x, using
815  * whitening subkey number m. */
816
817 #define INPACK(n, x, m) \
818    x = buf_get_le32(in + (n) * 4); \
819    x ^= ctx->w[m]
820
821 #define OUTUNPACK(n, x, m) \
822    x ^= ctx->w[m]; \
823    buf_put_le32(out + (n) * 4, x)
824
825 #endif /*!USE_AMD64_ASM*/
826
827 \f
828 /* Encrypt one block.  in and out may be the same. */
829
830 #ifdef USE_AMD64_ASM
831
832 static unsigned int
833 twofish_encrypt (void *context, byte *out, const byte *in)
834 {
835   TWOFISH_context *ctx = context;
836   _gcry_twofish_amd64_encrypt_block(ctx, out, in);
837   return /*burn_stack*/ (4*sizeof (void*));
838 }
839
840 #elif defined(USE_ARM_ASM)
841
842 static unsigned int
843 twofish_encrypt (void *context, byte *out, const byte *in)
844 {
845   TWOFISH_context *ctx = context;
846   _gcry_twofish_arm_encrypt_block(ctx, out, in);
847   return /*burn_stack*/ (4*sizeof (void*));
848 }
849
850 #else /*!USE_AMD64_ASM && !USE_ARM_ASM*/
851
852 static void
853 do_twofish_encrypt (const TWOFISH_context *ctx, byte *out, const byte *in)
854 {
855   /* The four 32-bit chunks of the text. */
856   u32 a, b, c, d;
857
858   /* Temporaries used by the round function. */
859   u32 x, y;
860
861   /* Input whitening and packing. */
862   INPACK (0, a, 0);
863   INPACK (1, b, 1);
864   INPACK (2, c, 2);
865   INPACK (3, d, 3);
866
867   /* Encryption Feistel cycles. */
868   ENCCYCLE (0);
869   ENCCYCLE (1);
870   ENCCYCLE (2);
871   ENCCYCLE (3);
872   ENCCYCLE (4);
873   ENCCYCLE (5);
874   ENCCYCLE (6);
875   ENCCYCLE (7);
876
877   /* Output whitening and unpacking. */
878   OUTUNPACK (0, c, 4);
879   OUTUNPACK (1, d, 5);
880   OUTUNPACK (2, a, 6);
881   OUTUNPACK (3, b, 7);
882 }
883
884 static unsigned int
885 twofish_encrypt (void *context, byte *out, const byte *in)
886 {
887   TWOFISH_context *ctx = context;
888   do_twofish_encrypt (ctx, out, in);
889   return /*burn_stack*/ (24+3*sizeof (void*));
890 }
891
892 #endif /*!USE_AMD64_ASM && !USE_ARM_ASM*/
893
894 \f
895 /* Decrypt one block.  in and out may be the same. */
896
897 #ifdef USE_AMD64_ASM
898
899 static unsigned int
900 twofish_decrypt (void *context, byte *out, const byte *in)
901 {
902   TWOFISH_context *ctx = context;
903   _gcry_twofish_amd64_decrypt_block(ctx, out, in);
904   return /*burn_stack*/ (4*sizeof (void*));
905 }
906
907 #elif defined(USE_ARM_ASM)
908
909 static unsigned int
910 twofish_decrypt (void *context, byte *out, const byte *in)
911 {
912   TWOFISH_context *ctx = context;
913   _gcry_twofish_arm_decrypt_block(ctx, out, in);
914   return /*burn_stack*/ (4*sizeof (void*));
915 }
916
917 #else /*!USE_AMD64_ASM && !USE_ARM_ASM*/
918
919 static void
920 do_twofish_decrypt (const TWOFISH_context *ctx, byte *out, const byte *in)
921 {
922   /* The four 32-bit chunks of the text. */
923   u32 a, b, c, d;
924
925   /* Temporaries used by the round function. */
926   u32 x, y;
927
928   /* Input whitening and packing. */
929   INPACK (0, c, 4);
930   INPACK (1, d, 5);
931   INPACK (2, a, 6);
932   INPACK (3, b, 7);
933
934   /* Encryption Feistel cycles. */
935   DECCYCLE (7);
936   DECCYCLE (6);
937   DECCYCLE (5);
938   DECCYCLE (4);
939   DECCYCLE (3);
940   DECCYCLE (2);
941   DECCYCLE (1);
942   DECCYCLE (0);
943
944   /* Output whitening and unpacking. */
945   OUTUNPACK (0, a, 0);
946   OUTUNPACK (1, b, 1);
947   OUTUNPACK (2, c, 2);
948   OUTUNPACK (3, d, 3);
949 }
950
951 static unsigned int
952 twofish_decrypt (void *context, byte *out, const byte *in)
953 {
954   TWOFISH_context *ctx = context;
955
956   do_twofish_decrypt (ctx, out, in);
957   return /*burn_stack*/ (24+3*sizeof (void*));
958 }
959
960 #endif /*!USE_AMD64_ASM && !USE_ARM_ASM*/
961
962 \f
963
964 /* Bulk encryption of complete blocks in CTR mode.  This function is only
965    intended for the bulk encryption feature of cipher.c.  CTR is expected to be
966    of size TWOFISH_BLOCKSIZE. */
967 void
968 _gcry_twofish_ctr_enc(void *context, unsigned char *ctr, void *outbuf_arg,
969                       const void *inbuf_arg, size_t nblocks)
970 {
971   TWOFISH_context *ctx = context;
972   unsigned char *outbuf = outbuf_arg;
973   const unsigned char *inbuf = inbuf_arg;
974   unsigned char tmpbuf[TWOFISH_BLOCKSIZE];
975   unsigned int burn, burn_stack_depth = 0;
976   int i;
977
978 #ifdef USE_AMD64_ASM
979   {
980     /* Process data in 3 block chunks. */
981     while (nblocks >= 3)
982       {
983         _gcry_twofish_amd64_ctr_enc(ctx, outbuf, inbuf, ctr);
984
985         nblocks -= 3;
986         outbuf += 3 * TWOFISH_BLOCKSIZE;
987         inbuf += 3 * TWOFISH_BLOCKSIZE;
988
989         burn = 8 * sizeof(void*);
990         if (burn > burn_stack_depth)
991           burn_stack_depth = burn;
992       }
993
994     /* Use generic code to handle smaller chunks... */
995     /* TODO: use caching instead? */
996   }
997 #endif
998
999   for ( ;nblocks; nblocks-- )
1000     {
1001       /* Encrypt the counter. */
1002       burn = twofish_encrypt(ctx, tmpbuf, ctr);
1003       if (burn > burn_stack_depth)
1004         burn_stack_depth = burn;
1005
1006       /* XOR the input with the encrypted counter and store in output.  */
1007       buf_xor(outbuf, tmpbuf, inbuf, TWOFISH_BLOCKSIZE);
1008       outbuf += TWOFISH_BLOCKSIZE;
1009       inbuf  += TWOFISH_BLOCKSIZE;
1010       /* Increment the counter.  */
1011       for (i = TWOFISH_BLOCKSIZE; i > 0; i--)
1012         {
1013           ctr[i-1]++;
1014           if (ctr[i-1])
1015             break;
1016         }
1017     }
1018
1019   wipememory(tmpbuf, sizeof(tmpbuf));
1020   _gcry_burn_stack(burn_stack_depth);
1021 }
1022
1023
1024 /* Bulk decryption of complete blocks in CBC mode.  This function is only
1025    intended for the bulk encryption feature of cipher.c. */
1026 void
1027 _gcry_twofish_cbc_dec(void *context, unsigned char *iv, void *outbuf_arg,
1028                       const void *inbuf_arg, size_t nblocks)
1029 {
1030   TWOFISH_context *ctx = context;
1031   unsigned char *outbuf = outbuf_arg;
1032   const unsigned char *inbuf = inbuf_arg;
1033   unsigned char savebuf[TWOFISH_BLOCKSIZE];
1034   unsigned int burn, burn_stack_depth = 0;
1035
1036 #ifdef USE_AMD64_ASM
1037   {
1038     /* Process data in 3 block chunks. */
1039     while (nblocks >= 3)
1040       {
1041         _gcry_twofish_amd64_cbc_dec(ctx, outbuf, inbuf, iv);
1042
1043         nblocks -= 3;
1044         outbuf += 3 * TWOFISH_BLOCKSIZE;
1045         inbuf += 3 * TWOFISH_BLOCKSIZE;
1046
1047         burn = 9 * sizeof(void*);
1048         if (burn > burn_stack_depth)
1049           burn_stack_depth = burn;
1050       }
1051
1052     /* Use generic code to handle smaller chunks... */
1053   }
1054 #endif
1055
1056   for ( ;nblocks; nblocks-- )
1057     {
1058       /* INBUF is needed later and it may be identical to OUTBUF, so store
1059          the intermediate result to SAVEBUF.  */
1060       burn = twofish_decrypt (ctx, savebuf, inbuf);
1061       if (burn > burn_stack_depth)
1062         burn_stack_depth = burn;
1063
1064       buf_xor_n_copy_2(outbuf, savebuf, iv, inbuf, TWOFISH_BLOCKSIZE);
1065       inbuf += TWOFISH_BLOCKSIZE;
1066       outbuf += TWOFISH_BLOCKSIZE;
1067     }
1068
1069   wipememory(savebuf, sizeof(savebuf));
1070   _gcry_burn_stack(burn_stack_depth);
1071 }
1072
1073
1074 /* Bulk decryption of complete blocks in CFB mode.  This function is only
1075    intended for the bulk encryption feature of cipher.c. */
1076 void
1077 _gcry_twofish_cfb_dec(void *context, unsigned char *iv, void *outbuf_arg,
1078                     const void *inbuf_arg, size_t nblocks)
1079 {
1080   TWOFISH_context *ctx = context;
1081   unsigned char *outbuf = outbuf_arg;
1082   const unsigned char *inbuf = inbuf_arg;
1083   unsigned int burn, burn_stack_depth = 0;
1084
1085 #ifdef USE_AMD64_ASM
1086   {
1087     /* Process data in 3 block chunks. */
1088     while (nblocks >= 3)
1089       {
1090         _gcry_twofish_amd64_cfb_dec(ctx, outbuf, inbuf, iv);
1091
1092         nblocks -= 3;
1093         outbuf += 3 * TWOFISH_BLOCKSIZE;
1094         inbuf += 3 * TWOFISH_BLOCKSIZE;
1095
1096         burn = 8 * sizeof(void*);
1097         if (burn > burn_stack_depth)
1098           burn_stack_depth = burn;
1099       }
1100
1101     /* Use generic code to handle smaller chunks... */
1102   }
1103 #endif
1104
1105   for ( ;nblocks; nblocks-- )
1106     {
1107       burn = twofish_encrypt(ctx, iv, iv);
1108       if (burn > burn_stack_depth)
1109         burn_stack_depth = burn;
1110
1111       buf_xor_n_copy(outbuf, iv, inbuf, TWOFISH_BLOCKSIZE);
1112       outbuf += TWOFISH_BLOCKSIZE;
1113       inbuf += TWOFISH_BLOCKSIZE;
1114     }
1115
1116   _gcry_burn_stack(burn_stack_depth);
1117 }
1118
1119 \f
1120
1121 /* Run the self-tests for TWOFISH-CTR, tests IV increment of bulk CTR
1122    encryption.  Returns NULL on success. */
1123 static const char *
1124 selftest_ctr (void)
1125 {
1126   const int nblocks = 3+1;
1127   const int blocksize = TWOFISH_BLOCKSIZE;
1128   const int context_size = sizeof(TWOFISH_context);
1129
1130   return _gcry_selftest_helper_ctr("TWOFISH", &twofish_setkey,
1131            &twofish_encrypt, &_gcry_twofish_ctr_enc, nblocks, blocksize,
1132            context_size);
1133 }
1134
1135 /* Run the self-tests for TWOFISH-CBC, tests bulk CBC decryption.
1136    Returns NULL on success. */
1137 static const char *
1138 selftest_cbc (void)
1139 {
1140   const int nblocks = 3+2;
1141   const int blocksize = TWOFISH_BLOCKSIZE;
1142   const int context_size = sizeof(TWOFISH_context);
1143
1144   return _gcry_selftest_helper_cbc("TWOFISH", &twofish_setkey,
1145            &twofish_encrypt, &_gcry_twofish_cbc_dec, nblocks, blocksize,
1146            context_size);
1147 }
1148
1149 /* Run the self-tests for TWOFISH-CFB, tests bulk CBC decryption.
1150    Returns NULL on success. */
1151 static const char *
1152 selftest_cfb (void)
1153 {
1154   const int nblocks = 3+2;
1155   const int blocksize = TWOFISH_BLOCKSIZE;
1156   const int context_size = sizeof(TWOFISH_context);
1157
1158   return _gcry_selftest_helper_cfb("TWOFISH", &twofish_setkey,
1159            &twofish_encrypt, &_gcry_twofish_cfb_dec, nblocks, blocksize,
1160            context_size);
1161 }
1162
1163 \f
1164 /* Test a single encryption and decryption with each key size. */
1165
1166 static const char*
1167 selftest (void)
1168 {
1169   TWOFISH_context ctx; /* Expanded key. */
1170   byte scratch[16];     /* Encryption/decryption result buffer. */
1171   const char *r;
1172
1173   /* Test vectors for single encryption/decryption.  Note that I am using
1174    * the vectors from the Twofish paper's "known answer test", I=3 for
1175    * 128-bit and I=4 for 256-bit, instead of the all-0 vectors from the
1176    * "intermediate value test", because an all-0 key would trigger all the
1177    * special cases in the RS matrix multiply, leaving the math untested. */
1178   static  byte plaintext[16] = {
1179     0xD4, 0x91, 0xDB, 0x16, 0xE7, 0xB1, 0xC3, 0x9E,
1180     0x86, 0xCB, 0x08, 0x6B, 0x78, 0x9F, 0x54, 0x19
1181   };
1182   static byte key[16] = {
1183     0x9F, 0x58, 0x9F, 0x5C, 0xF6, 0x12, 0x2C, 0x32,
1184     0xB6, 0xBF, 0xEC, 0x2F, 0x2A, 0xE8, 0xC3, 0x5A
1185   };
1186   static const byte ciphertext[16] = {
1187     0x01, 0x9F, 0x98, 0x09, 0xDE, 0x17, 0x11, 0x85,
1188     0x8F, 0xAA, 0xC3, 0xA3, 0xBA, 0x20, 0xFB, 0xC3
1189   };
1190   static byte plaintext_256[16] = {
1191     0x90, 0xAF, 0xE9, 0x1B, 0xB2, 0x88, 0x54, 0x4F,
1192     0x2C, 0x32, 0xDC, 0x23, 0x9B, 0x26, 0x35, 0xE6
1193   };
1194   static byte key_256[32] = {
1195     0xD4, 0x3B, 0xB7, 0x55, 0x6E, 0xA3, 0x2E, 0x46,
1196     0xF2, 0xA2, 0x82, 0xB7, 0xD4, 0x5B, 0x4E, 0x0D,
1197     0x57, 0xFF, 0x73, 0x9D, 0x4D, 0xC9, 0x2C, 0x1B,
1198     0xD7, 0xFC, 0x01, 0x70, 0x0C, 0xC8, 0x21, 0x6F
1199   };
1200   static const byte ciphertext_256[16] = {
1201     0x6C, 0xB4, 0x56, 0x1C, 0x40, 0xBF, 0x0A, 0x97,
1202     0x05, 0x93, 0x1C, 0xB6, 0xD4, 0x08, 0xE7, 0xFA
1203   };
1204
1205   twofish_setkey (&ctx, key, sizeof(key));
1206   twofish_encrypt (&ctx, scratch, plaintext);
1207   if (memcmp (scratch, ciphertext, sizeof (ciphertext)))
1208     return "Twofish-128 test encryption failed.";
1209   twofish_decrypt (&ctx, scratch, scratch);
1210   if (memcmp (scratch, plaintext, sizeof (plaintext)))
1211     return "Twofish-128 test decryption failed.";
1212
1213   twofish_setkey (&ctx, key_256, sizeof(key_256));
1214   twofish_encrypt (&ctx, scratch, plaintext_256);
1215   if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
1216     return "Twofish-256 test encryption failed.";
1217   twofish_decrypt (&ctx, scratch, scratch);
1218   if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
1219     return "Twofish-256 test decryption failed.";
1220
1221   if ((r = selftest_ctr()) != NULL)
1222     return r;
1223   if ((r = selftest_cbc()) != NULL)
1224     return r;
1225   if ((r = selftest_cfb()) != NULL)
1226     return r;
1227
1228   return NULL;
1229 }
1230 \f
1231 /* More complete test program.  This does 1000 encryptions and decryptions
1232  * with each of 250 128-bit keys and 2000 encryptions and decryptions with
1233  * each of 125 256-bit keys, using a feedback scheme similar to a Feistel
1234  * cipher, so as to be sure of testing all the table entries pretty
1235  * thoroughly.  We keep changing the keys so as to get a more meaningful
1236  * performance number, since the key setup is non-trivial for Twofish. */
1237
1238 #ifdef TEST
1239
1240 #include <stdio.h>
1241 #include <string.h>
1242 #include <time.h>
1243
1244 int
1245 main()
1246 {
1247   TWOFISH_context ctx;     /* Expanded key. */
1248   int i, j;                 /* Loop counters. */
1249
1250   const char *encrypt_msg; /* Message to print regarding encryption test;
1251                             * the printf is done outside the loop to avoid
1252                             * stuffing up the timing. */
1253   clock_t timer; /* For computing elapsed time. */
1254
1255   /* Test buffer. */
1256   byte buffer[4][16] = {
1257     {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1258      0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF},
1259     {0x0F, 0x1E, 0x2D, 0x3C, 0x4B, 0x5A, 0x69, 0x78,
1260      0x87, 0x96, 0xA5, 0xB4, 0xC3, 0xD2 ,0xE1, 0xF0},
1261     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
1262      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54 ,0x32, 0x10},
1263     {0x01, 0x23, 0x45, 0x67, 0x76, 0x54 ,0x32, 0x10,
1264      0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98}
1265   };
1266
1267   /* Expected outputs for the million-operation test */
1268   static const byte test_encrypt[4][16] = {
1269     {0xC8, 0x23, 0xB8, 0xB7, 0x6B, 0xFE, 0x91, 0x13,
1270      0x2F, 0xA7, 0x5E, 0xE6, 0x94, 0x77, 0x6F, 0x6B},
1271     {0x90, 0x36, 0xD8, 0x29, 0xD5, 0x96, 0xC2, 0x8E,
1272      0xE4, 0xFF, 0x76, 0xBC, 0xE5, 0x77, 0x88, 0x27},
1273     {0xB8, 0x78, 0x69, 0xAF, 0x42, 0x8B, 0x48, 0x64,
1274      0xF7, 0xE9, 0xF3, 0x9C, 0x42, 0x18, 0x7B, 0x73},
1275     {0x7A, 0x88, 0xFB, 0xEB, 0x90, 0xA4, 0xB4, 0xA8,
1276      0x43, 0xA3, 0x1D, 0xF1, 0x26, 0xC4, 0x53, 0x57}
1277   };
1278   static const byte test_decrypt[4][16] = {
1279     {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1280      0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF},
1281     {0x0F, 0x1E, 0x2D, 0x3C, 0x4B, 0x5A, 0x69, 0x78,
1282      0x87, 0x96, 0xA5, 0xB4, 0xC3, 0xD2 ,0xE1, 0xF0},
1283     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
1284      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54 ,0x32, 0x10},
1285     {0x01, 0x23, 0x45, 0x67, 0x76, 0x54 ,0x32, 0x10,
1286      0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98}
1287   };
1288
1289   /* Start the timer ticking. */
1290   timer = clock ();
1291
1292   /* Encryption test. */
1293   for (i = 0; i < 125; i++)
1294     {
1295       twofish_setkey (&ctx, buffer[0], sizeof (buffer[0]));
1296       for (j = 0; j < 1000; j++)
1297         twofish_encrypt (&ctx, buffer[2], buffer[2]);
1298       twofish_setkey (&ctx, buffer[1], sizeof (buffer[1]));
1299       for (j = 0; j < 1000; j++)
1300         twofish_encrypt (&ctx, buffer[3], buffer[3]);
1301       twofish_setkey (&ctx, buffer[2], sizeof (buffer[2])*2);
1302       for (j = 0; j < 1000; j++) {
1303         twofish_encrypt (&ctx, buffer[0], buffer[0]);
1304         twofish_encrypt (&ctx, buffer[1], buffer[1]);
1305       }
1306     }
1307   encrypt_msg = memcmp (buffer, test_encrypt, sizeof (test_encrypt)) ?
1308     "encryption failure!\n" : "encryption OK!\n";
1309
1310   /* Decryption test. */
1311   for (i = 0; i < 125; i++)
1312     {
1313       twofish_setkey (&ctx, buffer[2], sizeof (buffer[2])*2);
1314       for (j = 0; j < 1000; j++) {
1315         twofish_decrypt (&ctx, buffer[0], buffer[0]);
1316         twofish_decrypt (&ctx, buffer[1], buffer[1]);
1317       }
1318       twofish_setkey (&ctx, buffer[1], sizeof (buffer[1]));
1319       for (j = 0; j < 1000; j++)
1320         twofish_decrypt (&ctx, buffer[3], buffer[3]);
1321       twofish_setkey (&ctx, buffer[0], sizeof (buffer[0]));
1322       for (j = 0; j < 1000; j++)
1323         twofish_decrypt (&ctx, buffer[2], buffer[2]);
1324     }
1325
1326   /* Stop the timer, and print results. */
1327   timer = clock () - timer;
1328   printf (encrypt_msg);
1329   printf (memcmp (buffer, test_decrypt, sizeof (test_decrypt)) ?
1330           "decryption failure!\n" : "decryption OK!\n");
1331   printf ("elapsed time: %.1f s.\n", (float) timer / CLOCKS_PER_SEC);
1332
1333   return 0;
1334 }
1335
1336 #endif /* TEST */
1337
1338 \f
1339
1340 gcry_cipher_spec_t _gcry_cipher_spec_twofish =
1341   {
1342     GCRY_CIPHER_TWOFISH, {0, 0},
1343     "TWOFISH", NULL, NULL, 16, 256, sizeof (TWOFISH_context),
1344     twofish_setkey, twofish_encrypt, twofish_decrypt
1345   };
1346
1347 gcry_cipher_spec_t _gcry_cipher_spec_twofish128 =
1348   {
1349     GCRY_CIPHER_TWOFISH128, {0, 0},
1350     "TWOFISH128", NULL, NULL, 16, 128, sizeof (TWOFISH_context),
1351     twofish_setkey, twofish_encrypt, twofish_decrypt
1352   };