Botan 1.10.17
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
12namespace Botan {
13
14namespace {
15
16/**
17* The MARS sbox
18*/
19const 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*/
110inline 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*/
130inline 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*/
150void 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*/
175void 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*/
201u32bit 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*/
235void 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*/
278void 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*/
321void 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}
Botan::Block_Cipher_Fixed_Params< 16, 16, 32, 4 >::BLOCK_SIZE
@ BLOCK_SIZE
Definition block_cipher.h:107
Botan::MARS::decrypt_n
void decrypt_n(const byte in[], byte out[], size_t blocks) const
Definition mars.cpp:278
Botan::MARS::encrypt_n
void encrypt_n(const byte in[], byte out[], size_t blocks) const
Definition mars.cpp:235
Botan::get_byte
byte get_byte(size_t byte_num, T input)
Definition get_byte.h:21
Botan::rotate_right
T rotate_right(T input, size_t rot)
Definition rotate.h:34
Botan::rotate_left
T rotate_left(T input, size_t rot)
Definition rotate.h:21
Botan::load_le
T load_le(const byte in[], size_t off)
Definition loadstor.h:116
Botan::u32bit
unsigned int u32bit
Definition types.h:32
Botan::store_le
void store_le(u16bit in, byte out[2])
Definition loadstor.h:427
Generated by doxygen 1.18.0