1#include <time.h> 2 3#ifdef IOWNANATHLON 4#include <unistd.h> 5#define SLEEP sleep(4) 6#else 7#define SLEEP 8#endif 9 10#include "tommath.h" 11 12void ndraw(mp_int * a, char *name) 13{ 14 char buf[16000]; 15 16 printf("%s: ", name); 17 mp_toradix(a, buf, 10); 18 printf("%s\n", buf); 19} 20 21static void draw(mp_int * a) 22{ 23 ndraw(a, ""); 24} 25 26 27unsigned long lfsr = 0xAAAAAAAAUL; 28 29int lbit(void) 30{ 31 if (lfsr & 0x80000000UL) { 32 lfsr = ((lfsr << 1) ^ 0x8000001BUL) & 0xFFFFFFFFUL; 33 return 1; 34 } else { 35 lfsr <<= 1; 36 return 0; 37 } 38} 39 40int myrng(unsigned char *dst, int len, void *dat) 41{ 42 int x; 43 44 for (x = 0; x < len; x++) 45 dst[x] = rand() & 0xFF; 46 return len; 47} 48 49 50 51char cmd[4096], buf[4096]; 52int main(void) 53{ 54 mp_int a, b, c, d, e, f; 55 unsigned long expt_n, add_n, sub_n, mul_n, div_n, sqr_n, mul2d_n, div2d_n, 56 gcd_n, lcm_n, inv_n, div2_n, mul2_n, add_d_n, sub_d_n, t; 57 unsigned rr; 58 int i, n, err, cnt, ix, old_kara_m, old_kara_s; 59 mp_digit mp; 60 61 62 mp_init(&a); 63 mp_init(&b); 64 mp_init(&c); 65 mp_init(&d); 66 mp_init(&e); 67 mp_init(&f); 68 69 srand(time(NULL)); 70 71#if 0 72 // test montgomery 73 printf("Testing montgomery...\n"); 74 for (i = 1; i < 10; i++) { 75 printf("Testing digit size: %d\n", i); 76 for (n = 0; n < 1000; n++) { 77 mp_rand(&a, i); 78 a.dp[0] |= 1; 79 80 // let's see if R is right 81 mp_montgomery_calc_normalization(&b, &a); 82 mp_montgomery_setup(&a, &mp); 83 84 // now test a random reduction 85 for (ix = 0; ix < 100; ix++) { 86 mp_rand(&c, 1 + abs(rand()) % (2*i)); 87 mp_copy(&c, &d); 88 mp_copy(&c, &e); 89 90 mp_mod(&d, &a, &d); 91 mp_montgomery_reduce(&c, &a, mp); 92 mp_mulmod(&c, &b, &a, &c); 93 94 if (mp_cmp(&c, &d) != MP_EQ) { 95printf("d = e mod a, c = e MOD a\n"); 96mp_todecimal(&a, buf); printf("a = %s\n", buf); 97mp_todecimal(&e, buf); printf("e = %s\n", buf); 98mp_todecimal(&d, buf); printf("d = %s\n", buf); 99mp_todecimal(&c, buf); printf("c = %s\n", buf); 100printf("compare no compare!\n"); exit(EXIT_FAILURE); } 101 } 102 } 103 } 104 printf("done\n"); 105 106 // test mp_get_int 107 printf("Testing: mp_get_int\n"); 108 for (i = 0; i < 1000; ++i) { 109 t = ((unsigned long) rand() * rand() + 1) & 0xFFFFFFFF; 110 mp_set_int(&a, t); 111 if (t != mp_get_int(&a)) { 112 printf("mp_get_int() bad result!\n"); 113 return 1; 114 } 115 } 116 mp_set_int(&a, 0); 117 if (mp_get_int(&a) != 0) { 118 printf("mp_get_int() bad result!\n"); 119 return 1; 120 } 121 mp_set_int(&a, 0xffffffff); 122 if (mp_get_int(&a) != 0xffffffff) { 123 printf("mp_get_int() bad result!\n"); 124 return 1; 125 } 126 // test mp_sqrt 127 printf("Testing: mp_sqrt\n"); 128 for (i = 0; i < 1000; ++i) { 129 printf("%6d\r", i); 130 fflush(stdout); 131 n = (rand() & 15) + 1; 132 mp_rand(&a, n); 133 if (mp_sqrt(&a, &b) != MP_OKAY) { 134 printf("mp_sqrt() error!\n"); 135 return 1; 136 } 137 mp_n_root(&a, 2, &a); 138 if (mp_cmp_mag(&b, &a) != MP_EQ) { 139 printf("mp_sqrt() bad result!\n"); 140 return 1; 141 } 142 } 143 144 printf("\nTesting: mp_is_square\n"); 145 for (i = 0; i < 1000; ++i) { 146 printf("%6d\r", i); 147 fflush(stdout); 148 149 /* test mp_is_square false negatives */ 150 n = (rand() & 7) + 1; 151 mp_rand(&a, n); 152 mp_sqr(&a, &a); 153 if (mp_is_square(&a, &n) != MP_OKAY) { 154 printf("fn:mp_is_square() error!\n"); 155 return 1; 156 } 157 if (n == 0) { 158 printf("fn:mp_is_square() bad result!\n"); 159 return 1; 160 } 161 162 /* test for false positives */ 163 mp_add_d(&a, 1, &a); 164 if (mp_is_square(&a, &n) != MP_OKAY) { 165 printf("fp:mp_is_square() error!\n"); 166 return 1; 167 } 168 if (n == 1) { 169 printf("fp:mp_is_square() bad result!\n"); 170 return 1; 171 } 172 173 } 174 printf("\n\n"); 175 176 /* test for size */ 177 for (ix = 10; ix < 128; ix++) { 178 printf("Testing (not safe-prime): %9d bits \r", ix); 179 fflush(stdout); 180 err = 181 mp_prime_random_ex(&a, 8, ix, 182 (rand() & 1) ? 0 : LTM_PRIME_2MSB_ON, 183 myrng, NULL); 184 if (err != MP_OKAY) { 185 printf("failed with err code %d\n", err); 186 return EXIT_FAILURE; 187 } 188 if (mp_count_bits(&a) != ix) { 189 printf("Prime is %d not %d bits!!!\n", mp_count_bits(&a), ix); 190 return EXIT_FAILURE; 191 } 192 } 193 194 for (ix = 16; ix < 128; ix++) { 195 printf("Testing ( safe-prime): %9d bits \r", ix); 196 fflush(stdout); 197 err = 198 mp_prime_random_ex(&a, 8, ix, 199 ((rand() & 1) ? 0 : LTM_PRIME_2MSB_ON) | LTM_PRIME_SAFE, 200 myrng, NULL); 201 if (err != MP_OKAY) { 202 printf("failed with err code %d\n", err); 203 return EXIT_FAILURE; 204 } 205 if (mp_count_bits(&a) != ix) { 206 printf("Prime is %d not %d bits!!!\n", mp_count_bits(&a), ix); 207 return EXIT_FAILURE; 208 } 209 /* let's see if it's really a safe prime */ 210 mp_sub_d(&a, 1, &a); 211 mp_div_2(&a, &a); 212 mp_prime_is_prime(&a, 8, &cnt); 213 if (cnt != MP_YES) { 214 printf("sub is not prime!\n"); 215 return EXIT_FAILURE; 216 } 217 } 218 219 printf("\n\n"); 220 221 mp_read_radix(&a, "123456", 10); 222 mp_toradix_n(&a, buf, 10, 3); 223 printf("a == %s\n", buf); 224 mp_toradix_n(&a, buf, 10, 4); 225 printf("a == %s\n", buf); 226 mp_toradix_n(&a, buf, 10, 30); 227 printf("a == %s\n", buf); 228 229 230#if 0 231 for (;;) { 232 fgets(buf, sizeof(buf), stdin); 233 mp_read_radix(&a, buf, 10); 234 mp_prime_next_prime(&a, 5, 1); 235 mp_toradix(&a, buf, 10); 236 printf("%s, %lu\n", buf, a.dp[0] & 3); 237 } 238#endif 239 240 /* test mp_cnt_lsb */ 241 printf("testing mp_cnt_lsb...\n"); 242 mp_set(&a, 1); 243 for (ix = 0; ix < 1024; ix++) { 244 if (mp_cnt_lsb(&a) != ix) { 245 printf("Failed at %d, %d\n", ix, mp_cnt_lsb(&a)); 246 return 0; 247 } 248 mp_mul_2(&a, &a); 249 } 250 251/* test mp_reduce_2k */ 252 printf("Testing mp_reduce_2k...\n"); 253 for (cnt = 3; cnt <= 128; ++cnt) { 254 mp_digit tmp; 255 256 mp_2expt(&a, cnt); 257 mp_sub_d(&a, 2, &a); /* a = 2**cnt - 2 */ 258 259 260 printf("\nTesting %4d bits", cnt); 261 printf("(%d)", mp_reduce_is_2k(&a)); 262 mp_reduce_2k_setup(&a, &tmp); 263 printf("(%d)", tmp); 264 for (ix = 0; ix < 1000; ix++) { 265 if (!(ix & 127)) { 266 printf("."); 267 fflush(stdout); 268 } 269 mp_rand(&b, (cnt / DIGIT_BIT + 1) * 2); 270 mp_copy(&c, &b); 271 mp_mod(&c, &a, &c); 272 mp_reduce_2k(&b, &a, 2); 273 if (mp_cmp(&c, &b)) { 274 printf("FAILED\n"); 275 exit(0); 276 } 277 } 278 } 279 280/* test mp_div_3 */ 281 printf("Testing mp_div_3...\n"); 282 mp_set(&d, 3); 283 for (cnt = 0; cnt < 10000;) { 284 mp_digit r1, r2; 285 286 if (!(++cnt & 127)) 287 printf("%9d\r", cnt); 288 mp_rand(&a, abs(rand()) % 128 + 1); 289 mp_div(&a, &d, &b, &e); 290 mp_div_3(&a, &c, &r2); 291 292 if (mp_cmp(&b, &c) || mp_cmp_d(&e, r2)) { 293 printf("\n\nmp_div_3 => Failure\n"); 294 } 295 } 296 printf("\n\nPassed div_3 testing\n"); 297 298/* test the DR reduction */ 299 printf("testing mp_dr_reduce...\n"); 300 for (cnt = 2; cnt < 32; cnt++) { 301 printf("%d digit modulus\n", cnt); 302 mp_grow(&a, cnt); 303 mp_zero(&a); 304 for (ix = 1; ix < cnt; ix++) { 305 a.dp[ix] = MP_MASK; 306 } 307 a.used = cnt; 308 a.dp[0] = 3; 309 310 mp_rand(&b, cnt - 1); 311 mp_copy(&b, &c); 312 313 rr = 0; 314 do { 315 if (!(rr & 127)) { 316 printf("%9lu\r", rr); 317 fflush(stdout); 318 } 319 mp_sqr(&b, &b); 320 mp_add_d(&b, 1, &b); 321 mp_copy(&b, &c); 322 323 mp_mod(&b, &a, &b); 324 mp_dr_reduce(&c, &a, (((mp_digit) 1) << DIGIT_BIT) - a.dp[0]); 325 326 if (mp_cmp(&b, &c) != MP_EQ) { 327 printf("Failed on trial %lu\n", rr); 328 exit(-1); 329 330 } 331 } while (++rr < 500); 332 printf("Passed DR test for %d digits\n", cnt); 333 } 334 335#endif 336 337/* test the mp_reduce_2k_l code */ 338#if 0 339#if 0 340/* first load P with 2^1024 - 0x2A434 B9FDEC95 D8F9D550 FFFFFFFF FFFFFFFF */ 341 mp_2expt(&a, 1024); 342 mp_read_radix(&b, "2A434B9FDEC95D8F9D550FFFFFFFFFFFFFFFF", 16); 343 mp_sub(&a, &b, &a); 344#elif 1 345/* p = 2^2048 - 0x1 00000000 00000000 00000000 00000000 4945DDBF 8EA2A91D 5776399B B83E188F */ 346 mp_2expt(&a, 2048); 347 mp_read_radix(&b, 348 "1000000000000000000000000000000004945DDBF8EA2A91D5776399BB83E188F", 349 16); 350 mp_sub(&a, &b, &a); 351#endif 352 353 mp_todecimal(&a, buf); 354 printf("p==%s\n", buf); 355/* now mp_reduce_is_2k_l() should return */ 356 if (mp_reduce_is_2k_l(&a) != 1) { 357 printf("mp_reduce_is_2k_l() return 0, should be 1\n"); 358 return EXIT_FAILURE; 359 } 360 mp_reduce_2k_setup_l(&a, &d); 361 /* now do a million square+1 to see if it varies */ 362 mp_rand(&b, 64); 363 mp_mod(&b, &a, &b); 364 mp_copy(&b, &c); 365 printf("testing mp_reduce_2k_l..."); 366 fflush(stdout); 367 for (cnt = 0; cnt < (1UL << 20); cnt++) { 368 mp_sqr(&b, &b); 369 mp_add_d(&b, 1, &b); 370 mp_reduce_2k_l(&b, &a, &d); 371 mp_sqr(&c, &c); 372 mp_add_d(&c, 1, &c); 373 mp_mod(&c, &a, &c); 374 if (mp_cmp(&b, &c) != MP_EQ) { 375 printf("mp_reduce_2k_l() failed at step %lu\n", cnt); 376 mp_tohex(&b, buf); 377 printf("b == %s\n", buf); 378 mp_tohex(&c, buf); 379 printf("c == %s\n", buf); 380 return EXIT_FAILURE; 381 } 382 } 383 printf("...Passed\n"); 384#endif 385 386 div2_n = mul2_n = inv_n = expt_n = lcm_n = gcd_n = add_n = 387 sub_n = mul_n = div_n = sqr_n = mul2d_n = div2d_n = cnt = add_d_n = 388 sub_d_n = 0; 389 390 /* force KARA and TOOM to enable despite cutoffs */ 391 KARATSUBA_SQR_CUTOFF = KARATSUBA_MUL_CUTOFF = 8; 392 TOOM_SQR_CUTOFF = TOOM_MUL_CUTOFF = 16; 393 394 for (;;) { 395 /* randomly clear and re-init one variable, this has the affect of triming the alloc space */ 396 switch (abs(rand()) % 7) { 397 case 0: 398 mp_clear(&a); 399 mp_init(&a); 400 break; 401 case 1: 402 mp_clear(&b); 403 mp_init(&b); 404 break; 405 case 2: 406 mp_clear(&c); 407 mp_init(&c); 408 break; 409 case 3: 410 mp_clear(&d); 411 mp_init(&d); 412 break; 413 case 4: 414 mp_clear(&e); 415 mp_init(&e); 416 break; 417 case 5: 418 mp_clear(&f); 419 mp_init(&f); 420 break; 421 case 6: 422 break; /* don't clear any */ 423 } 424 425 426 printf 427 ("%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu/%4lu ", 428 add_n, sub_n, mul_n, div_n, sqr_n, mul2d_n, div2d_n, gcd_n, lcm_n, 429 expt_n, inv_n, div2_n, mul2_n, add_d_n, sub_d_n); 430 fgets(cmd, 4095, stdin); 431 cmd[strlen(cmd) - 1] = 0; 432 printf("%s ]\r", cmd); 433 fflush(stdout); 434 if (!strcmp(cmd, "mul2d")) { 435 ++mul2d_n; 436 fgets(buf, 4095, stdin); 437 mp_read_radix(&a, buf, 64); 438 fgets(buf, 4095, stdin); 439 sscanf(buf, "%d", &rr); 440 fgets(buf, 4095, stdin); 441 mp_read_radix(&b, buf, 64); 442 443 mp_mul_2d(&a, rr, &a); 444 a.sign = b.sign; 445 if (mp_cmp(&a, &b) != MP_EQ) { 446 printf("mul2d failed, rr == %d\n", rr); 447 draw(&a); 448 draw(&b); 449 return 0; 450 } 451 } else if (!strcmp(cmd, "div2d")) { 452 ++div2d_n; 453 fgets(buf, 4095, stdin); 454 mp_read_radix(&a, buf, 64); 455 fgets(buf, 4095, stdin); 456 sscanf(buf, "%d", &rr); 457 fgets(buf, 4095, stdin); 458 mp_read_radix(&b, buf, 64); 459 460 mp_div_2d(&a, rr, &a, &e); 461 a.sign = b.sign; 462 if (a.used == b.used && a.used == 0) { 463 a.sign = b.sign = MP_ZPOS; 464 } 465 if (mp_cmp(&a, &b) != MP_EQ) { 466 printf("div2d failed, rr == %d\n", rr); 467 draw(&a); 468 draw(&b); 469 return 0; 470 } 471 } else if (!strcmp(cmd, "add")) { 472 ++add_n; 473 fgets(buf, 4095, stdin); 474 mp_read_radix(&a, buf, 64); 475 fgets(buf, 4095, stdin); 476 mp_read_radix(&b, buf, 64); 477 fgets(buf, 4095, stdin); 478 mp_read_radix(&c, buf, 64); 479 mp_copy(&a, &d); 480 mp_add(&d, &b, &d); 481 if (mp_cmp(&c, &d) != MP_EQ) { 482 printf("add %lu failure!\n", add_n); 483 draw(&a); 484 draw(&b); 485 draw(&c); 486 draw(&d); 487 return 0; 488 } 489 490 /* test the sign/unsigned storage functions */ 491 492 rr = mp_signed_bin_size(&c); 493 mp_to_signed_bin(&c, (unsigned char *) cmd); 494 memset(cmd + rr, rand() & 255, sizeof(cmd) - rr); 495 mp_read_signed_bin(&d, (unsigned char *) cmd, rr); 496 if (mp_cmp(&c, &d) != MP_EQ) { 497 printf("mp_signed_bin failure!\n"); 498 draw(&c); 499 draw(&d); 500 return 0; 501 } 502 503 504 rr = mp_unsigned_bin_size(&c); 505 mp_to_unsigned_bin(&c, (unsigned char *) cmd); 506 memset(cmd + rr, rand() & 255, sizeof(cmd) - rr); 507 mp_read_unsigned_bin(&d, (unsigned char *) cmd, rr); 508 if (mp_cmp_mag(&c, &d) != MP_EQ) { 509 printf("mp_unsigned_bin failure!\n"); 510 draw(&c); 511 draw(&d); 512 return 0; 513 } 514 515 } else if (!strcmp(cmd, "sub")) { 516 ++sub_n; 517 fgets(buf, 4095, stdin); 518 mp_read_radix(&a, buf, 64); 519 fgets(buf, 4095, stdin); 520 mp_read_radix(&b, buf, 64); 521 fgets(buf, 4095, stdin); 522 mp_read_radix(&c, buf, 64); 523 mp_copy(&a, &d); 524 mp_sub(&d, &b, &d); 525 if (mp_cmp(&c, &d) != MP_EQ) { 526 printf("sub %lu failure!\n", sub_n); 527 draw(&a); 528 draw(&b); 529 draw(&c); 530 draw(&d); 531 return 0; 532 } 533 } else if (!strcmp(cmd, "mul")) { 534 ++mul_n; 535 fgets(buf, 4095, stdin); 536 mp_read_radix(&a, buf, 64); 537 fgets(buf, 4095, stdin); 538 mp_read_radix(&b, buf, 64); 539 fgets(buf, 4095, stdin); 540 mp_read_radix(&c, buf, 64); 541 mp_copy(&a, &d); 542 mp_mul(&d, &b, &d); 543 if (mp_cmp(&c, &d) != MP_EQ) { 544 printf("mul %lu failure!\n", mul_n); 545 draw(&a); 546 draw(&b); 547 draw(&c); 548 draw(&d); 549 return 0; 550 } 551 } else if (!strcmp(cmd, "div")) { 552 ++div_n; 553 fgets(buf, 4095, stdin); 554 mp_read_radix(&a, buf, 64); 555 fgets(buf, 4095, stdin); 556 mp_read_radix(&b, buf, 64); 557 fgets(buf, 4095, stdin); 558 mp_read_radix(&c, buf, 64); 559 fgets(buf, 4095, stdin); 560 mp_read_radix(&d, buf, 64); 561 562 mp_div(&a, &b, &e, &f); 563 if (mp_cmp(&c, &e) != MP_EQ || mp_cmp(&d, &f) != MP_EQ) { 564 printf("div %lu %d, %d, failure!\n", div_n, mp_cmp(&c, &e), 565 mp_cmp(&d, &f)); 566 draw(&a); 567 draw(&b); 568 draw(&c); 569 draw(&d); 570 draw(&e); 571 draw(&f); 572 return 0; 573 } 574 575 } else if (!strcmp(cmd, "sqr")) { 576 ++sqr_n; 577 fgets(buf, 4095, stdin); 578 mp_read_radix(&a, buf, 64); 579 fgets(buf, 4095, stdin); 580 mp_read_radix(&b, buf, 64); 581 mp_copy(&a, &c); 582 mp_sqr(&c, &c); 583 if (mp_cmp(&b, &c) != MP_EQ) { 584 printf("sqr %lu failure!\n", sqr_n); 585 draw(&a); 586 draw(&b); 587 draw(&c); 588 return 0; 589 } 590 } else if (!strcmp(cmd, "gcd")) { 591 ++gcd_n; 592 fgets(buf, 4095, stdin); 593 mp_read_radix(&a, buf, 64); 594 fgets(buf, 4095, stdin); 595 mp_read_radix(&b, buf, 64); 596 fgets(buf, 4095, stdin); 597 mp_read_radix(&c, buf, 64); 598 mp_copy(&a, &d); 599 mp_gcd(&d, &b, &d); 600 d.sign = c.sign; 601 if (mp_cmp(&c, &d) != MP_EQ) { 602 printf("gcd %lu failure!\n", gcd_n); 603 draw(&a); 604 draw(&b); 605 draw(&c); 606 draw(&d); 607 return 0; 608 } 609 } else if (!strcmp(cmd, "lcm")) { 610 ++lcm_n; 611 fgets(buf, 4095, stdin); 612 mp_read_radix(&a, buf, 64); 613 fgets(buf, 4095, stdin); 614 mp_read_radix(&b, buf, 64); 615 fgets(buf, 4095, stdin); 616 mp_read_radix(&c, buf, 64); 617 mp_copy(&a, &d); 618 mp_lcm(&d, &b, &d); 619 d.sign = c.sign; 620 if (mp_cmp(&c, &d) != MP_EQ) { 621 printf("lcm %lu failure!\n", lcm_n); 622 draw(&a); 623 draw(&b); 624 draw(&c); 625 draw(&d); 626 return 0; 627 } 628 } else if (!strcmp(cmd, "expt")) { 629 ++expt_n; 630 fgets(buf, 4095, stdin); 631 mp_read_radix(&a, buf, 64); 632 fgets(buf, 4095, stdin); 633 mp_read_radix(&b, buf, 64); 634 fgets(buf, 4095, stdin); 635 mp_read_radix(&c, buf, 64); 636 fgets(buf, 4095, stdin); 637 mp_read_radix(&d, buf, 64); 638 mp_copy(&a, &e); 639 mp_exptmod(&e, &b, &c, &e); 640 if (mp_cmp(&d, &e) != MP_EQ) { 641 printf("expt %lu failure!\n", expt_n); 642 draw(&a); 643 draw(&b); 644 draw(&c); 645 draw(&d); 646 draw(&e); 647 return 0; 648 } 649 } else if (!strcmp(cmd, "invmod")) { 650 ++inv_n; 651 fgets(buf, 4095, stdin); 652 mp_read_radix(&a, buf, 64); 653 fgets(buf, 4095, stdin); 654 mp_read_radix(&b, buf, 64); 655 fgets(buf, 4095, stdin); 656 mp_read_radix(&c, buf, 64); 657 mp_invmod(&a, &b, &d); 658 mp_mulmod(&d, &a, &b, &e); 659 if (mp_cmp_d(&e, 1) != MP_EQ) { 660 printf("inv [wrong value from MPI?!] failure\n"); 661 draw(&a); 662 draw(&b); 663 draw(&c); 664 draw(&d); 665 mp_gcd(&a, &b, &e); 666 draw(&e); 667 return 0; 668 } 669 670 } else if (!strcmp(cmd, "div2")) { 671 ++div2_n; 672 fgets(buf, 4095, stdin); 673 mp_read_radix(&a, buf, 64); 674 fgets(buf, 4095, stdin); 675 mp_read_radix(&b, buf, 64); 676 mp_div_2(&a, &c); 677 if (mp_cmp(&c, &b) != MP_EQ) { 678 printf("div_2 %lu failure\n", div2_n); 679 draw(&a); 680 draw(&b); 681 draw(&c); 682 return 0; 683 } 684 } else if (!strcmp(cmd, "mul2")) { 685 ++mul2_n; 686 fgets(buf, 4095, stdin); 687 mp_read_radix(&a, buf, 64); 688 fgets(buf, 4095, stdin); 689 mp_read_radix(&b, buf, 64); 690 mp_mul_2(&a, &c); 691 if (mp_cmp(&c, &b) != MP_EQ) { 692 printf("mul_2 %lu failure\n", mul2_n); 693 draw(&a); 694 draw(&b); 695 draw(&c); 696 return 0; 697 } 698 } else if (!strcmp(cmd, "add_d")) { 699 ++add_d_n; 700 fgets(buf, 4095, stdin); 701 mp_read_radix(&a, buf, 64); 702 fgets(buf, 4095, stdin); 703 sscanf(buf, "%d", &ix); 704 fgets(buf, 4095, stdin); 705 mp_read_radix(&b, buf, 64); 706 mp_add_d(&a, ix, &c); 707 if (mp_cmp(&b, &c) != MP_EQ) { 708 printf("add_d %lu failure\n", add_d_n); 709 draw(&a); 710 draw(&b); 711 draw(&c); 712 printf("d == %d\n", ix); 713 return 0; 714 } 715 } else if (!strcmp(cmd, "sub_d")) { 716 ++sub_d_n; 717 fgets(buf, 4095, stdin); 718 mp_read_radix(&a, buf, 64); 719 fgets(buf, 4095, stdin); 720 sscanf(buf, "%d", &ix); 721 fgets(buf, 4095, stdin); 722 mp_read_radix(&b, buf, 64); 723 mp_sub_d(&a, ix, &c); 724 if (mp_cmp(&b, &c) != MP_EQ) { 725 printf("sub_d %lu failure\n", sub_d_n); 726 draw(&a); 727 draw(&b); 728 draw(&c); 729 printf("d == %d\n", ix); 730 return 0; 731 } 732 } 733 } 734 return 0; 735} 736 737/* $Source$ */ 738/* $Revision$ */ 739/* $Date$ */ 740