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