Develop and Download Open Source Software

プロジェクト・ナニ屋

Browse Subversion Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log

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