Add bulk OCB for Twofish AMD64 implementation
[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 byte poly_to_exp[255] = {
360    0x00, 0x01, 0x17, 0x02, 0x2E, 0x18, 0x53, 0x03, 0x6A, 0x2F, 0x93, 0x19,
361    0x34, 0x54, 0x45, 0x04, 0x5C, 0x6B, 0xB6, 0x30, 0xA6, 0x94, 0x4B, 0x1A,
362    0x8C, 0x35, 0x81, 0x55, 0xAA, 0x46, 0x0D, 0x05, 0x24, 0x5D, 0x87, 0x6C,
363    0x9B, 0xB7, 0xC1, 0x31, 0x2B, 0xA7, 0xA3, 0x95, 0x98, 0x4C, 0xCA, 0x1B,
364    0xE6, 0x8D, 0x73, 0x36, 0xCD, 0x82, 0x12, 0x56, 0x62, 0xAB, 0xF0, 0x47,
365    0x4F, 0x0E, 0xBD, 0x06, 0xD4, 0x25, 0xD2, 0x5E, 0x27, 0x88, 0x66, 0x6D,
366    0xD6, 0x9C, 0x79, 0xB8, 0x08, 0xC2, 0xDF, 0x32, 0x68, 0x2C, 0xFD, 0xA8,
367    0x8A, 0xA4, 0x5A, 0x96, 0x29, 0x99, 0x22, 0x4D, 0x60, 0xCB, 0xE4, 0x1C,
368    0x7B, 0xE7, 0x3B, 0x8E, 0x9E, 0x74, 0xF4, 0x37, 0xD8, 0xCE, 0xF9, 0x83,
369    0x6F, 0x13, 0xB2, 0x57, 0xE1, 0x63, 0xDC, 0xAC, 0xC4, 0xF1, 0xAF, 0x48,
370    0x0A, 0x50, 0x42, 0x0F, 0xBA, 0xBE, 0xC7, 0x07, 0xDE, 0xD5, 0x78, 0x26,
371    0x65, 0xD3, 0xD1, 0x5F, 0xE3, 0x28, 0x21, 0x89, 0x59, 0x67, 0xFC, 0x6E,
372    0xB1, 0xD7, 0xF8, 0x9D, 0xF3, 0x7A, 0x3A, 0xB9, 0xC6, 0x09, 0x41, 0xC3,
373    0xAE, 0xE0, 0xDB, 0x33, 0x44, 0x69, 0x92, 0x2D, 0x52, 0xFE, 0x16, 0xA9,
374    0x0C, 0x8B, 0x80, 0xA5, 0x4A, 0x5B, 0xB5, 0x97, 0xC9, 0x2A, 0xA2, 0x9A,
375    0xC0, 0x23, 0x86, 0x4E, 0xBC, 0x61, 0xEF, 0xCC, 0x11, 0xE5, 0x72, 0x1D,
376    0x3D, 0x7C, 0xEB, 0xE8, 0xE9, 0x3C, 0xEA, 0x8F, 0x7D, 0x9F, 0xEC, 0x75,
377    0x1E, 0xF5, 0x3E, 0x38, 0xF6, 0xD9, 0x3F, 0xCF, 0x76, 0xFA, 0x1F, 0x84,
378    0xA0, 0x70, 0xED, 0x14, 0x90, 0xB3, 0x7E, 0x58, 0xFB, 0xE2, 0x20, 0x64,
379    0xD0, 0xDD, 0x77, 0xAD, 0xDA, 0xC5, 0x40, 0xF2, 0x39, 0xB0, 0xF7, 0x49,
380    0xB4, 0x0B, 0x7F, 0x51, 0x15, 0x43, 0x91, 0x10, 0x71, 0xBB, 0xEE, 0xBF,
381    0x85, 0xC8, 0xA1
382 };
383
384 static const byte exp_to_poly[492] = {
385    0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x4D, 0x9A, 0x79, 0xF2,
386    0xA9, 0x1F, 0x3E, 0x7C, 0xF8, 0xBD, 0x37, 0x6E, 0xDC, 0xF5, 0xA7, 0x03,
387    0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0xCD, 0xD7, 0xE3, 0x8B, 0x5B, 0xB6,
388    0x21, 0x42, 0x84, 0x45, 0x8A, 0x59, 0xB2, 0x29, 0x52, 0xA4, 0x05, 0x0A,
389    0x14, 0x28, 0x50, 0xA0, 0x0D, 0x1A, 0x34, 0x68, 0xD0, 0xED, 0x97, 0x63,
390    0xC6, 0xC1, 0xCF, 0xD3, 0xEB, 0x9B, 0x7B, 0xF6, 0xA1, 0x0F, 0x1E, 0x3C,
391    0x78, 0xF0, 0xAD, 0x17, 0x2E, 0x5C, 0xB8, 0x3D, 0x7A, 0xF4, 0xA5, 0x07,
392    0x0E, 0x1C, 0x38, 0x70, 0xE0, 0x8D, 0x57, 0xAE, 0x11, 0x22, 0x44, 0x88,
393    0x5D, 0xBA, 0x39, 0x72, 0xE4, 0x85, 0x47, 0x8E, 0x51, 0xA2, 0x09, 0x12,
394    0x24, 0x48, 0x90, 0x6D, 0xDA, 0xF9, 0xBF, 0x33, 0x66, 0xCC, 0xD5, 0xE7,
395    0x83, 0x4B, 0x96, 0x61, 0xC2, 0xC9, 0xDF, 0xF3, 0xAB, 0x1B, 0x36, 0x6C,
396    0xD8, 0xFD, 0xB7, 0x23, 0x46, 0x8C, 0x55, 0xAA, 0x19, 0x32, 0x64, 0xC8,
397    0xDD, 0xF7, 0xA3, 0x0B, 0x16, 0x2C, 0x58, 0xB0, 0x2D, 0x5A, 0xB4, 0x25,
398    0x4A, 0x94, 0x65, 0xCA, 0xD9, 0xFF, 0xB3, 0x2B, 0x56, 0xAC, 0x15, 0x2A,
399    0x54, 0xA8, 0x1D, 0x3A, 0x74, 0xE8, 0x9D, 0x77, 0xEE, 0x91, 0x6F, 0xDE,
400    0xF1, 0xAF, 0x13, 0x26, 0x4C, 0x98, 0x7D, 0xFA, 0xB9, 0x3F, 0x7E, 0xFC,
401    0xB5, 0x27, 0x4E, 0x9C, 0x75, 0xEA, 0x99, 0x7F, 0xFE, 0xB1, 0x2F, 0x5E,
402    0xBC, 0x35, 0x6A, 0xD4, 0xE5, 0x87, 0x43, 0x86, 0x41, 0x82, 0x49, 0x92,
403    0x69, 0xD2, 0xE9, 0x9F, 0x73, 0xE6, 0x81, 0x4F, 0x9E, 0x71, 0xE2, 0x89,
404    0x5F, 0xBE, 0x31, 0x62, 0xC4, 0xC5, 0xC7, 0xC3, 0xCB, 0xDB, 0xFB, 0xBB,
405    0x3B, 0x76, 0xEC, 0x95, 0x67, 0xCE, 0xD1, 0xEF, 0x93, 0x6B, 0xD6, 0xE1,
406    0x8F, 0x53, 0xA6, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x4D,
407    0x9A, 0x79, 0xF2, 0xA9, 0x1F, 0x3E, 0x7C, 0xF8, 0xBD, 0x37, 0x6E, 0xDC,
408    0xF5, 0xA7, 0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0xCD, 0xD7, 0xE3,
409    0x8B, 0x5B, 0xB6, 0x21, 0x42, 0x84, 0x45, 0x8A, 0x59, 0xB2, 0x29, 0x52,
410    0xA4, 0x05, 0x0A, 0x14, 0x28, 0x50, 0xA0, 0x0D, 0x1A, 0x34, 0x68, 0xD0,
411    0xED, 0x97, 0x63, 0xC6, 0xC1, 0xCF, 0xD3, 0xEB, 0x9B, 0x7B, 0xF6, 0xA1,
412    0x0F, 0x1E, 0x3C, 0x78, 0xF0, 0xAD, 0x17, 0x2E, 0x5C, 0xB8, 0x3D, 0x7A,
413    0xF4, 0xA5, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0, 0x8D, 0x57, 0xAE, 0x11,
414    0x22, 0x44, 0x88, 0x5D, 0xBA, 0x39, 0x72, 0xE4, 0x85, 0x47, 0x8E, 0x51,
415    0xA2, 0x09, 0x12, 0x24, 0x48, 0x90, 0x6D, 0xDA, 0xF9, 0xBF, 0x33, 0x66,
416    0xCC, 0xD5, 0xE7, 0x83, 0x4B, 0x96, 0x61, 0xC2, 0xC9, 0xDF, 0xF3, 0xAB,
417    0x1B, 0x36, 0x6C, 0xD8, 0xFD, 0xB7, 0x23, 0x46, 0x8C, 0x55, 0xAA, 0x19,
418    0x32, 0x64, 0xC8, 0xDD, 0xF7, 0xA3, 0x0B, 0x16, 0x2C, 0x58, 0xB0, 0x2D,
419    0x5A, 0xB4, 0x25, 0x4A, 0x94, 0x65, 0xCA, 0xD9, 0xFF, 0xB3, 0x2B, 0x56,
420    0xAC, 0x15, 0x2A, 0x54, 0xA8, 0x1D, 0x3A, 0x74, 0xE8, 0x9D, 0x77, 0xEE,
421    0x91, 0x6F, 0xDE, 0xF1, 0xAF, 0x13, 0x26, 0x4C, 0x98, 0x7D, 0xFA, 0xB9,
422    0x3F, 0x7E, 0xFC, 0xB5, 0x27, 0x4E, 0x9C, 0x75, 0xEA, 0x99, 0x7F, 0xFE,
423    0xB1, 0x2F, 0x5E, 0xBC, 0x35, 0x6A, 0xD4, 0xE5, 0x87, 0x43, 0x86, 0x41,
424    0x82, 0x49, 0x92, 0x69, 0xD2, 0xE9, 0x9F, 0x73, 0xE6, 0x81, 0x4F, 0x9E,
425    0x71, 0xE2, 0x89, 0x5F, 0xBE, 0x31, 0x62, 0xC4, 0xC5, 0xC7, 0xC3, 0xCB
426 };
427 \f
428
429 /* The table constants are indices of
430  * S-box entries, preprocessed through q0 and q1. */
431 static byte calc_sb_tbl[512] = {
432     0xA9, 0x75, 0x67, 0xF3, 0xB3, 0xC6, 0xE8, 0xF4,
433     0x04, 0xDB, 0xFD, 0x7B, 0xA3, 0xFB, 0x76, 0xC8,
434     0x9A, 0x4A, 0x92, 0xD3, 0x80, 0xE6, 0x78, 0x6B,
435     0xE4, 0x45, 0xDD, 0x7D, 0xD1, 0xE8, 0x38, 0x4B,
436     0x0D, 0xD6, 0xC6, 0x32, 0x35, 0xD8, 0x98, 0xFD,
437     0x18, 0x37, 0xF7, 0x71, 0xEC, 0xF1, 0x6C, 0xE1,
438     0x43, 0x30, 0x75, 0x0F, 0x37, 0xF8, 0x26, 0x1B,
439     0xFA, 0x87, 0x13, 0xFA, 0x94, 0x06, 0x48, 0x3F,
440     0xF2, 0x5E, 0xD0, 0xBA, 0x8B, 0xAE, 0x30, 0x5B,
441     0x84, 0x8A, 0x54, 0x00, 0xDF, 0xBC, 0x23, 0x9D,
442     0x19, 0x6D, 0x5B, 0xC1, 0x3D, 0xB1, 0x59, 0x0E,
443     0xF3, 0x80, 0xAE, 0x5D, 0xA2, 0xD2, 0x82, 0xD5,
444     0x63, 0xA0, 0x01, 0x84, 0x83, 0x07, 0x2E, 0x14,
445     0xD9, 0xB5, 0x51, 0x90, 0x9B, 0x2C, 0x7C, 0xA3,
446     0xA6, 0xB2, 0xEB, 0x73, 0xA5, 0x4C, 0xBE, 0x54,
447     0x16, 0x92, 0x0C, 0x74, 0xE3, 0x36, 0x61, 0x51,
448     0xC0, 0x38, 0x8C, 0xB0, 0x3A, 0xBD, 0xF5, 0x5A,
449     0x73, 0xFC, 0x2C, 0x60, 0x25, 0x62, 0x0B, 0x96,
450     0xBB, 0x6C, 0x4E, 0x42, 0x89, 0xF7, 0x6B, 0x10,
451     0x53, 0x7C, 0x6A, 0x28, 0xB4, 0x27, 0xF1, 0x8C,
452     0xE1, 0x13, 0xE6, 0x95, 0xBD, 0x9C, 0x45, 0xC7,
453     0xE2, 0x24, 0xF4, 0x46, 0xB6, 0x3B, 0x66, 0x70,
454     0xCC, 0xCA, 0x95, 0xE3, 0x03, 0x85, 0x56, 0xCB,
455     0xD4, 0x11, 0x1C, 0xD0, 0x1E, 0x93, 0xD7, 0xB8,
456     0xFB, 0xA6, 0xC3, 0x83, 0x8E, 0x20, 0xB5, 0xFF,
457     0xE9, 0x9F, 0xCF, 0x77, 0xBF, 0xC3, 0xBA, 0xCC,
458     0xEA, 0x03, 0x77, 0x6F, 0x39, 0x08, 0xAF, 0xBF,
459     0x33, 0x40, 0xC9, 0xE7, 0x62, 0x2B, 0x71, 0xE2,
460     0x81, 0x79, 0x79, 0x0C, 0x09, 0xAA, 0xAD, 0x82,
461     0x24, 0x41, 0xCD, 0x3A, 0xF9, 0xEA, 0xD8, 0xB9,
462     0xE5, 0xE4, 0xC5, 0x9A, 0xB9, 0xA4, 0x4D, 0x97,
463     0x44, 0x7E, 0x08, 0xDA, 0x86, 0x7A, 0xE7, 0x17,
464     0xA1, 0x66, 0x1D, 0x94, 0xAA, 0xA1, 0xED, 0x1D,
465     0x06, 0x3D, 0x70, 0xF0, 0xB2, 0xDE, 0xD2, 0xB3,
466     0x41, 0x0B, 0x7B, 0x72, 0xA0, 0xA7, 0x11, 0x1C,
467     0x31, 0xEF, 0xC2, 0xD1, 0x27, 0x53, 0x90, 0x3E,
468     0x20, 0x8F, 0xF6, 0x33, 0x60, 0x26, 0xFF, 0x5F,
469     0x96, 0xEC, 0x5C, 0x76, 0xB1, 0x2A, 0xAB, 0x49,
470     0x9E, 0x81, 0x9C, 0x88, 0x52, 0xEE, 0x1B, 0x21,
471     0x5F, 0xC4, 0x93, 0x1A, 0x0A, 0xEB, 0xEF, 0xD9,
472     0x91, 0xC5, 0x85, 0x39, 0x49, 0x99, 0xEE, 0xCD,
473     0x2D, 0xAD, 0x4F, 0x31, 0x8F, 0x8B, 0x3B, 0x01,
474     0x47, 0x18, 0x87, 0x23, 0x6D, 0xDD, 0x46, 0x1F,
475     0xD6, 0x4E, 0x3E, 0x2D, 0x69, 0xF9, 0x64, 0x48,
476     0x2A, 0x4F, 0xCE, 0xF2, 0xCB, 0x65, 0x2F, 0x8E,
477     0xFC, 0x78, 0x97, 0x5C, 0x05, 0x58, 0x7A, 0x19,
478     0xAC, 0x8D, 0x7F, 0xE5, 0xD5, 0x98, 0x1A, 0x57,
479     0x4B, 0x67, 0x0E, 0x7F, 0xA7, 0x05, 0x5A, 0x64,
480     0x28, 0xAF, 0x14, 0x63, 0x3F, 0xB6, 0x29, 0xFE,
481     0x88, 0xF5, 0x3C, 0xB7, 0x4C, 0x3C, 0x02, 0xA5,
482     0xB8, 0xCE, 0xDA, 0xE9, 0xB0, 0x68, 0x17, 0x44,
483     0x55, 0xE0, 0x1F, 0x4D, 0x8A, 0x43, 0x7D, 0x69,
484     0x57, 0x29, 0xC7, 0x2E, 0x8D, 0xAC, 0x74, 0x15,
485     0xB7, 0x59, 0xC4, 0xA8, 0x9F, 0x0A, 0x72, 0x9E,
486     0x7E, 0x6E, 0x15, 0x47, 0x22, 0xDF, 0x12, 0x34,
487     0x58, 0x35, 0x07, 0x6A, 0x99, 0xCF, 0x34, 0xDC,
488     0x6E, 0x22, 0x50, 0xC9, 0xDE, 0xC0, 0x68, 0x9B,
489     0x65, 0x89, 0xBC, 0xD4, 0xDB, 0xED, 0xF8, 0xAB,
490     0xC8, 0x12, 0xA8, 0xA2, 0x2B, 0x0D, 0x40, 0x52,
491     0xDC, 0xBB, 0xFE, 0x02, 0x32, 0x2F, 0xA4, 0xA9,
492     0xCA, 0xD7, 0x10, 0x61, 0x21, 0x1E, 0xF0, 0xB4,
493     0xD3, 0x50, 0x5D, 0x04, 0x0F, 0xF6, 0x00, 0xC2,
494     0x6F, 0x16, 0x9D, 0x25, 0x36, 0x86, 0x42, 0x56,
495     0x4A, 0x55, 0x5E, 0x09, 0xC1, 0xBE, 0xE0, 0x91
496 };
497 /* Macro to perform one column of the RS matrix multiplication.  The
498  * parameters a, b, c, and d are the four bytes of output; i is the index
499  * of the key bytes, and w, x, y, and z, are the column of constants from
500  * the RS matrix, preprocessed through the poly_to_exp table. */
501
502 #define CALC_S(a, b, c, d, i, w, x, y, z) \
503    if (key[i]) { \
504       tmp = poly_to_exp[key[i] - 1]; \
505       (a) ^= exp_to_poly[tmp + (w)]; \
506       (b) ^= exp_to_poly[tmp + (x)]; \
507       (c) ^= exp_to_poly[tmp + (y)]; \
508       (d) ^= exp_to_poly[tmp + (z)]; \
509    }
510
511 /* Macros to calculate the key-dependent S-boxes for a 128-bit key using
512  * the S vector from CALC_S.  CALC_SB_2 computes a single entry in all
513  * four S-boxes, where i is the index of the entry to compute, and a and b
514  * are the index numbers preprocessed through the q0 and q1 tables
515  * respectively.  CALC_SB is simply a convenience to make the code shorter;
516  * it calls CALC_SB_2 four times with consecutive indices from i to i+3,
517  * using the remaining parameters two by two. */
518
519 #define CALC_SB_2(i, a, b) \
520    ctx->s[0][i] = mds[0][q0[(a) ^ sa] ^ se]; \
521    ctx->s[1][i] = mds[1][q0[(b) ^ sb] ^ sf]; \
522    ctx->s[2][i] = mds[2][q1[(a) ^ sc] ^ sg]; \
523    ctx->s[3][i] = mds[3][q1[(b) ^ sd] ^ sh]
524
525 #define CALC_SB(i, a, b, c, d, e, f, g, h) \
526    CALC_SB_2 (i, a, b); CALC_SB_2 ((i)+1, c, d); \
527    CALC_SB_2 ((i)+2, e, f); CALC_SB_2 ((i)+3, g, h)
528
529 /* Macros exactly like CALC_SB and CALC_SB_2, but for 256-bit keys. */
530
531 #define CALC_SB256_2(i, a, b) \
532    ctx->s[0][i] = mds[0][q0[q0[q1[(b) ^ sa] ^ se] ^ si] ^ sm]; \
533    ctx->s[1][i] = mds[1][q0[q1[q1[(a) ^ sb] ^ sf] ^ sj] ^ sn]; \
534    ctx->s[2][i] = mds[2][q1[q0[q0[(a) ^ sc] ^ sg] ^ sk] ^ so]; \
535    ctx->s[3][i] = mds[3][q1[q1[q0[(b) ^ sd] ^ sh] ^ sl] ^ sp];
536
537 #define CALC_SB256(i, a, b, c, d, e, f, g, h) \
538    CALC_SB256_2 (i, a, b); CALC_SB256_2 ((i)+1, c, d); \
539    CALC_SB256_2 ((i)+2, e, f); CALC_SB256_2 ((i)+3, g, h)
540
541 /* Macros to calculate the whitening and round subkeys.  CALC_K_2 computes the
542  * last two stages of the h() function for a given index (either 2i or 2i+1).
543  * a, b, c, and d are the four bytes going into the last two stages.  For
544  * 128-bit keys, this is the entire h() function and a and c are the index
545  * preprocessed through q0 and q1 respectively; for longer keys they are the
546  * output of previous stages.  j is the index of the first key byte to use.
547  * CALC_K computes a pair of subkeys for 128-bit Twofish, by calling CALC_K_2
548  * twice, doing the Pseudo-Hadamard Transform, and doing the necessary
549  * rotations.  Its parameters are: a, the array to write the results into,
550  * j, the index of the first output entry, k and l, the preprocessed indices
551  * for index 2i, and m and n, the preprocessed indices for index 2i+1.
552  * CALC_K256_2 expands CALC_K_2 to handle 256-bit keys, by doing two
553  * additional lookup-and-XOR stages.  The parameters a and b are the index
554  * preprocessed through q0 and q1 respectively; j is the index of the first
555  * key byte to use.  CALC_K256 is identical to CALC_K but for using the
556  * CALC_K256_2 macro instead of CALC_K_2. */
557
558 #define CALC_K_2(a, b, c, d, j) \
559      mds[0][q0[a ^ key[(j) + 8]] ^ key[j]] \
560    ^ mds[1][q0[b ^ key[(j) + 9]] ^ key[(j) + 1]] \
561    ^ mds[2][q1[c ^ key[(j) + 10]] ^ key[(j) + 2]] \
562    ^ mds[3][q1[d ^ key[(j) + 11]] ^ key[(j) + 3]]
563
564 #define CALC_K(a, j, k, l, m, n) \
565    x = CALC_K_2 (k, l, k, l, 0); \
566    y = CALC_K_2 (m, n, m, n, 4); \
567    y = (y << 8) + (y >> 24); \
568    x += y; y += x; ctx->a[j] = x; \
569    ctx->a[(j) + 1] = (y << 9) + (y >> 23)
570
571 #define CALC_K256_2(a, b, j) \
572    CALC_K_2 (q0[q1[b ^ key[(j) + 24]] ^ key[(j) + 16]], \
573              q1[q1[a ^ key[(j) + 25]] ^ key[(j) + 17]], \
574              q0[q0[a ^ key[(j) + 26]] ^ key[(j) + 18]], \
575              q1[q0[b ^ key[(j) + 27]] ^ key[(j) + 19]], j)
576
577 #define CALC_K256(a, j, k, l, m, n) \
578    x = CALC_K256_2 (k, l, 0); \
579    y = CALC_K256_2 (m, n, 4); \
580    y = (y << 8) + (y >> 24); \
581    x += y; y += x; ctx->a[j] = x; \
582    ctx->a[(j) + 1] = (y << 9) + (y >> 23)
583 \f
584
585
586 /* Perform the key setup.  Note that this works only with 128- and 256-bit
587  * keys, despite the API that looks like it might support other sizes. */
588
589 static gcry_err_code_t
590 do_twofish_setkey (TWOFISH_context *ctx, const byte *key, const unsigned keylen)
591 {
592   int i, j, k;
593
594   /* Temporaries for CALC_K. */
595   u32 x, y;
596
597   /* The S vector used to key the S-boxes, split up into individual bytes.
598    * 128-bit keys use only sa through sh; 256-bit use all of them. */
599   byte sa = 0, sb = 0, sc = 0, sd = 0, se = 0, sf = 0, sg = 0, sh = 0;
600   byte si = 0, sj = 0, sk = 0, sl = 0, sm = 0, sn = 0, so = 0, sp = 0;
601
602   /* Temporary for CALC_S. */
603   byte tmp;
604
605   /* Flags for self-test. */
606   static int initialized = 0;
607   static const char *selftest_failed=0;
608
609   /* Check key length. */
610   if( ( ( keylen - 16 ) | 16 ) != 16 )
611     return GPG_ERR_INV_KEYLEN;
612
613   /* Do self-test if necessary. */
614   if (!initialized)
615     {
616       initialized = 1;
617       selftest_failed = selftest ();
618       if( selftest_failed )
619         log_error("%s\n", selftest_failed );
620     }
621   if( selftest_failed )
622     return GPG_ERR_SELFTEST_FAILED;
623
624   /* Compute the first two words of the S vector.  The magic numbers are
625    * the entries of the RS matrix, preprocessed through poly_to_exp.    The
626    * numbers in the comments are the original (polynomial form) matrix
627    * entries. */
628   CALC_S (sa, sb, sc, sd, 0, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
629   CALC_S (sa, sb, sc, sd, 1, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
630   CALC_S (sa, sb, sc, sd, 2, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
631   CALC_S (sa, sb, sc, sd, 3, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
632   CALC_S (sa, sb, sc, sd, 4, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
633   CALC_S (sa, sb, sc, sd, 5, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
634   CALC_S (sa, sb, sc, sd, 6, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
635   CALC_S (sa, sb, sc, sd, 7, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
636   CALC_S (se, sf, sg, sh, 8, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
637   CALC_S (se, sf, sg, sh, 9, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
638   CALC_S (se, sf, sg, sh, 10, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
639   CALC_S (se, sf, sg, sh, 11, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
640   CALC_S (se, sf, sg, sh, 12, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
641   CALC_S (se, sf, sg, sh, 13, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
642   CALC_S (se, sf, sg, sh, 14, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
643   CALC_S (se, sf, sg, sh, 15, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
644
645   if (keylen == 32)  /* 256-bit key */
646     {
647       /* Calculate the remaining two words of the S vector */
648       CALC_S (si, sj, sk, sl, 16, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
649       CALC_S (si, sj, sk, sl, 17, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
650       CALC_S (si, sj, sk, sl, 18, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
651       CALC_S (si, sj, sk, sl, 19, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
652       CALC_S (si, sj, sk, sl, 20, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
653       CALC_S (si, sj, sk, sl, 21, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
654       CALC_S (si, sj, sk, sl, 22, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
655       CALC_S (si, sj, sk, sl, 23, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
656       CALC_S (sm, sn, so, sp, 24, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
657       CALC_S (sm, sn, so, sp, 25, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
658       CALC_S (sm, sn, so, sp, 26, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
659       CALC_S (sm, sn, so, sp, 27, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
660       CALC_S (sm, sn, so, sp, 28, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
661       CALC_S (sm, sn, so, sp, 29, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
662       CALC_S (sm, sn, so, sp, 30, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
663       CALC_S (sm, sn, so, sp, 31, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
664
665       /* Compute the S-boxes. */
666       for(i=j=0,k=1; i < 256; i++, j += 2, k += 2 )
667         {
668           CALC_SB256_2( i, calc_sb_tbl[j], calc_sb_tbl[k] );
669         }
670
671       /* Calculate whitening and round subkeys.  The constants are
672        * indices of subkeys, preprocessed through q0 and q1. */
673       CALC_K256 (w, 0, 0xA9, 0x75, 0x67, 0xF3);
674       CALC_K256 (w, 2, 0xB3, 0xC6, 0xE8, 0xF4);
675       CALC_K256 (w, 4, 0x04, 0xDB, 0xFD, 0x7B);
676       CALC_K256 (w, 6, 0xA3, 0xFB, 0x76, 0xC8);
677       CALC_K256 (k, 0, 0x9A, 0x4A, 0x92, 0xD3);
678       CALC_K256 (k, 2, 0x80, 0xE6, 0x78, 0x6B);
679       CALC_K256 (k, 4, 0xE4, 0x45, 0xDD, 0x7D);
680       CALC_K256 (k, 6, 0xD1, 0xE8, 0x38, 0x4B);
681       CALC_K256 (k, 8, 0x0D, 0xD6, 0xC6, 0x32);
682       CALC_K256 (k, 10, 0x35, 0xD8, 0x98, 0xFD);
683       CALC_K256 (k, 12, 0x18, 0x37, 0xF7, 0x71);
684       CALC_K256 (k, 14, 0xEC, 0xF1, 0x6C, 0xE1);
685       CALC_K256 (k, 16, 0x43, 0x30, 0x75, 0x0F);
686       CALC_K256 (k, 18, 0x37, 0xF8, 0x26, 0x1B);
687       CALC_K256 (k, 20, 0xFA, 0x87, 0x13, 0xFA);
688       CALC_K256 (k, 22, 0x94, 0x06, 0x48, 0x3F);
689       CALC_K256 (k, 24, 0xF2, 0x5E, 0xD0, 0xBA);
690       CALC_K256 (k, 26, 0x8B, 0xAE, 0x30, 0x5B);
691       CALC_K256 (k, 28, 0x84, 0x8A, 0x54, 0x00);
692       CALC_K256 (k, 30, 0xDF, 0xBC, 0x23, 0x9D);
693     }
694   else
695     {
696       /* Compute the S-boxes. */
697       for(i=j=0,k=1; i < 256; i++, j += 2, k += 2 )
698         {
699           CALC_SB_2( i, calc_sb_tbl[j], calc_sb_tbl[k] );
700         }
701
702       /* Calculate whitening and round subkeys.  The constants are
703        * indices of subkeys, preprocessed through q0 and q1. */
704       CALC_K (w, 0, 0xA9, 0x75, 0x67, 0xF3);
705       CALC_K (w, 2, 0xB3, 0xC6, 0xE8, 0xF4);
706       CALC_K (w, 4, 0x04, 0xDB, 0xFD, 0x7B);
707       CALC_K (w, 6, 0xA3, 0xFB, 0x76, 0xC8);
708       CALC_K (k, 0, 0x9A, 0x4A, 0x92, 0xD3);
709       CALC_K (k, 2, 0x80, 0xE6, 0x78, 0x6B);
710       CALC_K (k, 4, 0xE4, 0x45, 0xDD, 0x7D);
711       CALC_K (k, 6, 0xD1, 0xE8, 0x38, 0x4B);
712       CALC_K (k, 8, 0x0D, 0xD6, 0xC6, 0x32);
713       CALC_K (k, 10, 0x35, 0xD8, 0x98, 0xFD);
714       CALC_K (k, 12, 0x18, 0x37, 0xF7, 0x71);
715       CALC_K (k, 14, 0xEC, 0xF1, 0x6C, 0xE1);
716       CALC_K (k, 16, 0x43, 0x30, 0x75, 0x0F);
717       CALC_K (k, 18, 0x37, 0xF8, 0x26, 0x1B);
718       CALC_K (k, 20, 0xFA, 0x87, 0x13, 0xFA);
719       CALC_K (k, 22, 0x94, 0x06, 0x48, 0x3F);
720       CALC_K (k, 24, 0xF2, 0x5E, 0xD0, 0xBA);
721       CALC_K (k, 26, 0x8B, 0xAE, 0x30, 0x5B);
722       CALC_K (k, 28, 0x84, 0x8A, 0x54, 0x00);
723       CALC_K (k, 30, 0xDF, 0xBC, 0x23, 0x9D);
724     }
725
726   return 0;
727 }
728
729 static gcry_err_code_t
730 twofish_setkey (void *context, const byte *key, unsigned int keylen)
731 {
732   TWOFISH_context *ctx = context;
733   int rc = do_twofish_setkey (ctx, key, keylen);
734   _gcry_burn_stack (23+6*sizeof(void*));
735   return rc;
736 }
737
738
739 \f
740 #ifdef USE_AMD64_ASM
741
742 /* Assembly implementations of Twofish. */
743 extern void _gcry_twofish_amd64_encrypt_block(const TWOFISH_context *c,
744                                               byte *out, const byte *in);
745
746 extern void _gcry_twofish_amd64_decrypt_block(const TWOFISH_context *c,
747                                               byte *out, const byte *in);
748
749 /* These assembly implementations process three blocks in parallel. */
750 extern void _gcry_twofish_amd64_ctr_enc(const TWOFISH_context *c, byte *out,
751                                         const byte *in, byte *ctr);
752
753 extern void _gcry_twofish_amd64_cbc_dec(const TWOFISH_context *c, byte *out,
754                                         const byte *in, byte *iv);
755
756 extern void _gcry_twofish_amd64_cfb_dec(const TWOFISH_context *c, byte *out,
757                                         const byte *in, byte *iv);
758
759 extern void _gcry_twofish_amd64_ocb_enc(const TWOFISH_context *ctx, byte *out,
760                                         const byte *in, byte *offset,
761                                         byte *checksum, const void *Ls[3]);
762
763 extern void _gcry_twofish_amd64_ocb_dec(const TWOFISH_context *ctx, byte *out,
764                                         const byte *in, byte *offset,
765                                         byte *checksum, const void *Ls[3]);
766
767 extern void _gcry_twofish_amd64_ocb_auth(const TWOFISH_context *ctx,
768                                          const byte *abuf, byte *offset,
769                                          byte *checksum, const void *Ls[3]);
770
771 #ifdef HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS
772 static inline void
773 call_sysv_fn (const void *fn, const void *arg1, const void *arg2,
774               const void *arg3, const void *arg4)
775 {
776   /* Call SystemV ABI function without storing non-volatile XMM registers,
777    * as target function does not use vector instruction sets. */
778   asm volatile ("callq *%0\n\t"
779                 : "+a" (fn),
780                   "+D" (arg1),
781                   "+S" (arg2),
782                   "+d" (arg3),
783                   "+c" (arg4)
784                 :
785                 : "cc", "memory", "r8", "r9", "r10", "r11");
786 }
787
788 static inline void
789 call_sysv_fn5 (const void *fn, const void *arg1, const void *arg2,
790                const void *arg3, const void *arg4, const void *arg5)
791 {
792   /* Call SystemV ABI function without storing non-volatile XMM registers,
793    * as target function does not use vector instruction sets. */
794   asm volatile ("movq %[arg5], %%r8\n\t"
795                 "callq *%0\n\t"
796                 : "+a" (fn),
797                   "+D" (arg1),
798                   "+S" (arg2),
799                   "+d" (arg3),
800                   "+c" (arg4)
801                 : [arg5] "g" (arg5)
802                 : "cc", "memory", "r8", "r9", "r10", "r11");
803 }
804
805 static inline void
806 call_sysv_fn6 (const void *fn, const void *arg1, const void *arg2,
807                const void *arg3, const void *arg4, const void *arg5,
808                const void *arg6)
809 {
810   /* Call SystemV ABI function without storing non-volatile XMM registers,
811    * as target function does not use vector instruction sets. */
812   asm volatile ("movq %[arg5], %%r8\n\t"
813                 "movq %[arg6], %%r9\n\t"
814                 "callq *%0\n\t"
815                 : "+a" (fn),
816                   "+D" (arg1),
817                   "+S" (arg2),
818                   "+d" (arg3),
819                   "+c" (arg4)
820                 : [arg5] "g" (arg5),
821                   [arg6] "g" (arg6)
822                 : "cc", "memory", "r8", "r9", "r10", "r11");
823 }
824 #endif
825
826 static inline void
827 twofish_amd64_encrypt_block(const TWOFISH_context *c, byte *out, const byte *in)
828 {
829 #ifdef HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS
830   call_sysv_fn(_gcry_twofish_amd64_encrypt_block, c, out, in, NULL);
831 #else
832   _gcry_twofish_amd64_encrypt_block(c, out, in);
833 #endif
834 }
835
836 static inline void
837 twofish_amd64_decrypt_block(const TWOFISH_context *c, byte *out, const byte *in)
838 {
839 #ifdef HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS
840   call_sysv_fn(_gcry_twofish_amd64_decrypt_block, c, out, in, NULL);
841 #else
842   _gcry_twofish_amd64_decrypt_block(c, out, in);
843 #endif
844 }
845
846 static inline void
847 twofish_amd64_ctr_enc(const TWOFISH_context *c, byte *out, const byte *in,
848                       byte *ctr)
849 {
850 #ifdef HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS
851   call_sysv_fn(_gcry_twofish_amd64_ctr_enc, c, out, in, ctr);
852 #else
853   _gcry_twofish_amd64_ctr_enc(c, out, in, ctr);
854 #endif
855 }
856
857 static inline void
858 twofish_amd64_cbc_dec(const TWOFISH_context *c, byte *out, const byte *in,
859                       byte *iv)
860 {
861 #ifdef HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS
862   call_sysv_fn(_gcry_twofish_amd64_cbc_dec, c, out, in, iv);
863 #else
864   _gcry_twofish_amd64_cbc_dec(c, out, in, iv);
865 #endif
866 }
867
868 static inline void
869 twofish_amd64_cfb_dec(const TWOFISH_context *c, byte *out, const byte *in,
870                       byte *iv)
871 {
872 #ifdef HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS
873   call_sysv_fn(_gcry_twofish_amd64_cfb_dec, c, out, in, iv);
874 #else
875   _gcry_twofish_amd64_cfb_dec(c, out, in, iv);
876 #endif
877 }
878
879 static inline void
880 twofish_amd64_ocb_enc(const TWOFISH_context *ctx, byte *out, const byte *in,
881                       byte *offset, byte *checksum, const void *Ls[3])
882 {
883 #ifdef HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS
884   call_sysv_fn6(_gcry_twofish_amd64_ocb_enc, ctx, out, in, offset, checksum, Ls);
885 #else
886   _gcry_twofish_amd64_ocb_enc(ctx, out, in, offset, checksum, Ls);
887 #endif
888 }
889
890 static inline void
891 twofish_amd64_ocb_dec(const TWOFISH_context *ctx, byte *out, const byte *in,
892                       byte *offset, byte *checksum, const void *Ls[3])
893 {
894 #ifdef HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS
895   call_sysv_fn6(_gcry_twofish_amd64_ocb_dec, ctx, out, in, offset, checksum, Ls);
896 #else
897   _gcry_twofish_amd64_ocb_dec(ctx, out, in, offset, checksum, Ls);
898 #endif
899 }
900
901 static inline void
902 twofish_amd64_ocb_auth(const TWOFISH_context *ctx, const byte *abuf,
903                        byte *offset, byte *checksum, const void *Ls[3])
904 {
905 #ifdef HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS
906   call_sysv_fn5(_gcry_twofish_amd64_ocb_auth, ctx, abuf, offset, checksum, Ls);
907 #else
908   _gcry_twofish_amd64_ocb_auth(ctx, abuf, offset, checksum, Ls);
909 #endif
910 }
911
912 #elif defined(USE_ARM_ASM)
913
914 /* Assembly implementations of Twofish. */
915 extern void _gcry_twofish_arm_encrypt_block(const TWOFISH_context *c,
916                                               byte *out, const byte *in);
917
918 extern void _gcry_twofish_arm_decrypt_block(const TWOFISH_context *c,
919                                               byte *out, const byte *in);
920
921 #else /*!USE_AMD64_ASM && !USE_ARM_ASM*/
922
923 /* Macros to compute the g() function in the encryption and decryption
924  * rounds.  G1 is the straight g() function; G2 includes the 8-bit
925  * rotation for the high 32-bit word. */
926
927 #define G1(a) \
928      (ctx->s[0][(a) & 0xFF]) ^ (ctx->s[1][((a) >> 8) & 0xFF]) \
929    ^ (ctx->s[2][((a) >> 16) & 0xFF]) ^ (ctx->s[3][(a) >> 24])
930
931 #define G2(b) \
932      (ctx->s[1][(b) & 0xFF]) ^ (ctx->s[2][((b) >> 8) & 0xFF]) \
933    ^ (ctx->s[3][((b) >> 16) & 0xFF]) ^ (ctx->s[0][(b) >> 24])
934
935 /* Encryption and decryption Feistel rounds.  Each one calls the two g()
936  * macros, does the PHT, and performs the XOR and the appropriate bit
937  * rotations.  The parameters are the round number (used to select subkeys),
938  * and the four 32-bit chunks of the text. */
939
940 #define ENCROUND(n, a, b, c, d) \
941    x = G1 (a); y = G2 (b); \
942    x += y; y += x + ctx->k[2 * (n) + 1]; \
943    (c) ^= x + ctx->k[2 * (n)]; \
944    (c) = ((c) >> 1) + ((c) << 31); \
945    (d) = (((d) << 1)+((d) >> 31)) ^ y
946
947 #define DECROUND(n, a, b, c, d) \
948    x = G1 (a); y = G2 (b); \
949    x += y; y += x; \
950    (d) ^= y + ctx->k[2 * (n) + 1]; \
951    (d) = ((d) >> 1) + ((d) << 31); \
952    (c) = (((c) << 1)+((c) >> 31)); \
953    (c) ^= (x + ctx->k[2 * (n)])
954
955 /* Encryption and decryption cycles; each one is simply two Feistel rounds
956  * with the 32-bit chunks re-ordered to simulate the "swap" */
957
958 #define ENCCYCLE(n) \
959    ENCROUND (2 * (n), a, b, c, d); \
960    ENCROUND (2 * (n) + 1, c, d, a, b)
961
962 #define DECCYCLE(n) \
963    DECROUND (2 * (n) + 1, c, d, a, b); \
964    DECROUND (2 * (n), a, b, c, d)
965
966 /* Macros to convert the input and output bytes into 32-bit words,
967  * and simultaneously perform the whitening step.  INPACK packs word
968  * number n into the variable named by x, using whitening subkey number m.
969  * OUTUNPACK unpacks word number n from the variable named by x, using
970  * whitening subkey number m. */
971
972 #define INPACK(n, x, m) \
973    x = buf_get_le32(in + (n) * 4); \
974    x ^= ctx->w[m]
975
976 #define OUTUNPACK(n, x, m) \
977    x ^= ctx->w[m]; \
978    buf_put_le32(out + (n) * 4, x)
979
980 #endif /*!USE_AMD64_ASM*/
981
982 \f
983 /* Encrypt one block.  in and out may be the same. */
984
985 #ifdef USE_AMD64_ASM
986
987 static unsigned int
988 twofish_encrypt (void *context, byte *out, const byte *in)
989 {
990   TWOFISH_context *ctx = context;
991   twofish_amd64_encrypt_block(ctx, out, in);
992   return /*burn_stack*/ (4*sizeof (void*));
993 }
994
995 #elif defined(USE_ARM_ASM)
996
997 static unsigned int
998 twofish_encrypt (void *context, byte *out, const byte *in)
999 {
1000   TWOFISH_context *ctx = context;
1001   _gcry_twofish_arm_encrypt_block(ctx, out, in);
1002   return /*burn_stack*/ (4*sizeof (void*));
1003 }
1004
1005 #else /*!USE_AMD64_ASM && !USE_ARM_ASM*/
1006
1007 static void
1008 do_twofish_encrypt (const TWOFISH_context *ctx, byte *out, const byte *in)
1009 {
1010   /* The four 32-bit chunks of the text. */
1011   u32 a, b, c, d;
1012
1013   /* Temporaries used by the round function. */
1014   u32 x, y;
1015
1016   /* Input whitening and packing. */
1017   INPACK (0, a, 0);
1018   INPACK (1, b, 1);
1019   INPACK (2, c, 2);
1020   INPACK (3, d, 3);
1021
1022   /* Encryption Feistel cycles. */
1023   ENCCYCLE (0);
1024   ENCCYCLE (1);
1025   ENCCYCLE (2);
1026   ENCCYCLE (3);
1027   ENCCYCLE (4);
1028   ENCCYCLE (5);
1029   ENCCYCLE (6);
1030   ENCCYCLE (7);
1031
1032   /* Output whitening and unpacking. */
1033   OUTUNPACK (0, c, 4);
1034   OUTUNPACK (1, d, 5);
1035   OUTUNPACK (2, a, 6);
1036   OUTUNPACK (3, b, 7);
1037 }
1038
1039 static unsigned int
1040 twofish_encrypt (void *context, byte *out, const byte *in)
1041 {
1042   TWOFISH_context *ctx = context;
1043   do_twofish_encrypt (ctx, out, in);
1044   return /*burn_stack*/ (24+3*sizeof (void*));
1045 }
1046
1047 #endif /*!USE_AMD64_ASM && !USE_ARM_ASM*/
1048
1049 \f
1050 /* Decrypt one block.  in and out may be the same. */
1051
1052 #ifdef USE_AMD64_ASM
1053
1054 static unsigned int
1055 twofish_decrypt (void *context, byte *out, const byte *in)
1056 {
1057   TWOFISH_context *ctx = context;
1058   twofish_amd64_decrypt_block(ctx, out, in);
1059   return /*burn_stack*/ (4*sizeof (void*));
1060 }
1061
1062 #elif defined(USE_ARM_ASM)
1063
1064 static unsigned int
1065 twofish_decrypt (void *context, byte *out, const byte *in)
1066 {
1067   TWOFISH_context *ctx = context;
1068   _gcry_twofish_arm_decrypt_block(ctx, out, in);
1069   return /*burn_stack*/ (4*sizeof (void*));
1070 }
1071
1072 #else /*!USE_AMD64_ASM && !USE_ARM_ASM*/
1073
1074 static void
1075 do_twofish_decrypt (const TWOFISH_context *ctx, byte *out, const byte *in)
1076 {
1077   /* The four 32-bit chunks of the text. */
1078   u32 a, b, c, d;
1079
1080   /* Temporaries used by the round function. */
1081   u32 x, y;
1082
1083   /* Input whitening and packing. */
1084   INPACK (0, c, 4);
1085   INPACK (1, d, 5);
1086   INPACK (2, a, 6);
1087   INPACK (3, b, 7);
1088
1089   /* Encryption Feistel cycles. */
1090   DECCYCLE (7);
1091   DECCYCLE (6);
1092   DECCYCLE (5);
1093   DECCYCLE (4);
1094   DECCYCLE (3);
1095   DECCYCLE (2);
1096   DECCYCLE (1);
1097   DECCYCLE (0);
1098
1099   /* Output whitening and unpacking. */
1100   OUTUNPACK (0, a, 0);
1101   OUTUNPACK (1, b, 1);
1102   OUTUNPACK (2, c, 2);
1103   OUTUNPACK (3, d, 3);
1104 }
1105
1106 static unsigned int
1107 twofish_decrypt (void *context, byte *out, const byte *in)
1108 {
1109   TWOFISH_context *ctx = context;
1110
1111   do_twofish_decrypt (ctx, out, in);
1112   return /*burn_stack*/ (24+3*sizeof (void*));
1113 }
1114
1115 #endif /*!USE_AMD64_ASM && !USE_ARM_ASM*/
1116
1117 \f
1118
1119 /* Bulk encryption of complete blocks in CTR mode.  This function is only
1120    intended for the bulk encryption feature of cipher.c.  CTR is expected to be
1121    of size TWOFISH_BLOCKSIZE. */
1122 void
1123 _gcry_twofish_ctr_enc(void *context, unsigned char *ctr, void *outbuf_arg,
1124                       const void *inbuf_arg, size_t nblocks)
1125 {
1126   TWOFISH_context *ctx = context;
1127   unsigned char *outbuf = outbuf_arg;
1128   const unsigned char *inbuf = inbuf_arg;
1129   unsigned char tmpbuf[TWOFISH_BLOCKSIZE];
1130   unsigned int burn, burn_stack_depth = 0;
1131   int i;
1132
1133 #ifdef USE_AMD64_ASM
1134   {
1135     /* Process data in 3 block chunks. */
1136     while (nblocks >= 3)
1137       {
1138         twofish_amd64_ctr_enc(ctx, outbuf, inbuf, ctr);
1139
1140         nblocks -= 3;
1141         outbuf += 3 * TWOFISH_BLOCKSIZE;
1142         inbuf += 3 * TWOFISH_BLOCKSIZE;
1143
1144         burn = 8 * sizeof(void*);
1145         if (burn > burn_stack_depth)
1146           burn_stack_depth = burn;
1147       }
1148
1149     /* Use generic code to handle smaller chunks... */
1150     /* TODO: use caching instead? */
1151   }
1152 #endif
1153
1154   for ( ;nblocks; nblocks-- )
1155     {
1156       /* Encrypt the counter. */
1157       burn = twofish_encrypt(ctx, tmpbuf, ctr);
1158       if (burn > burn_stack_depth)
1159         burn_stack_depth = burn;
1160
1161       /* XOR the input with the encrypted counter and store in output.  */
1162       buf_xor(outbuf, tmpbuf, inbuf, TWOFISH_BLOCKSIZE);
1163       outbuf += TWOFISH_BLOCKSIZE;
1164       inbuf  += TWOFISH_BLOCKSIZE;
1165       /* Increment the counter.  */
1166       for (i = TWOFISH_BLOCKSIZE; i > 0; i--)
1167         {
1168           ctr[i-1]++;
1169           if (ctr[i-1])
1170             break;
1171         }
1172     }
1173
1174   wipememory(tmpbuf, sizeof(tmpbuf));
1175   _gcry_burn_stack(burn_stack_depth);
1176 }
1177
1178
1179 /* Bulk decryption of complete blocks in CBC mode.  This function is only
1180    intended for the bulk encryption feature of cipher.c. */
1181 void
1182 _gcry_twofish_cbc_dec(void *context, unsigned char *iv, void *outbuf_arg,
1183                       const void *inbuf_arg, size_t nblocks)
1184 {
1185   TWOFISH_context *ctx = context;
1186   unsigned char *outbuf = outbuf_arg;
1187   const unsigned char *inbuf = inbuf_arg;
1188   unsigned char savebuf[TWOFISH_BLOCKSIZE];
1189   unsigned int burn, burn_stack_depth = 0;
1190
1191 #ifdef USE_AMD64_ASM
1192   {
1193     /* Process data in 3 block chunks. */
1194     while (nblocks >= 3)
1195       {
1196         twofish_amd64_cbc_dec(ctx, outbuf, inbuf, iv);
1197
1198         nblocks -= 3;
1199         outbuf += 3 * TWOFISH_BLOCKSIZE;
1200         inbuf += 3 * TWOFISH_BLOCKSIZE;
1201
1202         burn = 9 * sizeof(void*);
1203         if (burn > burn_stack_depth)
1204           burn_stack_depth = burn;
1205       }
1206
1207     /* Use generic code to handle smaller chunks... */
1208   }
1209 #endif
1210
1211   for ( ;nblocks; nblocks-- )
1212     {
1213       /* INBUF is needed later and it may be identical to OUTBUF, so store
1214          the intermediate result to SAVEBUF.  */
1215       burn = twofish_decrypt (ctx, savebuf, inbuf);
1216       if (burn > burn_stack_depth)
1217         burn_stack_depth = burn;
1218
1219       buf_xor_n_copy_2(outbuf, savebuf, iv, inbuf, TWOFISH_BLOCKSIZE);
1220       inbuf += TWOFISH_BLOCKSIZE;
1221       outbuf += TWOFISH_BLOCKSIZE;
1222     }
1223
1224   wipememory(savebuf, sizeof(savebuf));
1225   _gcry_burn_stack(burn_stack_depth);
1226 }
1227
1228
1229 /* Bulk decryption of complete blocks in CFB mode.  This function is only
1230    intended for the bulk encryption feature of cipher.c. */
1231 void
1232 _gcry_twofish_cfb_dec(void *context, unsigned char *iv, void *outbuf_arg,
1233                     const void *inbuf_arg, size_t nblocks)
1234 {
1235   TWOFISH_context *ctx = context;
1236   unsigned char *outbuf = outbuf_arg;
1237   const unsigned char *inbuf = inbuf_arg;
1238   unsigned int burn, burn_stack_depth = 0;
1239
1240 #ifdef USE_AMD64_ASM
1241   {
1242     /* Process data in 3 block chunks. */
1243     while (nblocks >= 3)
1244       {
1245         twofish_amd64_cfb_dec(ctx, outbuf, inbuf, iv);
1246
1247         nblocks -= 3;
1248         outbuf += 3 * TWOFISH_BLOCKSIZE;
1249         inbuf += 3 * TWOFISH_BLOCKSIZE;
1250
1251         burn = 8 * sizeof(void*);
1252         if (burn > burn_stack_depth)
1253           burn_stack_depth = burn;
1254       }
1255
1256     /* Use generic code to handle smaller chunks... */
1257   }
1258 #endif
1259
1260   for ( ;nblocks; nblocks-- )
1261     {
1262       burn = twofish_encrypt(ctx, iv, iv);
1263       if (burn > burn_stack_depth)
1264         burn_stack_depth = burn;
1265
1266       buf_xor_n_copy(outbuf, iv, inbuf, TWOFISH_BLOCKSIZE);
1267       outbuf += TWOFISH_BLOCKSIZE;
1268       inbuf += TWOFISH_BLOCKSIZE;
1269     }
1270
1271   _gcry_burn_stack(burn_stack_depth);
1272 }
1273
1274 static inline const unsigned char *
1275 get_l (gcry_cipher_hd_t c, unsigned char *l_tmp, u64 i)
1276 {
1277   unsigned int ntz = _gcry_ctz64 (i);
1278
1279   if (ntz < OCB_L_TABLE_SIZE)
1280       return c->u_mode.ocb.L[ntz];
1281   else
1282       return _gcry_cipher_ocb_get_l (c, l_tmp, i);
1283 }
1284
1285 /* Bulk encryption/decryption of complete blocks in OCB mode. */
1286 void
1287 _gcry_twofish_ocb_crypt (gcry_cipher_hd_t c, void *outbuf_arg,
1288                         const void *inbuf_arg, size_t nblocks, int encrypt)
1289 {
1290   TWOFISH_context *ctx = (void *)&c->context.c;
1291   unsigned char *outbuf = outbuf_arg;
1292   const unsigned char *inbuf = inbuf_arg;
1293   unsigned char l_tmp[TWOFISH_BLOCKSIZE];
1294   const unsigned char *l;
1295   unsigned int burn, burn_stack_depth = 0;
1296   u64 blkn = c->u_mode.ocb.data_nblocks;
1297
1298 #ifdef USE_AMD64_ASM
1299   {
1300     const void *Ls[3];
1301
1302     /* Process data in 3 block chunks. */
1303     while (nblocks >= 3)
1304       {
1305         /* l_tmp will be used only every 65536-th block. */
1306         Ls[0] = get_l(c, l_tmp, blkn + 1);
1307         Ls[1] = get_l(c, l_tmp, blkn + 2);
1308         Ls[2] = get_l(c, l_tmp, blkn + 3);
1309         blkn += 3;
1310
1311         if (encrypt)
1312           twofish_amd64_ocb_enc(ctx, outbuf, inbuf, c->u_iv.iv, c->u_ctr.ctr,
1313                                 Ls);
1314         else
1315           twofish_amd64_ocb_dec(ctx, outbuf, inbuf, c->u_iv.iv, c->u_ctr.ctr,
1316                                 Ls);
1317
1318         nblocks -= 3;
1319         outbuf += 3 * TWOFISH_BLOCKSIZE;
1320         inbuf  += 3 * TWOFISH_BLOCKSIZE;
1321
1322         burn = 8 * sizeof(void*);
1323         if (burn > burn_stack_depth)
1324           burn_stack_depth = burn;
1325       }
1326
1327     /* Use generic code to handle smaller chunks... */
1328   }
1329 #endif
1330
1331   if (encrypt)
1332     {
1333       for (; nblocks; nblocks--)
1334         {
1335           l = get_l(c, l_tmp, ++blkn);
1336
1337           /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
1338           buf_xor_1 (c->u_iv.iv, l, TWOFISH_BLOCKSIZE);
1339           buf_cpy (l_tmp, inbuf, TWOFISH_BLOCKSIZE);
1340           /* Checksum_i = Checksum_{i-1} xor P_i  */
1341           buf_xor_1 (c->u_ctr.ctr, l_tmp, TWOFISH_BLOCKSIZE);
1342           /* C_i = Offset_i xor ENCIPHER(K, P_i xor Offset_i)  */
1343           buf_xor_1 (l_tmp, c->u_iv.iv, TWOFISH_BLOCKSIZE);
1344           burn = twofish_encrypt(ctx, l_tmp, l_tmp);
1345           if (burn > burn_stack_depth)
1346             burn_stack_depth = burn;
1347           buf_xor_1 (l_tmp, c->u_iv.iv, TWOFISH_BLOCKSIZE);
1348           buf_cpy (outbuf, l_tmp, TWOFISH_BLOCKSIZE);
1349
1350           inbuf += TWOFISH_BLOCKSIZE;
1351           outbuf += TWOFISH_BLOCKSIZE;
1352         }
1353     }
1354   else
1355     {
1356       for (; nblocks; nblocks--)
1357         {
1358           l = get_l(c, l_tmp, ++blkn);
1359
1360           /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
1361           buf_xor_1 (c->u_iv.iv, l, TWOFISH_BLOCKSIZE);
1362           buf_cpy (l_tmp, inbuf, TWOFISH_BLOCKSIZE);
1363           /* C_i = Offset_i xor ENCIPHER(K, P_i xor Offset_i)  */
1364           buf_xor_1 (l_tmp, c->u_iv.iv, TWOFISH_BLOCKSIZE);
1365           burn = twofish_decrypt(ctx, l_tmp, l_tmp);
1366           if (burn > burn_stack_depth)
1367             burn_stack_depth = burn;
1368           buf_xor_1 (l_tmp, c->u_iv.iv, TWOFISH_BLOCKSIZE);
1369           /* Checksum_i = Checksum_{i-1} xor P_i  */
1370           buf_xor_1 (c->u_ctr.ctr, l_tmp, TWOFISH_BLOCKSIZE);
1371           buf_cpy (outbuf, l_tmp, TWOFISH_BLOCKSIZE);
1372
1373           inbuf += TWOFISH_BLOCKSIZE;
1374           outbuf += TWOFISH_BLOCKSIZE;
1375         }
1376     }
1377
1378   c->u_mode.ocb.data_nblocks = blkn;
1379
1380   wipememory(&l_tmp, sizeof(l_tmp));
1381
1382   if (burn_stack_depth)
1383     _gcry_burn_stack (burn_stack_depth + 4 * sizeof(void *));
1384 }
1385
1386 /* Bulk authentication of complete blocks in OCB mode. */
1387 void
1388 _gcry_twofish_ocb_auth (gcry_cipher_hd_t c, const void *abuf_arg,
1389                         size_t nblocks)
1390 {
1391   TWOFISH_context *ctx = (void *)&c->context.c;
1392   const unsigned char *abuf = abuf_arg;
1393   unsigned char l_tmp[TWOFISH_BLOCKSIZE];
1394   const unsigned char *l;
1395   unsigned int burn, burn_stack_depth = 0;
1396   u64 blkn = c->u_mode.ocb.aad_nblocks;
1397
1398 #ifdef USE_AMD64_ASM
1399   {
1400     const void *Ls[3];
1401
1402     /* Process data in 3 block chunks. */
1403     while (nblocks >= 3)
1404       {
1405         /* l_tmp will be used only every 65536-th block. */
1406         Ls[0] = get_l(c, l_tmp, blkn + 1);
1407         Ls[1] = get_l(c, l_tmp, blkn + 2);
1408         Ls[2] = get_l(c, l_tmp, blkn + 3);
1409         blkn += 3;
1410
1411         twofish_amd64_ocb_auth(ctx, abuf, c->u_mode.ocb.aad_offset,
1412                               c->u_mode.ocb.aad_sum, Ls);
1413
1414         nblocks -= 3;
1415         abuf += 3 * TWOFISH_BLOCKSIZE;
1416
1417         burn = 8 * sizeof(void*);
1418         if (burn > burn_stack_depth)
1419           burn_stack_depth = burn;
1420       }
1421
1422     /* Use generic code to handle smaller chunks... */
1423   }
1424 #endif
1425
1426   for (; nblocks; nblocks--)
1427     {
1428       l = get_l(c, l_tmp, ++blkn);
1429
1430       /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
1431       buf_xor_1 (c->u_mode.ocb.aad_offset, l, TWOFISH_BLOCKSIZE);
1432       /* Sum_i = Sum_{i-1} xor ENCIPHER(K, A_i xor Offset_i)  */
1433       buf_xor (l_tmp, c->u_mode.ocb.aad_offset, abuf, TWOFISH_BLOCKSIZE);
1434       burn = twofish_encrypt(ctx, l_tmp, l_tmp);
1435       if (burn > burn_stack_depth)
1436         burn_stack_depth = burn;
1437       buf_xor_1 (c->u_mode.ocb.aad_sum, l_tmp, TWOFISH_BLOCKSIZE);
1438
1439       abuf += TWOFISH_BLOCKSIZE;
1440     }
1441
1442   c->u_mode.ocb.aad_nblocks = blkn;
1443
1444   wipememory(&l_tmp, sizeof(l_tmp));
1445
1446   if (burn_stack_depth)
1447     _gcry_burn_stack (burn_stack_depth + 4 * sizeof(void *));
1448 }
1449
1450 \f
1451
1452 /* Run the self-tests for TWOFISH-CTR, tests IV increment of bulk CTR
1453    encryption.  Returns NULL on success. */
1454 static const char *
1455 selftest_ctr (void)
1456 {
1457   const int nblocks = 3+1;
1458   const int blocksize = TWOFISH_BLOCKSIZE;
1459   const int context_size = sizeof(TWOFISH_context);
1460
1461   return _gcry_selftest_helper_ctr("TWOFISH", &twofish_setkey,
1462            &twofish_encrypt, &_gcry_twofish_ctr_enc, nblocks, blocksize,
1463            context_size);
1464 }
1465
1466 /* Run the self-tests for TWOFISH-CBC, tests bulk CBC decryption.
1467    Returns NULL on success. */
1468 static const char *
1469 selftest_cbc (void)
1470 {
1471   const int nblocks = 3+2;
1472   const int blocksize = TWOFISH_BLOCKSIZE;
1473   const int context_size = sizeof(TWOFISH_context);
1474
1475   return _gcry_selftest_helper_cbc("TWOFISH", &twofish_setkey,
1476            &twofish_encrypt, &_gcry_twofish_cbc_dec, nblocks, blocksize,
1477            context_size);
1478 }
1479
1480 /* Run the self-tests for TWOFISH-CFB, tests bulk CBC decryption.
1481    Returns NULL on success. */
1482 static const char *
1483 selftest_cfb (void)
1484 {
1485   const int nblocks = 3+2;
1486   const int blocksize = TWOFISH_BLOCKSIZE;
1487   const int context_size = sizeof(TWOFISH_context);
1488
1489   return _gcry_selftest_helper_cfb("TWOFISH", &twofish_setkey,
1490            &twofish_encrypt, &_gcry_twofish_cfb_dec, nblocks, blocksize,
1491            context_size);
1492 }
1493
1494 \f
1495 /* Test a single encryption and decryption with each key size. */
1496
1497 static const char*
1498 selftest (void)
1499 {
1500   TWOFISH_context ctx; /* Expanded key. */
1501   byte scratch[16];     /* Encryption/decryption result buffer. */
1502   const char *r;
1503
1504   /* Test vectors for single encryption/decryption.  Note that I am using
1505    * the vectors from the Twofish paper's "known answer test", I=3 for
1506    * 128-bit and I=4 for 256-bit, instead of the all-0 vectors from the
1507    * "intermediate value test", because an all-0 key would trigger all the
1508    * special cases in the RS matrix multiply, leaving the math untested. */
1509   static  byte plaintext[16] = {
1510     0xD4, 0x91, 0xDB, 0x16, 0xE7, 0xB1, 0xC3, 0x9E,
1511     0x86, 0xCB, 0x08, 0x6B, 0x78, 0x9F, 0x54, 0x19
1512   };
1513   static byte key[16] = {
1514     0x9F, 0x58, 0x9F, 0x5C, 0xF6, 0x12, 0x2C, 0x32,
1515     0xB6, 0xBF, 0xEC, 0x2F, 0x2A, 0xE8, 0xC3, 0x5A
1516   };
1517   static const byte ciphertext[16] = {
1518     0x01, 0x9F, 0x98, 0x09, 0xDE, 0x17, 0x11, 0x85,
1519     0x8F, 0xAA, 0xC3, 0xA3, 0xBA, 0x20, 0xFB, 0xC3
1520   };
1521   static byte plaintext_256[16] = {
1522     0x90, 0xAF, 0xE9, 0x1B, 0xB2, 0x88, 0x54, 0x4F,
1523     0x2C, 0x32, 0xDC, 0x23, 0x9B, 0x26, 0x35, 0xE6
1524   };
1525   static byte key_256[32] = {
1526     0xD4, 0x3B, 0xB7, 0x55, 0x6E, 0xA3, 0x2E, 0x46,
1527     0xF2, 0xA2, 0x82, 0xB7, 0xD4, 0x5B, 0x4E, 0x0D,
1528     0x57, 0xFF, 0x73, 0x9D, 0x4D, 0xC9, 0x2C, 0x1B,
1529     0xD7, 0xFC, 0x01, 0x70, 0x0C, 0xC8, 0x21, 0x6F
1530   };
1531   static const byte ciphertext_256[16] = {
1532     0x6C, 0xB4, 0x56, 0x1C, 0x40, 0xBF, 0x0A, 0x97,
1533     0x05, 0x93, 0x1C, 0xB6, 0xD4, 0x08, 0xE7, 0xFA
1534   };
1535
1536   twofish_setkey (&ctx, key, sizeof(key));
1537   twofish_encrypt (&ctx, scratch, plaintext);
1538   if (memcmp (scratch, ciphertext, sizeof (ciphertext)))
1539     return "Twofish-128 test encryption failed.";
1540   twofish_decrypt (&ctx, scratch, scratch);
1541   if (memcmp (scratch, plaintext, sizeof (plaintext)))
1542     return "Twofish-128 test decryption failed.";
1543
1544   twofish_setkey (&ctx, key_256, sizeof(key_256));
1545   twofish_encrypt (&ctx, scratch, plaintext_256);
1546   if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
1547     return "Twofish-256 test encryption failed.";
1548   twofish_decrypt (&ctx, scratch, scratch);
1549   if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
1550     return "Twofish-256 test decryption failed.";
1551
1552   if ((r = selftest_ctr()) != NULL)
1553     return r;
1554   if ((r = selftest_cbc()) != NULL)
1555     return r;
1556   if ((r = selftest_cfb()) != NULL)
1557     return r;
1558
1559   return NULL;
1560 }
1561 \f
1562 /* More complete test program.  This does 1000 encryptions and decryptions
1563  * with each of 250 128-bit keys and 2000 encryptions and decryptions with
1564  * each of 125 256-bit keys, using a feedback scheme similar to a Feistel
1565  * cipher, so as to be sure of testing all the table entries pretty
1566  * thoroughly.  We keep changing the keys so as to get a more meaningful
1567  * performance number, since the key setup is non-trivial for Twofish. */
1568
1569 #ifdef TEST
1570
1571 #include <stdio.h>
1572 #include <string.h>
1573 #include <time.h>
1574
1575 int
1576 main()
1577 {
1578   TWOFISH_context ctx;     /* Expanded key. */
1579   int i, j;                 /* Loop counters. */
1580
1581   const char *encrypt_msg; /* Message to print regarding encryption test;
1582                             * the printf is done outside the loop to avoid
1583                             * stuffing up the timing. */
1584   clock_t timer; /* For computing elapsed time. */
1585
1586   /* Test buffer. */
1587   byte buffer[4][16] = {
1588     {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1589      0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF},
1590     {0x0F, 0x1E, 0x2D, 0x3C, 0x4B, 0x5A, 0x69, 0x78,
1591      0x87, 0x96, 0xA5, 0xB4, 0xC3, 0xD2 ,0xE1, 0xF0},
1592     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
1593      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54 ,0x32, 0x10},
1594     {0x01, 0x23, 0x45, 0x67, 0x76, 0x54 ,0x32, 0x10,
1595      0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98}
1596   };
1597
1598   /* Expected outputs for the million-operation test */
1599   static const byte test_encrypt[4][16] = {
1600     {0xC8, 0x23, 0xB8, 0xB7, 0x6B, 0xFE, 0x91, 0x13,
1601      0x2F, 0xA7, 0x5E, 0xE6, 0x94, 0x77, 0x6F, 0x6B},
1602     {0x90, 0x36, 0xD8, 0x29, 0xD5, 0x96, 0xC2, 0x8E,
1603      0xE4, 0xFF, 0x76, 0xBC, 0xE5, 0x77, 0x88, 0x27},
1604     {0xB8, 0x78, 0x69, 0xAF, 0x42, 0x8B, 0x48, 0x64,
1605      0xF7, 0xE9, 0xF3, 0x9C, 0x42, 0x18, 0x7B, 0x73},
1606     {0x7A, 0x88, 0xFB, 0xEB, 0x90, 0xA4, 0xB4, 0xA8,
1607      0x43, 0xA3, 0x1D, 0xF1, 0x26, 0xC4, 0x53, 0x57}
1608   };
1609   static const byte test_decrypt[4][16] = {
1610     {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1611      0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF},
1612     {0x0F, 0x1E, 0x2D, 0x3C, 0x4B, 0x5A, 0x69, 0x78,
1613      0x87, 0x96, 0xA5, 0xB4, 0xC3, 0xD2 ,0xE1, 0xF0},
1614     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
1615      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54 ,0x32, 0x10},
1616     {0x01, 0x23, 0x45, 0x67, 0x76, 0x54 ,0x32, 0x10,
1617      0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98}
1618   };
1619
1620   /* Start the timer ticking. */
1621   timer = clock ();
1622
1623   /* Encryption test. */
1624   for (i = 0; i < 125; i++)
1625     {
1626       twofish_setkey (&ctx, buffer[0], sizeof (buffer[0]));
1627       for (j = 0; j < 1000; j++)
1628         twofish_encrypt (&ctx, buffer[2], buffer[2]);
1629       twofish_setkey (&ctx, buffer[1], sizeof (buffer[1]));
1630       for (j = 0; j < 1000; j++)
1631         twofish_encrypt (&ctx, buffer[3], buffer[3]);
1632       twofish_setkey (&ctx, buffer[2], sizeof (buffer[2])*2);
1633       for (j = 0; j < 1000; j++) {
1634         twofish_encrypt (&ctx, buffer[0], buffer[0]);
1635         twofish_encrypt (&ctx, buffer[1], buffer[1]);
1636       }
1637     }
1638   encrypt_msg = memcmp (buffer, test_encrypt, sizeof (test_encrypt)) ?
1639     "encryption failure!\n" : "encryption OK!\n";
1640
1641   /* Decryption test. */
1642   for (i = 0; i < 125; i++)
1643     {
1644       twofish_setkey (&ctx, buffer[2], sizeof (buffer[2])*2);
1645       for (j = 0; j < 1000; j++) {
1646         twofish_decrypt (&ctx, buffer[0], buffer[0]);
1647         twofish_decrypt (&ctx, buffer[1], buffer[1]);
1648       }
1649       twofish_setkey (&ctx, buffer[1], sizeof (buffer[1]));
1650       for (j = 0; j < 1000; j++)
1651         twofish_decrypt (&ctx, buffer[3], buffer[3]);
1652       twofish_setkey (&ctx, buffer[0], sizeof (buffer[0]));
1653       for (j = 0; j < 1000; j++)
1654         twofish_decrypt (&ctx, buffer[2], buffer[2]);
1655     }
1656
1657   /* Stop the timer, and print results. */
1658   timer = clock () - timer;
1659   printf (encrypt_msg);
1660   printf (memcmp (buffer, test_decrypt, sizeof (test_decrypt)) ?
1661           "decryption failure!\n" : "decryption OK!\n");
1662   printf ("elapsed time: %.1f s.\n", (float) timer / CLOCKS_PER_SEC);
1663
1664   return 0;
1665 }
1666
1667 #endif /* TEST */
1668
1669 \f
1670
1671 gcry_cipher_spec_t _gcry_cipher_spec_twofish =
1672   {
1673     GCRY_CIPHER_TWOFISH, {0, 0},
1674     "TWOFISH", NULL, NULL, 16, 256, sizeof (TWOFISH_context),
1675     twofish_setkey, twofish_encrypt, twofish_decrypt
1676   };
1677
1678 gcry_cipher_spec_t _gcry_cipher_spec_twofish128 =
1679   {
1680     GCRY_CIPHER_TWOFISH128, {0, 0},
1681     "TWOFISH128", NULL, NULL, 16, 128, sizeof (TWOFISH_context),
1682     twofish_setkey, twofish_encrypt, twofish_decrypt
1683   };