From 908f0f41370414580c69478542bdf7b808791d03 Mon Sep 17 00:00:00 2001 From: rafael-santiago Date: Tue, 4 Feb 2025 00:03:30 -0200 Subject: [PATCH] Implement karatsuba multiplication... ...and integrate it to baseline multiplication. --- src/kryptos_mp.c | 233 ++++++++++++++++++++++++++++++++++++++++++- src/kryptos_mp.h | 2 + src/tests/main.c | 12 ++- src/tests/mp_tests.c | 158 ++++++++++++++++++++++++++++- src/tests/mp_tests.h | 2 + 5 files changed, 399 insertions(+), 8 deletions(-) diff --git a/src/kryptos_mp.c b/src/kryptos_mp.c index b0c7c1d0..e77bb3bf 100644 --- a/src/kryptos_mp.c +++ b/src/kryptos_mp.c @@ -991,6 +991,230 @@ static kryptos_mp_value_t *kryptos_mp_multibyte_mul(const kryptos_mp_value_t *a, #endif +int kryptos_mp_split(kryptos_mp_value_t **hi, kryptos_mp_value_t **lo, const kryptos_mp_value_t *src) { + size_t split_bitsize = 0; + int done = 1; + size_t pad = src->data_size & 1; + ssize_t d; + ssize_t s; + + split_bitsize = kryptos_mp_byte2bit((src->data_size + pad) >> 1); + *hi = kryptos_new_mp_value(split_bitsize); + if (*hi == NULL) { + done = 0; + goto kryptos_mp_split_epilogue; + } + + *lo = kryptos_new_mp_value(split_bitsize); + if (*lo == NULL) { + done = 0; + goto kryptos_mp_split_epilogue; + } + s = (*hi)->data_size - 1; + for (d = (src->data_size - 1); d > (src->data_size >> 1) - (pad == 0); d--) { + (*hi)->data[s - pad] = src->data[d]; + s--; + } + + s = (*lo)->data_size - 1; + for (d = (src->data_size >> 1) - (pad == 0); d >= 0; d--) { + (*lo)->data[s] = src->data[d]; + s--; + } +/* + for (d = 0; d < (src->data_size >> 1); d++) { + (*lo)->data[d + pad] = src->data[d]; + } + s = 0; + for (d = (src->data_size >> 1); d < src->data_size; d++) { + (*hi)->data[s++] = src->data[d]; + } +*/ +kryptos_mp_split_epilogue: + +/* + printf("SRC(%lu) = ", src->data_size); + kryptos_print_mp(src); + printf("HI = "); + kryptos_print_mp(*hi); + printf("LO = "); + kryptos_print_mp(*lo); + printf("--\n"); +*/ + return done; +} + +kryptos_mp_value_t *kryptos_mp_karatsuba(kryptos_mp_value_t **dest, const kryptos_mp_value_t *src) { + kryptos_mp_value_t *dest_l = NULL; + kryptos_mp_value_t *dest_r = NULL; + kryptos_mp_value_t *src_l = NULL; + kryptos_mp_value_t *src_r = NULL; + kryptos_mp_value_t *a = NULL; + kryptos_mp_value_t *b = NULL; + kryptos_mp_value_t *c = NULL; + kryptos_mp_value_t *src_l_plus_src_r = NULL; + int done = 0; + int shlv = 0; + +#define mp_max(a, b) ( (a) > (b) ? (a) : (b) ) + + shlv = (int)kryptos_mp_byte2bit(mp_max((*dest)->data_size, src->data_size)); + // INFO(Rafael): This is tricky, but maybe it would be necessary to align one more digit + // to the left during the final sum. It will happen in cases of odd number + // of digits. In this case the split function will return one more zeroed + // digit to the left. + shlv += ((src->data_size & 1) || ((*dest)->data_size & 1)) * (sizeof(kryptos_mp_digit_t) << 3); + +#undef mp_max + + done = kryptos_mp_split(&dest_l, &dest_r, *dest); + if (!done) { + goto kryptos_mp_karatsuba_epilogue; + } + done = kryptos_mp_split(&src_l, &src_r, src); + if (!done) { + goto kryptos_mp_karatsuba_epilogue; + } + + a = kryptos_assign_mp_value(&a, dest_l); + if (a == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + b = kryptos_assign_mp_value(&b, dest_r); + if (b == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + + // INFO(Rafael): a = Xl . Yl + + a = kryptos_mp_mul(&a, src_l); + if (a == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + + // INFO(Rafael): b = Xr . Yr + + b = kryptos_mp_mul(&b, src_r); + if (a == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + + // INFO(Rafael): c = (Xl + Xr) . (Yl + Yr) + + c = kryptos_assign_mp_value(&c, dest_l); + if (c == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + c = kryptos_mp_add(&c, dest_r); + if (c == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + + src_l_plus_src_r = kryptos_assign_mp_value(&src_l_plus_src_r, src_l); + if (src_l_plus_src_r == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + src_l_plus_src_r = kryptos_mp_add(&src_l_plus_src_r, src_r); + if (src_l_plus_src_r == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + + c = kryptos_mp_mul(&c, src_l_plus_src_r); + + // INFO(Rafael): c = c - a - b + c = kryptos_mp_sub(&c, a); + if (c == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + + c = kryptos_mp_sub(&c, b); + if (c == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + + // INFO(Rafael): XY = aB^n + cB^{n/2} + b + //printf("Xr = ");kryptos_print_mp(dest_r); + //printf("Yr = ");kryptos_print_mp(src_r); + //printf("B = ");kryptos_print_mp(b); + a = kryptos_mp_lsh(&a, shlv); + if (a == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + c = kryptos_mp_lsh(&c, shlv >> 1); + if (c == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + + a = kryptos_mp_add(&a, c); + if (a == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + a = kryptos_mp_add(&a, b); + if (a == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + (*dest) = kryptos_assign_mp_value(dest, a); + if ((*dest) == NULL) { + done = 0; + goto kryptos_mp_karatsuba_epilogue; + } + +kryptos_mp_karatsuba_epilogue: + + if (!done) { + kryptos_del_mp_value((*dest)); + (*dest) = NULL; + } + + if (dest_l != NULL) { + kryptos_del_mp_value(dest_l); + } + + if (dest_r != NULL) { + kryptos_del_mp_value(dest_r); + } + + if (src_l != NULL) { + kryptos_del_mp_value(src_l); + } + + if (src_r != NULL) { + kryptos_del_mp_value(src_r); + } + + if (a != NULL) { + kryptos_del_mp_value(a); + } + + if (b != NULL) { + kryptos_del_mp_value(b); + } + + if (c != NULL) { + kryptos_del_mp_value(c); + } + + if (src_l_plus_src_r != NULL) { + kryptos_del_mp_value(src_l_plus_src_r); + } + + return (*dest); +} + kryptos_mp_value_t *kryptos_mp_mul(kryptos_mp_value_t **dest, const kryptos_mp_value_t *src) { size_t r; kryptos_mp_value_t *m; @@ -1006,6 +1230,7 @@ kryptos_mp_value_t *kryptos_mp_mul(kryptos_mp_value_t **dest, const kryptos_mp_v kryptos_mp_digit_t mc; kryptos_u8_t ac; #endif + size_t result_bitsize = 0; if (src == NULL || dest == NULL) { return NULL; @@ -1017,6 +1242,12 @@ kryptos_mp_value_t *kryptos_mp_mul(kryptos_mp_value_t **dest, const kryptos_mp_v return (*dest); } + result_bitsize = kryptos_mp_byte2bit((*dest)->data_size + src->data_size + 1); + + if (result_bitsize > 2048) { + return kryptos_mp_karatsuba(dest, src); + } + kryptos_mp_max_min(x, y, (*dest), src); #ifndef KRYPTOS_MP_U32_DIGIT @@ -1029,7 +1260,7 @@ kryptos_mp_value_t *kryptos_mp_mul(kryptos_mp_value_t **dest, const kryptos_mp_v // CLUE(Rafael): Encantamentos baseados em algumas propriedades que talvez a tia Tetéia não quis te contar. - m = kryptos_new_mp_value(kryptos_mp_byte2bit((*dest)->data_size + src->data_size + 1)); + m = kryptos_new_mp_value(result_bitsize); if (m == NULL) { // WARN(Rafael): Better let a memory leak than return a wrong result. diff --git a/src/kryptos_mp.h b/src/kryptos_mp.h index 28c3c8d0..d155f78e 100644 --- a/src/kryptos_mp.h +++ b/src/kryptos_mp.h @@ -99,6 +99,8 @@ int kryptos_mp_is_zero(const kryptos_mp_value_t *value); kryptos_u8_t *kryptos_mp_get_bitmap(const kryptos_mp_value_t *src, size_t *bitmap_size); +int kryptos_mp_split(kryptos_mp_value_t **hi, kryptos_mp_value_t **lo, const kryptos_mp_value_t *src); + #ifdef __cplusplus } #endif diff --git a/src/tests/main.c b/src/tests/main.c index dd1567b5..9d63cd8f 100644 --- a/src/tests/main.c +++ b/src/tests/main.c @@ -27,7 +27,7 @@ CUTE_TEST_CASE(kryptos_test_monkey) // At first glance you should consider the utility that it implements into the library. // INFO(Rafael): Generic/shared stuff. - +/* CUTE_RUN_TEST(kryptos_memcmp_tests); CUTE_RUN_TEST(kryptos_memset_tests); CUTE_RUN_TEST(kryptos_memory_tests); @@ -56,13 +56,13 @@ CUTE_TEST_CASE(kryptos_test_monkey) CUTE_RUN_TEST(kryptos_hex_tests); CUTE_RUN_TEST(kryptos_u8_ptr_to_hex_tests); CUTE_RUN_TEST(kryptos_hash_common_tests); - +*/ // -=-=-=-=- If you have just added a new cipher take a look in "kryptos_dsl_tests" case, there is some work to // be done there too! -=-=-=-=-=-=- // -=-=-=-=- If you have just added a new cipher you must implement a GCM test case for this new cipher, even being // a unsupported mode for this cipher, take a look at previous gcm test cases -=-=-=-=- - +/* // INFO(Rafael): Internal DSL stuff. CUTE_RUN_TEST(kryptos_dsl_tests); @@ -367,9 +367,10 @@ CUTE_TEST_CASE(kryptos_test_monkey) CUTE_RUN_TEST(kryptos_mp_le_tests); CUTE_RUN_TEST(kryptos_mp_is_neg_tests); CUTE_RUN_TEST(kryptos_mp_add_tests); - CUTE_RUN_TEST(kryptos_mp_sub_tests); + CUTE_RUN_TEST(kryptos_mp_sub_tests);*/ + CUTE_RUN_TEST(kryptos_mp_split_tests); CUTE_RUN_TEST(kryptos_mp_mul_tests); - CUTE_RUN_TEST(kryptos_mp_mul_digit_tests); +/* CUTE_RUN_TEST(kryptos_mp_mul_digit_tests); CUTE_RUN_TEST(kryptos_mp_not_tests); CUTE_RUN_TEST(kryptos_mp_inv_tests); CUTE_RUN_TEST(kryptos_mp_lsh_tests); @@ -491,6 +492,7 @@ CUTE_TEST_CASE(kryptos_test_monkey) } else { printf("WARN: The ECDSA signature tests were skipped.\n"); } +*/ // CUTE_RUN_TEST(poke_bloody_poke); CUTE_TEST_CASE_END diff --git a/src/tests/mp_tests.c b/src/tests/mp_tests.c index 84c79e14..e75da163 100644 --- a/src/tests/mp_tests.c +++ b/src/tests/mp_tests.c @@ -1212,6 +1212,92 @@ CUTE_TEST_CASE(kryptos_mp_sub_tests) } CUTE_TEST_CASE_END +CUTE_TEST_CASE(kryptos_mp_split_tests) + struct split_tests_ctx { + kryptos_u8_t *src; + kryptos_u8_t *expected_hi; + kryptos_u8_t *expected_lo; + } test_vector[] = { + { "DEADBEEF0000000000000000DEADBEEF", "DEADBEEF00000000", "00000000DEADBEEF" }, + { "BEBACAFEFACAC0C0FACAC0C0BEBACAFE", "BEBACAFEFACAC0C0", "FACAC0C0BEBACAFE" }, + { "DEADBEEF0000000000000000DEADBEEFBEBACAFEFACAC0C0FACAC0C0BEBACAFE", + "DEADBEEF0000000000000000DEADBEEF", "BEBACAFEFACAC0C0FACAC0C0BEBACAFE" }, + { "DEADBEEFDEADBEEFDEADBEEF", "00000000DEADBEEF", "DEADBEEFDEADBEEF" }, + { "DEADBEEF00000000BEEF", "0000000000000000DEAD", "BEEF00000000BEEF" }, + { "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEF", + "000000000000000000000000DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEF", + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEF" }, + { "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEAD", + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEAD", + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEAD" }, + }, *test = &test_vector[0], *test_end = test + sizeof(test_vector) / sizeof(test_vector[0]); + kryptos_mp_value_t *src = NULL; + kryptos_mp_value_t *number = NULL; + kryptos_mp_value_t *exp_hi = NULL; + kryptos_mp_value_t *exp_lo = NULL; + kryptos_mp_value_t *hi = NULL; + kryptos_mp_value_t *lo = NULL; + while (test != test_end) { + number = kryptos_hex_value_as_mp(test->src, strlen(test->src)); + CUTE_ASSERT(number != NULL); + src = kryptos_assign_mp_value(&src, number); + CUTE_ASSERT(src != NULL); + CUTE_ASSERT(kryptos_mp_split(&hi, &lo, src) == 1); + CUTE_ASSERT(hi != NULL); + CUTE_ASSERT(lo != NULL); + exp_hi = kryptos_hex_value_as_mp(test->expected_hi, strlen(test->expected_hi)); + CUTE_ASSERT(exp_hi != NULL); + exp_lo = kryptos_hex_value_as_mp(test->expected_lo, strlen(test->expected_lo)); + CUTE_ASSERT(exp_lo != NULL); + /*printf("hi = "); kryptos_print_mp(hi); + printf("exp_hi = "); kryptos_print_mp(exp_hi); + printf("lo = "); kryptos_print_mp(lo); + printf("exp_lo = "); kryptos_print_mp(exp_lo);*/ + CUTE_ASSERT(kryptos_mp_eq(hi, exp_hi) == 1); + CUTE_ASSERT(kryptos_mp_eq(lo, exp_lo) == 1); + kryptos_del_mp_value(number); + number = NULL; + kryptos_del_mp_value(src); + src = NULL; + kryptos_del_mp_value(hi); + hi = NULL; + kryptos_del_mp_value(lo); + lo = NULL; + kryptos_del_mp_value(exp_hi); + kryptos_del_mp_value(exp_lo); + test++; + } +CUTE_TEST_CASE_END + CUTE_TEST_CASE(kryptos_mp_mul_tests) kryptos_mp_value_t *a, *b, *e; struct mul_tests_ctx { @@ -1229,7 +1315,74 @@ CUTE_TEST_CASE(kryptos_mp_mul_tests) { "FFFFFFFF", "FFFFFFFF", "FFFFFFFE00000001" }, { "DEADBEEF", "DEAD", "C1B126FD4983" }, { "DEADBEEFDEADBEEF", "DEADBEEF", "C1B1CD12E31F7033216DA321" }, - { "FD02FF", "FF", "FC05FC01" } + { "FD02FF", "FF", "FC05FC01" }, + { "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF", + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF" + "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF", + "C1B1CD13A4D13D4787F0AD7B6B101DAF4E2F8DE3314EFE17146E6E4A" + "F78DDE7EDAAD4EB2BDCCBEE6A0EC2F1A840B9F4E672B0F824A4A7FB6" + "2D69EFEA1089601DF3A8D051D6C84085B9E7B0B99D0720ED80269121" + "63460155466571892984E1BD0CA451F0EFC3C224D2E33258B602A28C" + "992212C07C4182F45F60F3284280635C259FD39008BF43C3EBDEB3F7" + "CEFE242BB21D945F953D0493785C74C75B7BE4FB3E9B552F21BAC563" + "04DA3596E7F9A5CACB1915FEAE3886329157F6667477669A5796D6CC" + "B752ACDAD4333CA6F113CC730DF45C3F2AD4EC0B47B57BD764960BA3" + "81769B6F9E572B3BBB37BB07D8184AD3F4F8DAA011D96A6C2EB9FA38" + "4B9A8A04687B19D0855BA99CA23C3968BF1CC934DBFD5900F8DDE8CD" + "15BE7899329F08654F7F98316C6027FD8940B7C9A6214795C301D761" + "DFE2672DFCC2F6FA19A386C6368416925364A65E7045362A8D25C5F6" + "AA0655C2C6E6E58EE3C7755B00A805271D8894F33A6924BF5749B48B" + "742A4457910AD423ADEB63EFCACBF3BBE7AC8388048D1354216DA321" }, + { "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEAD", + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEAD" + "DEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEFBEEFDEADDEADBEEF" + "BEEFDEAD", + "C1B1CD136D98D65AA6091C772FE82D9D8A606BDAF23784E06EB7BB3E" + "B486DC23530F0AA276D6336637665A0639258AA91BBDA969FB74E1EC" + "0014F8CDBDC4392EE46C483180139071C8C397954262E7B4AD1AE6F9" + "04B23EF79172365CC701963A75C985C08950ED7D5A20D5244BA044C0" + "3E7824880DEF9C0322CF73EBD03EF3460726C34F928E4A88EB7E12B3" + "54DDA1CBCFD56217172CF90EB42CB17AD97C5051988400DE9BCBA794" + "7CDB50425E1AFED761329FA6206A561A4589EF09E2B9AD5D29E13E6D" + "A50904A00E388DD167585BE2F28FDD3529A7B325D6E72C98EBF70A68" + "BB3E7BFCAE4661AB9F95CB607095B8EE83ED1AC432E5103168446A27" + "F5346772C9381F64DC521201E4E0D0011A02BABF0089809D57B3637C" + "1C32313995640C3937DAE1D5D314B4F65383927210C55DB36F2C430E" + "4E7606708AD4F3AA8C26AF2DA67DA446C9D757EAC22654E3078800A7" + "DDCF057F4538A964F977B61B82E95222152066B7C099FADF30C91753" + "FE4AA39C4C71C7F03BFB4C59681A788C79ABF51683C32928B75C9DD3" + "9F6BD9C4F50D4690BB148A6132BDEF4DD6BD3AFD706E980AF265EB99" + "AE1F40C80E0E9C35EBCFE98529B74CD229809242455FFD6E67313AFF" + "6108AE0AA4E1E3BC7CB15EA6E2928C79985A0F4320433536B402BFDF" + "5DF3DDF3CFAB707B9BA486B0EB542117D9552F6E06FCD1B41705D82B" + "22A5825054B680E9" }, }; size_t test_vector_nr = sizeof(test_vector) / sizeof(test_vector[0]), tv; @@ -1252,7 +1405,8 @@ CUTE_TEST_CASE(kryptos_mp_mul_tests) a = kryptos_mp_mul(&a, b); CUTE_ASSERT(a != NULL); - + //printf("a = ");kryptos_print_mp(a); + //printf("e = ");kryptos_print_mp(e); CUTE_ASSERT(kryptos_mp_eq(a, e) == 1); kryptos_del_mp_value(a); diff --git a/src/tests/mp_tests.h b/src/tests/mp_tests.h index 404d09c8..c75134b3 100644 --- a/src/tests/mp_tests.h +++ b/src/tests/mp_tests.h @@ -40,6 +40,8 @@ CUTE_DECLARE_TEST_CASE(kryptos_mp_add_tests); CUTE_DECLARE_TEST_CASE(kryptos_mp_sub_tests); +CUTE_DECLARE_TEST_CASE(kryptos_mp_split_tests); + CUTE_DECLARE_TEST_CASE(kryptos_mp_mul_tests); CUTE_DECLARE_TEST_CASE(kryptos_mp_not_tests);