Develop and Download Open Source Software

プロジェクト・ナニ屋

Browse Subversion Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 263 - (hide annotations) (download) (as text)
Mon Jul 4 09:42:05 2011 UTC (12 years, 9 months ago) by notanpe
File MIME type: text/x-csrc
File size: 16712 byte(s) 
検索空間の記録機能を追加
1 notanpe 252 /***********************************************************************
2     *
3     * file: key.c
4     *
5     * $Id: key.c 241 2010-03-15 14:28:18Z chapuni $
6     *
7     */
8    
9 notanpe 263 #include <stdio.h>
10 notanpe 252 #include <assert.h>
11     #include <stdlib.h>
12    
13 notanpe 263 #ifdef KEYLOG
14     #include <time.h>
15     #include <windows.h>
16     #endif /* KEYLOG */
17    
18 notanpe 252 #include "cp932.h"
19     #include "desconst.h"
20     #include "key.h"
21     #include "translate.h"
22 notanpe 263 #include "makai.h"
23     #include "util.h"
24 notanpe 252
25     #if USE_DT
26     #include "dt4.h"
27     #endif
28    
29     /* 拡張鍵クラス */
30     #define KCLS_DT0 64
31     #define KCLS_DT1 128
32     #define KCLS_K2 256
33    
34     #if USE_DT
35     /* 鍵キメ用辞書インデクス */
36     struct DT *kd[8 + 8];
37    
38     /* 辞書インデクス */
39     struct DT *dtidx[0x100 + 1];
40     #endif
41    
42 notanpe 263 #ifdef KEYLOG
43     #define KEY_LOG_FILE "keylog.txt"
44     int keyLog = MAKAI_FALSE;
45     static HANDLE mutexKeylog;
46     #endif /* KEYLOG */
47    
48 notanpe 252 /* 指定されたクラスと入っているキーから、classify を行う */
49     void
50     key_make_map(struct KS_KEY *key, int n)
51     {
52     int i, j;
53     unsigned c = key->map[n][key->key[n]];
54    
55     #if USE_DT
56     if (3 <= n && n < 7 && kd[n - 3])
57     {
58     /* 辞書のケツの文字。後ろにナニヤラキャラクタが来る */
59     c = kd[n - 3]->c[0];
60     if ((0x81 <= c && c <= 0x9F)
61     || (0xE0 <= c && c <= 0xFC))
62     c = KCLS_K2;
63     else
64     c = (cp932[256 * key->key[n]]
65     | cp932[256 * (key->key[n] ^ 0x80)]);
66     #if DEBUG>=1
67     printf("*n=%d, key=%02X, cls=%04X\n",
68     n,
69     key[n],
70     c);
71     #endif
72     }
73     else if (2 <= n && n < 6 && kd[n - 2])
74     {
75     return;
76     }
77     else if (1 <= n && n < 5 && kd[n - 1])
78     {
79     return;
80     }
81     #if USE_DT
82     else if (1 <= n && n < 5 && !kd[n - 1]
83     //&& (c & KCLS_K2)
84     && (c & KCLS_DT1))
85     {
86     /* 漢字2文字を拾っていきまつ */
87     #if DEBUG>=1
88     printf("(%d)%02X %02X(%02X:%02X:%02X:%02X)\n",
89     n, key->key[n - 1], key->key[n],
90     cp932[(256 * key->key[n - 1] + key->key[n])],
91     cp932[(256 * key->key[n - 1] + key->key[n]) ^ 0x0080],
92     cp932[(256 * key->key[n - 1] + key->key[n]) ^ 0x8000],
93     cp932[(256 * key->key[n - 1] + key->key[n]) ^ 0x8080]);
94     #endif
95     if (n != 1 && n != 2
96     && (cp932[(256 * key->key[n - 1] + key->key[n]) ^ 0x0080] & KCLS_DT1))
97     key->key[n] ^= 0x80;
98     else if (n != 2 && n != 3
99     && (cp932[(256 * key->key[n - 1] + key->key[n]) ^ 0x8000] & KCLS_DT1))
100     key->key[n - 1] ^= 0x80;
101     else if (n > 3 && (cp932[(256 * key->key[n - 1] + key->key[n]) ^ 0x8080] & KCLS_DT1))
102     key->key[n - 1] ^= 0x80, key->key[n] ^= 0x80;
103     if (cp932[256 * key->key[n - 1] + key->key[n]] & KCLS_DT1)
104     {
105     for (kd[n - 1] = dtidx[key->key[n - 1]];
106     kd[n - 1]->c[1] != key->key[n];
107     kd[n - 1]++)
108     assert(kd[n - 1]->c[0] == key->key[n - 1]);
109     #if DEBUG>=1
110     printf("(%02X%02X:%02X%02X)%c%c%c%c\n",
111     kd[n - 1]->c[0],
112     kd[n - 1]->c[1],
113     kd[n - 1]->c[2],
114     kd[n - 1]->c[3],
115     kd[n - 1]->c[0],
116     kd[n - 1]->c[1],
117     kd[n - 1]->c[2],
118     kd[n - 1]->c[3]);
119     #endif
120     return;
121     }
122     }
123     else if (n < 4 && (c & KCLS_DT0) && kd[n] == NULL)
124     {
125     /* カタカナ埋め込みいきます */
126     assert(kd[n] == NULL);
127     #if DEBUG>=1
128     printf("n=%d, key=%02X\n", n, key->key[n]);
129     #endif
130     kd[n] = dtidx[key->key[n]];
131     if (!kd[n]
132     && !(n == 1 || n == 2)
133     && dtidx[key->key[n] ^ 0x80])
134     {
135     key->key[n] ^= 0x80;
136     kd[n] = dtidx[key->key[n]];
137     }
138     if (kd[n])
139     return;
140     }
141     #endif
142     else
143     {
144     kd[n] = NULL;
145     }
146     #endif
147    
148     /* 最後の部分は class map を生成する必要ナシ */
149     if (n >= 6)
150     return;
151    
152     for (i = 0; i < 256; i++)
153     {
154     unsigned bm = 0;
155     #if 1
156     if (c & KCLS_K1)
157     {
158     if (cp932[256 * key->key[n] + i] & KCLS_K1)
159     bm |= KCLS_K2 | (cp932[256 * key->key[n] + i] & KCLS_DT1);
160     if (cp932[256 * (key->key[n] ^ 0x80) + i] & KCLS_K1)
161     bm |= KCLS_K2 | (cp932[256 * (key->key[n] ^ 0x80) + i] & KCLS_DT1);
162     #if 0
163     bm |= ((cp932[256 * key->key[n] + i] & KCLS_K1)
164     || (cp932[256 * (key->key[n] ^ 0x80) + i] & KCLS_K1)
165     ? KCLS_K2 : 0);
166     #endif
167     }
168     if (c & (KCLS_AN | KCLS_KA | KCLS_K2))
169     for (j = 0; j < 256; j++)
170     {
171     bm |= cp932[256 * i + j] & (KCLS_AN | KCLS_KA | KCLS_K1
172     | KCLS_DT0);
173     #if 0
174     if (j >= 127 && !(n == 0 || n == 1))
175     break;
176     #endif
177     }
178     key->map[n + 1][i] = bm;
179     #endif
180     if (i >= 128 && !(n == 0 || n == 1))
181     key->map[n + 1][i - 128] |= key->map[n + 1][i];
182     }
183    
184     if (n < 6)
185     key->map[n + 1][0x00] = key->map[n + 1][0x80] = 0;
186     if (n == 6)
187     key->map[7][0x00] |= KCLS_AN;
188     }
189    
190     #if USE_DT
191     unsigned
192     dt_get(int kdn,
193     int xn,
194     int n,
195     int ch)
196     {
197     int i;
198     #if DEBUG>=1
199     printf("*dt_get(%d)%c%c%c%c(%02X%02X:%02X%02X)->ch=%d",
200     n,
201     kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
202     kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
203     ch);
204     #endif
205     /* まずは数える */
206     for (i = 0;
207     kd[kdn][i].c[xn] == kd[kdn]->c[xn];
208     i++)
209     ;
210     assert(i > 0);
211     kd[kdn] += ch % i;
212     #if DEBUG>=1
213     printf("/%d\n dt_get: %c%c%c%c(%02X%02X:%02X%02X)->ch=%d\n",
214     i,
215     kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
216     kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
217     ch);
218     #endif
219     return kd[kdn]->c[n];
220     }
221     #endif
222    
223     /* マップから文字を拾ってセット */
224     unsigned
225     key_set(struct KS_KEY *key, int n, unsigned ch)
226     {
227     int cnt = 0, i;
228    
229     #if USE_DT
230     if (3 <= n && n < 7 && kd[n - 3])
231     {
232     return dt_get(n - 3, 2, 3, ch);
233     return kd[n - 3]->c[3];
234     }
235     else if (2 <= n && n < 6 && kd[n - 2])
236     {
237     return dt_get(n - 2, 1, 2, ch);
238     return kd[n - 2]->c[2];
239     }
240     else if (1 <= n && n < 5 && kd[n - 1])
241     {
242     return dt_get(n - 1, 0, 1, ch);
243     return kd[n - 1]->c[1];
244     }
245     #endif
246    
247     #if DEBUG>=3
248     if (cnt == 0)
249     {
250     printf("n=%d, ch=%d, (n-1)=%02X\n", n, ch, key[n - 1]);
251     int j;
252     for (i = 0; i < 16; i++)
253     {
254     printf("map[0x%02X] =", 16 * i);
255     for (j = 0; j < 16; j++)
256     printf(" %03X", kcls[n].map[16 * i + j]);
257     printf("\n");
258     }
259     }
260     #endif
261     for (i = 0; i < 256; i++)
262     {
263     #if 1
264     /* 鳥屋っぽーい */
265     if (1 <= n && n <= 2 && '.' < i && i <= 'z')
266     continue;
267     #endif
268     if (key->map[n][i])
269     {
270     if (ch-- == 0)
271     return i;
272     cnt++;
273     }
274     if (n != 1 && n != 2 && i >= 127)
275     break;
276     }
277     /* 見つからなかったのでもいっぺん */
278     assert(cnt > 0);
279     ch %= cnt;
280     for (i = 0; i < 256; i++)
281     if (key->map[n][i])
282     {
283     #if 1
284     /* 鳥屋っぽーい */
285     if (1 <= n && n <= 2 && '.' < i && i <= 'z')
286     continue;
287     #endif
288     if (ch-- == 0)
289     return i;
290     }
291     assert(!"not matched");
292     return 0;
293     }
294    
295     /* bitwise key をセット */
296     void
297     key_set64(struct KEY *key64,
298     int n,
299     unsigned k,
300     unsigned vk,
301     unsigned sk)
302     {
303     int i, j;
304     if (!((vk | sk) & 0x7F))
305     return;
306    
307     for (i = 0; i < 7; i++)
308     {
309     if (n == 7 && i < N_STRIDE) continue;
310     if (sk & (1 << i))
311     {
312     /* セット */
313     int o = tr_pc1[n][6 - i] - 1;
314     if (o < 28)
315     {
316     assert(o >= 0);
317     for (j = 0; j < N_ALU; j++)
318     key64->k[0][0][o].a[j]
319     = key64->k[0][1][o].a[j]
320     = -!!(k & (1 << i));
321     }
322     else
323     {
324     assert(o >= 28);
325     assert(o < 56);
326     for (j = 0; j < N_ALU; j++)
327     key64->k[1][0][o - 28].a[j]
328     = key64->k[1][1][o - 28].a[j]
329     = -!!(k & (1 << i));
330     }
331     }
332     else if (vk & (1 << i))
333     {
334     /* 反転 */
335     int o = tr_pc1[n][6 - i] - 1;
336     if (o < 28)
337     {
338     assert(o >= 0);
339     for (j = 0; j < N_ALU; j++)
340     key64->k[0][0][o].a[j]
341     = key64->k[0][1][o].a[j]
342     = ~key64->k[0][0][o].a[j];
343     }
344     else
345     {
346     assert(o >= 28);
347     assert(o < 56);
348     for (j = 0; j < N_ALU; j++)
349     key64->k[1][0][o - 28].a[j]
350     = key64->k[1][1][o - 28].a[j]
351     = ~key64->k[1][0][o - 28].a[j];
352     }
353     }
354     }
355     }
356    
357     /* 指定されたクラスの開始値にリセット
358     直前の文字のクラスに縛られる */
359     int
360     key_reset(struct KS_KEY *key, int n)
361     {
362     if (n >= 8)
363     return 1;
364     if (n == 7)
365     {
366     key->key[7] = 0;
367     return 1;
368     }
369    
370     /* 0-2 文字目はランダムに決める
371     3 文字目以降は初期値に */
372     if (n >= KEY_SHUFFLE_POS)
373     key->key[n] = key_set(key, n, 0);
374     else
375     key->key[n] = key_set(key, n, rand());
376    
377 notanpe 263 #ifdef KEYLOG
378     if ( keyLog && (n == 2) ) {
379     FILE *fp;
380     int i;
381     struct timeb tb;
382     struct tm *plt;
383    
384     ftime( &tb );
385     plt = localtime( &tb.time );
386    
387     WaitForSingleObject( mutexKeylog, INFINITE );
388    
389     if ( (fp = fopen( KEY_LOG_FILE, "at" )) == NULL ) {
390     perror( KEY_LOG_FILE );
391     exit( 1 );
392     }
393     fprintf( fp, "%02x%02x%02x", key->key[0], key->key[1], key->key[2] );
394     fprintf( fp, "\t%04d/%02d/%02d %02d:%02d:%02d.%03d\n",
395     plt->tm_year + 1900, plt->tm_mon + 1, plt->tm_mday,
396     plt->tm_hour, plt->tm_min, plt->tm_sec, tb.millitm );
397     fclose( fp );
398    
399     ReleaseMutex( mutexKeylog );
400     }
401     #endif /* KEYLOG */
402    
403 notanpe 252 #if DEBUG>=3
404     printf("key[%d]=%02X ncls=%04X\n", n, key[n], kcls[n].map[key[n]]);
405     #endif
406    
407     /* セットされた文字を元に、次キャラの文字クラスを決める */
408     key_make_map(key, n);
409    
410     return key_reset(key, n + 1);
411     }
412    
413     /* 指定された鍵空間の中で、キーをひとつ進める
414     安全にインクリメントできた場合 true を返す */
415     int
416     key_inc(struct KS_KEY *key, int n, int e)
417     {
418     if (n >= 8)
419     return 0;
420     else if (n == 7)
421     {
422     /* 最後のバイト */
423     uint8_t o_k = (key->key[7] + (1 << N_STRIDE)) & 0x7F;
424     if (!o_k)
425     return 0; /* インクリメントできなかったときは次へ進めず待つ */
426    
427     /* 進める */
428     key->key[7] = o_k;
429     return 1;
430     }
431     else if (n >= e - 1)
432     {
433     /* do nothing */
434     }
435     else if (key_inc(key, n + 1, e)
436     /*
437     && key_inc(n + 1)
438     && key_inc(n + 1)
439     && key_inc(n + 1)*/
440     )
441     return 1;
442    
443     /* Salt はインクリメントしない約束にする */
444     if (n == 1 || n == 2)
445     return 1;
446    
447     #if DEBUG>=3
448     printf("key_inc(n=%d,ck=%02X)\n", n, key->key[n]);
449     #endif
450    
451     #if USE_DT
452     /* 辞書語はインクリメントしていい約束にする */
453     if (3 <= n && n < 7 && kd[n - 3])
454     {
455     if ((key->key[n - 3] & 0x7F) == ((kd[n - 3] + 1)->c[0] & 0x7F)
456     && (key->key[n - 2] & 0x7F) == ((kd[n - 3] + 1)->c[1] & 0x7F)
457     && (key->key[n - 1] & 0x7F) == ((kd[n - 3] + 1)->c[2] & 0x7F))
458     {
459     memcpy(&key->key[n - 3], &(++kd[n - 3])->c[0], 4);
460     #if DEBUG>=2
461     printf(">dt_get:%c%c%c%c(%02X%02X:%02X%02X)\n",
462     kd[n - 3]->c[0], kd[n - 3]->c[1], kd[n - 3]->c[2], kd[n - 3]->c[3],
463     kd[n - 3]->c[0], kd[n - 3]->c[1], kd[n - 3]->c[2], kd[n - 3]->c[3]);
464     #endif
465     return 1;
466     }
467     else
468     {
469     return 0;
470     }
471     }
472     else if (2 <= n && n < 6 && kd[n - 2])
473     {
474     if ((key->key[n - 2] & 0x7F) == ((kd[n - 2] + 1)->c[0] & 0x7F)
475     && (key->key[n - 1] & 0x7F) == ((kd[n - 2] + 1)->c[1] & 0x7F))
476     {
477     memcpy(&key->key[n - 2], &(++kd[n - 2])->c[0], 4);
478     #if DEBUG>=2
479     printf(">dt_get:%c%c%c%c(%02X%02X:%02X%02X)\n",
480     kd[n - 2]->c[0], kd[n - 2]->c[1], kd[n - 2]->c[2], kd[n - 2]->c[3],
481     kd[n - 2]->c[0], kd[n - 2]->c[1], kd[n - 2]->c[2], kd[n - 2]->c[3]);
482     #endif
483     return 1;
484     }
485     else
486     {
487     return 0;
488     }
489     if (kd[n - 2]->c[0] == key->key[n - 2])
490     return 1;
491     else
492     return 0;
493     }
494     else if (1 <= n && n < 5 && kd[n - 1])
495     {
496     unsigned c2 = kd[n - 1]->c[0];
497     if ((0x81 <= c2 && c2 <= 0x9F)
498     || (0xE0 <= c2 && c2 <= 0xFC))
499     {
500     kd[n - 1] = NULL;
501     #if 0
502     if (!(n == 1 && n == 2))
503     key->key[n] &= 0x7F;
504     if (!(n == 2 && n == 3))
505     key->key[n - 1] &= 0x7F;
506     #endif
507     key_make_map(n - 1);
508     }
509     else if ((key->key[n - 1] & 0x7F) == ((kd[n - 1] + 1)->c[0] & 0x7F))
510     {
511     memcpy(&key->key[n - 1], &(++kd[n - 1])->c[0], 4);
512     #if DEBUG>=2
513     printf(">dt_get:%c%c%c%c(%02X%02X:%02X%02X)\n",
514     kd[n - 1]->c[0], kd[n - 1]->c[1], kd[n - 1]->c[2], kd[n - 1]->c[3],
515     kd[n - 1]->c[0], kd[n - 1]->c[1], kd[n - 1]->c[2], kd[n - 1]->c[3]);
516     #endif
517     return 1;
518     }
519     else
520     {
521     return 0;
522     }
523     #if 0
524     if (kd[n - 1]->c[0] == key->key[n - 1])
525     return 1;
526     else
527     return 0;
528     #endif
529     }
530     else if (n < 4 && kd[n])
531     {
532     if (0 && kd[n]->c[0] == key->key[n])
533     return 1;
534     kd[n] = NULL;
535     #if 0
536     if (!(n == 1 || n == 2))
537     key->key[n] &= 0x7F;
538     #endif
539     }
540     #endif
541    
542     /* 実際に増やしてみる */
543     assert(n >= 3);
544     for (;;)
545     {
546     #if USE_DT
547     if (n <= 3
548     && !(key->key[n] & 0x80)
549     && kcls[n].map[key->key[n] ^ 0x80] & (KCLS_DT0))
550     {
551     /* 半角カタカナの1バイト目 */
552     key->key[n] ^= 0x80;
553     }
554     else
555     #endif
556     {
557     key->key[n] = (key->key[n] & 0x7F) + 1;
558     if (key->key[n] >= 0x80)
559     {
560     key->key[n] = 0xFF; /* 次に突入させないため */
561     return 0;
562     }
563     }
564    
565     if (key->map[n][key->key[n]])
566     {
567     key_make_map(key, n);
568     key_reset(key, n + 1);
569     return 1;
570     }
571     }
572     }
573    
574     /* 鍵を完全にリセットする
575     Saltもセットし直す */
576     void
577     key_init(struct KS_KEY *key)
578     {
579     int i, j;
580    
581     #if USE_DT
582     /* 辞書を、インデクスを作りながらマップにはめこんで逝く
583     辞書はコード順昇順に並んでるものとする */
584     for (i = 0; i < dtcnt; i++)
585     {
586     unsigned c = dt[i].c[0];
587    
588     assert(dt[i].c[0]
589     && dt[i].c[1]
590     && dt[i].c[2]
591     && dt[i].c[3]);
592    
593     /* BSD 鯖でしにそうな文字は残念ながら除外 */
594     assert((dt[i].c[0] & 0x7F)
595     && (dt[i].c[1] & 0x7F)
596     && (dt[i].c[2] & 0x7F)
597     && (dt[i].c[3] & 0x7F));
598    
599     /* インデクス */
600     if (!dtidx[c])
601     dtidx[c] = &dt[i];
602    
603     if ((0x81 <= c && c <= 0x9F)
604     || (0xE0 <= c && c <= 0xFC))
605     {
606     /* 全角なので、2バイトきまった時点で立てる */
607     cp932[256 * c + dt[i].c[1]] |= KCLS_DT1;
608     }
609     else if (0xA1 <= c && c <= 0xDF)
610     {
611     /* 半角カナ */
612     for (j = 0; j < 256; j++)
613     cp932[256 * c + j] |= KCLS_DT0;
614     }
615     }
616     /* ケツ、ちうか番人 */
617     dtidx[0x100] = &dt[i];
618     #endif
619    
620     key->key[8] = 0;
621    
622     /* 初期マップを組む */
623     for (i = 0; i < 256; i++)
624     {
625     unsigned bm = 0;
626     key->map[0][i] = 0;
627     for (j = 0; j < 256; j++)
628     bm |= cp932[256 * i + j];
629     key->map[0][i] = bm & (KCLS_AN | KCLS_KA | KCLS_K1
630     | KCLS_DT0
631     );
632     if (i >= 128)
633     key->map[0][i - 128] |= key->map[0][i];
634     }
635    
636     key_reset(key, 0);
637     }
638    
639     /***************************************************************
640     *
641     * 固定キーの生成
642     *
643     * 一見 Big Endian に非対応のように見えるだろうが
644     * 随所でに散らばっている kludge により
645     * ALU_T が 64 ビットである限り、これで問題なく動く。
646     *
647     */
648    
649     void
650     key_init_sk(struct KEY *key)
651     {
652     int i, j;
653     int o;
654     uint64_t m;
655    
656     for (i = 5, m = 0xFFFFFFFF00000000ULL;
657     i >= 0;
658     m ^= (m >> (1 << --i)))
659     {
660     o = tr_pc1[7][6 - i] - 1;
661     #if DEBUG>=2
662     printf("%d:%d->%2d: %08X%08X\n",
663     N_Q, i, o,
664     (unsigned)(m >> 32),
665     (unsigned)m);
666     #endif
667     for (j = 0; j < N_Q; j++)
668     if (o < 28)
669     key->k[0][0][o ].q[j] = key->k[0][1][o ].q[j] = m;
670     else
671     key->k[1][0][o - 28].q[j] = key->k[1][1][o - 28].q[j] = m;
672     }
673     #if N_STRIDE==7
674     /* bit 6 は Little Endian として扱う */
675     o = 0;
676     assert(tr_pc1[7][0] - 1 == o);
677     assert(N_Q == 2);
678     key->k[0][0][o].q[0] = key->k[0][1][o].q[0] = 0x0000000000000000ULL;
679     key->k[0][0][o].q[1] = key->k[0][1][o].q[1] = 0xFFFFFFFFFFFFFFFFULL;
680     #endif
681     }
682    
683     /***************************************************************
684     *
685     * Salt のセット
686     * オペランドのオフセットを書き換えて回ってるので注意
687     *
688     */
689    
690     void
691     set_salt(CODE_T *code,
692     struct CRYPT64_DESC const *desc,
693     uint8_t const *k)
694     {
695     int i, j;
696    
697     for (i = 0; i < 2; i++)
698     {
699     unsigned s = k[1 + i] & 255;
700     if (s > 'z')
701     s = 0;
702     else if (s >= 'a')
703     s = s - 'a' + 2 + 10 + 26;
704     else if (s >= 'A')
705     s = s - 'A' + 2 + 10;
706     else if (s >= '.')
707     s = s - '.';
708     else
709     s = 0;
710    
711 notanpe 263 OLDPRINT( "Salt %d:%02x\n", i, s & 63 );
712    
713 notanpe 252 #if DEBUG>=1
714     printf("Salt %d:%3o\n", i, s & 63);
715     #endif
716     for (j = 0; j < 6; j++)
717     {
718     #if DEBUG>=2
719     //printf("Salt %d:%d %+3d:%+3d",
720     printf("Salt %d:%d %08lX:%08lX",
721     i, j,
722     LSALT(desc, code, 0, i, j, 0),
723     LSALT(desc, code, 0, i, j, 24));
724     #endif
725     if (s & (1 << j))
726     {
727     LSALT(desc, code, 0, i, j, 0) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);
728     LSALT(desc, code, 0, i, j, 24) = sizeof(WS_T) * (((4 * i + j - 1) & 31) - 16);
729     }
730     else
731     {
732     LSALT(desc, code, 0, i, j, 0) = sizeof(WS_T) * (((4 * i + j - 1) & 31) - 16);
733     LSALT(desc, code, 0, i, j, 24) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);
734     }
735     LSALT(desc, code, 0, i, j, 12) = sizeof(WS_T) * (((4 * i + j + 7) & 31) - 16);
736     LSALT(desc, code, 0, i, j, 36) = sizeof(WS_T) * (((4 * i + j + 23) & 31) - 16);
737     #if DEBUG>=2
738     //printf(" => %+3d:%+3d\n",
739     printf(" => %08lX:%08lX\n",
740     LSALT(desc, code, 0, i, j, 0),
741     LSALT(desc, code, 0, i, j, 24));
742     #endif
743     }
744     }
745     }
746    
747 notanpe 263 #ifdef KEYLOG
748     void
749     initMutexKeylog()
750     {
751     mutexKeylog = CreateMutex(NULL, FALSE, NULL);
752     }
753     #endif /* KEYLOG */
754    
755 notanpe 252 /*
756     * Local Variables:
757     * tab-width: 4
758     * End:
759     *
760     * EOF */
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help