Develop and Download Open Source Software

プロジェクト・ナニ屋

Browse Subversion Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 263 - (show annotations) (download) (as text)
Mon Jul 4 09:42:05 2011 UTC (12 years, 8 months ago) by notanpe
File MIME type: text/x-csrc
File size: 16712 byte(s) 
検索空間の記録機能を追加
1 /***********************************************************************
2 *
3 * file: key.c
4 *
5 * $Id: key.c 241 2010-03-15 14:28:18Z chapuni $
6 *
7 */
8
9 #include <stdio.h>
10 #include <assert.h>
11 #include <stdlib.h>
12
13 #ifdef KEYLOG
14 #include <time.h>
15 #include <windows.h>
16 #endif /* KEYLOG */
17
18 #include "cp932.h"
19 #include "desconst.h"
20 #include "key.h"
21 #include "translate.h"
22 #include "makai.h"
23 #include "util.h"
24
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 #ifdef KEYLOG
43 #define KEY_LOG_FILE "keylog.txt"
44 int keyLog = MAKAI_FALSE;
45 static HANDLE mutexKeylog;
46 #endif /* KEYLOG */
47
48 /* 指定されたクラスと入っているキーから、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 #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 #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 OLDPRINT( "Salt %d:%02x\n", i, s & 63 );
712
713 #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 #ifdef KEYLOG
748 void
749 initMutexKeylog()
750 {
751 mutexKeylog = CreateMutex(NULL, FALSE, NULL);
752 }
753 #endif /* KEYLOG */
754
755 /*
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