Develop and Download Open Source Software

プロジェクト・ナニ屋

Browse Subversion Repository

/[naniya]/branches/mty-makai/mty.c

Contents of /branches/mty-makai/mty.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 24 - (show annotations) (download) (as text)
Sat Mar 17 12:11:18 2007 UTC (17 years ago) by chapuni
Original Path: mty/mty.c
File MIME type: text/x-csrc
File size: 32812 byte(s) 
ログ出力周りを整理。ついでにエラー処理を盛り込む。
実際のエラーにおける挙動に関しては未検証。
1 /***********************************************************************
2 *
3 * file: mty.cpp
4 *
5 * ‚Ü‚ A‘҂ĉŽB
6 *
7 * $Id$
8 *
9 */
10
11 #define DEBUG 0
12 #define USE_DT 1
13
14 #ifndef DEBUG
15 #define NDEBUG
16 #endif
17
18 #include <assert.h>
19 #include <ctype.h>
20 #include <errno.h>
21 #include <malloc.h>
22 #include <limits.h>
23 #include <stdarg.h>
24 #include <stddef.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <time.h>
29
30 #ifdef __GNUC__
31
32 #include <stdint.h>
33 #define ALIGN_PREFIX(n)
34 #define ALIGN_SUFFIX(n) __attribute__ ((aligned(n)))
35 #ifdef __SSE__
36 typedef unsigned DQWORD_T __attribute__ ((mode(V4SI)));
37 #endif
38
39 #else
40
41 #include <xmmintrin.h>
42 #define ALIGN_PREFIX(n) __declspec(align(16))
43 #define ALIGN_SUFFIX(n)
44
45 /* inttypes.h */
46 typedef __int8 int8_t;
47 typedef __int32 int32_t;
48 typedef unsigned __int32 uint32_t;
49 typedef unsigned __int64 uint64_t;
50
51 typedef __m128 DQWORD_T;
52
53 #endif
54
55 #if defined(WIN32)
56
57 #include <windows.h>
58 #include <sys/timeb.h>
59
60 #elif defined(__GNUC__)
61
62 #include <sys/mman.h>
63 #include <sys/time.h>
64
65 #endif
66
67 #include "crypt64.h"
68 #include "dt4.h"
69
70 #if defined(USE_MMX)
71
72 #define N_STRIDE 6
73 typedef uint64_t WS_T;
74 typedef uint32_t ALU_T;
75
76 #define CRYPT64_CLOBBER /* "%ecx", "%edx", */
77
78 #elif defined(USE_64) /* 64-bit ALU */
79
80 #define N_STRIDE 6
81 typedef uint64_t WS_T;
82 typedef uint64_t ALU_T;
83
84 #define CRYPT64_CLOBBER /* "%rcx", "%rdx",*/ "%r8", "%r9",
85
86 #elif defined(USE_64_XMM)
87
88 #define N_STRIDE 7
89 typedef DQWORD_T WS_T;
90 typedef uint64_t ALU_T;
91
92 #define CRYPT64_CLOBBER /* "%rcx", "%rdx",*/
93
94 #else /* XMM */
95
96 #define N_STRIDE 7
97 typedef DQWORD_T WS_T;
98 typedef uint32_t ALU_T;
99
100 #define CRYPT64_CLOBBER /* "%ecx", "%edx", */
101
102 #endif
103
104 #define N_I (sizeof(WS_T) / sizeof(uint32_t))
105 #define N_ALU (sizeof(WS_T) / sizeof(ALU_T))
106 #define ALU_BITS (CHAR_BIT * sizeof(ALU_T))
107
108 /* ŒŽ“]’u PC1 */
109 static int const tr_pc1[8][7] =
110 {
111 { 8, 16, 24, 56, 52, 44, 36},
112 { 7, 15, 23, 55, 51, 43, 35},
113 { 6, 14, 22, 54, 50, 42, 34},
114 { 5, 13, 21, 53, 49, 41, 33},
115 { 4, 12, 20, 28, 48, 40, 32},
116 { 3, 11, 19, 27, 47, 39, 31},
117 { 2, 10, 18, 26, 46, 38, 30},
118 { 1, 9, 17, 25, 45, 37, 29},
119 };
120
121 /* LRĹI“]’u */
122 static int const tr_fp[64 + 2] =
123 {
124 39, 7, 47, 15, 55, 23, 63, 31,
125 38, 6, 46, 14, 54, 22, 62, 30,
126 37, 5, 45, 13, 53, 21, 61, 29,
127 36, 4, 44, 12, 52, 20, 60, 28,
128 35, 3, 43, 11, 51, 19, 59, 27,
129 34, 2, 42, 10, 50, 18, 58, 26,
130 33, 1, 41, 9, 49, 17, 57, 25,
131 32, 0, 40, 8, 48, 16, 56, 24,
132 64, 64,
133 };
134
135 /* ŒŽƒVƒtƒgƒXƒPƒWƒ…[ƒ‹
136 KEY::k[2] ‚đćґň‚É—p‚˘‚ÄŽć‚čo‚ľ‚ĚŠČ‘f‰ť‚đ}‚é */
137 static int ks_ls[] =
138 {
139 1, 1, 2, -1,
140 2, -1, 2, -1,
141 2, -1, 2, -1,
142 2, -1, 1, 2,
143 -1, 2, -1, 2,
144 -1, 2, -1, 2,
145 -1, 2, -1, 1 - 28,
146 };
147
148 /* 1ƒrƒbƒg•Ş */
149 typedef union SLICE
150 {
151 uint32_t i[N_I]; /* 32-bit initializer */
152 ALU_T a[N_ALU]; /* C ‚Ĺˆľ‚˘‚₡‚˘ƒTƒCƒY */
153 WS_T w; /* ƒGƒ“ƒR[ƒh‚Ĺˆľ‚¤ƒTƒCƒY */
154 } SLICE;
155
156 /* crypt64() ‚Ş‹ň‚¤ƒpƒ‰ƒ[ƒ^ */
157 struct PARAM
158 {
159 SLICE lr[2][32];
160 SLICE t[32];
161 SLICE hit[10][64];
162 SLICE hiti[10][26];
163 };
164
165 /* ŒŽ‚ÍLR ‚ƁA‚ť‚ĚƒRƒs[‚Ş•K—v
166 KEY::k[0] LR
167 KEY::k[1] LR‚ĚƒRƒs[(č—]‚đČ‚­‚˝‚ß)
168 KEY::k[2][0][i].a[0] ŽŸŒŽ‚Ö‚Ě‘•Ş */
169 struct KEY
170 {
171 SLICE k[2][2][28];
172 SLICE ks[28];
173 };
174
175 /* ŠżŽšƒNƒ‰ƒX•\ */
176 unsigned char cp932[0x10000] = {
177 #include "cp932.inc"
178 };
179
180 /* ŒŽ•śŽš—ń */
181 unsigned char key[8 + 8];
182 unsigned char okey[8 + 8];
183
184 /* ŒŽƒNƒ‰ƒX */
185 struct
186 {
187 unsigned cls;
188 unsigned map[256];
189 } kcls[8 + 8];
190
191 #define KCLS_AN 1
192 #define KCLS_KA 2
193 #define KCLS_K1 4
194 #define KCLS_DT0 64
195 #define KCLS_DT1 128
196 #define KCLS_K2 256
197
198 #if USE_DT
199 /* ŒŽƒLƒ—pŽŤ‘ƒCƒ“ƒfƒNƒX */
200 struct DT *kd[8 + 8];
201
202 /* ŽŤ‘ƒCƒ“ƒfƒNƒX */
203 struct DT *dtidx[0x100 + 1];
204 #endif
205
206 /* Žw’č‚ł‚ę‚˝ƒNƒ‰ƒX‚Ć“ü‚Á‚Ä‚˘‚éƒL[‚Š‚çAclassify ‚đs‚¤ */
207 void
208 key_make_map(int n)
209 {
210 int i, j;
211 unsigned c = kcls[n].map[key[n]];
212
213 if (3 <= n && n < 7 && kd[n - 3])
214 {
215 /* ŽŤ‘‚ĚƒPƒc‚Ě•śŽšBŒă‚ë‚Ƀiƒjƒ„ƒ‰ƒLƒƒƒ‰ƒNƒ^‚Ş—ˆ‚é */
216 c = kd[n - 3]->c[0];
217 if ((0x81 <= c && c <= 0x9F)
218 || (0xE0 <= c && c <= 0xFC))
219 c = KCLS_K2;
220 else
221 c = (cp932[256 * key[n]]
222 | cp932[256 * (key[n] ^ 0x80)]);
223 #if DEBUG>=1
224 printf("*n=%d, key=%02X, cls=%04X\n",
225 n,
226 key[n],
227 c);
228 #endif
229 }
230 else if (2 <= n && n < 6 && kd[n - 2])
231 {
232 return;
233 }
234 else if (1 <= n && n < 5 && kd[n - 1])
235 {
236 return;
237 }
238 else if (1 <= n && n < 5 && !kd[n - 1]
239 //&& (c & KCLS_K2)
240 && (c & KCLS_DT1))
241 {
242 /* ŠżŽš2•śŽš‚đE‚Á‚Ä‚˘‚Ť‚Ü‚Â */
243 #if DEBUG>=1
244 printf("(%d)%02X %02X(%02X:%02X:%02X:%02X)\n",
245 n, key[n - 1], key[n],
246 cp932[(256 * key[n - 1] + key[n])],
247 cp932[(256 * key[n - 1] + key[n]) ^ 0x0080],
248 cp932[(256 * key[n - 1] + key[n]) ^ 0x8000],
249 cp932[(256 * key[n - 1] + key[n]) ^ 0x8080]);
250 #endif
251 if (n != 1 && n != 2
252 && (cp932[(256 * key[n - 1] + key[n]) ^ 0x0080] & KCLS_DT1))
253 key[n] ^= 0x80;
254 else if (n != 2 && n != 3
255 && (cp932[(256 * key[n - 1] + key[n]) ^ 0x8000] & KCLS_DT1))
256 key[n - 1] ^= 0x80;
257 else if (n > 3 && (cp932[(256 * key[n - 1] + key[n]) ^ 0x8080] & KCLS_DT1))
258 key[n - 1] ^= 0x80, key[n] ^= 0x80;
259 if (cp932[256 * key[n - 1] + key[n]] & KCLS_DT1)
260 {
261 for (kd[n - 1] = dtidx[key[n - 1]];
262 kd[n - 1]->c[1] != key[n];
263 kd[n - 1]++)
264 assert(kd[n - 1]->c[0] == key[n - 1]);
265 #if DEBUG>=1
266 printf("(%02X%02X:%02X%02X)%c%c%c%c\n",
267 kd[n - 1]->c[0],
268 kd[n - 1]->c[1],
269 kd[n - 1]->c[2],
270 kd[n - 1]->c[3],
271 kd[n - 1]->c[0],
272 kd[n - 1]->c[1],
273 kd[n - 1]->c[2],
274 kd[n - 1]->c[3]);
275 #endif
276 return;
277 }
278 }
279 else if (n < 4 && (c & KCLS_DT0) && kd[n] == NULL)
280 {
281 /* ƒJƒ^ƒJƒi–„‚ߍž‚Ý‚˘‚Ť‚Ü‚ˇ */
282 assert(kd[n] == NULL);
283 #if DEBUG>=1
284 printf("n=%d, key=%02X\n", n, key[n]);
285 #endif
286 kd[n] = dtidx[key[n]];
287 if (!kd[n]
288 && !(n == 1 || n == 2)
289 && dtidx[key[n] ^ 0x80])
290 {
291 key[n] ^= 0x80;
292 kd[n] = dtidx[key[n]];
293 }
294 if (kd[n])
295 return;
296 }
297 else
298 {
299 kd[n] = NULL;
300 }
301
302 /* ĹŒă‚Ě•”•Ş‚Í class map ‚𐜐Ź‚ˇ‚é•K—vƒiƒV */
303 if (n >= 6)
304 return;
305
306 for (i = 0; i < 256; i++)
307 {
308 unsigned bs = 0, bm = 0;
309 #if 1
310 if (c & KCLS_K1)
311 {
312 if (cp932[256 * key[n] + i] & KCLS_K1)
313 bm |= KCLS_K2 | (cp932[256 * key[n] + i] & KCLS_DT1);
314 if (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_K1)
315 bm |= KCLS_K2 | (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_DT1);
316 #if 0
317 bm |= ((cp932[256 * key[n] + i] & KCLS_K1)
318 || (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_K1)
319 ? KCLS_K2 : 0);
320 #endif
321 }
322 if (c & (KCLS_AN | KCLS_KA | KCLS_K2))
323 for (j = 0; j < 256; j++)
324 {
325 bm |= cp932[256 * i + j] & (KCLS_AN | KCLS_KA | KCLS_K1
326 | KCLS_DT0);
327 #if 0
328 if (j >= 127 && !(n == 0 || n == 1))
329 break;
330 #endif
331 }
332 kcls[n + 1].map[i] = bm;
333 #endif
334 if (i >= 128 && !(n == 0 || n == 1))
335 kcls[n + 1].map[i - 128] |= kcls[n + 1].map[i];
336 }
337
338 if (n < 6)
339 kcls[n + 1].map[0x00] = kcls[n + 1].map[0x80] = 0;
340 if (n == 6)
341 kcls[7].map[0x00] |= KCLS_AN;
342 }
343
344 unsigned
345 dt_get(int kdn,
346 int xn,
347 int n,
348 int ch)
349 {
350 int i;
351 #if DEBUG>=1
352 printf("*dt_get(%d)%c%c%c%c(%02X%02X:%02X%02X)->ch=%d",
353 n,
354 kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
355 kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
356 ch);
357 #endif
358 /* ‚Ü‚¸‚͐”‚Ś‚é */
359 for (i = 0;
360 kd[kdn][i].c[xn] == kd[kdn]->c[xn];
361 i++)
362 ;
363 assert(i > 0);
364 kd[kdn] += ch % i;
365 #if DEBUG>=1
366 printf("/%d\n dt_get: %c%c%c%c(%02X%02X:%02X%02X)->ch=%d\n",
367 i,
368 kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
369 kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
370 ch);
371 #endif
372 return kd[kdn]->c[n];
373 }
374
375 /* ƒ}ƒbƒv‚Š‚ç•śŽš‚đE‚Á‚ăZƒbƒg */
376 unsigned
377 key_set(int n, unsigned ch)
378 {
379 int cnt = 0, i;
380
381 if (3 <= n && n < 7 && kd[n - 3])
382 {
383 return dt_get(n - 3, 2, 3, ch);
384 return kd[n - 3]->c[3];
385 }
386 else if (2 <= n && n < 6 && kd[n - 2])
387 {
388 return dt_get(n - 2, 1, 2, ch);
389 return kd[n - 2]->c[2];
390 }
391 else if (1 <= n && n < 5 && kd[n - 1])
392 {
393 return dt_get(n - 1, 0, 1, ch);
394 return kd[n - 1]->c[1];
395 }
396
397 #if DEBUG>=3
398 if (cnt == 0)
399 {
400 printf("n=%d, ch=%d, (n-1)=%02X\n", n, ch, key[n - 1]);
401 int j;
402 for (i = 0; i < 16; i++)
403 {
404 printf("map[0x%02X] =", 16 * i);
405 for (j = 0; j < 16; j++)
406 printf(" %03X", kcls[n].map[16 * i + j]);
407 printf("\n");
408 }
409 }
410 #endif
411 for (i = 0; i < 256; i++)
412 {
413 if (kcls[n].map[i])
414 {
415 if (ch-- == 0)
416 return i;
417 cnt++;
418 }
419 if (n != 1 && n != 2 && i >= 127)
420 break;
421 }
422 /* ŒŠ‚‚Š‚ç‚Č‚Š‚Á‚˝‚Ě‚Ĺ‚ŕ‚˘‚Á‚Ř‚ń */
423 assert(cnt > 0);
424 ch %= cnt;
425 for (i = 0; i < 256; i++)
426 if (kcls[n].map[i])
427 {
428 if (ch-- == 0)
429 return i;
430 }
431 assert(!"not matched");
432 return 0;
433 }
434
435 /* bitwise key ‚đƒZƒbƒg */
436 static
437 void
438 key_set64(struct KEY *key64,
439 int n,
440 unsigned k,
441 unsigned vk,
442 unsigned sk)
443 {
444 int i, j;
445 if (!((vk | sk) & 0x7F))
446 return;
447
448 for (i = 0; i < 7; i++)
449 {
450 if (n == 7 && i < N_STRIDE) continue;
451 if (sk & (1 << i))
452 {
453 /* ƒZƒbƒg */
454 int o = tr_pc1[n][6 - i] - 1;
455 if (o < 28)
456 {
457 assert(o >= 0);
458 for (j = 0; j < N_ALU; j++)
459 key64->k[0][0][o].a[j]
460 = key64->k[0][1][o].a[j]
461 = -!!(k & (1 << i));
462 }
463 else
464 {
465 assert(o >= 28);
466 assert(o < 56);
467 for (j = 0; j < N_ALU; j++)
468 key64->k[1][0][o - 28].a[j]
469 = key64->k[1][1][o - 28].a[j]
470 = -!!(k & (1 << i));
471 }
472 }
473 else if (vk & (1 << i))
474 {
475 /* ”˝“] */
476 int o = tr_pc1[n][6 - i] - 1;
477 if (o < 28)
478 {
479 assert(o >= 0);
480 for (j = 0; j < N_ALU; j++)
481 key64->k[0][0][o].a[j]
482 = key64->k[0][1][o].a[j]
483 = ~key64->k[0][0][o].a[j];
484 }
485 else
486 {
487 assert(o >= 28);
488 assert(o < 56);
489 for (j = 0; j < N_ALU; j++)
490 key64->k[1][0][o - 28].a[j]
491 = key64->k[1][1][o - 28].a[j]
492 = ~key64->k[1][0][o - 28].a[j];
493 }
494 }
495 }
496 }
497
498 /* Žw’č‚ł‚ę‚˝ƒNƒ‰ƒX‚ĚŠJŽn’l‚ɃŠƒZƒbƒg
499 ’ź‘O‚Ě•śŽš‚ĚƒNƒ‰ƒX‚É”›‚ç‚ę‚é */
500 int
501 key_reset(int n)
502 {
503 if (n >= 8)
504 return 1;
505 if (n == 7)
506 {
507 key[7] = 0;
508 return 1;
509 }
510
511 /* 0-2 •śŽš–ڂ̓‰ƒ“ƒ_ƒ€‚ÉŒˆ‚ß‚é
512 3 •śŽš–ÚˆČ~‚͏‰Šú’l‚É */
513 if (n >= 3)
514 key[n] = key_set(n, 0);
515 else
516 key[n] = key_set(n, rand());
517
518 #if DEBUG>=3
519 printf("key[%d]=%02X ncls=%04X\n", n, key[n], kcls[n].map[key[n]]);
520 #endif
521
522 /* ƒZƒbƒg‚ł‚ę‚˝•śŽš‚đŒł‚ÉAŽŸƒLƒƒƒ‰‚Ě•śŽšƒNƒ‰ƒX‚đŒˆ‚ß‚é */
523 key_make_map(n);
524
525 return key_reset(n + 1);
526 }
527
528 /* Žw’č‚ł‚ę‚˝ŒŽ‹óŠÔ‚Ě’†‚ŁAƒL[‚đ‚ЂƂi‚ß‚é
529 ˆŔ‘S‚ɃCƒ“ƒNƒŠƒƒ“ƒg‚Ĺ‚Ť‚˝ę‡ true ‚đ•Ô‚ˇ */
530 static
531 int
532 key_inc(int n)
533 {
534 if (n >= 8)
535 return 0;
536 else if (n == 7)
537 {
538 /* ĹŒă‚ĚƒoƒCƒg */
539 if (N_STRIDE == 7)
540 return 0;
541
542 key[7] = (key[7] + 64) & 127;
543 if (key[7]) return 1;
544 else return 0;
545 }
546 else if (key_inc(n + 1)
547 /*
548 && key_inc(n + 1)
549 && key_inc(n + 1)
550 && key_inc(n + 1)*/
551 )
552 return 1;
553
554 /* Salt ‚̓Cƒ“ƒNƒŠƒƒ“ƒg‚ľ‚Č‚˘–ń‘Š‚É‚ˇ‚é */
555 if (n == 1 || n == 2)
556 return 1;
557
558 #if DEBUG>=3
559 printf("key_inc(n=%d,ck=%02X)\n", n, key[n]);
560 #endif
561
562 /* ŽŤ‘Œę‚̓Cƒ“ƒNƒŠƒƒ“ƒg‚ľ‚Ä‚˘‚˘–ń‘Š‚É‚ˇ‚é */
563 if (3 <= n && n < 7 && kd[n - 3])
564 {
565 if ((key[n - 3] & 0x7F) == ((kd[n - 3] + 1)->c[0] & 0x7F)
566 && (key[n - 2] & 0x7F) == ((kd[n - 3] + 1)->c[1] & 0x7F)
567 && (key[n - 1] & 0x7F) == ((kd[n - 3] + 1)->c[2] & 0x7F))
568 {
569 memcpy(&key[n - 3], &(++kd[n - 3])->c[0], 4);
570 #if DEBUG>=2
571 printf(">dt_get:%c%c%c%c(%02X%02X:%02X%02X)\n",
572 kd[n - 3]->c[0], kd[n - 3]->c[1], kd[n - 3]->c[2], kd[n - 3]->c[3],
573 kd[n - 3]->c[0], kd[n - 3]->c[1], kd[n - 3]->c[2], kd[n - 3]->c[3]);
574 #endif
575 return 1;
576 }
577 else
578 {
579 return 0;
580 }
581 }
582 else if (2 <= n && n < 6 && kd[n - 2])
583 {
584 if ((key[n - 2] & 0x7F) == ((kd[n - 2] + 1)->c[0] & 0x7F)
585 && (key[n - 1] & 0x7F) == ((kd[n - 2] + 1)->c[1] & 0x7F))
586 {
587 memcpy(&key[n - 2], &(++kd[n - 2])->c[0], 4);
588 #if DEBUG>=2
589 printf(">dt_get:%c%c%c%c(%02X%02X:%02X%02X)\n",
590 kd[n - 2]->c[0], kd[n - 2]->c[1], kd[n - 2]->c[2], kd[n - 2]->c[3],
591 kd[n - 2]->c[0], kd[n - 2]->c[1], kd[n - 2]->c[2], kd[n - 2]->c[3]);
592 #endif
593 return 1;
594 }
595 else
596 {
597 return 0;
598 }
599 if (kd[n - 2]->c[0] == key[n - 2])
600 return 1;
601 else
602 return 0;
603 }
604 else if (1 <= n && n < 5 && kd[n - 1])
605 {
606 unsigned c2 = kd[n - 1]->c[0];
607 if ((0x81 <= c2 && c2 <= 0x9F)
608 || (0xE0 <= c2 && c2 <= 0xFC))
609 {
610 kd[n - 1] = NULL;
611 #if 0
612 if (!(n == 1 && n == 2))
613 key[n] &= 0x7F;
614 if (!(n == 2 && n == 3))
615 key[n - 1] &= 0x7F;
616 #endif
617 key_make_map(n - 1);
618 }
619 else if ((key[n - 1] & 0x7F) == ((kd[n - 1] + 1)->c[0] & 0x7F))
620 {
621 memcpy(&key[n - 1], &(++kd[n - 1])->c[0], 4);
622 #if DEBUG>=2
623 printf(">dt_get:%c%c%c%c(%02X%02X:%02X%02X)\n",
624 kd[n - 1]->c[0], kd[n - 1]->c[1], kd[n - 1]->c[2], kd[n - 1]->c[3],
625 kd[n - 1]->c[0], kd[n - 1]->c[1], kd[n - 1]->c[2], kd[n - 1]->c[3]);
626 #endif
627 return 1;
628 }
629 else
630 {
631 return 0;
632 }
633 #if 0
634 if (kd[n - 1]->c[0] == key[n - 1])
635 return 1;
636 else
637 return 0;
638 #endif
639 }
640 else if (n < 4 && kd[n])
641 {
642 if (0 && kd[n]->c[0] == key[n])
643 return 1;
644 kd[n] = NULL;
645 #if 0
646 if (!(n == 1 || n == 2))
647 key[n] &= 0x7F;
648 #endif
649 }
650
651 /* ŽŔŰ‚É‘‚â‚ľ‚Ä‚Ý‚é */
652 assert(n >= 3);
653 for (;;)
654 {
655 if (n <= 3
656 && !(key[n] & 0x80)
657 && kcls[n].map[key[n] ^ 0x80] & (KCLS_DT0))
658 {
659 /* ”źŠpƒJƒ^ƒJƒi‚Ě1ƒoƒCƒg–Ú */
660 key[n] ^= 0x80;
661 }
662 else
663 {
664 key[n] = (key[n] & 0x7F) + 1;
665 if (key[n] >= 0x80)
666 return 0;
667 }
668
669 if (kcls[n].map[key[n]])
670 {
671 key_make_map(n);
672 key_reset(n + 1);
673 return 1;
674 }
675 }
676 while (++key[n] < 0x80)
677 {
678 if (kcls[n].map[key[n]])
679 {
680 key_make_map(n);
681 key_reset(n + 1);
682 return 1;
683 }
684 }
685 return 0;
686 }
687
688 /* ŒŽ‚đŠŽ‘S‚ɃŠƒZƒbƒg‚ˇ‚é
689 Salt‚ŕƒZƒbƒg‚ľ’ź‚ˇ */
690 static
691 void
692 key_init()
693 {
694 int i, j;
695
696 #if USE_DT
697 /* ŽŤ‘‚đAƒCƒ“ƒfƒNƒX‚đě‚č‚Č‚Ş‚çƒ}ƒbƒv‚É‚Í‚ß‚ą‚ń‚ŐŔ‚­
698 ŽŤ‘‚̓R[ƒh‡¸‡‚É•Ŕ‚ń‚Ĺ‚é‚ŕ‚Ě‚Ć‚ˇ‚é */
699 for (i = 0; i < dtcnt; i++)
700 {
701 unsigned c = dt[i].c[0];
702
703 assert(dt[i].c[0]
704 && dt[i].c[1]
705 && dt[i].c[2]
706 && dt[i].c[3]);
707
708 /* BSD ŽI‚Ĺ‚ľ‚É‚ť‚¤‚Č•śŽš‚ÍŽc”O‚Č‚Ş‚çœŠO */
709 assert((dt[i].c[0] & 0x7F)
710 && (dt[i].c[1] & 0x7F)
711 && (dt[i].c[2] & 0x7F)
712 && (dt[i].c[3] & 0x7F));
713
714 /* ƒCƒ“ƒfƒNƒX */
715 if (!dtidx[c])
716 dtidx[c] = &dt[i];
717
718 if ((0x81 <= c && c <= 0x9F)
719 || (0xE0 <= c && c <= 0xFC))
720 {
721 /* ‘SŠp‚Ȃ̂ŁA2ƒoƒCƒg‚Ť‚Ü‚Á‚˝Žž“_‚Ĺ—§‚Ä‚é */
722 cp932[256 * c + dt[i].c[1]] |= KCLS_DT1;
723 }
724 else if (0xA1 <= c && c <= 0xDF)
725 {
726 /* ”źŠpƒJƒi */
727 for (j = 0; j < 256; j++)
728 cp932[256 * c + j] |= KCLS_DT0;
729 }
730 }
731 /* ƒPƒcA‚ż‚¤‚Š”Ԑl */
732 dtidx[0x100] = &dt[i];
733 #endif
734
735 key[8] = 0;
736
737 /* ‰Šúƒ}ƒbƒv‚đ‘g‚Ţ */
738 for (i = 0; i < 256; i++)
739 {
740 unsigned bm = 0;
741 kcls[0].map[i] = 0;
742 for (j = 0; j < 256; j++)
743 bm |= cp932[256 * i + j];
744 kcls[0].map[i] = bm & (KCLS_AN | KCLS_KA | KCLS_K1
745 | KCLS_DT0
746 );
747 if (i >= 128)
748 kcls[0].map[i - 128] |= kcls[0].map[i];
749 }
750
751 key_reset(0);
752 }
753
754 /***************************************************************
755 *
756 * ‰ÂŽ‹•śŽš—ń‚É•ĎŠˇ
757 * n = 0, flag !=0 ‚ĹŒÄ‚Ô‚ą‚Ć
758 *
759 * ptr ‚ĹŽw‚ł‚ę‚é•śŽš—ń‚́A•ĎŠˇ‚ɐŹŒ÷‚ľ‚˝‚珑‚ŤŠˇ‚Ś‚ç‚ę‚é
760 *
761 * ŹŒ÷‚ľ‚˝‚ç flg, Ž¸”s‚ľ‚˝‚ç 0 ‚đ•Ô‚ˇB
762 *
763 */
764
765 unsigned
766 translate(unsigned char *ptr,
767 int n,
768 unsigned flag)
769 {
770 int r;
771 unsigned char buf[32];
772 unsigned s0 = (n == 1 || n == 2 ? 0x00 : 0x80);
773 unsigned s1 = (n == 0 || n == 1 ? 0x00 : 0x80);
774 unsigned c0 = ptr[n] << 8;
775 unsigned c1 = ptr[n + 1];
776 unsigned cs0 = c0 ^ (s0 << 8);
777 unsigned cs1 = c1 ^ s1;
778
779 if (n >= 8)
780 return flag;
781
782 if (n == 7)
783 {
784 int i;
785 /* ĹŒă‚Ě1•śŽš */
786 if (!(ptr[7] & 0x7F))
787 return flag;
788
789 for (i = 0x00; i <= 0x7E; i++)
790 {
791 if (cp932[c0 | i] & KCLS_K1)
792 {
793 ptr[8] = i;
794 return flag;
795 }
796 if (cp932[c0 | (0x80 + i)] & KCLS_K1)
797 {
798 ptr[8] = 0x80 + i;
799 return flag;
800 }
801 }
802
803 ptr[7] ^= 0x80; c0 = ptr[7] << 8;
804 for (i = 0x00; i <= 0x7E; i++)
805 {
806 if (cp932[c0 | i] & KCLS_K1)
807 {
808 ptr[8] = i;
809 return flag;
810 }
811 if (cp932[c0 | (0x80 + i)] & KCLS_K1)
812 {
813 ptr[8] = 0x80 + i;
814 return flag;
815 }
816 }
817 ptr[7] ^= 0x80; c0 = ptr[7] << 8;
818 }
819
820 /* K1 */
821 if (cp932[c0 | c1] & KCLS_K1)
822 {
823 r = translate(ptr, n + 2, flag);
824 if (r)
825 return r;
826 }
827 if (s0
828 && cp932[cs0 | c1] & KCLS_K1)
829 {
830 memcpy(buf, ptr, sizeof(buf));
831 buf[n] ^= s0;
832 r = translate(buf, n + 2, flag);
833 if (r)
834 {
835 memcpy(ptr, buf, sizeof(buf));
836 return r;
837 }
838 }
839 if (s1
840 && cp932[c0 | cs1] & KCLS_K1)
841 {
842 memcpy(buf, ptr, sizeof(buf));
843 buf[n + 1] ^= s1;
844 r = translate(buf, n + 2, flag);
845 if (r)
846 {
847 memcpy(ptr, buf, sizeof(buf));
848 return r;
849 }
850 }
851 if (s0 && s1
852 && cp932[cs0 | cs1] & KCLS_K1)
853 {
854 memcpy(buf, ptr, sizeof(buf));
855 buf[n] ^= s0;
856 buf[n + 1] ^= s1;
857 r = translate(buf, n + 2, flag);
858 if (r)
859 {
860 memcpy(ptr, buf, sizeof(buf));
861 return r;
862 }
863 }
864
865 /* AN */
866 if (cp932[c0] & (KCLS_AN | KCLS_KA))
867 {
868 r = translate(ptr, n + 1, flag);
869 if (r)
870 return r;
871 }
872 if (s0 && cp932[cs0] & (KCLS_AN | KCLS_KA))
873 {
874 memcpy(buf, ptr, sizeof(buf));
875 buf[n] ^= s0;
876 r = translate(buf, n + 1, flag);
877 if (r)
878 {
879 memcpy(ptr, buf, sizeof(buf));
880 return r;
881 }
882 }
883
884 /* KA */
885 /* KG */
886 /* KD */
887 /* AD */
888
889 return 0;
890 }
891
892 /***************************************************************
893 *
894 * Salt ‚ĚƒZƒbƒg
895 * ƒIƒyƒ‰ƒ“ƒh‚ĚƒIƒtƒZƒbƒg‚đ‘‚ŤŠˇ‚Ś‚ĉń‚Á‚Ä‚é‚Ě‚Ĺ’ˆÓ
896 *
897 */
898
899 #if N_STRIDE == 6
900 #define C(c,i,j,o) (*(int8_t *)((c) + (loo - crypt64_sta) + los[6 * (i) + (j) + (o)]))
901 #elif N_STRIDE == 7
902 #define C(c,i,j,o) (*(int32_t *)((c) + (loo - crypt64_sta) + los[6 * (i) + (j) + (o)]))
903 #endif
904
905 void
906 set_salt(signed char *code,
907 unsigned char const *k)
908 {
909 int i, j;
910
911 for (i = 0; i < 2; i++)
912 {
913 unsigned s = k[1 + i] & 255;
914 if (s > 'z')
915 s = 0;
916 else if (s >= 'a')
917 s = s - 'a' + 2 + 10 + 26;
918 else if (s >= 'A')
919 s = s - 'A' + 2 + 10;
920 else if (s >= '.')
921 s = s - '.';
922 else
923 s = 0;
924
925 #if DEBUG>=1
926 printf("Salt %d:%3o\n", i, s & 63);
927 #endif
928 for (j = 0; j < 6; j++)
929 {
930 #if DEBUG>=2
931 //printf("Salt %d:%d %+3d:%+3d",
932 printf("Salt %d:%d %08lX:%08lX",
933 i, j,
934 C(code, i, j, 0),
935 C(code, i, j, 24));
936 #endif
937 if (s & (1 << j))
938 {
939 C(code, i, j, 0) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);
940 C(code, i, j, 24) = sizeof(WS_T) * (((4 * i + j - 1) & 31) - 16);
941 }
942 else
943 {
944 C(code, i, j, 0) = sizeof(WS_T) * (((4 * i + j - 1) & 31) - 16);
945 C(code, i, j, 24) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);
946 }
947 C(code, i, j, 12) = sizeof(WS_T) * (((4 * i + j + 7) & 31) - 16);
948 C(code, i, j, 36) = sizeof(WS_T) * (((4 * i + j + 23) & 31) - 16);
949 #if DEBUG>=2
950 //printf(" => %+3d:%+3d\n",
951 printf(" => %08lX:%08lX\n",
952 C(code, i, j, 0),
953 C(code, i, j, 24));
954 #endif
955 }
956 }
957 }
958
959 /***************************************************************
960 *
961 * ƒIƒyƒR[ƒh‚đ“WŠJ
962 *
963 * r EAX, ECX, EDX, EBX
964 * SIB, EBP, ESI, EDI
965 *
966 */
967
968 /* ofs8(i) ‚ŕ‚ľ‚­‚Í ofs32(i) ‚𐜐Ź */
969 static
970 signed char *
971 disp_rm(signed char *pc,
972 unsigned d,
973 unsigned i,
974 long ofs)
975 {
976 assert(i != 4); /* SP ‚Ĺ‚Í‚Č‚­ SIB ‚É‚Č‚é */
977 if (-128 <= ofs && ofs <= 127)
978 {
979 /* short ofs
980 01 ddd sss [ofs.b] */
981 pc[0] = (0100
982 | ((d << 3) & 0070)
983 | (i & 0007));
984 pc[1] = ofs;
985 return pc + 2;
986 }
987 else
988 {
989 /* long ofs
990 10 ddd sss [ofs.l] */
991 pc[0] = (0200
992 | ((d << 3) & 0070)
993 | (i & 0007));
994 *(long *)&pc[1] = ofs; /* XXX unaligned */
995 return pc + 5;
996 }
997 }
998
999 #define PTR_T 7 /* DI(LR+16) */
1000 #define OFS_T (64 + 32 - 16)
1001
1002 #ifdef USE_64 /* ALU 64 */
1003
1004 /*
1005 * 0x49 0xF7 11-010-ddd not
1006 * 0x49 op 11-sss-ddd
1007 *
1008 * 0x4C op rm
1009 * 0x4C 0x8B rm load
1010 * 0x4C 0x89 rm store
1011 *
1012 */
1013
1014 #define OP_MOV 0x8B
1015 #define OP_STOR 0x89
1016 #define OP_AND 0x23
1017 #define OP_OR 0x0B
1018 #define OP_XOR 0x33
1019
1020 static
1021 signed char *
1022 reg_op(signed char *pc,
1023 unsigned op,
1024 unsigned d,
1025 unsigned s)
1026 {
1027 pc[0] = 0x4D; /* 49 */
1028 pc[1] = op & 0xFD;
1029 /* 11 ddd sss */
1030 pc[2] = (0300
1031 | ((s << 3) & 0070)
1032 | (d & 0007));
1033 return pc + 3;
1034 }
1035
1036 static
1037 signed char *
1038 reg_mem(signed char *pc,
1039 unsigned op,
1040 unsigned d,
1041 unsigned i,
1042 long ofs)
1043 {
1044 pc[0] = 0x4C;
1045 pc[1] = op;
1046 return disp_rm(pc + 2, d, i, ofs);
1047 }
1048
1049 #else /* MMX or XMM */
1050
1051 #define OP_MOV 0x6F
1052 #define OP_STOR 0x7F
1053 #define OP_AND 0xDB
1054 #define OP_ANDN 0xDF
1055 #define OP_OR 0xEB
1056 #define OP_XOR 0xEF
1057
1058 static
1059 signed char *
1060 reg_op(signed char *pc,
1061 unsigned op,
1062 unsigned d,
1063 unsigned s)
1064 {
1065 #ifndef USE_MMX
1066 *pc++ = 0x66;
1067 #endif
1068 pc[0] = 0x0F;
1069 pc[1] = op;
1070 /* 11 ddd sss */
1071 pc[2] = (0300
1072 | ((d << 3) & 0070)
1073 | (s & 0007));
1074 return pc + 3;
1075 }
1076
1077 static
1078 signed char *
1079 reg_mem(signed char *pc,
1080 unsigned op,
1081 unsigned d,
1082 unsigned i,
1083 int ofs)
1084 {
1085 #ifndef USE_MMX
1086 *pc++ = 0x66;
1087 #endif
1088 pc[0] = 0x0F;
1089 pc[1] = op;
1090 return disp_rm(pc + 2, d, i, ofs);
1091 }
1092
1093 #endif
1094
1095 /***************************************************************
1096 *
1097 * —^‚Ś‚ç‚ę‚˝ŽŽ‚đ‰đÍE–˝—ߐśŹ
1098 *
1099 * ^ ć“ŞŒĹ’č
1100 * $ ––”öŒĹ’č
1101 * ? ”CˆÓ‚Ě1•śŽš
1102 * * ”CˆÓ‚Ě0•śŽšˆČă
1103 * & ‘召‹ć•ĘƒiƒVAƒOƒ‹[ƒv‚ÉŽg‚í‚ę‚˝ę‡Acapitalize
1104 * () ƒOƒ‹[ƒv‰ť
1105 * \s or
1106 * \1 ˆę’v‚ľ‚˝ƒOƒ‹[ƒv(ŽŔ‘Ě)
1107 * $(fn) ƒeƒLƒXƒg‚đ“WŠJ(ƒOƒ‹[ƒv‚̓Nƒ‰ƒX‚Ć‚ľ‚Ĉľ‚í‚ę‚é)
1108 *
1109 * ˆČ‰şAƒNƒ‰ƒX“WŠJ‚Ěƒƒ^ƒLƒƒƒ‰
1110 * [A-Z] •śŽšƒNƒ‰ƒX’č‹` ^ ‚Í”r‘ź
1111 * {} 0•śŽšˆČă
1112 * {n} n•śŽš
1113 * {n,} n•śŽšˆČă
1114 * {,n} n•śŽšˆČ‰ş
1115 * {m,n} m-n•śŽš
1116 *
1117 */
1118
1119 static
1120 int
1121 cv64(int c)
1122 {
1123 if ('.' <= c && c <= '/')
1124 return c - '.';
1125 else if ('0' <= c && c <= '9')
1126 return c - '0' + 2;
1127 else if ('A' <= c && c <= 'Z')
1128 return c - 'A' + 2 + 10;
1129 else if ('a' <= c && c <= 'z')
1130 return c - 'a' + 2 + 10 + 26;
1131 else
1132 return -1;
1133 }
1134
1135 static
1136 int
1137 expr_make(signed char *iptr,
1138 int ofs,
1139 char const *expr,
1140 int len)
1141 {
1142 /* ć“ސ§–ń */
1143 signed char *o_iptr = iptr;
1144 unsigned op = OP_MOV;
1145 int i;
1146
1147 if (expr[0] == '^')
1148 {
1149 if (len == 0 || ofs > 0)
1150 return -1;
1151 expr++;
1152 len--;
1153 }
1154
1155 /* ˆę•śŽš‚“WŠJ */
1156 for (i = 0; i < len; i++)
1157 {
1158 int c = expr[i];
1159
1160 if (c == '$')
1161 {
1162 assert(op != OP_MOV);
1163 if (ofs < 10)
1164 return 0;
1165 else if (ofs > 10)
1166 return -1;
1167 return iptr - o_iptr;
1168 }
1169
1170 if (ofs >= 10)
1171 return -1;
1172
1173 if (c == '[')
1174 {
1175 /* ƒNƒ‰ƒX‚đ‚Ü‚Ć‚ß‚é */
1176 unsigned oop; /* MOVQ */
1177 int j;
1178 int cs[64];
1179 memset(cs, 0, 64 * sizeof(int));
1180 for (i++; c = expr[i], c != ']'; i++)
1181 {
1182 c = cv64(c);
1183 if (c < 0)
1184 return -1;
1185 if (expr[i + 1] == '-')
1186 {
1187 int ce = cv64(expr[i + 2]);
1188 if (ce < 0)
1189 return -1;
1190 while (c <= ce)
1191 cs[c++]++;
1192 i += 2;
1193 }
1194 else
1195 cs[c]++;
1196 }
1197 assert(c == ']');
1198
1199 /* ƒ}ƒbƒv‚ł‚ę‚˝ƒ‚ƒm‚Š‚ç–˝—߂𐜐Ź‚ˇ‚é */
1200 oop = OP_MOV;
1201 for (j = 0; j < 64; j++)
1202 if (cs[j])
1203 {
1204 if (ofs == 9 && (j & 3))
1205 continue;
1206 iptr = reg_mem(iptr,
1207 oop,
1208 1, /* MM1/R9 */
1209 PTR_T,
1210 sizeof(WS_T) * (OFS_T + (64 * ofs + j)));
1211 oop = OP_OR;
1212 }
1213 if (oop != OP_OR)
1214 {
1215 if (ofs == 9)
1216 return -1;
1217 }
1218 else
1219 {
1220 iptr = reg_op(iptr,
1221 op,
1222 0, /* MM0/R8 */
1223 1); /* MM1/R9 */
1224 op = OP_AND;
1225 }
1226 ofs++;
1227 }
1228 else if (c == '?')
1229 {
1230 ofs++;
1231 }
1232 else if ((c = cv64(c)) >= 0)
1233 {
1234 if (ofs == 9 && (c & 3))
1235 return -1;
1236 iptr = reg_mem(iptr,
1237 op,
1238 0, /* MM0/R8 */
1239 PTR_T,
1240 sizeof(WS_T) * (OFS_T + (64 * ofs + c)));
1241 op = OP_AND;
1242 ofs++;
1243 }
1244 else
1245 return -1;
1246 }
1247
1248 return iptr - o_iptr;
1249 }
1250 /*
1251 Fighters ^FIGHTERS ^BayStars ^Red[Ss]tar/ ^REDSTAR/ ^Parsifal ^VALKYRIE ^Valkyrie
1252 ^Dr.Death ^IamCHONO ^RAGNAROK ^MARAOH.. ^MARAOH// ......... God[Ff]ather GODFATHER
1253 ^maraGULO[./] BLACKJACK ^[Bb]lackjack ^BlackJack [Pp]atagonia PATAGONIA ^JC.PENNEY
1254 ^JC.Penney ^syombolic ROCKNROLL stammerB4U Ms.Erie.W. MARA.w/w/w R3[0-4]SKYLINE
1255 100000[Gg]et. 100000GET.
1256 */
1257 signed char *
1258 expr_parse(signed char *iptr,
1259 int codesiz_limit,
1260 char const *expr)
1261 {
1262 /* ƒtƒ@ƒCƒ‹‚đ“ǂݍž‚Ţ
1263 ‚ą‚̔łł͎蔲‚Ť‚Ĺ 64K §ŒŔ */
1264 #define TARGET_SIZ 65536
1265 char expr_buf[TARGET_SIZ + 1];
1266 FILE *fp;
1267 size_t sz;
1268
1269 fp = fopen("target.txt", "rb");
1270 assert(fp != NULL);
1271 memset(expr_buf, 0, TARGET_SIZ + 1);
1272 sz = fread(expr_buf, sizeof(char), TARGET_SIZ, fp);
1273 fclose(fp);
1274
1275 /* XXX ƒ^[ƒQƒbƒg‚ĚƒTƒCƒY‚đƒ`ƒFƒbƒN */
1276 if (sz == TARGET_SIZ)
1277 {
1278 /* ƒg[ƒNƒ“‚Ěƒgƒ‰ƒo[ƒX */
1279 char *ds, *pe, *ps;
1280 for (ds = &expr_buf[TARGET_SIZ - 1];
1281 !isspace(*ds);
1282 ds--)
1283 assert(ds >= expr_buf);
1284 for (pe = ds++; isspace(*pe); pe--)
1285 assert(pe >= expr_buf);
1286 for (ps = pe++; !isspace(*ps); ps--)
1287 assert(ps >= expr_buf);
1288 fprintf(stderr, "WARNING: <");
1289 ps++;
1290 while (ps < pe)
1291 fputc(*ps++, stderr);
1292 fprintf(stderr, ">‚ć‚čŒă‚ë‚Ěƒ^[ƒQƒbƒg<%s(ry>‚̓I‡hƒ‹\n",
1293 ds);
1294 *pe = 0;
1295 }
1296
1297 /* MM7 ‚Ƀ^[ƒQƒbƒg–ˆ‚É”äŠrŒ‹‰Ę‚đ OR ‚ľ‚Ä‚˘‚­‚˝‚ß
1298 ‚Ü‚¸‚̓[ƒƒNƒŠƒA */
1299 iptr = reg_op(iptr, OP_XOR, 7, 7); /* MM7/R15 := 0 */
1300
1301 /* ‡ŒJ‚č‚É parse */
1302 expr = expr_buf;
1303 while (expr[0])
1304 {
1305 char const *p;
1306 int i;
1307
1308 /* “Ş‚Ě Whitespace ‚đ“Ç‚Ý”ň‚΂ˇ */
1309 while (isspace(expr[0]))
1310 expr++;
1311
1312 if (!expr[0])
1313 break;
1314
1315 /* ƒg[ƒNƒ“‚đŘ‚čo‚ˇ */
1316 for (p = expr; expr[0] && !isspace(expr[0]); expr++)
1317 ;
1318
1319 /* “WŠJ‚ˇ‚é */
1320 for (i = 0; i < 10; i++)
1321 {
1322 int n = expr_make(iptr, i, p, expr - p);
1323 if (n < 0)
1324 break;
1325 #if DEBUG>=1
1326 if (n > 0)
1327 {
1328 int j;
1329 for (j = 0; &p[j] < expr; j++)
1330 putchar(p[j]);
1331 printf(": of=%d len=%d\n", i, expr - p);
1332 }
1333 #endif
1334 /* 1ƒ^[ƒQƒbƒg•Ş‚Ě”äŠrŒ‹‰Ę‚đ MM7 ‚ɒljÁ */
1335 if (n > 0)
1336 iptr = reg_op(iptr + n,
1337 OP_OR,
1338 7, /* MM7/R15 */
1339 0); /* MM0/R8 */
1340 }
1341 }
1342
1343 /* MM7 ‚ɐśŹ‚ł‚ę‚˝Œ‹‰Ę‚đ t[31] ‚ÉŠi”[ */
1344 return reg_mem(iptr,
1345 OP_STOR,
1346 7, /* MM7/R15 */
1347 PTR_T,
1348 sizeof(WS_T) * (64 + 31 - 16));
1349 }
1350
1351 static
1352 unsigned
1353 usec()
1354 {
1355 #if !defined(WIN32)
1356 struct timeval tv;
1357 gettimeofday(&tv, NULL);
1358 return 100 * tv.tv_sec + (tv.tv_usec / 10000);
1359 #else
1360 struct timeb tm;
1361 ftime(&tm);
1362 return 100 * tm.time + tm.millitm / 10;
1363 #endif
1364 }
1365
1366 static
1367 int
1368 log_printf(FILE *ofp, char const *fmt, ...)
1369 {
1370 int r;
1371 va_list ap;
1372 va_start(ap, fmt);
1373 vfprintf(stdout, fmt, ap);
1374 r = vfprintf(ofp, fmt, ap);
1375 va_end(ap);
1376 if (r > 0)
1377 return r;
1378 perror("log_printf");
1379 exit(errno);
1380 }
1381
1382 /***************************************************************
1383 *
1384 * ƒƒCƒ“ƒ‹[ƒv‚Ć‚Š
1385 *
1386 */
1387
1388 /* ’萔€ */
1389 #if N_STRIDE == 7
1390 static SLICE const sk6[N_STRIDE] =
1391 {
1392 {0xAAAAAAAAUL, 0xAAAAAAAAUL, 0xAAAAAAAAUL, 0xAAAAAAAAUL},
1393 {0xCCCCCCCCUL, 0xCCCCCCCCUL, 0xCCCCCCCCUL, 0xCCCCCCCCUL},
1394 {0xF0F0F0F0UL, 0xF0F0F0F0UL, 0xF0F0F0F0UL, 0xF0F0F0F0UL},
1395 {0xFF00FF00UL, 0xFF00FF00UL, 0xFF00FF00UL, 0xFF00FF00UL},
1396 {0xFFFF0000UL, 0xFFFF0000UL, 0xFFFF0000UL, 0xFFFF0000UL},
1397 {0x00000000UL, 0xFFFFFFFFUL, 0x00000000UL, 0xFFFFFFFFUL},
1398 {0x00000000UL, 0x00000000UL, 0xFFFFFFFFUL, 0xFFFFFFFFUL},
1399 };
1400 #elif N_STRIDE == 6
1401 static SLICE const sk6[N_STRIDE] =
1402 {
1403 {0xAAAAAAAAUL, 0xAAAAAAAAUL},
1404 {0xCCCCCCCCUL, 0xCCCCCCCCUL},
1405 {0xF0F0F0F0UL, 0xF0F0F0F0UL},
1406 {0xFF00FF00UL, 0xFF00FF00UL},
1407 {0xFFFF0000UL, 0xFFFF0000UL},
1408 {0x00000000UL, 0xFFFFFFFFUL},
1409 };
1410 #endif
1411
1412 #ifdef WIN32
1413 typedef int (__fastcall *CRYPT64_PP)(ALU_T const *k, ALU_T *lr);
1414 #endif
1415
1416 ALIGN_PREFIX(16) struct KEY key64 ALIGN_SUFFIX(16);
1417 ALIGN_PREFIX(16) struct PARAM param64 ALIGN_SUFFIX(16);
1418
1419 int
1420 main(int argc, char *argv[])
1421 {
1422 int i, j;
1423 int mincnt;
1424 signed char *code = NULL;
1425 FILE *ofp;
1426 int n_iter;
1427 int cr;
1428
1429 #define N_TS 4
1430 struct
1431 {
1432 unsigned t;
1433 int c;
1434 } ts[N_TS];
1435
1436 #ifdef WIN32
1437 HANDLE h;
1438 #endif
1439
1440 #ifndef __GNUC__
1441 CRYPT64_PP d_crypt64;
1442 #endif
1443
1444 #if 0
1445 if (argc < 2)
1446 {
1447 fprintf(stderr, "ŽŽ‚Ť‚Ú‚ń‚Ę\n");
1448 return 1;
1449 }
1450 #endif
1451
1452 assert((1 << N_STRIDE) == N_ALU * ALU_BITS);
1453
1454 /* t[16] ‚́A“ŕ•”‰‰ŽZ‚ĹŽg—p‚ˇ‚éAall 1 ‚Ş“ü‚Á‚Ä‚˘‚é */
1455 for (i = 0; i < N_ALU; i++)
1456 param64.t[16].a[i] = -1;
1457
1458 /* ŒĹ’čƒL[‚ĚƒRƒs[ */
1459 for (i = 0; i < N_STRIDE; i++)
1460 {
1461 int o = tr_pc1[7][6 - i] - 1;
1462 if (o < 28)
1463 {
1464 key64.k[0][0][o] = key64.k[0][1][o] = sk6[i];
1465 }
1466 else
1467 {
1468 o -= 28;
1469 key64.k[1][0][o] = key64.k[1][1][o] = sk6[i];
1470 }
1471 }
1472
1473 /* ƒL[ƒXƒPƒWƒ…[ƒ‹‚đ‚ą‚ą‚ɉŸ‚ľž‚ß‚Ä‚¨‚­
1474 ]—ˆ‚Í crypt64.S “ŕ‚ĹŠŽŒ‹‚ˇ‚é‚悤‚Ɉř‚˘‚Ä‚˘‚˝ */
1475 for (i = 0; i < 28; i++)
1476 key64.ks[i].a[0] = sizeof(WS_T) * ks_ls[i];
1477
1478 /* Salt‚đ‰Á–Ą‚ľ‚Č‚˘ę‡‚́AƒR[ƒh—Ěˆć‚đ
1479 writable —Ěˆć‚É“WŠJ‚ľ‚Č‚­‚Ä‚ŕ‚悢B
1480 [XXX] OS‚É‚ć‚Á‚ẮA‘ž&ŽŔs‰Â”\—Ěˆć‚đę—p‚ĚƒT[ƒ”ƒBƒX‚Ĺ
1481 Žć“ž‚ľ‚Č‚Ż‚ę‚΂Ȃç‚Č‚˘‚ŕ‚Ě‚ŕ‚ ‚é‚Š‚ŕ‚ľ‚ę‚Č‚˘‚̂ŁA’ˆÓ */
1482 #ifdef WIN32
1483 h = CreateFileMapping(INVALID_HANDLE_VALUE,
1484 NULL,
1485 PAGE_EXECUTE_READWRITE,
1486 0, 0x20000000,
1487 NULL);
1488 #ifndef FILE_MAP_EXECUTE
1489 #define FILE_MAP_EXECUTE SECTION_MAP_EXECUTE /* XXX cygwin */
1490 #endif
1491 if (SUCCEEDED(h))
1492 code = (signed char *)MapViewOfFile(h,
1493 FILE_MAP_EXECUTE | FILE_MAP_WRITE,
1494 0, 0x10000000,
1495 0);
1496 #else
1497 code = (signed char *)mmap(NULL,
1498 0x10000000,
1499 PROT_EXEC | PROT_READ | PROT_WRITE,
1500 MAP_PRIVATE | MAP_ANON,
1501 1, /* fd */
1502 0);
1503 if ((void *)code == MAP_FAILED)
1504 code =NULL;
1505 #endif
1506
1507 /* ƒƒ‚ƒŠ‚ŞŠm•Ű‚Ĺ‚Ť‚Ä‚˘‚Č‚˘ę‡‚Ě‚˘‚ń‚ż‚Ť‘΍ô */
1508 if (code == NULL)
1509 code = (signed char *)malloc(crypt64_end - crypt64_sta + 1024 * 1024);
1510 assert(code != NULL);
1511
1512 /* Prologue ‚đ“WŠJ */
1513 memcpy(code, crypt64_sta, crypt64_end - crypt64_sta);
1514 #ifndef __GNUC__
1515 d_crypt64 = (CRYPT64_PP)code;
1516 #endif
1517 memcpy(expr_parse(code + (crypt64_end - crypt64_sta),
1518 1024 * 1024 - (crypt64_ep_end - crypt64_ep),
1519 argv[1]),
1520 crypt64_ep,
1521 crypt64_ep_end - crypt64_ep);
1522
1523 /* ƒL[‚̏‰Šú‰ť */
1524 srand(time(NULL));
1525 key_init();
1526 set_salt(code, key);
1527 for (i = 0; i < 8; i++)
1528 key_set64(&key64, i, okey[i] = key[i], 0, 0x7F);
1529
1530 #if DEBUG>=1
1531 printf("key=%p param=%p\n", &key64, &param64);
1532 #endif
1533 assert(!((ptrdiff_t)&key64 & (sizeof(WS_T) - 1)));
1534 assert(!((ptrdiff_t)&param64 & (sizeof(WS_T) - 1)));
1535
1536 if ((ofp = fopen("log.txt", "at")) == NULL)
1537 {
1538 perror("log.txt");
1539 return errno;
1540 }
1541
1542 setvbuf(ofp, NULL, _IONBF, BUFSIZ); /* XXX MSVCRT ‚Ĺ‚Í _IOLBF ‚ŞŠú‘Ň’Ę‚č‚É“Žě‚ľ‚Č‚˘ */
1543
1544 for (i = 0; i < N_TS; i++)
1545 ts[i].t = ts[i].c = 0;
1546
1547 mincnt = 0x7FFFFFFF;
1548 n_iter = 0;
1549 cr = 0;
1550 /* ’Tőƒ‹[ƒv‚ž‚ź‚Á‚Ć */
1551 for (;;)
1552 {
1553 int32_t cnt;
1554 int k, kk;
1555
1556 /* ŒŽ‚ĚƒZƒbƒg */
1557 for (i = 0; i < 8; i++)
1558 {
1559 key_set64(&key64, i, key[i], key[i] ^ okey[i], 0);
1560 okey[i] = key[i];
1561 }
1562
1563 /* ŒÄ‚Ô!
1564 LR ‰Šú‰ť‚́AƒTƒuƒ‚ƒWƒ…[ƒ‹“ŕ‚ōs‚¤‚ׂľ
1565 FASTCALL ‚ɏ€‚ś‚˝ŒÄ‚яo‚ľ‚Ě‚˝‚߁A
1566 ƒzƒ“ƒg‚Í‚˘‚낢‚냌ƒWƒXƒ^‚Ş”j‰ó‚ł‚ę‚éƒnƒYc‚Č‚ń‚ž‚ށB */
1567 #ifdef __GNUC__
1568 asm volatile("call *%3"
1569 : "=a"(cnt)
1570 : "c"(key64.k), "d"(param64.lr),
1571 "m"(code)
1572 //"m"(crypt64_sta)
1573 : CRYPT64_CLOBBER "memory");
1574 #else
1575 cnt = (*d_crypt64)(key64.k[0][0][0].a, param64.lr[0][0].a);
1576 #endif
1577 if (mincnt > cnt && cnt > 0)
1578 {
1579 mincnt = cnt;
1580 if (cr)
1581 fprintf(stderr, "\n");
1582 cr = 0;
1583 fprintf(stderr, "cycle=%d\n", (int)cnt);
1584 }
1585
1586 /* ƒqƒbƒg‚ľ‚˝‚Ć‚Ť‚̏ˆ— */
1587 for (kk = 0; kk < N_ALU; kk++)
1588 {
1589 ALU_T t;
1590
1591 t = param64.t[31].a[kk];
1592 if (!t)
1593 continue;
1594
1595 for (k = 0; k < ALU_BITS; k++)
1596 {
1597 char hash[16];
1598 unsigned char buf[32];
1599
1600 if (!(t & ((ALU_T)1 << k)))
1601 continue;
1602
1603 /* XXX Žč”˛‚Ť‚Ě‚˝‚߁Aƒ[ƒN‚ɂ͂ݏo‚Ä‚˘‚é 2 ƒrƒbƒg‚đ‚ą‚ą‚Ĺ—Ž‚Ć‚ˇ
1604 ƒqƒbƒg‚ˇ‚é‚˝‚Ń‚Éç’ˇ‚ɍs‚í‚ę‚é‚ŞA‹C‚É‚ľ‚Ä‚Í‚˘‚Š‚ń */
1605 for (i = 0; i < N_ALU; i++)
1606 param64.t[0].a[i] = param64.t[1].a[i] = 0;
1607 for (i = 1; i < 11; i++)
1608 {
1609 unsigned c = 0;
1610 for (j = 0; j < 6; j++)
1611 c = (c << 1) | !!(param64.lr[0][tr_fp[6 * i + j]].a[kk] & ((ALU_T)1 << k));
1612 hash[i - 1] = c["./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"];
1613 }
1614 hash[10] = 0;
1615
1616 memcpy(buf, key, 32);
1617 buf[8] = buf[9] = 0;
1618 buf[7] = (buf[7] & -(1 << N_STRIDE) & 0x7F) + ALU_BITS * kk + k;
1619 if (translate(buf, 0, 1))
1620 {
1621 if (cr)
1622 fprintf(stderr, "\n");
1623 cr = 0;
1624 log_printf(ofp,
1625 "Ÿ%s #%-10.10s(%02X %02X %02X %02X %02X %02X %02X %02X/%02X)\n",
1626 hash,
1627 buf,
1628 buf[0], buf[1], buf[2], buf[3],
1629 buf[4], buf[5], buf[6], buf[7],
1630 buf[8]);
1631 }
1632 else
1633 {
1634 #if DEBUG>=1
1635 if (cr)
1636 fprintf(stderr, "\n");
1637 cr = 0;
1638 log_printf(ofp,
1639 "Ÿ%s (%02X %02X %02X %02X %02X %02X %02X %02X )\n",
1640 hash,
1641 buf[0], buf[1], buf[2], buf[3],
1642 buf[4], buf[5], buf[6], buf[7]);
1643 #endif
1644 }
1645 }
1646 }
1647
1648 if (++n_iter - ts[0].c >= 8192)
1649 {
1650 int t = usec();
1651 if (ts[N_TS - 1].c)
1652 {
1653 int a = (100 << N_STRIDE) * (n_iter - ts[N_TS - 1].c) / (t - ts[N_TS - 1].t);
1654 fprintf(stderr,
1655 "%8d.%03d(ktrips/sec)\r",
1656 a / 1000,
1657 a % 1000);
1658 cr++;
1659 }
1660 for (i = N_TS - 1; i >= 1; i--)
1661 ts[i] = ts[i - 1];
1662 ts[0].c = n_iter;
1663 ts[0].t = t;
1664 for (i = 1; i < N_TS; i++)
1665 if (ts[i].c)
1666 break;
1667 else
1668 ts[i] = ts[i - 1];
1669 }
1670 #if 1
1671 if (!key_inc(3))
1672 {
1673 #if DEBUG>=2
1674 printf("********************************\n");
1675 #endif
1676 key_reset(0);
1677 set_salt(code, key);
1678 for (i = 0; i < 8; i++)
1679 key_set64(&key64, i, okey[i] = key[i], 0, 0x7F);
1680 }
1681 #endif
1682 }
1683
1684 return 0;
1685 }
1686
1687 /*
1688 * Local Variables:
1689 * tab-width: 4
1690 * End:
1691 *
1692 * EOF */

Properties

Name Value
svn:eol-style native
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help