Botan  1.10.9
mars.cpp
Go to the documentation of this file.
1 /*
2 * MARS
3 * (C) 1999-2009 Jack Lloyd
4 *
5 * Distributed under the terms of the Botan license
6 */
7 
8 #include <botan/mars.h>
9 #include <botan/loadstor.h>
10 #include <botan/rotate.h>
11 
12 namespace Botan {
13 
14 namespace {
15 
16 /**
17 * The MARS sbox
18 */
19 const u32bit SBOX[512] = {
20  0x09D0C479, 0x28C8FFE0, 0x84AA6C39, 0x9DAD7287, 0x7DFF9BE3, 0xD4268361,
21  0xC96DA1D4, 0x7974CC93, 0x85D0582E, 0x2A4B5705, 0x1CA16A62, 0xC3BD279D,
22  0x0F1F25E5, 0x5160372F, 0xC695C1FB, 0x4D7FF1E4, 0xAE5F6BF4, 0x0D72EE46,
23  0xFF23DE8A, 0xB1CF8E83, 0xF14902E2, 0x3E981E42, 0x8BF53EB6, 0x7F4BF8AC,
24  0x83631F83, 0x25970205, 0x76AFE784, 0x3A7931D4, 0x4F846450, 0x5C64C3F6,
25  0x210A5F18, 0xC6986A26, 0x28F4E826, 0x3A60A81C, 0xD340A664, 0x7EA820C4,
26  0x526687C5, 0x7EDDD12B, 0x32A11D1D, 0x9C9EF086, 0x80F6E831, 0xAB6F04AD,
27  0x56FB9B53, 0x8B2E095C, 0xB68556AE, 0xD2250B0D, 0x294A7721, 0xE21FB253,
28  0xAE136749, 0xE82AAE86, 0x93365104, 0x99404A66, 0x78A784DC, 0xB69BA84B,
29  0x04046793, 0x23DB5C1E, 0x46CAE1D6, 0x2FE28134, 0x5A223942, 0x1863CD5B,
30  0xC190C6E3, 0x07DFB846, 0x6EB88816, 0x2D0DCC4A, 0xA4CCAE59, 0x3798670D,
31  0xCBFA9493, 0x4F481D45, 0xEAFC8CA8, 0xDB1129D6, 0xB0449E20, 0x0F5407FB,
32  0x6167D9A8, 0xD1F45763, 0x4DAA96C3, 0x3BEC5958, 0xABABA014, 0xB6CCD201,
33  0x38D6279F, 0x02682215, 0x8F376CD5, 0x092C237E, 0xBFC56593, 0x32889D2C,
34  0x854B3E95, 0x05BB9B43, 0x7DCD5DCD, 0xA02E926C, 0xFAE527E5, 0x36A1C330,
35  0x3412E1AE, 0xF257F462, 0x3C4F1D71, 0x30A2E809, 0x68E5F551, 0x9C61BA44,
36  0x5DED0AB8, 0x75CE09C8, 0x9654F93E, 0x698C0CCA, 0x243CB3E4, 0x2B062B97,
37  0x0F3B8D9E, 0x00E050DF, 0xFC5D6166, 0xE35F9288, 0xC079550D, 0x0591AEE8,
38  0x8E531E74, 0x75FE3578, 0x2F6D829A, 0xF60B21AE, 0x95E8EB8D, 0x6699486B,
39  0x901D7D9B, 0xFD6D6E31, 0x1090ACEF, 0xE0670DD8, 0xDAB2E692, 0xCD6D4365,
40  0xE5393514, 0x3AF345F0, 0x6241FC4D, 0x460DA3A3, 0x7BCF3729, 0x8BF1D1E0,
41  0x14AAC070, 0x1587ED55, 0x3AFD7D3E, 0xD2F29E01, 0x29A9D1F6, 0xEFB10C53,
42  0xCF3B870F, 0xB414935C, 0x664465ED, 0x024ACAC7, 0x59A744C1, 0x1D2936A7,
43  0xDC580AA6, 0xCF574CA8, 0x040A7A10, 0x6CD81807, 0x8A98BE4C, 0xACCEA063,
44  0xC33E92B5, 0xD1E0E03D, 0xB322517E, 0x2092BD13, 0x386B2C4A, 0x52E8DD58,
45  0x58656DFB, 0x50820371, 0x41811896, 0xE337EF7E, 0xD39FB119, 0xC97F0DF6,
46  0x68FEA01B, 0xA150A6E5, 0x55258962, 0xEB6FF41B, 0xD7C9CD7A, 0xA619CD9E,
47  0xBCF09576, 0x2672C073, 0xF003FB3C, 0x4AB7A50B, 0x1484126A, 0x487BA9B1,
48  0xA64FC9C6, 0xF6957D49, 0x38B06A75, 0xDD805FCD, 0x63D094CF, 0xF51C999E,
49  0x1AA4D343, 0xB8495294, 0xCE9F8E99, 0xBFFCD770, 0xC7C275CC, 0x378453A7,
50  0x7B21BE33, 0x397F41BD, 0x4E94D131, 0x92CC1F98, 0x5915EA51, 0x99F861B7,
51  0xC9980A88, 0x1D74FD5F, 0xB0A495F8, 0x614DEED0, 0xB5778EEA, 0x5941792D,
52  0xFA90C1F8, 0x33F824B4, 0xC4965372, 0x3FF6D550, 0x4CA5FEC0, 0x8630E964,
53  0x5B3FBBD6, 0x7DA26A48, 0xB203231A, 0x04297514, 0x2D639306, 0x2EB13149,
54  0x16A45272, 0x532459A0, 0x8E5F4872, 0xF966C7D9, 0x07128DC0, 0x0D44DB62,
55  0xAFC8D52D, 0x06316131, 0xD838E7CE, 0x1BC41D00, 0x3A2E8C0F, 0xEA83837E,
56  0xB984737D, 0x13BA4891, 0xC4F8B949, 0xA6D6ACB3, 0xA215CDCE, 0x8359838B,
57  0x6BD1AA31, 0xF579DD52, 0x21B93F93, 0xF5176781, 0x187DFDDE, 0xE94AEB76,
58  0x2B38FD54, 0x431DE1DA, 0xAB394825, 0x9AD3048F, 0xDFEA32AA, 0x659473E3,
59  0x623F7863, 0xF3346C59, 0xAB3AB685, 0x3346A90B, 0x6B56443E, 0xC6DE01F8,
60  0x8D421FC0, 0x9B0ED10C, 0x88F1A1E9, 0x54C1F029, 0x7DEAD57B, 0x8D7BA426,
61  0x4CF5178A, 0x551A7CCA, 0x1A9A5F08, 0xFCD651B9, 0x25605182, 0xE11FC6C3,
62  0xB6FD9676, 0x337B3027, 0xB7C8EB14, 0x9E5FD030, 0x6B57E354, 0xAD913CF7,
63  0x7E16688D, 0x58872A69, 0x2C2FC7DF, 0xE389CCC6, 0x30738DF1, 0x0824A734,
64  0xE1797A8B, 0xA4A8D57B, 0x5B5D193B, 0xC8A8309B, 0x73F9A978, 0x73398D32,
65  0x0F59573E, 0xE9DF2B03, 0xE8A5B6C8, 0x848D0704, 0x98DF93C2, 0x720A1DC3,
66  0x684F259A, 0x943BA848, 0xA6370152, 0x863B5EA3, 0xD17B978B, 0x6D9B58EF,
67  0x0A700DD4, 0xA73D36BF, 0x8E6A0829, 0x8695BC14, 0xE35B3447, 0x933AC568,
68  0x8894B022, 0x2F511C27, 0xDDFBCC3C, 0x006662B6, 0x117C83FE, 0x4E12B414,
69  0xC2BCA766, 0x3A2FEC10, 0xF4562420, 0x55792E2A, 0x46F5D857, 0xCEDA25CE,
70  0xC3601D3B, 0x6C00AB46, 0xEFAC9C28, 0xB3C35047, 0x611DFEE3, 0x257C3207,
71  0xFDD58482, 0x3B14D84F, 0x23BECB64, 0xA075F3A3, 0x088F8EAD, 0x07ADF158,
72  0x7796943C, 0xFACABF3D, 0xC09730CD, 0xF7679969, 0xDA44E9ED, 0x2C854C12,
73  0x35935FA3, 0x2F057D9F, 0x690624F8, 0x1CB0BAFD, 0x7B0DBDC6, 0x810F23BB,
74  0xFA929A1A, 0x6D969A17, 0x6742979B, 0x74AC7D05, 0x010E65C4, 0x86A3D963,
75  0xF907B5A0, 0xD0042BD3, 0x158D7D03, 0x287A8255, 0xBBA8366F, 0x096EDC33,
76  0x21916A7B, 0x77B56B86, 0x951622F9, 0xA6C5E650, 0x8CEA17D1, 0xCD8C62BC,
77  0xA3D63433, 0x358A68FD, 0x0F9B9D3C, 0xD6AA295B, 0xFE33384A, 0xC000738E,
78  0xCD67EB2F, 0xE2EB6DC2, 0x97338B02, 0x06C9F246, 0x419CF1AD, 0x2B83C045,
79  0x3723F18A, 0xCB5B3089, 0x160BEAD7, 0x5D494656, 0x35F8A74B, 0x1E4E6C9E,
80  0x000399BD, 0x67466880, 0xB4174831, 0xACF423B2, 0xCA815AB3, 0x5A6395E7,
81  0x302A67C5, 0x8BDB446B, 0x108F8FA4, 0x10223EDA, 0x92B8B48B, 0x7F38D0EE,
82  0xAB2701D4, 0x0262D415, 0xAF224A30, 0xB3D88ABA, 0xF8B2C3AF, 0xDAF7EF70,
83  0xCC97D3B7, 0xE9614B6C, 0x2BAEBFF4, 0x70F687CF, 0x386C9156, 0xCE092EE5,
84  0x01E87DA6, 0x6CE91E6A, 0xBB7BCC84, 0xC7922C20, 0x9D3B71FD, 0x060E41C6,
85  0xD7590F15, 0x4E03BB47, 0x183C198E, 0x63EEB240, 0x2DDBF49A, 0x6D5CBA54,
86  0x923750AF, 0xF9E14236, 0x7838162B, 0x59726C72, 0x81B66760, 0xBB2926C1,
87  0x48A0CE0D, 0xA6C0496D, 0xAD43507B, 0x718D496A, 0x9DF057AF, 0x44B1BDE6,
88  0x054356DC, 0xDE7CED35, 0xD51A138B, 0x62088CC9, 0x35830311, 0xC96EFCA2,
89  0x686F86EC, 0x8E77CB68, 0x63E1D6B8, 0xC80F9778, 0x79C491FD, 0x1B4C67F2,
90  0x72698D7D, 0x5E368C31, 0xF7D95E2E, 0xA1D3493F, 0xDCD9433E, 0x896F1552,
91  0x4BC4CA7A, 0xA6D1BAF4, 0xA5A96DCC, 0x0BEF8B46, 0xA169FDA7, 0x74DF40B7,
92  0x4E208804, 0x9A756607, 0x038E87C8, 0x20211E44, 0x8B7AD4BF, 0xC6403F35,
93  0x1848E36D, 0x80BDB038, 0x1E62891C, 0x643D2107, 0xBF04D6F8, 0x21092C8C,
94  0xF644F389, 0x0778404E, 0x7B78ADB8, 0xA2C52D53, 0x42157ABE, 0xA2253E2E,
95  0x7BF3F4AE, 0x80F594F9, 0x953194E7, 0x77EB92ED, 0xB3816930, 0xDA8D9336,
96  0xBF447469, 0xF26D9483, 0xEE6FAED5, 0x71371235, 0xDE425F73, 0xB4E59F43,
97  0x7DBE2D4E, 0x2D37B185, 0x49DC9A63, 0x98C39D98, 0x1301C9A2, 0x389B1BBF,
98  0x0C18588D, 0xA421C1BA, 0x7AA3865C, 0x71E08558, 0x3C5CFCAA, 0x7D239CA4,
99  0x0297D9DD, 0xD7DC2830, 0x4B37802B, 0x7428AB54, 0xAEEE0347, 0x4B3FBB85,
100  0x692F2F08, 0x134E578E, 0x36D9E0BF, 0xAE8B5FCF, 0xEDB93ECF, 0x2B27248E,
101  0x170EB1EF, 0x7DC57FD6, 0x1E760F16, 0xB1136601, 0x864E1B9B, 0xD7EA7319,
102  0x3AB871BD, 0xCFA4D76F, 0xE31BD782, 0x0DBEB469, 0xABB96061, 0x5370F85D,
103  0xFFB07E37, 0xDA30D0FB, 0xEBC977B6, 0x0B98B40F, 0x3A4D0FE6, 0xDF4FC26B,
104  0x159CF22A, 0xC298D6E2, 0x2B78EF6A, 0x61A94AC0, 0xAB561187, 0x14EEA0F0,
105  0xDF0D4164, 0x19AF70EE };
106 
107 /*
108 * MARS Encryption Round
109 */
110 inline void encrypt_round(u32bit& A, u32bit& B, u32bit& C, u32bit& D,
111  u32bit EK1, u32bit EK2)
112  {
113  const u32bit X = A + EK1;
114  A = rotate_left(A, 13);
115  u32bit Y = A * EK2;
116  u32bit Z = SBOX[X % 512];
117 
118  Y = rotate_left(Y, 5);
119  Z ^= Y;
120  C += rotate_left(X, Y % 32);
121  Y = rotate_left(Y, 5);
122  Z ^= Y;
123  D ^= Y;
124  B += rotate_left(Z, Y % 32);
125  }
126 
127 /*
128 * MARS Decryption Round
129 */
130 inline void decrypt_round(u32bit& A, u32bit& B, u32bit& C, u32bit& D,
131  u32bit EK1, u32bit EK2)
132  {
133  u32bit Y = A * EK1;
134  A = rotate_right(A, 13);
135  const u32bit X = A + EK2;
136  u32bit Z = SBOX[X % 512];
137 
138  Y = rotate_left(Y, 5);
139  Z ^= Y;
140  C -= rotate_left(X, Y % 32);
141  Y = rotate_left(Y, 5);
142  Z ^= Y;
143  D ^= Y;
144  B -= rotate_left(Z, Y % 32);
145  }
146 
147 /*
148 * MARS Forward Mixing Operation
149 */
150 void forward_mix(u32bit& A, u32bit& B, u32bit& C, u32bit& D)
151  {
152  for(size_t j = 0; j != 2; ++j)
153  {
154  B ^= SBOX[get_byte(3, A)]; B += SBOX[get_byte(2, A) + 256];
155  C += SBOX[get_byte(1, A)]; D ^= SBOX[get_byte(0, A) + 256];
156  A = rotate_right(A, 24) + D;
157 
158  C ^= SBOX[get_byte(3, B)]; C += SBOX[get_byte(2, B) + 256];
159  D += SBOX[get_byte(1, B)]; A ^= SBOX[get_byte(0, B) + 256];
160  B = rotate_right(B, 24) + C;
161 
162  D ^= SBOX[get_byte(3, C)]; D += SBOX[get_byte(2, C) + 256];
163  A += SBOX[get_byte(1, C)]; B ^= SBOX[get_byte(0, C) + 256];
164  C = rotate_right(C, 24);
165 
166  A ^= SBOX[get_byte(3, D)]; A += SBOX[get_byte(2, D) + 256];
167  B += SBOX[get_byte(1, D)]; C ^= SBOX[get_byte(0, D) + 256];
168  D = rotate_right(D, 24);
169  }
170  }
171 
172 /*
173 * MARS Reverse Mixing Operation
174 */
175 void reverse_mix(u32bit& A, u32bit& B, u32bit& C, u32bit& D)
176  {
177  for(size_t j = 0; j != 2; ++j)
178  {
179  B ^= SBOX[get_byte(3, A) + 256]; C -= SBOX[get_byte(0, A)];
180  D -= SBOX[get_byte(1, A) + 256]; D ^= SBOX[get_byte(2, A)];
181  A = rotate_left(A, 24);
182 
183  C ^= SBOX[get_byte(3, B) + 256]; D -= SBOX[get_byte(0, B)];
184  A -= SBOX[get_byte(1, B) + 256]; A ^= SBOX[get_byte(2, B)];
185  C -= (B = rotate_left(B, 24));
186 
187  D ^= SBOX[get_byte(3, C) + 256]; A -= SBOX[get_byte(0, C)];
188  B -= SBOX[get_byte(1, C) + 256]; B ^= SBOX[get_byte(2, C)];
189  C = rotate_left(C, 24);
190  D -= A;
191 
192  A ^= SBOX[get_byte(3, D) + 256]; B -= SBOX[get_byte(0, D)];
193  C -= SBOX[get_byte(1, D) + 256]; C ^= SBOX[get_byte(2, D)];
194  D = rotate_left(D, 24);
195  }
196  }
197 
198 /*
199 * Generate a mask for runs of bits
200 */
201 u32bit gen_mask(u32bit input)
202  {
203  u32bit mask = 0;
204 
205  for(u32bit j = 2; j != 31; ++j)
206  {
207  const u32bit region = (input >> (j-1)) & 0x07;
208 
209  if(region == 0x00 || region == 0x07)
210  {
211  const u32bit low = (j < 9) ? 0 : (j - 9);
212  const u32bit high = (j < 23) ? j : 23;
213 
214  for(u32bit k = low; k != high; ++k)
215  {
216  const u32bit value = (input >> k) & 0x3FF;
217 
218  if(value == 0 || value == 0x3FF)
219  {
220  mask |= 1 << j;
221  break;
222  }
223  }
224  }
225  }
226 
227  return mask;
228  }
229 
230 }
231 
232 /*
233 * MARS Encryption
234 */
235 void MARS::encrypt_n(const byte in[], byte out[], size_t blocks) const
236  {
237  for(size_t i = 0; i != blocks; ++i)
238  {
239  u32bit A = load_le<u32bit>(in, 0) + EK[0];
240  u32bit B = load_le<u32bit>(in, 1) + EK[1];
241  u32bit C = load_le<u32bit>(in, 2) + EK[2];
242  u32bit D = load_le<u32bit>(in, 3) + EK[3];
243 
244  forward_mix(A, B, C, D);
245 
246  encrypt_round(A, B, C, D, EK[ 4], EK[ 5]);
247  encrypt_round(B, C, D, A, EK[ 6], EK[ 7]);
248  encrypt_round(C, D, A, B, EK[ 8], EK[ 9]);
249  encrypt_round(D, A, B, C, EK[10], EK[11]);
250  encrypt_round(A, B, C, D, EK[12], EK[13]);
251  encrypt_round(B, C, D, A, EK[14], EK[15]);
252  encrypt_round(C, D, A, B, EK[16], EK[17]);
253  encrypt_round(D, A, B, C, EK[18], EK[19]);
254 
255  encrypt_round(A, D, C, B, EK[20], EK[21]);
256  encrypt_round(B, A, D, C, EK[22], EK[23]);
257  encrypt_round(C, B, A, D, EK[24], EK[25]);
258  encrypt_round(D, C, B, A, EK[26], EK[27]);
259  encrypt_round(A, D, C, B, EK[28], EK[29]);
260  encrypt_round(B, A, D, C, EK[30], EK[31]);
261  encrypt_round(C, B, A, D, EK[32], EK[33]);
262  encrypt_round(D, C, B, A, EK[34], EK[35]);
263 
264  reverse_mix(A, B, C, D);
265 
266  A -= EK[36]; B -= EK[37]; C -= EK[38]; D -= EK[39];
267 
268  store_le(out, A, B, C, D);
269 
270  in += BLOCK_SIZE;
271  out += BLOCK_SIZE;
272  }
273  }
274 
275 /*
276 * MARS Decryption
277 */
278 void MARS::decrypt_n(const byte in[], byte out[], size_t blocks) const
279  {
280  for(size_t i = 0; i != blocks; ++i)
281  {
282  u32bit A = load_le<u32bit>(in, 3) + EK[39];
283  u32bit B = load_le<u32bit>(in, 2) + EK[38];
284  u32bit C = load_le<u32bit>(in, 1) + EK[37];
285  u32bit D = load_le<u32bit>(in, 0) + EK[36];
286 
287  forward_mix(A, B, C, D);
288 
289  decrypt_round(A, B, C, D, EK[35], EK[34]);
290  decrypt_round(B, C, D, A, EK[33], EK[32]);
291  decrypt_round(C, D, A, B, EK[31], EK[30]);
292  decrypt_round(D, A, B, C, EK[29], EK[28]);
293  decrypt_round(A, B, C, D, EK[27], EK[26]);
294  decrypt_round(B, C, D, A, EK[25], EK[24]);
295  decrypt_round(C, D, A, B, EK[23], EK[22]);
296  decrypt_round(D, A, B, C, EK[21], EK[20]);
297 
298  decrypt_round(A, D, C, B, EK[19], EK[18]);
299  decrypt_round(B, A, D, C, EK[17], EK[16]);
300  decrypt_round(C, B, A, D, EK[15], EK[14]);
301  decrypt_round(D, C, B, A, EK[13], EK[12]);
302  decrypt_round(A, D, C, B, EK[11], EK[10]);
303  decrypt_round(B, A, D, C, EK[ 9], EK[ 8]);
304  decrypt_round(C, B, A, D, EK[ 7], EK[ 6]);
305  decrypt_round(D, C, B, A, EK[ 5], EK[ 4]);
306 
307  reverse_mix(A, B, C, D);
308 
309  A -= EK[3]; B -= EK[2]; C -= EK[1]; D -= EK[0];
310 
311  store_le(out, D, C, B, A);
312 
313  in += BLOCK_SIZE;
314  out += BLOCK_SIZE;
315  }
316  }
317 
318 /*
319 * MARS Key Schedule
320 */
321 void MARS::key_schedule(const byte key[], size_t length)
322  {
323  SecureVector<u32bit> T(15);
324  for(size_t i = 0; i != length / 4; ++i)
325  T[i] = load_le<u32bit>(key, i);
326 
327  T[length / 4] = static_cast<u32bit>(length) / 4;
328 
329  for(u32bit i = 0; i != 4; ++i)
330  {
331  T[ 0] ^= rotate_left(T[ 8] ^ T[13], 3) ^ (i );
332  T[ 1] ^= rotate_left(T[ 9] ^ T[14], 3) ^ (i + 4);
333  T[ 2] ^= rotate_left(T[10] ^ T[ 0], 3) ^ (i + 8);
334  T[ 3] ^= rotate_left(T[11] ^ T[ 1], 3) ^ (i + 12);
335  T[ 4] ^= rotate_left(T[12] ^ T[ 2], 3) ^ (i + 16);
336  T[ 5] ^= rotate_left(T[13] ^ T[ 3], 3) ^ (i + 20);
337  T[ 6] ^= rotate_left(T[14] ^ T[ 4], 3) ^ (i + 24);
338  T[ 7] ^= rotate_left(T[ 0] ^ T[ 5], 3) ^ (i + 28);
339  T[ 8] ^= rotate_left(T[ 1] ^ T[ 6], 3) ^ (i + 32);
340  T[ 9] ^= rotate_left(T[ 2] ^ T[ 7], 3) ^ (i + 36);
341  T[10] ^= rotate_left(T[ 3] ^ T[ 8], 3) ^ (i + 40);
342  T[11] ^= rotate_left(T[ 4] ^ T[ 9], 3) ^ (i + 44);
343  T[12] ^= rotate_left(T[ 5] ^ T[10], 3) ^ (i + 48);
344  T[13] ^= rotate_left(T[ 6] ^ T[11], 3) ^ (i + 52);
345  T[14] ^= rotate_left(T[ 7] ^ T[12], 3) ^ (i + 56);
346 
347  for(size_t j = 0; j != 4; ++j)
348  {
349  T[ 0] = rotate_left(T[ 0] + SBOX[T[14] % 512], 9);
350  T[ 1] = rotate_left(T[ 1] + SBOX[T[ 0] % 512], 9);
351  T[ 2] = rotate_left(T[ 2] + SBOX[T[ 1] % 512], 9);
352  T[ 3] = rotate_left(T[ 3] + SBOX[T[ 2] % 512], 9);
353  T[ 4] = rotate_left(T[ 4] + SBOX[T[ 3] % 512], 9);
354  T[ 5] = rotate_left(T[ 5] + SBOX[T[ 4] % 512], 9);
355  T[ 6] = rotate_left(T[ 6] + SBOX[T[ 5] % 512], 9);
356  T[ 7] = rotate_left(T[ 7] + SBOX[T[ 6] % 512], 9);
357  T[ 8] = rotate_left(T[ 8] + SBOX[T[ 7] % 512], 9);
358  T[ 9] = rotate_left(T[ 9] + SBOX[T[ 8] % 512], 9);
359  T[10] = rotate_left(T[10] + SBOX[T[ 9] % 512], 9);
360  T[11] = rotate_left(T[11] + SBOX[T[10] % 512], 9);
361  T[12] = rotate_left(T[12] + SBOX[T[11] % 512], 9);
362  T[13] = rotate_left(T[13] + SBOX[T[12] % 512], 9);
363  T[14] = rotate_left(T[14] + SBOX[T[13] % 512], 9);
364  }
365 
366  EK[10*i + 0] = T[ 0];
367  EK[10*i + 1] = T[ 4];
368  EK[10*i + 2] = T[ 8];
369  EK[10*i + 3] = T[12];
370  EK[10*i + 4] = T[ 1];
371  EK[10*i + 5] = T[ 5];
372  EK[10*i + 6] = T[ 9];
373  EK[10*i + 7] = T[13];
374  EK[10*i + 8] = T[ 2];
375  EK[10*i + 9] = T[ 6];
376  }
377 
378  for(size_t i = 5; i != 37; i += 2)
379  {
380  const u32bit key3 = EK[i] & 3;
381  EK[i] |= 3;
382  EK[i] ^= rotate_left(SBOX[265 + key3], EK[i-1] % 32) & gen_mask(EK[i]);
383  }
384  }
385 
386 }
void decrypt_n(const byte in[], byte out[], size_t blocks) const
Definition: mars.cpp:278
void store_le(u16bit in, byte out[2])
Definition: loadstor.h:427
T rotate_left(T input, size_t rot)
Definition: rotate.h:21
byte get_byte(size_t byte_num, T input)
Definition: get_byte.h:21
unsigned char byte
Definition: types.h:22
void encrypt_n(const byte in[], byte out[], size_t blocks) const
Definition: mars.cpp:235
T rotate_right(T input, size_t rot)
Definition: rotate.h:34
u32bit load_le< u32bit >(const byte in[], size_t off)
Definition: loadstor.h:183
unsigned int u32bit
Definition: types.h:32