1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61#define USE_PRECOMPUTED_u_sbox 1
62#define USE_REPETITIVE_SPEEDUP 0
63#define USE_ip_mask 0
64#define USE_de_keys 0
65
66
67
68static const uint8_t IP[64] ALIGN1 = {
69 58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,
70 62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,
71 57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
72 61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7
73};
74
75static const uint8_t key_perm[56] ALIGN1 = {
76 57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
77 10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,
78 63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
79 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4
80};
81
82static const uint8_t key_shifts[16] ALIGN1 = {
83 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
84};
85
86static const uint8_t comp_perm[48] ALIGN1 = {
87 14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,
88 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,
89 41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
90 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
91};
92
93
94
95
96#if !USE_PRECOMPUTED_u_sbox
97static const uint8_t sbox[8][64] = {
98 { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
99 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
100 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
101 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13
102 },
103 { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
104 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
105 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
106 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9
107 },
108 { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
109 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
110 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
111 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12
112 },
113 { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
114 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
115 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
116 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14
117 },
118 { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
119 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
120 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
121 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3
122 },
123 { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
124 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
125 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
126 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13
127 },
128 { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
129 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
130 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
131 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12
132 },
133 { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
134 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
135 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
136 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11
137 }
138};
139#else
140static const uint8_t u_sbox[8][32] = {
141 { 0x0e, 0xf4, 0x7d, 0x41, 0xe2, 0x2f, 0xdb, 0x18,
142 0xa3, 0x6a, 0xc6, 0xbc, 0x95, 0x59, 0x30, 0x87,
143 0xf4, 0xc1, 0x8e, 0x28, 0x4d, 0x96, 0x12, 0x7b,
144 0x5f, 0xbc, 0x39, 0xe7, 0xa3, 0x0a, 0x65, 0xd0,
145 },
146 { 0x3f, 0xd1, 0x48, 0x7e, 0xf6, 0x2b, 0x83, 0xe4,
147 0xc9, 0x07, 0x12, 0xad, 0x6c, 0x90, 0xb5, 0x5a,
148 0xd0, 0x8e, 0xa7, 0x1b, 0x3a, 0xf4, 0x4d, 0x21,
149 0xb5, 0x68, 0x7c, 0xc6, 0x09, 0x53, 0xe2, 0x9f,
150 },
151 { 0xda, 0x70, 0x09, 0x9e, 0x36, 0x43, 0x6f, 0xa5,
152 0x21, 0x8d, 0x5c, 0xe7, 0xcb, 0xb4, 0xf2, 0x18,
153 0x1d, 0xa6, 0xd4, 0x09, 0x68, 0x9f, 0x83, 0x70,
154 0x4b, 0xf1, 0xe2, 0x3c, 0xb5, 0x5a, 0x2e, 0xc7,
155 },
156 { 0xd7, 0x8d, 0xbe, 0x53, 0x60, 0xf6, 0x09, 0x3a,
157 0x41, 0x72, 0x28, 0xc5, 0x1b, 0xac, 0xe4, 0x9f,
158 0x3a, 0xf6, 0x09, 0x60, 0xac, 0x1b, 0xd7, 0x8d,
159 0x9f, 0x41, 0x53, 0xbe, 0xc5, 0x72, 0x28, 0xe4,
160 },
161 { 0xe2, 0xbc, 0x24, 0xc1, 0x47, 0x7a, 0xdb, 0x16,
162 0x58, 0x05, 0xf3, 0xaf, 0x3d, 0x90, 0x8e, 0x69,
163 0xb4, 0x82, 0xc1, 0x7b, 0x1a, 0xed, 0x27, 0xd8,
164 0x6f, 0xf9, 0x0c, 0x95, 0xa6, 0x43, 0x50, 0x3e,
165 },
166 { 0xac, 0xf1, 0x4a, 0x2f, 0x79, 0xc2, 0x96, 0x58,
167 0x60, 0x1d, 0xd3, 0xe4, 0x0e, 0xb7, 0x35, 0x8b,
168 0x49, 0x3e, 0x2f, 0xc5, 0x92, 0x58, 0xfc, 0xa3,
169 0xb7, 0xe0, 0x14, 0x7a, 0x61, 0x0d, 0x8b, 0xd6,
170 },
171 { 0xd4, 0x0b, 0xb2, 0x7e, 0x4f, 0x90, 0x18, 0xad,
172 0xe3, 0x3c, 0x59, 0xc7, 0x25, 0xfa, 0x86, 0x61,
173 0x61, 0xb4, 0xdb, 0x8d, 0x1c, 0x43, 0xa7, 0x7e,
174 0x9a, 0x5f, 0x06, 0xf8, 0xe0, 0x25, 0x39, 0xc2,
175 },
176 { 0x1d, 0xf2, 0xd8, 0x84, 0xa6, 0x3f, 0x7b, 0x41,
177 0xca, 0x59, 0x63, 0xbe, 0x05, 0xe0, 0x9c, 0x27,
178 0x27, 0x1b, 0xe4, 0x71, 0x49, 0xac, 0x8e, 0xd2,
179 0xf0, 0xc6, 0x9a, 0x0d, 0x3f, 0x53, 0x65, 0xb8,
180 },
181};
182#endif
183
184static const uint8_t pbox[32] ALIGN1 = {
185 16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,
186 2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25
187};
188
189static const uint32_t bits32[32] ALIGN4 = {
190 0x80000000, 0x40000000, 0x20000000, 0x10000000,
191 0x08000000, 0x04000000, 0x02000000, 0x01000000,
192 0x00800000, 0x00400000, 0x00200000, 0x00100000,
193 0x00080000, 0x00040000, 0x00020000, 0x00010000,
194 0x00008000, 0x00004000, 0x00002000, 0x00001000,
195 0x00000800, 0x00000400, 0x00000200, 0x00000100,
196 0x00000080, 0x00000040, 0x00000020, 0x00000010,
197 0x00000008, 0x00000004, 0x00000002, 0x00000001
198};
199
200static const uint8_t bits8[8] ALIGN1 = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
201
202
203static int
204ascii_to_bin(char ch)
205{
206 if (ch > 'z')
207 return 0;
208 if (ch >= 'a')
209 return (ch - 'a' + 38);
210 if (ch > 'Z')
211 return 0;
212 if (ch >= 'A')
213 return (ch - 'A' + 12);
214 if (ch > '9')
215 return 0;
216 if (ch >= '.')
217 return (ch - '.');
218 return 0;
219}
220
221
222
223
224
225struct const_des_ctx {
226#if USE_ip_mask
227 uint8_t init_perm[64];
228#endif
229 uint8_t final_perm[64];
230 uint8_t m_sbox[4][4096];
231};
232#define C (*cctx)
233#define init_perm (C.init_perm )
234#define final_perm (C.final_perm)
235#define m_sbox (C.m_sbox )
236
237static struct const_des_ctx*
238const_des_init(void)
239{
240 unsigned i, j, b;
241 struct const_des_ctx *cctx;
242
243#if !USE_PRECOMPUTED_u_sbox
244 uint8_t u_sbox[8][64];
245
246 cctx = xmalloc(sizeof(*cctx));
247
248
249 for (i = 0; i < 8; i++) {
250 for (j = 0; j < 64; j++) {
251 b = (j & 0x20) | ((j & 1) << 4) | ((j >> 1) & 0xf);
252 u_sbox[i][j] = sbox[i][b];
253 }
254 }
255 for (i = 0; i < 8; i++) {
256 fprintf(stderr, "\t{\t");
257 for (j = 0; j < 64; j+=2)
258 fprintf(stderr, " 0x%02x,", u_sbox[i][j] + u_sbox[i][j+1]*16);
259 fprintf(stderr, "\n\t},\n");
260 }
261
262
263
264
265 for (b = 0; b < 4; b++)
266 for (i = 0; i < 64; i++)
267 for (j = 0; j < 64; j++)
268 m_sbox[b][(i << 6) | j] =
269 (uint8_t)((u_sbox[(b << 1)][i] << 4) |
270 u_sbox[(b << 1) + 1][j]);
271#else
272 cctx = xmalloc(sizeof(*cctx));
273
274
275
276
277
278 for (b = 0; b < 4; b++)
279 for (i = 0; i < 64; i++)
280 for (j = 0; j < 64; j++) {
281 uint8_t lo, hi;
282 hi = u_sbox[(b << 1)][i / 2];
283 if (!(i & 1))
284 hi <<= 4;
285 lo = u_sbox[(b << 1) + 1][j / 2];
286 if (j & 1)
287 lo >>= 4;
288 m_sbox[b][(i << 6) | j] = (hi & 0xf0) | (lo & 0x0f);
289 }
290#endif
291
292
293
294
295 for (i = 0; i < 64; i++) {
296 final_perm[i] = IP[i] - 1;
297#if USE_ip_mask
298 init_perm[final_perm[i]] = (uint8_t)i;
299#endif
300 }
301
302 return cctx;
303}
304
305
306struct des_ctx {
307 const struct const_des_ctx *const_ctx;
308 uint32_t saltbits;
309#if USE_REPETITIVE_SPEEDUP
310 uint32_t old_salt;
311 uint32_t old_rawkey0, old_rawkey1;
312#endif
313 uint8_t un_pbox[32];
314 uint8_t inv_comp_perm[56];
315 uint8_t inv_key_perm[64];
316 uint32_t en_keysl[16], en_keysr[16];
317#if USE_de_keys
318 uint32_t de_keysl[16], de_keysr[16];
319#endif
320#if USE_ip_mask
321 uint32_t ip_maskl[8][256], ip_maskr[8][256];
322#endif
323 uint32_t fp_maskl[8][256], fp_maskr[8][256];
324 uint32_t key_perm_maskl[8][128], key_perm_maskr[8][128];
325 uint32_t comp_maskl[8][128], comp_maskr[8][128];
326 uint32_t psbox[4][256];
327};
328#define D (*ctx)
329#define const_ctx (D.const_ctx )
330#define saltbits (D.saltbits )
331#define old_salt (D.old_salt )
332#define old_rawkey0 (D.old_rawkey0 )
333#define old_rawkey1 (D.old_rawkey1 )
334#define un_pbox (D.un_pbox )
335#define inv_comp_perm (D.inv_comp_perm )
336#define inv_key_perm (D.inv_key_perm )
337#define en_keysl (D.en_keysl )
338#define en_keysr (D.en_keysr )
339#define de_keysl (D.de_keysl )
340#define de_keysr (D.de_keysr )
341#define ip_maskl (D.ip_maskl )
342#define ip_maskr (D.ip_maskr )
343#define fp_maskl (D.fp_maskl )
344#define fp_maskr (D.fp_maskr )
345#define key_perm_maskl (D.key_perm_maskl )
346#define key_perm_maskr (D.key_perm_maskr )
347#define comp_maskl (D.comp_maskl )
348#define comp_maskr (D.comp_maskr )
349#define psbox (D.psbox )
350
351static struct des_ctx*
352des_init(struct des_ctx *ctx, const struct const_des_ctx *cctx)
353{
354 int i, j, b, k, inbit, obit;
355 uint32_t p;
356 const uint32_t *bits28, *bits24;
357
358 if (!ctx)
359 ctx = xmalloc(sizeof(*ctx));
360 const_ctx = cctx;
361
362#if USE_REPETITIVE_SPEEDUP
363 old_rawkey0 = old_rawkey1 = 0;
364 old_salt = 0;
365#endif
366 saltbits = 0;
367 bits28 = bits32 + 4;
368 bits24 = bits28 + 4;
369
370
371 for (i = 0; i < 64; i++) {
372 inv_key_perm[i] = 255;
373 }
374
375
376
377
378
379 for (i = 0; i < 56; i++) {
380 inv_key_perm[key_perm[i] - 1] = (uint8_t)i;
381 inv_comp_perm[i] = 255;
382 }
383
384
385 for (i = 0; i < 48; i++) {
386 inv_comp_perm[comp_perm[i] - 1] = (uint8_t)i;
387 }
388
389
390
391
392
393 for (k = 0; k < 8; k++) {
394 uint32_t il, ir;
395 uint32_t fl, fr;
396 for (i = 0; i < 256; i++) {
397#if USE_ip_mask
398 il = 0;
399 ir = 0;
400#endif
401 fl = 0;
402 fr = 0;
403 for (j = 0; j < 8; j++) {
404 inbit = 8 * k + j;
405 if (i & bits8[j]) {
406#if USE_ip_mask
407 obit = init_perm[inbit];
408 if (obit < 32)
409 il |= bits32[obit];
410 else
411 ir |= bits32[obit - 32];
412#endif
413 obit = final_perm[inbit];
414 if (obit < 32)
415 fl |= bits32[obit];
416 else
417 fr |= bits32[obit - 32];
418 }
419 }
420#if USE_ip_mask
421 ip_maskl[k][i] = il;
422 ip_maskr[k][i] = ir;
423#endif
424 fp_maskl[k][i] = fl;
425 fp_maskr[k][i] = fr;
426 }
427 for (i = 0; i < 128; i++) {
428 il = 0;
429 ir = 0;
430 for (j = 0; j < 7; j++) {
431 inbit = 8 * k + j;
432 if (i & bits8[j + 1]) {
433 obit = inv_key_perm[inbit];
434 if (obit == 255)
435 continue;
436 if (obit < 28)
437 il |= bits28[obit];
438 else
439 ir |= bits28[obit - 28];
440 }
441 }
442 key_perm_maskl[k][i] = il;
443 key_perm_maskr[k][i] = ir;
444 il = 0;
445 ir = 0;
446 for (j = 0; j < 7; j++) {
447 inbit = 7 * k + j;
448 if (i & bits8[j + 1]) {
449 obit = inv_comp_perm[inbit];
450 if (obit == 255)
451 continue;
452 if (obit < 24)
453 il |= bits24[obit];
454 else
455 ir |= bits24[obit - 24];
456 }
457 }
458 comp_maskl[k][i] = il;
459 comp_maskr[k][i] = ir;
460 }
461 }
462
463
464
465
466
467 for (i = 0; i < 32; i++)
468 un_pbox[pbox[i] - 1] = (uint8_t)i;
469
470 for (b = 0; b < 4; b++) {
471 for (i = 0; i < 256; i++) {
472 p = 0;
473 for (j = 0; j < 8; j++) {
474 if (i & bits8[j])
475 p |= bits32[un_pbox[8 * b + j]];
476 }
477 psbox[b][i] = p;
478 }
479 }
480
481 return ctx;
482}
483
484
485static void
486setup_salt(struct des_ctx *ctx, uint32_t salt)
487{
488 uint32_t obit, saltbit;
489 int i;
490
491#if USE_REPETITIVE_SPEEDUP
492 if (salt == old_salt)
493 return;
494 old_salt = salt;
495#endif
496
497 saltbits = 0;
498 saltbit = 1;
499 obit = 0x800000;
500 for (i = 0; i < 24; i++) {
501 if (salt & saltbit)
502 saltbits |= obit;
503 saltbit <<= 1;
504 obit >>= 1;
505 }
506}
507
508static void
509des_setkey(struct des_ctx *ctx, const char *key)
510{
511 uint32_t k0, k1, rawkey0, rawkey1;
512 int shifts, round;
513
514 rawkey0 = ntohl(*(const uint32_t *) key);
515 rawkey1 = ntohl(*(const uint32_t *) (key + 4));
516
517#if USE_REPETITIVE_SPEEDUP
518 if ((rawkey0 | rawkey1)
519 && rawkey0 == old_rawkey0
520 && rawkey1 == old_rawkey1
521 ) {
522
523
524
525
526
527
528 return;
529 }
530 old_rawkey0 = rawkey0;
531 old_rawkey1 = rawkey1;
532#endif
533
534
535
536
537 k0 = key_perm_maskl[0][rawkey0 >> 25]
538 | key_perm_maskl[1][(rawkey0 >> 17) & 0x7f]
539 | key_perm_maskl[2][(rawkey0 >> 9) & 0x7f]
540 | key_perm_maskl[3][(rawkey0 >> 1) & 0x7f]
541 | key_perm_maskl[4][rawkey1 >> 25]
542 | key_perm_maskl[5][(rawkey1 >> 17) & 0x7f]
543 | key_perm_maskl[6][(rawkey1 >> 9) & 0x7f]
544 | key_perm_maskl[7][(rawkey1 >> 1) & 0x7f];
545 k1 = key_perm_maskr[0][rawkey0 >> 25]
546 | key_perm_maskr[1][(rawkey0 >> 17) & 0x7f]
547 | key_perm_maskr[2][(rawkey0 >> 9) & 0x7f]
548 | key_perm_maskr[3][(rawkey0 >> 1) & 0x7f]
549 | key_perm_maskr[4][rawkey1 >> 25]
550 | key_perm_maskr[5][(rawkey1 >> 17) & 0x7f]
551 | key_perm_maskr[6][(rawkey1 >> 9) & 0x7f]
552 | key_perm_maskr[7][(rawkey1 >> 1) & 0x7f];
553
554
555
556 shifts = 0;
557 for (round = 0; round < 16; round++) {
558 uint32_t t0, t1;
559
560 shifts += key_shifts[round];
561
562 t0 = (k0 << shifts) | (k0 >> (28 - shifts));
563 t1 = (k1 << shifts) | (k1 >> (28 - shifts));
564
565#if USE_de_keys
566 de_keysl[15 - round] =
567#endif
568 en_keysl[round] = comp_maskl[0][(t0 >> 21) & 0x7f]
569 | comp_maskl[1][(t0 >> 14) & 0x7f]
570 | comp_maskl[2][(t0 >> 7) & 0x7f]
571 | comp_maskl[3][t0 & 0x7f]
572 | comp_maskl[4][(t1 >> 21) & 0x7f]
573 | comp_maskl[5][(t1 >> 14) & 0x7f]
574 | comp_maskl[6][(t1 >> 7) & 0x7f]
575 | comp_maskl[7][t1 & 0x7f];
576
577#if USE_de_keys
578 de_keysr[15 - round] =
579#endif
580 en_keysr[round] = comp_maskr[0][(t0 >> 21) & 0x7f]
581 | comp_maskr[1][(t0 >> 14) & 0x7f]
582 | comp_maskr[2][(t0 >> 7) & 0x7f]
583 | comp_maskr[3][t0 & 0x7f]
584 | comp_maskr[4][(t1 >> 21) & 0x7f]
585 | comp_maskr[5][(t1 >> 14) & 0x7f]
586 | comp_maskr[6][(t1 >> 7) & 0x7f]
587 | comp_maskr[7][t1 & 0x7f];
588 }
589}
590
591
592static void
593do_des(struct des_ctx *ctx, uint32_t *l_out, uint32_t *r_out, int count)
594{
595 const struct const_des_ctx *cctx = const_ctx;
596
597
598
599 uint32_t l, r, *kl, *kr;
600 uint32_t f = f;
601 uint32_t r48l, r48r;
602 int round;
603
604
605#if USE_ip_mask
606 uint32_t l_in = 0;
607 uint32_t r_in = 0;
608 l = ip_maskl[0][l_in >> 24]
609 | ip_maskl[1][(l_in >> 16) & 0xff]
610 | ip_maskl[2][(l_in >> 8) & 0xff]
611 | ip_maskl[3][l_in & 0xff]
612 | ip_maskl[4][r_in >> 24]
613 | ip_maskl[5][(r_in >> 16) & 0xff]
614 | ip_maskl[6][(r_in >> 8) & 0xff]
615 | ip_maskl[7][r_in & 0xff];
616 r = ip_maskr[0][l_in >> 24]
617 | ip_maskr[1][(l_in >> 16) & 0xff]
618 | ip_maskr[2][(l_in >> 8) & 0xff]
619 | ip_maskr[3][l_in & 0xff]
620 | ip_maskr[4][r_in >> 24]
621 | ip_maskr[5][(r_in >> 16) & 0xff]
622 | ip_maskr[6][(r_in >> 8) & 0xff]
623 | ip_maskr[7][r_in & 0xff];
624#elif 0
625 l = r = 0;
626 for (round = 0; round < 8; round++) {
627 l |= ip_maskl[round][0];
628 r |= ip_maskr[round][0];
629 }
630 bb_error_msg("l:%x r:%x", l, r);
631#else
632 l = r = 0;
633#endif
634
635 do {
636
637 kl = en_keysl;
638 kr = en_keysr;
639 round = 16;
640 do {
641
642 r48l = ((r & 0x00000001) << 23)
643 | ((r & 0xf8000000) >> 9)
644 | ((r & 0x1f800000) >> 11)
645 | ((r & 0x01f80000) >> 13)
646 | ((r & 0x001f8000) >> 15);
647
648 r48r = ((r & 0x0001f800) << 7)
649 | ((r & 0x00001f80) << 5)
650 | ((r & 0x000001f8) << 3)
651 | ((r & 0x0000001f) << 1)
652 | ((r & 0x80000000) >> 31);
653
654
655
656
657 f = (r48l ^ r48r) & saltbits;
658 r48l ^= f ^ *kl++;
659 r48r ^= f ^ *kr++;
660
661
662
663
664 f = psbox[0][m_sbox[0][r48l >> 12]]
665 | psbox[1][m_sbox[1][r48l & 0xfff]]
666 | psbox[2][m_sbox[2][r48r >> 12]]
667 | psbox[3][m_sbox[3][r48r & 0xfff]];
668
669 f ^= l;
670 l = r;
671 r = f;
672 } while (--round);
673 r = l;
674 l = f;
675 } while (--count);
676
677
678 *l_out = fp_maskl[0][l >> 24]
679 | fp_maskl[1][(l >> 16) & 0xff]
680 | fp_maskl[2][(l >> 8) & 0xff]
681 | fp_maskl[3][l & 0xff]
682 | fp_maskl[4][r >> 24]
683 | fp_maskl[5][(r >> 16) & 0xff]
684 | fp_maskl[6][(r >> 8) & 0xff]
685 | fp_maskl[7][r & 0xff];
686 *r_out = fp_maskr[0][l >> 24]
687 | fp_maskr[1][(l >> 16) & 0xff]
688 | fp_maskr[2][(l >> 8) & 0xff]
689 | fp_maskr[3][l & 0xff]
690 | fp_maskr[4][r >> 24]
691 | fp_maskr[5][(r >> 16) & 0xff]
692 | fp_maskr[6][(r >> 8) & 0xff]
693 | fp_maskr[7][r & 0xff];
694}
695
696#define DES_OUT_BUFSIZE 21
697
698static void
699to64_msb_first(char *s, unsigned v)
700{
701#if 0
702 *s++ = ascii64[(v >> 18) & 0x3f];
703 *s++ = ascii64[(v >> 12) & 0x3f];
704 *s++ = ascii64[(v >> 6) & 0x3f];
705 *s = ascii64[v & 0x3f];
706#endif
707 *s++ = i64c(v >> 18);
708 *s++ = i64c(v >> 12);
709 *s++ = i64c(v >> 6);
710 *s = i64c(v);
711}
712
713static char *
714NOINLINE
715des_crypt(struct des_ctx *ctx, char output[DES_OUT_BUFSIZE],
716 const unsigned char *key, const unsigned char *salt_str)
717{
718 uint32_t salt, r0, r1, keybuf[2];
719 uint8_t *q;
720
721
722 if (!salt_str[0] || !salt_str[1])
723 return NULL;
724
725
726
727
728
729 q = (uint8_t *)keybuf;
730 while (q - (uint8_t *)keybuf != 8) {
731 *q = *key << 1;
732 if (*q)
733 key++;
734 q++;
735 }
736 des_setkey(ctx, (char *)keybuf);
737
738
739
740
741
742 output[0] = salt_str[0];
743 output[1] = salt_str[1];
744 salt = (ascii_to_bin(salt_str[1]) << 6)
745 | ascii_to_bin(salt_str[0]);
746 setup_salt(ctx, salt);
747
748
749 do_des(ctx, &r0, &r1, 25 );
750
751
752#if 0
753{
754 uint32_t l = (r0 >> 8);
755 q = (uint8_t *)output + 2;
756 *q++ = ascii64[(l >> 18) & 0x3f];
757 *q++ = ascii64[(l >> 12) & 0x3f];
758 *q++ = ascii64[(l >> 6) & 0x3f];
759 *q++ = ascii64[l & 0x3f];
760 l = ((r0 << 16) | (r1 >> 16));
761 *q++ = ascii64[(l >> 18) & 0x3f];
762 *q++ = ascii64[(l >> 12) & 0x3f];
763 *q++ = ascii64[(l >> 6) & 0x3f];
764 *q++ = ascii64[l & 0x3f];
765 l = r1 << 2;
766 *q++ = ascii64[(l >> 12) & 0x3f];
767 *q++ = ascii64[(l >> 6) & 0x3f];
768 *q++ = ascii64[l & 0x3f];
769 *q = 0;
770}
771#else
772
773
774 to64_msb_first(output + 2, (r0 >> 8));
775
776 to64_msb_first(output + 6, (r0 << 16) | (r1 >> 16));
777
778 to64_msb_first(output + 10, (r1 << 8));
779
780 output[13] = '\0';
781#endif
782
783 return output;
784}
785
786#undef USE_PRECOMPUTED_u_sbox
787#undef USE_REPETITIVE_SPEEDUP
788#undef USE_ip_mask
789#undef USE_de_keys
790
791#undef C
792#undef init_perm
793#undef final_perm
794#undef m_sbox
795#undef D
796#undef const_ctx
797#undef saltbits
798#undef old_salt
799#undef old_rawkey0
800#undef old_rawkey1
801#undef un_pbox
802#undef inv_comp_perm
803#undef inv_key_perm
804#undef en_keysl
805#undef en_keysr
806#undef de_keysl
807#undef de_keysr
808#undef ip_maskl
809#undef ip_maskr
810#undef fp_maskl
811#undef fp_maskr
812#undef key_perm_maskl
813#undef key_perm_maskr
814#undef comp_maskl
815#undef comp_maskr
816#undef psbox
817