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