Mercurial > dropbear
comparison demos/test.c @ 15:6362d3854bb4 libtomcrypt-orig
0.96 release of LibTomCrypt
author | Matt Johnston <matt@ucc.asn.au> |
---|---|
date | Tue, 15 Jun 2004 14:07:21 +0000 |
parents | 7faae8f46238 |
children | a3e31d3983cb |
comparison
equal
deleted
inserted
replaced
3:7faae8f46238 | 15:6362d3854bb4 |
---|---|
1200 { | 1200 { |
1201 printf ("MECC not compiled in\n"); | 1201 printf ("MECC not compiled in\n"); |
1202 } | 1202 } |
1203 #endif | 1203 #endif |
1204 | 1204 |
1205 #ifdef GF | |
1206 void | |
1207 gf_tests (void) | |
1208 { | |
1209 gf_int a, b, c, d; | |
1210 int n; | |
1211 unsigned char buf[1024]; | |
1212 | |
1213 printf ("GF tests\n"); | |
1214 gf_zero (a); | |
1215 gf_zero (b); | |
1216 gf_zero (c); | |
1217 gf_zero (d); | |
1218 | |
1219 /* a == 0x18000000b */ | |
1220 a[1] = 1; | |
1221 a[0] = 0x8000000bUL; | |
1222 | |
1223 /* b == 0x012345678 */ | |
1224 b[0] = 0x012345678UL; | |
1225 | |
1226 /* find 1/b mod a */ | |
1227 gf_invmod (b, a, c); | |
1228 | |
1229 /* find 1/1/b mod a */ | |
1230 gf_invmod (c, a, d); | |
1231 | |
1232 /* display them */ | |
1233 printf (" %08lx %08lx\n", c[0], d[0]); | |
1234 | |
1235 /* store as binary string */ | |
1236 n = gf_size (a); | |
1237 printf (" a takes %d bytes\n", n); | |
1238 gf_toraw (a, buf); | |
1239 gf_readraw (a, buf, n); | |
1240 printf (" a == %08lx%08lx\n", a[1], a[0]); | |
1241 | |
1242 /* primality testing */ | |
1243 gf_zero (a); | |
1244 a[0] = 0x169; | |
1245 printf (" GF prime: %s, ", gf_is_prime (a) ? "passed" : "failed"); | |
1246 a[0] = 0x168; | |
1247 printf (" %s\n", gf_is_prime (a) ? "failed" : "passed"); | |
1248 | |
1249 /* test sqrt code */ | |
1250 gf_zero (a); | |
1251 a[1] = 0x00000001; | |
1252 a[0] = 0x8000000bUL; | |
1253 gf_zero (b); | |
1254 b[0] = 0x12345678UL; | |
1255 | |
1256 gf_sqrt (b, a, c); | |
1257 gf_mulmod (c, c, a, b); | |
1258 printf (" (%08lx)^2 = %08lx (mod %08lx%08lx) \n", c[0], b[0], a[1], a[0]); | |
1259 } | |
1260 #else | |
1261 void | |
1262 gf_tests (void) | |
1263 { | |
1264 printf ("GF not compiled in\n"); | |
1265 } | |
1266 #endif | |
1267 | |
1268 #ifdef MPI | 1205 #ifdef MPI |
1269 void | 1206 void |
1270 test_prime (void) | 1207 test_prime (void) |
1271 { | 1208 { |
1272 char buf[1024]; | 1209 char buf[1024]; |
1387 #endif | 1324 #endif |
1388 #ifdef SPRNG | 1325 #ifdef SPRNG |
1389 register_prng (&sprng_desc); | 1326 register_prng (&sprng_desc); |
1390 #endif | 1327 #endif |
1391 } | 1328 } |
1392 | |
1393 #ifdef KR | |
1394 void | |
1395 kr_display (pk_key * kr) | |
1396 { | |
1397 static const char *sys[] = { "NON-KEY", "RSA", "DH", "ECC" }; | |
1398 static const char *type[] = { "PRIVATE", "PUBLIC", "PRIVATE_OPTIMIZED" }; | |
1399 | |
1400 while (kr->system != NON_KEY) { | |
1401 printf ("CRC [%08lx], System [%10s], Type [%20s], %s, %s, %s\n", kr->ID, | |
1402 sys[kr->system], type[kr->key_type], kr->name, kr->email, | |
1403 kr->description); | |
1404 kr = kr->next; | |
1405 } | |
1406 printf ("\n"); | |
1407 } | |
1408 | |
1409 void | |
1410 kr_test_makekeys (pk_key ** kr) | |
1411 { | |
1412 if ((errnum = kr_init (kr)) != CRYPT_OK) { | |
1413 printf ("KR init error %s\n", error_to_string (errnum)); | |
1414 exit (-1); | |
1415 } | |
1416 | |
1417 /* make a DH key */ | |
1418 printf ("KR: Making DH key...\n"); | |
1419 if ((errnum = | |
1420 kr_make_key (*kr, &prng, find_prng ("yarrow"), DH_KEY, 128, "dhkey", | |
1421 "[email protected]", "dhkey one")) != CRYPT_OK) { | |
1422 printf ("Make key error: %s\n", error_to_string (errnum)); | |
1423 exit (-1); | |
1424 } | |
1425 | |
1426 /* make a ECC key */ | |
1427 printf ("KR: Making ECC key...\n"); | |
1428 if ((errnum = | |
1429 kr_make_key (*kr, &prng, find_prng ("yarrow"), ECC_KEY, 20, "ecckey", | |
1430 "[email protected]", "ecckey one")) != CRYPT_OK) { | |
1431 printf ("Make key error: %s\n", error_to_string (errnum)); | |
1432 exit (-1); | |
1433 } | |
1434 | |
1435 /* make a RSA key */ | |
1436 printf ("KR: Making RSA key...\n"); | |
1437 if ((errnum = | |
1438 kr_make_key (*kr, &prng, find_prng ("yarrow"), RSA_KEY, 128, "rsakey", | |
1439 "[email protected]", "rsakey one")) != CRYPT_OK) { | |
1440 printf ("Make key error: %s\n", error_to_string (errnum)); | |
1441 exit (-1); | |
1442 } | |
1443 | |
1444 } | |
1445 | |
1446 void | |
1447 kr_test (void) | |
1448 { | |
1449 pk_key *kr, *_kr; | |
1450 unsigned char buf[8192], buf2[8192], buf3[8192]; | |
1451 unsigned long len; | |
1452 int i, j, stat; | |
1453 #ifndef NO_FILE | |
1454 FILE *f; | |
1455 #endif | |
1456 | |
1457 kr_test_makekeys (&kr); | |
1458 | |
1459 printf ("The original list:\n"); | |
1460 kr_display (kr); | |
1461 | |
1462 for (i = 0; i < 3; i++) { | |
1463 len = sizeof (buf); | |
1464 if ((errnum = kr_export (kr, kr->ID, kr->key_type, buf, &len)) != CRYPT_OK) { | |
1465 printf ("Error exporting key %d, %s\n", i, error_to_string (errnum)); | |
1466 exit (-1); | |
1467 } | |
1468 printf ("Exported key was: %lu bytes\n", len); | |
1469 if ((errnum = kr_del (&kr, kr->ID)) != CRYPT_OK) { | |
1470 printf ("Error deleting key %d, %s\n", i, error_to_string (errnum)); | |
1471 exit (-1); | |
1472 } | |
1473 kr_display (kr); | |
1474 if ((errnum = kr_import (kr, buf, len)) != CRYPT_OK) { | |
1475 printf ("Error importing key %d, %s\n", i, error_to_string (errnum)); | |
1476 exit (-1); | |
1477 } | |
1478 kr_display (kr); | |
1479 } | |
1480 | |
1481 for (i = 0; i < 3; i++) { | |
1482 len = sizeof (buf); | |
1483 if ((errnum = kr_export (kr, kr->ID, PK_PUBLIC, buf, &len)) != CRYPT_OK) { | |
1484 printf ("Error exporting key %d, %s\n", i, error_to_string (errnum)); | |
1485 exit (-1); | |
1486 } | |
1487 printf ("Exported key was: %lu bytes\n", len); | |
1488 if ((errnum = kr_del (&kr, kr->ID)) != CRYPT_OK) { | |
1489 printf ("Error deleting key %d, %s\n", i, error_to_string (errnum)); | |
1490 exit (-1); | |
1491 } | |
1492 kr_display (kr); | |
1493 if ((errnum = kr_import (kr, buf, len)) != CRYPT_OK) { | |
1494 printf ("Error importing key %d, %s\n", i, error_to_string (errnum)); | |
1495 exit (-1); | |
1496 } | |
1497 kr_display (kr); | |
1498 } | |
1499 | |
1500 if ((errnum = kr_clear (&kr)) != CRYPT_OK) { | |
1501 printf ("Error clearing ring: %s\n", error_to_string (errnum)); | |
1502 exit (-1); | |
1503 } | |
1504 | |
1505 | |
1506 /* TEST output to file */ | |
1507 #ifndef NO_FILE | |
1508 | |
1509 if ((errnum = kr_init (&kr)) != CRYPT_OK) { | |
1510 printf ("KR init error %s\n", error_to_string (errnum)); | |
1511 exit (-1); | |
1512 } | |
1513 kr_test_makekeys (&kr); | |
1514 | |
1515 /* save to file */ | |
1516 f = fopen ("ring.dat", "wb"); | |
1517 if ((errnum = kr_save (kr, f, NULL)) != CRYPT_OK) { | |
1518 printf ("kr_save error %s\n", error_to_string (errnum)); | |
1519 exit (-1); | |
1520 } | |
1521 fclose (f); | |
1522 | |
1523 /* delete and load */ | |
1524 if ((errnum = kr_clear (&kr)) != CRYPT_OK) { | |
1525 printf ("clear error: %s\n", error_to_string (errnum)); | |
1526 exit (-1); | |
1527 } | |
1528 | |
1529 f = fopen ("ring.dat", "rb"); | |
1530 if ((errnum = kr_load (&kr, f, NULL)) != CRYPT_OK) { | |
1531 printf ("kr_load error %s\n", error_to_string (errnum)); | |
1532 exit (-1); | |
1533 } | |
1534 fclose (f); | |
1535 remove ("ring.dat"); | |
1536 printf ("After load and save...\n"); | |
1537 kr_display (kr); | |
1538 | |
1539 if ((errnum = kr_clear (&kr)) != CRYPT_OK) { | |
1540 printf ("clear error: %s\n", error_to_string (errnum)); | |
1541 exit (-1); | |
1542 } | |
1543 #endif | |
1544 | |
1545 /* test the packet encryption/sign stuff */ | |
1546 for (i = 0; i < 32; i++) | |
1547 buf[i] = i; | |
1548 kr_test_makekeys (&kr); | |
1549 _kr = kr; | |
1550 for (i = 0; i < 3; i++) { | |
1551 printf ("Testing a key with system %d, type %d:\t", _kr->system, | |
1552 _kr->key_type); | |
1553 len = sizeof (buf2); | |
1554 if ((errnum = | |
1555 kr_encrypt_key (kr, _kr->ID, buf, 16, buf2, &len, &prng, | |
1556 find_prng ("yarrow"), | |
1557 find_hash ("md5"))) != CRYPT_OK) { | |
1558 printf ("Encrypt error, %d, %s\n", i, error_to_string (errnum)); | |
1559 exit (-1); | |
1560 } | |
1561 len = sizeof (buf3); | |
1562 if ((errnum = kr_decrypt_key (kr, buf2, buf3, &len)) != CRYPT_OK) { | |
1563 printf ("decrypt error, %d, %s\n", i, error_to_string (errnum)); | |
1564 exit (-1); | |
1565 } | |
1566 if (len != 16 || memcmp (buf3, buf, 16)) { | |
1567 printf ("kr_decrypt_key failed, %i, %lu\n", i, len); | |
1568 exit (-1); | |
1569 } | |
1570 printf ("kr_encrypt_key passed, "); | |
1571 | |
1572 len = sizeof (buf2); | |
1573 if ((errnum = | |
1574 kr_sign_hash (kr, _kr->ID, buf, 32, buf2, &len, &prng, | |
1575 find_prng ("yarrow"))) != CRYPT_OK) { | |
1576 printf ("kr_sign_hash failed, %i, %s\n", i, error_to_string (errnum)); | |
1577 exit (-1); | |
1578 } | |
1579 printf ("kr_sign_hash: "); | |
1580 if ((errnum = kr_verify_hash (kr, buf2, buf, 32, &stat)) != CRYPT_OK) { | |
1581 printf ("kr_sign_hash failed, %i, %s\n", i, error_to_string (errnum)); | |
1582 exit (-1); | |
1583 } | |
1584 printf ("%s, ", stat ? "passed" : "failed"); | |
1585 buf[15] ^= 1; | |
1586 if ((errnum = kr_verify_hash (kr, buf2, buf, 32, &stat)) != CRYPT_OK) { | |
1587 printf ("kr_sign_hash failed, %i, %s\n", i, error_to_string (errnum)); | |
1588 exit (-1); | |
1589 } | |
1590 printf ("%s\n", (!stat) ? "passed" : "failed"); | |
1591 buf[15] ^= 1; | |
1592 | |
1593 len = sizeof (buf); | |
1594 if ((errnum = | |
1595 kr_fingerprint (kr, _kr->ID, find_hash ("sha1"), buf, | |
1596 &len)) != CRYPT_OK) { | |
1597 printf ("kr_fingerprint failed, %i, %lu\n", i, len); | |
1598 exit (-1); | |
1599 } | |
1600 printf ("Fingerprint: "); | |
1601 for (j = 0; j < 20; j++) { | |
1602 printf ("%02x", buf[j]); | |
1603 if (j < 19) | |
1604 printf (":"); | |
1605 } | |
1606 printf ("\n\n"); | |
1607 | |
1608 _kr = _kr->next; | |
1609 } | |
1610 | |
1611 /* Test encrypting/decrypting to a public key */ | |
1612 /* first dump the other two keys */ | |
1613 kr_del (&kr, kr->ID); | |
1614 kr_del (&kr, kr->ID); | |
1615 kr_display (kr); | |
1616 | |
1617 /* now export it as public and private */ | |
1618 len = sizeof (buf); | |
1619 if ((errnum = kr_export (kr, kr->ID, PK_PUBLIC, buf, &len)) != CRYPT_OK) { | |
1620 printf ("Error exporting key %d, %s\n", i, error_to_string (errnum)); | |
1621 exit (-1); | |
1622 } | |
1623 | |
1624 /* check boundaries */ | |
1625 memset (buf + len, 0, sizeof (buf) - len); | |
1626 | |
1627 len = sizeof (buf2); | |
1628 if ((errnum = kr_export (kr, kr->ID, PK_PRIVATE, buf2, &len)) != CRYPT_OK) { | |
1629 printf ("Error exporting key %s\n", error_to_string (errnum)); | |
1630 exit (-1); | |
1631 } | |
1632 | |
1633 /* check boundaries */ | |
1634 memset (buf2 + len, 0, sizeof (buf2) - len); | |
1635 | |
1636 /* delete the key and import the public */ | |
1637 kr_clear (&kr); | |
1638 kr_init (&kr); | |
1639 kr_display (kr); | |
1640 if ((errnum = kr_import (kr, buf, len)) != CRYPT_OK) { | |
1641 printf ("Error importing key %s\n", error_to_string (errnum)); | |
1642 exit (-1); | |
1643 } | |
1644 kr_display (kr); | |
1645 | |
1646 /* now encrypt a buffer */ | |
1647 for (i = 0; i < 16; i++) | |
1648 buf[i] = i; | |
1649 len = sizeof (buf3); | |
1650 if ((errnum = | |
1651 kr_encrypt_key (kr, kr->ID, buf, 16, buf3, &len, &prng, | |
1652 find_prng ("yarrow"), | |
1653 find_hash ("md5"))) != CRYPT_OK) { | |
1654 printf ("Encrypt error, %d, %s\n", i, error_to_string (errnum)); | |
1655 exit (-1); | |
1656 } | |
1657 | |
1658 /* now delete the key and import the private one */ | |
1659 kr_clear (&kr); | |
1660 kr_init (&kr); | |
1661 kr_display (kr); | |
1662 if ((errnum = kr_import (kr, buf2, len)) != CRYPT_OK) { | |
1663 printf ("Error importing key %s\n", error_to_string (errnum)); | |
1664 exit (-1); | |
1665 } | |
1666 kr_display (kr); | |
1667 | |
1668 /* now decrypt */ | |
1669 len = sizeof (buf2); | |
1670 if ((errnum = kr_decrypt_key (kr, buf3, buf2, &len)) != CRYPT_OK) { | |
1671 printf ("decrypt error, %s\n", error_to_string (errnum)); | |
1672 exit (-1); | |
1673 } | |
1674 | |
1675 printf ("KR encrypt to public, decrypt with private: "); | |
1676 if (len == 16 && !memcmp (buf2, buf, 16)) { | |
1677 printf ("passed\n"); | |
1678 } else { | |
1679 printf ("failed\n"); | |
1680 } | |
1681 | |
1682 kr_clear (&kr); | |
1683 } | |
1684 #endif | |
1685 | 1329 |
1686 void | 1330 void |
1687 test_errs (void) | 1331 test_errs (void) |
1688 { | 1332 { |
1689 #define ERR(x) printf("%25s => %s\n", #x, error_to_string(x)); | 1333 #define ERR(x) printf("%25s => %s\n", #x, error_to_string(x)); |
1838 exit(-1); | 1482 exit(-1); |
1839 } | 1483 } |
1840 | 1484 |
1841 /* decode it */ | 1485 /* decode it */ |
1842 l2 = sizeof(buf[2]); | 1486 l2 = sizeof(buf[2]); |
1843 if ((err = pkcs_1_oaep_decode(buf[1], l1, NULL, 0, 1024, hash_idx, buf[2], &l2)) != CRYPT_OK) { | 1487 if ((err = pkcs_1_oaep_decode(buf[1], l1, NULL, 0, 1024, hash_idx, buf[2], &l2, &res1)) != CRYPT_OK) { |
1844 printf("OAEP decode: %s\n", error_to_string(err)); | 1488 printf("OAEP decode: %s\n", error_to_string(err)); |
1845 exit(-1); | 1489 exit(-1); |
1846 } | 1490 } |
1847 | 1491 |
1848 if (l2 != l3 || memcmp(buf[2], buf[0], l3) != 0) { | 1492 if (res1 != 1 || l2 != l3 || memcmp(buf[2], buf[0], l3) != 0) { |
1849 printf("Outsize == %lu, should have been %lu, msg contents follow.\n", l2, l3); | 1493 printf("res == %d, Outsize == %lu, should have been %lu, msg contents follow.\n", res1, l2, l3); |
1850 printf("ORIGINAL:\n"); | 1494 printf("ORIGINAL:\n"); |
1851 for (x = 0; x < l3; x++) { | 1495 for (x = 0; x < l3; x++) { |
1852 printf("%02x ", buf[0][x]); | 1496 printf("%02x ", buf[0][x]); |
1853 } | 1497 } |
1854 printf("\nRESULT:\n"); | 1498 printf("\nRESULT:\n"); |
1957 cfb_tests (); | 1601 cfb_tests (); |
1958 | 1602 |
1959 rng_tests (); | 1603 rng_tests (); |
1960 test_prime(); | 1604 test_prime(); |
1961 | 1605 |
1962 #ifdef KR | |
1963 kr_test (); | |
1964 #endif | |
1965 dsa_tests(); | 1606 dsa_tests(); |
1966 rsa_test (); | 1607 rsa_test (); |
1967 pad_test (); | 1608 pad_test (); |
1968 ecc_tests (); | 1609 ecc_tests (); |
1969 dh_tests (); | 1610 dh_tests (); |
1970 | 1611 |
1971 gf_tests (); | |
1972 base64_test (); | 1612 base64_test (); |
1973 | 1613 |
1974 time_ecb (); | 1614 time_ecb (); |
1975 time_hash (); | 1615 time_hash (); |
1976 | 1616 |