fuzz_early_setup: 23| 2|void fuzz_early_setup(void) { 24| | /* Set stderr to point to normal stderr by default */ 25| | fuzz.fake_stderr = stderr; 26| 2|} fuzz_common_setup: 28| 1|void fuzz_common_setup(void) { 29| 1| disallow_core(); 30| 1| fuzz.fuzzing = 1; 31| 1| fuzz.wrapfds = 1; 32| 1| fuzz.do_jmp = 1; 33| 1| fuzz.input = m_malloc(sizeof(buffer)); 34| 1| _dropbear_log = fuzz_dropbear_log; 35| 1| crypto_init(); 36| 1| fuzz_seed("start", 5); 37| | /* let any messages get flushed */ 38| 1| setlinebuf(stdout); 39| |#if DEBUG_TRACE 40| | if (debug_trace) 41| | { 42| | fprintf(stderr, "Dropbear fuzzer: -v specified, not disabling stderr output\n"); 43| | } 44| | else 45| |#endif 46| 1| if (getenv("DROPBEAR_KEEP_STDERR")) { ------------------ | Branch (46:9): [True: 0, False: 1] ------------------ 47| 0| fprintf(stderr, "Dropbear fuzzer: DROPBEAR_KEEP_STDERR, not disabling stderr output\n"); 48| 0| } 49| 1| else 50| 1| { 51| 1| fprintf(stderr, "Dropbear fuzzer: Disabling stderr output\n"); 52| 1| fuzz.fake_stderr = fopen("/dev/null", "w"); 53| | assert(fuzz.fake_stderr); ------------------ | Branch (53:9): [True: 0, False: 1] | Branch (53:9): [True: 1, False: 0] ------------------ 54| 1| } 55| 1|} fuzz_set_input: 57| 2.91k|int fuzz_set_input(const uint8_t *Data, size_t Size) { 58| | 59| 2.91k| fuzz.input->data = (unsigned char*)Data; 60| 2.91k| fuzz.input->size = Size; 61| 2.91k| fuzz.input->len = Size; 62| 2.91k| fuzz.input->pos = 0; 63| | 64| 2.91k| memset(&ses, 0x0, sizeof(ses)); 65| 2.91k| memset(&svr_ses, 0x0, sizeof(svr_ses)); 66| 2.91k| memset(&cli_ses, 0x0, sizeof(cli_ses)); 67| 2.91k| wrapfd_setup(fuzz.input); 68| | // printhex("input", fuzz.input->data, fuzz.input->len); 69| | 70| 2.91k| fuzz_seed(fuzz.input->data, MIN(fuzz.input->len, 16)); ------------------ | Branch (70:33): [True: 235, False: 2.68k] ------------------ 71| | 72| 2.91k| return DROPBEAR_SUCCESS; ------------------ | | 111| 2.91k|#define DROPBEAR_SUCCESS 0 ------------------ 73| 2.91k|} fuzz-common.c:fuzz_dropbear_log: 84| 690|static void fuzz_dropbear_log(int UNUSED(priority), const char* UNUSED(format), va_list UNUSED(param)) { 85| | /* No print */ 86| 690|} wrapfd_setup: 32| 2.91k|void wrapfd_setup(buffer *buf) { 33| 2.91k| TRACE(("wrapfd_setup")) 34| | 35| | // clean old ones 36| 2.91k| int i; 37| 2.91k| for (i = 0; i <= wrapfd_maxfd; i++) { ------------------ | Branch (37:14): [True: 0, False: 2.91k] ------------------ 38| 0| if (wrap_fds[i].mode != UNUSED) { ------------------ | Branch (38:7): [True: 0, False: 0] ------------------ 39| 0| wrapfd_remove(i); 40| 0| } 41| 0| } 42| 2.91k| wrapfd_maxfd = -1; 43| | 44| 2.91k| memset(rand_state, 0x0, sizeof(rand_state)); 45| 2.91k| wrapfd_setseed(50); 46| 2.91k| input_buf = buf; 47| 2.91k|} wrapfd_setseed: 49| 2.91k|void wrapfd_setseed(uint32_t seed) { 50| 2.91k| memcpy(rand_state, &seed, sizeof(seed)); 51| 2.91k| nrand48(rand_state); 52| 2.91k|} LLVMFuzzerTestOneInput: 15| 2.91k|int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { 16| 2.91k| static int once = 0; 17| 2.91k| if (!once) { ------------------ | Branch (17:6): [True: 1, False: 2.91k] ------------------ 18| 1| setup_fuzzer(); 19| 1| verifydata = buf_new(30); 20| 1| buf_putstring(verifydata, "x", 1); 21| 1| once = 1; 22| 1| } 23| | 24| 2.91k| if (fuzz_set_input(Data, Size) == DROPBEAR_FAILURE) { ------------------ | | 112| 2.91k|#define DROPBEAR_FAILURE -1 ------------------ | Branch (24:6): [True: 0, False: 2.91k] ------------------ 25| 0| return 0; 26| 0| } 27| | 28| 2.91k| m_malloc_set_epoch(1); 29| | 30| 2.91k| if (setjmp(fuzz.jmp) == 0) { ------------------ | Branch (30:6): [True: 2.91k, False: 0] ------------------ 31| 2.91k| sign_key *key = new_sign_key(); 32| 2.91k| enum signkey_type keytype = DROPBEAR_SIGNKEY_ANY; 33| 2.91k| if (buf_get_pub_key(fuzz.input, key, &keytype) == DROPBEAR_SUCCESS) { ------------------ | | 111| 2.91k|#define DROPBEAR_SUCCESS 0 ------------------ | Branch (33:7): [True: 1.77k, False: 1.14k] ------------------ 34| 1.77k| enum signature_type sigtype; 35| 1.77k| if (keytype == DROPBEAR_SIGNKEY_RSA) { ------------------ | Branch (35:8): [True: 930, False: 847] ------------------ 36| | /* Flip a coin to decide rsa signature type */ 37| 930| int flag = buf_getbyte(fuzz.input); 38| 930| if (flag & 0x01) { ------------------ | Branch (38:9): [True: 16, False: 914] ------------------ 39| 16| sigtype = DROPBEAR_SIGNATURE_RSA_SHA256; 40| 914| } else { 41| 914| sigtype = DROPBEAR_SIGNATURE_RSA_SHA1; 42| 914| } 43| 930| } else { 44| 847| sigtype = signature_type_from_signkey(keytype); 45| 847| } 46| 1.77k| if (buf_verify(fuzz.input, key, sigtype, verifydata) == DROPBEAR_SUCCESS) { ------------------ | | 111| 1.77k|#define DROPBEAR_SUCCESS 0 ------------------ | Branch (46:8): [True: 121, False: 1.65k] ------------------ 47| | /* The fuzzer is capable of generating keys with a signature to match. 48| | We don't want false positives if the key is bogus, since a client/server 49| | wouldn't be trusting a bogus key anyway */ 50| 121| int boguskey = 0; 51| | 52| 121| if (keytype == DROPBEAR_SIGNKEY_DSS) { ------------------ | Branch (52:9): [True: 119, False: 2] ------------------ 53| | /* So far have seen dss keys with bad p/q/g domain parameters */ 54| 119| int pprime, qprime, trials; 55| 119| trials = mp_prime_rabin_miller_trials(mp_count_bits(key->dsskey->p)); 56| 119| assert(mp_prime_is_prime(key->dsskey->p, trials, &pprime) == MP_OKAY); ------------------ | Branch (56:6): [True: 0, False: 119] | Branch (56:6): [True: 119, False: 0] ------------------ 57| 119| trials = mp_prime_rabin_miller_trials(mp_count_bits(key->dsskey->q)); 58| 119| assert(mp_prime_is_prime(key->dsskey->q, trials, &qprime) == MP_OKAY); ------------------ | Branch (58:6): [True: 0, False: 119] | Branch (58:6): [True: 119, False: 0] ------------------ 59| 119| boguskey = !(pprime && qprime); ------------------ | Branch (59:19): [True: 0, False: 119] | Branch (59:29): [True: 0, False: 0] ------------------ 60| | /* Could also check g**q mod p == 1 */ 61| 119| } 62| | 63| 121| if (keytype == DROPBEAR_SIGNKEY_SK_ED25519 || keytype == DROPBEAR_SIGNKEY_ED25519) { ------------------ | Branch (63:9): [True: 2, False: 119] | Branch (63:51): [True: 0, False: 119] ------------------ 64| 2| dropbear_ed25519_key **eck = (dropbear_ed25519_key**)signkey_key_ptr(key, keytype); 65| 2| if (eck && *eck) { ------------------ | Branch (65:10): [True: 2, False: 0] | Branch (65:17): [True: 2, False: 0] ------------------ 66| 2| int i; 67| | /* we've seen all-zero keys validate */ 68| 2| boguskey = 1; 69| 66| for (i = 0; i < CURVE25519_LEN; i++) { ------------------ | | 34| 66|#define CURVE25519_LEN 32 ------------------ | Branch (69:19): [True: 64, False: 2] ------------------ 70| 64| if ((*eck)->priv[i] != 0x00 || (*eck)->pub[i] != 0x00) { ------------------ | Branch (70:12): [True: 0, False: 64] | Branch (70:39): [True: 0, False: 64] ------------------ 71| 0| boguskey = 0; 72| 0| } 73| 64| } 74| | 75| 2| } 76| 2| } 77| | 78| 121| if (!boguskey) { ------------------ | Branch (78:9): [True: 0, False: 121] ------------------ 79| 0| printf("Random key/signature managed to verify!\n"); 80| 0| abort(); 81| 0| } 82| | 83| | 84| 121| } 85| 1.77k| } 86| 2.91k| sign_key_free(key); 87| 2.91k| m_malloc_free_epoch(1, 0); 88| 2.91k| } else { 89| 0| m_malloc_free_epoch(1, 1); 90| 0| TRACE(("dropbear_exit longjmped")) 91| | /* dropbear_exit jumped here */ 92| 0| } 93| | 94| 2.91k| return 0; 95| 2.91k|} fuzzer-verify.c:setup_fuzzer: 8| 1|static void setup_fuzzer(void) { 9| 1| fuzz_common_setup(); 10| 1|} sha1_init: 164| 1.02k|{ 165| 1.02k| LTC_ARGCHK(md != NULL); ------------------ | | 32| 1.02k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.02k] | | | Branch (32:87): [Folded, False: 1.02k] | | ------------------ ------------------ 166| 1.02k| md->sha1.state[0] = 0x67452301UL; 167| 1.02k| md->sha1.state[1] = 0xefcdab89UL; 168| 1.02k| md->sha1.state[2] = 0x98badcfeUL; 169| 1.02k| md->sha1.state[3] = 0x10325476UL; 170| 1.02k| md->sha1.state[4] = 0xc3d2e1f0UL; 171| 1.02k| md->sha1.curlen = 0; 172| 1.02k| md->sha1.length = 0; 173| 1.02k| return CRYPT_OK; 174| 1.02k|} sha1_done: 192| 1.02k|{ 193| 1.02k| int i; 194| | 195| 1.02k| LTC_ARGCHK(md != NULL); ------------------ | | 32| 1.02k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.02k] | | | Branch (32:87): [Folded, False: 1.02k] | | ------------------ ------------------ 196| 1.02k| LTC_ARGCHK(out != NULL); ------------------ | | 32| 1.02k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.02k] | | | Branch (32:87): [Folded, False: 1.02k] | | ------------------ ------------------ 197| | 198| 1.02k| if (md->sha1.curlen >= sizeof(md->sha1.buf)) { ------------------ | Branch (198:9): [True: 0, False: 1.02k] ------------------ 199| 0| return CRYPT_INVALID_ARG; 200| 0| } 201| | 202| | /* increase the length of the message */ 203| 1.02k| md->sha1.length += md->sha1.curlen * 8; 204| | 205| | /* append the '1' bit */ 206| 1.02k| md->sha1.buf[md->sha1.curlen++] = (unsigned char)0x80; 207| | 208| | /* if the length is currently above 56 bytes we append zeros 209| | * then compress. Then we can fall back to padding zeros and length 210| | * encoding like normal. 211| | */ 212| 1.02k| if (md->sha1.curlen > 56) { ------------------ | Branch (212:9): [True: 0, False: 1.02k] ------------------ 213| 0| while (md->sha1.curlen < 64) { ------------------ | Branch (213:16): [True: 0, False: 0] ------------------ 214| 0| md->sha1.buf[md->sha1.curlen++] = (unsigned char)0; 215| 0| } 216| 0| sha1_compress(md, md->sha1.buf); 217| 0| md->sha1.curlen = 0; 218| 0| } 219| | 220| | /* pad upto 56 bytes of zeroes */ 221| 52.2k| while (md->sha1.curlen < 56) { ------------------ | Branch (221:12): [True: 51.2k, False: 1.02k] ------------------ 222| 51.2k| md->sha1.buf[md->sha1.curlen++] = (unsigned char)0; 223| 51.2k| } 224| | 225| | /* store length */ 226| 1.02k| STORE64H(md->sha1.length, md->sha1.buf+56); ------------------ | | 101| 1.02k|#define STORE64H(x, y) \ | | 102| 1.02k|do { ulong64 __t = __builtin_bswap64 ((x)); \ | | 103| 1.02k| XMEMCPY ((y), &__t, 8); } while(0) | | ------------------ | | | | 39| 1.02k|#define XMEMCPY memcpy | | ------------------ | | | Branch (103:39): [Folded, False: 1.02k] | | ------------------ ------------------ 227| 1.02k| sha1_compress(md, md->sha1.buf); 228| | 229| | /* copy output */ 230| 6.14k| for (i = 0; i < 5; i++) { ------------------ | Branch (230:17): [True: 5.12k, False: 1.02k] ------------------ 231| 5.12k| STORE32H(md->sha1.state[i], out+(4*i)); ------------------ | | 62| 5.12k|#define STORE32H(x, y) \ | | 63| 5.12k|do { ulong32 __t = __builtin_bswap32 ((x)); \ | | 64| 5.12k| XMEMCPY ((y), &__t, 4); } while(0) | | ------------------ | | | | 39| 5.12k|#define XMEMCPY memcpy | | ------------------ | | | Branch (64:39): [Folded, False: 5.12k] | | ------------------ ------------------ 232| 5.12k| } 233| |#ifdef LTC_CLEAN_STACK 234| | zeromem(md, sizeof(hash_state)); 235| |#endif 236| 1.02k| return CRYPT_OK; 237| 1.02k|} sha1.c:sha1_compress: 47| 1.02k|{ 48| 1.02k| ulong32 a,b,c,d,e,W[80],i; 49| 1.02k|#ifdef LTC_SMALL_CODE 50| 1.02k| ulong32 t; 51| 1.02k|#endif 52| | 53| | /* copy the state into 512-bits into W[0..15] */ 54| 17.4k| for (i = 0; i < 16; i++) { ------------------ | Branch (54:17): [True: 16.3k, False: 1.02k] ------------------ 55| 16.3k| LOAD32H(W[i], buf + (4*i)); ------------------ | | 66| 16.3k|#define LOAD32H(x, y) \ | | 67| 16.3k|do { XMEMCPY (&(x), (y), 4); \ | | ------------------ | | | | 39| 16.3k|#define XMEMCPY memcpy | | ------------------ | | 68| 16.3k| (x) = __builtin_bswap32 ((x)); } while(0) | | ------------------ | | | Branch (68:46): [Folded, False: 16.3k] | | ------------------ ------------------ 56| 16.3k| } 57| | 58| | /* copy state */ 59| 1.02k| a = md->sha1.state[0]; 60| 1.02k| b = md->sha1.state[1]; 61| 1.02k| c = md->sha1.state[2]; 62| 1.02k| d = md->sha1.state[3]; 63| 1.02k| e = md->sha1.state[4]; 64| | 65| | /* expand it */ 66| 66.5k| for (i = 16; i < 80; i++) { ------------------ | Branch (66:18): [True: 65.5k, False: 1.02k] ------------------ 67| 65.5k| W[i] = ROL(W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16], 1); 68| 65.5k| } 69| | 70| | /* compress */ 71| | /* round one */ 72| 1.02k| #define FF0(a,b,c,d,e,i) e = (ROLc(a, 5) + F0(b,c,d) + e + W[i] + 0x5a827999UL); b = ROLc(b, 30); 73| 1.02k| #define FF1(a,b,c,d,e,i) e = (ROLc(a, 5) + F1(b,c,d) + e + W[i] + 0x6ed9eba1UL); b = ROLc(b, 30); 74| 1.02k| #define FF2(a,b,c,d,e,i) e = (ROLc(a, 5) + F2(b,c,d) + e + W[i] + 0x8f1bbcdcUL); b = ROLc(b, 30); 75| 1.02k| #define FF3(a,b,c,d,e,i) e = (ROLc(a, 5) + F3(b,c,d) + e + W[i] + 0xca62c1d6UL); b = ROLc(b, 30); 76| | 77| 1.02k|#ifdef LTC_SMALL_CODE 78| | 79| 21.5k| for (i = 0; i < 20; ) { ------------------ | Branch (79:17): [True: 20.4k, False: 1.02k] ------------------ 80| 20.4k| FF0(a,b,c,d,e,i++); t = e; e = d; d = c; c = b; b = a; a = t; ------------------ | | 72| 20.4k| #define FF0(a,b,c,d,e,i) e = (ROLc(a, 5) + F0(b,c,d) + e + W[i] + 0x5a827999UL); b = ROLc(b, 30); | | ------------------ | | | | 275| 20.4k|#define ROLc(word,i) ({ \ | | | | 276| 20.4k| ulong32 __ROLc_tmp = (word); \ | | | | 277| 20.4k| __asm__ ("roll %2, %0" : \ | | | | 278| 20.4k| "=r" (__ROLc_tmp) : \ | | | | 279| 20.4k| "0" (__ROLc_tmp), \ | | | | 280| 20.4k| "I" (i)); \ | | | | 281| 20.4k| __ROLc_tmp; \ | | | | 282| 20.4k| }) | | ------------------ | | #define FF0(a,b,c,d,e,i) e = (ROLc(a, 5) + F0(b,c,d) + e + W[i] + 0x5a827999UL); b = ROLc(b, 30); | | ------------------ | | | | 37| 20.4k|#define F0(x,y,z) (z ^ (x & (y ^ z))) | | ------------------ | | #define FF0(a,b,c,d,e,i) e = (ROLc(a, 5) + F0(b,c,d) + e + W[i] + 0x5a827999UL); b = ROLc(b, 30); | | ------------------ | | | | 275| 20.4k|#define ROLc(word,i) ({ \ | | | | 276| 20.4k| ulong32 __ROLc_tmp = (word); \ | | | | 277| 20.4k| __asm__ ("roll %2, %0" : \ | | | | 278| 20.4k| "=r" (__ROLc_tmp) : \ | | | | 279| 20.4k| "0" (__ROLc_tmp), \ | | | | 280| 20.4k| "I" (i)); \ | | | | 281| 20.4k| __ROLc_tmp; \ | | | | 282| 20.4k| }) | | ------------------ ------------------ 81| 20.4k| } 82| | 83| 21.5k| for (; i < 40; ) { ------------------ | Branch (83:12): [True: 20.4k, False: 1.02k] ------------------ 84| 20.4k| FF1(a,b,c,d,e,i++); t = e; e = d; d = c; c = b; b = a; a = t; ------------------ | | 73| 20.4k| #define FF1(a,b,c,d,e,i) e = (ROLc(a, 5) + F1(b,c,d) + e + W[i] + 0x6ed9eba1UL); b = ROLc(b, 30); | | ------------------ | | | | 275| 20.4k|#define ROLc(word,i) ({ \ | | | | 276| 20.4k| ulong32 __ROLc_tmp = (word); \ | | | | 277| 20.4k| __asm__ ("roll %2, %0" : \ | | | | 278| 20.4k| "=r" (__ROLc_tmp) : \ | | | | 279| 20.4k| "0" (__ROLc_tmp), \ | | | | 280| 20.4k| "I" (i)); \ | | | | 281| 20.4k| __ROLc_tmp; \ | | | | 282| 20.4k| }) | | ------------------ | | #define FF1(a,b,c,d,e,i) e = (ROLc(a, 5) + F1(b,c,d) + e + W[i] + 0x6ed9eba1UL); b = ROLc(b, 30); | | ------------------ | | | | 38| 20.4k|#define F1(x,y,z) (x ^ y ^ z) | | ------------------ | | #define FF1(a,b,c,d,e,i) e = (ROLc(a, 5) + F1(b,c,d) + e + W[i] + 0x6ed9eba1UL); b = ROLc(b, 30); | | ------------------ | | | | 275| 20.4k|#define ROLc(word,i) ({ \ | | | | 276| 20.4k| ulong32 __ROLc_tmp = (word); \ | | | | 277| 20.4k| __asm__ ("roll %2, %0" : \ | | | | 278| 20.4k| "=r" (__ROLc_tmp) : \ | | | | 279| 20.4k| "0" (__ROLc_tmp), \ | | | | 280| 20.4k| "I" (i)); \ | | | | 281| 20.4k| __ROLc_tmp; \ | | | | 282| 20.4k| }) | | ------------------ ------------------ 85| 20.4k| } 86| | 87| 21.5k| for (; i < 60; ) { ------------------ | Branch (87:12): [True: 20.4k, False: 1.02k] ------------------ 88| 20.4k| FF2(a,b,c,d,e,i++); t = e; e = d; d = c; c = b; b = a; a = t; ------------------ | | 74| 20.4k| #define FF2(a,b,c,d,e,i) e = (ROLc(a, 5) + F2(b,c,d) + e + W[i] + 0x8f1bbcdcUL); b = ROLc(b, 30); | | ------------------ | | | | 275| 20.4k|#define ROLc(word,i) ({ \ | | | | 276| 20.4k| ulong32 __ROLc_tmp = (word); \ | | | | 277| 20.4k| __asm__ ("roll %2, %0" : \ | | | | 278| 20.4k| "=r" (__ROLc_tmp) : \ | | | | 279| 20.4k| "0" (__ROLc_tmp), \ | | | | 280| 20.4k| "I" (i)); \ | | | | 281| 20.4k| __ROLc_tmp; \ | | | | 282| 20.4k| }) | | ------------------ | | #define FF2(a,b,c,d,e,i) e = (ROLc(a, 5) + F2(b,c,d) + e + W[i] + 0x8f1bbcdcUL); b = ROLc(b, 30); | | ------------------ | | | | 39| 20.4k|#define F2(x,y,z) ((x & y) | (z & (x | y))) | | ------------------ | | #define FF2(a,b,c,d,e,i) e = (ROLc(a, 5) + F2(b,c,d) + e + W[i] + 0x8f1bbcdcUL); b = ROLc(b, 30); | | ------------------ | | | | 275| 20.4k|#define ROLc(word,i) ({ \ | | | | 276| 20.4k| ulong32 __ROLc_tmp = (word); \ | | | | 277| 20.4k| __asm__ ("roll %2, %0" : \ | | | | 278| 20.4k| "=r" (__ROLc_tmp) : \ | | | | 279| 20.4k| "0" (__ROLc_tmp), \ | | | | 280| 20.4k| "I" (i)); \ | | | | 281| 20.4k| __ROLc_tmp; \ | | | | 282| 20.4k| }) | | ------------------ ------------------ 89| 20.4k| } 90| | 91| 21.5k| for (; i < 80; ) { ------------------ | Branch (91:12): [True: 20.4k, False: 1.02k] ------------------ 92| 20.4k| FF3(a,b,c,d,e,i++); t = e; e = d; d = c; c = b; b = a; a = t; ------------------ | | 75| 20.4k| #define FF3(a,b,c,d,e,i) e = (ROLc(a, 5) + F3(b,c,d) + e + W[i] + 0xca62c1d6UL); b = ROLc(b, 30); | | ------------------ | | | | 275| 20.4k|#define ROLc(word,i) ({ \ | | | | 276| 20.4k| ulong32 __ROLc_tmp = (word); \ | | | | 277| 20.4k| __asm__ ("roll %2, %0" : \ | | | | 278| 20.4k| "=r" (__ROLc_tmp) : \ | | | | 279| 20.4k| "0" (__ROLc_tmp), \ | | | | 280| 20.4k| "I" (i)); \ | | | | 281| 20.4k| __ROLc_tmp; \ | | | | 282| 20.4k| }) | | ------------------ | | #define FF3(a,b,c,d,e,i) e = (ROLc(a, 5) + F3(b,c,d) + e + W[i] + 0xca62c1d6UL); b = ROLc(b, 30); | | ------------------ | | | | 40| 20.4k|#define F3(x,y,z) (x ^ y ^ z) | | ------------------ | | #define FF3(a,b,c,d,e,i) e = (ROLc(a, 5) + F3(b,c,d) + e + W[i] + 0xca62c1d6UL); b = ROLc(b, 30); | | ------------------ | | | | 275| 20.4k|#define ROLc(word,i) ({ \ | | | | 276| 20.4k| ulong32 __ROLc_tmp = (word); \ | | | | 277| 20.4k| __asm__ ("roll %2, %0" : \ | | | | 278| 20.4k| "=r" (__ROLc_tmp) : \ | | | | 279| 20.4k| "0" (__ROLc_tmp), \ | | | | 280| 20.4k| "I" (i)); \ | | | | 281| 20.4k| __ROLc_tmp; \ | | | | 282| 20.4k| }) | | ------------------ ------------------ 93| 20.4k| } 94| | 95| |#else 96| | 97| | for (i = 0; i < 20; ) { 98| | FF0(a,b,c,d,e,i++); 99| | FF0(e,a,b,c,d,i++); 100| | FF0(d,e,a,b,c,i++); 101| | FF0(c,d,e,a,b,i++); 102| | FF0(b,c,d,e,a,i++); 103| | } 104| | 105| | /* round two */ 106| | for (; i < 40; ) { 107| | FF1(a,b,c,d,e,i++); 108| | FF1(e,a,b,c,d,i++); 109| | FF1(d,e,a,b,c,i++); 110| | FF1(c,d,e,a,b,i++); 111| | FF1(b,c,d,e,a,i++); 112| | } 113| | 114| | /* round three */ 115| | for (; i < 60; ) { 116| | FF2(a,b,c,d,e,i++); 117| | FF2(e,a,b,c,d,i++); 118| | FF2(d,e,a,b,c,i++); 119| | FF2(c,d,e,a,b,i++); 120| | FF2(b,c,d,e,a,i++); 121| | } 122| | 123| | /* round four */ 124| | for (; i < 80; ) { 125| | FF3(a,b,c,d,e,i++); 126| | FF3(e,a,b,c,d,i++); 127| | FF3(d,e,a,b,c,i++); 128| | FF3(c,d,e,a,b,i++); 129| | FF3(b,c,d,e,a,i++); 130| | } 131| |#endif 132| | 133| 1.02k| #undef FF0 134| 1.02k| #undef FF1 135| 1.02k| #undef FF2 136| 1.02k| #undef FF3 137| | 138| | /* store */ 139| 1.02k| md->sha1.state[0] = md->sha1.state[0] + a; 140| 1.02k| md->sha1.state[1] = md->sha1.state[1] + b; 141| 1.02k| md->sha1.state[2] = md->sha1.state[2] + c; 142| 1.02k| md->sha1.state[3] = md->sha1.state[3] + d; 143| 1.02k| md->sha1.state[4] = md->sha1.state[4] + e; 144| | 145| 1.02k| return CRYPT_OK; 146| 1.02k|} sha256_init: 205| 7.08k|{ 206| 7.08k| LTC_ARGCHK(md != NULL); ------------------ | | 32| 7.08k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 7.08k] | | | Branch (32:87): [Folded, False: 7.08k] | | ------------------ ------------------ 207| | 208| 7.08k| md->sha256.curlen = 0; 209| 7.08k| md->sha256.length = 0; 210| 7.08k| md->sha256.state[0] = 0x6A09E667UL; 211| 7.08k| md->sha256.state[1] = 0xBB67AE85UL; 212| 7.08k| md->sha256.state[2] = 0x3C6EF372UL; 213| 7.08k| md->sha256.state[3] = 0xA54FF53AUL; 214| 7.08k| md->sha256.state[4] = 0x510E527FUL; 215| 7.08k| md->sha256.state[5] = 0x9B05688CUL; 216| 7.08k| md->sha256.state[6] = 0x1F83D9ABUL; 217| 7.08k| md->sha256.state[7] = 0x5BE0CD19UL; 218| 7.08k| return CRYPT_OK; 219| 7.08k|} sha256_done: 237| 7.08k|{ 238| 7.08k| int i; 239| | 240| 7.08k| LTC_ARGCHK(md != NULL); ------------------ | | 32| 7.08k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 7.08k] | | | Branch (32:87): [Folded, False: 7.08k] | | ------------------ ------------------ 241| 7.08k| LTC_ARGCHK(out != NULL); ------------------ | | 32| 7.08k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 7.08k] | | | Branch (32:87): [Folded, False: 7.08k] | | ------------------ ------------------ 242| | 243| 7.08k| if (md->sha256.curlen >= sizeof(md->sha256.buf)) { ------------------ | Branch (243:9): [True: 0, False: 7.08k] ------------------ 244| 0| return CRYPT_INVALID_ARG; 245| 0| } 246| | 247| | 248| | /* increase the length of the message */ 249| 7.08k| md->sha256.length += md->sha256.curlen * 8; 250| | 251| | /* append the '1' bit */ 252| 7.08k| md->sha256.buf[md->sha256.curlen++] = (unsigned char)0x80; 253| | 254| | /* if the length is currently above 56 bytes we append zeros 255| | * then compress. Then we can fall back to padding zeros and length 256| | * encoding like normal. 257| | */ 258| 7.08k| if (md->sha256.curlen > 56) { ------------------ | Branch (258:9): [True: 20, False: 7.06k] ------------------ 259| 87| while (md->sha256.curlen < 64) { ------------------ | Branch (259:16): [True: 67, False: 20] ------------------ 260| 67| md->sha256.buf[md->sha256.curlen++] = (unsigned char)0; 261| 67| } 262| 20| sha256_compress(md, md->sha256.buf); 263| 20| md->sha256.curlen = 0; 264| 20| } 265| | 266| | /* pad upto 56 bytes of zeroes */ 267| 175k| while (md->sha256.curlen < 56) { ------------------ | Branch (267:12): [True: 168k, False: 7.08k] ------------------ 268| 168k| md->sha256.buf[md->sha256.curlen++] = (unsigned char)0; 269| 168k| } 270| | 271| | /* store length */ 272| 7.08k| STORE64H(md->sha256.length, md->sha256.buf+56); ------------------ | | 101| 7.08k|#define STORE64H(x, y) \ | | 102| 7.08k|do { ulong64 __t = __builtin_bswap64 ((x)); \ | | 103| 7.08k| XMEMCPY ((y), &__t, 8); } while(0) | | ------------------ | | | | 39| 7.08k|#define XMEMCPY memcpy | | ------------------ | | | Branch (103:39): [Folded, False: 7.08k] | | ------------------ ------------------ 273| 7.08k| sha256_compress(md, md->sha256.buf); 274| | 275| | /* copy output */ 276| 63.7k| for (i = 0; i < 8; i++) { ------------------ | Branch (276:17): [True: 56.6k, False: 7.08k] ------------------ 277| 56.6k| STORE32H(md->sha256.state[i], out+(4*i)); ------------------ | | 62| 56.6k|#define STORE32H(x, y) \ | | 63| 56.6k|do { ulong32 __t = __builtin_bswap32 ((x)); \ | | 64| 56.6k| XMEMCPY ((y), &__t, 4); } while(0) | | ------------------ | | | | 39| 56.6k|#define XMEMCPY memcpy | | ------------------ | | | Branch (64:39): [Folded, False: 56.6k] | | ------------------ ------------------ 278| 56.6k| } 279| |#ifdef LTC_CLEAN_STACK 280| | zeromem(md, sizeof(hash_state)); 281| |#endif 282| 7.08k| return CRYPT_OK; 283| 7.08k|} sha256.c:sha256_compress: 71| 8.86k|{ 72| 8.86k| ulong32 S[8], W[64], t0, t1; 73| 8.86k|#ifdef LTC_SMALL_CODE 74| 8.86k| ulong32 t; 75| 8.86k|#endif 76| 8.86k| int i; 77| | 78| | /* copy state into S */ 79| 79.7k| for (i = 0; i < 8; i++) { ------------------ | Branch (79:17): [True: 70.8k, False: 8.86k] ------------------ 80| 70.8k| S[i] = md->sha256.state[i]; 81| 70.8k| } 82| | 83| | /* copy the state into 512-bits into W[0..15] */ 84| 150k| for (i = 0; i < 16; i++) { ------------------ | Branch (84:17): [True: 141k, False: 8.86k] ------------------ 85| 141k| LOAD32H(W[i], buf + (4*i)); ------------------ | | 66| 141k|#define LOAD32H(x, y) \ | | 67| 141k|do { XMEMCPY (&(x), (y), 4); \ | | ------------------ | | | | 39| 141k|#define XMEMCPY memcpy | | ------------------ | | 68| 141k| (x) = __builtin_bswap32 ((x)); } while(0) | | ------------------ | | | Branch (68:46): [Folded, False: 141k] | | ------------------ ------------------ 86| 141k| } 87| | 88| | /* fill W[16..63] */ 89| 434k| for (i = 16; i < 64; i++) { ------------------ | Branch (89:18): [True: 425k, False: 8.86k] ------------------ 90| 425k| W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]; ------------------ | | 63| 425k|#define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10)) | | ------------------ | | | | 58| 425k|#define S(x, n) RORc((x),(n)) | | | | ------------------ | | | | | | 283| 425k|#define RORc(word,i) ({ \ | | | | | | 284| 425k| ulong32 __RORc_tmp = (word); \ | | | | | | 285| 425k| __asm__ ("rorl %2, %0" : \ | | | | | | 286| 425k| "=r" (__RORc_tmp) : \ | | | | | | 287| 425k| "0" (__RORc_tmp), \ | | | | | | 288| 425k| "I" (i)); \ | | | | | | 289| 425k| __RORc_tmp; \ | | | | | | 290| 425k| }) | | | | ------------------ | | ------------------ | | #define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10)) | | ------------------ | | | | 58| 425k|#define S(x, n) RORc((x),(n)) | | | | ------------------ | | | | | | 283| 425k|#define RORc(word,i) ({ \ | | | | | | 284| 425k| ulong32 __RORc_tmp = (word); \ | | | | | | 285| 425k| __asm__ ("rorl %2, %0" : \ | | | | | | 286| 425k| "=r" (__RORc_tmp) : \ | | | | | | 287| 425k| "0" (__RORc_tmp), \ | | | | | | 288| 425k| "I" (i)); \ | | | | | | 289| 425k| __RORc_tmp; \ | | | | | | 290| 425k| }) | | | | ------------------ | | ------------------ | | #define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10)) | | ------------------ | | | | 59| 425k|#define R(x, n) (((x)&0xFFFFFFFFUL)>>(n)) | | ------------------ ------------------ W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]; ------------------ | | 62| 425k|#define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3)) | | ------------------ | | | | 58| 425k|#define S(x, n) RORc((x),(n)) | | | | ------------------ | | | | | | 283| 425k|#define RORc(word,i) ({ \ | | | | | | 284| 425k| ulong32 __RORc_tmp = (word); \ | | | | | | 285| 425k| __asm__ ("rorl %2, %0" : \ | | | | | | 286| 425k| "=r" (__RORc_tmp) : \ | | | | | | 287| 425k| "0" (__RORc_tmp), \ | | | | | | 288| 425k| "I" (i)); \ | | | | | | 289| 425k| __RORc_tmp; \ | | | | | | 290| 425k| }) | | | | ------------------ | | ------------------ | | #define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3)) | | ------------------ | | | | 58| 425k|#define S(x, n) RORc((x),(n)) | | | | ------------------ | | | | | | 283| 425k|#define RORc(word,i) ({ \ | | | | | | 284| 425k| ulong32 __RORc_tmp = (word); \ | | | | | | 285| 425k| __asm__ ("rorl %2, %0" : \ | | | | | | 286| 425k| "=r" (__RORc_tmp) : \ | | | | | | 287| 425k| "0" (__RORc_tmp), \ | | | | | | 288| 425k| "I" (i)); \ | | | | | | 289| 425k| __RORc_tmp; \ | | | | | | 290| 425k| }) | | | | ------------------ | | ------------------ | | #define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3)) | | ------------------ | | | | 59| 425k|#define R(x, n) (((x)&0xFFFFFFFFUL)>>(n)) | | ------------------ ------------------ 91| 425k| } 92| | 93| | /* Compress */ 94| 8.86k|#ifdef LTC_SMALL_CODE 95| 8.86k|#define RND(a,b,c,d,e,f,g,h,i) \ 96| 8.86k| t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \ 97| 8.86k| t1 = Sigma0(a) + Maj(a, b, c); \ 98| 8.86k| d += t0; \ 99| 8.86k| h = t0 + t1; 100| | 101| 575k| for (i = 0; i < 64; ++i) { ------------------ | Branch (101:18): [True: 567k, False: 8.86k] ------------------ 102| 567k| RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],i); ------------------ | | 96| 567k| t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \ | | ------------------ | | | | 61| 567k|#define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25)) | | | | ------------------ | | | | | | 58| 567k|#define S(x, n) RORc((x),(n)) | | | | | | ------------------ | | | | | | | | 283| 567k|#define RORc(word,i) ({ \ | | | | | | | | 284| 567k| ulong32 __RORc_tmp = (word); \ | | | | | | | | 285| 567k| __asm__ ("rorl %2, %0" : \ | | | | | | | | 286| 567k| "=r" (__RORc_tmp) : \ | | | | | | | | 287| 567k| "0" (__RORc_tmp), \ | | | | | | | | 288| 567k| "I" (i)); \ | | | | | | | | 289| 567k| __RORc_tmp; \ | | | | | | | | 290| 567k| }) | | | | | | ------------------ | | | | ------------------ | | | | #define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25)) | | | | ------------------ | | | | | | 58| 567k|#define S(x, n) RORc((x),(n)) | | | | | | ------------------ | | | | | | | | 283| 567k|#define RORc(word,i) ({ \ | | | | | | | | 284| 567k| ulong32 __RORc_tmp = (word); \ | | | | | | | | 285| 567k| __asm__ ("rorl %2, %0" : \ | | | | | | | | 286| 567k| "=r" (__RORc_tmp) : \ | | | | | | | | 287| 567k| "0" (__RORc_tmp), \ | | | | | | | | 288| 567k| "I" (i)); \ | | | | | | | | 289| 567k| __RORc_tmp; \ | | | | | | | | 290| 567k| }) | | | | | | ------------------ | | | | ------------------ | | | | #define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25)) | | | | ------------------ | | | | | | 58| 567k|#define S(x, n) RORc((x),(n)) | | | | | | ------------------ | | | | | | | | 283| 567k|#define RORc(word,i) ({ \ | | | | | | | | 284| 567k| ulong32 __RORc_tmp = (word); \ | | | | | | | | 285| 567k| __asm__ ("rorl %2, %0" : \ | | | | | | | | 286| 567k| "=r" (__RORc_tmp) : \ | | | | | | | | 287| 567k| "0" (__RORc_tmp), \ | | | | | | | | 288| 567k| "I" (i)); \ | | | | | | | | 289| 567k| __RORc_tmp; \ | | | | | | | | 290| 567k| }) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \ | | ------------------ | | | | 56| 567k|#define Ch(x,y,z) (z ^ (x & (y ^ z))) | | ------------------ | | 97| 567k| t1 = Sigma0(a) + Maj(a, b, c); \ | | ------------------ | | | | 60| 567k|#define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22)) | | | | ------------------ | | | | | | 58| 567k|#define S(x, n) RORc((x),(n)) | | | | | | ------------------ | | | | | | | | 283| 567k|#define RORc(word,i) ({ \ | | | | | | | | 284| 567k| ulong32 __RORc_tmp = (word); \ | | | | | | | | 285| 567k| __asm__ ("rorl %2, %0" : \ | | | | | | | | 286| 567k| "=r" (__RORc_tmp) : \ | | | | | | | | 287| 567k| "0" (__RORc_tmp), \ | | | | | | | | 288| 567k| "I" (i)); \ | | | | | | | | 289| 567k| __RORc_tmp; \ | | | | | | | | 290| 567k| }) | | | | | | ------------------ | | | | ------------------ | | | | #define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22)) | | | | ------------------ | | | | | | 58| 567k|#define S(x, n) RORc((x),(n)) | | | | | | ------------------ | | | | | | | | 283| 567k|#define RORc(word,i) ({ \ | | | | | | | | 284| 567k| ulong32 __RORc_tmp = (word); \ | | | | | | | | 285| 567k| __asm__ ("rorl %2, %0" : \ | | | | | | | | 286| 567k| "=r" (__RORc_tmp) : \ | | | | | | | | 287| 567k| "0" (__RORc_tmp), \ | | | | | | | | 288| 567k| "I" (i)); \ | | | | | | | | 289| 567k| __RORc_tmp; \ | | | | | | | | 290| 567k| }) | | | | | | ------------------ | | | | ------------------ | | | | #define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22)) | | | | ------------------ | | | | | | 58| 567k|#define S(x, n) RORc((x),(n)) | | | | | | ------------------ | | | | | | | | 283| 567k|#define RORc(word,i) ({ \ | | | | | | | | 284| 567k| ulong32 __RORc_tmp = (word); \ | | | | | | | | 285| 567k| __asm__ ("rorl %2, %0" : \ | | | | | | | | 286| 567k| "=r" (__RORc_tmp) : \ | | | | | | | | 287| 567k| "0" (__RORc_tmp), \ | | | | | | | | 288| 567k| "I" (i)); \ | | | | | | | | 289| 567k| __RORc_tmp; \ | | | | | | | | 290| 567k| }) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | t1 = Sigma0(a) + Maj(a, b, c); \ | | ------------------ | | | | 57| 567k|#define Maj(x,y,z) (((x | y) & z) | (x & y)) | | ------------------ | | 98| 567k| d += t0; \ | | 99| 567k| h = t0 + t1; ------------------ 103| 567k| t = S[7]; S[7] = S[6]; S[6] = S[5]; S[5] = S[4]; 104| 567k| S[4] = S[3]; S[3] = S[2]; S[2] = S[1]; S[1] = S[0]; S[0] = t; 105| 567k| } 106| |#else 107| |#define RND(a,b,c,d,e,f,g,h,i,ki) \ 108| | t0 = h + Sigma1(e) + Ch(e, f, g) + ki + W[i]; \ 109| | t1 = Sigma0(a) + Maj(a, b, c); \ 110| | d += t0; \ 111| | h = t0 + t1; 112| | 113| | RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],0,0x428a2f98); 114| | RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],1,0x71374491); 115| | RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],2,0xb5c0fbcf); 116| | RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],3,0xe9b5dba5); 117| | RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],4,0x3956c25b); 118| | RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],5,0x59f111f1); 119| | RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],6,0x923f82a4); 120| | RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],7,0xab1c5ed5); 121| | RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],8,0xd807aa98); 122| | RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],9,0x12835b01); 123| | RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],10,0x243185be); 124| | RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],11,0x550c7dc3); 125| | RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],12,0x72be5d74); 126| | RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],13,0x80deb1fe); 127| | RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],14,0x9bdc06a7); 128| | RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],15,0xc19bf174); 129| | RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],16,0xe49b69c1); 130| | RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],17,0xefbe4786); 131| | RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],18,0x0fc19dc6); 132| | RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],19,0x240ca1cc); 133| | RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],20,0x2de92c6f); 134| | RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],21,0x4a7484aa); 135| | RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],22,0x5cb0a9dc); 136| | RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],23,0x76f988da); 137| | RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],24,0x983e5152); 138| | RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],25,0xa831c66d); 139| | RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],26,0xb00327c8); 140| | RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],27,0xbf597fc7); 141| | RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],28,0xc6e00bf3); 142| | RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],29,0xd5a79147); 143| | RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],30,0x06ca6351); 144| | RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],31,0x14292967); 145| | RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],32,0x27b70a85); 146| | RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],33,0x2e1b2138); 147| | RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],34,0x4d2c6dfc); 148| | RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],35,0x53380d13); 149| | RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],36,0x650a7354); 150| | RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],37,0x766a0abb); 151| | RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],38,0x81c2c92e); 152| | RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],39,0x92722c85); 153| | RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],40,0xa2bfe8a1); 154| | RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],41,0xa81a664b); 155| | RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],42,0xc24b8b70); 156| | RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],43,0xc76c51a3); 157| | RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],44,0xd192e819); 158| | RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],45,0xd6990624); 159| | RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],46,0xf40e3585); 160| | RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],47,0x106aa070); 161| | RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],48,0x19a4c116); 162| | RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],49,0x1e376c08); 163| | RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],50,0x2748774c); 164| | RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],51,0x34b0bcb5); 165| | RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],52,0x391c0cb3); 166| | RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],53,0x4ed8aa4a); 167| | RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],54,0x5b9cca4f); 168| | RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],55,0x682e6ff3); 169| | RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],56,0x748f82ee); 170| | RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],57,0x78a5636f); 171| | RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],58,0x84c87814); 172| | RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],59,0x8cc70208); 173| | RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],60,0x90befffa); 174| | RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],61,0xa4506ceb); 175| | RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],62,0xbef9a3f7); 176| | RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],63,0xc67178f2); 177| | 178| |#undef RND 179| | 180| |#endif 181| | 182| | /* feedback */ 183| 79.7k| for (i = 0; i < 8; i++) { ------------------ | Branch (183:17): [True: 70.8k, False: 8.86k] ------------------ 184| 70.8k| md->sha256.state[i] = md->sha256.state[i] + S[i]; 185| 70.8k| } 186| 8.86k| return CRYPT_OK; 187| 8.86k|} sha384_init: 42| 52|{ 43| 52| LTC_ARGCHK(md != NULL); ------------------ | | 32| 52|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 52] | | | Branch (32:87): [Folded, False: 52] | | ------------------ ------------------ 44| | 45| 52| md->sha512.curlen = 0; 46| 52| md->sha512.length = 0; 47| 52| md->sha512.state[0] = CONST64(0xcbbb9d5dc1059ed8); ------------------ | | 200| 52| #define CONST64(n) n ## ULL ------------------ 48| 52| md->sha512.state[1] = CONST64(0x629a292a367cd507); ------------------ | | 200| 52| #define CONST64(n) n ## ULL ------------------ 49| 52| md->sha512.state[2] = CONST64(0x9159015a3070dd17); ------------------ | | 200| 52| #define CONST64(n) n ## ULL ------------------ 50| 52| md->sha512.state[3] = CONST64(0x152fecd8f70e5939); ------------------ | | 200| 52| #define CONST64(n) n ## ULL ------------------ 51| 52| md->sha512.state[4] = CONST64(0x67332667ffc00b31); ------------------ | | 200| 52| #define CONST64(n) n ## ULL ------------------ 52| 52| md->sha512.state[5] = CONST64(0x8eb44a8768581511); ------------------ | | 200| 52| #define CONST64(n) n ## ULL ------------------ 53| 52| md->sha512.state[6] = CONST64(0xdb0c2e0d64f98fa7); ------------------ | | 200| 52| #define CONST64(n) n ## ULL ------------------ 54| 52| md->sha512.state[7] = CONST64(0x47b5481dbefa4fa4); ------------------ | | 200| 52| #define CONST64(n) n ## ULL ------------------ 55| 52| return CRYPT_OK; 56| 52|} sha384_done: 65| 52|{ 66| 52| unsigned char buf[64]; 67| | 68| 52| LTC_ARGCHK(md != NULL); ------------------ | | 32| 52|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 52] | | | Branch (32:87): [Folded, False: 52] | | ------------------ ------------------ 69| 52| LTC_ARGCHK(out != NULL); ------------------ | | 32| 52|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 52] | | | Branch (32:87): [Folded, False: 52] | | ------------------ ------------------ 70| | 71| 52| if (md->sha512.curlen >= sizeof(md->sha512.buf)) { ------------------ | Branch (71:9): [True: 0, False: 52] ------------------ 72| 0| return CRYPT_INVALID_ARG; 73| 0| } 74| | 75| 52| sha512_done(md, buf); 76| 52| XMEMCPY(out, buf, 48); ------------------ | | 39| 52|#define XMEMCPY memcpy ------------------ 77| |#ifdef LTC_CLEAN_STACK 78| | zeromem(buf, sizeof(buf)); 79| |#endif 80| 52| return CRYPT_OK; 81| 52|} sha512_init: 174| 76|{ 175| 76| LTC_ARGCHK(md != NULL); ------------------ | | 32| 76|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 76] | | | Branch (32:87): [Folded, False: 76] | | ------------------ ------------------ 176| 76| md->sha512.curlen = 0; 177| 76| md->sha512.length = 0; 178| 76| md->sha512.state[0] = CONST64(0x6a09e667f3bcc908); ------------------ | | 200| 76| #define CONST64(n) n ## ULL ------------------ 179| 76| md->sha512.state[1] = CONST64(0xbb67ae8584caa73b); ------------------ | | 200| 76| #define CONST64(n) n ## ULL ------------------ 180| 76| md->sha512.state[2] = CONST64(0x3c6ef372fe94f82b); ------------------ | | 200| 76| #define CONST64(n) n ## ULL ------------------ 181| 76| md->sha512.state[3] = CONST64(0xa54ff53a5f1d36f1); ------------------ | | 200| 76| #define CONST64(n) n ## ULL ------------------ 182| 76| md->sha512.state[4] = CONST64(0x510e527fade682d1); ------------------ | | 200| 76| #define CONST64(n) n ## ULL ------------------ 183| 76| md->sha512.state[5] = CONST64(0x9b05688c2b3e6c1f); ------------------ | | 200| 76| #define CONST64(n) n ## ULL ------------------ 184| 76| md->sha512.state[6] = CONST64(0x1f83d9abfb41bd6b); ------------------ | | 200| 76| #define CONST64(n) n ## ULL ------------------ 185| 76| md->sha512.state[7] = CONST64(0x5be0cd19137e2179); ------------------ | | 200| 76| #define CONST64(n) n ## ULL ------------------ 186| 76| return CRYPT_OK; 187| 76|} sha512_done: 205| 128|{ 206| 128| int i; 207| | 208| 128| LTC_ARGCHK(md != NULL); ------------------ | | 32| 128|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 128] | | | Branch (32:87): [Folded, False: 128] | | ------------------ ------------------ 209| 128| LTC_ARGCHK(out != NULL); ------------------ | | 32| 128|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 128] | | | Branch (32:87): [Folded, False: 128] | | ------------------ ------------------ 210| | 211| 128| if (md->sha512.curlen >= sizeof(md->sha512.buf)) { ------------------ | Branch (211:9): [True: 0, False: 128] ------------------ 212| 0| return CRYPT_INVALID_ARG; 213| 0| } 214| | 215| | /* increase the length of the message */ 216| 128| md->sha512.length += md->sha512.curlen * CONST64(8); ------------------ | | 200| 128| #define CONST64(n) n ## ULL ------------------ 217| | 218| | /* append the '1' bit */ 219| 128| md->sha512.buf[md->sha512.curlen++] = (unsigned char)0x80; 220| | 221| | /* if the length is currently above 112 bytes we append zeros 222| | * then compress. Then we can fall back to padding zeros and length 223| | * encoding like normal. 224| | */ 225| 128| if (md->sha512.curlen > 112) { ------------------ | Branch (225:9): [True: 0, False: 128] ------------------ 226| 0| while (md->sha512.curlen < 128) { ------------------ | Branch (226:16): [True: 0, False: 0] ------------------ 227| 0| md->sha512.buf[md->sha512.curlen++] = (unsigned char)0; 228| 0| } 229| 0| sha512_compress(md, md->sha512.buf); 230| 0| md->sha512.curlen = 0; 231| 0| } 232| | 233| | /* pad upto 120 bytes of zeroes 234| | * note: that from 112 to 120 is the 64 MSB of the length. We assume that you won't hash 235| | * > 2^64 bits of data... :-) 236| | */ 237| 14.0k| while (md->sha512.curlen < 120) { ------------------ | Branch (237:12): [True: 13.9k, False: 128] ------------------ 238| 13.9k| md->sha512.buf[md->sha512.curlen++] = (unsigned char)0; 239| 13.9k| } 240| | 241| | /* store length */ 242| 128| STORE64H(md->sha512.length, md->sha512.buf+120); ------------------ | | 101| 128|#define STORE64H(x, y) \ | | 102| 128|do { ulong64 __t = __builtin_bswap64 ((x)); \ | | 103| 128| XMEMCPY ((y), &__t, 8); } while(0) | | ------------------ | | | | 39| 128|#define XMEMCPY memcpy | | ------------------ | | | Branch (103:39): [Folded, False: 128] | | ------------------ ------------------ 243| 128| sha512_compress(md, md->sha512.buf); 244| | 245| | /* copy output */ 246| 1.15k| for (i = 0; i < 8; i++) { ------------------ | Branch (246:17): [True: 1.02k, False: 128] ------------------ 247| 1.02k| STORE64H(md->sha512.state[i], out+(8*i)); ------------------ | | 101| 1.02k|#define STORE64H(x, y) \ | | 102| 1.02k|do { ulong64 __t = __builtin_bswap64 ((x)); \ | | 103| 1.02k| XMEMCPY ((y), &__t, 8); } while(0) | | ------------------ | | | | 39| 1.02k|#define XMEMCPY memcpy | | ------------------ | | | Branch (103:39): [Folded, False: 1.02k] | | ------------------ ------------------ 248| 1.02k| } 249| |#ifdef LTC_CLEAN_STACK 250| | zeromem(md, sizeof(hash_state)); 251| |#endif 252| 128| return CRYPT_OK; 253| 128|} sha512.c:sha512_compress: 96| 140|{ 97| 140| ulong64 S[8], W[80], t0, t1; 98| 140| int i; 99| | 100| | /* copy state into S */ 101| 1.26k| for (i = 0; i < 8; i++) { ------------------ | Branch (101:17): [True: 1.12k, False: 140] ------------------ 102| 1.12k| S[i] = md->sha512.state[i]; 103| 1.12k| } 104| | 105| | /* copy the state into 1024-bits into W[0..15] */ 106| 2.38k| for (i = 0; i < 16; i++) { ------------------ | Branch (106:17): [True: 2.24k, False: 140] ------------------ 107| 2.24k| LOAD64H(W[i], buf + (8*i)); ------------------ | | 105| 2.24k|#define LOAD64H(x, y) \ | | 106| 2.24k|do { XMEMCPY (&(x), (y), 8); \ | | ------------------ | | | | 39| 2.24k|#define XMEMCPY memcpy | | ------------------ | | 107| 2.24k| (x) = __builtin_bswap64 ((x)); } while(0) | | ------------------ | | | Branch (107:46): [Folded, False: 2.24k] | | ------------------ ------------------ 108| 2.24k| } 109| | 110| | /* fill W[16..79] */ 111| 9.10k| for (i = 16; i < 80; i++) { ------------------ | Branch (111:18): [True: 8.96k, False: 140] ------------------ 112| 8.96k| W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]; ------------------ | | 88| 8.96k|#define Gamma1(x) (S(x, 19) ^ S(x, 61) ^ R(x, 6)) | | ------------------ | | | | 83| 8.96k|#define S(x, n) ROR64c(x, n) | | | | ------------------ | | | | | | 384| 8.96k|#define ROR64c(word,i) ({ \ | | | | | | 385| 8.96k| ulong64 __ROR64c_tmp = word; \ | | | | | | 386| 8.96k| __asm__ ("rorq %2, %0" : \ | | | | | | 387| 8.96k| "=r" (__ROR64c_tmp) : \ | | | | | | 388| 8.96k| "0" (__ROR64c_tmp), \ | | | | | | 389| 8.96k| "J" (i)); \ | | | | | | 390| 8.96k| __ROR64c_tmp; \ | | | | | | 391| 8.96k| }) | | | | ------------------ | | ------------------ | | #define Gamma1(x) (S(x, 19) ^ S(x, 61) ^ R(x, 6)) | | ------------------ | | | | 83| 8.96k|#define S(x, n) ROR64c(x, n) | | | | ------------------ | | | | | | 384| 8.96k|#define ROR64c(word,i) ({ \ | | | | | | 385| 8.96k| ulong64 __ROR64c_tmp = word; \ | | | | | | 386| 8.96k| __asm__ ("rorq %2, %0" : \ | | | | | | 387| 8.96k| "=r" (__ROR64c_tmp) : \ | | | | | | 388| 8.96k| "0" (__ROR64c_tmp), \ | | | | | | 389| 8.96k| "J" (i)); \ | | | | | | 390| 8.96k| __ROR64c_tmp; \ | | | | | | 391| 8.96k| }) | | | | ------------------ | | ------------------ | | #define Gamma1(x) (S(x, 19) ^ S(x, 61) ^ R(x, 6)) | | ------------------ | | | | 84| 8.96k|#define R(x, n) (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)n)) | | | | ------------------ | | | | | | 200| 8.96k| #define CONST64(n) n ## ULL | | | | ------------------ | | ------------------ ------------------ W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]; ------------------ | | 87| 8.96k|#define Gamma0(x) (S(x, 1) ^ S(x, 8) ^ R(x, 7)) | | ------------------ | | | | 83| 8.96k|#define S(x, n) ROR64c(x, n) | | | | ------------------ | | | | | | 384| 8.96k|#define ROR64c(word,i) ({ \ | | | | | | 385| 8.96k| ulong64 __ROR64c_tmp = word; \ | | | | | | 386| 8.96k| __asm__ ("rorq %2, %0" : \ | | | | | | 387| 8.96k| "=r" (__ROR64c_tmp) : \ | | | | | | 388| 8.96k| "0" (__ROR64c_tmp), \ | | | | | | 389| 8.96k| "J" (i)); \ | | | | | | 390| 8.96k| __ROR64c_tmp; \ | | | | | | 391| 8.96k| }) | | | | ------------------ | | ------------------ | | #define Gamma0(x) (S(x, 1) ^ S(x, 8) ^ R(x, 7)) | | ------------------ | | | | 83| 8.96k|#define S(x, n) ROR64c(x, n) | | | | ------------------ | | | | | | 384| 8.96k|#define ROR64c(word,i) ({ \ | | | | | | 385| 8.96k| ulong64 __ROR64c_tmp = word; \ | | | | | | 386| 8.96k| __asm__ ("rorq %2, %0" : \ | | | | | | 387| 8.96k| "=r" (__ROR64c_tmp) : \ | | | | | | 388| 8.96k| "0" (__ROR64c_tmp), \ | | | | | | 389| 8.96k| "J" (i)); \ | | | | | | 390| 8.96k| __ROR64c_tmp; \ | | | | | | 391| 8.96k| }) | | | | ------------------ | | ------------------ | | #define Gamma0(x) (S(x, 1) ^ S(x, 8) ^ R(x, 7)) | | ------------------ | | | | 84| 8.96k|#define R(x, n) (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)n)) | | | | ------------------ | | | | | | 200| 8.96k| #define CONST64(n) n ## ULL | | | | ------------------ | | ------------------ ------------------ 113| 8.96k| } 114| | 115| | /* Compress */ 116| 140|#ifdef LTC_SMALL_CODE 117| 11.3k| for (i = 0; i < 80; i++) { ------------------ | Branch (117:17): [True: 11.2k, False: 140] ------------------ 118| 11.2k| t0 = S[7] + Sigma1(S[4]) + Ch(S[4], S[5], S[6]) + K[i] + W[i]; ------------------ | | 86| 11.2k|#define Sigma1(x) (S(x, 14) ^ S(x, 18) ^ S(x, 41)) | | ------------------ | | | | 83| 11.2k|#define S(x, n) ROR64c(x, n) | | | | ------------------ | | | | | | 384| 11.2k|#define ROR64c(word,i) ({ \ | | | | | | 385| 11.2k| ulong64 __ROR64c_tmp = word; \ | | | | | | 386| 11.2k| __asm__ ("rorq %2, %0" : \ | | | | | | 387| 11.2k| "=r" (__ROR64c_tmp) : \ | | | | | | 388| 11.2k| "0" (__ROR64c_tmp), \ | | | | | | 389| 11.2k| "J" (i)); \ | | | | | | 390| 11.2k| __ROR64c_tmp; \ | | | | | | 391| 11.2k| }) | | | | ------------------ | | ------------------ | | #define Sigma1(x) (S(x, 14) ^ S(x, 18) ^ S(x, 41)) | | ------------------ | | | | 83| 11.2k|#define S(x, n) ROR64c(x, n) | | | | ------------------ | | | | | | 384| 11.2k|#define ROR64c(word,i) ({ \ | | | | | | 385| 11.2k| ulong64 __ROR64c_tmp = word; \ | | | | | | 386| 11.2k| __asm__ ("rorq %2, %0" : \ | | | | | | 387| 11.2k| "=r" (__ROR64c_tmp) : \ | | | | | | 388| 11.2k| "0" (__ROR64c_tmp), \ | | | | | | 389| 11.2k| "J" (i)); \ | | | | | | 390| 11.2k| __ROR64c_tmp; \ | | | | | | 391| 11.2k| }) | | | | ------------------ | | ------------------ | | #define Sigma1(x) (S(x, 14) ^ S(x, 18) ^ S(x, 41)) | | ------------------ | | | | 83| 11.2k|#define S(x, n) ROR64c(x, n) | | | | ------------------ | | | | | | 384| 11.2k|#define ROR64c(word,i) ({ \ | | | | | | 385| 11.2k| ulong64 __ROR64c_tmp = word; \ | | | | | | 386| 11.2k| __asm__ ("rorq %2, %0" : \ | | | | | | 387| 11.2k| "=r" (__ROR64c_tmp) : \ | | | | | | 388| 11.2k| "0" (__ROR64c_tmp), \ | | | | | | 389| 11.2k| "J" (i)); \ | | | | | | 390| 11.2k| __ROR64c_tmp; \ | | | | | | 391| 11.2k| }) | | | | ------------------ | | ------------------ ------------------ t0 = S[7] + Sigma1(S[4]) + Ch(S[4], S[5], S[6]) + K[i] + W[i]; ------------------ | | 81| 11.2k|#define Ch(x,y,z) (z ^ (x & (y ^ z))) ------------------ 119| 11.2k| t1 = Sigma0(S[0]) + Maj(S[0], S[1], S[2]); ------------------ | | 85| 11.2k|#define Sigma0(x) (S(x, 28) ^ S(x, 34) ^ S(x, 39)) | | ------------------ | | | | 83| 11.2k|#define S(x, n) ROR64c(x, n) | | | | ------------------ | | | | | | 384| 11.2k|#define ROR64c(word,i) ({ \ | | | | | | 385| 11.2k| ulong64 __ROR64c_tmp = word; \ | | | | | | 386| 11.2k| __asm__ ("rorq %2, %0" : \ | | | | | | 387| 11.2k| "=r" (__ROR64c_tmp) : \ | | | | | | 388| 11.2k| "0" (__ROR64c_tmp), \ | | | | | | 389| 11.2k| "J" (i)); \ | | | | | | 390| 11.2k| __ROR64c_tmp; \ | | | | | | 391| 11.2k| }) | | | | ------------------ | | ------------------ | | #define Sigma0(x) (S(x, 28) ^ S(x, 34) ^ S(x, 39)) | | ------------------ | | | | 83| 11.2k|#define S(x, n) ROR64c(x, n) | | | | ------------------ | | | | | | 384| 11.2k|#define ROR64c(word,i) ({ \ | | | | | | 385| 11.2k| ulong64 __ROR64c_tmp = word; \ | | | | | | 386| 11.2k| __asm__ ("rorq %2, %0" : \ | | | | | | 387| 11.2k| "=r" (__ROR64c_tmp) : \ | | | | | | 388| 11.2k| "0" (__ROR64c_tmp), \ | | | | | | 389| 11.2k| "J" (i)); \ | | | | | | 390| 11.2k| __ROR64c_tmp; \ | | | | | | 391| 11.2k| }) | | | | ------------------ | | ------------------ | | #define Sigma0(x) (S(x, 28) ^ S(x, 34) ^ S(x, 39)) | | ------------------ | | | | 83| 11.2k|#define S(x, n) ROR64c(x, n) | | | | ------------------ | | | | | | 384| 11.2k|#define ROR64c(word,i) ({ \ | | | | | | 385| 11.2k| ulong64 __ROR64c_tmp = word; \ | | | | | | 386| 11.2k| __asm__ ("rorq %2, %0" : \ | | | | | | 387| 11.2k| "=r" (__ROR64c_tmp) : \ | | | | | | 388| 11.2k| "0" (__ROR64c_tmp), \ | | | | | | 389| 11.2k| "J" (i)); \ | | | | | | 390| 11.2k| __ROR64c_tmp; \ | | | | | | 391| 11.2k| }) | | | | ------------------ | | ------------------ ------------------ t1 = Sigma0(S[0]) + Maj(S[0], S[1], S[2]); ------------------ | | 82| 11.2k|#define Maj(x,y,z) (((x | y) & z) | (x & y)) ------------------ 120| 11.2k| S[7] = S[6]; 121| 11.2k| S[6] = S[5]; 122| 11.2k| S[5] = S[4]; 123| 11.2k| S[4] = S[3] + t0; 124| 11.2k| S[3] = S[2]; 125| 11.2k| S[2] = S[1]; 126| 11.2k| S[1] = S[0]; 127| 11.2k| S[0] = t0 + t1; 128| 11.2k| } 129| |#else 130| |#define RND(a,b,c,d,e,f,g,h,i) \ 131| | t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \ 132| | t1 = Sigma0(a) + Maj(a, b, c); \ 133| | d += t0; \ 134| | h = t0 + t1; 135| | 136| | for (i = 0; i < 80; i += 8) { 137| | RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],i+0); 138| | RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],i+1); 139| | RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],i+2); 140| | RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],i+3); 141| | RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],i+4); 142| | RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],i+5); 143| | RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],i+6); 144| | RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],i+7); 145| | } 146| |#endif 147| | 148| | 149| | /* feedback */ 150| 1.26k| for (i = 0; i < 8; i++) { ------------------ | Branch (150:17): [True: 1.12k, False: 140] ------------------ 151| 1.12k| md->sha512.state[i] = md->sha512.state[i] + S[i]; 152| 1.12k| } 153| | 154| 140| return CRYPT_OK; 155| 140|} sha1_process: 491| 1.02k|int func_name (hash_state * md, const unsigned char *in, unsigned long inlen) \ 492| 1.02k|{ \ 493| 1.02k| unsigned long n; \ 494| 1.02k| int err; \ 495| 1.02k| LTC_ARGCHK(md != NULL); \ ------------------ | | 32| 1.02k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.02k] | | | Branch (32:87): [Folded, False: 1.02k] | | ------------------ ------------------ 496| 1.02k| LTC_ARGCHK(in != NULL); \ ------------------ | | 32| 1.02k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.02k] | | | Branch (32:87): [Folded, False: 1.02k] | | ------------------ ------------------ 497| 1.02k| if (md-> state_var .curlen > sizeof(md-> state_var .buf)) { \ ------------------ | Branch (497:9): [True: 0, False: 1.02k] ------------------ 498| 0| return CRYPT_INVALID_ARG; \ 499| 0| } \ 500| 1.02k| if ((md-> state_var .length + inlen) < md-> state_var .length) { \ ------------------ | Branch (500:9): [True: 0, False: 1.02k] ------------------ 501| 0| return CRYPT_HASH_OVERFLOW; \ 502| 0| } \ 503| 2.04k| while (inlen > 0) { \ ------------------ | Branch (503:12): [True: 1.02k, False: 1.02k] ------------------ 504| 1.02k| if (md-> state_var .curlen == 0 && inlen >= block_size) { \ ------------------ | Branch (504:13): [True: 1.02k, False: 0] | Branch (504:44): [True: 0, False: 1.02k] ------------------ 505| 0| if ((err = compress_name (md, (unsigned char *)in)) != CRYPT_OK) { \ ------------------ | Branch (505:16): [True: 0, False: 0] ------------------ 506| 0| return err; \ 507| 0| } \ 508| 0| md-> state_var .length += block_size * 8; \ 509| 0| in += block_size; \ 510| 0| inlen -= block_size; \ 511| 1.02k| } else { \ 512| 1.02k| n = MIN(inlen, (block_size - md-> state_var .curlen)); \ ------------------ | | 425| 1.02k| #define MIN(x, y) ( ((x)<(y))?(x):(y) ) | | ------------------ | | | Branch (425:24): [True: 1.02k, False: 0] | | ------------------ ------------------ 513| 1.02k| XMEMCPY(md-> state_var .buf + md-> state_var.curlen, in, (size_t)n); \ ------------------ | | 39| 1.02k|#define XMEMCPY memcpy ------------------ 514| 1.02k| md-> state_var .curlen += n; \ 515| 1.02k| in += n; \ 516| 1.02k| inlen -= n; \ 517| 1.02k| if (md-> state_var .curlen == block_size) { \ ------------------ | Branch (517:16): [True: 0, False: 1.02k] ------------------ 518| 0| if ((err = compress_name (md, md-> state_var .buf)) != CRYPT_OK) { \ ------------------ | Branch (518:19): [True: 0, False: 0] ------------------ 519| 0| return err; \ 520| 0| } \ 521| 0| md-> state_var .length += 8*block_size; \ 522| 0| md-> state_var .curlen = 0; \ 523| 0| } \ 524| 1.02k| } \ 525| 1.02k| } \ 526| 1.02k| return CRYPT_OK; \ 527| 1.02k|} sha256_process: 491| 13.8k|int func_name (hash_state * md, const unsigned char *in, unsigned long inlen) \ 492| 13.8k|{ \ 493| 13.8k| unsigned long n; \ 494| 13.8k| int err; \ 495| 13.8k| LTC_ARGCHK(md != NULL); \ ------------------ | | 32| 13.8k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 13.8k] | | | Branch (32:87): [Folded, False: 13.8k] | | ------------------ ------------------ 496| 13.8k| LTC_ARGCHK(in != NULL); \ ------------------ | | 32| 13.8k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 13.8k] | | | Branch (32:87): [Folded, False: 13.8k] | | ------------------ ------------------ 497| 13.8k| if (md-> state_var .curlen > sizeof(md-> state_var .buf)) { \ ------------------ | Branch (497:9): [True: 0, False: 13.8k] ------------------ 498| 0| return CRYPT_INVALID_ARG; \ 499| 0| } \ 500| 13.8k| if ((md-> state_var .length + inlen) < md-> state_var .length) { \ ------------------ | Branch (500:9): [True: 0, False: 13.8k] ------------------ 501| 0| return CRYPT_HASH_OVERFLOW; \ 502| 0| } \ 503| 29.4k| while (inlen > 0) { \ ------------------ | Branch (503:12): [True: 15.5k, False: 13.8k] ------------------ 504| 15.5k| if (md-> state_var .curlen == 0 && inlen >= block_size) { \ ------------------ | Branch (504:13): [True: 8.81k, False: 6.77k] | Branch (504:44): [True: 1.75k, False: 7.06k] ------------------ 505| 1.75k| if ((err = compress_name (md, (unsigned char *)in)) != CRYPT_OK) { \ ------------------ | Branch (505:16): [True: 0, False: 1.75k] ------------------ 506| 0| return err; \ 507| 0| } \ 508| 1.75k| md-> state_var .length += block_size * 8; \ 509| 1.75k| in += block_size; \ 510| 1.75k| inlen -= block_size; \ 511| 13.8k| } else { \ 512| 13.8k| n = MIN(inlen, (block_size - md-> state_var .curlen)); \ ------------------ | | 425| 13.8k| #define MIN(x, y) ( ((x)<(y))?(x):(y) ) | | ------------------ | | | Branch (425:24): [True: 13.8k, False: 0] | | ------------------ ------------------ 513| 13.8k| XMEMCPY(md-> state_var .buf + md-> state_var.curlen, in, (size_t)n); \ ------------------ | | 39| 13.8k|#define XMEMCPY memcpy ------------------ 514| 13.8k| md-> state_var .curlen += n; \ 515| 13.8k| in += n; \ 516| 13.8k| inlen -= n; \ 517| 13.8k| if (md-> state_var .curlen == block_size) { \ ------------------ | Branch (517:16): [True: 0, False: 13.8k] ------------------ 518| 0| if ((err = compress_name (md, md-> state_var .buf)) != CRYPT_OK) { \ ------------------ | Branch (518:19): [True: 0, False: 0] ------------------ 519| 0| return err; \ 520| 0| } \ 521| 0| md-> state_var .length += 8*block_size; \ 522| 0| md-> state_var .curlen = 0; \ 523| 0| } \ 524| 13.8k| } \ 525| 15.5k| } \ 526| 13.8k| return CRYPT_OK; \ 527| 13.8k|} sha512_process: 491| 172|int func_name (hash_state * md, const unsigned char *in, unsigned long inlen) \ 492| 172|{ \ 493| 172| unsigned long n; \ 494| 172| int err; \ 495| 172| LTC_ARGCHK(md != NULL); \ ------------------ | | 32| 172|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 172] | | | Branch (32:87): [Folded, False: 172] | | ------------------ ------------------ 496| 172| LTC_ARGCHK(in != NULL); \ ------------------ | | 32| 172|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 172] | | | Branch (32:87): [Folded, False: 172] | | ------------------ ------------------ 497| 172| if (md-> state_var .curlen > sizeof(md-> state_var .buf)) { \ ------------------ | Branch (497:9): [True: 0, False: 172] ------------------ 498| 0| return CRYPT_INVALID_ARG; \ 499| 0| } \ 500| 172| if ((md-> state_var .length + inlen) < md-> state_var .length) { \ ------------------ | Branch (500:9): [True: 0, False: 172] ------------------ 501| 0| return CRYPT_HASH_OVERFLOW; \ 502| 0| } \ 503| 356| while (inlen > 0) { \ ------------------ | Branch (503:12): [True: 184, False: 172] ------------------ 504| 184| if (md-> state_var .curlen == 0 && inlen >= block_size) { \ ------------------ | Branch (504:13): [True: 140, False: 44] | Branch (504:44): [True: 0, False: 140] ------------------ 505| 0| if ((err = compress_name (md, (unsigned char *)in)) != CRYPT_OK) { \ ------------------ | Branch (505:16): [True: 0, False: 0] ------------------ 506| 0| return err; \ 507| 0| } \ 508| 0| md-> state_var .length += block_size * 8; \ 509| 0| in += block_size; \ 510| 0| inlen -= block_size; \ 511| 184| } else { \ 512| 184| n = MIN(inlen, (block_size - md-> state_var .curlen)); \ ------------------ | | 425| 184| #define MIN(x, y) ( ((x)<(y))?(x):(y) ) | | ------------------ | | | Branch (425:24): [True: 172, False: 12] | | ------------------ ------------------ 513| 184| XMEMCPY(md-> state_var .buf + md-> state_var.curlen, in, (size_t)n); \ ------------------ | | 39| 184|#define XMEMCPY memcpy ------------------ 514| 184| md-> state_var .curlen += n; \ 515| 184| in += n; \ 516| 184| inlen -= n; \ 517| 184| if (md-> state_var .curlen == block_size) { \ ------------------ | Branch (517:16): [True: 12, False: 172] ------------------ 518| 12| if ((err = compress_name (md, md-> state_var .buf)) != CRYPT_OK) { \ ------------------ | Branch (518:19): [True: 0, False: 12] ------------------ 519| 0| return err; \ 520| 0| } \ 521| 12| md-> state_var .length += 8*block_size; \ 522| 12| md-> state_var .curlen = 0; \ 523| 12| } \ 524| 184| } \ 525| 184| } \ 526| 172| return CRYPT_OK; \ 527| 172|} sha1.c:ROL: 258| 65.5k|{ 259| 65.5k| asm ("roll %%cl,%0" 260| 65.5k| :"=r" (word) 261| 65.5k| :"0" (word),"c" (i)); 262| 65.5k| return word; 263| 65.5k|} ltm_desc.c:init: 58| 402k|{ 59| 402k| int err; 60| | 61| 402k| LTC_ARGCHK(a != NULL); ------------------ | | 32| 402k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 402k] | | | Branch (32:87): [Folded, False: 402k] | | ------------------ ------------------ 62| | 63| 402k| if ((err = init_mpi(a)) != CRYPT_OK) { ------------------ | Branch (63:8): [True: 0, False: 402k] ------------------ 64| 0| return err; 65| 0| } 66| 402k| if ((err = mpi_to_ltc_error(mp_init(*a))) != CRYPT_OK) { ------------------ | Branch (66:8): [True: 0, False: 402k] ------------------ 67| 0| XFREE(*a); ------------------ | | 17| 0|#define XFREE m_free_direct ------------------ 68| 0| } 69| 402k| return err; 70| 402k|} ltm_desc.c:init_mpi: 46| 402k|{ 47| 402k| LTC_ARGCHK(a != NULL); ------------------ | | 32| 402k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 402k] | | | Branch (32:87): [Folded, False: 402k] | | ------------------ ------------------ 48| | 49| 402k| *a = XCALLOC(1, sizeof(mp_int)); ------------------ | | 19| 402k|#define XCALLOC m_calloc ------------------ 50| 402k| if (*a == NULL) { ------------------ | Branch (50:8): [True: 0, False: 402k] ------------------ 51| 0| return CRYPT_MEM; 52| 402k| } else { 53| 402k| return CRYPT_OK; 54| 402k| } 55| 402k|} ltm_desc.c:mpi_to_ltc_error: 34| 5.57M|{ 35| 5.57M| size_t x; 36| | 37| 5.57M| for (x = 0; x < sizeof(mpi_to_ltc_codes)/sizeof(mpi_to_ltc_codes[0]); x++) { ------------------ | Branch (37:16): [True: 5.57M, False: 0] ------------------ 38| 5.57M| if (err == mpi_to_ltc_codes[x].mpi_code) { ------------------ | Branch (38:12): [True: 5.57M, False: 0] ------------------ 39| 5.57M| return mpi_to_ltc_codes[x].ltc_code; 40| 5.57M| } 41| 5.57M| } 42| 0| return CRYPT_ERROR; 43| 5.57M|} ltm_desc.c:deinit: 73| 403k|{ 74| 403k| LTC_ARGCHKVD(a != NULL); ------------------ | | 33| 403k|#define LTC_ARGCHKVD(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (33:34): [True: 0, False: 403k] | | | Branch (33:89): [Folded, False: 403k] | | ------------------ ------------------ 75| 403k| mp_clear(a); 76| 403k| XFREE(a); ------------------ | | 17| 403k|#define XFREE m_free_direct ------------------ 77| 403k|} ltm_desc.c:copy: 87| 255k|{ 88| 255k| LTC_ARGCHK(a != NULL); ------------------ | | 32| 255k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 255k] | | | Branch (32:87): [Folded, False: 255k] | | ------------------ ------------------ 89| 255k| LTC_ARGCHK(b != NULL); ------------------ | | 32| 255k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 255k] | | | Branch (32:87): [Folded, False: 255k] | | ------------------ ------------------ 90| 255k| return mpi_to_ltc_error(mp_copy(a, b)); 91| 255k|} ltm_desc.c:set_int: 104| 520|{ 105| 520| LTC_ARGCHK(a != NULL); ------------------ | | 32| 520|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 520] | | | Branch (32:87): [Folded, False: 520] | | ------------------ ------------------ 106| 520| mp_set_u32(a, b); 107| 520| return CRYPT_OK; 108| 520|} ltm_desc.c:get_digit: 117| 129k|{ 118| 129k| mp_int *A; 119| 129k| LTC_ARGCHK(a != NULL); ------------------ | | 32| 129k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 129k] | | | Branch (32:87): [Folded, False: 129k] | | ------------------ ------------------ 120| 129k| A = a; 121| 129k| return (n >= A->used || n < 0) ? 0 : A->dp[n]; ------------------ | Branch (121:12): [True: 0, False: 129k] | Branch (121:28): [True: 0, False: 129k] ------------------ 122| 129k|} ltm_desc.c:get_digit_count: 125| 129k|{ 126| 129k| mp_int *A; 127| 129k| LTC_ARGCHK(a != NULL); ------------------ | | 32| 129k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 129k] | | | Branch (32:87): [Folded, False: 129k] | | ------------------ ------------------ 128| 129k| A = a; 129| 129k| return A->used; 130| 129k|} ltm_desc.c:compare: 133| 645k|{ 134| 645k| LTC_ARGCHK(a != NULL); ------------------ | | 32| 645k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 645k] | | | Branch (32:87): [Folded, False: 645k] | | ------------------ ------------------ 135| 645k| LTC_ARGCHK(b != NULL); ------------------ | | 32| 645k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 645k] | | | Branch (32:87): [Folded, False: 645k] | | ------------------ ------------------ 136| 645k| switch (mp_cmp(a, b)) { 137| 322k| case MP_LT: return LTC_MP_LT; ------------------ | | 154| 322k|#define MP_LT -1 /* less than */ ------------------ case MP_LT: return LTC_MP_LT; ------------------ | | 12| 322k|#define LTC_MP_LT -1 ------------------ | Branch (137:7): [True: 322k, False: 323k] ------------------ 138| 0| case MP_EQ: return LTC_MP_EQ; ------------------ | | 155| 0|#define MP_EQ 0 /* equal to */ ------------------ case MP_EQ: return LTC_MP_EQ; ------------------ | | 13| 0|#define LTC_MP_EQ 0 ------------------ | Branch (138:7): [True: 0, False: 645k] ------------------ 139| 323k| case MP_GT: return LTC_MP_GT; ------------------ | | 156| 323k|#define MP_GT 1 /* greater than */ ------------------ case MP_GT: return LTC_MP_GT; ------------------ | | 14| 323k|#define LTC_MP_GT 1 ------------------ | Branch (139:7): [True: 323k, False: 322k] ------------------ 140| 0| default: return 0; ------------------ | Branch (140:7): [True: 0, False: 645k] ------------------ 141| 645k| } 142| 645k|} ltm_desc.c:compare_d: 145| 687k|{ 146| 687k| LTC_ARGCHK(a != NULL); ------------------ | | 32| 687k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 687k] | | | Branch (32:87): [Folded, False: 687k] | | ------------------ ------------------ 147| 687k| switch (mp_cmp_d(a, b)) { 148| 343k| case MP_LT: return LTC_MP_LT; ------------------ | | 154| 343k|#define MP_LT -1 /* less than */ ------------------ case MP_LT: return LTC_MP_LT; ------------------ | | 12| 343k|#define LTC_MP_LT -1 ------------------ | Branch (148:7): [True: 343k, False: 344k] ------------------ 149| 4| case MP_EQ: return LTC_MP_EQ; ------------------ | | 155| 4|#define MP_EQ 0 /* equal to */ ------------------ case MP_EQ: return LTC_MP_EQ; ------------------ | | 13| 4|#define LTC_MP_EQ 0 ------------------ | Branch (149:7): [True: 4, False: 687k] ------------------ 150| 344k| case MP_GT: return LTC_MP_GT; ------------------ | | 156| 344k|#define MP_GT 1 /* greater than */ ------------------ case MP_GT: return LTC_MP_GT; ------------------ | | 14| 344k|#define LTC_MP_GT 1 ------------------ | Branch (150:7): [True: 344k, False: 343k] ------------------ 151| 0| default: return 0; ------------------ | Branch (151:7): [True: 0, False: 687k] ------------------ 152| 687k| } 153| 687k|} ltm_desc.c:read_radix: 178| 1.05k|{ 179| 1.05k| LTC_ARGCHK(a != NULL); ------------------ | | 32| 1.05k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.05k] | | | Branch (32:87): [Folded, False: 1.05k] | | ------------------ ------------------ 180| 1.05k| LTC_ARGCHK(b != NULL); ------------------ | | 32| 1.05k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.05k] | | | Branch (32:87): [Folded, False: 1.05k] | | ------------------ ------------------ 181| 1.05k| return mpi_to_ltc_error(mp_read_radix(a, b, radix)); 182| 1.05k|} ltm_desc.c:unsigned_size: 194| 520|{ 195| 520| LTC_ARGCHK(a != NULL); ------------------ | | 32| 520|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 520] | | | Branch (32:87): [Folded, False: 520] | | ------------------ ------------------ 196| 520| return (unsigned long)mp_ubin_size(a); 197| 520|} ltm_desc.c:unsigned_write: 201| 520|{ 202| 520| LTC_ARGCHK(a != NULL); ------------------ | | 32| 520|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 520] | | | Branch (32:87): [Folded, False: 520] | | ------------------ ------------------ 203| 520| LTC_ARGCHK(b != NULL); ------------------ | | 32| 520|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 520] | | | Branch (32:87): [Folded, False: 520] | | ------------------ ------------------ 204| 520| return mpi_to_ltc_error(mp_to_ubin(a, b, SIZE_MAX, NULL)); 205| 520|} ltm_desc.c:unsigned_read: 209| 266|{ 210| 266| LTC_ARGCHK(a != NULL); ------------------ | | 32| 266|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 266] | | | Branch (32:87): [Folded, False: 266] | | ------------------ ------------------ 211| 266| LTC_ARGCHK(b != NULL); ------------------ | | 32| 266|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 266] | | | Branch (32:87): [Folded, False: 266] | | ------------------ ------------------ 212| 266| return mpi_to_ltc_error(mp_from_ubin(a, b, (size_t)len)); 213| 266|} ltm_desc.c:add: 217| 1.01M|{ 218| 1.01M| LTC_ARGCHK(a != NULL); ------------------ | | 32| 1.01M|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.01M] | | | Branch (32:87): [Folded, False: 1.01M] | | ------------------ ------------------ 219| 1.01M| LTC_ARGCHK(b != NULL); ------------------ | | 32| 1.01M|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.01M] | | | Branch (32:87): [Folded, False: 1.01M] | | ------------------ ------------------ 220| 1.01M| LTC_ARGCHK(c != NULL); ------------------ | | 32| 1.01M|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.01M] | | | Branch (32:87): [Folded, False: 1.01M] | | ------------------ ------------------ 221| 1.01M| return mpi_to_ltc_error(mp_add(a, b, c)); 222| 1.01M|} ltm_desc.c:sub: 233| 1.03M|{ 234| 1.03M| LTC_ARGCHK(a != NULL); ------------------ | | 32| 1.03M|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.03M] | | | Branch (32:87): [Folded, False: 1.03M] | | ------------------ ------------------ 235| 1.03M| LTC_ARGCHK(b != NULL); ------------------ | | 32| 1.03M|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.03M] | | | Branch (32:87): [Folded, False: 1.03M] | | ------------------ ------------------ 236| 1.03M| LTC_ARGCHK(c != NULL); ------------------ | | 32| 1.03M|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.03M] | | | Branch (32:87): [Folded, False: 1.03M] | | ------------------ ------------------ 237| 1.03M| return mpi_to_ltc_error(mp_sub(a, b, c)); 238| 1.03M|} ltm_desc.c:mul: 249| 853k|{ 250| 853k| LTC_ARGCHK(a != NULL); ------------------ | | 32| 853k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 853k] | | | Branch (32:87): [Folded, False: 853k] | | ------------------ ------------------ 251| 853k| LTC_ARGCHK(b != NULL); ------------------ | | 32| 853k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 853k] | | | Branch (32:87): [Folded, False: 853k] | | ------------------ ------------------ 252| 853k| LTC_ARGCHK(c != NULL); ------------------ | | 32| 853k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 853k] | | | Branch (32:87): [Folded, False: 853k] | | ------------------ ------------------ 253| 853k| return mpi_to_ltc_error(mp_mul(a, b, c)); 254| 853k|} ltm_desc.c:sqr: 265| 516k|{ 266| 516k| LTC_ARGCHK(a != NULL); ------------------ | | 32| 516k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 516k] | | | Branch (32:87): [Folded, False: 516k] | | ------------------ ------------------ 267| 516k| LTC_ARGCHK(b != NULL); ------------------ | | 32| 516k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 516k] | | | Branch (32:87): [Folded, False: 516k] | | ------------------ ------------------ 268| 516k| return mpi_to_ltc_error(mp_sqr(a, b)); 269| 516k|} ltm_desc.c:divide: 273| 780|{ 274| 780| LTC_ARGCHK(a != NULL); ------------------ | | 32| 780|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 780] | | | Branch (32:87): [Folded, False: 780] | | ------------------ ------------------ 275| 780| LTC_ARGCHK(b != NULL); ------------------ | | 32| 780|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 780] | | | Branch (32:87): [Folded, False: 780] | | ------------------ ------------------ 276| 780| return mpi_to_ltc_error(mp_div(a, b, c, d)); 277| 780|} ltm_desc.c:div_2: 280| 129k|{ 281| 129k| LTC_ARGCHK(a != NULL); ------------------ | | 32| 129k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 129k] | | | Branch (32:87): [Folded, False: 129k] | | ------------------ ------------------ 282| 129k| LTC_ARGCHK(b != NULL); ------------------ | | 32| 129k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 129k] | | | Branch (32:87): [Folded, False: 129k] | | ------------------ ------------------ 283| 129k| return mpi_to_ltc_error(mp_div_2(a, b)); 284| 129k|} ltm_desc.c:mulmod: 339| 2.08k|{ 340| 2.08k| LTC_ARGCHK(a != NULL); ------------------ | | 32| 2.08k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 2.08k] | | | Branch (32:87): [Folded, False: 2.08k] | | ------------------ ------------------ 341| 2.08k| LTC_ARGCHK(b != NULL); ------------------ | | 32| 2.08k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 2.08k] | | | Branch (32:87): [Folded, False: 2.08k] | | ------------------ ------------------ 342| 2.08k| LTC_ARGCHK(c != NULL); ------------------ | | 32| 2.08k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 2.08k] | | | Branch (32:87): [Folded, False: 2.08k] | | ------------------ ------------------ 343| 2.08k| LTC_ARGCHK(d != NULL); ------------------ | | 32| 2.08k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 2.08k] | | | Branch (32:87): [Folded, False: 2.08k] | | ------------------ ------------------ 344| 2.08k| return mpi_to_ltc_error(mp_mulmod(a,b,c,d)); 345| 2.08k|} ltm_desc.c:invmod: 357| 520|{ 358| 520| LTC_ARGCHK(a != NULL); ------------------ | | 32| 520|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 520] | | | Branch (32:87): [Folded, False: 520] | | ------------------ ------------------ 359| 520| LTC_ARGCHK(b != NULL); ------------------ | | 32| 520|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 520] | | | Branch (32:87): [Folded, False: 520] | | ------------------ ------------------ 360| 520| LTC_ARGCHK(c != NULL); ------------------ | | 32| 520|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 520] | | | Branch (32:87): [Folded, False: 520] | | ------------------ ------------------ 361| 520| return mpi_to_ltc_error(mp_invmod(a, b, c)); 362| 520|} ltm_desc.c:montgomery_setup: 366| 260|{ 367| 260| int err; 368| 260| LTC_ARGCHK(a != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 369| 260| LTC_ARGCHK(b != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 370| 260| *b = XCALLOC(1, sizeof(mp_digit)); ------------------ | | 19| 260|#define XCALLOC m_calloc ------------------ 371| 260| if (*b == NULL) { ------------------ | Branch (371:8): [True: 0, False: 260] ------------------ 372| 0| return CRYPT_MEM; 373| 0| } 374| 260| if ((err = mpi_to_ltc_error(mp_montgomery_setup(a, (mp_digit *)*b))) != CRYPT_OK) { ------------------ | Branch (374:8): [True: 0, False: 260] ------------------ 375| 0| XFREE(*b); ------------------ | | 17| 0|#define XFREE m_free_direct ------------------ 376| 0| } 377| 260| return err; 378| 260|} ltm_desc.c:montgomery_normalization: 382| 260|{ 383| 260| LTC_ARGCHK(a != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 384| 260| LTC_ARGCHK(b != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 385| 260| return mpi_to_ltc_error(mp_montgomery_calc_normalization(a, b)); 386| 260|} ltm_desc.c:montgomery_reduce: 390| 1.36M|{ 391| 1.36M| LTC_ARGCHK(a != NULL); ------------------ | | 32| 1.36M|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.36M] | | | Branch (32:87): [Folded, False: 1.36M] | | ------------------ ------------------ 392| 1.36M| LTC_ARGCHK(b != NULL); ------------------ | | 32| 1.36M|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.36M] | | | Branch (32:87): [Folded, False: 1.36M] | | ------------------ ------------------ 393| 1.36M| LTC_ARGCHK(c != NULL); ------------------ | | 32| 1.36M|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1.36M] | | | Branch (32:87): [Folded, False: 1.36M] | | ------------------ ------------------ 394| 1.36M| return mpi_to_ltc_error(mp_montgomery_reduce(a, b, *((mp_digit *)c))); 395| 1.36M|} ltm_desc.c:montgomery_deinit: 399| 260|{ 400| 260| XFREE(a); ------------------ | | 17| 260|#define XFREE m_free_direct ------------------ 401| 260|} ltc_init_multi: 15| 134k|{ 16| 134k| void **cur = a; 17| 134k| int np = 0; 18| 134k| va_list args; 19| | 20| 134k| va_start(args, a); 21| 536k| while (cur != NULL) { ------------------ | Branch (21:11): [True: 401k, False: 134k] ------------------ 22| 401k| if (mp_init(cur) != CRYPT_OK) { ------------------ | | 516| 401k|#define mp_init(a) ltc_mp.init(a) ------------------ | Branch (22:12): [True: 0, False: 401k] ------------------ 23| | /* failed */ 24| 0| va_list clean_list; 25| | 26| 0| va_start(clean_list, a); 27| 0| cur = a; 28| 0| while (np--) { ------------------ | Branch (28:18): [True: 0, False: 0] ------------------ 29| 0| mp_clear(*cur); ------------------ | | 518| 0|#define mp_clear(a) ltc_mp.deinit(a) ------------------ 30| 0| cur = va_arg(clean_list, void**); 31| 0| } 32| 0| va_end(clean_list); 33| 0| va_end(args); 34| 0| return CRYPT_MEM; 35| 0| } 36| 401k| ++np; 37| 401k| cur = va_arg(args, void**); 38| 401k| } 39| 134k| va_end(args); 40| 134k| return CRYPT_OK; 41| 134k|} ltc_deinit_multi: 44| 134k|{ 45| 134k| void *cur = a; 46| 134k| va_list args; 47| | 48| 134k| va_start(args, a); 49| 538k| while (cur != NULL) { ------------------ | Branch (49:11): [True: 403k, False: 134k] ------------------ 50| 403k| mp_clear(cur); ------------------ | | 518| 403k|#define mp_clear(a) ltc_mp.deinit(a) ------------------ 51| 403k| cur = va_arg(args, void *); 52| 403k| } 53| | va_end(args); 54| 134k|} register_cipher: 22| 1|{ 23| 1| int x; 24| | 25| 1| LTC_ARGCHK(cipher != NULL); ------------------ | | 32| 1|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1] | | | Branch (32:87): [Folded, False: 1] | | ------------------ ------------------ 26| | 27| | /* is it already registered? */ 28| 1| LTC_MUTEX_LOCK(<c_cipher_mutex); 29| 6| for (x = 0; x < TAB_SIZE; x++) { ------------------ | | 14| 6|#define TAB_SIZE 5 ------------------ | Branch (29:16): [True: 5, False: 1] ------------------ 30| 5| if (cipher_descriptor[x].name != NULL && cipher_descriptor[x].ID == cipher->ID) { ------------------ | Branch (30:12): [True: 0, False: 5] | Branch (30:49): [True: 0, False: 0] ------------------ 31| 0| LTC_MUTEX_UNLOCK(<c_cipher_mutex); 32| 0| return x; 33| 0| } 34| 5| } 35| | 36| | /* find a blank spot */ 37| 1| for (x = 0; x < TAB_SIZE; x++) { ------------------ | | 14| 1|#define TAB_SIZE 5 ------------------ | Branch (37:16): [True: 1, False: 0] ------------------ 38| 1| if (cipher_descriptor[x].name == NULL) { ------------------ | Branch (38:12): [True: 1, False: 0] ------------------ 39| 1| XMEMCPY(&cipher_descriptor[x], cipher, sizeof(struct ltc_cipher_descriptor)); ------------------ | | 39| 1|#define XMEMCPY memcpy ------------------ 40| 1| LTC_MUTEX_UNLOCK(<c_cipher_mutex); 41| 1| return x; 42| 1| } 43| 1| } 44| | 45| | /* no spot */ 46| 0| LTC_MUTEX_UNLOCK(<c_cipher_mutex); 47| 0| return -1; 48| 1|} register_hash: 22| 3|{ 23| 3| int x; 24| | 25| 3| LTC_ARGCHK(hash != NULL); ------------------ | | 32| 3|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 3] | | | Branch (32:87): [Folded, False: 3] | | ------------------ ------------------ 26| | 27| | /* is it already registered? */ 28| 3| LTC_MUTEX_LOCK(<c_hash_mutex); 29| 18| for (x = 0; x < TAB_SIZE; x++) { ------------------ | | 14| 18|#define TAB_SIZE 5 ------------------ | Branch (29:16): [True: 15, False: 3] ------------------ 30| 15| if (XMEMCMP(&hash_descriptor[x], hash, sizeof(struct ltc_hash_descriptor)) == 0) { ------------------ | | 45| 15|#define XMEMCMP memcmp ------------------ | Branch (30:12): [True: 0, False: 15] ------------------ 31| 0| LTC_MUTEX_UNLOCK(<c_hash_mutex); 32| 0| return x; 33| 0| } 34| 15| } 35| | 36| | /* find a blank spot */ 37| 6| for (x = 0; x < TAB_SIZE; x++) { ------------------ | | 14| 6|#define TAB_SIZE 5 ------------------ | Branch (37:16): [True: 6, False: 0] ------------------ 38| 6| if (hash_descriptor[x].name == NULL) { ------------------ | Branch (38:12): [True: 3, False: 3] ------------------ 39| 3| XMEMCPY(&hash_descriptor[x], hash, sizeof(struct ltc_hash_descriptor)); ------------------ | | 39| 3|#define XMEMCPY memcpy ------------------ 40| 3| LTC_MUTEX_UNLOCK(<c_hash_mutex); 41| 3| return x; 42| 3| } 43| 6| } 44| | 45| | /* no spot */ 46| 0| LTC_MUTEX_UNLOCK(<c_hash_mutex); 47| 0| return -1; 48| 3|} register_prng: 22| 1|{ 23| 1| int x; 24| | 25| 1| LTC_ARGCHK(prng != NULL); ------------------ | | 32| 1|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 1] | | | Branch (32:87): [Folded, False: 1] | | ------------------ ------------------ 26| | 27| | /* is it already registered? */ 28| 1| LTC_MUTEX_LOCK(<c_prng_mutex); 29| 6| for (x = 0; x < TAB_SIZE; x++) { ------------------ | | 14| 6|#define TAB_SIZE 5 ------------------ | Branch (29:16): [True: 5, False: 1] ------------------ 30| 5| if (XMEMCMP(&prng_descriptor[x], prng, sizeof(struct ltc_prng_descriptor)) == 0) { ------------------ | | 45| 5|#define XMEMCMP memcmp ------------------ | Branch (30:12): [True: 0, False: 5] ------------------ 31| 0| LTC_MUTEX_UNLOCK(<c_prng_mutex); 32| 0| return x; 33| 0| } 34| 5| } 35| | 36| | /* find a blank spot */ 37| 1| for (x = 0; x < TAB_SIZE; x++) { ------------------ | | 14| 1|#define TAB_SIZE 5 ------------------ | Branch (37:16): [True: 1, False: 0] ------------------ 38| 1| if (prng_descriptor[x].name == NULL) { ------------------ | Branch (38:12): [True: 1, False: 0] ------------------ 39| 1| XMEMCPY(&prng_descriptor[x], prng, sizeof(struct ltc_prng_descriptor)); ------------------ | | 39| 1|#define XMEMCPY memcpy ------------------ 40| 1| LTC_MUTEX_UNLOCK(<c_prng_mutex); 41| 1| return x; 42| 1| } 43| 1| } 44| | 45| | /* no spot */ 46| 0| LTC_MUTEX_UNLOCK(<c_prng_mutex); 47| 0| return -1; 48| 1|} ecc_free: 29| 506|{ 30| 506| LTC_ARGCHKVD(key != NULL); ------------------ | | 33| 506|#define LTC_ARGCHKVD(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (33:34): [True: 0, False: 506] | | | Branch (33:89): [Folded, False: 506] | | ------------------ ------------------ 31| 506| mp_clear_multi(key->pubkey.x, key->pubkey.y, key->pubkey.z, key->k, NULL); ------------------ | | 519| 506|#define mp_clear_multi ltc_deinit_multi ------------------ 32| 506|} ltc_ecc_map: 32| 260|{ 33| 260| void *t1, *t2; 34| 260| int err; 35| | 36| 260| LTC_ARGCHK(P != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 37| 260| LTC_ARGCHK(modulus != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 38| 260| LTC_ARGCHK(mp != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 39| | 40| 260| if ((err = mp_init_multi(&t1, &t2, NULL)) != CRYPT_OK) { ------------------ | | 517| 260|#define mp_init_multi ltc_init_multi ------------------ | Branch (40:8): [True: 0, False: 260] ------------------ 41| 0| return err; 42| 0| } 43| | 44| | /* first map z back to normal */ 45| 260| if ((err = mp_montgomery_reduce(P->z, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 260|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (45:8): [True: 0, False: 260] ------------------ 46| | 47| | /* get 1/z */ 48| 260| if ((err = mp_invmod(P->z, modulus, t1)) != CRYPT_OK) { goto done; } ------------------ | | 561| 260|#define mp_invmod(a, b, c) ltc_mp.invmod(a, b, c) ------------------ | Branch (48:8): [True: 0, False: 260] ------------------ 49| | 50| | /* get 1/z^2 and 1/z^3 */ 51| 260| if ((err = mp_sqr(t1, t2)) != CRYPT_OK) { goto done; } ------------------ | | 549| 260|#define mp_sqr(a, b) ltc_mp.sqr(a, b) ------------------ | Branch (51:8): [True: 0, False: 260] ------------------ 52| 260| if ((err = mp_mod(t2, modulus, t2)) != CRYPT_OK) { goto done; } ------------------ | | 552| 260|#define mp_mod(a, b, c) ltc_mp.mpdiv(a, b, NULL, c) ------------------ | Branch (52:8): [True: 0, False: 260] ------------------ 53| 260| if ((err = mp_mul(t1, t2, t1)) != CRYPT_OK) { goto done; } ------------------ | | 547| 260|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (53:8): [True: 0, False: 260] ------------------ 54| 260| if ((err = mp_mod(t1, modulus, t1)) != CRYPT_OK) { goto done; } ------------------ | | 552| 260|#define mp_mod(a, b, c) ltc_mp.mpdiv(a, b, NULL, c) ------------------ | Branch (54:8): [True: 0, False: 260] ------------------ 55| | 56| | /* multiply against x/y */ 57| 260| if ((err = mp_mul(P->x, t2, P->x)) != CRYPT_OK) { goto done; } ------------------ | | 547| 260|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (57:8): [True: 0, False: 260] ------------------ 58| 260| if ((err = mp_montgomery_reduce(P->x, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 260|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (58:8): [True: 0, False: 260] ------------------ 59| 260| if ((err = mp_mul(P->y, t1, P->y)) != CRYPT_OK) { goto done; } ------------------ | | 547| 260|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (59:8): [True: 0, False: 260] ------------------ 60| 260| if ((err = mp_montgomery_reduce(P->y, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 260|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (60:8): [True: 0, False: 260] ------------------ 61| 260| if ((err = mp_set(P->z, 1)) != CRYPT_OK) { goto done; } ------------------ | | 526| 260|#define mp_set(a, b) ltc_mp.set_int(a, b) ------------------ | Branch (61:8): [True: 0, False: 260] ------------------ 62| | 63| 260| err = CRYPT_OK; 64| 260|done: 65| 260| mp_clear_multi(t1, t2, NULL); ------------------ | | 519| 260|#define mp_clear_multi ltc_deinit_multi ------------------ 66| 260| return err; 67| 260|} ltc_ecc_mul2add: 39| 260|{ 40| 260| ecc_point *precomp[16]; 41| 260| unsigned bitbufA, bitbufB, lenA, lenB, len, x, y, nA, nB, nibble; 42| 260| unsigned char *tA, *tB; 43| 260| int err, first; 44| 260| void *mp, *mu; 45| | 46| | /* argchks */ 47| 260| LTC_ARGCHK(A != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 48| 260| LTC_ARGCHK(B != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 49| 260| LTC_ARGCHK(C != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 50| 260| LTC_ARGCHK(kA != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 51| 260| LTC_ARGCHK(kB != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 52| 260| LTC_ARGCHK(modulus != NULL); ------------------ | | 32| 260|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 260] | | | Branch (32:87): [Folded, False: 260] | | ------------------ ------------------ 53| | 54| | /* allocate memory */ 55| 260| tA = XCALLOC(1, ECC_BUF_SIZE); ------------------ | | 19| 260|#define XCALLOC m_calloc ------------------ tA = XCALLOC(1, ECC_BUF_SIZE); ------------------ | | 246| 260|#define ECC_BUF_SIZE 256 ------------------ 56| 260| if (tA == NULL) { ------------------ | Branch (56:7): [True: 0, False: 260] ------------------ 57| 0| return CRYPT_MEM; 58| 0| } 59| 260| tB = XCALLOC(1, ECC_BUF_SIZE); ------------------ | | 19| 260|#define XCALLOC m_calloc ------------------ tB = XCALLOC(1, ECC_BUF_SIZE); ------------------ | | 246| 260|#define ECC_BUF_SIZE 256 ------------------ 60| 260| if (tB == NULL) { ------------------ | Branch (60:7): [True: 0, False: 260] ------------------ 61| 0| XFREE(tA); ------------------ | | 17| 0|#define XFREE m_free_direct ------------------ 62| 0| return CRYPT_MEM; 63| 0| } 64| | 65| | /* get sizes */ 66| 260| lenA = mp_unsigned_bin_size(kA); ------------------ | | 539| 260|#define mp_unsigned_bin_size(a) ltc_mp.unsigned_size(a) ------------------ 67| 260| lenB = mp_unsigned_bin_size(kB); ------------------ | | 539| 260|#define mp_unsigned_bin_size(a) ltc_mp.unsigned_size(a) ------------------ 68| 260| len = MAX(lenA, lenB); ------------------ | | 421| 260| #define MAX(x, y) ( ((x)>(y))?(x):(y) ) | | ------------------ | | | Branch (421:24): [True: 79, False: 181] | | ------------------ ------------------ 69| | 70| | /* sanity check */ 71| 260| if ((lenA > ECC_BUF_SIZE) || (lenB > ECC_BUF_SIZE)) { ------------------ | | 246| 260|#define ECC_BUF_SIZE 256 ------------------ if ((lenA > ECC_BUF_SIZE) || (lenB > ECC_BUF_SIZE)) { ------------------ | | 246| 260|#define ECC_BUF_SIZE 256 ------------------ | Branch (71:7): [True: 0, False: 260] | Branch (71:32): [True: 0, False: 260] ------------------ 72| 0| err = CRYPT_INVALID_ARG; 73| 0| goto ERR_T; 74| 0| } 75| | 76| | /* extract and justify kA */ 77| 260| mp_to_unsigned_bin(kA, (len - lenA) + tA); ------------------ | | 540| 260|#define mp_to_unsigned_bin(a, b) ltc_mp.unsigned_write(a, b) ------------------ 78| | 79| | /* extract and justify kB */ 80| 260| mp_to_unsigned_bin(kB, (len - lenB) + tB); ------------------ | | 540| 260|#define mp_to_unsigned_bin(a, b) ltc_mp.unsigned_write(a, b) ------------------ 81| | 82| | /* allocate the table */ 83| 4.42k| for (x = 0; x < 16; x++) { ------------------ | Branch (83:15): [True: 4.16k, False: 260] ------------------ 84| 4.16k| precomp[x] = ltc_ecc_new_point(); 85| 4.16k| if (precomp[x] == NULL) { ------------------ | Branch (85:10): [True: 0, False: 4.16k] ------------------ 86| 0| for (y = 0; y < x; ++y) { ------------------ | Branch (86:22): [True: 0, False: 0] ------------------ 87| 0| ltc_ecc_del_point(precomp[y]); 88| 0| } 89| 0| err = CRYPT_MEM; 90| 0| goto ERR_T; 91| 0| } 92| 4.16k| } 93| | 94| | /* init montgomery reduction */ 95| 260| if ((err = mp_montgomery_setup(modulus, &mp)) != CRYPT_OK) { ------------------ | | 563| 260|#define mp_montgomery_setup(a, b) ltc_mp.montgomery_setup(a, b) ------------------ | Branch (95:7): [True: 0, False: 260] ------------------ 96| 0| goto ERR_P; 97| 0| } 98| 260| if ((err = mp_init(&mu)) != CRYPT_OK) { ------------------ | | 516| 260|#define mp_init(a) ltc_mp.init(a) ------------------ | Branch (98:7): [True: 0, False: 260] ------------------ 99| 0| goto ERR_MP; 100| 0| } 101| 260| if ((err = mp_montgomery_normalization(mu, modulus)) != CRYPT_OK) { ------------------ | | 564| 260|#define mp_montgomery_normalization(a, b) ltc_mp.montgomery_normalization(a, b) ------------------ | Branch (101:7): [True: 0, False: 260] ------------------ 102| 0| goto ERR_MU; 103| 0| } 104| | 105| | /* copy ones ... */ 106| 260| if ((err = mp_mulmod(A->x, mu, modulus, precomp[1]->x)) != CRYPT_OK) { goto ERR_MU; } ------------------ | | 559| 260|#define mp_mulmod(a, b, c, d) ltc_mp.mulmod(a, b, c, d) ------------------ | Branch (106:7): [True: 0, False: 260] ------------------ 107| 260| if ((err = mp_mulmod(A->y, mu, modulus, precomp[1]->y)) != CRYPT_OK) { goto ERR_MU; } ------------------ | | 559| 260|#define mp_mulmod(a, b, c, d) ltc_mp.mulmod(a, b, c, d) ------------------ | Branch (107:7): [True: 0, False: 260] ------------------ 108| 260| if ((err = mp_mulmod(A->z, mu, modulus, precomp[1]->z)) != CRYPT_OK) { goto ERR_MU; } ------------------ | | 559| 260|#define mp_mulmod(a, b, c, d) ltc_mp.mulmod(a, b, c, d) ------------------ | Branch (108:7): [True: 0, False: 260] ------------------ 109| | 110| 260| if ((err = mp_mulmod(B->x, mu, modulus, precomp[1<<2]->x)) != CRYPT_OK) { goto ERR_MU; } ------------------ | | 559| 260|#define mp_mulmod(a, b, c, d) ltc_mp.mulmod(a, b, c, d) ------------------ | Branch (110:7): [True: 0, False: 260] ------------------ 111| 260| if ((err = mp_mulmod(B->y, mu, modulus, precomp[1<<2]->y)) != CRYPT_OK) { goto ERR_MU; } ------------------ | | 559| 260|#define mp_mulmod(a, b, c, d) ltc_mp.mulmod(a, b, c, d) ------------------ | Branch (111:7): [True: 0, False: 260] ------------------ 112| 260| if ((err = mp_mulmod(B->z, mu, modulus, precomp[1<<2]->z)) != CRYPT_OK) { goto ERR_MU; } ------------------ | | 559| 260|#define mp_mulmod(a, b, c, d) ltc_mp.mulmod(a, b, c, d) ------------------ | Branch (112:7): [True: 0, False: 260] ------------------ 113| | 114| | /* precomp [i,0](A + B) table */ 115| 260| if ((err = ltc_mp.ecc_ptdbl(precomp[1], precomp[2], modulus, mp)) != CRYPT_OK) { goto ERR_MU; } ------------------ | Branch (115:7): [True: 0, False: 260] ------------------ 116| 260| if ((err = ltc_mp.ecc_ptadd(precomp[1], precomp[2], precomp[3], modulus, mp)) != CRYPT_OK) { goto ERR_MU; } ------------------ | Branch (116:7): [True: 0, False: 260] ------------------ 117| | 118| | /* precomp [0,i](A + B) table */ 119| 260| if ((err = ltc_mp.ecc_ptdbl(precomp[1<<2], precomp[2<<2], modulus, mp)) != CRYPT_OK) { goto ERR_MU; } ------------------ | Branch (119:7): [True: 0, False: 260] ------------------ 120| 260| if ((err = ltc_mp.ecc_ptadd(precomp[1<<2], precomp[2<<2], precomp[3<<2], modulus, mp)) != CRYPT_OK) { goto ERR_MU; } ------------------ | Branch (120:7): [True: 0, False: 260] ------------------ 121| | 122| | /* precomp [i,j](A + B) table (i != 0, j != 0) */ 123| 1.04k| for (x = 1; x < 4; x++) { ------------------ | Branch (123:15): [True: 780, False: 260] ------------------ 124| 3.12k| for (y = 1; y < 4; y++) { ------------------ | Branch (124:18): [True: 2.34k, False: 780] ------------------ 125| 2.34k| if ((err = ltc_mp.ecc_ptadd(precomp[x], precomp[(y<<2)], precomp[x+(y<<2)], modulus, mp)) != CRYPT_OK) { goto ERR_MU; } ------------------ | Branch (125:13): [True: 0, False: 2.34k] ------------------ 126| 2.34k| } 127| 780| } 128| | 129| 260| nibble = 3; 130| 260| first = 1; 131| 260| bitbufA = tA[0]; 132| 260| bitbufB = tB[0]; 133| | 134| | /* for every byte of the multiplicands */ 135| 43.9k| for (x = 0;; ) { 136| | /* grab a nibble */ 137| 43.9k| if (++nibble == 4) { ------------------ | Branch (137:10): [True: 11.1k, False: 32.7k] ------------------ 138| 11.1k| if (x == len) break; ------------------ | Branch (138:13): [True: 260, False: 10.9k] ------------------ 139| 10.9k| bitbufA = tA[x]; 140| 10.9k| bitbufB = tB[x]; 141| 10.9k| nibble = 0; 142| 10.9k| ++x; 143| 10.9k| } 144| | 145| | /* extract two bits from both, shift/update */ 146| 43.6k| nA = (bitbufA >> 6) & 0x03; 147| 43.6k| nB = (bitbufB >> 6) & 0x03; 148| 43.6k| bitbufA = (bitbufA << 2) & 0xFF; 149| 43.6k| bitbufB = (bitbufB << 2) & 0xFF; 150| | 151| | /* if both zero, if first, continue */ 152| 43.6k| if ((nA == 0) && (nB == 0) && (first == 1)) { ------------------ | Branch (152:10): [True: 11.0k, False: 32.6k] | Branch (152:23): [True: 4.22k, False: 6.79k] | Branch (152:36): [True: 187, False: 4.04k] ------------------ 153| 187| continue; 154| 187| } 155| | 156| | /* double twice, only if this isn't the first */ 157| 43.4k| if (first == 0) { ------------------ | Branch (157:10): [True: 43.2k, False: 260] ------------------ 158| | /* double twice */ 159| 43.2k| if ((err = ltc_mp.ecc_ptdbl(C, C, modulus, mp)) != CRYPT_OK) { goto ERR_MU; } ------------------ | Branch (159:13): [True: 0, False: 43.2k] ------------------ 160| 43.2k| if ((err = ltc_mp.ecc_ptdbl(C, C, modulus, mp)) != CRYPT_OK) { goto ERR_MU; } ------------------ | Branch (160:13): [True: 0, False: 43.2k] ------------------ 161| 43.2k| } 162| | 163| | /* if not both zero */ 164| 43.4k| if ((nA != 0) || (nB != 0)) { ------------------ | Branch (164:10): [True: 32.6k, False: 10.8k] | Branch (164:23): [True: 6.79k, False: 4.04k] ------------------ 165| 39.4k| if (first == 1) { ------------------ | Branch (165:13): [True: 260, False: 39.1k] ------------------ 166| | /* if first, copy from table */ 167| 260| first = 0; 168| 260| if ((err = mp_copy(precomp[nA + (nB<<2)]->x, C->x)) != CRYPT_OK) { goto ERR_MU; } ------------------ | | 524| 260|#define mp_copy(a, b) ltc_mp.copy(a, b) ------------------ | Branch (168:16): [True: 0, False: 260] ------------------ 169| 260| if ((err = mp_copy(precomp[nA + (nB<<2)]->y, C->y)) != CRYPT_OK) { goto ERR_MU; } ------------------ | | 524| 260|#define mp_copy(a, b) ltc_mp.copy(a, b) ------------------ | Branch (169:16): [True: 0, False: 260] ------------------ 170| 260| if ((err = mp_copy(precomp[nA + (nB<<2)]->z, C->z)) != CRYPT_OK) { goto ERR_MU; } ------------------ | | 524| 260|#define mp_copy(a, b) ltc_mp.copy(a, b) ------------------ | Branch (170:16): [True: 0, False: 260] ------------------ 171| 39.1k| } else { 172| | /* if not first, add from table */ 173| 39.1k| if ((err = ltc_mp.ecc_ptadd(C, precomp[nA + (nB<<2)], C, modulus, mp)) != CRYPT_OK) { goto ERR_MU; } ------------------ | Branch (173:16): [True: 0, False: 39.1k] ------------------ 174| 39.1k| } 175| 39.4k| } 176| 43.4k| } 177| | 178| | /* reduce to affine */ 179| 260| err = ltc_ecc_map(C, modulus, mp); 180| | 181| | /* clean up */ 182| 260|ERR_MU: 183| 260| mp_clear(mu); ------------------ | | 518| 260|#define mp_clear(a) ltc_mp.deinit(a) ------------------ 184| 260|ERR_MP: 185| 260| mp_montgomery_free(mp); ------------------ | | 566| 260|#define mp_montgomery_free(a) ltc_mp.montgomery_deinit(a) ------------------ 186| 260|ERR_P: 187| 4.42k| for (x = 0; x < 16; x++) { ------------------ | Branch (187:16): [True: 4.16k, False: 260] ------------------ 188| 4.16k| ltc_ecc_del_point(precomp[x]); 189| 4.16k| } 190| 260|ERR_T: 191| |#ifdef LTC_CLEAN_STACK 192| | zeromem(tA, ECC_BUF_SIZE); 193| | zeromem(tB, ECC_BUF_SIZE); 194| |#endif 195| 260| XFREE(tA); ------------------ | | 17| 260|#define XFREE m_free_direct ------------------ 196| 260| XFREE(tB); ------------------ | | 17| 260|#define XFREE m_free_direct ------------------ 197| | 198| 260| return err; 199| 260|} ltc_ecc_new_point: 29| 4.77k|{ 30| 4.77k| ecc_point *p; 31| 4.77k| p = XCALLOC(1, sizeof(*p)); ------------------ | | 19| 4.77k|#define XCALLOC m_calloc ------------------ 32| 4.77k| if (p == NULL) { ------------------ | Branch (32:8): [True: 0, False: 4.77k] ------------------ 33| 0| return NULL; 34| 0| } 35| 4.77k| if (mp_init_multi(&p->x, &p->y, &p->z, NULL) != CRYPT_OK) { ------------------ | | 517| 4.77k|#define mp_init_multi ltc_init_multi ------------------ | Branch (35:8): [True: 0, False: 4.77k] ------------------ 36| 0| XFREE(p); ------------------ | | 17| 0|#define XFREE m_free_direct ------------------ 37| 0| return NULL; 38| 0| } 39| 4.77k| return p; 40| 4.77k|} ltc_ecc_del_point: 46| 4.76k|{ 47| | /* prevents free'ing null arguments */ 48| 4.76k| if (p != NULL) { ------------------ | Branch (48:8): [True: 4.76k, False: 0] ------------------ 49| 4.76k| mp_clear_multi(p->x, p->y, p->z, NULL); /* note: p->z may be NULL but that's ok with this function anyways */ ------------------ | | 519| 4.76k|#define mp_clear_multi ltc_deinit_multi ------------------ 50| 4.76k| XFREE(p); ------------------ | | 17| 4.76k|#define XFREE m_free_direct ------------------ 51| 4.76k| } 52| 4.76k|} ltc_ecc_projective_add_point: 34| 42.0k|{ 35| 42.0k| void *t1, *t2, *x, *y, *z; 36| 42.0k| int err; 37| | 38| 42.0k| LTC_ARGCHK(P != NULL); ------------------ | | 32| 42.0k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 42.0k] | | | Branch (32:87): [Folded, False: 42.0k] | | ------------------ ------------------ 39| 42.0k| LTC_ARGCHK(Q != NULL); ------------------ | | 32| 42.0k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 42.0k] | | | Branch (32:87): [Folded, False: 42.0k] | | ------------------ ------------------ 40| 42.0k| LTC_ARGCHK(R != NULL); ------------------ | | 32| 42.0k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 42.0k] | | | Branch (32:87): [Folded, False: 42.0k] | | ------------------ ------------------ 41| 42.0k| LTC_ARGCHK(modulus != NULL); ------------------ | | 32| 42.0k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 42.0k] | | | Branch (32:87): [Folded, False: 42.0k] | | ------------------ ------------------ 42| 42.0k| LTC_ARGCHK(mp != NULL); ------------------ | | 32| 42.0k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 42.0k] | | | Branch (32:87): [Folded, False: 42.0k] | | ------------------ ------------------ 43| | 44| 42.0k| if ((err = mp_init_multi(&t1, &t2, &x, &y, &z, NULL)) != CRYPT_OK) { ------------------ | | 517| 42.0k|#define mp_init_multi ltc_init_multi ------------------ | Branch (44:8): [True: 0, False: 42.0k] ------------------ 45| 0| return err; 46| 0| } 47| | 48| | /* should we dbl instead? */ 49| 42.0k| if ((err = mp_sub(modulus, Q->y, t1)) != CRYPT_OK) { goto done; } ------------------ | | 545| 42.0k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (49:8): [True: 0, False: 42.0k] ------------------ 50| | 51| 42.0k| if ( (mp_cmp(P->x, Q->x) == LTC_MP_EQ) && ------------------ | | 531| 42.0k|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ if ( (mp_cmp(P->x, Q->x) == LTC_MP_EQ) && ------------------ | | 13| 42.0k|#define LTC_MP_EQ 0 ------------------ | Branch (51:9): [True: 0, False: 42.0k] ------------------ 52| 0| (Q->z != NULL && mp_cmp(P->z, Q->z) == LTC_MP_EQ) && ------------------ | | 531| 0|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ (Q->z != NULL && mp_cmp(P->z, Q->z) == LTC_MP_EQ) && ------------------ | | 13| 0|#define LTC_MP_EQ 0 ------------------ | Branch (52:10): [True: 0, False: 0] | Branch (52:26): [True: 0, False: 0] ------------------ 53| 0| (mp_cmp(P->y, Q->y) == LTC_MP_EQ || mp_cmp(P->y, t1) == LTC_MP_EQ)) { ------------------ | | 531| 0|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ (mp_cmp(P->y, Q->y) == LTC_MP_EQ || mp_cmp(P->y, t1) == LTC_MP_EQ)) { ------------------ | | 13| 0|#define LTC_MP_EQ 0 ------------------ (mp_cmp(P->y, Q->y) == LTC_MP_EQ || mp_cmp(P->y, t1) == LTC_MP_EQ)) { ------------------ | | 531| 0|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ (mp_cmp(P->y, Q->y) == LTC_MP_EQ || mp_cmp(P->y, t1) == LTC_MP_EQ)) { ------------------ | | 13| 0|#define LTC_MP_EQ 0 ------------------ | Branch (53:10): [True: 0, False: 0] | Branch (53:45): [True: 0, False: 0] ------------------ 54| 0| mp_clear_multi(t1, t2, x, y, z, NULL); ------------------ | | 519| 0|#define mp_clear_multi ltc_deinit_multi ------------------ 55| 0| return ltc_ecc_projective_dbl_point(P, R, modulus, mp); 56| 0| } 57| | 58| 42.0k| if ((err = mp_copy(P->x, x)) != CRYPT_OK) { goto done; } ------------------ | | 524| 42.0k|#define mp_copy(a, b) ltc_mp.copy(a, b) ------------------ | Branch (58:8): [True: 0, False: 42.0k] ------------------ 59| 42.0k| if ((err = mp_copy(P->y, y)) != CRYPT_OK) { goto done; } ------------------ | | 524| 42.0k|#define mp_copy(a, b) ltc_mp.copy(a, b) ------------------ | Branch (59:8): [True: 0, False: 42.0k] ------------------ 60| 42.0k| if ((err = mp_copy(P->z, z)) != CRYPT_OK) { goto done; } ------------------ | | 524| 42.0k|#define mp_copy(a, b) ltc_mp.copy(a, b) ------------------ | Branch (60:8): [True: 0, False: 42.0k] ------------------ 61| | 62| | /* if Z is one then these are no-operations */ 63| 42.0k| if (Q->z != NULL) { ------------------ | Branch (63:8): [True: 42.0k, False: 0] ------------------ 64| | /* T1 = Z' * Z' */ 65| 42.0k| if ((err = mp_sqr(Q->z, t1)) != CRYPT_OK) { goto done; } ------------------ | | 549| 42.0k|#define mp_sqr(a, b) ltc_mp.sqr(a, b) ------------------ | Branch (65:11): [True: 0, False: 42.0k] ------------------ 66| 42.0k| if ((err = mp_montgomery_reduce(t1, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (66:11): [True: 0, False: 42.0k] ------------------ 67| | /* X = X * T1 */ 68| 42.0k| if ((err = mp_mul(t1, x, x)) != CRYPT_OK) { goto done; } ------------------ | | 547| 42.0k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (68:11): [True: 0, False: 42.0k] ------------------ 69| 42.0k| if ((err = mp_montgomery_reduce(x, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (69:11): [True: 0, False: 42.0k] ------------------ 70| | /* T1 = Z' * T1 */ 71| 42.0k| if ((err = mp_mul(Q->z, t1, t1)) != CRYPT_OK) { goto done; } ------------------ | | 547| 42.0k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (71:11): [True: 0, False: 42.0k] ------------------ 72| 42.0k| if ((err = mp_montgomery_reduce(t1, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (72:11): [True: 0, False: 42.0k] ------------------ 73| | /* Y = Y * T1 */ 74| 42.0k| if ((err = mp_mul(t1, y, y)) != CRYPT_OK) { goto done; } ------------------ | | 547| 42.0k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (74:11): [True: 0, False: 42.0k] ------------------ 75| 42.0k| if ((err = mp_montgomery_reduce(y, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (75:11): [True: 0, False: 42.0k] ------------------ 76| 42.0k| } 77| | 78| | /* T1 = Z*Z */ 79| 42.0k| if ((err = mp_sqr(z, t1)) != CRYPT_OK) { goto done; } ------------------ | | 549| 42.0k|#define mp_sqr(a, b) ltc_mp.sqr(a, b) ------------------ | Branch (79:8): [True: 0, False: 42.0k] ------------------ 80| 42.0k| if ((err = mp_montgomery_reduce(t1, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (80:8): [True: 0, False: 42.0k] ------------------ 81| | /* T2 = X' * T1 */ 82| 42.0k| if ((err = mp_mul(Q->x, t1, t2)) != CRYPT_OK) { goto done; } ------------------ | | 547| 42.0k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (82:8): [True: 0, False: 42.0k] ------------------ 83| 42.0k| if ((err = mp_montgomery_reduce(t2, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (83:8): [True: 0, False: 42.0k] ------------------ 84| | /* T1 = Z * T1 */ 85| 42.0k| if ((err = mp_mul(z, t1, t1)) != CRYPT_OK) { goto done; } ------------------ | | 547| 42.0k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (85:8): [True: 0, False: 42.0k] ------------------ 86| 42.0k| if ((err = mp_montgomery_reduce(t1, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (86:8): [True: 0, False: 42.0k] ------------------ 87| | /* T1 = Y' * T1 */ 88| 42.0k| if ((err = mp_mul(Q->y, t1, t1)) != CRYPT_OK) { goto done; } ------------------ | | 547| 42.0k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (88:8): [True: 0, False: 42.0k] ------------------ 89| 42.0k| if ((err = mp_montgomery_reduce(t1, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (89:8): [True: 0, False: 42.0k] ------------------ 90| | 91| | /* Y = Y - T1 */ 92| 42.0k| if ((err = mp_sub(y, t1, y)) != CRYPT_OK) { goto done; } ------------------ | | 545| 42.0k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (92:8): [True: 0, False: 42.0k] ------------------ 93| 42.0k| if (mp_cmp_d(y, 0) == LTC_MP_LT) { ------------------ | | 532| 42.0k|#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) ------------------ if (mp_cmp_d(y, 0) == LTC_MP_LT) { ------------------ | | 12| 42.0k|#define LTC_MP_LT -1 ------------------ | Branch (93:8): [True: 20.8k, False: 21.1k] ------------------ 94| 20.8k| if ((err = mp_add(y, modulus, y)) != CRYPT_OK) { goto done; } ------------------ | | 543| 20.8k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (94:11): [True: 0, False: 20.8k] ------------------ 95| 20.8k| } 96| | /* T1 = 2T1 */ 97| 42.0k| if ((err = mp_add(t1, t1, t1)) != CRYPT_OK) { goto done; } ------------------ | | 543| 42.0k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (97:8): [True: 0, False: 42.0k] ------------------ 98| 42.0k| if (mp_cmp(t1, modulus) != LTC_MP_LT) { ------------------ | | 531| 42.0k|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ if (mp_cmp(t1, modulus) != LTC_MP_LT) { ------------------ | | 12| 42.0k|#define LTC_MP_LT -1 ------------------ | Branch (98:8): [True: 21.1k, False: 20.8k] ------------------ 99| 21.1k| if ((err = mp_sub(t1, modulus, t1)) != CRYPT_OK) { goto done; } ------------------ | | 545| 21.1k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (99:11): [True: 0, False: 21.1k] ------------------ 100| 21.1k| } 101| | /* T1 = Y + T1 */ 102| 42.0k| if ((err = mp_add(t1, y, t1)) != CRYPT_OK) { goto done; } ------------------ | | 543| 42.0k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (102:8): [True: 0, False: 42.0k] ------------------ 103| 42.0k| if (mp_cmp(t1, modulus) != LTC_MP_LT) { ------------------ | | 531| 42.0k|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ if (mp_cmp(t1, modulus) != LTC_MP_LT) { ------------------ | | 12| 42.0k|#define LTC_MP_LT -1 ------------------ | Branch (103:8): [True: 20.5k, False: 21.5k] ------------------ 104| 20.5k| if ((err = mp_sub(t1, modulus, t1)) != CRYPT_OK) { goto done; } ------------------ | | 545| 20.5k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (104:11): [True: 0, False: 20.5k] ------------------ 105| 20.5k| } 106| | /* X = X - T2 */ 107| 42.0k| if ((err = mp_sub(x, t2, x)) != CRYPT_OK) { goto done; } ------------------ | | 545| 42.0k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (107:8): [True: 0, False: 42.0k] ------------------ 108| 42.0k| if (mp_cmp_d(x, 0) == LTC_MP_LT) { ------------------ | | 532| 42.0k|#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) ------------------ if (mp_cmp_d(x, 0) == LTC_MP_LT) { ------------------ | | 12| 42.0k|#define LTC_MP_LT -1 ------------------ | Branch (108:8): [True: 21.2k, False: 20.7k] ------------------ 109| 21.2k| if ((err = mp_add(x, modulus, x)) != CRYPT_OK) { goto done; } ------------------ | | 543| 21.2k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (109:11): [True: 0, False: 21.2k] ------------------ 110| 21.2k| } 111| | /* T2 = 2T2 */ 112| 42.0k| if ((err = mp_add(t2, t2, t2)) != CRYPT_OK) { goto done; } ------------------ | | 543| 42.0k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (112:8): [True: 0, False: 42.0k] ------------------ 113| 42.0k| if (mp_cmp(t2, modulus) != LTC_MP_LT) { ------------------ | | 531| 42.0k|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ if (mp_cmp(t2, modulus) != LTC_MP_LT) { ------------------ | | 12| 42.0k|#define LTC_MP_LT -1 ------------------ | Branch (113:8): [True: 21.0k, False: 20.9k] ------------------ 114| 21.0k| if ((err = mp_sub(t2, modulus, t2)) != CRYPT_OK) { goto done; } ------------------ | | 545| 21.0k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (114:11): [True: 0, False: 21.0k] ------------------ 115| 21.0k| } 116| | /* T2 = X + T2 */ 117| 42.0k| if ((err = mp_add(t2, x, t2)) != CRYPT_OK) { goto done; } ------------------ | | 543| 42.0k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (117:8): [True: 0, False: 42.0k] ------------------ 118| 42.0k| if (mp_cmp(t2, modulus) != LTC_MP_LT) { ------------------ | | 531| 42.0k|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ if (mp_cmp(t2, modulus) != LTC_MP_LT) { ------------------ | | 12| 42.0k|#define LTC_MP_LT -1 ------------------ | Branch (118:8): [True: 20.7k, False: 21.2k] ------------------ 119| 20.7k| if ((err = mp_sub(t2, modulus, t2)) != CRYPT_OK) { goto done; } ------------------ | | 545| 20.7k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (119:11): [True: 0, False: 20.7k] ------------------ 120| 20.7k| } 121| | 122| | /* if Z' != 1 */ 123| 42.0k| if (Q->z != NULL) { ------------------ | Branch (123:8): [True: 42.0k, False: 0] ------------------ 124| | /* Z = Z * Z' */ 125| 42.0k| if ((err = mp_mul(z, Q->z, z)) != CRYPT_OK) { goto done; } ------------------ | | 547| 42.0k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (125:11): [True: 0, False: 42.0k] ------------------ 126| 42.0k| if ((err = mp_montgomery_reduce(z, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (126:11): [True: 0, False: 42.0k] ------------------ 127| 42.0k| } 128| | 129| | /* Z = Z * X */ 130| 42.0k| if ((err = mp_mul(z, x, z)) != CRYPT_OK) { goto done; } ------------------ | | 547| 42.0k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (130:8): [True: 0, False: 42.0k] ------------------ 131| 42.0k| if ((err = mp_montgomery_reduce(z, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (131:8): [True: 0, False: 42.0k] ------------------ 132| | 133| | /* T1 = T1 * X */ 134| 42.0k| if ((err = mp_mul(t1, x, t1)) != CRYPT_OK) { goto done; } ------------------ | | 547| 42.0k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (134:8): [True: 0, False: 42.0k] ------------------ 135| 42.0k| if ((err = mp_montgomery_reduce(t1, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (135:8): [True: 0, False: 42.0k] ------------------ 136| | /* X = X * X */ 137| 42.0k| if ((err = mp_sqr(x, x)) != CRYPT_OK) { goto done; } ------------------ | | 549| 42.0k|#define mp_sqr(a, b) ltc_mp.sqr(a, b) ------------------ | Branch (137:8): [True: 0, False: 42.0k] ------------------ 138| 42.0k| if ((err = mp_montgomery_reduce(x, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (138:8): [True: 0, False: 42.0k] ------------------ 139| | /* T2 = T2 * x */ 140| 42.0k| if ((err = mp_mul(t2, x, t2)) != CRYPT_OK) { goto done; } ------------------ | | 547| 42.0k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (140:8): [True: 0, False: 42.0k] ------------------ 141| 42.0k| if ((err = mp_montgomery_reduce(t2, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (141:8): [True: 0, False: 42.0k] ------------------ 142| | /* T1 = T1 * X */ 143| 42.0k| if ((err = mp_mul(t1, x, t1)) != CRYPT_OK) { goto done; } ------------------ | | 547| 42.0k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (143:8): [True: 0, False: 42.0k] ------------------ 144| 42.0k| if ((err = mp_montgomery_reduce(t1, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (144:8): [True: 0, False: 42.0k] ------------------ 145| | 146| | /* X = Y*Y */ 147| 42.0k| if ((err = mp_sqr(y, x)) != CRYPT_OK) { goto done; } ------------------ | | 549| 42.0k|#define mp_sqr(a, b) ltc_mp.sqr(a, b) ------------------ | Branch (147:8): [True: 0, False: 42.0k] ------------------ 148| 42.0k| if ((err = mp_montgomery_reduce(x, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (148:8): [True: 0, False: 42.0k] ------------------ 149| | /* X = X - T2 */ 150| 42.0k| if ((err = mp_sub(x, t2, x)) != CRYPT_OK) { goto done; } ------------------ | | 545| 42.0k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (150:8): [True: 0, False: 42.0k] ------------------ 151| 42.0k| if (mp_cmp_d(x, 0) == LTC_MP_LT) { ------------------ | | 532| 42.0k|#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) ------------------ if (mp_cmp_d(x, 0) == LTC_MP_LT) { ------------------ | | 12| 42.0k|#define LTC_MP_LT -1 ------------------ | Branch (151:8): [True: 20.5k, False: 21.4k] ------------------ 152| 20.5k| if ((err = mp_add(x, modulus, x)) != CRYPT_OK) { goto done; } ------------------ | | 543| 20.5k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (152:11): [True: 0, False: 20.5k] ------------------ 153| 20.5k| } 154| | 155| | /* T2 = T2 - X */ 156| 42.0k| if ((err = mp_sub(t2, x, t2)) != CRYPT_OK) { goto done; } ------------------ | | 545| 42.0k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (156:8): [True: 0, False: 42.0k] ------------------ 157| 42.0k| if (mp_cmp_d(t2, 0) == LTC_MP_LT) { ------------------ | | 532| 42.0k|#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) ------------------ if (mp_cmp_d(t2, 0) == LTC_MP_LT) { ------------------ | | 12| 42.0k|#define LTC_MP_LT -1 ------------------ | Branch (157:8): [True: 20.8k, False: 21.2k] ------------------ 158| 20.8k| if ((err = mp_add(t2, modulus, t2)) != CRYPT_OK) { goto done; } ------------------ | | 543| 20.8k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (158:11): [True: 0, False: 20.8k] ------------------ 159| 20.8k| } 160| | /* T2 = T2 - X */ 161| 42.0k| if ((err = mp_sub(t2, x, t2)) != CRYPT_OK) { goto done; } ------------------ | | 545| 42.0k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (161:8): [True: 0, False: 42.0k] ------------------ 162| 42.0k| if (mp_cmp_d(t2, 0) == LTC_MP_LT) { ------------------ | | 532| 42.0k|#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) ------------------ if (mp_cmp_d(t2, 0) == LTC_MP_LT) { ------------------ | | 12| 42.0k|#define LTC_MP_LT -1 ------------------ | Branch (162:8): [True: 21.0k, False: 21.0k] ------------------ 163| 21.0k| if ((err = mp_add(t2, modulus, t2)) != CRYPT_OK) { goto done; } ------------------ | | 543| 21.0k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (163:11): [True: 0, False: 21.0k] ------------------ 164| 21.0k| } 165| | /* T2 = T2 * Y */ 166| 42.0k| if ((err = mp_mul(t2, y, t2)) != CRYPT_OK) { goto done; } ------------------ | | 547| 42.0k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (166:8): [True: 0, False: 42.0k] ------------------ 167| 42.0k| if ((err = mp_montgomery_reduce(t2, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 42.0k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (167:8): [True: 0, False: 42.0k] ------------------ 168| | /* Y = T2 - T1 */ 169| 42.0k| if ((err = mp_sub(t2, t1, y)) != CRYPT_OK) { goto done; } ------------------ | | 545| 42.0k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (169:8): [True: 0, False: 42.0k] ------------------ 170| 42.0k| if (mp_cmp_d(y, 0) == LTC_MP_LT) { ------------------ | | 532| 42.0k|#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) ------------------ if (mp_cmp_d(y, 0) == LTC_MP_LT) { ------------------ | | 12| 42.0k|#define LTC_MP_LT -1 ------------------ | Branch (170:8): [True: 21.0k, False: 21.0k] ------------------ 171| 21.0k| if ((err = mp_add(y, modulus, y)) != CRYPT_OK) { goto done; } ------------------ | | 543| 21.0k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (171:11): [True: 0, False: 21.0k] ------------------ 172| 21.0k| } 173| | /* Y = Y/2 */ 174| 42.0k| if (mp_isodd(y)) { ------------------ | | 572| 42.0k|#define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO) | | ------------------ | | | | 530| 42.0k|#define mp_get_digit_count(a) ltc_mp.get_digit_count(a) | | ------------------ | | #define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO) | | ------------------ | | | | 529| 42.0k|#define mp_get_digit(a, n) ltc_mp.get_digit(a, n) | | ------------------ | | #define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO) | | ------------------ | | | | 17| 21.0k|#define LTC_MP_YES 1 | | ------------------ | | #define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO) | | ------------------ | | | | 16| 21.0k|#define LTC_MP_NO 0 | | ------------------ | | #define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO) | | ------------------ | | | | 16| 0|#define LTC_MP_NO 0 | | ------------------ | | | Branch (572:38): [True: 21.0k, False: 21.0k] | | | Branch (572:39): [True: 42.0k, False: 0] | | | Branch (572:68): [True: 21.0k, False: 21.0k] | | ------------------ ------------------ 175| 21.0k| if ((err = mp_add(y, modulus, y)) != CRYPT_OK) { goto done; } ------------------ | | 543| 21.0k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (175:11): [True: 0, False: 21.0k] ------------------ 176| 21.0k| } 177| 42.0k| if ((err = mp_div_2(y, y)) != CRYPT_OK) { goto done; } ------------------ | | 551| 42.0k|#define mp_div_2(a, b) ltc_mp.div_2(a, b) ------------------ | Branch (177:8): [True: 0, False: 42.0k] ------------------ 178| | 179| 42.0k| if ((err = mp_copy(x, R->x)) != CRYPT_OK) { goto done; } ------------------ | | 524| 42.0k|#define mp_copy(a, b) ltc_mp.copy(a, b) ------------------ | Branch (179:8): [True: 0, False: 42.0k] ------------------ 180| 42.0k| if ((err = mp_copy(y, R->y)) != CRYPT_OK) { goto done; } ------------------ | | 524| 42.0k|#define mp_copy(a, b) ltc_mp.copy(a, b) ------------------ | Branch (180:8): [True: 0, False: 42.0k] ------------------ 181| 42.0k| if ((err = mp_copy(z, R->z)) != CRYPT_OK) { goto done; } ------------------ | | 524| 42.0k|#define mp_copy(a, b) ltc_mp.copy(a, b) ------------------ | Branch (181:8): [True: 0, False: 42.0k] ------------------ 182| | 183| 42.0k| err = CRYPT_OK; 184| 42.0k|done: 185| 42.0k| mp_clear_multi(t1, t2, x, y, z, NULL); ------------------ | | 519| 42.0k|#define mp_clear_multi ltc_deinit_multi ------------------ 186| 42.0k| return err; 187| 42.0k|} ltc_ecc_projective_dbl_point: 33| 86.9k|{ 34| 86.9k| void *t1, *t2; 35| 86.9k| int err; 36| | 37| 86.9k| LTC_ARGCHK(P != NULL); ------------------ | | 32| 86.9k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 86.9k] | | | Branch (32:87): [Folded, False: 86.9k] | | ------------------ ------------------ 38| 86.9k| LTC_ARGCHK(R != NULL); ------------------ | | 32| 86.9k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 86.9k] | | | Branch (32:87): [Folded, False: 86.9k] | | ------------------ ------------------ 39| 86.9k| LTC_ARGCHK(modulus != NULL); ------------------ | | 32| 86.9k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 86.9k] | | | Branch (32:87): [Folded, False: 86.9k] | | ------------------ ------------------ 40| 86.9k| LTC_ARGCHK(mp != NULL); ------------------ | | 32| 86.9k|#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) | | ------------------ | | | Branch (32:32): [True: 0, False: 86.9k] | | | Branch (32:87): [Folded, False: 86.9k] | | ------------------ ------------------ 41| | 42| 86.9k| if ((err = mp_init_multi(&t1, &t2, NULL)) != CRYPT_OK) { ------------------ | | 517| 86.9k|#define mp_init_multi ltc_init_multi ------------------ | Branch (42:8): [True: 0, False: 86.9k] ------------------ 43| 0| return err; 44| 0| } 45| | 46| 86.9k| if (P != R) { ------------------ | Branch (46:8): [True: 520, False: 86.4k] ------------------ 47| 520| if ((err = mp_copy(P->x, R->x)) != CRYPT_OK) { goto done; } ------------------ | | 524| 520|#define mp_copy(a, b) ltc_mp.copy(a, b) ------------------ | Branch (47:11): [True: 0, False: 520] ------------------ 48| 520| if ((err = mp_copy(P->y, R->y)) != CRYPT_OK) { goto done; } ------------------ | | 524| 520|#define mp_copy(a, b) ltc_mp.copy(a, b) ------------------ | Branch (48:11): [True: 0, False: 520] ------------------ 49| 520| if ((err = mp_copy(P->z, R->z)) != CRYPT_OK) { goto done; } ------------------ | | 524| 520|#define mp_copy(a, b) ltc_mp.copy(a, b) ------------------ | Branch (49:11): [True: 0, False: 520] ------------------ 50| 520| } 51| | 52| | /* t1 = Z * Z */ 53| 86.9k| if ((err = mp_sqr(R->z, t1)) != CRYPT_OK) { goto done; } ------------------ | | 549| 86.9k|#define mp_sqr(a, b) ltc_mp.sqr(a, b) ------------------ | Branch (53:8): [True: 0, False: 86.9k] ------------------ 54| 86.9k| if ((err = mp_montgomery_reduce(t1, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 86.9k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (54:8): [True: 0, False: 86.9k] ------------------ 55| | /* Z = Y * Z */ 56| 86.9k| if ((err = mp_mul(R->z, R->y, R->z)) != CRYPT_OK) { goto done; } ------------------ | | 547| 86.9k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (56:8): [True: 0, False: 86.9k] ------------------ 57| 86.9k| if ((err = mp_montgomery_reduce(R->z, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 86.9k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (57:8): [True: 0, False: 86.9k] ------------------ 58| | /* Z = 2Z */ 59| 86.9k| if ((err = mp_add(R->z, R->z, R->z)) != CRYPT_OK) { goto done; } ------------------ | | 543| 86.9k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (59:8): [True: 0, False: 86.9k] ------------------ 60| 86.9k| if (mp_cmp(R->z, modulus) != LTC_MP_LT) { ------------------ | | 531| 86.9k|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ if (mp_cmp(R->z, modulus) != LTC_MP_LT) { ------------------ | | 12| 86.9k|#define LTC_MP_LT -1 ------------------ | Branch (60:8): [True: 43.4k, False: 43.5k] ------------------ 61| 43.4k| if ((err = mp_sub(R->z, modulus, R->z)) != CRYPT_OK) { goto done; } ------------------ | | 545| 43.4k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (61:11): [True: 0, False: 43.4k] ------------------ 62| 43.4k| } 63| | 64| | /* T2 = X - T1 */ 65| 86.9k| if ((err = mp_sub(R->x, t1, t2)) != CRYPT_OK) { goto done; } ------------------ | | 545| 86.9k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (65:8): [True: 0, False: 86.9k] ------------------ 66| 86.9k| if (mp_cmp_d(t2, 0) == LTC_MP_LT) { ------------------ | | 532| 86.9k|#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) ------------------ if (mp_cmp_d(t2, 0) == LTC_MP_LT) { ------------------ | | 12| 86.9k|#define LTC_MP_LT -1 ------------------ | Branch (66:8): [True: 43.4k, False: 43.5k] ------------------ 67| 43.4k| if ((err = mp_add(t2, modulus, t2)) != CRYPT_OK) { goto done; } ------------------ | | 543| 43.4k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (67:11): [True: 0, False: 43.4k] ------------------ 68| 43.4k| } 69| | /* T1 = X + T1 */ 70| 86.9k| if ((err = mp_add(t1, R->x, t1)) != CRYPT_OK) { goto done; } ------------------ | | 543| 86.9k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (70:8): [True: 0, False: 86.9k] ------------------ 71| 86.9k| if (mp_cmp(t1, modulus) != LTC_MP_LT) { ------------------ | | 531| 86.9k|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ if (mp_cmp(t1, modulus) != LTC_MP_LT) { ------------------ | | 12| 86.9k|#define LTC_MP_LT -1 ------------------ | Branch (71:8): [True: 43.2k, False: 43.7k] ------------------ 72| 43.2k| if ((err = mp_sub(t1, modulus, t1)) != CRYPT_OK) { goto done; } ------------------ | | 545| 43.2k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (72:11): [True: 0, False: 43.2k] ------------------ 73| 43.2k| } 74| | /* T2 = T1 * T2 */ 75| 86.9k| if ((err = mp_mul(t1, t2, t2)) != CRYPT_OK) { goto done; } ------------------ | | 547| 86.9k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (75:8): [True: 0, False: 86.9k] ------------------ 76| 86.9k| if ((err = mp_montgomery_reduce(t2, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 86.9k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (76:8): [True: 0, False: 86.9k] ------------------ 77| | /* T1 = 2T2 */ 78| 86.9k| if ((err = mp_add(t2, t2, t1)) != CRYPT_OK) { goto done; } ------------------ | | 543| 86.9k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (78:8): [True: 0, False: 86.9k] ------------------ 79| 86.9k| if (mp_cmp(t1, modulus) != LTC_MP_LT) { ------------------ | | 531| 86.9k|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ if (mp_cmp(t1, modulus) != LTC_MP_LT) { ------------------ | | 12| 86.9k|#define LTC_MP_LT -1 ------------------ | Branch (79:8): [True: 43.8k, False: 43.0k] ------------------ 80| 43.8k| if ((err = mp_sub(t1, modulus, t1)) != CRYPT_OK) { goto done; } ------------------ | | 545| 43.8k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (80:11): [True: 0, False: 43.8k] ------------------ 81| 43.8k| } 82| | /* T1 = T1 + T2 */ 83| 86.9k| if ((err = mp_add(t1, t2, t1)) != CRYPT_OK) { goto done; } ------------------ | | 543| 86.9k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (83:8): [True: 0, False: 86.9k] ------------------ 84| 86.9k| if (mp_cmp(t1, modulus) != LTC_MP_LT) { ------------------ | | 531| 86.9k|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ if (mp_cmp(t1, modulus) != LTC_MP_LT) { ------------------ | | 12| 86.9k|#define LTC_MP_LT -1 ------------------ | Branch (84:8): [True: 43.5k, False: 43.4k] ------------------ 85| 43.5k| if ((err = mp_sub(t1, modulus, t1)) != CRYPT_OK) { goto done; } ------------------ | | 545| 43.5k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (85:11): [True: 0, False: 43.5k] ------------------ 86| 43.5k| } 87| | 88| | /* Y = 2Y */ 89| 86.9k| if ((err = mp_add(R->y, R->y, R->y)) != CRYPT_OK) { goto done; } ------------------ | | 543| 86.9k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (89:8): [True: 0, False: 86.9k] ------------------ 90| 86.9k| if (mp_cmp(R->y, modulus) != LTC_MP_LT) { ------------------ | | 531| 86.9k|#define mp_cmp(a, b) ltc_mp.compare(a, b) ------------------ if (mp_cmp(R->y, modulus) != LTC_MP_LT) { ------------------ | | 12| 86.9k|#define LTC_MP_LT -1 ------------------ | Branch (90:8): [True: 43.2k, False: 43.6k] ------------------ 91| 43.2k| if ((err = mp_sub(R->y, modulus, R->y)) != CRYPT_OK) { goto done; } ------------------ | | 545| 43.2k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (91:11): [True: 0, False: 43.2k] ------------------ 92| 43.2k| } 93| | /* Y = Y * Y */ 94| 86.9k| if ((err = mp_sqr(R->y, R->y)) != CRYPT_OK) { goto done; } ------------------ | | 549| 86.9k|#define mp_sqr(a, b) ltc_mp.sqr(a, b) ------------------ | Branch (94:8): [True: 0, False: 86.9k] ------------------ 95| 86.9k| if ((err = mp_montgomery_reduce(R->y, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 86.9k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (95:8): [True: 0, False: 86.9k] ------------------ 96| | /* T2 = Y * Y */ 97| 86.9k| if ((err = mp_sqr(R->y, t2)) != CRYPT_OK) { goto done; } ------------------ | | 549| 86.9k|#define mp_sqr(a, b) ltc_mp.sqr(a, b) ------------------ | Branch (97:8): [True: 0, False: 86.9k] ------------------ 98| 86.9k| if ((err = mp_montgomery_reduce(t2, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 86.9k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (98:8): [True: 0, False: 86.9k] ------------------ 99| | /* T2 = T2/2 */ 100| 86.9k| if (mp_isodd(t2)) { ------------------ | | 572| 86.9k|#define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO) | | ------------------ | | | | 530| 86.9k|#define mp_get_digit_count(a) ltc_mp.get_digit_count(a) | | ------------------ | | #define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO) | | ------------------ | | | | 529| 86.9k|#define mp_get_digit(a, n) ltc_mp.get_digit(a, n) | | ------------------ | | #define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO) | | ------------------ | | | | 17| 43.8k|#define LTC_MP_YES 1 | | ------------------ | | #define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO) | | ------------------ | | | | 16| 43.0k|#define LTC_MP_NO 0 | | ------------------ | | #define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO) | | ------------------ | | | | 16| 0|#define LTC_MP_NO 0 | | ------------------ | | | Branch (572:38): [True: 43.8k, False: 43.0k] | | | Branch (572:39): [True: 86.9k, False: 0] | | | Branch (572:68): [True: 43.8k, False: 43.0k] | | ------------------ ------------------ 101| 43.8k| if ((err = mp_add(t2, modulus, t2)) != CRYPT_OK) { goto done; } ------------------ | | 543| 43.8k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (101:11): [True: 0, False: 43.8k] ------------------ 102| 43.8k| } 103| 86.9k| if ((err = mp_div_2(t2, t2)) != CRYPT_OK) { goto done; } ------------------ | | 551| 86.9k|#define mp_div_2(a, b) ltc_mp.div_2(a, b) ------------------ | Branch (103:8): [True: 0, False: 86.9k] ------------------ 104| | /* Y = Y * X */ 105| 86.9k| if ((err = mp_mul(R->y, R->x, R->y)) != CRYPT_OK) { goto done; } ------------------ | | 547| 86.9k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (105:8): [True: 0, False: 86.9k] ------------------ 106| 86.9k| if ((err = mp_montgomery_reduce(R->y, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 86.9k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (106:8): [True: 0, False: 86.9k] ------------------ 107| | 108| | /* X = T1 * T1 */ 109| 86.9k| if ((err = mp_sqr(t1, R->x)) != CRYPT_OK) { goto done; } ------------------ | | 549| 86.9k|#define mp_sqr(a, b) ltc_mp.sqr(a, b) ------------------ | Branch (109:8): [True: 0, False: 86.9k] ------------------ 110| 86.9k| if ((err = mp_montgomery_reduce(R->x, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 86.9k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (110:8): [True: 0, False: 86.9k] ------------------ 111| | /* X = X - Y */ 112| 86.9k| if ((err = mp_sub(R->x, R->y, R->x)) != CRYPT_OK) { goto done; } ------------------ | | 545| 86.9k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (112:8): [True: 0, False: 86.9k] ------------------ 113| 86.9k| if (mp_cmp_d(R->x, 0) == LTC_MP_LT) { ------------------ | | 532| 86.9k|#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) ------------------ if (mp_cmp_d(R->x, 0) == LTC_MP_LT) { ------------------ | | 12| 86.9k|#define LTC_MP_LT -1 ------------------ | Branch (113:8): [True: 43.3k, False: 43.5k] ------------------ 114| 43.3k| if ((err = mp_add(R->x, modulus, R->x)) != CRYPT_OK) { goto done; } ------------------ | | 543| 43.3k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (114:11): [True: 0, False: 43.3k] ------------------ 115| 43.3k| } 116| | /* X = X - Y */ 117| 86.9k| if ((err = mp_sub(R->x, R->y, R->x)) != CRYPT_OK) { goto done; } ------------------ | | 545| 86.9k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (117:8): [True: 0, False: 86.9k] ------------------ 118| 86.9k| if (mp_cmp_d(R->x, 0) == LTC_MP_LT) { ------------------ | | 532| 86.9k|#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) ------------------ if (mp_cmp_d(R->x, 0) == LTC_MP_LT) { ------------------ | | 12| 86.9k|#define LTC_MP_LT -1 ------------------ | Branch (118:8): [True: 43.2k, False: 43.6k] ------------------ 119| 43.2k| if ((err = mp_add(R->x, modulus, R->x)) != CRYPT_OK) { goto done; } ------------------ | | 543| 43.2k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (119:11): [True: 0, False: 43.2k] ------------------ 120| 43.2k| } 121| | 122| | /* Y = Y - X */ 123| 86.9k| if ((err = mp_sub(R->y, R->x, R->y)) != CRYPT_OK) { goto done; } ------------------ | | 545| 86.9k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (123:8): [True: 0, False: 86.9k] ------------------ 124| 86.9k| if (mp_cmp_d(R->y, 0) == LTC_MP_LT) { ------------------ | | 532| 86.9k|#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) ------------------ if (mp_cmp_d(R->y, 0) == LTC_MP_LT) { ------------------ | | 12| 86.9k|#define LTC_MP_LT -1 ------------------ | Branch (124:8): [True: 43.8k, False: 43.0k] ------------------ 125| 43.8k| if ((err = mp_add(R->y, modulus, R->y)) != CRYPT_OK) { goto done; } ------------------ | | 543| 43.8k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (125:11): [True: 0, False: 43.8k] ------------------ 126| 43.8k| } 127| | /* Y = Y * T1 */ 128| 86.9k| if ((err = mp_mul(R->y, t1, R->y)) != CRYPT_OK) { goto done; } ------------------ | | 547| 86.9k|#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) ------------------ | Branch (128:8): [True: 0, False: 86.9k] ------------------ 129| 86.9k| if ((err = mp_montgomery_reduce(R->y, modulus, mp)) != CRYPT_OK) { goto done; } ------------------ | | 565| 86.9k|#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) ------------------ | Branch (129:8): [True: 0, False: 86.9k] ------------------ 130| | /* Y = Y - T2 */ 131| 86.9k| if ((err = mp_sub(R->y, t2, R->y)) != CRYPT_OK) { goto done; } ------------------ | | 545| 86.9k|#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) ------------------ | Branch (131:8): [True: 0, False: 86.9k] ------------------ 132| 86.9k| if (mp_cmp_d(R->y, 0) == LTC_MP_LT) { ------------------ | | 532| 86.9k|#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) ------------------ if (mp_cmp_d(R->y, 0) == LTC_MP_LT) { ------------------ | | 12| 86.9k|#define LTC_MP_LT -1 ------------------ | Branch (132:8): [True: 43.8k, False: 43.0k] ------------------ 133| 43.8k| if ((err = mp_add(R->y, modulus, R->y)) != CRYPT_OK) { goto done; } ------------------ | | 543| 43.8k|#define mp_add(a, b, c) ltc_mp.add(a, b, c) ------------------ | Branch (133:11): [True: 0, False: 43.8k] ------------------ 134| 43.8k| } 135| | 136| 86.9k| err = CRYPT_OK; 137| 86.9k|done: 138| 86.9k| mp_clear_multi(t1, t2, NULL); ------------------ | | 519| 86.9k|#define mp_clear_multi ltc_deinit_multi ------------------ 139| 86.9k| return err; 140| 86.9k|} mp_2expt: 12| 3.54k|{ 13| 3.54k| mp_err err; 14| | 15| 3.54k| if (b < 0) { ------------------ | Branch (15:8): [True: 0, False: 3.54k] ------------------ 16| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 17| 0| } 18| | 19| | /* zero a as per default */ 20| 3.54k| mp_zero(a); 21| | 22| | /* grow a to accomodate the single bit */ 23| 3.54k| if ((err = mp_grow(a, (b / MP_DIGIT_BIT) + 1)) != MP_OKAY) { ------------------ | | 82| 3.54k|# define MP_DIGIT_BIT 60 ------------------ if ((err = mp_grow(a, (b / MP_DIGIT_BIT) + 1)) != MP_OKAY) { ------------------ | | 161| 3.54k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (23:8): [True: 0, False: 3.54k] ------------------ 24| 0| return err; 25| 0| } 26| | 27| | /* set the used count of where the bit will go */ 28| 3.54k| a->used = (b / MP_DIGIT_BIT) + 1; ------------------ | | 82| 3.54k|# define MP_DIGIT_BIT 60 ------------------ 29| | 30| | /* put the single bit in its place */ 31| 3.54k| a->dp[b / MP_DIGIT_BIT] = (mp_digit)1 << (mp_digit)(b % MP_DIGIT_BIT); ------------------ | | 82| 3.54k|# define MP_DIGIT_BIT 60 ------------------ a->dp[b / MP_DIGIT_BIT] = (mp_digit)1 << (mp_digit)(b % MP_DIGIT_BIT); ------------------ | | 82| 3.54k|# define MP_DIGIT_BIT 60 ------------------ 32| | 33| 3.54k| return MP_OKAY; ------------------ | | 161| 3.54k|#define MP_OKAY 0 /* no error */ ------------------ 34| 3.54k|} mp_add: 8| 1.02M|{ 9| 1.02M| mp_sign sa, sb; 10| 1.02M| mp_err err; 11| | 12| | /* get sign of both inputs */ 13| 1.02M| sa = a->sign; 14| 1.02M| sb = b->sign; 15| | 16| | /* handle two cases, not four */ 17| 1.02M| if (sa == sb) { ------------------ | Branch (17:8): [True: 673k, False: 354k] ------------------ 18| | /* both positive or both negative */ 19| | /* add their magnitudes, copy the sign */ 20| 673k| c->sign = sa; 21| 673k| err = s_mp_add(a, b, c); 22| 673k| } else { 23| | /* one positive, the other negative */ 24| | /* subtract the one with the greater magnitude from */ 25| | /* the one of the lesser magnitude. The result gets */ 26| | /* the sign of the one with the greater magnitude. */ 27| 354k| if (mp_cmp_mag(a, b) == MP_LT) { ------------------ | | 154| 354k|#define MP_LT -1 /* less than */ ------------------ | Branch (27:11): [True: 353k, False: 1.64k] ------------------ 28| 353k| c->sign = sb; 29| 353k| err = s_mp_sub(b, a, c); 30| 353k| } else { 31| 1.64k| c->sign = sa; 32| 1.64k| err = s_mp_sub(a, b, c); 33| 1.64k| } 34| 354k| } 35| 1.02M| return err; 36| 1.02M|} mp_add_d: 8| 166k|{ 9| 166k| mp_err err; 10| 166k| int ix, oldused; 11| 166k| mp_digit *tmpa, *tmpc; 12| | 13| | /* grow c as required */ 14| 166k| if (c->alloc < (a->used + 1)) { ------------------ | Branch (14:8): [True: 0, False: 166k] ------------------ 15| 0| if ((err = mp_grow(c, a->used + 1)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (15:11): [True: 0, False: 0] ------------------ 16| 0| return err; 17| 0| } 18| 0| } 19| | 20| | /* if a is negative and |a| >= b, call c = |a| - b */ 21| 166k| if ((a->sign == MP_NEG) && ((a->used > 1) || (a->dp[0] >= b))) { ------------------ | | 152| 166k|#define MP_NEG 1 /* negative */ ------------------ | Branch (21:8): [True: 0, False: 166k] | Branch (21:32): [True: 0, False: 0] | Branch (21:49): [True: 0, False: 0] ------------------ 22| 0| mp_int a_ = *a; 23| | /* temporarily fix sign of a */ 24| 0| a_.sign = MP_ZPOS; ------------------ | | 151| 0|#define MP_ZPOS 0 /* positive integer */ ------------------ 25| | 26| | /* c = |a| - b */ 27| 0| err = mp_sub_d(&a_, b, c); 28| | 29| | /* fix sign */ 30| 0| c->sign = MP_NEG; ------------------ | | 152| 0|#define MP_NEG 1 /* negative */ ------------------ 31| | 32| | /* clamp */ 33| 0| mp_clamp(c); 34| | 35| 0| return err; 36| 0| } 37| | 38| | /* old number of used digits in c */ 39| 166k| oldused = c->used; 40| | 41| | /* source alias */ 42| 166k| tmpa = a->dp; 43| | 44| | /* destination alias */ 45| 166k| tmpc = c->dp; 46| | 47| | /* if a is positive */ 48| 166k| if (a->sign == MP_ZPOS) { ------------------ | | 151| 166k|#define MP_ZPOS 0 /* positive integer */ ------------------ | Branch (48:8): [True: 166k, False: 0] ------------------ 49| | /* add digits, mu is carry */ 50| 166k| mp_digit mu = b; 51| 742k| for (ix = 0; ix < a->used; ix++) { ------------------ | Branch (51:20): [True: 575k, False: 166k] ------------------ 52| 575k| *tmpc = *tmpa++ + mu; 53| 575k| mu = *tmpc >> MP_DIGIT_BIT; ------------------ | | 82| 575k|# define MP_DIGIT_BIT 60 ------------------ 54| 575k| *tmpc++ &= MP_MASK; ------------------ | | 106| 575k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 575k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 55| 575k| } 56| | /* set final carry */ 57| 166k| ix++; 58| 166k| *tmpc++ = mu; 59| | 60| | /* setup size */ 61| 166k| c->used = a->used + 1; 62| 166k| } else { 63| | /* a was negative and |a| < b */ 64| 0| c->used = 1; 65| | 66| | /* the result is a single digit */ 67| 0| if (a->used == 1) { ------------------ | Branch (67:11): [True: 0, False: 0] ------------------ 68| 0| *tmpc++ = b - a->dp[0]; 69| 0| } else { 70| 0| *tmpc++ = b; 71| 0| } 72| | 73| | /* setup count so the clearing of oldused 74| | * can fall through correctly 75| | */ 76| 0| ix = 1; 77| 0| } 78| | 79| | /* sign always positive */ 80| 166k| c->sign = MP_ZPOS; ------------------ | | 151| 166k|#define MP_ZPOS 0 /* positive integer */ ------------------ 81| | 82| | /* now zero to oldused */ 83| 166k| MP_ZERO_DIGITS(tmpc, oldused - ix); ------------------ | | 89| 166k|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 166k|do { \ | | 91| 166k| int zd_ = (digits); \ | | 92| 166k| mp_digit* zm_ = (mem); \ | | 93| 166k| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 0, False: 166k] | | ------------------ | | 94| 0| *zm_++ = 0; \ | | 95| 0| } \ | | 96| 166k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 166k] | | ------------------ ------------------ 84| 166k| mp_clamp(c); 85| | 86| 166k| return MP_OKAY; ------------------ | | 161| 166k|#define MP_OKAY 0 /* no error */ ------------------ 87| 166k|} mp_clamp: 14| 20.4M|{ 15| | /* decrease used while the most significant digit is 16| | * zero. 17| | */ 18| 58.7M| while ((a->used > 0) && (a->dp[a->used - 1] == 0u)) { ------------------ | Branch (18:11): [True: 58.5M, False: 155k] | Branch (18:28): [True: 38.3M, False: 20.2M] ------------------ 19| 38.3M| --(a->used); 20| 38.3M| } 21| | 22| | /* reset the sign flag if used == 0 */ 23| 20.4M| if (a->used == 0) { ------------------ | Branch (23:8): [True: 155k, False: 20.2M] ------------------ 24| 155k| a->sign = MP_ZPOS; ------------------ | | 151| 155k|#define MP_ZPOS 0 /* positive integer */ ------------------ 25| 155k| } 26| 20.4M|} mp_clear: 8| 1.27M|{ 9| | /* only do anything if a hasn't been freed previously */ 10| 1.27M| if (a->dp != NULL) { ------------------ | Branch (10:8): [True: 1.27M, False: 0] ------------------ 11| | /* free ram */ 12| 1.27M| MP_FREE_DIGITS(a->dp, a->alloc); ------------------ | | 58| 1.27M|# define MP_FREE_DIGITS(mem, digits) \ | | 59| 1.27M|do { \ | | 60| 1.27M| int fd_ = (digits); \ | | 61| 1.27M| void* fm_ = (mem); \ | | 62| 1.27M| if (fm_ != NULL) { \ | | ------------------ | | | Branch (62:8): [True: 1.27M, False: 0] | | ------------------ | | 63| 1.27M| size_t fs_ = sizeof (mp_digit) * (size_t)fd_; \ | | 64| 1.27M| MP_ZERO_BUFFER(fm_, fs_); \ | | ------------------ | | | | 81| 1.27M|# define MP_ZERO_BUFFER(mem, size) \ | | | | 82| 1.27M|do { \ | | | | 83| 1.27M| size_t zs_ = (size); \ | | | | 84| 1.27M| char* zm_ = (char*)(mem); \ | | | | 85| 238M| while (zs_-- > 0u) { \ | | | | ------------------ | | | | | Branch (85:11): [True: 237M, False: 1.27M] | | | | ------------------ | | | | 86| 237M| *zm_++ = '\0'; \ | | | | 87| 237M| } \ | | | | 88| 1.27M|} while (0) | | | | ------------------ | | | | | Branch (88:10): [Folded, False: 1.27M] | | | | ------------------ | | ------------------ | | 65| 1.27M| MP_FREE(fm_, fs_); \ | | ------------------ | | | | 1324| 1.27M|#define MP_FREE m_free_ltm | | ------------------ | | 66| 1.27M| } \ | | 67| 1.27M|} while (0) | | ------------------ | | | Branch (67:10): [Folded, False: 1.27M] | | ------------------ ------------------ 13| | 14| | /* reset members to make debugging easier */ 15| 1.27M| a->dp = NULL; 16| 1.27M| a->alloc = a->used = 0; 17| 1.27M| a->sign = MP_ZPOS; ------------------ | | 151| 1.27M|#define MP_ZPOS 0 /* positive integer */ ------------------ 18| 1.27M| } 19| 1.27M|} mp_clear_multi: 9| 2.38k|{ 10| 2.38k| mp_int *next_mp = mp; 11| 2.38k| va_list args; 12| 2.38k| va_start(args, mp); 13| 12.6k| while (next_mp != NULL) { ------------------ | Branch (13:11): [True: 10.2k, False: 2.38k] ------------------ 14| 10.2k| mp_clear(next_mp); 15| 10.2k| next_mp = va_arg(args, mp_int *); 16| 10.2k| } 17| | va_end(args); 18| 2.38k|} mp_cmp: 8| 1.04M|{ 9| | /* compare based on sign */ 10| 1.04M| if (a->sign != b->sign) { ------------------ | Branch (10:8): [True: 0, False: 1.04M] ------------------ 11| 0| if (a->sign == MP_NEG) { ------------------ | | 152| 0|#define MP_NEG 1 /* negative */ ------------------ | Branch (11:11): [True: 0, False: 0] ------------------ 12| 0| return MP_LT; ------------------ | | 154| 0|#define MP_LT -1 /* less than */ ------------------ 13| 0| } else { 14| 0| return MP_GT; ------------------ | | 156| 0|#define MP_GT 1 /* greater than */ ------------------ 15| 0| } 16| 0| } 17| | 18| | /* compare digits */ 19| 1.04M| if (a->sign == MP_NEG) { ------------------ | | 152| 1.04M|#define MP_NEG 1 /* negative */ ------------------ | Branch (19:8): [True: 0, False: 1.04M] ------------------ 20| | /* if negative compare opposite direction */ 21| 0| return mp_cmp_mag(b, a); 22| 1.04M| } else { 23| 1.04M| return mp_cmp_mag(a, b); 24| 1.04M| } 25| 1.04M|} mp_cmp_d: 8| 867k|{ 9| | /* compare based on sign */ 10| 867k| if (a->sign == MP_NEG) { ------------------ | | 152| 867k|#define MP_NEG 1 /* negative */ ------------------ | Branch (10:8): [True: 349k, False: 518k] ------------------ 11| 349k| return MP_LT; ------------------ | | 154| 349k|#define MP_LT -1 /* less than */ ------------------ 12| 349k| } 13| | 14| | /* compare based on magnitude */ 15| 518k| if (a->used > 1) { ------------------ | Branch (15:8): [True: 502k, False: 16.0k] ------------------ 16| 502k| return MP_GT; ------------------ | | 156| 502k|#define MP_GT 1 /* greater than */ ------------------ 17| 502k| } 18| | 19| | /* compare the only digit of a to b */ 20| 16.0k| if (a->dp[0] > b) { ------------------ | Branch (20:8): [True: 7.45k, False: 8.64k] ------------------ 21| 7.45k| return MP_GT; ------------------ | | 156| 7.45k|#define MP_GT 1 /* greater than */ ------------------ 22| 8.64k| } else if (a->dp[0] < b) { ------------------ | Branch (22:15): [True: 1, False: 8.64k] ------------------ 23| 1| return MP_LT; ------------------ | | 154| 1|#define MP_LT -1 /* less than */ ------------------ 24| 8.64k| } else { 25| 8.64k| return MP_EQ; ------------------ | | 155| 8.64k|#define MP_EQ 0 /* equal to */ ------------------ 26| 8.64k| } 27| 16.0k|} mp_cmp_mag: 8| 7.46M|{ 9| 7.46M| int n; 10| 7.46M| const mp_digit *tmpa, *tmpb; 11| | 12| | /* compare based on # of non-zero digits */ 13| 7.46M| if (a->used > b->used) { ------------------ | Branch (13:8): [True: 2.16M, False: 5.30M] ------------------ 14| 2.16M| return MP_GT; ------------------ | | 156| 2.16M|#define MP_GT 1 /* greater than */ ------------------ 15| 2.16M| } 16| | 17| 5.30M| if (a->used < b->used) { ------------------ | Branch (17:8): [True: 108k, False: 5.19M] ------------------ 18| 108k| return MP_LT; ------------------ | | 154| 108k|#define MP_LT -1 /* less than */ ------------------ 19| 108k| } 20| | 21| | /* alias for a */ 22| 5.19M| tmpa = a->dp + (a->used - 1); 23| | 24| | /* alias for b */ 25| 5.19M| tmpb = b->dp + (a->used - 1); 26| | 27| | /* compare based on digits */ 28| 5.83M| for (n = 0; n < a->used; ++n, --tmpa, --tmpb) { ------------------ | Branch (28:16): [True: 5.82M, False: 13.5k] ------------------ 29| 5.82M| if (*tmpa > *tmpb) { ------------------ | Branch (29:11): [True: 1.83M, False: 3.98M] ------------------ 30| 1.83M| return MP_GT; ------------------ | | 156| 1.83M|#define MP_GT 1 /* greater than */ ------------------ 31| 1.83M| } 32| | 33| 3.98M| if (*tmpa < *tmpb) { ------------------ | Branch (33:11): [True: 3.34M, False: 642k] ------------------ 34| 3.34M| return MP_LT; ------------------ | | 154| 3.34M|#define MP_LT -1 /* less than */ ------------------ 35| 3.34M| } 36| 3.98M| } 37| 13.5k| return MP_EQ; ------------------ | | 155| 13.5k|#define MP_EQ 0 /* equal to */ ------------------ 38| 5.19M|} mp_cnt_lsb: 12| 2.07k|{ 13| 2.07k| int x; 14| 2.07k| mp_digit q, qq; 15| | 16| | /* easy out */ 17| 2.07k| if (MP_IS_ZERO(a)) { ------------------ | | 163| 2.07k|#define MP_IS_ZERO(a) ((a)->used == 0) | | ------------------ | | | Branch (163:23): [True: 0, False: 2.07k] | | ------------------ ------------------ 18| 0| return 0; 19| 0| } 20| | 21| | /* scan lower digits until non-zero */ 22| 3.29k| for (x = 0; (x < a->used) && (a->dp[x] == 0u); x++) {} ------------------ | Branch (22:16): [True: 3.29k, False: 0] | Branch (22:33): [True: 1.21k, False: 2.07k] ------------------ 23| 2.07k| q = a->dp[x]; 24| 2.07k| x *= MP_DIGIT_BIT; ------------------ | | 82| 2.07k|# define MP_DIGIT_BIT 60 ------------------ 25| | 26| | /* now scan this digit until a 1 is found */ 27| 2.07k| if ((q & 1u) == 0u) { ------------------ | Branch (27:8): [True: 1.76k, False: 305] ------------------ 28| 7.26k| do { 29| 7.26k| qq = q & 15u; 30| 7.26k| x += lnz[qq]; 31| 7.26k| q >>= 4; 32| 7.26k| } while (qq == 0u); ------------------ | Branch (32:16): [True: 5.49k, False: 1.76k] ------------------ 33| 1.76k| } 34| 2.07k| return x; 35| 2.07k|} mp_copy: 8| 4.99M|{ 9| 4.99M| int n; 10| 4.99M| mp_digit *tmpa, *tmpb; 11| 4.99M| mp_err err; 12| | 13| | /* if dst == src do nothing */ 14| 4.99M| if (a == b) { ------------------ | Branch (14:8): [True: 2.32M, False: 2.67M] ------------------ 15| 2.32M| return MP_OKAY; ------------------ | | 161| 2.32M|#define MP_OKAY 0 /* no error */ ------------------ 16| 2.32M| } 17| | 18| | /* grow dest */ 19| 2.67M| if (b->alloc < a->used) { ------------------ | Branch (19:8): [True: 2.53k, False: 2.66M] ------------------ 20| 2.53k| if ((err = mp_grow(b, a->used)) != MP_OKAY) { ------------------ | | 161| 2.53k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (20:11): [True: 0, False: 2.53k] ------------------ 21| 0| return err; 22| 0| } 23| 2.53k| } 24| | 25| | /* zero b and copy the parameters over */ 26| | /* pointer aliases */ 27| | 28| | /* source */ 29| 2.67M| tmpa = a->dp; 30| | 31| | /* destination */ 32| 2.67M| tmpb = b->dp; 33| | 34| | /* copy all the digits */ 35| 90.2M| for (n = 0; n < a->used; n++) { ------------------ | Branch (35:16): [True: 87.5M, False: 2.67M] ------------------ 36| 87.5M| *tmpb++ = *tmpa++; 37| 87.5M| } 38| | 39| | /* clear high digits */ 40| 2.67M| MP_ZERO_DIGITS(tmpb, b->used - n); ------------------ | | 89| 2.67M|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 2.67M|do { \ | | 91| 2.67M| int zd_ = (digits); \ | | 92| 2.67M| mp_digit* zm_ = (mem); \ | | 93| 2.67M| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 5.21k, False: 2.67M] | | ------------------ | | 94| 5.21k| *zm_++ = 0; \ | | 95| 5.21k| } \ | | 96| 2.67M|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2.67M] | | ------------------ ------------------ 41| | 42| | /* copy used count and sign */ 43| 2.67M| b->used = a->used; 44| 2.67M| b->sign = a->sign; 45| 2.67M| return MP_OKAY; ------------------ | | 161| 2.67M|#define MP_OKAY 0 /* no error */ ------------------ 46| 2.67M|} mp_count_bits: 8| 165k|{ 9| 165k| int r; 10| 165k| mp_digit q; 11| | 12| | /* shortcut */ 13| 165k| if (MP_IS_ZERO(a)) { ------------------ | | 163| 165k|#define MP_IS_ZERO(a) ((a)->used == 0) | | ------------------ | | | Branch (163:23): [True: 899, False: 164k] | | ------------------ ------------------ 14| 899| return 0; 15| 899| } 16| | 17| | /* get number of digits and add that */ 18| 164k| r = (a->used - 1) * MP_DIGIT_BIT; ------------------ | | 82| 164k|# define MP_DIGIT_BIT 60 ------------------ 19| | 20| | /* take the last digit and count the bits in it */ 21| 164k| q = a->dp[a->used - 1]; 22| 6.28M| while (q > 0u) { ------------------ | Branch (22:11): [True: 6.12M, False: 164k] ------------------ 23| 6.12M| ++r; 24| 6.12M| q >>= 1u; 25| 6.12M| } 26| 164k| return r; 27| 165k|} mp_div: 87| 102k|{ 88| 102k| mp_int q, x, y, t1, t2; 89| 102k| int n, t, i, norm; 90| 102k| mp_sign neg; 91| 102k| mp_err err; 92| | 93| | /* is divisor zero ? */ 94| 102k| if (MP_IS_ZERO(b)) { ------------------ | | 163| 102k|#define MP_IS_ZERO(a) ((a)->used == 0) | | ------------------ | | | Branch (163:23): [True: 0, False: 102k] | | ------------------ ------------------ 95| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 96| 0| } 97| | 98| | /* if a < b then q=0, r = a */ 99| 102k| if (mp_cmp_mag(a, b) == MP_LT) { ------------------ | | 154| 102k|#define MP_LT -1 /* less than */ ------------------ | Branch (99:8): [True: 3.38k, False: 99.4k] ------------------ 100| 3.38k| if (d != NULL) { ------------------ | Branch (100:11): [True: 3.38k, False: 0] ------------------ 101| 3.38k| err = mp_copy(a, d); 102| 3.38k| } else { 103| 0| err = MP_OKAY; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ 104| 0| } 105| 3.38k| if (c != NULL) { ------------------ | Branch (105:11): [True: 0, False: 3.38k] ------------------ 106| 0| mp_zero(c); 107| 0| } 108| 3.38k| return err; 109| 3.38k| } 110| | 111| 99.4k| if ((err = mp_init_size(&q, a->used + 2)) != MP_OKAY) { ------------------ | | 161| 99.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (111:8): [True: 0, False: 99.4k] ------------------ 112| 0| return err; 113| 0| } 114| 99.4k| q.used = a->used + 2; 115| | 116| 99.4k| if ((err = mp_init(&t1)) != MP_OKAY) goto LBL_Q; ------------------ | | 161| 99.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (116:8): [True: 0, False: 99.4k] ------------------ 117| | 118| 99.4k| if ((err = mp_init(&t2)) != MP_OKAY) goto LBL_T1; ------------------ | | 161| 99.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (118:8): [True: 0, False: 99.4k] ------------------ 119| | 120| 99.4k| if ((err = mp_init_copy(&x, a)) != MP_OKAY) goto LBL_T2; ------------------ | | 161| 99.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (120:8): [True: 0, False: 99.4k] ------------------ 121| | 122| 99.4k| if ((err = mp_init_copy(&y, b)) != MP_OKAY) goto LBL_X; ------------------ | | 161| 99.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (122:8): [True: 0, False: 99.4k] ------------------ 123| | 124| | /* fix the sign */ 125| 99.4k| neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG; ------------------ | | 151| 99.2k|#define MP_ZPOS 0 /* positive integer */ ------------------ neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG; ------------------ | | 152| 99.7k|#define MP_NEG 1 /* negative */ ------------------ | Branch (125:10): [True: 99.2k, False: 273] ------------------ 126| 99.4k| x.sign = y.sign = MP_ZPOS; ------------------ | | 151| 99.4k|#define MP_ZPOS 0 /* positive integer */ ------------------ 127| | 128| | /* normalize both x and y, ensure that y >= b/2, [b == 2**MP_DIGIT_BIT] */ 129| 99.4k| norm = mp_count_bits(&y) % MP_DIGIT_BIT; ------------------ | | 82| 99.4k|# define MP_DIGIT_BIT 60 ------------------ 130| 99.4k| if (norm < (MP_DIGIT_BIT - 1)) { ------------------ | | 82| 99.4k|# define MP_DIGIT_BIT 60 ------------------ | Branch (130:8): [True: 99.4k, False: 15] ------------------ 131| 99.4k| norm = (MP_DIGIT_BIT - 1) - norm; ------------------ | | 82| 99.4k|# define MP_DIGIT_BIT 60 ------------------ 132| 99.4k| if ((err = mp_mul_2d(&x, norm, &x)) != MP_OKAY) goto LBL_Y; ------------------ | | 161| 99.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (132:11): [True: 0, False: 99.4k] ------------------ 133| 99.4k| if ((err = mp_mul_2d(&y, norm, &y)) != MP_OKAY) goto LBL_Y; ------------------ | | 161| 99.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (133:11): [True: 0, False: 99.4k] ------------------ 134| 99.4k| } else { 135| 15| norm = 0; 136| 15| } 137| | 138| | /* note hac does 0 based, so if used==5 then its 0,1,2,3,4, e.g. use 4 */ 139| 99.4k| n = x.used - 1; 140| 99.4k| t = y.used - 1; 141| | 142| | /* while (x >= y*b**n-t) do { q[n-t] += 1; x -= y*b**{n-t} } */ 143| | /* y = y*b**{n-t} */ 144| 99.4k| if ((err = mp_lshd(&y, n - t)) != MP_OKAY) goto LBL_Y; ------------------ | | 161| 99.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (144:8): [True: 0, False: 99.4k] ------------------ 145| | 146| 99.7k| while (mp_cmp(&x, &y) != MP_LT) { ------------------ | | 154| 99.7k|#define MP_LT -1 /* less than */ ------------------ | Branch (146:11): [True: 283, False: 99.4k] ------------------ 147| 283| ++(q.dp[n - t]); 148| 283| if ((err = mp_sub(&x, &y, &x)) != MP_OKAY) goto LBL_Y; ------------------ | | 161| 283|#define MP_OKAY 0 /* no error */ ------------------ | Branch (148:11): [True: 0, False: 283] ------------------ 149| 283| } 150| | 151| | /* reset y by shifting it back down */ 152| 99.4k| mp_rshd(&y, n - t); 153| | 154| | /* step 3. for i from n down to (t + 1) */ 155| 412k| for (i = n; i >= (t + 1); i--) { ------------------ | Branch (155:16): [True: 313k, False: 99.4k] ------------------ 156| 313k| if (i > x.used) { ------------------ | Branch (156:11): [True: 3.73k, False: 309k] ------------------ 157| 3.73k| continue; 158| 3.73k| } 159| | 160| | /* step 3.1 if xi == yt then set q{i-t-1} to b-1, 161| | * otherwise set q{i-t-1} to (xi*b + x{i-1})/yt */ 162| 309k| if (x.dp[i] == y.dp[t]) { ------------------ | Branch (162:11): [True: 345, False: 309k] ------------------ 163| 345| q.dp[(i - t) - 1] = ((mp_digit)1 << (mp_digit)MP_DIGIT_BIT) - (mp_digit)1; ------------------ | | 82| 345|# define MP_DIGIT_BIT 60 ------------------ 164| 309k| } else { 165| 309k| mp_word tmp; 166| 309k| tmp = (mp_word)x.dp[i] << (mp_word)MP_DIGIT_BIT; ------------------ | | 82| 309k|# define MP_DIGIT_BIT 60 ------------------ 167| 309k| tmp |= (mp_word)x.dp[i - 1]; 168| 309k| tmp /= (mp_word)y.dp[t]; 169| 309k| if (tmp > (mp_word)MP_MASK) { ------------------ | | 106| 309k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 309k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ | Branch (169:14): [True: 0, False: 309k] ------------------ 170| 0| tmp = MP_MASK; ------------------ | | 106| 0|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 0|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 171| 0| } 172| 309k| q.dp[(i - t) - 1] = (mp_digit)(tmp & (mp_word)MP_MASK); ------------------ | | 106| 309k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 309k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 173| 309k| } 174| | 175| | /* while (q{i-t-1} * (yt * b + y{t-1})) > 176| | xi * b**2 + xi-1 * b + xi-2 177| | 178| | do q{i-t-1} -= 1; 179| | */ 180| 309k| q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] + 1uL) & (mp_digit)MP_MASK; ------------------ | | 106| 309k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 309k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 181| 426k| do { 182| 426k| q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] - 1uL) & (mp_digit)MP_MASK; ------------------ | | 106| 426k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 426k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 183| | 184| | /* find left hand */ 185| 426k| mp_zero(&t1); 186| 426k| t1.dp[0] = ((t - 1) < 0) ? 0u : y.dp[t - 1]; ------------------ | Branch (186:21): [True: 286, False: 425k] ------------------ 187| 426k| t1.dp[1] = y.dp[t]; 188| 426k| t1.used = 2; 189| 426k| if ((err = mp_mul_d(&t1, q.dp[(i - t) - 1], &t1)) != MP_OKAY) goto LBL_Y; ------------------ | | 161| 426k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (189:14): [True: 0, False: 426k] ------------------ 190| | 191| | /* find right hand */ 192| 426k| t2.dp[0] = ((i - 2) < 0) ? 0u : x.dp[i - 2]; ------------------ | Branch (192:21): [True: 44, False: 426k] ------------------ 193| 426k| t2.dp[1] = x.dp[i - 1]; /* i >= 1 always holds */ 194| 426k| t2.dp[2] = x.dp[i]; 195| 426k| t2.used = 3; 196| 426k| } while (mp_cmp_mag(&t1, &t2) == MP_GT); ------------------ | | 156| 426k|#define MP_GT 1 /* greater than */ ------------------ | Branch (196:16): [True: 116k, False: 309k] ------------------ 197| | 198| | /* step 3.3 x = x - q{i-t-1} * y * b**{i-t-1} */ 199| 309k| if ((err = mp_mul_d(&y, q.dp[(i - t) - 1], &t1)) != MP_OKAY) goto LBL_Y; ------------------ | | 161| 309k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (199:11): [True: 0, False: 309k] ------------------ 200| | 201| 309k| if ((err = mp_lshd(&t1, (i - t) - 1)) != MP_OKAY) goto LBL_Y; ------------------ | | 161| 309k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (201:11): [True: 0, False: 309k] ------------------ 202| | 203| 309k| if ((err = mp_sub(&x, &t1, &x)) != MP_OKAY) goto LBL_Y; ------------------ | | 161| 309k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (203:11): [True: 0, False: 309k] ------------------ 204| | 205| | /* if x < 0 then { x = x + y*b**{i-t-1}; q{i-t-1} -= 1; } */ 206| 309k| if (x.sign == MP_NEG) { ------------------ | | 152| 309k|#define MP_NEG 1 /* negative */ ------------------ | Branch (206:11): [True: 1.90k, False: 307k] ------------------ 207| 1.90k| if ((err = mp_copy(&y, &t1)) != MP_OKAY) goto LBL_Y; ------------------ | | 161| 1.90k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (207:14): [True: 0, False: 1.90k] ------------------ 208| 1.90k| if ((err = mp_lshd(&t1, (i - t) - 1)) != MP_OKAY) goto LBL_Y; ------------------ | | 161| 1.90k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (208:14): [True: 0, False: 1.90k] ------------------ 209| 1.90k| if ((err = mp_add(&x, &t1, &x)) != MP_OKAY) goto LBL_Y; ------------------ | | 161| 1.90k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (209:14): [True: 0, False: 1.90k] ------------------ 210| | 211| 1.90k| q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] - 1uL) & MP_MASK; ------------------ | | 106| 1.90k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 1.90k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 212| 1.90k| } 213| 309k| } 214| | 215| | /* now q is the quotient and x is the remainder 216| | * [which we have to normalize] 217| | */ 218| | 219| | /* get sign before writing to c */ 220| 99.4k| x.sign = (x.used == 0) ? MP_ZPOS : a->sign; ------------------ | | 151| 24|#define MP_ZPOS 0 /* positive integer */ ------------------ | Branch (220:13): [True: 24, False: 99.4k] ------------------ 221| | 222| 99.4k| if (c != NULL) { ------------------ | Branch (222:8): [True: 667, False: 98.8k] ------------------ 223| 667| mp_clamp(&q); 224| 667| mp_exch(&q, c); 225| 667| c->sign = neg; 226| 667| } 227| | 228| 99.4k| if (d != NULL) { ------------------ | Branch (228:8): [True: 98.8k, False: 667] ------------------ 229| 98.8k| if ((err = mp_div_2d(&x, norm, &x, NULL)) != MP_OKAY) goto LBL_Y; ------------------ | | 161| 98.8k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (229:11): [True: 0, False: 98.8k] ------------------ 230| 98.8k| mp_exch(&x, d); 231| 98.8k| } 232| | 233| 99.4k| err = MP_OKAY; ------------------ | | 161| 99.4k|#define MP_OKAY 0 /* no error */ ------------------ 234| | 235| 99.4k|LBL_Y: 236| 99.4k| mp_clear(&y); 237| 99.4k|LBL_X: 238| 99.4k| mp_clear(&x); 239| 99.4k|LBL_T2: 240| 99.4k| mp_clear(&t2); 241| 99.4k|LBL_T1: 242| 99.4k| mp_clear(&t1); 243| 99.4k|LBL_Q: 244| 99.4k| mp_clear(&q); 245| 99.4k| return err; 246| 99.4k|} mp_div_2: 8| 660k|{ 9| 660k| int x, oldused; 10| 660k| mp_digit r, rr, *tmpa, *tmpb; 11| 660k| mp_err err; 12| | 13| | /* copy */ 14| 660k| if (b->alloc < a->used) { ------------------ | Branch (14:8): [True: 0, False: 660k] ------------------ 15| 0| if ((err = mp_grow(b, a->used)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (15:11): [True: 0, False: 0] ------------------ 16| 0| return err; 17| 0| } 18| 0| } 19| | 20| 660k| oldused = b->used; 21| 660k| b->used = a->used; 22| | 23| | /* source alias */ 24| 660k| tmpa = a->dp + b->used - 1; 25| | 26| | /* dest alias */ 27| 660k| tmpb = b->dp + b->used - 1; 28| | 29| | /* carry */ 30| 660k| r = 0; 31| 3.93M| for (x = b->used - 1; x >= 0; x--) { ------------------ | Branch (31:26): [True: 3.27M, False: 660k] ------------------ 32| | /* get the carry for the next iteration */ 33| 3.27M| rr = *tmpa & 1u; 34| | 35| | /* shift the current digit, add in carry and store */ 36| 3.27M| *tmpb-- = (*tmpa-- >> 1) | (r << (MP_DIGIT_BIT - 1)); ------------------ | | 82| 3.27M|# define MP_DIGIT_BIT 60 ------------------ 37| | 38| | /* forward carry to next iteration */ 39| 3.27M| r = rr; 40| 3.27M| } 41| | 42| | /* zero excess digits */ 43| 660k| MP_ZERO_DIGITS(b->dp + b->used, oldused - b->used); ------------------ | | 89| 660k|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 660k|do { \ | | 91| 660k| int zd_ = (digits); \ | | 92| 660k| mp_digit* zm_ = (mem); \ | | 93| 660k| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 0, False: 660k] | | ------------------ | | 94| 0| *zm_++ = 0; \ | | 95| 0| } \ | | 96| 660k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 660k] | | ------------------ ------------------ 44| | 45| 660k| b->sign = a->sign; 46| 660k| mp_clamp(b); 47| 660k| return MP_OKAY; ------------------ | | 161| 660k|#define MP_OKAY 0 /* no error */ ------------------ 48| 660k|} mp_div_2d: 8| 2.28M|{ 9| 2.28M| mp_digit D, r, rr; 10| 2.28M| int x; 11| 2.28M| mp_err err; 12| | 13| | /* if the shift count is <= 0 then we do no work */ 14| 2.28M| if (b <= 0) { ------------------ | Branch (14:8): [True: 3, False: 2.28M] ------------------ 15| 3| err = mp_copy(a, c); 16| 3| if (d != NULL) { ------------------ | Branch (16:11): [True: 0, False: 3] ------------------ 17| 0| mp_zero(d); 18| 0| } 19| 3| return err; 20| 3| } 21| | 22| | /* copy */ 23| 2.28M| if ((err = mp_copy(a, c)) != MP_OKAY) { ------------------ | | 161| 2.28M|#define MP_OKAY 0 /* no error */ ------------------ | Branch (23:8): [True: 0, False: 2.28M] ------------------ 24| 0| return err; 25| 0| } 26| | /* 'a' should not be used after here - it might be the same as d */ 27| | 28| | /* get the remainder */ 29| 2.28M| if (d != NULL) { ------------------ | Branch (29:8): [True: 2.16M, False: 121k] ------------------ 30| 2.16M| if ((err = mp_mod_2d(a, b, d)) != MP_OKAY) { ------------------ | | 161| 2.16M|#define MP_OKAY 0 /* no error */ ------------------ | Branch (30:11): [True: 0, False: 2.16M] ------------------ 31| 0| return err; 32| 0| } 33| 2.16M| } 34| | 35| | /* shift by as many digits in the bit count */ 36| 2.28M| if (b >= MP_DIGIT_BIT) { ------------------ | | 82| 2.28M|# define MP_DIGIT_BIT 60 ------------------ | Branch (36:8): [True: 2.16M, False: 120k] ------------------ 37| 2.16M| mp_rshd(c, b / MP_DIGIT_BIT); ------------------ | | 82| 2.16M|# define MP_DIGIT_BIT 60 ------------------ 38| 2.16M| } 39| | 40| | /* shift any bit count < MP_DIGIT_BIT */ 41| 2.28M| D = (mp_digit)(b % MP_DIGIT_BIT); ------------------ | | 82| 2.28M|# define MP_DIGIT_BIT 60 ------------------ 42| 2.28M| if (D != 0u) { ------------------ | Branch (42:8): [True: 2.20M, False: 73.8k] ------------------ 43| 2.20M| mp_digit *tmpc, mask, shift; 44| | 45| | /* mask */ 46| 2.20M| mask = ((mp_digit)1 << D) - 1uL; 47| | 48| | /* shift for lsb */ 49| 2.20M| shift = (mp_digit)MP_DIGIT_BIT - D; ------------------ | | 82| 2.20M|# define MP_DIGIT_BIT 60 ------------------ 50| | 51| | /* alias */ 52| 2.20M| tmpc = c->dp + (c->used - 1); 53| | 54| | /* carry */ 55| 2.20M| r = 0; 56| 30.5M| for (x = c->used - 1; x >= 0; x--) { ------------------ | Branch (56:29): [True: 28.3M, False: 2.20M] ------------------ 57| | /* get the lower bits of this word in a temp */ 58| 28.3M| rr = *tmpc & mask; 59| | 60| | /* shift the current word and mix in the carry bits from the previous word */ 61| 28.3M| *tmpc = (*tmpc >> D) | (r << shift); 62| 28.3M| --tmpc; 63| | 64| | /* set the carry to the carry bits of the current word found above */ 65| 28.3M| r = rr; 66| 28.3M| } 67| 2.20M| } 68| 2.28M| mp_clamp(c); 69| 2.28M| return MP_OKAY; ------------------ | | 161| 2.28M|#define MP_OKAY 0 /* no error */ ------------------ 70| 2.28M|} mp_div_3: 8| 151|{ 9| 151| mp_int q; 10| 151| mp_word w, t; 11| 151| mp_digit b; 12| 151| mp_err err; 13| 151| int ix; 14| | 15| | /* b = 2**MP_DIGIT_BIT / 3 */ 16| 151| b = ((mp_word)1 << (mp_word)MP_DIGIT_BIT) / (mp_word)3; ------------------ | | 82| 151|# define MP_DIGIT_BIT 60 ------------------ 17| | 18| 151| if ((err = mp_init_size(&q, a->used)) != MP_OKAY) { ------------------ | | 161| 151|#define MP_OKAY 0 /* no error */ ------------------ | Branch (18:8): [True: 0, False: 151] ------------------ 19| 0| return err; 20| 0| } 21| | 22| 151| q.used = a->used; 23| 151| q.sign = a->sign; 24| 151| w = 0; 25| 1.12k| for (ix = a->used - 1; ix >= 0; ix--) { ------------------ | Branch (25:27): [True: 978, False: 151] ------------------ 26| 978| w = (w << (mp_word)MP_DIGIT_BIT) | (mp_word)a->dp[ix]; ------------------ | | 82| 978|# define MP_DIGIT_BIT 60 ------------------ 27| | 28| 978| if (w >= 3u) { ------------------ | Branch (28:11): [True: 864, False: 114] ------------------ 29| | /* multiply w by [1/3] */ 30| 864| t = (w * (mp_word)b) >> (mp_word)MP_DIGIT_BIT; ------------------ | | 82| 864|# define MP_DIGIT_BIT 60 ------------------ 31| | 32| | /* now subtract 3 * [w/3] from w, to get the remainder */ 33| 864| w -= t+t+t; 34| | 35| | /* fixup the remainder as required since 36| | * the optimization is not exact. 37| | */ 38| 1.37k| while (w >= 3u) { ------------------ | Branch (38:17): [True: 510, False: 864] ------------------ 39| 510| t += 1u; 40| 510| w -= 3u; 41| 510| } 42| 864| } else { 43| 114| t = 0; 44| 114| } 45| 978| q.dp[ix] = (mp_digit)t; 46| 978| } 47| | 48| | /* [optional] store the remainder */ 49| 151| if (d != NULL) { ------------------ | Branch (49:8): [True: 151, False: 0] ------------------ 50| 151| *d = (mp_digit)w; 51| 151| } 52| | 53| | /* [optional] store the quotient */ 54| 151| if (c != NULL) { ------------------ | Branch (54:8): [True: 0, False: 151] ------------------ 55| 0| mp_clamp(&q); 56| 0| mp_exch(&q, c); 57| 0| } 58| 151| mp_clear(&q); 59| | 60| 151| return err; 61| 151|} mp_div_d: 8| 26.2k|{ 9| 26.2k| mp_int q; 10| 26.2k| mp_word w; 11| 26.2k| mp_digit t; 12| 26.2k| mp_err err; 13| 26.2k| int ix; 14| | 15| | /* cannot divide by zero */ 16| 26.2k| if (b == 0u) { ------------------ | Branch (16:8): [True: 0, False: 26.2k] ------------------ 17| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 18| 0| } 19| | 20| | /* quick outs */ 21| 26.2k| if ((b == 1u) || MP_IS_ZERO(a)) { ------------------ | | 163| 26.2k|#define MP_IS_ZERO(a) ((a)->used == 0) | | ------------------ | | | Branch (163:23): [True: 0, False: 26.2k] | | ------------------ ------------------ | Branch (21:8): [True: 0, False: 26.2k] ------------------ 22| 0| if (d != NULL) { ------------------ | Branch (22:11): [True: 0, False: 0] ------------------ 23| 0| *d = 0; 24| 0| } 25| 0| if (c != NULL) { ------------------ | Branch (25:11): [True: 0, False: 0] ------------------ 26| 0| return mp_copy(a, c); 27| 0| } 28| 0| return MP_OKAY; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ 29| 0| } 30| | 31| | /* power of two ? */ 32| 26.2k| if ((b & (b - 1u)) == 0u) { ------------------ | Branch (32:8): [True: 151, False: 26.0k] ------------------ 33| 151| ix = 1; 34| 151| while ((ix < MP_DIGIT_BIT) && (b != (((mp_digit)1)<dp[0] & (((mp_digit)1<<(mp_digit)ix) - 1uL); 39| 151| } 40| 151| if (c != NULL) { ------------------ | Branch (40:11): [True: 0, False: 151] ------------------ 41| 0| return mp_div_2d(a, ix, c, NULL); 42| 0| } 43| 151| return MP_OKAY; ------------------ | | 161| 151|#define MP_OKAY 0 /* no error */ ------------------ 44| 151| } 45| | 46| | /* three? */ 47| 26.0k| if (MP_HAS(MP_DIV_3) && (b == 3u)) { ------------------ | | 150| 52.1k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 26.0k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 26.0k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 26.0k, Folded] | | ------------------ ------------------ | Branch (47:28): [True: 151, False: 25.9k] ------------------ 48| 151| return mp_div_3(a, c, d); 49| 151| } 50| | 51| | /* no easy answer [c'est la vie]. Just division */ 52| 25.9k| if ((err = mp_init_size(&q, a->used)) != MP_OKAY) { ------------------ | | 161| 25.9k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (52:8): [True: 0, False: 25.9k] ------------------ 53| 0| return err; 54| 0| } 55| | 56| 25.9k| q.used = a->used; 57| 25.9k| q.sign = a->sign; 58| 25.9k| w = 0; 59| 116k| for (ix = a->used - 1; ix >= 0; ix--) { ------------------ | Branch (59:27): [True: 90.2k, False: 25.9k] ------------------ 60| 90.2k| w = (w << (mp_word)MP_DIGIT_BIT) | (mp_word)a->dp[ix]; ------------------ | | 82| 90.2k|# define MP_DIGIT_BIT 60 ------------------ 61| | 62| 90.2k| if (w >= b) { ------------------ | Branch (62:11): [True: 89.3k, False: 914] ------------------ 63| 89.3k| t = (mp_digit)(w / b); 64| 89.3k| w -= (mp_word)t * (mp_word)b; 65| 89.3k| } else { 66| 914| t = 0; 67| 914| } 68| 90.2k| q.dp[ix] = t; 69| 90.2k| } 70| | 71| 25.9k| if (d != NULL) { ------------------ | Branch (71:8): [True: 25.9k, False: 0] ------------------ 72| 25.9k| *d = (mp_digit)w; 73| 25.9k| } 74| | 75| 25.9k| if (c != NULL) { ------------------ | Branch (75:8): [True: 0, False: 25.9k] ------------------ 76| 0| mp_clamp(&q); 77| 0| mp_exch(&q, c); 78| 0| } 79| 25.9k| mp_clear(&q); 80| | 81| 25.9k| return err; 82| 25.9k|} mp_dr_is_modulus: 8| 2.89k|{ 9| 2.89k| int ix; 10| | 11| | /* must be at least two digits */ 12| 2.89k| if (a->used < 2) { ------------------ | Branch (12:8): [True: 0, False: 2.89k] ------------------ 13| 0| return MP_NO; ------------------ | | 159| 0|#define MP_NO 0 ------------------ 14| 0| } 15| | 16| | /* must be of the form b**k - a [a <= b] so all 17| | * but the first digit must be equal to -1 (mod b). 18| | */ 19| 3.15k| for (ix = 1; ix < a->used; ix++) { ------------------ | Branch (19:17): [True: 3.15k, False: 0] ------------------ 20| 3.15k| if (a->dp[ix] != MP_MASK) { ------------------ | | 106| 3.15k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 3.15k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ | Branch (20:11): [True: 2.89k, False: 263] ------------------ 21| 2.89k| return MP_NO; ------------------ | | 159| 2.89k|#define MP_NO 0 ------------------ 22| 2.89k| } 23| 3.15k| } 24| 0| return MP_YES; ------------------ | | 158| 0|#define MP_YES 1 ------------------ 25| 2.89k|} mp_exch: 10| 204k|{ 11| 204k| mp_int t; 12| | 13| 204k| t = *a; 14| 204k| *a = *b; 15| 204k| *b = t; 16| 204k|} mp_exptmod: 12| 3.28k|{ 13| 3.28k| int dr; 14| | 15| | /* modulus P must be positive */ 16| 3.28k| if (P->sign == MP_NEG) { ------------------ | | 152| 3.28k|#define MP_NEG 1 /* negative */ ------------------ | Branch (16:8): [True: 0, False: 3.28k] ------------------ 17| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 18| 0| } 19| | 20| | /* if exponent X is negative we have to recurse */ 21| 3.28k| if (X->sign == MP_NEG) { ------------------ | | 152| 3.28k|#define MP_NEG 1 /* negative */ ------------------ | Branch (21:8): [True: 0, False: 3.28k] ------------------ 22| 0| mp_int tmpG, tmpX; 23| 0| mp_err err; 24| | 25| 0| if (!MP_HAS(MP_INVMOD)) { ------------------ | | 150| 0|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 0|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 0|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ ------------------ | Branch (25:11): [Folded, False: 0] ------------------ 26| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 27| 0| } 28| | 29| 0| if ((err = mp_init_multi(&tmpG, &tmpX, NULL)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (29:11): [True: 0, False: 0] ------------------ 30| 0| return err; 31| 0| } 32| | 33| | /* first compute 1/G mod P */ 34| 0| if ((err = mp_invmod(G, P, &tmpG)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (34:11): [True: 0, False: 0] ------------------ 35| 0| goto LBL_ERR; 36| 0| } 37| | 38| | /* now get |X| */ 39| 0| if ((err = mp_abs(X, &tmpX)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (39:11): [True: 0, False: 0] ------------------ 40| 0| goto LBL_ERR; 41| 0| } 42| | 43| | /* and now compute (1/G)**|X| instead of G**X [X < 0] */ 44| 0| err = mp_exptmod(&tmpG, &tmpX, P, Y); 45| 0|LBL_ERR: 46| 0| mp_clear_multi(&tmpG, &tmpX, NULL); 47| 0| return err; 48| 0| } 49| | 50| | /* modified diminished radix reduction */ 51| 3.28k| if (MP_HAS(MP_REDUCE_IS_2K_L) && MP_HAS(MP_REDUCE_2K_L) && MP_HAS(S_MP_EXPTMOD) && ------------------ | | 150| 6.57k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 3.28k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 3.28k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 0, Folded] | | ------------------ ------------------ if (MP_HAS(MP_REDUCE_IS_2K_L) && MP_HAS(MP_REDUCE_2K_L) && MP_HAS(S_MP_EXPTMOD) && ------------------ | | 150| 3.28k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 0|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 0|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 0, Folded] | | ------------------ ------------------ if (MP_HAS(MP_REDUCE_IS_2K_L) && MP_HAS(MP_REDUCE_2K_L) && MP_HAS(S_MP_EXPTMOD) && ------------------ | | 150| 3.28k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 0|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 0|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 0, Folded] | | ------------------ ------------------ 52| 3.28k| (mp_reduce_is_2k_l(P) == MP_YES)) { ------------------ | | 158| 3.28k|#define MP_YES 1 ------------------ | Branch (52:8): [True: 396, False: 2.89k] ------------------ 53| 396| return s_mp_exptmod(G, X, P, Y, 1); 54| 396| } 55| | 56| | /* is it a DR modulus? default to no */ 57| 2.89k| dr = (MP_HAS(MP_DR_IS_MODULUS) && (mp_dr_is_modulus(P) == MP_YES)) ? 1 : 0; ------------------ | | 150| 5.78k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 2.89k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 2.89k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 2.89k, Folded] | | ------------------ ------------------ dr = (MP_HAS(MP_DR_IS_MODULUS) && (mp_dr_is_modulus(P) == MP_YES)) ? 1 : 0; ------------------ | | 158| 2.89k|#define MP_YES 1 ------------------ | Branch (57:38): [True: 0, False: 2.89k] ------------------ 58| | 59| | /* if not, is it a unrestricted DR modulus? */ 60| 2.89k| if (MP_HAS(MP_REDUCE_IS_2K) && (dr == 0)) { ------------------ | | 150| 5.78k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 2.89k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 2.89k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 2.89k, Folded] | | ------------------ ------------------ | Branch (60:35): [True: 2.89k, False: 0] ------------------ 61| 2.89k| dr = (mp_reduce_is_2k(P) == MP_YES) ? 2 : 0; ------------------ | | 158| 2.89k|#define MP_YES 1 ------------------ | Branch (61:12): [True: 0, False: 2.89k] ------------------ 62| 2.89k| } 63| | 64| | /* if the modulus is odd or dr != 0 use the montgomery method */ 65| 2.89k| if (MP_HAS(S_MP_EXPTMOD_FAST) && (MP_IS_ODD(P) || (dr != 0))) { ------------------ | | 150| 5.78k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 2.89k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 2.89k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 2.89k, Folded] | | ------------------ ------------------ if (MP_HAS(S_MP_EXPTMOD_FAST) && (MP_IS_ODD(P) || (dr != 0))) { ------------------ | | 165| 5.78k|#define MP_IS_ODD(a) (((a)->used > 0) && (((a)->dp[0] & 1u) == 1u)) | | ------------------ | | | Branch (165:24): [True: 2.89k, False: 0] | | | Branch (165:43): [True: 2.37k, False: 515] | | ------------------ ------------------ | Branch (65:54): [True: 0, False: 515] ------------------ 66| 2.37k| return s_mp_exptmod_fast(G, X, P, Y, dr); 67| 2.37k| } else if (MP_HAS(S_MP_EXPTMOD)) { ------------------ | | 150| 515|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 515|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 515|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 515, Folded] | | ------------------ ------------------ 68| | /* otherwise use the generic Barrett reduction technique */ 69| 515| return s_mp_exptmod(G, X, P, Y, 0); 70| 515| } else { 71| | /* no exptmod for evens */ 72| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 73| 0| } 74| 2.89k|} mp_from_ubin: 8| 6.68k|{ 9| 6.68k| mp_err err; 10| | 11| | /* make sure there are at least two digits */ 12| 6.68k| if (a->alloc < 2) { ------------------ | Branch (12:8): [True: 0, False: 6.68k] ------------------ 13| 0| if ((err = mp_grow(a, 2)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (13:11): [True: 0, False: 0] ------------------ 14| 0| return err; 15| 0| } 16| 0| } 17| | 18| | /* zero the int */ 19| 6.68k| mp_zero(a); 20| | 21| | /* read the bytes in */ 22| 1.13M| while (size-- > 0u) { ------------------ | Branch (22:11): [True: 1.12M, False: 6.68k] ------------------ 23| 1.12M| if ((err = mp_mul_2d(a, 8, a)) != MP_OKAY) { ------------------ | | 161| 1.12M|#define MP_OKAY 0 /* no error */ ------------------ | Branch (23:11): [True: 0, False: 1.12M] ------------------ 24| 0| return err; 25| 0| } 26| | 27| 1.12M|#ifndef MP_8BIT 28| 1.12M| a->dp[0] |= *buf++; 29| 1.12M| a->used += 1; 30| |#else 31| | a->dp[0] = (*buf & MP_MASK); 32| | a->dp[1] |= ((*buf++ >> 7) & 1u); 33| | a->used += 2; 34| |#endif 35| 1.12M| } 36| 6.68k| mp_clamp(a); 37| 6.68k| return MP_OKAY; ------------------ | | 161| 6.68k|#define MP_OKAY 0 /* no error */ ------------------ 38| 6.68k|} mp_grow: 8| 453k|{ 9| 453k| int i; 10| 453k| mp_digit *tmp; 11| | 12| 453k| if (size < 0) { ------------------ | Branch (12:8): [True: 0, False: 453k] ------------------ 13| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 14| 0| } 15| | 16| | /* if the alloc size is smaller alloc more ram */ 17| 453k| if (a->alloc < size) { ------------------ | Branch (17:8): [True: 447k, False: 6.84k] ------------------ 18| | /* reallocate the array a->dp 19| | * 20| | * We store the return in a temporary variable 21| | * in case the operation failed we don't want 22| | * to overwrite the dp member of a. 23| | */ 24| 447k| tmp = (mp_digit *) MP_REALLOC(a->dp, ------------------ | | 1325| 447k|#define MP_REALLOC m_realloc_ltm ------------------ 25| 447k| (size_t)a->alloc * sizeof(mp_digit), 26| 447k| (size_t)size * sizeof(mp_digit)); 27| 447k| if (tmp == NULL) { ------------------ | Branch (27:11): [True: 0, False: 447k] ------------------ 28| | /* reallocation failed but "a" is still valid [can be freed] */ 29| 0| return MP_MEM; ------------------ | | 163| 0|#define MP_MEM -2 /* out of mem */ ------------------ 30| 0| } 31| | 32| | /* reallocation succeeded so set a->dp */ 33| 447k| a->dp = tmp; 34| | 35| | /* zero excess digits */ 36| 447k| i = a->alloc; 37| 447k| a->alloc = size; 38| 447k| MP_ZERO_DIGITS(a->dp + i, a->alloc - i); ------------------ | | 89| 447k|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 447k|do { \ | | 91| 447k| int zd_ = (digits); \ | | 92| 447k| mp_digit* zm_ = (mem); \ | | 93| 1.49M| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 1.04M, False: 447k] | | ------------------ | | 94| 1.04M| *zm_++ = 0; \ | | 95| 1.04M| } \ | | 96| 447k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 447k] | | ------------------ ------------------ 39| 447k| } 40| 453k| return MP_OKAY; ------------------ | | 161| 453k|#define MP_OKAY 0 /* no error */ ------------------ 41| 453k|} mp_init: 8| 772k|{ 9| | /* allocate memory required and clear it */ 10| 772k| a->dp = (mp_digit *) MP_CALLOC((size_t)MP_PREC, sizeof(mp_digit)); ------------------ | | 1326| 772k|#define MP_CALLOC m_calloc ------------------ a->dp = (mp_digit *) MP_CALLOC((size_t)MP_PREC, sizeof(mp_digit)); ------------------ | | 177| 772k|# define MP_PREC PRIVATE_MP_PREC | | ------------------ | | | | 193| 772k|# define PRIVATE_MP_PREC 32 /* default digits of precision */ | | ------------------ ------------------ 11| 772k| if (a->dp == NULL) { ------------------ | Branch (11:8): [True: 0, False: 772k] ------------------ 12| 0| return MP_MEM; ------------------ | | 163| 0|#define MP_MEM -2 /* out of mem */ ------------------ 13| 0| } 14| | 15| | /* set the used to zero, allocated digits to the default precision 16| | * and sign to positive */ 17| 772k| a->used = 0; 18| 772k| a->alloc = MP_PREC; ------------------ | | 177| 772k|# define MP_PREC PRIVATE_MP_PREC | | ------------------ | | | | 193| 772k|# define PRIVATE_MP_PREC 32 /* default digits of precision */ | | ------------------ ------------------ 19| 772k| a->sign = MP_ZPOS; ------------------ | | 151| 772k|#define MP_ZPOS 0 /* positive integer */ ------------------ 20| | 21| 772k| return MP_OKAY; ------------------ | | 161| 772k|#define MP_OKAY 0 /* no error */ ------------------ 22| 772k|} mp_init_copy: 8| 242k|{ 9| 242k| mp_err err; 10| | 11| 242k| if ((err = mp_init_size(a, b->used)) != MP_OKAY) { ------------------ | | 161| 242k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (11:8): [True: 0, False: 242k] ------------------ 12| 0| return err; 13| 0| } 14| | 15| 242k| if ((err = mp_copy(b, a)) != MP_OKAY) { ------------------ | | 161| 242k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (15:8): [True: 0, False: 242k] ------------------ 16| 0| mp_clear(a); 17| 0| } 18| | 19| 242k| return err; 20| 242k|} mp_init_multi: 9| 742|{ 10| 742| mp_err err = MP_OKAY; /* Assume ok until proven otherwise */ ------------------ | | 161| 742|#define MP_OKAY 0 /* no error */ ------------------ 11| 742| int n = 0; /* Number of ok inits */ 12| 742| mp_int *cur_arg = mp; 13| 742| va_list args; 14| | 15| 742| va_start(args, mp); /* init args to next argument from caller */ 16| 5.34k| while (cur_arg != NULL) { ------------------ | Branch (16:11): [True: 4.60k, False: 742] ------------------ 17| 4.60k| if (mp_init(cur_arg) != MP_OKAY) { ------------------ | | 161| 4.60k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (17:11): [True: 0, False: 4.60k] ------------------ 18| | /* Oops - error! Back-track and mp_clear what we already 19| | succeeded in init-ing, then return error. 20| | */ 21| 0| va_list clean_args; 22| | 23| | /* now start cleaning up */ 24| 0| cur_arg = mp; 25| 0| va_start(clean_args, mp); 26| 0| while (n-- != 0) { ------------------ | Branch (26:17): [True: 0, False: 0] ------------------ 27| 0| mp_clear(cur_arg); 28| 0| cur_arg = va_arg(clean_args, mp_int *); 29| 0| } 30| 0| va_end(clean_args); 31| 0| err = MP_MEM; ------------------ | | 163| 0|#define MP_MEM -2 /* out of mem */ ------------------ 32| 0| break; 33| 0| } 34| 4.60k| n++; 35| 4.60k| cur_arg = va_arg(args, mp_int *); 36| 4.60k| } 37| | va_end(args); 38| 742| return err; /* Assumed ok, if error flagged above. */ 39| 742|} mp_init_set: 8| 94|{ 9| 94| mp_err err; 10| 94| if ((err = mp_init(a)) != MP_OKAY) { ------------------ | | 161| 94|#define MP_OKAY 0 /* no error */ ------------------ | Branch (10:8): [True: 0, False: 94] ------------------ 11| 0| return err; 12| 0| } 13| 94| mp_set(a, b); 14| 94| return err; 15| 94|} mp_init_size: 8| 501k|{ 9| | 10| 501k| if (size < 0) { ------------------ | Branch (10:8): [True: 0, False: 501k] ------------------ 11| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 12| 0| } 13| | 14| 501k| size = MP_MAX(MP_MIN_PREC, size); ------------------ | | 157| 501k|#define MP_MAX(x, y) (((x) > (y)) ? (x) : (y)) | | ------------------ | | | Branch (157:23): [True: 11.7k, False: 489k] | | ------------------ ------------------ 15| | 16| | /* alloc mem */ 17| 501k| a->dp = (mp_digit *) MP_CALLOC((size_t)size, sizeof(mp_digit)); ------------------ | | 1326| 501k|#define MP_CALLOC m_calloc ------------------ 18| 501k| if (a->dp == NULL) { ------------------ | Branch (18:8): [True: 0, False: 501k] ------------------ 19| 0| return MP_MEM; ------------------ | | 163| 0|#define MP_MEM -2 /* out of mem */ ------------------ 20| 0| } 21| | 22| | /* set the members */ 23| 501k| a->used = 0; 24| 501k| a->alloc = size; 25| 501k| a->sign = MP_ZPOS; ------------------ | | 151| 501k|#define MP_ZPOS 0 /* positive integer */ ------------------ 26| | 27| 501k| return MP_OKAY; ------------------ | | 161| 501k|#define MP_OKAY 0 /* no error */ ------------------ 28| 501k|} mp_invmod: 8| 742|{ 9| | /* b cannot be negative and has to be >1 */ 10| 742| if ((b->sign == MP_NEG) || (mp_cmp_d(b, 1uL) != MP_GT)) { ------------------ | | 152| 742|#define MP_NEG 1 /* negative */ ------------------ if ((b->sign == MP_NEG) || (mp_cmp_d(b, 1uL) != MP_GT)) { ------------------ | | 156| 742|#define MP_GT 1 /* greater than */ ------------------ | Branch (10:8): [True: 0, False: 742] | Branch (10:31): [True: 0, False: 742] ------------------ 11| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 12| 0| } 13| | 14| | /* if the modulus is odd we can use a faster routine instead */ 15| 742| if (MP_HAS(S_MP_INVMOD_FAST) && MP_IS_ODD(b)) { ------------------ | | 150| 1.48k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 742|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 742|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 742, Folded] | | ------------------ ------------------ if (MP_HAS(S_MP_INVMOD_FAST) && MP_IS_ODD(b)) { ------------------ | | 165| 742|#define MP_IS_ODD(a) (((a)->used > 0) && (((a)->dp[0] & 1u) == 1u)) | | ------------------ | | | Branch (165:24): [True: 742, False: 0] | | | Branch (165:43): [True: 668, False: 74] | | ------------------ ------------------ 16| 668| return s_mp_invmod_fast(a, b, c); 17| 668| } 18| | 19| 74| return MP_HAS(S_MP_INVMOD_SLOW) ------------------ | | 150| 74|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 74|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 74|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 74, Folded] | | ------------------ ------------------ 20| 74| ? s_mp_invmod_slow(a, b, c) 21| 74| : MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 22| 742|} mp_is_square: 30| 152|{ 31| 152| mp_err err; 32| 152| mp_digit c; 33| 152| mp_int t; 34| 152| unsigned long r; 35| | 36| | /* Default to Non-square :) */ 37| 152| *ret = MP_NO; ------------------ | | 159| 152|#define MP_NO 0 ------------------ 38| | 39| 152| if (arg->sign == MP_NEG) { ------------------ | | 152| 152|#define MP_NEG 1 /* negative */ ------------------ | Branch (39:8): [True: 0, False: 152] ------------------ 40| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 41| 0| } 42| | 43| 152| if (MP_IS_ZERO(arg)) { ------------------ | | 163| 152|#define MP_IS_ZERO(a) ((a)->used == 0) | | ------------------ | | | Branch (163:23): [True: 0, False: 152] | | ------------------ ------------------ 44| 0| return MP_OKAY; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ 45| 0| } 46| | 47| | /* First check mod 128 (suppose that MP_DIGIT_BIT is at least 7) */ 48| 152| if (rem_128[127u & arg->dp[0]] == (char)1) { ------------------ | Branch (48:8): [True: 19, False: 133] ------------------ 49| 19| return MP_OKAY; ------------------ | | 161| 19|#define MP_OKAY 0 /* no error */ ------------------ 50| 19| } 51| | 52| | /* Next check mod 105 (3*5*7) */ 53| 133| if ((err = mp_mod_d(arg, 105uL, &c)) != MP_OKAY) { ------------------ | | 161| 133|#define MP_OKAY 0 /* no error */ ------------------ | Branch (53:8): [True: 0, False: 133] ------------------ 54| 0| return err; 55| 0| } 56| 133| if (rem_105[c] == (char)1) { ------------------ | Branch (56:8): [True: 89, False: 44] ------------------ 57| 89| return MP_OKAY; ------------------ | | 161| 89|#define MP_OKAY 0 /* no error */ ------------------ 58| 89| } 59| | 60| | 61| 44| if ((err = mp_init_u32(&t, 11u*13u*17u*19u*23u*29u*31u)) != MP_OKAY) { ------------------ | | 161| 44|#define MP_OKAY 0 /* no error */ ------------------ | Branch (61:8): [True: 0, False: 44] ------------------ 62| 0| return err; 63| 0| } 64| 44| if ((err = mp_mod(arg, &t, &t)) != MP_OKAY) { ------------------ | | 161| 44|#define MP_OKAY 0 /* no error */ ------------------ | Branch (64:8): [True: 0, False: 44] ------------------ 65| 0| goto LBL_ERR; 66| 0| } 67| 44| r = mp_get_u32(&t); ------------------ | | 310| 44|#define mp_get_u32(a) ((uint32_t)mp_get_i32(a)) ------------------ 68| | /* Check for other prime modules, note it's not an ERROR but we must 69| | * free "t" so the easiest way is to goto LBL_ERR. We know that err 70| | * is already equal to MP_OKAY from the mp_mod call 71| | */ 72| 44| if (((1uL<<(r%11uL)) & 0x5C4uL) != 0uL) goto LBL_ERR; ------------------ | Branch (72:8): [True: 10, False: 34] ------------------ 73| 34| if (((1uL<<(r%13uL)) & 0x9E4uL) != 0uL) goto LBL_ERR; ------------------ | Branch (73:8): [True: 7, False: 27] ------------------ 74| 27| if (((1uL<<(r%17uL)) & 0x5CE8uL) != 0uL) goto LBL_ERR; ------------------ | Branch (74:8): [True: 6, False: 21] ------------------ 75| 21| if (((1uL<<(r%19uL)) & 0x4F50CuL) != 0uL) goto LBL_ERR; ------------------ | Branch (75:8): [True: 11, False: 10] ------------------ 76| 10| if (((1uL<<(r%23uL)) & 0x7ACCA0uL) != 0uL) goto LBL_ERR; ------------------ | Branch (76:8): [True: 3, False: 7] ------------------ 77| 7| if (((1uL<<(r%29uL)) & 0xC2EDD0CuL) != 0uL) goto LBL_ERR; ------------------ | Branch (77:8): [True: 1, False: 6] ------------------ 78| 6| if (((1uL<<(r%31uL)) & 0x6DE2B848uL) != 0uL) goto LBL_ERR; ------------------ | Branch (78:8): [True: 1, False: 5] ------------------ 79| | 80| | /* Final check - is sqr(sqrt(arg)) == arg ? */ 81| 5| if ((err = mp_sqrt(arg, &t)) != MP_OKAY) { ------------------ | | 161| 5|#define MP_OKAY 0 /* no error */ ------------------ | Branch (81:8): [True: 0, False: 5] ------------------ 82| 0| goto LBL_ERR; 83| 0| } 84| 5| if ((err = mp_sqr(&t, &t)) != MP_OKAY) { ------------------ | | 161| 5|#define MP_OKAY 0 /* no error */ ------------------ | Branch (84:8): [True: 0, False: 5] ------------------ 85| 0| goto LBL_ERR; 86| 0| } 87| | 88| 5| *ret = (mp_cmp_mag(&t, arg) == MP_EQ) ? MP_YES : MP_NO; ------------------ | | 155| 5|#define MP_EQ 0 /* equal to */ ------------------ *ret = (mp_cmp_mag(&t, arg) == MP_EQ) ? MP_YES : MP_NO; ------------------ | | 158| 1|#define MP_YES 1 ------------------ *ret = (mp_cmp_mag(&t, arg) == MP_EQ) ? MP_YES : MP_NO; ------------------ | | 159| 9|#define MP_NO 0 ------------------ | Branch (88:11): [True: 1, False: 4] ------------------ 89| 44|LBL_ERR: 90| 44| mp_clear(&t); 91| 44| return err; 92| 5|} mp_lshd: 8| 417k|{ 9| 417k| int x; 10| 417k| mp_err err; 11| 417k| mp_digit *top, *bottom; 12| | 13| | /* if its less than zero return */ 14| 417k| if (b <= 0) { ------------------ | Branch (14:8): [True: 101k, False: 315k] ------------------ 15| 101k| return MP_OKAY; ------------------ | | 161| 101k|#define MP_OKAY 0 /* no error */ ------------------ 16| 101k| } 17| | /* no need to shift 0 around */ 18| 315k| if (MP_IS_ZERO(a)) { ------------------ | | 163| 315k|#define MP_IS_ZERO(a) ((a)->used == 0) | | ------------------ | | | Branch (163:23): [True: 466, False: 315k] | | ------------------ ------------------ 19| 466| return MP_OKAY; ------------------ | | 161| 466|#define MP_OKAY 0 /* no error */ ------------------ 20| 466| } 21| | 22| | /* grow to fit the new digits */ 23| 315k| if (a->alloc < (a->used + b)) { ------------------ | Branch (23:8): [True: 98.2k, False: 217k] ------------------ 24| 98.2k| if ((err = mp_grow(a, a->used + b)) != MP_OKAY) { ------------------ | | 161| 98.2k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (24:11): [True: 0, False: 98.2k] ------------------ 25| 0| return err; 26| 0| } 27| 98.2k| } 28| | 29| | /* increment the used by the shift amount then copy upwards */ 30| 315k| a->used += b; 31| | 32| | /* top */ 33| 315k| top = a->dp + a->used - 1; 34| | 35| | /* base */ 36| 315k| bottom = (a->dp + a->used - 1) - b; 37| | 38| | /* much like mp_rshd this is implemented using a sliding window 39| | * except the window goes the otherway around. Copying from 40| | * the bottom to the top. see bn_mp_rshd.c for more info. 41| | */ 42| 2.02M| for (x = a->used - 1; x >= b; x--) { ------------------ | Branch (42:26): [True: 1.71M, False: 315k] ------------------ 43| 1.71M| *top-- = *bottom--; 44| 1.71M| } 45| | 46| | /* zero the lower digits */ 47| 315k| MP_ZERO_DIGITS(a->dp, b); ------------------ | | 89| 315k|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 315k|do { \ | | 91| 315k| int zd_ = (digits); \ | | 92| 315k| mp_digit* zm_ = (mem); \ | | 93| 1.33M| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 1.01M, False: 315k] | | ------------------ | | 94| 1.01M| *zm_++ = 0; \ | | 95| 1.01M| } \ | | 96| 315k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 315k] | | ------------------ ------------------ 48| | 49| 315k| return MP_OKAY; ------------------ | | 161| 315k|#define MP_OKAY 0 /* no error */ ------------------ 50| 315k|} mp_mod: 8| 101k|{ 9| 101k| mp_int t; 10| 101k| mp_err err; 11| | 12| 101k| if ((err = mp_init_size(&t, b->used)) != MP_OKAY) { ------------------ | | 161| 101k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (12:8): [True: 0, False: 101k] ------------------ 13| 0| return err; 14| 0| } 15| | 16| 101k| if ((err = mp_div(a, b, NULL, &t)) != MP_OKAY) { ------------------ | | 161| 101k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (16:8): [True: 0, False: 101k] ------------------ 17| 0| goto LBL_ERR; 18| 0| } 19| | 20| 101k| if (MP_IS_ZERO(&t) || (t.sign == b->sign)) { ------------------ | | 163| 202k|#define MP_IS_ZERO(a) ((a)->used == 0) | | ------------------ | | | Branch (163:23): [True: 769, False: 100k] | | ------------------ ------------------ | Branch (20:26): [True: 100k, False: 277] ------------------ 21| 101k| err = MP_OKAY; ------------------ | | 161| 101k|#define MP_OKAY 0 /* no error */ ------------------ 22| 101k| mp_exch(&t, c); 23| 101k| } else { 24| 277| err = mp_add(b, &t, c); 25| 277| } 26| | 27| 101k|LBL_ERR: 28| 101k| mp_clear(&t); 29| 101k| return err; 30| 101k|} mp_mod_2d: 8| 2.20M|{ 9| 2.20M| int x; 10| 2.20M| mp_err err; 11| | 12| | /* if b is <= 0 then zero the int */ 13| 2.20M| if (b <= 0) { ------------------ | Branch (13:8): [True: 0, False: 2.20M] ------------------ 14| 0| mp_zero(c); 15| 0| return MP_OKAY; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ 16| 0| } 17| | 18| | /* if the modulus is larger than the value than return */ 19| 2.20M| if (b >= (a->used * MP_DIGIT_BIT)) { ------------------ | | 82| 2.20M|# define MP_DIGIT_BIT 60 ------------------ | Branch (19:8): [True: 30.4k, False: 2.17M] ------------------ 20| 30.4k| return mp_copy(a, c); 21| 30.4k| } 22| | 23| | /* copy */ 24| 2.17M| if ((err = mp_copy(a, c)) != MP_OKAY) { ------------------ | | 161| 2.17M|#define MP_OKAY 0 /* no error */ ------------------ | Branch (24:8): [True: 0, False: 2.17M] ------------------ 25| 0| return err; 26| 0| } 27| | 28| | /* zero digits above the last digit of the modulus */ 29| 2.17M| x = (b / MP_DIGIT_BIT) + (((b % MP_DIGIT_BIT) == 0) ? 0 : 1); ------------------ | | 82| 2.17M|# define MP_DIGIT_BIT 60 ------------------ x = (b / MP_DIGIT_BIT) + (((b % MP_DIGIT_BIT) == 0) ? 0 : 1); ------------------ | | 82| 2.17M|# define MP_DIGIT_BIT 60 ------------------ | Branch (29:30): [True: 87.1k, False: 2.08M] ------------------ 30| 2.17M| MP_ZERO_DIGITS(c->dp + x, c->used - x); ------------------ | | 89| 2.17M|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 2.17M|do { \ | | 91| 2.17M| int zd_ = (digits); \ | | 92| 2.17M| mp_digit* zm_ = (mem); \ | | 93| 29.3M| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 27.1M, False: 2.17M] | | ------------------ | | 94| 27.1M| *zm_++ = 0; \ | | 95| 27.1M| } \ | | 96| 2.17M|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2.17M] | | ------------------ ------------------ 31| | 32| | /* clear the digit that is not completely outside/inside the modulus */ 33| 2.17M| c->dp[b / MP_DIGIT_BIT] &= ------------------ | | 82| 2.17M|# define MP_DIGIT_BIT 60 ------------------ 34| 2.17M| ((mp_digit)1 << (mp_digit)(b % MP_DIGIT_BIT)) - (mp_digit)1; ------------------ | | 82| 2.17M|# define MP_DIGIT_BIT 60 ------------------ 35| 2.17M| mp_clamp(c); 36| 2.17M| return MP_OKAY; ------------------ | | 161| 2.17M|#define MP_OKAY 0 /* no error */ ------------------ 37| 2.17M|} mp_mod_d: 7| 26.2k|{ 8| | return mp_div_d(a, b, NULL, c); 9| 26.2k|} mp_montgomery_calc_normalization: 13| 2.63k|{ 14| 2.63k| int x, bits; 15| 2.63k| mp_err err; 16| | 17| | /* how many bits of last digit does b use */ 18| 2.63k| bits = mp_count_bits(b) % MP_DIGIT_BIT; ------------------ | | 82| 2.63k|# define MP_DIGIT_BIT 60 ------------------ 19| | 20| 2.63k| if (b->used > 1) { ------------------ | Branch (20:8): [True: 2.63k, False: 0] ------------------ 21| 2.63k| if ((err = mp_2expt(a, ((b->used - 1) * MP_DIGIT_BIT) + bits - 1)) != MP_OKAY) { ------------------ | | 82| 2.63k|# define MP_DIGIT_BIT 60 ------------------ if ((err = mp_2expt(a, ((b->used - 1) * MP_DIGIT_BIT) + bits - 1)) != MP_OKAY) { ------------------ | | 161| 2.63k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (21:11): [True: 0, False: 2.63k] ------------------ 22| 0| return err; 23| 0| } 24| 2.63k| } else { 25| 0| mp_set(a, 1uL); 26| 0| bits = 1; 27| 0| } 28| | 29| | 30| | /* now compute C = A * B mod b */ 31| 78.8k| for (x = bits - 1; x < (int)MP_DIGIT_BIT; x++) { ------------------ | | 82| 78.8k|# define MP_DIGIT_BIT 60 ------------------ | Branch (31:23): [True: 76.2k, False: 2.63k] ------------------ 32| 76.2k| if ((err = mp_mul_2(a, a)) != MP_OKAY) { ------------------ | | 161| 76.2k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (32:11): [True: 0, False: 76.2k] ------------------ 33| 0| return err; 34| 0| } 35| 76.2k| if (mp_cmp_mag(a, b) != MP_LT) { ------------------ | | 154| 76.2k|#define MP_LT -1 /* less than */ ------------------ | Branch (35:11): [True: 27.9k, False: 48.2k] ------------------ 36| 27.9k| if ((err = s_mp_sub(a, b, a)) != MP_OKAY) { ------------------ | | 161| 27.9k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (36:14): [True: 0, False: 27.9k] ------------------ 37| 0| return err; 38| 0| } 39| 27.9k| } 40| 76.2k| } 41| | 42| 2.63k| return MP_OKAY; ------------------ | | 161| 2.63k|#define MP_OKAY 0 /* no error */ ------------------ 43| 2.63k|} mp_montgomery_reduce: 8| 1.36M|{ 9| 1.36M| int ix, digs; 10| 1.36M| mp_err err; 11| 1.36M| mp_digit mu; 12| | 13| | /* can the fast reduction [comba] method be used? 14| | * 15| | * Note that unlike in mul you're safely allowed *less* 16| | * than the available columns [255 per default] since carries 17| | * are fixed up in the inner loop. 18| | */ 19| 1.36M| digs = (n->used * 2) + 1; 20| 1.36M| if ((digs < MP_WARRAY) && ------------------ | | 172| 1.36M|#define MP_WARRAY PRIVATE_MP_WARRAY | | ------------------ | | | | 203| 1.36M|#define PRIVATE_MP_WARRAY (int)(1uLL << (((CHAR_BIT * sizeof(private_mp_word)) - (2 * MP_DIGIT_BIT)) + 1)) | | | | ------------------ | | | | | | 82| 1.36M|# define MP_DIGIT_BIT 60 | | | | ------------------ | | ------------------ ------------------ | Branch (20:8): [True: 1.36M, False: 0] ------------------ 21| 1.36M| (x->used <= MP_WARRAY) && ------------------ | | 172| 1.36M|#define MP_WARRAY PRIVATE_MP_WARRAY | | ------------------ | | | | 203| 1.36M|#define PRIVATE_MP_WARRAY (int)(1uLL << (((CHAR_BIT * sizeof(private_mp_word)) - (2 * MP_DIGIT_BIT)) + 1)) | | | | ------------------ | | | | | | 82| 1.36M|# define MP_DIGIT_BIT 60 | | | | ------------------ | | ------------------ ------------------ | Branch (21:8): [True: 1.36M, False: 0] ------------------ 22| 1.36M| (n->used < MP_MAXFAST)) { ------------------ | | 168| 1.36M|#define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT))) | | ------------------ | | | | 167| 1.36M|#define MP_SIZEOF_BITS(type) ((size_t)CHAR_BIT * sizeof(type)) | | ------------------ | | #define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT))) | | ------------------ | | | | 82| 1.36M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ | Branch (22:8): [True: 1.36M, False: 0] ------------------ 23| 1.36M| return s_mp_montgomery_reduce_fast(x, n, rho); 24| 1.36M| } 25| | 26| | /* grow the input as required */ 27| 0| if (x->alloc < digs) { ------------------ | Branch (27:8): [True: 0, False: 0] ------------------ 28| 0| if ((err = mp_grow(x, digs)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (28:11): [True: 0, False: 0] ------------------ 29| 0| return err; 30| 0| } 31| 0| } 32| 0| x->used = digs; 33| | 34| 0| for (ix = 0; ix < n->used; ix++) { ------------------ | Branch (34:17): [True: 0, False: 0] ------------------ 35| | /* mu = ai * rho mod b 36| | * 37| | * The value of rho must be precalculated via 38| | * montgomery_setup() such that 39| | * it equals -1/n0 mod b this allows the 40| | * following inner loop to reduce the 41| | * input one digit at a time 42| | */ 43| 0| mu = (mp_digit)(((mp_word)x->dp[ix] * (mp_word)rho) & MP_MASK); ------------------ | | 106| 0|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 0|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 44| | 45| | /* a = a + mu * m * b**i */ 46| 0| { 47| 0| int iy; 48| 0| mp_digit *tmpn, *tmpx, u; 49| 0| mp_word r; 50| | 51| | /* alias for digits of the modulus */ 52| 0| tmpn = n->dp; 53| | 54| | /* alias for the digits of x [the input] */ 55| 0| tmpx = x->dp + ix; 56| | 57| | /* set the carry to zero */ 58| 0| u = 0; 59| | 60| | /* Multiply and add in place */ 61| 0| for (iy = 0; iy < n->used; iy++) { ------------------ | Branch (61:23): [True: 0, False: 0] ------------------ 62| | /* compute product and sum */ 63| 0| r = ((mp_word)mu * (mp_word)*tmpn++) + 64| 0| (mp_word)u + (mp_word)*tmpx; 65| | 66| | /* get carry */ 67| 0| u = (mp_digit)(r >> (mp_word)MP_DIGIT_BIT); ------------------ | | 82| 0|# define MP_DIGIT_BIT 60 ------------------ 68| | 69| | /* fix digit */ 70| 0| *tmpx++ = (mp_digit)(r & (mp_word)MP_MASK); ------------------ | | 106| 0|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 0|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 71| 0| } 72| | /* At this point the ix'th digit of x should be zero */ 73| | 74| | 75| | /* propagate carries upwards as required*/ 76| 0| while (u != 0u) { ------------------ | Branch (76:17): [True: 0, False: 0] ------------------ 77| 0| *tmpx += u; 78| 0| u = *tmpx >> MP_DIGIT_BIT; ------------------ | | 82| 0|# define MP_DIGIT_BIT 60 ------------------ 79| 0| *tmpx++ &= MP_MASK; ------------------ | | 106| 0|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 0|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 80| 0| } 81| 0| } 82| 0| } 83| | 84| | /* at this point the n.used'th least 85| | * significant digits of x are all zero 86| | * which means we can shift x to the 87| | * right by n.used digits and the 88| | * residue is unchanged. 89| | */ 90| | 91| | /* x = x/b**n.used */ 92| 0| mp_clamp(x); 93| 0| mp_rshd(x, n->used); 94| | 95| | /* if x >= n then x = x - n */ 96| 0| if (mp_cmp_mag(x, n) != MP_LT) { ------------------ | | 154| 0|#define MP_LT -1 /* less than */ ------------------ | Branch (96:8): [True: 0, False: 0] ------------------ 97| 0| return s_mp_sub(x, n, x); 98| 0| } 99| | 100| 0| return MP_OKAY; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ 101| 0|} mp_montgomery_setup: 8| 2.63k|{ 9| 2.63k| mp_digit x, b; 10| | 11| | /* fast inversion mod 2**k 12| | * 13| | * Based on the fact that 14| | * 15| | * XA = 1 (mod 2**n) => (X(2-XA)) A = 1 (mod 2**2n) 16| | * => 2*X*A - X*X*A*A = 1 17| | * => 2*(1) - (1) = 1 18| | */ 19| 2.63k| b = n->dp[0]; 20| | 21| 2.63k| if ((b & 1u) == 0u) { ------------------ | Branch (21:8): [True: 0, False: 2.63k] ------------------ 22| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 23| 0| } 24| | 25| 2.63k| x = (((b + 2u) & 4u) << 1) + b; /* here x*a==1 mod 2**4 */ 26| 2.63k| x *= 2u - (b * x); /* here x*a==1 mod 2**8 */ 27| 2.63k|#if !defined(MP_8BIT) 28| 2.63k| x *= 2u - (b * x); /* here x*a==1 mod 2**16 */ 29| 2.63k|#endif 30| 2.63k|#if defined(MP_64BIT) || !(defined(MP_8BIT) || defined(MP_16BIT)) 31| 2.63k| x *= 2u - (b * x); /* here x*a==1 mod 2**32 */ 32| 2.63k|#endif 33| 2.63k|#ifdef MP_64BIT 34| 2.63k| x *= 2u - (b * x); /* here x*a==1 mod 2**64 */ 35| 2.63k|#endif 36| | 37| | /* rho = -1/m mod b */ 38| 2.63k| *rho = (mp_digit)(((mp_word)1 << (mp_word)MP_DIGIT_BIT) - x) & MP_MASK; ------------------ | | 82| 2.63k|# define MP_DIGIT_BIT 60 ------------------ *rho = (mp_digit)(((mp_word)1 << (mp_word)MP_DIGIT_BIT) - x) & MP_MASK; ------------------ | | 106| 2.63k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 2.63k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 39| | 40| 2.63k| return MP_OKAY; ------------------ | | 161| 2.63k|#define MP_OKAY 0 /* no error */ ------------------ 41| 2.63k|} mp_mul: 8| 3.09M|{ 9| 3.09M| mp_err err; 10| 3.09M| int min_len = MP_MIN(a->used, b->used), ------------------ | | 156| 3.09M|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 1.99M, False: 1.10M] | | ------------------ ------------------ 11| 3.09M| max_len = MP_MAX(a->used, b->used), ------------------ | | 157| 3.09M|#define MP_MAX(x, y) (((x) > (y)) ? (x) : (y)) | | ------------------ | | | Branch (157:23): [True: 16.1k, False: 3.07M] | | ------------------ ------------------ 12| 3.09M| digs = a->used + b->used + 1; 13| 3.09M| mp_sign neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG; ------------------ | | 151| 3.09M|#define MP_ZPOS 0 /* positive integer */ ------------------ mp_sign neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG; ------------------ | | 152| 0|#define MP_NEG 1 /* negative */ ------------------ | Branch (13:18): [True: 3.09M, False: 0] ------------------ 14| | 15| 3.09M| if (MP_HAS(S_MP_BALANCE_MUL) && ------------------ | | 150| 6.19M|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 3.09M|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 3.09M|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 3.09M, Folded] | | ------------------ ------------------ 16| | /* Check sizes. The smaller one needs to be larger than the Karatsuba cut-off. 17| | * The bigger one needs to be at least about one MP_KARATSUBA_MUL_CUTOFF bigger 18| | * to make some sense, but it depends on architecture, OS, position of the 19| | * stars... so YMMV. 20| | * Using it to cut the input into slices small enough for fast_s_mp_mul_digs 21| | * was actually slower on the author's machine, but YMMV. 22| | */ 23| 3.09M| (min_len >= MP_KARATSUBA_MUL_CUTOFF) && ------------------ | | 121| 3.09M|# define MP_KARATSUBA_MUL_CUTOFF KARATSUBA_MUL_CUTOFF ------------------ | Branch (23:8): [True: 53.2k, False: 3.04M] ------------------ 24| 53.2k| ((max_len / 2) >= MP_KARATSUBA_MUL_CUTOFF) && ------------------ | | 121| 53.2k|# define MP_KARATSUBA_MUL_CUTOFF KARATSUBA_MUL_CUTOFF ------------------ | Branch (24:8): [True: 0, False: 53.2k] ------------------ 25| | /* Not much effect was observed below a ratio of 1:2, but again: YMMV. */ 26| 0| (max_len >= (2 * min_len))) { ------------------ | Branch (26:8): [True: 0, False: 0] ------------------ 27| 0| err = s_mp_balance_mul(a,b,c); 28| 3.09M| } else if (MP_HAS(S_MP_TOOM_MUL) && ------------------ | | 150| 6.19M|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 3.09M|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 3.09M|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [Folded, False: 3.09M] | | ------------------ ------------------ 29| 0| (min_len >= MP_TOOM_MUL_CUTOFF)) { ------------------ | | 123| 0|# define MP_TOOM_MUL_CUTOFF TOOM_MUL_CUTOFF ------------------ | Branch (29:15): [True: 0, False: 0] ------------------ 30| 0| err = s_mp_toom_mul(a, b, c); 31| 3.09M| } else if (MP_HAS(S_MP_KARATSUBA_MUL) && ------------------ | | 150| 6.19M|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 3.09M|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 3.09M|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [Folded, False: 3.09M] | | ------------------ ------------------ 32| 0| (min_len >= MP_KARATSUBA_MUL_CUTOFF)) { ------------------ | | 121| 0|# define MP_KARATSUBA_MUL_CUTOFF KARATSUBA_MUL_CUTOFF ------------------ | Branch (32:15): [True: 0, False: 0] ------------------ 33| 0| err = s_mp_karatsuba_mul(a, b, c); 34| 3.09M| } else if (MP_HAS(S_MP_MUL_DIGS_FAST) && ------------------ | | 150| 6.19M|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 3.09M|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 3.09M|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 3.09M, Folded] | | ------------------ ------------------ 35| | /* can we use the fast multiplier? 36| | * 37| | * The fast multiplier can be used if the output will 38| | * have less than MP_WARRAY digits and the number of 39| | * digits won't affect carry propagation 40| | */ 41| 3.09M| (digs < MP_WARRAY) && ------------------ | | 172| 3.09M|#define MP_WARRAY PRIVATE_MP_WARRAY | | ------------------ | | | | 203| 3.09M|#define PRIVATE_MP_WARRAY (int)(1uLL << (((CHAR_BIT * sizeof(private_mp_word)) - (2 * MP_DIGIT_BIT)) + 1)) | | | | ------------------ | | | | | | 82| 3.09M|# define MP_DIGIT_BIT 60 | | | | ------------------ | | ------------------ ------------------ | Branch (41:15): [True: 3.09M, False: 0] ------------------ 42| 3.09M| (min_len <= MP_MAXFAST)) { ------------------ | | 168| 3.09M|#define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT))) | | ------------------ | | | | 167| 3.09M|#define MP_SIZEOF_BITS(type) ((size_t)CHAR_BIT * sizeof(type)) | | ------------------ | | #define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT))) | | ------------------ | | | | 82| 3.09M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ | Branch (42:15): [True: 3.09M, False: 0] ------------------ 43| 3.09M| err = s_mp_mul_digs_fast(a, b, c, digs); 44| 3.09M| } else if (MP_HAS(S_MP_MUL_DIGS)) { ------------------ | | 150| 0|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 0|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 0|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 0, Folded] | | ------------------ ------------------ 45| 0| err = s_mp_mul_digs(a, b, c, digs); 46| 0| } else { 47| 0| err = MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 48| 0| } 49| 3.09M| c->sign = (c->used > 0) ? neg : MP_ZPOS; ------------------ | | 151| 3.12M|#define MP_ZPOS 0 /* positive integer */ ------------------ | Branch (49:14): [True: 3.07M, False: 25.0k] ------------------ 50| 3.09M| return err; 51| 3.09M|} mp_mul_2: 8| 76.2k|{ 9| 76.2k| int x, oldused; 10| 76.2k| mp_err err; 11| | 12| | /* grow to accomodate result */ 13| 76.2k| if (b->alloc < (a->used + 1)) { ------------------ | Branch (13:8): [True: 0, False: 76.2k] ------------------ 14| 0| if ((err = mp_grow(b, a->used + 1)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (14:11): [True: 0, False: 0] ------------------ 15| 0| return err; 16| 0| } 17| 0| } 18| | 19| 76.2k| oldused = b->used; 20| 76.2k| b->used = a->used; 21| | 22| 76.2k| { 23| 76.2k| mp_digit r, rr, *tmpa, *tmpb; 24| | 25| | /* alias for source */ 26| 76.2k| tmpa = a->dp; 27| | 28| | /* alias for dest */ 29| 76.2k| tmpb = b->dp; 30| | 31| | /* carry */ 32| 76.2k| r = 0; 33| 1.00M| for (x = 0; x < a->used; x++) { ------------------ | Branch (33:19): [True: 931k, False: 76.2k] ------------------ 34| | 35| | /* get what will be the *next* carry bit from the 36| | * MSB of the current digit 37| | */ 38| 931k| rr = *tmpa >> (mp_digit)(MP_DIGIT_BIT - 1); ------------------ | | 82| 931k|# define MP_DIGIT_BIT 60 ------------------ 39| | 40| | /* now shift up this digit, add in the carry [from the previous] */ 41| 931k| *tmpb++ = ((*tmpa++ << 1uL) | r) & MP_MASK; ------------------ | | 106| 931k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 931k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 42| | 43| | /* copy the carry that would be from the source 44| | * digit into the next iteration 45| | */ 46| 931k| r = rr; 47| 931k| } 48| | 49| | /* new leading digit? */ 50| 76.2k| if (r != 0u) { ------------------ | Branch (50:11): [True: 1.76k, False: 74.4k] ------------------ 51| | /* add a MSB which is always 1 at this point */ 52| 1.76k| *tmpb = 1; 53| 1.76k| ++(b->used); 54| 1.76k| } 55| | 56| | /* now zero any excess digits on the destination 57| | * that we didn't write to 58| | */ 59| 76.2k| MP_ZERO_DIGITS(b->dp + b->used, oldused - b->used); ------------------ | | 89| 76.2k|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 76.2k|do { \ | | 91| 76.2k| int zd_ = (digits); \ | | 92| 76.2k| mp_digit* zm_ = (mem); \ | | 93| 76.2k| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 0, False: 76.2k] | | ------------------ | | 94| 0| *zm_++ = 0; \ | | 95| 0| } \ | | 96| 76.2k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 76.2k] | | ------------------ ------------------ 60| 76.2k| } 61| 76.2k| b->sign = a->sign; 62| 76.2k| return MP_OKAY; ------------------ | | 161| 76.2k|#define MP_OKAY 0 /* no error */ ------------------ 63| 76.2k|} mp_mul_2d: 8| 1.32M|{ 9| 1.32M| mp_digit d; 10| 1.32M| mp_err err; 11| | 12| 1.32M| if (b < 0) { ------------------ | Branch (12:8): [True: 0, False: 1.32M] ------------------ 13| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 14| 0| } 15| | 16| | /* copy */ 17| 1.32M| if (a != c) { ------------------ | Branch (17:8): [True: 0, False: 1.32M] ------------------ 18| 0| if ((err = mp_copy(a, c)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (18:11): [True: 0, False: 0] ------------------ 19| 0| return err; 20| 0| } 21| 0| } 22| | 23| 1.32M| if (c->alloc < (c->used + (b / MP_DIGIT_BIT) + 1)) { ------------------ | | 82| 1.32M|# define MP_DIGIT_BIT 60 ------------------ | Branch (23:8): [True: 294k, False: 1.03M] ------------------ 24| 294k| if ((err = mp_grow(c, c->used + (b / MP_DIGIT_BIT) + 1)) != MP_OKAY) { ------------------ | | 82| 294k|# define MP_DIGIT_BIT 60 ------------------ if ((err = mp_grow(c, c->used + (b / MP_DIGIT_BIT) + 1)) != MP_OKAY) { ------------------ | | 161| 294k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (24:11): [True: 0, False: 294k] ------------------ 25| 0| return err; 26| 0| } 27| 294k| } 28| | 29| | /* shift by as many digits in the bit count */ 30| 1.32M| if (b >= MP_DIGIT_BIT) { ------------------ | | 82| 1.32M|# define MP_DIGIT_BIT 60 ------------------ | Branch (30:8): [True: 0, False: 1.32M] ------------------ 31| 0| if ((err = mp_lshd(c, b / MP_DIGIT_BIT)) != MP_OKAY) { ------------------ | | 82| 0|# define MP_DIGIT_BIT 60 ------------------ if ((err = mp_lshd(c, b / MP_DIGIT_BIT)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (31:11): [True: 0, False: 0] ------------------ 32| 0| return err; 33| 0| } 34| 0| } 35| | 36| | /* shift any bit count < MP_DIGIT_BIT */ 37| 1.32M| d = (mp_digit)(b % MP_DIGIT_BIT); ------------------ | | 82| 1.32M|# define MP_DIGIT_BIT 60 ------------------ 38| 1.32M| if (d != 0u) { ------------------ | Branch (38:8): [True: 1.32M, False: 0] ------------------ 39| 1.32M| mp_digit *tmpc, shift, mask, r, rr; 40| 1.32M| int x; 41| | 42| | /* bitmask for carries */ 43| 1.32M| mask = ((mp_digit)1 << d) - (mp_digit)1; 44| | 45| | /* shift for msbs */ 46| 1.32M| shift = (mp_digit)MP_DIGIT_BIT - d; ------------------ | | 82| 1.32M|# define MP_DIGIT_BIT 60 ------------------ 47| | 48| | /* alias */ 49| 1.32M| tmpc = c->dp; 50| | 51| | /* carry */ 52| 1.32M| r = 0; 53| 836M| for (x = 0; x < c->used; x++) { ------------------ | Branch (53:19): [True: 835M, False: 1.32M] ------------------ 54| | /* get the higher bits of the current word */ 55| 835M| rr = (*tmpc >> shift) & mask; 56| | 57| | /* shift the current word and OR in the carry */ 58| 835M| *tmpc = ((*tmpc << d) | r) & MP_MASK; ------------------ | | 106| 835M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 835M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 59| 835M| ++tmpc; 60| | 61| | /* set the carry to the carry bits of the current word */ 62| 835M| r = rr; 63| 835M| } 64| | 65| | /* set final carry */ 66| 1.32M| if (r != 0u) { ------------------ | Branch (66:11): [True: 2.80k, False: 1.32M] ------------------ 67| 2.80k| c->dp[(c->used)++] = r; 68| 2.80k| } 69| 1.32M| } 70| 1.32M| mp_clamp(c); 71| 1.32M| return MP_OKAY; ------------------ | | 161| 1.32M|#define MP_OKAY 0 /* no error */ ------------------ 72| 1.32M|} mp_mul_d: 8| 902k|{ 9| 902k| mp_digit u, *tmpa, *tmpc; 10| 902k| mp_word r; 11| 902k| mp_err err; 12| 902k| int ix, olduse; 13| | 14| | /* make sure c is big enough to hold a*b */ 15| 902k| if (c->alloc < (a->used + 1)) { ------------------ | Branch (15:8): [True: 92, False: 902k] ------------------ 16| 92| if ((err = mp_grow(c, a->used + 1)) != MP_OKAY) { ------------------ | | 161| 92|#define MP_OKAY 0 /* no error */ ------------------ | Branch (16:11): [True: 0, False: 92] ------------------ 17| 0| return err; 18| 0| } 19| 92| } 20| | 21| | /* get the original destinations used count */ 22| 902k| olduse = c->used; 23| | 24| | /* set the sign */ 25| 902k| c->sign = a->sign; 26| | 27| | /* alias for a->dp [source] */ 28| 902k| tmpa = a->dp; 29| | 30| | /* alias for c->dp [dest] */ 31| 902k| tmpc = c->dp; 32| | 33| | /* zero carry */ 34| 902k| u = 0; 35| | 36| | /* compute columns */ 37| 3.82M| for (ix = 0; ix < a->used; ix++) { ------------------ | Branch (37:17): [True: 2.92M, False: 902k] ------------------ 38| | /* compute product and carry sum for this term */ 39| 2.92M| r = (mp_word)u + ((mp_word)*tmpa++ * (mp_word)b); 40| | 41| | /* mask off higher bits to get a single digit */ 42| 2.92M| *tmpc++ = (mp_digit)(r & (mp_word)MP_MASK); ------------------ | | 106| 2.92M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 2.92M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 43| | 44| | /* send carry into next iteration */ 45| 2.92M| u = (mp_digit)(r >> (mp_word)MP_DIGIT_BIT); ------------------ | | 82| 2.92M|# define MP_DIGIT_BIT 60 ------------------ 46| 2.92M| } 47| | 48| | /* store final carry [if any] and increment ix offset */ 49| 902k| *tmpc++ = u; 50| 902k| ++ix; 51| | 52| | /* now zero digits above the top */ 53| 902k| MP_ZERO_DIGITS(tmpc, olduse - ix); ------------------ | | 89| 902k|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 902k|do { \ | | 91| 902k| int zd_ = (digits); \ | | 92| 902k| mp_digit* zm_ = (mem); \ | | 93| 902k| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 286, False: 902k] | | ------------------ | | 94| 286| *zm_++ = 0; \ | | 95| 286| } \ | | 96| 902k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 902k] | | ------------------ ------------------ 54| | 55| | /* set used count */ 56| 902k| c->used = a->used + 1; 57| 902k| mp_clamp(c); 58| | 59| 902k| return MP_OKAY; ------------------ | | 161| 902k|#define MP_OKAY 0 /* no error */ ------------------ 60| 902k|} mp_mulmod: 8| 5.08k|{ 9| 5.08k| mp_err err; 10| 5.08k| mp_int t; 11| | 12| 5.08k| if ((err = mp_init_size(&t, c->used)) != MP_OKAY) { ------------------ | | 161| 5.08k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (12:8): [True: 0, False: 5.08k] ------------------ 13| 0| return err; 14| 0| } 15| | 16| 5.08k| if ((err = mp_mul(a, b, &t)) != MP_OKAY) { ------------------ | | 161| 5.08k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (16:8): [True: 0, False: 5.08k] ------------------ 17| 0| goto LBL_ERR; 18| 0| } 19| 5.08k| err = mp_mod(&t, c, d); 20| | 21| 5.08k|LBL_ERR: 22| 5.08k| mp_clear(&t); 23| 5.08k| return err; 24| 5.08k|} mp_prime_is_prime: 18| 238|{ 19| 238| mp_int b; 20| 238| int ix, p_max = 0, size_a, len; 21| 238| mp_bool res; 22| 238| mp_err err; 23| 238| unsigned int fips_rand, mask; 24| | 25| | /* default to no */ 26| 238| *result = MP_NO; ------------------ | | 159| 238|#define MP_NO 0 ------------------ 27| | 28| | /* Some shortcuts */ 29| | /* N > 3 */ 30| 238| if (a->used == 1) { ------------------ | Branch (30:8): [True: 0, False: 238] ------------------ 31| 0| if ((a->dp[0] == 0u) || (a->dp[0] == 1u)) { ------------------ | Branch (31:11): [True: 0, False: 0] | Branch (31:31): [True: 0, False: 0] ------------------ 32| 0| *result = MP_NO; ------------------ | | 159| 0|#define MP_NO 0 ------------------ 33| 0| return MP_OKAY; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ 34| 0| } 35| 0| if (a->dp[0] == 2u) { ------------------ | Branch (35:11): [True: 0, False: 0] ------------------ 36| 0| *result = MP_YES; ------------------ | | 158| 0|#define MP_YES 1 ------------------ 37| 0| return MP_OKAY; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ 38| 0| } 39| 0| } 40| | 41| | /* N must be odd */ 42| 238| if (MP_IS_EVEN(a)) { ------------------ | | 164| 238|#define MP_IS_EVEN(a) (((a)->used == 0) || (((a)->dp[0] & 1u) == 0u)) | | ------------------ | | | Branch (164:24): [True: 0, False: 238] | | | Branch (164:44): [True: 86, False: 152] | | ------------------ ------------------ 43| 86| return MP_OKAY; ------------------ | | 161| 86|#define MP_OKAY 0 /* no error */ ------------------ 44| 86| } 45| | /* N is not a perfect square: floor(sqrt(N))^2 != N */ 46| 152| if ((err = mp_is_square(a, &res)) != MP_OKAY) { ------------------ | | 161| 152|#define MP_OKAY 0 /* no error */ ------------------ | Branch (46:8): [True: 0, False: 152] ------------------ 47| 0| return err; 48| 0| } 49| 152| if (res != MP_NO) { ------------------ | | 159| 152|#define MP_NO 0 ------------------ | Branch (49:8): [True: 1, False: 151] ------------------ 50| 1| return MP_OKAY; ------------------ | | 161| 1|#define MP_OKAY 0 /* no error */ ------------------ 51| 1| } 52| | 53| | /* is the input equal to one of the primes in the table? */ 54| 38.8k| for (ix = 0; ix < PRIVATE_MP_PRIME_TAB_SIZE; ix++) { ------------------ | | 633| 38.8k|# define PRIVATE_MP_PRIME_TAB_SIZE 256 ------------------ | Branch (54:17): [True: 38.6k, False: 151] ------------------ 55| 38.6k| if (mp_cmp_d(a, s_mp_prime_tab[ix]) == MP_EQ) { ------------------ | | 155| 38.6k|#define MP_EQ 0 /* equal to */ ------------------ | Branch (55:11): [True: 0, False: 38.6k] ------------------ 56| 0| *result = MP_YES; ------------------ | | 158| 0|#define MP_YES 1 ------------------ 57| 0| return MP_OKAY; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ 58| 0| } 59| 38.6k| } 60| |#ifdef MP_8BIT 61| | /* The search in the loop above was exhaustive in this case */ 62| | if ((a->used == 1) && (PRIVATE_MP_PRIME_TAB_SIZE >= 31)) { 63| | return MP_OKAY; 64| | } 65| |#endif 66| | 67| | /* first perform trial division */ 68| 151| if ((err = s_mp_prime_is_divisible(a, &res)) != MP_OKAY) { ------------------ | | 161| 151|#define MP_OKAY 0 /* no error */ ------------------ | Branch (68:8): [True: 0, False: 151] ------------------ 69| 0| return err; 70| 0| } 71| | 72| | /* return if it was trivially divisible */ 73| 151| if (res == MP_YES) { ------------------ | | 158| 151|#define MP_YES 1 ------------------ | Branch (73:8): [True: 57, False: 94] ------------------ 74| 57| return MP_OKAY; ------------------ | | 161| 57|#define MP_OKAY 0 /* no error */ ------------------ 75| 57| } 76| | 77| | /* 78| | Run the Miller-Rabin test with base 2 for the BPSW test. 79| | */ 80| 94| if ((err = mp_init_set(&b, 2uL)) != MP_OKAY) { ------------------ | | 161| 94|#define MP_OKAY 0 /* no error */ ------------------ | Branch (80:8): [True: 0, False: 94] ------------------ 81| 0| return err; 82| 0| } 83| | 84| 94| if ((err = mp_prime_miller_rabin(a, &b, &res)) != MP_OKAY) { ------------------ | | 161| 94|#define MP_OKAY 0 /* no error */ ------------------ | Branch (84:8): [True: 0, False: 94] ------------------ 85| 0| goto LBL_B; 86| 0| } 87| 94| if (res == MP_NO) { ------------------ | | 159| 94|#define MP_NO 0 ------------------ | Branch (87:8): [True: 39, False: 55] ------------------ 88| 39| goto LBL_B; 89| 39| } 90| | /* 91| | Rumours have it that Mathematica does a second M-R test with base 3. 92| | Other rumours have it that their strong L-S test is slightly different. 93| | It does not hurt, though, beside a bit of extra runtime. 94| | */ 95| 55| b.dp[0]++; 96| 55| if ((err = mp_prime_miller_rabin(a, &b, &res)) != MP_OKAY) { ------------------ | | 161| 55|#define MP_OKAY 0 /* no error */ ------------------ | Branch (96:8): [True: 0, False: 55] ------------------ 97| 0| goto LBL_B; 98| 0| } 99| 55| if (res == MP_NO) { ------------------ | | 159| 55|#define MP_NO 0 ------------------ | Branch (99:8): [True: 0, False: 55] ------------------ 100| 0| goto LBL_B; 101| 0| } 102| | 103| | /* 104| | * Both, the Frobenius-Underwood test and the the Lucas-Selfridge test are quite 105| | * slow so if speed is an issue, define LTM_USE_ONLY_MR to use M-R tests with 106| | * bases 2, 3 and t random bases. 107| | */ 108| |#ifndef LTM_USE_ONLY_MR 109| | if (t >= 0) { 110| | /* 111| | * Use a Frobenius-Underwood test instead of the Lucas-Selfridge test for 112| | * MP_8BIT (It is unknown if the Lucas-Selfridge test works with 16-bit 113| | * integers but the necesssary analysis is on the todo-list). 114| | */ 115| |#if defined (MP_8BIT) || defined (LTM_USE_FROBENIUS_TEST) 116| | err = mp_prime_frobenius_underwood(a, &res); 117| | if ((err != MP_OKAY) && (err != MP_ITER)) { 118| | goto LBL_B; 119| | } 120| | if (res == MP_NO) { 121| | goto LBL_B; 122| | } 123| |#else 124| | if ((err = mp_prime_strong_lucas_selfridge(a, &res)) != MP_OKAY) { 125| | goto LBL_B; 126| | } 127| | if (res == MP_NO) { 128| | goto LBL_B; 129| | } 130| |#endif 131| | } 132| |#endif 133| | 134| | /* run at least one Miller-Rabin test with a random base */ 135| 55| if (t == 0) { ------------------ | Branch (135:8): [True: 0, False: 55] ------------------ 136| 0| t = 1; 137| 0| } 138| | 139| | /* 140| | Only recommended if the input range is known to be < 3317044064679887385961981 141| | 142| | It uses the bases necessary for a deterministic M-R test if the input is 143| | smaller than 3317044064679887385961981 144| | The caller has to check the size. 145| | TODO: can be made a bit finer grained but comparing is not free. 146| | */ 147| 55| if (t < 0) { ------------------ | Branch (147:8): [True: 0, False: 55] ------------------ 148| | /* 149| | Sorenson, Jonathan; Webster, Jonathan (2015). 150| | "Strong Pseudoprimes to Twelve Prime Bases". 151| | */ 152| | /* 0x437ae92817f9fc85b7e5 = 318665857834031151167461 */ 153| 0| if ((err = mp_read_radix(&b, "437ae92817f9fc85b7e5", 16)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (153:11): [True: 0, False: 0] ------------------ 154| 0| goto LBL_B; 155| 0| } 156| | 157| 0| if (mp_cmp(a, &b) == MP_LT) { ------------------ | | 154| 0|#define MP_LT -1 /* less than */ ------------------ | Branch (157:11): [True: 0, False: 0] ------------------ 158| 0| p_max = 12; 159| 0| } else { 160| | /* 0x2be6951adc5b22410a5fd = 3317044064679887385961981 */ 161| 0| if ((err = mp_read_radix(&b, "2be6951adc5b22410a5fd", 16)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (161:14): [True: 0, False: 0] ------------------ 162| 0| goto LBL_B; 163| 0| } 164| | 165| 0| if (mp_cmp(a, &b) == MP_LT) { ------------------ | | 154| 0|#define MP_LT -1 /* less than */ ------------------ | Branch (165:14): [True: 0, False: 0] ------------------ 166| 0| p_max = 13; 167| 0| } else { 168| 0| err = MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 169| 0| goto LBL_B; 170| 0| } 171| 0| } 172| | 173| | /* we did bases 2 and 3 already, skip them */ 174| 0| for (ix = 2; ix < p_max; ix++) { ------------------ | Branch (174:20): [True: 0, False: 0] ------------------ 175| 0| mp_set(&b, s_mp_prime_tab[ix]); 176| 0| if ((err = mp_prime_miller_rabin(a, &b, &res)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (176:14): [True: 0, False: 0] ------------------ 177| 0| goto LBL_B; 178| 0| } 179| 0| if (res == MP_NO) { ------------------ | | 159| 0|#define MP_NO 0 ------------------ | Branch (179:14): [True: 0, False: 0] ------------------ 180| 0| goto LBL_B; 181| 0| } 182| 0| } 183| 0| } 184| | /* 185| | Do "t" M-R tests with random bases between 3 and "a". 186| | See Fips 186.4 p. 126ff 187| | */ 188| 55| else if (t > 0) { ------------------ | Branch (188:13): [True: 55, False: 0] ------------------ 189| | /* 190| | * The mp_digit's have a defined bit-size but the size of the 191| | * array a.dp is a simple 'int' and this library can not assume full 192| | * compliance to the current C-standard (ISO/IEC 9899:2011) because 193| | * it gets used for small embeded processors, too. Some of those MCUs 194| | * have compilers that one cannot call standard compliant by any means. 195| | * Hence the ugly type-fiddling in the following code. 196| | */ 197| 55| size_a = mp_count_bits(a); 198| 55| mask = (1u << s_floor_ilog2(size_a)) - 1u; 199| | /* 200| | Assuming the General Rieman hypothesis (never thought to write that in a 201| | comment) the upper bound can be lowered to 2*(log a)^2. 202| | E. Bach, "Explicit bounds for primality testing and related problems," 203| | Math. Comp. 55 (1990), 355-380. 204| | 205| | size_a = (size_a/10) * 7; 206| | len = 2 * (size_a * size_a); 207| | 208| | E.g.: a number of size 2^2048 would be reduced to the upper limit 209| | 210| | floor(2048/10)*7 = 1428 211| | 2 * 1428^2 = 4078368 212| | 213| | (would have been ~4030331.9962 with floats and natural log instead) 214| | That number is smaller than 2^28, the default bit-size of mp_digit. 215| | */ 216| | 217| | /* 218| | How many tests, you might ask? Dana Jacobsen of Math::Prime::Util fame 219| | does exactly 1. In words: one. Look at the end of _GMP_is_prime() in 220| | Math-Prime-Util-GMP-0.50/primality.c if you do not believe it. 221| | 222| | The function mp_rand() goes to some length to use a cryptographically 223| | good PRNG. That also means that the chance to always get the same base 224| | in the loop is non-zero, although very low. 225| | If the BPSW test and/or the addtional Frobenious test have been 226| | performed instead of just the Miller-Rabin test with the bases 2 and 3, 227| | a single extra test should suffice, so such a very unlikely event 228| | will not do much harm. 229| | 230| | To preemptivly answer the dangling question: no, a witness does not 231| | need to be prime. 232| | */ 233| 1.98k| for (ix = 0; ix < t; ix++) { ------------------ | Branch (233:20): [True: 1.92k, False: 55] ------------------ 234| | /* mp_rand() guarantees the first digit to be non-zero */ 235| 1.92k| if ((err = mp_rand(&b, 1)) != MP_OKAY) { ------------------ | | 161| 1.92k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (235:14): [True: 0, False: 1.92k] ------------------ 236| 0| goto LBL_B; 237| 0| } 238| | /* 239| | * Reduce digit before casting because mp_digit might be bigger than 240| | * an unsigned int and "mask" on the other side is most probably not. 241| | */ 242| 1.92k| fips_rand = (unsigned int)(b.dp[0] & (mp_digit) mask); 243| |#ifdef MP_8BIT 244| | /* 245| | * One 8-bit digit is too small, so concatenate two if the size of 246| | * unsigned int allows for it. 247| | */ 248| | if ((MP_SIZEOF_BITS(unsigned int)/2) >= MP_SIZEOF_BITS(mp_digit)) { 249| | if ((err = mp_rand(&b, 1)) != MP_OKAY) { 250| | goto LBL_B; 251| | } 252| | fips_rand <<= MP_SIZEOF_BITS(mp_digit); 253| | fips_rand |= (unsigned int) b.dp[0]; 254| | fips_rand &= mask; 255| | } 256| |#endif 257| 1.92k| if (fips_rand > (unsigned int)(INT_MAX - MP_DIGIT_BIT)) { ------------------ | | 82| 1.92k|# define MP_DIGIT_BIT 60 ------------------ | Branch (257:14): [True: 0, False: 1.92k] ------------------ 258| 0| len = INT_MAX / MP_DIGIT_BIT; ------------------ | | 82| 0|# define MP_DIGIT_BIT 60 ------------------ 259| 1.92k| } else { 260| 1.92k| len = (((int)fips_rand + MP_DIGIT_BIT) / MP_DIGIT_BIT); ------------------ | | 82| 1.92k|# define MP_DIGIT_BIT 60 ------------------ len = (((int)fips_rand + MP_DIGIT_BIT) / MP_DIGIT_BIT); ------------------ | | 82| 1.92k|# define MP_DIGIT_BIT 60 ------------------ 261| 1.92k| } 262| | /* Unlikely. */ 263| 1.92k| if (len < 0) { ------------------ | Branch (263:14): [True: 0, False: 1.92k] ------------------ 264| 0| ix--; 265| 0| continue; 266| 0| } 267| | /* 268| | * As mentioned above, one 8-bit digit is too small and 269| | * although it can only happen in the unlikely case that 270| | * an "unsigned int" is smaller than 16 bit a simple test 271| | * is cheap and the correction even cheaper. 272| | */ 273| |#ifdef MP_8BIT 274| | /* All "a" < 2^8 have been caught before */ 275| | if (len == 1) { 276| | len++; 277| | } 278| |#endif 279| 1.92k| if ((err = mp_rand(&b, len)) != MP_OKAY) { ------------------ | | 161| 1.92k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (279:14): [True: 0, False: 1.92k] ------------------ 280| 0| goto LBL_B; 281| 0| } 282| | /* 283| | * That number might got too big and the witness has to be 284| | * smaller than "a" 285| | */ 286| 1.92k| len = mp_count_bits(&b); 287| 1.92k| if (len >= size_a) { ------------------ | Branch (287:14): [True: 215, False: 1.71k] ------------------ 288| 215| len = (len - size_a) + 1; 289| 215| if ((err = mp_div_2d(&b, len, &b, NULL)) != MP_OKAY) { ------------------ | | 161| 215|#define MP_OKAY 0 /* no error */ ------------------ | Branch (289:17): [True: 0, False: 215] ------------------ 290| 0| goto LBL_B; 291| 0| } 292| 215| } 293| | /* Although the chance for b <= 3 is miniscule, try again. */ 294| 1.92k| if (mp_cmp_d(&b, 3uL) != MP_GT) { ------------------ | | 156| 1.92k|#define MP_GT 1 /* greater than */ ------------------ | Branch (294:14): [True: 0, False: 1.92k] ------------------ 295| 0| ix--; 296| 0| continue; 297| 0| } 298| 1.92k| if ((err = mp_prime_miller_rabin(a, &b, &res)) != MP_OKAY) { ------------------ | | 161| 1.92k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (298:14): [True: 0, False: 1.92k] ------------------ 299| 0| goto LBL_B; 300| 0| } 301| 1.92k| if (res == MP_NO) { ------------------ | | 159| 1.92k|#define MP_NO 0 ------------------ | Branch (301:14): [True: 0, False: 1.92k] ------------------ 302| 0| goto LBL_B; 303| 0| } 304| 1.92k| } 305| 55| } 306| | 307| | /* passed the test */ 308| 55| *result = MP_YES; ------------------ | | 158| 55|#define MP_YES 1 ------------------ 309| 94|LBL_B: 310| 94| mp_clear(&b); 311| 94| return err; 312| 55|} bn_mp_prime_is_prime.c:s_floor_ilog2: 8| 55|{ 9| 55| unsigned int r = 0; 10| 440| while ((value >>= 1) != 0) { ------------------ | Branch (10:11): [True: 385, False: 55] ------------------ 11| 385| r++; 12| 385| } 13| 55| return r; 14| 55|} mp_prime_miller_rabin: 14| 2.07k|{ 15| 2.07k| mp_int n1, y, r; 16| 2.07k| mp_err err; 17| 2.07k| int s, j; 18| | 19| | /* default */ 20| 2.07k| *result = MP_NO; ------------------ | | 159| 2.07k|#define MP_NO 0 ------------------ 21| | 22| | /* ensure b > 1 */ 23| 2.07k| if (mp_cmp_d(b, 1uL) != MP_GT) { ------------------ | | 156| 2.07k|#define MP_GT 1 /* greater than */ ------------------ | Branch (23:8): [True: 0, False: 2.07k] ------------------ 24| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 25| 0| } 26| | 27| | /* get n1 = a - 1 */ 28| 2.07k| if ((err = mp_init_copy(&n1, a)) != MP_OKAY) { ------------------ | | 161| 2.07k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (28:8): [True: 0, False: 2.07k] ------------------ 29| 0| return err; 30| 0| } 31| 2.07k| if ((err = mp_sub_d(&n1, 1uL, &n1)) != MP_OKAY) { ------------------ | | 161| 2.07k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (31:8): [True: 0, False: 2.07k] ------------------ 32| 0| goto LBL_N1; 33| 0| } 34| | 35| | /* set 2**s * r = n1 */ 36| 2.07k| if ((err = mp_init_copy(&r, &n1)) != MP_OKAY) { ------------------ | | 161| 2.07k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (36:8): [True: 0, False: 2.07k] ------------------ 37| 0| goto LBL_N1; 38| 0| } 39| | 40| | /* count the number of least significant bits 41| | * which are zero 42| | */ 43| 2.07k| s = mp_cnt_lsb(&r); 44| | 45| | /* now divide n - 1 by 2**s */ 46| 2.07k| if ((err = mp_div_2d(&r, s, &r, NULL)) != MP_OKAY) { ------------------ | | 161| 2.07k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (46:8): [True: 0, False: 2.07k] ------------------ 47| 0| goto LBL_R; 48| 0| } 49| | 50| | /* compute y = b**r mod a */ 51| 2.07k| if ((err = mp_init(&y)) != MP_OKAY) { ------------------ | | 161| 2.07k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (51:8): [True: 0, False: 2.07k] ------------------ 52| 0| goto LBL_R; 53| 0| } 54| 2.07k| if ((err = mp_exptmod(b, &r, a, &y)) != MP_OKAY) { ------------------ | | 161| 2.07k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (54:8): [True: 0, False: 2.07k] ------------------ 55| 0| goto LBL_Y; 56| 0| } 57| | 58| | /* if y != 1 and y != n1 do */ 59| 2.07k| if ((mp_cmp_d(&y, 1uL) != MP_EQ) && (mp_cmp(&y, &n1) != MP_EQ)) { ------------------ | | 155| 2.07k|#define MP_EQ 0 /* equal to */ ------------------ if ((mp_cmp_d(&y, 1uL) != MP_EQ) && (mp_cmp(&y, &n1) != MP_EQ)) { ------------------ | | 155| 1.92k|#define MP_EQ 0 /* equal to */ ------------------ | Branch (59:8): [True: 1.92k, False: 151] | Branch (59:40): [True: 1.80k, False: 119] ------------------ 60| 1.80k| j = 1; 61| | /* while j <= s-1 and y != n1 */ 62| 95.2k| while ((j <= (s - 1)) && (mp_cmp(&y, &n1) != MP_EQ)) { ------------------ | | 155| 94.2k|#define MP_EQ 0 /* equal to */ ------------------ | Branch (62:14): [True: 94.2k, False: 970] | Branch (62:32): [True: 93.4k, False: 834] ------------------ 63| 93.4k| if ((err = mp_sqrmod(&y, a, &y)) != MP_OKAY) { ------------------ | | 161| 93.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (63:14): [True: 0, False: 93.4k] ------------------ 64| 0| goto LBL_Y; 65| 0| } 66| | 67| | /* if y == 1 then composite */ 68| 93.4k| if (mp_cmp_d(&y, 1uL) == MP_EQ) { ------------------ | | 155| 93.4k|#define MP_EQ 0 /* equal to */ ------------------ | Branch (68:14): [True: 0, False: 93.4k] ------------------ 69| 0| goto LBL_Y; 70| 0| } 71| | 72| 93.4k| ++j; 73| 93.4k| } 74| | 75| | /* if y != n1 then composite */ 76| 1.80k| if (mp_cmp(&y, &n1) != MP_EQ) { ------------------ | | 155| 1.80k|#define MP_EQ 0 /* equal to */ ------------------ | Branch (76:11): [True: 39, False: 1.76k] ------------------ 77| 39| goto LBL_Y; 78| 39| } 79| 1.80k| } 80| | 81| | /* probably prime now */ 82| 2.03k| *result = MP_YES; ------------------ | | 158| 2.03k|#define MP_YES 1 ------------------ 83| 2.07k|LBL_Y: 84| 2.07k| mp_clear(&y); 85| 2.07k|LBL_R: 86| 2.07k| mp_clear(&r); 87| 2.07k|LBL_N1: 88| 2.07k| mp_clear(&n1); 89| 2.07k| return err; 90| 2.07k|} mp_prime_rabin_miller_trials: 33| 238|{ 34| 238| int x; 35| | 36| 1.90k| for (x = 0; x < (int)(sizeof(sizes)/(sizeof(sizes[0]))); x++) { ------------------ | Branch (36:16): [True: 1.90k, False: 0] ------------------ 37| 1.90k| if (sizes[x].k == size) { ------------------ | Branch (37:11): [True: 238, False: 1.66k] ------------------ 38| 238| return sizes[x].t; 39| 1.66k| } else if (sizes[x].k > size) { ------------------ | Branch (39:18): [True: 0, False: 1.66k] ------------------ 40| 0| return (x == 0) ? sizes[0].t : sizes[x - 1].t; ------------------ | Branch (40:17): [True: 0, False: 0] ------------------ 41| 0| } 42| 1.90k| } 43| 0| return sizes[x-1].t; 44| 238|} mp_rand_source: 10| 1|{ 11| | /* Dropbear, don't reset to platform if source==NULL */ 12| 1| s_mp_rand_source = source; 13| 1|} mp_rand: 16| 3.85k|{ 17| 3.85k| int i; 18| 3.85k| mp_err err; 19| | 20| 3.85k| mp_zero(a); 21| | 22| 3.85k| if (digits <= 0) { ------------------ | Branch (22:8): [True: 0, False: 3.85k] ------------------ 23| 0| return MP_OKAY; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ 24| 0| } 25| | 26| 3.85k| if ((err = mp_grow(a, digits)) != MP_OKAY) { ------------------ | | 161| 3.85k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (26:8): [True: 0, False: 3.85k] ------------------ 27| 0| return err; 28| 0| } 29| | 30| 3.85k| if ((err = s_mp_rand_source(a->dp, (size_t)digits * sizeof(mp_digit))) != MP_OKAY) { ------------------ | | 161| 3.85k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (30:8): [True: 0, False: 3.85k] ------------------ 31| 0| return err; 32| 0| } 33| | 34| | /* TODO: We ensure that the highest digit is nonzero. Should this be removed? */ 35| 3.85k| while ((a->dp[digits - 1] & MP_MASK) == 0u) { ------------------ | | 106| 3.85k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 3.85k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ | Branch (35:11): [True: 0, False: 3.85k] ------------------ 36| 0| if ((err = s_mp_rand_source(a->dp + digits - 1, sizeof(mp_digit))) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (36:11): [True: 0, False: 0] ------------------ 37| 0| return err; 38| 0| } 39| 0| } 40| | 41| 3.85k| a->used = digits; 42| 8.80k| for (i = 0; i < digits; ++i) { ------------------ | Branch (42:16): [True: 4.95k, False: 3.85k] ------------------ 43| 4.95k| a->dp[i] &= MP_MASK; ------------------ | | 106| 4.95k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 4.95k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 44| 4.95k| } 45| | 46| 3.85k| return MP_OKAY; ------------------ | | 161| 3.85k|#define MP_OKAY 0 /* no error */ ------------------ 47| 3.85k|} mp_read_radix: 10| 2.07k|{ 11| 2.07k| mp_err err; 12| 2.07k| int y; 13| 2.07k| mp_sign neg; 14| 2.07k| unsigned pos; 15| 2.07k| char ch; 16| | 17| | /* zero the digit bignum */ 18| 2.07k| mp_zero(a); 19| | 20| | /* make sure the radix is ok */ 21| 2.07k| if ((radix < 2) || (radix > 64)) { ------------------ | Branch (21:8): [True: 0, False: 2.07k] | Branch (21:23): [True: 0, False: 2.07k] ------------------ 22| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 23| 0| } 24| | 25| | /* if the leading digit is a 26| | * minus set the sign to negative. 27| | */ 28| 2.07k| if (*str == '-') { ------------------ | Branch (28:8): [True: 0, False: 2.07k] ------------------ 29| 0| ++str; 30| 0| neg = MP_NEG; ------------------ | | 152| 0|#define MP_NEG 1 /* negative */ ------------------ 31| 2.07k| } else { 32| 2.07k| neg = MP_ZPOS; ------------------ | | 151| 2.07k|#define MP_ZPOS 0 /* positive integer */ ------------------ 33| 2.07k| } 34| | 35| | /* set the integer to the default of zero */ 36| 2.07k| mp_zero(a); 37| | 38| | /* process each digit of the string */ 39| 169k| while (*str != '\0') { ------------------ | Branch (39:11): [True: 166k, False: 2.07k] ------------------ 40| | /* if the radix <= 36 the conversion is case insensitive 41| | * this allows numbers like 1AB and 1ab to represent the same value 42| | * [e.g. in hex] 43| | */ 44| 166k| ch = (radix <= 36) ? (char)MP_TOUPPER((int)*str) : *str; ------------------ | | 6| 166k|#define MP_TOUPPER(c) ((((c) >= 'a') && ((c) <= 'z')) ? (((c) + 'A') - 'a') : (c)) | | ------------------ | | | Branch (6:25): [True: 0, False: 166k] | | | Branch (6:41): [True: 0, False: 0] | | ------------------ ------------------ | Branch (44:12): [True: 166k, False: 0] ------------------ 45| 166k| pos = (unsigned)(ch - '('); 46| 166k| if (mp_s_rmap_reverse_sz < pos) { ------------------ | Branch (46:11): [True: 0, False: 166k] ------------------ 47| 0| break; 48| 0| } 49| 166k| y = (int)mp_s_rmap_reverse[pos]; 50| | 51| | /* if the char was found in the map 52| | * and is less than the given radix add it 53| | * to the number, otherwise exit the loop. 54| | */ 55| 166k| if ((y == 0xff) || (y >= radix)) { ------------------ | Branch (55:11): [True: 0, False: 166k] | Branch (55:26): [True: 0, False: 166k] ------------------ 56| 0| break; 57| 0| } 58| 166k| if ((err = mp_mul_d(a, (mp_digit)radix, a)) != MP_OKAY) { ------------------ | | 161| 166k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (58:11): [True: 0, False: 166k] ------------------ 59| 0| return err; 60| 0| } 61| 166k| if ((err = mp_add_d(a, (mp_digit)y, a)) != MP_OKAY) { ------------------ | | 161| 166k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (61:11): [True: 0, False: 166k] ------------------ 62| 0| return err; 63| 0| } 64| 166k| ++str; 65| 166k| } 66| | 67| | /* if an illegal character was found, fail. */ 68| 2.07k| if (!((*str == '\0') || (*str == '\r') || (*str == '\n'))) { ------------------ | Branch (68:10): [True: 2.07k, False: 0] | Branch (68:28): [True: 0, False: 0] | Branch (68:46): [True: 0, False: 0] ------------------ 69| 0| mp_zero(a); 70| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 71| 0| } 72| | 73| | /* set the sign only if a != 0 */ 74| 2.07k| if (!MP_IS_ZERO(a)) { ------------------ | | 163| 2.07k|#define MP_IS_ZERO(a) ((a)->used == 0) ------------------ | Branch (74:8): [True: 2.07k, False: 0] ------------------ 75| 2.07k| a->sign = neg; 76| 2.07k| } 77| 2.07k| return MP_OKAY; ------------------ | | 161| 2.07k|#define MP_OKAY 0 /* no error */ ------------------ 78| 2.07k|} mp_reduce: 11| 38.7k|{ 12| 38.7k| mp_int q; 13| 38.7k| mp_err err; 14| 38.7k| int um = m->used; 15| | 16| | /* q = x */ 17| 38.7k| if ((err = mp_init_copy(&q, x)) != MP_OKAY) { ------------------ | | 161| 38.7k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (17:8): [True: 0, False: 38.7k] ------------------ 18| 0| return err; 19| 0| } 20| | 21| | /* q1 = x / b**(k-1) */ 22| 38.7k| mp_rshd(&q, um - 1); 23| | 24| | /* according to HAC this optimization is ok */ 25| 38.7k| if ((mp_digit)um > ((mp_digit)1 << (MP_DIGIT_BIT - 1))) { ------------------ | | 82| 38.7k|# define MP_DIGIT_BIT 60 ------------------ | Branch (25:8): [True: 0, False: 38.7k] ------------------ 26| 0| if ((err = mp_mul(&q, mu, &q)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (26:11): [True: 0, False: 0] ------------------ 27| 0| goto CLEANUP; 28| 0| } 29| 38.7k| } else if (MP_HAS(S_MP_MUL_HIGH_DIGS)) { ------------------ | | 150| 38.7k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 38.7k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 38.7k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 38.7k, Folded] | | ------------------ ------------------ 30| 38.7k| if ((err = s_mp_mul_high_digs(&q, mu, &q, um)) != MP_OKAY) { ------------------ | | 161| 38.7k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (30:11): [True: 0, False: 38.7k] ------------------ 31| 0| goto CLEANUP; 32| 0| } 33| 38.7k| } else if (MP_HAS(S_MP_MUL_HIGH_DIGS_FAST)) { ------------------ | | 150| 0|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 0|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 0|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 0, Folded] | | ------------------ ------------------ 34| 0| if ((err = s_mp_mul_high_digs_fast(&q, mu, &q, um)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (34:11): [True: 0, False: 0] ------------------ 35| 0| goto CLEANUP; 36| 0| } 37| 0| } else { 38| 0| err = MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 39| 0| goto CLEANUP; 40| 0| } 41| | 42| | /* q3 = q2 / b**(k+1) */ 43| 38.7k| mp_rshd(&q, um + 1); 44| | 45| | /* x = x mod b**(k+1), quick (no division) */ 46| 38.7k| if ((err = mp_mod_2d(x, MP_DIGIT_BIT * (um + 1), x)) != MP_OKAY) { ------------------ | | 82| 38.7k|# define MP_DIGIT_BIT 60 ------------------ if ((err = mp_mod_2d(x, MP_DIGIT_BIT * (um + 1), x)) != MP_OKAY) { ------------------ | | 161| 38.7k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (46:8): [True: 0, False: 38.7k] ------------------ 47| 0| goto CLEANUP; 48| 0| } 49| | 50| | /* q = q * m mod b**(k+1), quick (no division) */ 51| 38.7k| if ((err = s_mp_mul_digs(&q, m, &q, um + 1)) != MP_OKAY) { ------------------ | | 161| 38.7k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (51:8): [True: 0, False: 38.7k] ------------------ 52| 0| goto CLEANUP; 53| 0| } 54| | 55| | /* x = x - q */ 56| 38.7k| if ((err = mp_sub(x, &q, x)) != MP_OKAY) { ------------------ | | 161| 38.7k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (56:8): [True: 0, False: 38.7k] ------------------ 57| 0| goto CLEANUP; 58| 0| } 59| | 60| | /* If x < 0, add b**(k+1) to it */ 61| 38.7k| if (mp_cmp_d(x, 0uL) == MP_LT) { ------------------ | | 154| 38.7k|#define MP_LT -1 /* less than */ ------------------ | Branch (61:8): [True: 6.03k, False: 32.7k] ------------------ 62| 6.03k| mp_set(&q, 1uL); 63| 6.03k| if ((err = mp_lshd(&q, um + 1)) != MP_OKAY) { ------------------ | | 161| 6.03k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (63:11): [True: 0, False: 6.03k] ------------------ 64| 0| goto CLEANUP; 65| 0| } 66| 6.03k| if ((err = mp_add(x, &q, x)) != MP_OKAY) { ------------------ | | 161| 6.03k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (66:11): [True: 0, False: 6.03k] ------------------ 67| 0| goto CLEANUP; 68| 0| } 69| 6.03k| } 70| | 71| | /* Back off if it's too big */ 72| 74.9k| while (mp_cmp(x, m) != MP_LT) { ------------------ | | 154| 74.9k|#define MP_LT -1 /* less than */ ------------------ | Branch (72:11): [True: 36.1k, False: 38.7k] ------------------ 73| 36.1k| if ((err = s_mp_sub(x, m, x)) != MP_OKAY) { ------------------ | | 161| 36.1k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (73:11): [True: 0, False: 36.1k] ------------------ 74| 0| goto CLEANUP; 75| 0| } 76| 36.1k| } 77| | 78| 38.7k|CLEANUP: 79| 38.7k| mp_clear(&q); 80| | 81| 38.7k| return err; 82| 38.7k|} mp_reduce_2k_l: 11| 48.9k|{ 12| 48.9k| mp_int q; 13| 48.9k| mp_err err; 14| 48.9k| int p; 15| | 16| 48.9k| if ((err = mp_init(&q)) != MP_OKAY) { ------------------ | | 161| 48.9k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (16:8): [True: 0, False: 48.9k] ------------------ 17| 0| return err; 18| 0| } 19| | 20| 48.9k| p = mp_count_bits(n); 21| 2.16M|top: 22| | /* q = a/2**p, a = a mod 2**p */ 23| 2.16M| if ((err = mp_div_2d(a, p, &q, a)) != MP_OKAY) { ------------------ | | 161| 2.16M|#define MP_OKAY 0 /* no error */ ------------------ | Branch (23:8): [True: 0, False: 2.16M] ------------------ 24| 0| goto LBL_ERR; 25| 0| } 26| | 27| | /* q = q * d */ 28| 2.16M| if ((err = mp_mul(&q, d, &q)) != MP_OKAY) { ------------------ | | 161| 2.16M|#define MP_OKAY 0 /* no error */ ------------------ | Branch (28:8): [True: 0, False: 2.16M] ------------------ 29| 0| goto LBL_ERR; 30| 0| } 31| | 32| | /* a = a + q */ 33| 2.16M| if ((err = s_mp_add(a, &q, a)) != MP_OKAY) { ------------------ | | 161| 2.16M|#define MP_OKAY 0 /* no error */ ------------------ | Branch (33:8): [True: 0, False: 2.16M] ------------------ 34| 0| goto LBL_ERR; 35| 0| } 36| | 37| 2.16M| if (mp_cmp_mag(a, n) != MP_LT) { ------------------ | | 154| 2.16M|#define MP_LT -1 /* less than */ ------------------ | Branch (37:8): [True: 2.11M, False: 48.9k] ------------------ 38| 2.11M| if ((err = s_mp_sub(a, n, a)) != MP_OKAY) { ------------------ | | 161| 2.11M|#define MP_OKAY 0 /* no error */ ------------------ | Branch (38:11): [True: 0, False: 2.11M] ------------------ 39| 0| goto LBL_ERR; 40| 0| } 41| 2.11M| goto top; 42| 2.11M| } 43| | 44| 48.9k|LBL_ERR: 45| 48.9k| mp_clear(&q); 46| 48.9k| return err; 47| 2.16M|} mp_reduce_2k_setup_l: 8| 396|{ 9| 396| mp_err err; 10| 396| mp_int tmp; 11| | 12| 396| if ((err = mp_init(&tmp)) != MP_OKAY) { ------------------ | | 161| 396|#define MP_OKAY 0 /* no error */ ------------------ | Branch (12:8): [True: 0, False: 396] ------------------ 13| 0| return err; 14| 0| } 15| | 16| 396| if ((err = mp_2expt(&tmp, mp_count_bits(a))) != MP_OKAY) { ------------------ | | 161| 396|#define MP_OKAY 0 /* no error */ ------------------ | Branch (16:8): [True: 0, False: 396] ------------------ 17| 0| goto LBL_ERR; 18| 0| } 19| | 20| 396| if ((err = s_mp_sub(&tmp, a, d)) != MP_OKAY) { ------------------ | | 161| 396|#define MP_OKAY 0 /* no error */ ------------------ | Branch (20:8): [True: 0, False: 396] ------------------ 21| 0| goto LBL_ERR; 22| 0| } 23| | 24| 396|LBL_ERR: 25| 396| mp_clear(&tmp); 26| 396| return err; 27| 396|} mp_reduce_is_2k: 8| 2.89k|{ 9| 2.89k| int ix, iy, iw; 10| 2.89k| mp_digit iz; 11| | 12| 2.89k| if (a->used == 0) { ------------------ | Branch (12:8): [True: 0, False: 2.89k] ------------------ 13| 0| return MP_NO; ------------------ | | 159| 0|#define MP_NO 0 ------------------ 14| 2.89k| } else if (a->used == 1) { ------------------ | Branch (14:15): [True: 0, False: 2.89k] ------------------ 15| 0| return MP_YES; ------------------ | | 158| 0|#define MP_YES 1 ------------------ 16| 2.89k| } else if (a->used > 1) { ------------------ | Branch (16:15): [True: 2.89k, False: 0] ------------------ 17| 2.89k| iy = mp_count_bits(a); 18| 2.89k| iz = 1; 19| 2.89k| iw = 1; 20| | 21| | /* Test every bit from the second digit up, must be 1 */ 22| 27.8k| for (ix = MP_DIGIT_BIT; ix < iy; ix++) { ------------------ | | 82| 2.89k|# define MP_DIGIT_BIT 60 ------------------ | Branch (22:31): [True: 27.8k, False: 0] ------------------ 23| 27.8k| if ((a->dp[iw] & iz) == 0u) { ------------------ | Branch (23:14): [True: 2.89k, False: 24.9k] ------------------ 24| 2.89k| return MP_NO; ------------------ | | 159| 2.89k|#define MP_NO 0 ------------------ 25| 2.89k| } 26| 24.9k| iz <<= 1; 27| 24.9k| if (iz > MP_DIGIT_MAX) { ------------------ | | 107| 24.9k|#define MP_DIGIT_MAX MP_MASK | | ------------------ | | | | 106| 24.9k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | | | ------------------ | | | | | | 82| 24.9k|# define MP_DIGIT_BIT 60 | | | | ------------------ | | ------------------ ------------------ | Branch (27:14): [True: 263, False: 24.7k] ------------------ 28| 263| ++iw; 29| 263| iz = 1; 30| 263| } 31| 24.9k| } 32| 0| return MP_YES; ------------------ | | 158| 0|#define MP_YES 1 ------------------ 33| 2.89k| } else { 34| 0| return MP_YES; ------------------ | | 158| 0|#define MP_YES 1 ------------------ 35| 0| } 36| 2.89k|} mp_reduce_is_2k_l: 8| 3.28k|{ 9| 3.28k| int ix, iy; 10| | 11| 3.28k| if (a->used == 0) { ------------------ | Branch (11:8): [True: 0, False: 3.28k] ------------------ 12| 0| return MP_NO; ------------------ | | 159| 0|#define MP_NO 0 ------------------ 13| 3.28k| } else if (a->used == 1) { ------------------ | Branch (13:15): [True: 0, False: 3.28k] ------------------ 14| 0| return MP_YES; ------------------ | | 158| 0|#define MP_YES 1 ------------------ 15| 3.28k| } else if (a->used > 1) { ------------------ | Branch (15:15): [True: 3.28k, False: 0] ------------------ 16| | /* if more than half of the digits are -1 we're sold */ 17| 47.0k| for (iy = ix = 0; ix < a->used; ix++) { ------------------ | Branch (17:25): [True: 43.8k, False: 3.28k] ------------------ 18| 43.8k| if (a->dp[ix] == MP_DIGIT_MAX) { ------------------ | | 107| 43.8k|#define MP_DIGIT_MAX MP_MASK | | ------------------ | | | | 106| 43.8k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | | | ------------------ | | | | | | 82| 43.8k|# define MP_DIGIT_BIT 60 | | | | ------------------ | | ------------------ ------------------ | Branch (18:14): [True: 7.08k, False: 36.7k] ------------------ 19| 7.08k| ++iy; 20| 7.08k| } 21| 43.8k| } 22| 3.28k| return (iy >= (a->used/2)) ? MP_YES : MP_NO; ------------------ | | 158| 396|#define MP_YES 1 ------------------ return (iy >= (a->used/2)) ? MP_YES : MP_NO; ------------------ | | 159| 2.89k|#define MP_NO 0 ------------------ | Branch (22:14): [True: 396, False: 2.89k] ------------------ 23| 3.28k| } else { 24| 0| return MP_NO; ------------------ | | 159| 0|#define MP_NO 0 ------------------ 25| 0| } 26| 3.28k|} mp_reduce_setup: 10| 515|{ 11| 515| mp_err err; 12| 515| if ((err = mp_2expt(a, b->used * 2 * MP_DIGIT_BIT)) != MP_OKAY) { ------------------ | | 82| 515|# define MP_DIGIT_BIT 60 ------------------ if ((err = mp_2expt(a, b->used * 2 * MP_DIGIT_BIT)) != MP_OKAY) { ------------------ | | 161| 515|#define MP_OKAY 0 /* no error */ ------------------ | Branch (12:8): [True: 0, False: 515] ------------------ 13| 0| return err; 14| 0| } 15| 515| return mp_div(a, b, a, NULL); 16| 515|} mp_rshd: 8| 2.33M|{ 9| 2.33M| int x; 10| 2.33M| mp_digit *bottom, *top; 11| | 12| | /* if b <= 0 then ignore it */ 13| 2.33M| if (b <= 0) { ------------------ | Branch (13:8): [True: 144, False: 2.33M] ------------------ 14| 144| return; 15| 144| } 16| | 17| | /* if b > used then simply zero it and return */ 18| 2.33M| if (a->used <= b) { ------------------ | Branch (18:8): [True: 50.8k, False: 2.28M] ------------------ 19| 50.8k| mp_zero(a); 20| 50.8k| return; 21| 50.8k| } 22| | 23| | /* shift the digits down */ 24| | 25| | /* bottom */ 26| 2.28M| bottom = a->dp; 27| | 28| | /* top [offset into digits] */ 29| 2.28M| top = a->dp + b; 30| | 31| | /* this is implemented as a sliding window where 32| | * the window is b-digits long and digits from 33| | * the top of the window are copied to the bottom 34| | * 35| | * e.g. 36| | 37| | b-2 | b-1 | b0 | b1 | b2 | ... | bb | ----> 38| | /\ | ----> 39| | \-------------------/ ----> 40| | */ 41| 32.0M| for (x = 0; x < (a->used - b); x++) { ------------------ | Branch (41:16): [True: 29.7M, False: 2.28M] ------------------ 42| 29.7M| *bottom++ = *top++; 43| 29.7M| } 44| | 45| | /* zero the top digits */ 46| 2.28M| MP_ZERO_DIGITS(bottom, a->used - x); ------------------ | | 89| 2.28M|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 2.28M|do { \ | | 91| 2.28M| int zd_ = (digits); \ | | 92| 2.28M| mp_digit* zm_ = (mem); \ | | 93| 58.4M| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 56.1M, False: 2.28M] | | ------------------ | | 94| 56.1M| *zm_++ = 0; \ | | 95| 56.1M| } \ | | 96| 2.28M|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2.28M] | | ------------------ ------------------ 47| | 48| | /* remove excess digits */ 49| 2.28M| a->used -= b; 50| 2.28M|} mp_set: 8| 8.37k|{ 9| 8.37k| a->dp[0] = b & MP_MASK; ------------------ | | 106| 8.37k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 8.37k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 10| 8.37k| a->sign = MP_ZPOS; ------------------ | | 151| 8.37k|#define MP_ZPOS 0 /* positive integer */ ------------------ 11| 8.37k| a->used = (a->dp[0] != 0u) ? 1 : 0; ------------------ | Branch (11:15): [True: 8.37k, False: 0] ------------------ 12| 8.37k| MP_ZERO_DIGITS(a->dp + a->used, a->alloc - a->used); ------------------ | | 89| 8.37k|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 8.37k|do { \ | | 91| 8.37k| int zd_ = (digits); \ | | 92| 8.37k| mp_digit* zm_ = (mem); \ | | 93| 252k| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 244k, False: 8.37k] | | ------------------ | | 94| 244k| *zm_++ = 0; \ | | 95| 244k| } \ | | 96| 8.37k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 8.37k] | | ------------------ ------------------ 13| 8.37k|} mp_sqr: 8| 909k|{ 9| 909k| mp_err err; 10| 909k| if (MP_HAS(S_MP_TOOM_SQR) && /* use Toom-Cook? */ ------------------ | | 150| 1.81M|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 909k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 909k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [Folded, False: 909k] | | ------------------ ------------------ 11| 0| (a->used >= MP_TOOM_SQR_CUTOFF)) { ------------------ | | 124| 0|# define MP_TOOM_SQR_CUTOFF TOOM_SQR_CUTOFF ------------------ | Branch (11:8): [True: 0, False: 0] ------------------ 12| 0| err = s_mp_toom_sqr(a, b); 13| 909k| } else if (MP_HAS(S_MP_KARATSUBA_SQR) && /* Karatsuba? */ ------------------ | | 150| 1.81M|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 909k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 909k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [Folded, False: 909k] | | ------------------ ------------------ 14| 0| (a->used >= MP_KARATSUBA_SQR_CUTOFF)) { ------------------ | | 122| 0|# define MP_KARATSUBA_SQR_CUTOFF KARATSUBA_SQR_CUTOFF ------------------ | Branch (14:15): [True: 0, False: 0] ------------------ 15| 0| err = s_mp_karatsuba_sqr(a, b); 16| 909k| } else if (MP_HAS(S_MP_SQR_FAST) && /* can we use the fast comba multiplier? */ ------------------ | | 150| 1.81M|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 909k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 909k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 909k, Folded] | | ------------------ ------------------ 17| 909k| (((a->used * 2) + 1) < MP_WARRAY) && ------------------ | | 172| 909k|#define MP_WARRAY PRIVATE_MP_WARRAY | | ------------------ | | | | 203| 909k|#define PRIVATE_MP_WARRAY (int)(1uLL << (((CHAR_BIT * sizeof(private_mp_word)) - (2 * MP_DIGIT_BIT)) + 1)) | | | | ------------------ | | | | | | 82| 909k|# define MP_DIGIT_BIT 60 | | | | ------------------ | | ------------------ ------------------ | Branch (17:15): [True: 909k, False: 0] ------------------ 18| 909k| (a->used < (MP_MAXFAST / 2))) { ------------------ | | 168| 909k|#define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT))) | | ------------------ | | | | 167| 909k|#define MP_SIZEOF_BITS(type) ((size_t)CHAR_BIT * sizeof(type)) | | ------------------ | | #define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT))) | | ------------------ | | | | 82| 909k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ | Branch (18:15): [True: 909k, False: 286] ------------------ 19| 909k| err = s_mp_sqr_fast(a, b); 20| 909k| } else if (MP_HAS(S_MP_SQR)) { ------------------ | | 150| 286|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 286|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 286|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 286, Folded] | | ------------------ ------------------ 21| 286| err = s_mp_sqr(a, b); 22| 286| } else { 23| 0| err = MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 24| 0| } 25| 909k| b->sign = MP_ZPOS; ------------------ | | 151| 909k|#define MP_ZPOS 0 /* positive integer */ ------------------ 26| 909k| return err; 27| 909k|} mp_sqrmod: 8| 93.4k|{ 9| 93.4k| mp_err err; 10| 93.4k| mp_int t; 11| | 12| 93.4k| if ((err = mp_init(&t)) != MP_OKAY) { ------------------ | | 161| 93.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (12:8): [True: 0, False: 93.4k] ------------------ 13| 0| return err; 14| 0| } 15| | 16| 93.4k| if ((err = mp_sqr(a, &t)) != MP_OKAY) { ------------------ | | 161| 93.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (16:8): [True: 0, False: 93.4k] ------------------ 17| 0| goto LBL_ERR; 18| 0| } 19| 93.4k| err = mp_mod(&t, b, c); 20| | 21| 93.4k|LBL_ERR: 22| 93.4k| mp_clear(&t); 23| 93.4k| return err; 24| 93.4k|} mp_sqrt: 8| 5|{ 9| 5| mp_err err; 10| 5| mp_int t1, t2; 11| | 12| | /* must be positive */ 13| 5| if (arg->sign == MP_NEG) { ------------------ | | 152| 5|#define MP_NEG 1 /* negative */ ------------------ | Branch (13:8): [True: 0, False: 5] ------------------ 14| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 15| 0| } 16| | 17| | /* easy out */ 18| 5| if (MP_IS_ZERO(arg)) { ------------------ | | 163| 5|#define MP_IS_ZERO(a) ((a)->used == 0) | | ------------------ | | | Branch (163:23): [True: 0, False: 5] | | ------------------ ------------------ 19| 0| mp_zero(ret); 20| 0| return MP_OKAY; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ 21| 0| } 22| | 23| 5| if ((err = mp_init_copy(&t1, arg)) != MP_OKAY) { ------------------ | | 161| 5|#define MP_OKAY 0 /* no error */ ------------------ | Branch (23:8): [True: 0, False: 5] ------------------ 24| 0| return err; 25| 0| } 26| | 27| 5| if ((err = mp_init(&t2)) != MP_OKAY) { ------------------ | | 161| 5|#define MP_OKAY 0 /* no error */ ------------------ | Branch (27:8): [True: 0, False: 5] ------------------ 28| 0| goto E2; 29| 0| } 30| | 31| | /* First approx. (not very bad for large arg) */ 32| 5| mp_rshd(&t1, t1.used/2); 33| | 34| | /* t1 > 0 */ 35| 5| if ((err = mp_div(arg, &t1, &t2, NULL)) != MP_OKAY) { ------------------ | | 161| 5|#define MP_OKAY 0 /* no error */ ------------------ | Branch (35:8): [True: 0, False: 5] ------------------ 36| 0| goto E1; 37| 0| } 38| 5| if ((err = mp_add(&t1, &t2, &t1)) != MP_OKAY) { ------------------ | | 161| 5|#define MP_OKAY 0 /* no error */ ------------------ | Branch (38:8): [True: 0, False: 5] ------------------ 39| 0| goto E1; 40| 0| } 41| 5| if ((err = mp_div_2(&t1, &t1)) != MP_OKAY) { ------------------ | | 161| 5|#define MP_OKAY 0 /* no error */ ------------------ | Branch (41:8): [True: 0, False: 5] ------------------ 42| 0| goto E1; 43| 0| } 44| | /* And now t1 > sqrt(arg) */ 45| 147| do { 46| 147| if ((err = mp_div(arg, &t1, &t2, NULL)) != MP_OKAY) { ------------------ | | 161| 147|#define MP_OKAY 0 /* no error */ ------------------ | Branch (46:11): [True: 0, False: 147] ------------------ 47| 0| goto E1; 48| 0| } 49| 147| if ((err = mp_add(&t1, &t2, &t1)) != MP_OKAY) { ------------------ | | 161| 147|#define MP_OKAY 0 /* no error */ ------------------ | Branch (49:11): [True: 0, False: 147] ------------------ 50| 0| goto E1; 51| 0| } 52| 147| if ((err = mp_div_2(&t1, &t1)) != MP_OKAY) { ------------------ | | 161| 147|#define MP_OKAY 0 /* no error */ ------------------ | Branch (52:11): [True: 0, False: 147] ------------------ 53| 0| goto E1; 54| 0| } 55| | /* t1 >= sqrt(arg) >= t2 at this point */ 56| 147| } while (mp_cmp_mag(&t1, &t2) == MP_GT); ------------------ | | 156| 147|#define MP_GT 1 /* greater than */ ------------------ | Branch (56:13): [True: 142, False: 5] ------------------ 57| | 58| 5| mp_exch(&t1, ret); 59| | 60| 5|E1: 61| 5| mp_clear(&t2); 62| 5|E2: 63| 5| mp_clear(&t1); 64| 5| return err; 65| 5|} mp_sub: 8| 1.77M|{ 9| 1.77M| mp_sign sa = a->sign, sb = b->sign; 10| 1.77M| mp_err err; 11| | 12| 1.77M| if (sa != sb) { ------------------ | Branch (12:8): [True: 137k, False: 1.63M] ------------------ 13| | /* subtract a negative from a positive, OR */ 14| | /* subtract a positive from a negative. */ 15| | /* In either case, ADD their magnitudes, */ 16| | /* and use the sign of the first number. */ 17| 137k| c->sign = sa; 18| 137k| err = s_mp_add(a, b, c); 19| 1.63M| } else { 20| | /* subtract a positive from a positive, OR */ 21| | /* subtract a negative from a negative. */ 22| | /* First, take the difference between their */ 23| | /* magnitudes, then... */ 24| 1.63M| if (mp_cmp_mag(a, b) != MP_LT) { ------------------ | | 154| 1.63M|#define MP_LT -1 /* less than */ ------------------ | Branch (24:11): [True: 1.20M, False: 432k] ------------------ 25| | /* Copy the sign from the first */ 26| 1.20M| c->sign = sa; 27| | /* The first has a larger or equal magnitude */ 28| 1.20M| err = s_mp_sub(a, b, c); 29| 1.20M| } else { 30| | /* The result has the *opposite* sign from */ 31| | /* the first number. */ 32| 432k| c->sign = (sa == MP_ZPOS) ? MP_NEG : MP_ZPOS; ------------------ | | 151| 432k|#define MP_ZPOS 0 /* positive integer */ ------------------ c->sign = (sa == MP_ZPOS) ? MP_NEG : MP_ZPOS; ------------------ | | 152| 393k|#define MP_NEG 1 /* negative */ ------------------ c->sign = (sa == MP_ZPOS) ? MP_NEG : MP_ZPOS; ------------------ | | 151| 471k|#define MP_ZPOS 0 /* positive integer */ ------------------ | Branch (32:20): [True: 393k, False: 39.1k] ------------------ 33| | /* The second has a larger magnitude */ 34| 432k| err = s_mp_sub(b, a, c); 35| 432k| } 36| 1.63M| } 37| 1.77M| return err; 38| 1.77M|} mp_sub_d: 8| 2.07k|{ 9| 2.07k| mp_digit *tmpa, *tmpc; 10| 2.07k| mp_err err; 11| 2.07k| int ix, oldused; 12| | 13| | /* grow c as required */ 14| 2.07k| if (c->alloc < (a->used + 1)) { ------------------ | Branch (14:8): [True: 2.07k, False: 0] ------------------ 15| 2.07k| if ((err = mp_grow(c, a->used + 1)) != MP_OKAY) { ------------------ | | 161| 2.07k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (15:11): [True: 0, False: 2.07k] ------------------ 16| 0| return err; 17| 0| } 18| 2.07k| } 19| | 20| | /* if a is negative just do an unsigned 21| | * addition [with fudged signs] 22| | */ 23| 2.07k| if (a->sign == MP_NEG) { ------------------ | | 152| 2.07k|#define MP_NEG 1 /* negative */ ------------------ | Branch (23:8): [True: 0, False: 2.07k] ------------------ 24| 0| mp_int a_ = *a; 25| 0| a_.sign = MP_ZPOS; ------------------ | | 151| 0|#define MP_ZPOS 0 /* positive integer */ ------------------ 26| 0| err = mp_add_d(&a_, b, c); 27| 0| c->sign = MP_NEG; ------------------ | | 152| 0|#define MP_NEG 1 /* negative */ ------------------ 28| | 29| | /* clamp */ 30| 0| mp_clamp(c); 31| | 32| 0| return err; 33| 0| } 34| | 35| | /* setup regs */ 36| 2.07k| oldused = c->used; 37| 2.07k| tmpa = a->dp; 38| 2.07k| tmpc = c->dp; 39| | 40| | /* if a <= b simply fix the single digit */ 41| 2.07k| if (((a->used == 1) && (a->dp[0] <= b)) || (a->used == 0)) { ------------------ | Branch (41:9): [True: 0, False: 2.07k] | Branch (41:27): [True: 0, False: 0] | Branch (41:47): [True: 0, False: 2.07k] ------------------ 42| 0| if (a->used == 1) { ------------------ | Branch (42:11): [True: 0, False: 0] ------------------ 43| 0| *tmpc++ = b - *tmpa; 44| 0| } else { 45| 0| *tmpc++ = b; 46| 0| } 47| 0| ix = 1; 48| | 49| | /* negative/1digit */ 50| 0| c->sign = MP_NEG; ------------------ | | 152| 0|#define MP_NEG 1 /* negative */ ------------------ 51| 0| c->used = 1; 52| 2.07k| } else { 53| 2.07k| mp_digit mu = b; 54| | 55| | /* positive/size */ 56| 2.07k| c->sign = MP_ZPOS; ------------------ | | 151| 2.07k|#define MP_ZPOS 0 /* positive integer */ ------------------ 57| 2.07k| c->used = a->used; 58| | 59| | /* subtract digits, mu is carry */ 60| 8.29k| for (ix = 0; ix < a->used; ix++) { ------------------ | Branch (60:20): [True: 6.22k, False: 2.07k] ------------------ 61| 6.22k| *tmpc = *tmpa++ - mu; 62| 6.22k| mu = *tmpc >> (MP_SIZEOF_BITS(mp_digit) - 1u); ------------------ | | 167| 6.22k|#define MP_SIZEOF_BITS(type) ((size_t)CHAR_BIT * sizeof(type)) ------------------ 63| 6.22k| *tmpc++ &= MP_MASK; ------------------ | | 106| 6.22k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 6.22k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 64| 6.22k| } 65| 2.07k| } 66| | 67| | /* zero excess digits */ 68| 2.07k| MP_ZERO_DIGITS(tmpc, oldused - ix); ------------------ | | 89| 2.07k|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 2.07k|do { \ | | 91| 2.07k| int zd_ = (digits); \ | | 92| 2.07k| mp_digit* zm_ = (mem); \ | | 93| 2.07k| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 0, False: 2.07k] | | ------------------ | | 94| 0| *zm_++ = 0; \ | | 95| 0| } \ | | 96| 2.07k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2.07k] | | ------------------ ------------------ 69| | 70| 2.07k| mp_clamp(c); 71| 2.07k| return MP_OKAY; ------------------ | | 161| 2.07k|#define MP_OKAY 0 /* no error */ ------------------ 72| 2.07k|} mp_to_ubin: 8| 520|{ 9| 520| size_t x, count; 10| 520| mp_err err; 11| 520| mp_int t; 12| | 13| 520| count = mp_ubin_size(a); 14| 520| if (count > maxlen) { ------------------ | Branch (14:8): [True: 0, False: 520] ------------------ 15| 0| return MP_BUF; ------------------ | | 167| 0|#define MP_BUF -5 /* buffer overflow, supplied buffer too small */ ------------------ 16| 0| } 17| | 18| 520| if ((err = mp_init_copy(&t, a)) != MP_OKAY) { ------------------ | | 161| 520|#define MP_OKAY 0 /* no error */ ------------------ | Branch (18:8): [True: 0, False: 520] ------------------ 19| 0| return err; 20| 0| } 21| | 22| 20.6k| for (x = count; x --> 0u;) { ------------------ | Branch (22:20): [True: 20.1k, False: 520] ------------------ 23| 20.1k|#ifndef MP_8BIT 24| 20.1k| buf[x] = (unsigned char)(t.dp[0] & 255u); 25| |#else 26| | buf[x] = (unsigned char)(t.dp[0] | ((t.dp[1] & 1u) << 7)); 27| |#endif 28| 20.1k| if ((err = mp_div_2d(&t, 8, &t, NULL)) != MP_OKAY) { ------------------ | | 161| 20.1k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (28:11): [True: 0, False: 20.1k] ------------------ 29| 0| goto LBL_ERR; 30| 0| } 31| 20.1k| } 32| | 33| 520| if (written != NULL) { ------------------ | Branch (33:8): [True: 0, False: 520] ------------------ 34| 0| *written = count; 35| 0| } 36| | 37| 520|LBL_ERR: 38| 520| mp_clear(&t); 39| 520| return err; 40| 520|} mp_ubin_size: 8| 2.73k|{ 9| 2.73k| size_t size = (size_t)mp_count_bits(a); 10| 2.73k| return (size / 8u) + (((size & 7u) != 0u) ? 1u : 0u); ------------------ | Branch (10:26): [True: 1.61k, False: 1.12k] ------------------ 11| 2.73k|} mp_zero: 8| 496k|{ 9| 496k| a->sign = MP_ZPOS; ------------------ | | 151| 496k|#define MP_ZPOS 0 /* positive integer */ ------------------ 10| 496k| a->used = 0; 11| 496k| MP_ZERO_DIGITS(a->dp, a->alloc); ------------------ | | 89| 496k|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 496k|do { \ | | 91| 496k| int zd_ = (digits); \ | | 92| 496k| mp_digit* zm_ = (mem); \ | | 93| 16.6M| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 16.1M, False: 496k] | | ------------------ | | 94| 16.1M| *zm_++ = 0; \ | | 95| 16.1M| } \ | | 96| 496k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 496k] | | ------------------ ------------------ 12| 496k|} s_mp_add: 8| 2.97M|{ 9| 2.97M| const mp_int *x; 10| 2.97M| mp_err err; 11| 2.97M| int olduse, min, max; 12| | 13| | /* find sizes, we let |a| <= |b| which means we have to sort 14| | * them. "x" will point to the input with the most digits 15| | */ 16| 2.97M| if (a->used > b->used) { ------------------ | Branch (16:8): [True: 38.5k, False: 2.93M] ------------------ 17| 38.5k| min = b->used; 18| 38.5k| max = a->used; 19| 38.5k| x = a; 20| 2.93M| } else { 21| 2.93M| min = a->used; 22| 2.93M| max = b->used; 23| 2.93M| x = b; 24| 2.93M| } 25| | 26| | /* init result */ 27| 2.97M| if (c->alloc < (max + 1)) { ------------------ | Branch (27:8): [True: 71, False: 2.97M] ------------------ 28| 71| if ((err = mp_grow(c, max + 1)) != MP_OKAY) { ------------------ | | 161| 71|#define MP_OKAY 0 /* no error */ ------------------ | Branch (28:11): [True: 0, False: 71] ------------------ 29| 0| return err; 30| 0| } 31| 71| } 32| | 33| | /* get old used digit count and set new one */ 34| 2.97M| olduse = c->used; 35| 2.97M| c->used = max + 1; 36| | 37| 2.97M| { 38| 2.97M| mp_digit u, *tmpa, *tmpb, *tmpc; 39| 2.97M| int i; 40| | 41| | /* alias for digit pointers */ 42| | 43| | /* first input */ 44| 2.97M| tmpa = a->dp; 45| | 46| | /* second input */ 47| 2.97M| tmpb = b->dp; 48| | 49| | /* destination */ 50| 2.97M| tmpc = c->dp; 51| | 52| | /* zero the carry */ 53| 2.97M| u = 0; 54| 65.2M| for (i = 0; i < min; i++) { ------------------ | Branch (54:19): [True: 62.3M, False: 2.97M] ------------------ 55| | /* Compute the sum at one digit, T[i] = A[i] + B[i] + U */ 56| 62.3M| *tmpc = *tmpa++ + *tmpb++ + u; 57| | 58| | /* U = carry bit of T[i] */ 59| 62.3M| u = *tmpc >> (mp_digit)MP_DIGIT_BIT; ------------------ | | 82| 62.3M|# define MP_DIGIT_BIT 60 ------------------ 60| | 61| | /* take away carry bit from T[i] */ 62| 62.3M| *tmpc++ &= MP_MASK; ------------------ | | 106| 62.3M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 62.3M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 63| 62.3M| } 64| | 65| | /* now copy higher words if any, that is in A+B 66| | * if A or B has more digits add those in 67| | */ 68| 2.97M| if (min != max) { ------------------ | Branch (68:11): [True: 1.99M, False: 981k] ------------------ 69| 29.0M| for (; i < max; i++) { ------------------ | Branch (69:17): [True: 27.0M, False: 1.99M] ------------------ 70| | /* T[i] = X[i] + U */ 71| 27.0M| *tmpc = x->dp[i] + u; 72| | 73| | /* U = carry bit of T[i] */ 74| 27.0M| u = *tmpc >> (mp_digit)MP_DIGIT_BIT; ------------------ | | 82| 27.0M|# define MP_DIGIT_BIT 60 ------------------ 75| | 76| | /* take away carry bit from T[i] */ 77| 27.0M| *tmpc++ &= MP_MASK; ------------------ | | 106| 27.0M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 27.0M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 78| 27.0M| } 79| 1.99M| } 80| | 81| | /* add carry */ 82| 2.97M| *tmpc++ = u; 83| | 84| | /* clear digits above oldused */ 85| 2.97M| MP_ZERO_DIGITS(tmpc, olduse - c->used); ------------------ | | 89| 2.97M|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 2.97M|do { \ | | 91| 2.97M| int zd_ = (digits); \ | | 92| 2.97M| mp_digit* zm_ = (mem); \ | | 93| 2.97M| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 0, False: 2.97M] | | ------------------ | | 94| 0| *zm_++ = 0; \ | | 95| 0| } \ | | 96| 2.97M|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2.97M] | | ------------------ ------------------ 86| 2.97M| } 87| | 88| 2.97M| mp_clamp(c); 89| 2.97M| return MP_OKAY; ------------------ | | 161| 2.97M|#define MP_OKAY 0 /* no error */ ------------------ 90| 2.97M|} s_mp_exptmod: 15| 911|{ 16| 911| mp_int M[TAB_SIZE], res, mu; 17| 911| mp_digit buf; 18| 911| mp_err err; 19| 911| int bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize; 20| 911| mp_err(*redux)(mp_int *x, const mp_int *m, const mp_int *mu); 21| | 22| | /* find window size */ 23| 911| x = mp_count_bits(X); 24| 911| if (x <= 7) { ------------------ | Branch (24:8): [True: 218, False: 693] ------------------ 25| 218| winsize = 2; 26| 693| } else if (x <= 36) { ------------------ | Branch (26:15): [True: 250, False: 443] ------------------ 27| 250| winsize = 3; 28| 443| } else if (x <= 140) { ------------------ | Branch (28:15): [True: 123, False: 320] ------------------ 29| 123| winsize = 4; 30| 320| } else if (x <= 450) { ------------------ | Branch (30:15): [True: 320, False: 0] ------------------ 31| 320| winsize = 5; 32| 320| } else if (x <= 1303) { ------------------ | Branch (32:15): [True: 0, False: 0] ------------------ 33| 0| winsize = 6; 34| 0| } else if (x <= 3529) { ------------------ | Branch (34:15): [True: 0, False: 0] ------------------ 35| 0| winsize = 7; 36| 0| } else { 37| 0| winsize = 8; 38| 0| } 39| | 40| 911| winsize = MAX_WINSIZE ? MP_MIN(MAX_WINSIZE, winsize) : winsize; ------------------ | | 11| 911|# define MAX_WINSIZE 0 | | ------------------ | | | Branch (11:24): [Folded, False: 911] | | ------------------ ------------------ winsize = MAX_WINSIZE ? MP_MIN(MAX_WINSIZE, winsize) : winsize; ------------------ | | 156| 0|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 0, False: 0] | | ------------------ ------------------ 41| | 42| | /* init M array */ 43| | /* init first cell */ 44| 911| if ((err = mp_init(&M[1])) != MP_OKAY) { ------------------ | | 161| 911|#define MP_OKAY 0 /* no error */ ------------------ | Branch (44:8): [True: 0, False: 911] ------------------ 45| 0| return err; 46| 0| } 47| | 48| | /* now init the second half of the array */ 49| 8.45k| for (x = 1<<(winsize-1); x < (1 << winsize); x++) { ------------------ | Branch (49:29): [True: 7.54k, False: 911] ------------------ 50| 7.54k| if ((err = mp_init(&M[x])) != MP_OKAY) { ------------------ | | 161| 7.54k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (50:11): [True: 0, False: 7.54k] ------------------ 51| 0| for (y = 1<<(winsize-1); y < x; y++) { ------------------ | Branch (51:35): [True: 0, False: 0] ------------------ 52| 0| mp_clear(&M[y]); 53| 0| } 54| 0| mp_clear(&M[1]); 55| 0| return err; 56| 0| } 57| 7.54k| } 58| | 59| | /* create mu, used for Barrett reduction */ 60| 911| if ((err = mp_init(&mu)) != MP_OKAY) goto LBL_M; ------------------ | | 161| 911|#define MP_OKAY 0 /* no error */ ------------------ | Branch (60:8): [True: 0, False: 911] ------------------ 61| | 62| 911| if (redmode == 0) { ------------------ | Branch (62:8): [True: 515, False: 396] ------------------ 63| 515| if ((err = mp_reduce_setup(&mu, P)) != MP_OKAY) goto LBL_MU; ------------------ | | 161| 515|#define MP_OKAY 0 /* no error */ ------------------ | Branch (63:11): [True: 0, False: 515] ------------------ 64| 515| redux = mp_reduce; 65| 515| } else { 66| 396| if ((err = mp_reduce_2k_setup_l(P, &mu)) != MP_OKAY) goto LBL_MU; ------------------ | | 161| 396|#define MP_OKAY 0 /* no error */ ------------------ | Branch (66:11): [True: 0, False: 396] ------------------ 67| 396| redux = mp_reduce_2k_l; 68| 396| } 69| | 70| | /* create M table 71| | * 72| | * The M table contains powers of the base, 73| | * e.g. M[x] = G**x mod P 74| | * 75| | * The first half of the table is not 76| | * computed though accept for M[0] and M[1] 77| | */ 78| 911| if ((err = mp_mod(G, P, &M[1])) != MP_OKAY) goto LBL_MU; ------------------ | | 161| 911|#define MP_OKAY 0 /* no error */ ------------------ | Branch (78:8): [True: 0, False: 911] ------------------ 79| | 80| | /* compute the value at M[1<<(winsize-1)] by squaring 81| | * M[1] (winsize-1) times 82| | */ 83| 911| if ((err = mp_copy(&M[1], &M[(size_t)1 << (winsize - 1)])) != MP_OKAY) goto LBL_MU; ------------------ | | 161| 911|#define MP_OKAY 0 /* no error */ ------------------ | Branch (83:8): [True: 0, False: 911] ------------------ 84| | 85| 3.27k| for (x = 0; x < (winsize - 1); x++) { ------------------ | Branch (85:16): [True: 2.36k, False: 911] ------------------ 86| | /* square it */ 87| 2.36k| if ((err = mp_sqr(&M[(size_t)1 << (winsize - 1)], ------------------ | Branch (87:11): [True: 0, False: 2.36k] ------------------ 88| 2.36k| &M[(size_t)1 << (winsize - 1)])) != MP_OKAY) goto LBL_MU; ------------------ | | 161| 2.36k|#define MP_OKAY 0 /* no error */ ------------------ 89| | 90| | /* reduce modulo P */ 91| 2.36k| if ((err = redux(&M[(size_t)1 << (winsize - 1)], P, &mu)) != MP_OKAY) goto LBL_MU; ------------------ | | 161| 2.36k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (91:11): [True: 0, False: 2.36k] ------------------ 92| 2.36k| } 93| | 94| | /* create upper table, that is M[x] = M[x-1] * M[1] (mod P) 95| | * for x = (2**(winsize - 1) + 1) to (2**winsize - 1) 96| | */ 97| 7.54k| for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) { ------------------ | Branch (97:39): [True: 6.62k, False: 911] ------------------ 98| 6.62k| if ((err = mp_mul(&M[x - 1], &M[1], &M[x])) != MP_OKAY) goto LBL_MU; ------------------ | | 161| 6.62k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (98:11): [True: 0, False: 6.62k] ------------------ 99| 6.62k| if ((err = redux(&M[x], P, &mu)) != MP_OKAY) goto LBL_MU; ------------------ | | 161| 6.62k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (99:11): [True: 0, False: 6.62k] ------------------ 100| 6.62k| } 101| | 102| | /* setup result */ 103| 911| if ((err = mp_init(&res)) != MP_OKAY) goto LBL_MU; ------------------ | | 161| 911|#define MP_OKAY 0 /* no error */ ------------------ | Branch (103:8): [True: 0, False: 911] ------------------ 104| 911| mp_set(&res, 1uL); 105| | 106| | /* set initial mode and bit cnt */ 107| 911| mode = 0; 108| 911| bitcnt = 1; 109| 911| buf = 0; 110| 911| digidx = X->used - 1; 111| 911| bitcpy = 0; 112| 911| bitbuf = 0; 113| | 114| 92.6k| for (;;) { 115| | /* grab next digit as required */ 116| 92.6k| if (--bitcnt == 0) { ------------------ | Branch (116:11): [True: 2.44k, False: 90.2k] ------------------ 117| | /* if digidx == -1 we are out of digits */ 118| 2.44k| if (digidx == -1) { ------------------ | Branch (118:14): [True: 911, False: 1.52k] ------------------ 119| 911| break; 120| 911| } 121| | /* read next digit and reset the bitcnt */ 122| 1.52k| buf = X->dp[digidx--]; 123| 1.52k| bitcnt = (int)MP_DIGIT_BIT; ------------------ | | 82| 1.52k|# define MP_DIGIT_BIT 60 ------------------ 124| 1.52k| } 125| | 126| | /* grab the next msb from the exponent */ 127| 91.7k| y = (buf >> (mp_digit)(MP_DIGIT_BIT - 1)) & 1uL; ------------------ | | 82| 91.7k|# define MP_DIGIT_BIT 60 ------------------ 128| 91.7k| buf <<= (mp_digit)1; 129| | 130| | /* if the bit is zero and mode == 0 then we ignore it 131| | * These represent the leading zero bits before the first 1 bit 132| | * in the exponent. Technically this opt is not required but it 133| | * does lower the # of trivial squaring/reductions used 134| | */ 135| 91.7k| if ((mode == 0) && (y == 0)) { ------------------ | Branch (135:11): [True: 25.6k, False: 66.1k] | Branch (135:26): [True: 24.8k, False: 755] ------------------ 136| 24.8k| continue; 137| 24.8k| } 138| | 139| | /* if the bit is zero and mode == 1 then we square */ 140| 66.8k| if ((mode == 1) && (y == 0)) { ------------------ | Branch (140:11): [True: 25.7k, False: 41.1k] | Branch (140:26): [True: 15.1k, False: 10.6k] ------------------ 141| 15.1k| if ((err = mp_sqr(&res, &res)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 15.1k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (141:14): [True: 0, False: 15.1k] ------------------ 142| 15.1k| if ((err = redux(&res, P, &mu)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 15.1k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (142:14): [True: 0, False: 15.1k] ------------------ 143| 15.1k| continue; 144| 15.1k| } 145| | 146| | /* else we add it to the window */ 147| 51.7k| bitbuf |= (y << (winsize - ++bitcpy)); 148| 51.7k| mode = 2; 149| | 150| 51.7k| if (bitcpy == winsize) { ------------------ | Branch (150:11): [True: 11.0k, False: 40.7k] ------------------ 151| | /* ok window is filled so square as required and multiply */ 152| | /* square first */ 153| 61.7k| for (x = 0; x < winsize; x++) { ------------------ | Branch (153:22): [True: 50.7k, False: 11.0k] ------------------ 154| 50.7k| if ((err = mp_sqr(&res, &res)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 50.7k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (154:17): [True: 0, False: 50.7k] ------------------ 155| 50.7k| if ((err = redux(&res, P, &mu)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 50.7k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (155:17): [True: 0, False: 50.7k] ------------------ 156| 50.7k| } 157| | 158| | /* then multiply */ 159| 11.0k| if ((err = mp_mul(&res, &M[bitbuf], &res)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 11.0k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (159:14): [True: 0, False: 11.0k] ------------------ 160| 11.0k| if ((err = redux(&res, P, &mu)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 11.0k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (160:14): [True: 0, False: 11.0k] ------------------ 161| | 162| | /* empty window and reset */ 163| 11.0k| bitcpy = 0; 164| 11.0k| bitbuf = 0; 165| 11.0k| mode = 1; 166| 11.0k| } 167| 51.7k| } 168| | 169| | /* if bits remain then square/multiply */ 170| 911| if ((mode == 2) && (bitcpy > 0)) { ------------------ | Branch (170:8): [True: 374, False: 537] | Branch (170:23): [True: 374, False: 0] ------------------ 171| | /* square then multiply if the bit is set */ 172| 1.39k| for (x = 0; x < bitcpy; x++) { ------------------ | Branch (172:19): [True: 1.02k, False: 374] ------------------ 173| 1.02k| if ((err = mp_sqr(&res, &res)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 1.02k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (173:14): [True: 0, False: 1.02k] ------------------ 174| 1.02k| if ((err = redux(&res, P, &mu)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 1.02k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (174:14): [True: 0, False: 1.02k] ------------------ 175| | 176| 1.02k| bitbuf <<= 1; 177| 1.02k| if ((bitbuf & (1 << winsize)) != 0) { ------------------ | Branch (177:14): [True: 790, False: 231] ------------------ 178| | /* then multiply */ 179| 790| if ((err = mp_mul(&res, &M[1], &res)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 790|#define MP_OKAY 0 /* no error */ ------------------ | Branch (179:17): [True: 0, False: 790] ------------------ 180| 790| if ((err = redux(&res, P, &mu)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 790|#define MP_OKAY 0 /* no error */ ------------------ | Branch (180:17): [True: 0, False: 790] ------------------ 181| 790| } 182| 1.02k| } 183| 374| } 184| | 185| 911| mp_exch(&res, Y); 186| 911| err = MP_OKAY; ------------------ | | 161| 911|#define MP_OKAY 0 /* no error */ ------------------ 187| 911|LBL_RES: 188| 911| mp_clear(&res); 189| 911|LBL_MU: 190| 911| mp_clear(&mu); 191| 911|LBL_M: 192| 911| mp_clear(&M[1]); 193| 8.45k| for (x = 1<<(winsize-1); x < (1 << winsize); x++) { ------------------ | Branch (193:29): [True: 7.54k, False: 911] ------------------ 194| 7.54k| mp_clear(&M[x]); 195| 7.54k| } 196| 911| return err; 197| 911|} s_mp_exptmod_fast: 23| 2.37k|{ 24| 2.37k| mp_int M[TAB_SIZE], res; 25| 2.37k| mp_digit buf, mp; 26| 2.37k| int bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize; 27| 2.37k| mp_err err; 28| | 29| | /* use a pointer to the reduction algorithm. This allows us to use 30| | * one of many reduction algorithms without modding the guts of 31| | * the code with if statements everywhere. 32| | */ 33| 2.37k| mp_err(*redux)(mp_int *x, const mp_int *n, mp_digit rho); 34| | 35| | /* find window size */ 36| 2.37k| x = mp_count_bits(X); 37| 2.37k| if (x <= 7) { ------------------ | Branch (37:8): [True: 335, False: 2.04k] ------------------ 38| 335| winsize = 2; 39| 2.04k| } else if (x <= 36) { ------------------ | Branch (39:15): [True: 131, False: 1.91k] ------------------ 40| 131| winsize = 3; 41| 1.91k| } else if (x <= 140) { ------------------ | Branch (41:15): [True: 1.24k, False: 668] ------------------ 42| 1.24k| winsize = 4; 43| 1.24k| } else if (x <= 450) { ------------------ | Branch (43:15): [True: 668, False: 0] ------------------ 44| 668| winsize = 5; 45| 668| } else if (x <= 1303) { ------------------ | Branch (45:15): [True: 0, False: 0] ------------------ 46| 0| winsize = 6; 47| 0| } else if (x <= 3529) { ------------------ | Branch (47:15): [True: 0, False: 0] ------------------ 48| 0| winsize = 7; 49| 0| } else { 50| 0| winsize = 8; 51| 0| } 52| | 53| 2.37k| winsize = MAX_WINSIZE ? MP_MIN(MAX_WINSIZE, winsize) : winsize; ------------------ | | 19| 2.37k|# define MAX_WINSIZE 0 | | ------------------ | | | Branch (19:24): [Folded, False: 2.37k] | | ------------------ ------------------ winsize = MAX_WINSIZE ? MP_MIN(MAX_WINSIZE, winsize) : winsize; ------------------ | | 156| 0|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 0, False: 0] | | ------------------ ------------------ 54| | 55| | /* init M array */ 56| | /* init first cell */ 57| 2.37k| if ((err = mp_init_size(&M[1], P->alloc)) != MP_OKAY) { ------------------ | | 161| 2.37k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (57:8): [True: 0, False: 2.37k] ------------------ 58| 0| return err; 59| 0| } 60| | 61| | /* now init the second half of the array */ 62| 24.2k| for (x = 1<<(winsize-1); x < (1 << winsize); x++) { ------------------ | Branch (62:29): [True: 21.8k, False: 2.37k] ------------------ 63| 21.8k| if ((err = mp_init_size(&M[x], P->alloc)) != MP_OKAY) { ------------------ | | 161| 21.8k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (63:11): [True: 0, False: 21.8k] ------------------ 64| 0| for (y = 1<<(winsize-1); y < x; y++) { ------------------ | Branch (64:35): [True: 0, False: 0] ------------------ 65| 0| mp_clear(&M[y]); 66| 0| } 67| 0| mp_clear(&M[1]); 68| 0| return err; 69| 0| } 70| 21.8k| } 71| | 72| | /* determine and setup reduction code */ 73| 2.37k| if (redmode == 0) { ------------------ | Branch (73:8): [True: 2.37k, False: 0] ------------------ 74| 2.37k| if (MP_HAS(MP_MONTGOMERY_SETUP)) { ------------------ | | 150| 2.37k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 2.37k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 2.37k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 2.37k, Folded] | | ------------------ ------------------ 75| | /* now setup montgomery */ 76| 2.37k| if ((err = mp_montgomery_setup(P, &mp)) != MP_OKAY) goto LBL_M; ------------------ | | 161| 2.37k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (76:14): [True: 0, False: 2.37k] ------------------ 77| 2.37k| } else { 78| 0| err = MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 79| 0| goto LBL_M; 80| 0| } 81| | 82| | /* automatically pick the comba one if available (saves quite a few calls/ifs) */ 83| 2.37k| if (MP_HAS(S_MP_MONTGOMERY_REDUCE_FAST) && ------------------ | | 150| 4.75k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 2.37k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 2.37k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 2.37k, Folded] | | ------------------ ------------------ 84| 2.37k| (((P->used * 2) + 1) < MP_WARRAY) && ------------------ | | 172| 2.37k|#define MP_WARRAY PRIVATE_MP_WARRAY | | ------------------ | | | | 203| 2.37k|#define PRIVATE_MP_WARRAY (int)(1uLL << (((CHAR_BIT * sizeof(private_mp_word)) - (2 * MP_DIGIT_BIT)) + 1)) | | | | ------------------ | | | | | | 82| 2.37k|# define MP_DIGIT_BIT 60 | | | | ------------------ | | ------------------ ------------------ | Branch (84:11): [True: 2.37k, False: 0] ------------------ 85| 2.37k| (P->used < MP_MAXFAST)) { ------------------ | | 168| 2.37k|#define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT))) | | ------------------ | | | | 167| 2.37k|#define MP_SIZEOF_BITS(type) ((size_t)CHAR_BIT * sizeof(type)) | | ------------------ | | #define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT))) | | ------------------ | | | | 82| 2.37k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ | Branch (85:11): [True: 2.37k, False: 0] ------------------ 86| 2.37k| redux = s_mp_montgomery_reduce_fast; 87| 2.37k| } else if (MP_HAS(MP_MONTGOMERY_REDUCE)) { ------------------ | | 150| 0|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 0|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 0|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 0, Folded] | | ------------------ ------------------ 88| | /* use slower baseline Montgomery method */ 89| 0| redux = mp_montgomery_reduce; 90| 0| } else { 91| 0| err = MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 92| 0| goto LBL_M; 93| 0| } 94| 2.37k| } else if (redmode == 1) { ------------------ | Branch (94:15): [True: 0, False: 0] ------------------ 95| 0| if (MP_HAS(MP_DR_SETUP) && MP_HAS(MP_DR_REDUCE)) { ------------------ | | 150| 0|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 0|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 0|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 0, Folded] | | ------------------ ------------------ if (MP_HAS(MP_DR_SETUP) && MP_HAS(MP_DR_REDUCE)) { ------------------ | | 150| 0|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 0|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 0|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 0, Folded] | | ------------------ ------------------ 96| | /* setup DR reduction for moduli of the form B**k - b */ 97| 0| mp_dr_setup(P, &mp); 98| 0| redux = mp_dr_reduce; 99| 0| } else { 100| 0| err = MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 101| 0| goto LBL_M; 102| 0| } 103| 0| } else if (MP_HAS(MP_REDUCE_2K_SETUP) && MP_HAS(MP_REDUCE_2K)) { ------------------ | | 150| 0|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 0|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 0|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 0, Folded] | | ------------------ ------------------ } else if (MP_HAS(MP_REDUCE_2K_SETUP) && MP_HAS(MP_REDUCE_2K)) { ------------------ | | 150| 0|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 0|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 0|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 0, Folded] | | ------------------ ------------------ 104| | /* setup DR reduction for moduli of the form 2**k - b */ 105| 0| if ((err = mp_reduce_2k_setup(P, &mp)) != MP_OKAY) goto LBL_M; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (105:11): [True: 0, False: 0] ------------------ 106| 0| redux = mp_reduce_2k; 107| 0| } else { 108| 0| err = MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 109| 0| goto LBL_M; 110| 0| } 111| | 112| | /* setup result */ 113| 2.37k| if ((err = mp_init_size(&res, P->alloc)) != MP_OKAY) goto LBL_M; ------------------ | | 161| 2.37k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (113:8): [True: 0, False: 2.37k] ------------------ 114| | 115| | /* create M table 116| | * 117| | 118| | * 119| | * The first half of the table is not computed though accept for M[0] and M[1] 120| | */ 121| | 122| 2.37k| if (redmode == 0) { ------------------ | Branch (122:8): [True: 2.37k, False: 0] ------------------ 123| 2.37k| if (MP_HAS(MP_MONTGOMERY_CALC_NORMALIZATION)) { ------------------ | | 150| 2.37k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 2.37k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 2.37k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 2.37k, Folded] | | ------------------ ------------------ 124| | /* now we need R mod m */ 125| 2.37k| if ((err = mp_montgomery_calc_normalization(&res, P)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 2.37k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (125:14): [True: 0, False: 2.37k] ------------------ 126| | 127| | /* now set M[1] to G * R mod m */ 128| 2.37k| if ((err = mp_mulmod(G, &res, P, &M[1])) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 2.37k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (128:14): [True: 0, False: 2.37k] ------------------ 129| 2.37k| } else { 130| 0| err = MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 131| 0| goto LBL_RES; 132| 0| } 133| 2.37k| } else { 134| 0| mp_set(&res, 1uL); 135| 0| if ((err = mp_mod(G, P, &M[1])) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (135:11): [True: 0, False: 0] ------------------ 136| 0| } 137| | 138| | /* compute the value at M[1<<(winsize-1)] by squaring M[1] (winsize-1) times */ 139| 2.37k| if ((err = mp_copy(&M[1], &M[(size_t)1 << (winsize - 1)])) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 2.37k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (139:8): [True: 0, False: 2.37k] ------------------ 140| | 141| 9.37k| for (x = 0; x < (winsize - 1); x++) { ------------------ | Branch (141:16): [True: 7.00k, False: 2.37k] ------------------ 142| 7.00k| if ((err = mp_sqr(&M[(size_t)1 << (winsize - 1)], &M[(size_t)1 << (winsize - 1)])) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 7.00k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (142:11): [True: 0, False: 7.00k] ------------------ 143| 7.00k| if ((err = redux(&M[(size_t)1 << (winsize - 1)], P, mp)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 7.00k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (143:11): [True: 0, False: 7.00k] ------------------ 144| 7.00k| } 145| | 146| | /* create upper table */ 147| 21.8k| for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) { ------------------ | Branch (147:39): [True: 19.4k, False: 2.37k] ------------------ 148| 19.4k| if ((err = mp_mul(&M[x - 1], &M[1], &M[x])) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 19.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (148:11): [True: 0, False: 19.4k] ------------------ 149| 19.4k| if ((err = redux(&M[x], P, mp)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 19.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (149:11): [True: 0, False: 19.4k] ------------------ 150| 19.4k| } 151| | 152| | /* set initial mode and bit cnt */ 153| 2.37k| mode = 0; 154| 2.37k| bitcnt = 1; 155| 2.37k| buf = 0; 156| 2.37k| digidx = X->used - 1; 157| 2.37k| bitcpy = 0; 158| 2.37k| bitbuf = 0; 159| | 160| 284k| for (;;) { 161| | /* grab next digit as required */ 162| 284k| if (--bitcnt == 0) { ------------------ | Branch (162:11): [True: 7.07k, False: 277k] ------------------ 163| | /* if digidx == -1 we are out of digits so break */ 164| 7.07k| if (digidx == -1) { ------------------ | Branch (164:14): [True: 2.37k, False: 4.69k] ------------------ 165| 2.37k| break; 166| 2.37k| } 167| | /* read next digit and reset bitcnt */ 168| 4.69k| buf = X->dp[digidx--]; 169| 4.69k| bitcnt = (int)MP_DIGIT_BIT; ------------------ | | 82| 4.69k|# define MP_DIGIT_BIT 60 ------------------ 170| 4.69k| } 171| | 172| | /* grab the next msb from the exponent */ 173| 281k| y = (mp_digit)(buf >> (MP_DIGIT_BIT - 1)) & 1uL; ------------------ | | 82| 281k|# define MP_DIGIT_BIT 60 ------------------ 174| 281k| buf <<= (mp_digit)1; 175| | 176| | /* if the bit is zero and mode == 0 then we ignore it 177| | * These represent the leading zero bits before the first 1 bit 178| | * in the exponent. Technically this opt is not required but it 179| | * does lower the # of trivial squaring/reductions used 180| | */ 181| 281k| if ((mode == 0) && (y == 0)) { ------------------ | Branch (181:11): [True: 61.4k, False: 220k] | Branch (181:26): [True: 59.3k, False: 2.13k] ------------------ 182| 59.3k| continue; 183| 59.3k| } 184| | 185| | /* if the bit is zero and mode == 1 then we square */ 186| 222k| if ((mode == 1) && (y == 0)) { ------------------ | Branch (186:11): [True: 104k, False: 117k] | Branch (186:26): [True: 71.4k, False: 33.5k] ------------------ 187| 71.4k| if ((err = mp_sqr(&res, &res)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 71.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (187:14): [True: 0, False: 71.4k] ------------------ 188| 71.4k| if ((err = redux(&res, P, mp)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 71.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (188:14): [True: 0, False: 71.4k] ------------------ 189| 71.4k| continue; 190| 71.4k| } 191| | 192| | /* else we add it to the window */ 193| 151k| bitbuf |= (y << (winsize - ++bitcpy)); 194| 151k| mode = 2; 195| | 196| 151k| if (bitcpy == winsize) { ------------------ | Branch (196:11): [True: 33.9k, False: 117k] ------------------ 197| | /* ok window is filled so square as required and multiply */ 198| | /* square first */ 199| 181k| for (x = 0; x < winsize; x++) { ------------------ | Branch (199:22): [True: 147k, False: 33.9k] ------------------ 200| 147k| if ((err = mp_sqr(&res, &res)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 147k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (200:17): [True: 0, False: 147k] ------------------ 201| 147k| if ((err = redux(&res, P, mp)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 147k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (201:17): [True: 0, False: 147k] ------------------ 202| 147k| } 203| | 204| | /* then multiply */ 205| 33.9k| if ((err = mp_mul(&res, &M[bitbuf], &res)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 33.9k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (205:14): [True: 0, False: 33.9k] ------------------ 206| 33.9k| if ((err = redux(&res, P, mp)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 33.9k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (206:14): [True: 0, False: 33.9k] ------------------ 207| | 208| | /* empty window and reset */ 209| 33.9k| bitcpy = 0; 210| 33.9k| bitbuf = 0; 211| 33.9k| mode = 1; 212| 33.9k| } 213| 151k| } 214| | 215| | /* if bits remain then square/multiply */ 216| 2.37k| if ((mode == 2) && (bitcpy > 0)) { ------------------ | Branch (216:8): [True: 1.66k, False: 713] | Branch (216:23): [True: 1.66k, False: 0] ------------------ 217| | /* square then multiply if the bit is set */ 218| 4.98k| for (x = 0; x < bitcpy; x++) { ------------------ | Branch (218:19): [True: 3.31k, False: 1.66k] ------------------ 219| 3.31k| if ((err = mp_sqr(&res, &res)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 3.31k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (219:14): [True: 0, False: 3.31k] ------------------ 220| 3.31k| if ((err = redux(&res, P, mp)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 3.31k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (220:14): [True: 0, False: 3.31k] ------------------ 221| | 222| | /* get next bit of the window */ 223| 3.31k| bitbuf <<= 1; 224| 3.31k| if ((bitbuf & (1 << winsize)) != 0) { ------------------ | Branch (224:14): [True: 2.87k, False: 447] ------------------ 225| | /* then multiply */ 226| 2.87k| if ((err = mp_mul(&res, &M[1], &res)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 2.87k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (226:17): [True: 0, False: 2.87k] ------------------ 227| 2.87k| if ((err = redux(&res, P, mp)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 2.87k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (227:17): [True: 0, False: 2.87k] ------------------ 228| 2.87k| } 229| 3.31k| } 230| 1.66k| } 231| | 232| 2.37k| if (redmode == 0) { ------------------ | Branch (232:8): [True: 2.37k, False: 0] ------------------ 233| | /* fixup result if Montgomery reduction is used 234| | * recall that any value in a Montgomery system is 235| | * actually multiplied by R mod n. So we have 236| | * to reduce one more time to cancel out the factor 237| | * of R. 238| | */ 239| 2.37k| if ((err = redux(&res, P, mp)) != MP_OKAY) goto LBL_RES; ------------------ | | 161| 2.37k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (239:11): [True: 0, False: 2.37k] ------------------ 240| 2.37k| } 241| | 242| | /* swap res with Y */ 243| 2.37k| mp_exch(&res, Y); 244| 2.37k| err = MP_OKAY; ------------------ | | 161| 2.37k|#define MP_OKAY 0 /* no error */ ------------------ 245| 2.37k|LBL_RES: 246| 2.37k| mp_clear(&res); 247| 2.37k|LBL_M: 248| 2.37k| mp_clear(&M[1]); 249| 24.2k| for (x = 1<<(winsize-1); x < (1 << winsize); x++) { ------------------ | Branch (249:29): [True: 21.8k, False: 2.37k] ------------------ 250| 21.8k| mp_clear(&M[x]); 251| 21.8k| } 252| 2.37k| return err; 253| 2.37k|} s_mp_invmod_fast: 13| 668|{ 14| 668| mp_int x, y, u, v, B, D; 15| 668| mp_sign neg; 16| 668| mp_err err; 17| | 18| | /* 2. [modified] b must be odd */ 19| 668| if (MP_IS_EVEN(b)) { ------------------ | | 164| 668|#define MP_IS_EVEN(a) (((a)->used == 0) || (((a)->dp[0] & 1u) == 0u)) | | ------------------ | | | Branch (164:24): [True: 0, False: 668] | | | Branch (164:44): [True: 0, False: 668] | | ------------------ ------------------ 20| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 21| 0| } 22| | 23| | /* init all our temps */ 24| 668| if ((err = mp_init_multi(&x, &y, &u, &v, &B, &D, NULL)) != MP_OKAY) { ------------------ | | 161| 668|#define MP_OKAY 0 /* no error */ ------------------ | Branch (24:8): [True: 0, False: 668] ------------------ 25| 0| return err; 26| 0| } 27| | 28| | /* x == modulus, y == value to invert */ 29| 668| if ((err = mp_copy(b, &x)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 668|#define MP_OKAY 0 /* no error */ ------------------ | Branch (29:8): [True: 0, False: 668] ------------------ 30| | 31| | /* we need y = |a| */ 32| 668| if ((err = mp_mod(a, b, &y)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 668|#define MP_OKAY 0 /* no error */ ------------------ | Branch (32:8): [True: 0, False: 668] ------------------ 33| | 34| | /* if one of x,y is zero return an error! */ 35| 668| if (MP_IS_ZERO(&x) || MP_IS_ZERO(&y)) { ------------------ | | 163| 1.33k|#define MP_IS_ZERO(a) ((a)->used == 0) | | ------------------ | | | Branch (163:23): [True: 0, False: 668] | | ------------------ ------------------ if (MP_IS_ZERO(&x) || MP_IS_ZERO(&y)) { ------------------ | | 163| 668|#define MP_IS_ZERO(a) ((a)->used == 0) | | ------------------ | | | Branch (163:23): [True: 0, False: 668] | | ------------------ ------------------ 36| 0| err = MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 37| 0| goto LBL_ERR; 38| 0| } 39| | 40| | /* 3. u=x, v=y, A=1, B=0, C=0,D=1 */ 41| 668| if ((err = mp_copy(&x, &u)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 668|#define MP_OKAY 0 /* no error */ ------------------ | Branch (41:8): [True: 0, False: 668] ------------------ 42| 668| if ((err = mp_copy(&y, &v)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 668|#define MP_OKAY 0 /* no error */ ------------------ | Branch (42:8): [True: 0, False: 668] ------------------ 43| 668| mp_set(&D, 1uL); 44| | 45| 119k|top: 46| | /* 4. while u is even do */ 47| 286k| while (MP_IS_EVEN(&u)) { ------------------ | | 164| 286k|#define MP_IS_EVEN(a) (((a)->used == 0) || (((a)->dp[0] & 1u) == 0u)) | | ------------------ | | | Branch (164:24): [True: 0, False: 286k] | | | Branch (164:44): [True: 166k, False: 119k] | | ------------------ ------------------ 48| | /* 4.1 u = u/2 */ 49| 166k| if ((err = mp_div_2(&u, &u)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 166k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (49:11): [True: 0, False: 166k] ------------------ 50| | 51| | /* 4.2 if B is odd then */ 52| 166k| if (MP_IS_ODD(&B)) { ------------------ | | 165| 166k|#define MP_IS_ODD(a) (((a)->used > 0) && (((a)->dp[0] & 1u) == 1u)) | | ------------------ | | | Branch (165:24): [True: 166k, False: 0] | | | Branch (165:43): [True: 79.0k, False: 87.8k] | | ------------------ ------------------ 53| 79.0k| if ((err = mp_sub(&B, &x, &B)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 79.0k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (53:14): [True: 0, False: 79.0k] ------------------ 54| 79.0k| } 55| | /* B = B/2 */ 56| 166k| if ((err = mp_div_2(&B, &B)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 166k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (56:11): [True: 0, False: 166k] ------------------ 57| 166k| } 58| | 59| | /* 5. while v is even do */ 60| 198k| while (MP_IS_EVEN(&v)) { ------------------ | | 164| 198k|#define MP_IS_EVEN(a) (((a)->used == 0) || (((a)->dp[0] & 1u) == 0u)) | | ------------------ | | | Branch (164:24): [True: 0, False: 198k] | | | Branch (164:44): [True: 78.6k, False: 119k] | | ------------------ ------------------ 61| | /* 5.1 v = v/2 */ 62| 78.6k| if ((err = mp_div_2(&v, &v)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 78.6k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (62:11): [True: 0, False: 78.6k] ------------------ 63| | 64| | /* 5.2 if D is odd then */ 65| 78.6k| if (MP_IS_ODD(&D)) { ------------------ | | 165| 78.6k|#define MP_IS_ODD(a) (((a)->used > 0) && (((a)->dp[0] & 1u) == 1u)) | | ------------------ | | | Branch (165:24): [True: 78.6k, False: 0] | | | Branch (165:43): [True: 48.4k, False: 30.2k] | | ------------------ ------------------ 66| | /* D = (D-x)/2 */ 67| 48.4k| if ((err = mp_sub(&D, &x, &D)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 48.4k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (67:14): [True: 0, False: 48.4k] ------------------ 68| 48.4k| } 69| | /* D = D/2 */ 70| 78.6k| if ((err = mp_div_2(&D, &D)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 78.6k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (70:11): [True: 0, False: 78.6k] ------------------ 71| 78.6k| } 72| | 73| | /* 6. if u >= v then */ 74| 119k| if (mp_cmp(&u, &v) != MP_LT) { ------------------ | | 154| 119k|#define MP_LT -1 /* less than */ ------------------ | Branch (74:8): [True: 84.0k, False: 35.5k] ------------------ 75| | /* u = u - v, B = B - D */ 76| 84.0k| if ((err = mp_sub(&u, &v, &u)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 84.0k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (76:11): [True: 0, False: 84.0k] ------------------ 77| | 78| 84.0k| if ((err = mp_sub(&B, &D, &B)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 84.0k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (78:11): [True: 0, False: 84.0k] ------------------ 79| 84.0k| } else { 80| | /* v - v - u, D = D - B */ 81| 35.5k| if ((err = mp_sub(&v, &u, &v)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 35.5k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (81:11): [True: 0, False: 35.5k] ------------------ 82| | 83| 35.5k| if ((err = mp_sub(&D, &B, &D)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 35.5k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (83:11): [True: 0, False: 35.5k] ------------------ 84| 35.5k| } 85| | 86| | /* if not zero goto step 4 */ 87| 119k| if (!MP_IS_ZERO(&u)) { ------------------ | | 163| 119k|#define MP_IS_ZERO(a) ((a)->used == 0) ------------------ | Branch (87:8): [True: 118k, False: 668] ------------------ 88| 118k| goto top; 89| 118k| } 90| | 91| | /* now a = C, b = D, gcd == g*v */ 92| | 93| | /* if v != 1 then there is no inverse */ 94| 668| if (mp_cmp_d(&v, 1uL) != MP_EQ) { ------------------ | | 155| 668|#define MP_EQ 0 /* equal to */ ------------------ | Branch (94:8): [True: 1, False: 667] ------------------ 95| 1| err = MP_VAL; ------------------ | | 164| 1|#define MP_VAL -3 /* invalid input */ ------------------ 96| 1| goto LBL_ERR; 97| 1| } 98| | 99| | /* b is now the inverse */ 100| 667| neg = a->sign; 101| 1.24k| while (D.sign == MP_NEG) { ------------------ | | 152| 1.24k|#define MP_NEG 1 /* negative */ ------------------ | Branch (101:11): [True: 576, False: 667] ------------------ 102| 576| if ((err = mp_add(&D, b, &D)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 576|#define MP_OKAY 0 /* no error */ ------------------ | Branch (102:11): [True: 0, False: 576] ------------------ 103| 576| } 104| | 105| | /* too big */ 106| 714| while (mp_cmp_mag(&D, b) != MP_LT) { ------------------ | | 154| 714|#define MP_LT -1 /* less than */ ------------------ | Branch (106:11): [True: 47, False: 667] ------------------ 107| 47| if ((err = mp_sub(&D, b, &D)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 47|#define MP_OKAY 0 /* no error */ ------------------ | Branch (107:11): [True: 0, False: 47] ------------------ 108| 47| } 109| | 110| 667| mp_exch(&D, c); 111| 667| c->sign = neg; 112| 667| err = MP_OKAY; ------------------ | | 161| 667|#define MP_OKAY 0 /* no error */ ------------------ 113| | 114| 668|LBL_ERR: 115| | mp_clear_multi(&x, &y, &u, &v, &B, &D, NULL); 116| 668| return err; 117| 667|} s_mp_invmod_slow: 8| 74|{ 9| 74| mp_int x, y, u, v, A, B, C, D; 10| 74| mp_err err; 11| | 12| | /* b cannot be negative */ 13| 74| if ((b->sign == MP_NEG) || MP_IS_ZERO(b)) { ------------------ | | 152| 74|#define MP_NEG 1 /* negative */ ------------------ if ((b->sign == MP_NEG) || MP_IS_ZERO(b)) { ------------------ | | 163| 74|#define MP_IS_ZERO(a) ((a)->used == 0) | | ------------------ | | | Branch (163:23): [True: 0, False: 74] | | ------------------ ------------------ | Branch (13:8): [True: 0, False: 74] ------------------ 14| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 15| 0| } 16| | 17| | /* init temps */ 18| 74| if ((err = mp_init_multi(&x, &y, &u, &v, ------------------ | Branch (18:8): [True: 0, False: 74] ------------------ 19| 74| &A, &B, &C, &D, NULL)) != MP_OKAY) { ------------------ | | 161| 74|#define MP_OKAY 0 /* no error */ ------------------ 20| 0| return err; 21| 0| } 22| | 23| | /* x = a, y = b */ 24| 74| if ((err = mp_mod(a, b, &x)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 74|#define MP_OKAY 0 /* no error */ ------------------ | Branch (24:8): [True: 0, False: 74] ------------------ 25| 74| if ((err = mp_copy(b, &y)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 74|#define MP_OKAY 0 /* no error */ ------------------ | Branch (25:8): [True: 0, False: 74] ------------------ 26| | 27| | /* 2. [modified] if x,y are both even then return an error! */ 28| 74| if (MP_IS_EVEN(&x) && MP_IS_EVEN(&y)) { ------------------ | | 164| 148|#define MP_IS_EVEN(a) (((a)->used == 0) || (((a)->dp[0] & 1u) == 0u)) | | ------------------ | | | Branch (164:24): [True: 0, False: 74] | | | Branch (164:44): [True: 1, False: 73] | | ------------------ ------------------ if (MP_IS_EVEN(&x) && MP_IS_EVEN(&y)) { ------------------ | | 164| 1|#define MP_IS_EVEN(a) (((a)->used == 0) || (((a)->dp[0] & 1u) == 0u)) | | ------------------ | | | Branch (164:24): [True: 0, False: 1] | | | Branch (164:44): [True: 1, False: 0] | | ------------------ ------------------ 29| 1| err = MP_VAL; ------------------ | | 164| 1|#define MP_VAL -3 /* invalid input */ ------------------ 30| 1| goto LBL_ERR; 31| 1| } 32| | 33| | /* 3. u=x, v=y, A=1, B=0, C=0,D=1 */ 34| 73| if ((err = mp_copy(&x, &u)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 73|#define MP_OKAY 0 /* no error */ ------------------ | Branch (34:8): [True: 0, False: 73] ------------------ 35| 73| if ((err = mp_copy(&y, &v)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 73|#define MP_OKAY 0 /* no error */ ------------------ | Branch (35:8): [True: 0, False: 73] ------------------ 36| 73| mp_set(&A, 1uL); 37| 73| mp_set(&D, 1uL); 38| | 39| 6.50k|top: 40| | /* 4. while u is even do */ 41| 11.2k| while (MP_IS_EVEN(&u)) { ------------------ | | 164| 11.2k|#define MP_IS_EVEN(a) (((a)->used == 0) || (((a)->dp[0] & 1u) == 0u)) | | ------------------ | | | Branch (164:24): [True: 0, False: 11.2k] | | | Branch (164:44): [True: 4.75k, False: 6.50k] | | ------------------ ------------------ 42| | /* 4.1 u = u/2 */ 43| 4.75k| if ((err = mp_div_2(&u, &u)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 4.75k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (43:11): [True: 0, False: 4.75k] ------------------ 44| | 45| | /* 4.2 if A or B is odd then */ 46| 4.75k| if (MP_IS_ODD(&A) || MP_IS_ODD(&B)) { ------------------ | | 165| 9.51k|#define MP_IS_ODD(a) (((a)->used > 0) && (((a)->dp[0] & 1u) == 1u)) | | ------------------ | | | Branch (165:24): [True: 4.75k, False: 0] | | | Branch (165:43): [True: 0, False: 4.75k] | | ------------------ ------------------ if (MP_IS_ODD(&A) || MP_IS_ODD(&B)) { ------------------ | | 165| 4.75k|#define MP_IS_ODD(a) (((a)->used > 0) && (((a)->dp[0] & 1u) == 1u)) | | ------------------ | | | Branch (165:24): [True: 4.75k, False: 0] | | | Branch (165:43): [True: 2.21k, False: 2.53k] | | ------------------ ------------------ 47| | /* A = (A+y)/2, B = (B-x)/2 */ 48| 2.21k| if ((err = mp_add(&A, &y, &A)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 2.21k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (48:14): [True: 0, False: 2.21k] ------------------ 49| 2.21k| if ((err = mp_sub(&B, &x, &B)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 2.21k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (49:14): [True: 0, False: 2.21k] ------------------ 50| 2.21k| } 51| | /* A = A/2, B = B/2 */ 52| 4.75k| if ((err = mp_div_2(&A, &A)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 4.75k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (52:11): [True: 0, False: 4.75k] ------------------ 53| 4.75k| if ((err = mp_div_2(&B, &B)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 4.75k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (53:11): [True: 0, False: 4.75k] ------------------ 54| 4.75k| } 55| | 56| | /* 5. while v is even do */ 57| 15.2k| while (MP_IS_EVEN(&v)) { ------------------ | | 164| 15.2k|#define MP_IS_EVEN(a) (((a)->used == 0) || (((a)->dp[0] & 1u) == 0u)) | | ------------------ | | | Branch (164:24): [True: 0, False: 15.2k] | | | Branch (164:44): [True: 8.77k, False: 6.50k] | | ------------------ ------------------ 58| | /* 5.1 v = v/2 */ 59| 8.77k| if ((err = mp_div_2(&v, &v)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 8.77k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (59:11): [True: 0, False: 8.77k] ------------------ 60| | 61| | /* 5.2 if C or D is odd then */ 62| 8.77k| if (MP_IS_ODD(&C) || MP_IS_ODD(&D)) { ------------------ | | 165| 17.5k|#define MP_IS_ODD(a) (((a)->used > 0) && (((a)->dp[0] & 1u) == 1u)) | | ------------------ | | | Branch (165:24): [True: 8.70k, False: 73] | | | Branch (165:43): [True: 0, False: 8.70k] | | ------------------ ------------------ if (MP_IS_ODD(&C) || MP_IS_ODD(&D)) { ------------------ | | 165| 8.77k|#define MP_IS_ODD(a) (((a)->used > 0) && (((a)->dp[0] & 1u) == 1u)) | | ------------------ | | | Branch (165:24): [True: 7.35k, False: 1.42k] | | | Branch (165:43): [True: 3.86k, False: 3.49k] | | ------------------ ------------------ 63| | /* C = (C+y)/2, D = (D-x)/2 */ 64| 3.86k| if ((err = mp_add(&C, &y, &C)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 3.86k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (64:14): [True: 0, False: 3.86k] ------------------ 65| 3.86k| if ((err = mp_sub(&D, &x, &D)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 3.86k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (65:14): [True: 0, False: 3.86k] ------------------ 66| 3.86k| } 67| | /* C = C/2, D = D/2 */ 68| 8.77k| if ((err = mp_div_2(&C, &C)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 8.77k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (68:11): [True: 0, False: 8.77k] ------------------ 69| 8.77k| if ((err = mp_div_2(&D, &D)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 8.77k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (69:11): [True: 0, False: 8.77k] ------------------ 70| 8.77k| } 71| | 72| | /* 6. if u >= v then */ 73| 6.50k| if (mp_cmp(&u, &v) != MP_LT) { ------------------ | | 154| 6.50k|#define MP_LT -1 /* less than */ ------------------ | Branch (73:8): [True: 2.79k, False: 3.71k] ------------------ 74| | /* u = u - v, A = A - C, B = B - D */ 75| 2.79k| if ((err = mp_sub(&u, &v, &u)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 2.79k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (75:11): [True: 0, False: 2.79k] ------------------ 76| | 77| 2.79k| if ((err = mp_sub(&A, &C, &A)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 2.79k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (77:11): [True: 0, False: 2.79k] ------------------ 78| | 79| 2.79k| if ((err = mp_sub(&B, &D, &B)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 2.79k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (79:11): [True: 0, False: 2.79k] ------------------ 80| 3.71k| } else { 81| | /* v - v - u, C = C - A, D = D - B */ 82| 3.71k| if ((err = mp_sub(&v, &u, &v)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 3.71k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (82:11): [True: 0, False: 3.71k] ------------------ 83| | 84| 3.71k| if ((err = mp_sub(&C, &A, &C)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 3.71k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (84:11): [True: 0, False: 3.71k] ------------------ 85| | 86| 3.71k| if ((err = mp_sub(&D, &B, &D)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 3.71k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (86:11): [True: 0, False: 3.71k] ------------------ 87| 3.71k| } 88| | 89| | /* if not zero goto step 4 */ 90| 6.50k| if (!MP_IS_ZERO(&u)) { ------------------ | | 163| 6.50k|#define MP_IS_ZERO(a) ((a)->used == 0) ------------------ | Branch (90:8): [True: 6.43k, False: 73] ------------------ 91| 6.43k| goto top; 92| 6.43k| } 93| | 94| | /* now a = C, b = D, gcd == g*v */ 95| | 96| | /* if v != 1 then there is no inverse */ 97| 73| if (mp_cmp_d(&v, 1uL) != MP_EQ) { ------------------ | | 155| 73|#define MP_EQ 0 /* equal to */ ------------------ | Branch (97:8): [True: 8, False: 65] ------------------ 98| 8| err = MP_VAL; ------------------ | | 164| 8|#define MP_VAL -3 /* invalid input */ ------------------ 99| 8| goto LBL_ERR; 100| 8| } 101| | 102| | /* if its too low */ 103| 115| while (mp_cmp_d(&C, 0uL) == MP_LT) { ------------------ | | 154| 115|#define MP_LT -1 /* less than */ ------------------ | Branch (103:11): [True: 50, False: 65] ------------------ 104| 50| if ((err = mp_add(&C, b, &C)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 50|#define MP_OKAY 0 /* no error */ ------------------ | Branch (104:11): [True: 0, False: 50] ------------------ 105| 50| } 106| | 107| | /* too big */ 108| 109| while (mp_cmp_mag(&C, b) != MP_LT) { ------------------ | | 154| 109|#define MP_LT -1 /* less than */ ------------------ | Branch (108:11): [True: 44, False: 65] ------------------ 109| 44| if ((err = mp_sub(&C, b, &C)) != MP_OKAY) goto LBL_ERR; ------------------ | | 161| 44|#define MP_OKAY 0 /* no error */ ------------------ | Branch (109:11): [True: 0, False: 44] ------------------ 110| 44| } 111| | 112| | /* C is now the inverse */ 113| 65| mp_exch(&C, c); 114| 65| err = MP_OKAY; ------------------ | | 161| 65|#define MP_OKAY 0 /* no error */ ------------------ 115| 74|LBL_ERR: 116| | mp_clear_multi(&x, &y, &u, &v, &A, &B, &C, &D, NULL); 117| 74| return err; 118| 65|} s_mp_montgomery_reduce_fast: 15| 1.65M|{ 16| 1.65M| int ix, olduse; 17| 1.65M| mp_err err; 18| 1.65M| mp_word W[MP_WARRAY]; 19| | 20| 1.65M| if (x->used > MP_WARRAY) { ------------------ | | 172| 1.65M|#define MP_WARRAY PRIVATE_MP_WARRAY | | ------------------ | | | | 203| 1.65M|#define PRIVATE_MP_WARRAY (int)(1uLL << (((CHAR_BIT * sizeof(private_mp_word)) - (2 * MP_DIGIT_BIT)) + 1)) | | | | ------------------ | | | | | | 82| 1.65M|# define MP_DIGIT_BIT 60 | | | | ------------------ | | ------------------ ------------------ | Branch (20:8): [True: 0, False: 1.65M] ------------------ 21| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 22| 0| } 23| | 24| | /* get old used count */ 25| 1.65M| olduse = x->used; 26| | 27| | /* grow a as required */ 28| 1.65M| if (x->alloc < (n->used + 1)) { ------------------ | Branch (28:8): [True: 0, False: 1.65M] ------------------ 29| 0| if ((err = mp_grow(x, n->used + 1)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (29:11): [True: 0, False: 0] ------------------ 30| 0| return err; 31| 0| } 32| 0| } 33| | 34| | /* first we have to get the digits of the input into 35| | * an array of double precision words W[...] 36| | */ 37| 1.65M| { 38| 1.65M| mp_word *_W; 39| 1.65M| mp_digit *tmpx; 40| | 41| | /* alias for the W[] array */ 42| 1.65M| _W = W; 43| | 44| | /* alias for the digits of x*/ 45| 1.65M| tmpx = x->dp; 46| | 47| | /* copy the digits of a into W[0..a->used-1] */ 48| 21.1M| for (ix = 0; ix < x->used; ix++) { ------------------ | Branch (48:20): [True: 19.5M, False: 1.65M] ------------------ 49| 19.5M| *_W++ = *tmpx++; 50| 19.5M| } 51| | 52| | /* zero the high words of W[a->used..m->used*2] */ 53| 1.65M| if (ix < ((n->used * 2) + 1)) { ------------------ | Branch (53:11): [True: 1.65M, False: 0] ------------------ 54| 1.65M| MP_ZERO_BUFFER(_W, sizeof(mp_word) * (size_t)(((n->used * 2) + 1) - ix)); ------------------ | | 81| 1.65M|# define MP_ZERO_BUFFER(mem, size) \ | | 82| 1.65M|do { \ | | 83| 1.65M| size_t zs_ = (size); \ | | 84| 1.65M| char* zm_ = (char*)(mem); \ | | 85| 53.6M| while (zs_-- > 0u) { \ | | ------------------ | | | Branch (85:11): [True: 51.9M, False: 1.65M] | | ------------------ | | 86| 51.9M| *zm_++ = '\0'; \ | | 87| 51.9M| } \ | | 88| 1.65M|} while (0) | | ------------------ | | | Branch (88:10): [Folded, False: 1.65M] | | ------------------ ------------------ 55| 1.65M| } 56| 1.65M| } 57| | 58| | /* now we proceed to zero successive digits 59| | * from the least significant upwards 60| | */ 61| 12.2M| for (ix = 0; ix < n->used; ix++) { ------------------ | Branch (61:17): [True: 10.5M, False: 1.65M] ------------------ 62| | /* mu = ai * m' mod b 63| | * 64| | * We avoid a double precision multiplication (which isn't required) 65| | * by casting the value down to a mp_digit. Note this requires 66| | * that W[ix-1] have the carry cleared (see after the inner loop) 67| | */ 68| 10.5M| mp_digit mu; 69| 10.5M| mu = ((W[ix] & MP_MASK) * rho) & MP_MASK; ------------------ | | 106| 10.5M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 10.5M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ mu = ((W[ix] & MP_MASK) * rho) & MP_MASK; ------------------ | | 106| 10.5M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 10.5M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 70| | 71| | /* a = a + mu * m * b**i 72| | * 73| | * This is computed in place and on the fly. The multiplication 74| | * by b**i is handled by offseting which columns the results 75| | * are added to. 76| | * 77| | * Note the comba method normally doesn't handle carries in the 78| | * inner loop In this case we fix the carry from the previous 79| | * column since the Montgomery reduction requires digits of the 80| | * result (so far) [see above] to work. This is 81| | * handled by fixing up one carry after the inner loop. The 82| | * carry fixups are done in order so after these loops the 83| | * first m->used words of W[] have the carries fixed 84| | */ 85| 10.5M| { 86| 10.5M| int iy; 87| 10.5M| mp_digit *tmpn; 88| 10.5M| mp_word *_W; 89| | 90| | /* alias for the digits of the modulus */ 91| 10.5M| tmpn = n->dp; 92| | 93| | /* Alias for the columns set by an offset of ix */ 94| 10.5M| _W = W + ix; 95| | 96| | /* inner loop */ 97| 100M| for (iy = 0; iy < n->used; iy++) { ------------------ | Branch (97:23): [True: 89.6M, False: 10.5M] ------------------ 98| 89.6M| *_W++ += (mp_word)mu * (mp_word)*tmpn++; 99| 89.6M| } 100| 10.5M| } 101| | 102| | /* now fix carry for next digit, W[ix+1] */ 103| 10.5M| W[ix + 1] += W[ix] >> (mp_word)MP_DIGIT_BIT; ------------------ | | 82| 10.5M|# define MP_DIGIT_BIT 60 ------------------ 104| 10.5M| } 105| | 106| | /* now we have to propagate the carries and 107| | * shift the words downward [all those least 108| | * significant digits we zeroed]. 109| | */ 110| 1.65M| { 111| 1.65M| mp_digit *tmpx; 112| 1.65M| mp_word *_W, *_W1; 113| | 114| | /* nox fix rest of carries */ 115| | 116| | /* alias for current word */ 117| 1.65M| _W1 = W + ix; 118| | 119| | /* alias for next word, where the carry goes */ 120| 1.65M| _W = W + ++ix; 121| | 122| 12.2M| for (; ix < ((n->used * 2) + 1); ix++) { ------------------ | Branch (122:14): [True: 10.5M, False: 1.65M] ------------------ 123| 10.5M| *_W++ += *_W1++ >> (mp_word)MP_DIGIT_BIT; ------------------ | | 82| 10.5M|# define MP_DIGIT_BIT 60 ------------------ 124| 10.5M| } 125| | 126| | /* copy out, A = A/b**n 127| | * 128| | * The result is A/b**n but instead of converting from an 129| | * array of mp_word to mp_digit than calling mp_rshd 130| | * we just copy them in the right order 131| | */ 132| | 133| | /* alias for destination word */ 134| 1.65M| tmpx = x->dp; 135| | 136| | /* alias for shifted double precision result */ 137| 1.65M| _W = W + n->used; 138| | 139| 13.8M| for (ix = 0; ix < (n->used + 1); ix++) { ------------------ | Branch (139:20): [True: 12.2M, False: 1.65M] ------------------ 140| 12.2M| *tmpx++ = *_W++ & (mp_word)MP_MASK; ------------------ | | 106| 12.2M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 12.2M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 141| 12.2M| } 142| | 143| | /* zero oldused digits, if the input a was larger than 144| | * m->used+1 we'll have to clear the digits 145| | */ 146| 1.65M| MP_ZERO_DIGITS(tmpx, olduse - ix); ------------------ | | 89| 1.65M|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 1.65M|do { \ | | 91| 1.65M| int zd_ = (digits); \ | | 92| 1.65M| mp_digit* zm_ = (mem); \ | | 93| 9.24M| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 7.58M, False: 1.65M] | | ------------------ | | 94| 7.58M| *zm_++ = 0; \ | | 95| 7.58M| } \ | | 96| 1.65M|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 1.65M] | | ------------------ ------------------ 147| 1.65M| } 148| | 149| | /* set the max used and clamp */ 150| 1.65M| x->used = n->used + 1; 151| 1.65M| mp_clamp(x); 152| | 153| | /* if A >= m then A = A - m */ 154| 1.65M| if (mp_cmp_mag(x, n) != MP_LT) { ------------------ | | 154| 1.65M|#define MP_LT -1 /* less than */ ------------------ | Branch (154:8): [True: 1.33k, False: 1.65M] ------------------ 155| 1.33k| return s_mp_sub(x, n, x); 156| 1.33k| } 157| 1.65M| return MP_OKAY; ------------------ | | 161| 1.65M|#define MP_OKAY 0 /* no error */ ------------------ 158| 1.65M|} s_mp_mul_digs: 11| 38.7k|{ 12| 38.7k| mp_int t; 13| 38.7k| mp_err err; 14| 38.7k| int pa, pb, ix, iy; 15| 38.7k| mp_digit u; 16| 38.7k| mp_word r; 17| 38.7k| mp_digit tmpx, *tmpt, *tmpy; 18| | 19| 38.7k| if (digs < 0) { ------------------ | Branch (19:8): [True: 0, False: 38.7k] ------------------ 20| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 21| 0| } 22| | 23| | /* can we use the fast multiplier? */ 24| 38.7k| if ((digs < MP_WARRAY) && ------------------ | | 172| 38.7k|#define MP_WARRAY PRIVATE_MP_WARRAY | | ------------------ | | | | 203| 38.7k|#define PRIVATE_MP_WARRAY (int)(1uLL << (((CHAR_BIT * sizeof(private_mp_word)) - (2 * MP_DIGIT_BIT)) + 1)) | | | | ------------------ | | | | | | 82| 38.7k|# define MP_DIGIT_BIT 60 | | | | ------------------ | | ------------------ ------------------ | Branch (24:8): [True: 38.7k, False: 0] ------------------ 25| 38.7k| (MP_MIN(a->used, b->used) < MP_MAXFAST)) { ------------------ | | 156| 38.7k|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 32.9k, False: 5.83k] | | ------------------ ------------------ (MP_MIN(a->used, b->used) < MP_MAXFAST)) { ------------------ | | 168| 38.7k|#define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT))) | | ------------------ | | | | 167| 38.7k|#define MP_SIZEOF_BITS(type) ((size_t)CHAR_BIT * sizeof(type)) | | ------------------ | | #define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT))) | | ------------------ | | | | 82| 38.7k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ | Branch (25:8): [True: 38.7k, False: 0] ------------------ 26| 38.7k| return s_mp_mul_digs_fast(a, b, c, digs); 27| 38.7k| } 28| | 29| 0| if ((err = mp_init_size(&t, digs)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (29:8): [True: 0, False: 0] ------------------ 30| 0| return err; 31| 0| } 32| 0| t.used = digs; 33| | 34| | /* compute the digits of the product directly */ 35| 0| pa = a->used; 36| 0| for (ix = 0; ix < pa; ix++) { ------------------ | Branch (36:17): [True: 0, False: 0] ------------------ 37| | /* set the carry to zero */ 38| 0| u = 0; 39| | 40| | /* limit ourselves to making digs digits of output */ 41| 0| pb = MP_MIN(b->used, digs - ix); ------------------ | | 156| 0|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 0, False: 0] | | ------------------ ------------------ 42| | 43| | /* setup some aliases */ 44| | /* copy of the digit from a used within the nested loop */ 45| 0| tmpx = a->dp[ix]; 46| | 47| | /* an alias for the destination shifted ix places */ 48| 0| tmpt = t.dp + ix; 49| | 50| | /* an alias for the digits of b */ 51| 0| tmpy = b->dp; 52| | 53| | /* compute the columns of the output and propagate the carry */ 54| 0| for (iy = 0; iy < pb; iy++) { ------------------ | Branch (54:20): [True: 0, False: 0] ------------------ 55| | /* compute the column as a mp_word */ 56| 0| r = (mp_word)*tmpt + 57| 0| ((mp_word)tmpx * (mp_word)*tmpy++) + 58| 0| (mp_word)u; 59| | 60| | /* the new column is the lower part of the result */ 61| 0| *tmpt++ = (mp_digit)(r & (mp_word)MP_MASK); ------------------ | | 106| 0|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 0|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 62| | 63| | /* get the carry word from the result */ 64| 0| u = (mp_digit)(r >> (mp_word)MP_DIGIT_BIT); ------------------ | | 82| 0|# define MP_DIGIT_BIT 60 ------------------ 65| 0| } 66| | /* set carry if it is placed below digs */ 67| 0| if ((ix + iy) < digs) { ------------------ | Branch (67:11): [True: 0, False: 0] ------------------ 68| 0| *tmpt = u; 69| 0| } 70| 0| } 71| | 72| 0| mp_clamp(&t); 73| 0| mp_exch(&t, c); 74| | 75| 0| mp_clear(&t); 76| 0| return MP_OKAY; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ 77| 0|} s_mp_mul_digs_fast: 23| 3.13M|{ 24| 3.13M| int olduse, pa, ix, iz; 25| 3.13M| mp_err err; 26| 3.13M| mp_digit W[MP_WARRAY]; 27| 3.13M| mp_word _W; 28| | 29| 3.13M| if (digs < 0) { ------------------ | Branch (29:8): [True: 0, False: 3.13M] ------------------ 30| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 31| 0| } 32| | 33| | /* grow the destination as required */ 34| 3.13M| if (c->alloc < digs) { ------------------ | Branch (34:8): [True: 8.94k, False: 3.12M] ------------------ 35| 8.94k| if ((err = mp_grow(c, digs)) != MP_OKAY) { ------------------ | | 161| 8.94k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (35:11): [True: 0, False: 8.94k] ------------------ 36| 0| return err; 37| 0| } 38| 8.94k| } 39| | 40| | /* number of output digits to produce */ 41| 3.13M| pa = MP_MIN(digs, a->used + b->used); ------------------ | | 156| 3.13M|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 15.1k, False: 3.11M] | | ------------------ ------------------ 42| | 43| | /* clear the carry */ 44| 3.13M| _W = 0; 45| 101M| for (ix = 0; ix < pa; ix++) { ------------------ | Branch (45:17): [True: 98.4M, False: 3.13M] ------------------ 46| 98.4M| int tx, ty; 47| 98.4M| int iy; 48| 98.4M| mp_digit *tmpx, *tmpy; 49| | 50| | /* get offsets into the two bignums */ 51| 98.4M| ty = MP_MIN(b->used-1, ix); ------------------ | | 156| 98.4M|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 34.3M, False: 64.0M] | | ------------------ ------------------ 52| 98.4M| tx = ix - ty; 53| | 54| | /* setup temp aliases */ 55| 98.4M| tmpx = a->dp + tx; 56| 98.4M| tmpy = b->dp + ty; 57| | 58| | /* this is the number of times the loop will iterrate, essentially 59| | while (tx++ < a->used && ty-- >= 0) { ... } 60| | */ 61| 98.4M| iy = MP_MIN(a->used-tx, ty+1); ------------------ | | 156| 98.4M|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 63.8M, False: 34.5M] | | ------------------ ------------------ 62| | 63| | /* execute loop */ 64| 2.11G| for (iz = 0; iz < iy; ++iz) { ------------------ | Branch (64:20): [True: 2.01G, False: 98.4M] ------------------ 65| 2.01G| _W += (mp_word)*tmpx++ * (mp_word)*tmpy--; 66| | 67| 2.01G| } 68| | 69| | /* store term */ 70| 98.4M| W[ix] = (mp_digit)_W & MP_MASK; ------------------ | | 106| 98.4M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 98.4M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 71| | 72| | /* make next carry */ 73| 98.4M| _W = _W >> (mp_word)MP_DIGIT_BIT; ------------------ | | 82| 98.4M|# define MP_DIGIT_BIT 60 ------------------ 74| 98.4M| } 75| | 76| | /* setup dest */ 77| 3.13M| olduse = c->used; 78| 3.13M| c->used = pa; 79| | 80| 3.13M| { 81| 3.13M| mp_digit *tmpc; 82| 3.13M| tmpc = c->dp; 83| 101M| for (ix = 0; ix < pa; ix++) { ------------------ | Branch (83:20): [True: 98.4M, False: 3.13M] ------------------ 84| | /* now extract the previous digit [below the carry] */ 85| 98.4M| *tmpc++ = W[ix]; 86| 98.4M| } 87| | 88| | /* clear unused digits [that existed in the old copy of c] */ 89| 3.13M| MP_ZERO_DIGITS(tmpc, olduse - ix); ------------------ | | 89| 3.13M|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 3.13M|do { \ | | 91| 3.13M| int zd_ = (digits); \ | | 92| 3.13M| mp_digit* zm_ = (mem); \ | | 93| 3.13M| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 0, False: 3.13M] | | ------------------ | | 94| 0| *zm_++ = 0; \ | | 95| 0| } \ | | 96| 3.13M|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 3.13M] | | ------------------ ------------------ 90| 3.13M| } 91| 3.13M| mp_clamp(c); 92| 3.13M| return MP_OKAY; ------------------ | | 161| 3.13M|#define MP_OKAY 0 /* no error */ ------------------ 93| 3.13M|} s_mp_mul_high_digs: 10| 38.7k|{ 11| 38.7k| mp_int t; 12| 38.7k| int pa, pb, ix, iy; 13| 38.7k| mp_err err; 14| 38.7k| mp_digit u; 15| 38.7k| mp_word r; 16| 38.7k| mp_digit tmpx, *tmpt, *tmpy; 17| | 18| 38.7k| if (digs < 0) { ------------------ | Branch (18:8): [True: 0, False: 38.7k] ------------------ 19| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 20| 0| } 21| | 22| | /* can we use the fast multiplier? */ 23| 38.7k| if (MP_HAS(S_MP_MUL_HIGH_DIGS_FAST) ------------------ | | 150| 77.4k|#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u) | | ------------------ | | | | 148| 38.7k|#define MP_STRINGIZE(x) MP__STRINGIZE(x) | | | | ------------------ | | | | | | 149| 38.7k|#define MP__STRINGIZE(x) ""#x"" | | | | ------------------ | | ------------------ | | | Branch (150:26): [True: 38.7k, Folded] | | ------------------ ------------------ 24| 38.7k| && ((a->used + b->used + 1) < MP_WARRAY) ------------------ | | 172| 38.7k|#define MP_WARRAY PRIVATE_MP_WARRAY | | ------------------ | | | | 203| 38.7k|#define PRIVATE_MP_WARRAY (int)(1uLL << (((CHAR_BIT * sizeof(private_mp_word)) - (2 * MP_DIGIT_BIT)) + 1)) | | | | ------------------ | | | | | | 82| 38.7k|# define MP_DIGIT_BIT 60 | | | | ------------------ | | ------------------ ------------------ | Branch (24:11): [True: 38.7k, False: 0] ------------------ 25| 38.7k| && (MP_MIN(a->used, b->used) < MP_MAXFAST)) { ------------------ | | 156| 38.7k|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 38.3k, False: 432] | | ------------------ ------------------ && (MP_MIN(a->used, b->used) < MP_MAXFAST)) { ------------------ | | 168| 38.7k|#define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT))) | | ------------------ | | | | 167| 38.7k|#define MP_SIZEOF_BITS(type) ((size_t)CHAR_BIT * sizeof(type)) | | ------------------ | | #define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT))) | | ------------------ | | | | 82| 38.7k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ | Branch (25:11): [True: 38.7k, False: 0] ------------------ 26| 38.7k| return s_mp_mul_high_digs_fast(a, b, c, digs); 27| 38.7k| } 28| | 29| 0| if ((err = mp_init_size(&t, a->used + b->used + 1)) != MP_OKAY) { ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ | Branch (29:8): [True: 0, False: 0] ------------------ 30| 0| return err; 31| 0| } 32| 0| t.used = a->used + b->used + 1; 33| | 34| 0| pa = a->used; 35| 0| pb = b->used; 36| 0| for (ix = 0; ix < pa; ix++) { ------------------ | Branch (36:17): [True: 0, False: 0] ------------------ 37| | /* clear the carry */ 38| 0| u = 0; 39| | 40| | /* left hand side of A[ix] * B[iy] */ 41| 0| tmpx = a->dp[ix]; 42| | 43| | /* alias to the address of where the digits will be stored */ 44| 0| tmpt = &(t.dp[digs]); 45| | 46| | /* alias for where to read the right hand side from */ 47| 0| tmpy = b->dp + (digs - ix); 48| | 49| 0| for (iy = digs - ix; iy < pb; iy++) { ------------------ | Branch (49:28): [True: 0, False: 0] ------------------ 50| | /* calculate the double precision result */ 51| 0| r = (mp_word)*tmpt + 52| 0| ((mp_word)tmpx * (mp_word)*tmpy++) + 53| 0| (mp_word)u; 54| | 55| | /* get the lower part */ 56| 0| *tmpt++ = (mp_digit)(r & (mp_word)MP_MASK); ------------------ | | 106| 0|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 0|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 57| | 58| | /* carry the carry */ 59| 0| u = (mp_digit)(r >> (mp_word)MP_DIGIT_BIT); ------------------ | | 82| 0|# define MP_DIGIT_BIT 60 ------------------ 60| 0| } 61| 0| *tmpt = u; 62| 0| } 63| 0| mp_clamp(&t); 64| 0| mp_exch(&t, c); 65| 0| mp_clear(&t); 66| 0| return MP_OKAY; ------------------ | | 161| 0|#define MP_OKAY 0 /* no error */ ------------------ 67| 0|} s_mp_mul_high_digs_fast: 16| 38.7k|{ 17| 38.7k| int olduse, pa, ix, iz; 18| 38.7k| mp_err err; 19| 38.7k| mp_digit W[MP_WARRAY]; 20| 38.7k| mp_word _W; 21| | 22| 38.7k| if (digs < 0) { ------------------ | Branch (22:8): [True: 0, False: 38.7k] ------------------ 23| 0| return MP_VAL; ------------------ | | 164| 0|#define MP_VAL -3 /* invalid input */ ------------------ 24| 0| } 25| | 26| | /* grow the destination as required */ 27| 38.7k| pa = a->used + b->used; 28| 38.7k| if (c->alloc < pa) { ------------------ | Branch (28:8): [True: 38.7k, False: 0] ------------------ 29| 38.7k| if ((err = mp_grow(c, pa)) != MP_OKAY) { ------------------ | | 161| 38.7k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (29:11): [True: 0, False: 38.7k] ------------------ 30| 0| return err; 31| 0| } 32| 38.7k| } 33| | 34| | /* number of output digits to produce */ 35| 38.7k| pa = a->used + b->used; 36| 38.7k| _W = 0; 37| 301k| for (ix = digs; ix < pa; ix++) { ------------------ | Branch (37:20): [True: 262k, False: 38.7k] ------------------ 38| 262k| int tx, ty, iy; 39| 262k| mp_digit *tmpx, *tmpy; 40| | 41| | /* get offsets into the two bignums */ 42| 262k| ty = MP_MIN(b->used-1, ix); ------------------ | | 156| 262k|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 223k, False: 38.8k] | | ------------------ ------------------ 43| 262k| tx = ix - ty; 44| | 45| | /* setup temp aliases */ 46| 262k| tmpx = a->dp + tx; 47| 262k| tmpy = b->dp + ty; 48| | 49| | /* this is the number of times the loop will iterrate, essentially its 50| | while (tx++ < a->used && ty-- >= 0) { ... } 51| | */ 52| 262k| iy = MP_MIN(a->used-tx, ty+1); ------------------ | | 156| 262k|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 261k, False: 432] | | ------------------ ------------------ 53| | 54| | /* execute loop */ 55| 3.05M| for (iz = 0; iz < iy; iz++) { ------------------ | Branch (55:20): [True: 2.78M, False: 262k] ------------------ 56| 2.78M| _W += (mp_word)*tmpx++ * (mp_word)*tmpy--; 57| 2.78M| } 58| | 59| | /* store term */ 60| 262k| W[ix] = (mp_digit)_W & MP_MASK; ------------------ | | 106| 262k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 262k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 61| | 62| | /* make next carry */ 63| 262k| _W = _W >> (mp_word)MP_DIGIT_BIT; ------------------ | | 82| 262k|# define MP_DIGIT_BIT 60 ------------------ 64| 262k| } 65| | 66| | /* setup dest */ 67| 38.7k| olduse = c->used; 68| 38.7k| c->used = pa; 69| | 70| 38.7k| { 71| 38.7k| mp_digit *tmpc; 72| | 73| 38.7k| tmpc = c->dp + digs; 74| 301k| for (ix = digs; ix < pa; ix++) { ------------------ | Branch (74:23): [True: 262k, False: 38.7k] ------------------ 75| | /* now extract the previous digit [below the carry] */ 76| 262k| *tmpc++ = W[ix]; 77| 262k| } 78| | 79| | /* clear unused digits [that existed in the old copy of c] */ 80| 38.7k| MP_ZERO_DIGITS(tmpc, olduse - ix); ------------------ | | 89| 38.7k|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 38.7k|do { \ | | 91| 38.7k| int zd_ = (digits); \ | | 92| 38.7k| mp_digit* zm_ = (mem); \ | | 93| 38.7k| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 0, False: 38.7k] | | ------------------ | | 94| 0| *zm_++ = 0; \ | | 95| 0| } \ | | 96| 38.7k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 38.7k] | | ------------------ ------------------ 81| 38.7k| } 82| 38.7k| mp_clamp(c); 83| 38.7k| return MP_OKAY; ------------------ | | 161| 38.7k|#define MP_OKAY 0 /* no error */ ------------------ 84| 38.7k|} s_mp_prime_is_divisible: 12| 151|{ 13| 151| int ix; 14| 151| mp_err err; 15| 151| mp_digit res; 16| | 17| | /* default to not */ 18| 151| *result = MP_NO; ------------------ | | 159| 151|#define MP_NO 0 ------------------ 19| | 20| 26.1k| for (ix = 0; ix < PRIVATE_MP_PRIME_TAB_SIZE; ix++) { ------------------ | | 633| 26.1k|# define PRIVATE_MP_PRIME_TAB_SIZE 256 ------------------ | Branch (20:17): [True: 26.0k, False: 94] ------------------ 21| | /* what is a mod LBL_prime_tab[ix] */ 22| 26.0k| if ((err = mp_mod_d(a, s_mp_prime_tab[ix], &res)) != MP_OKAY) { ------------------ | | 161| 26.0k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (22:11): [True: 0, False: 26.0k] ------------------ 23| 0| return err; 24| 0| } 25| | 26| | /* is the residue zero? */ 27| 26.0k| if (res == 0u) { ------------------ | Branch (27:11): [True: 57, False: 26.0k] ------------------ 28| 57| *result = MP_YES; ------------------ | | 158| 57|#define MP_YES 1 ------------------ 29| 57| return MP_OKAY; ------------------ | | 161| 57|#define MP_OKAY 0 /* no error */ ------------------ 30| 57| } 31| 26.0k| } 32| | 33| 94| return MP_OKAY; ------------------ | | 161| 94|#define MP_OKAY 0 /* no error */ ------------------ 34| 151|} s_mp_sqr: 8| 286|{ 9| 286| mp_int t; 10| 286| int ix, iy, pa; 11| 286| mp_err err; 12| 286| mp_word r; 13| 286| mp_digit u, tmpx, *tmpt; 14| | 15| 286| pa = a->used; 16| 286| if ((err = mp_init_size(&t, (2 * pa) + 1)) != MP_OKAY) { ------------------ | | 161| 286|#define MP_OKAY 0 /* no error */ ------------------ | Branch (16:8): [True: 0, False: 286] ------------------ 17| 0| return err; 18| 0| } 19| | 20| | /* default used is maximum possible size */ 21| 286| t.used = (2 * pa) + 1; 22| | 23| 38.1k| for (ix = 0; ix < pa; ix++) { ------------------ | Branch (23:17): [True: 37.9k, False: 286] ------------------ 24| | /* first calculate the digit at 2*ix */ 25| | /* calculate double precision result */ 26| 37.9k| r = (mp_word)t.dp[2*ix] + 27| 37.9k| ((mp_word)a->dp[ix] * (mp_word)a->dp[ix]); 28| | 29| | /* store lower part in result */ 30| 37.9k| t.dp[ix+ix] = (mp_digit)(r & (mp_word)MP_MASK); ------------------ | | 106| 37.9k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 37.9k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 31| | 32| | /* get the carry */ 33| 37.9k| u = (mp_digit)(r >> (mp_word)MP_DIGIT_BIT); ------------------ | | 82| 37.9k|# define MP_DIGIT_BIT 60 ------------------ 34| | 35| | /* left hand side of A[ix] * A[iy] */ 36| 37.9k| tmpx = a->dp[ix]; 37| | 38| | /* alias for where to store the results */ 39| 37.9k| tmpt = t.dp + ((2 * ix) + 1); 40| | 41| 2.53M| for (iy = ix + 1; iy < pa; iy++) { ------------------ | Branch (41:25): [True: 2.49M, False: 37.9k] ------------------ 42| | /* first calculate the product */ 43| 2.49M| r = (mp_word)tmpx * (mp_word)a->dp[iy]; 44| | 45| | /* now calculate the double precision result, note we use 46| | * addition instead of *2 since it's easier to optimize 47| | */ 48| 2.49M| r = (mp_word)*tmpt + r + r + (mp_word)u; 49| | 50| | /* store lower part */ 51| 2.49M| *tmpt++ = (mp_digit)(r & (mp_word)MP_MASK); ------------------ | | 106| 2.49M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 2.49M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 52| | 53| | /* get carry */ 54| 2.49M| u = (mp_digit)(r >> (mp_word)MP_DIGIT_BIT); ------------------ | | 82| 2.49M|# define MP_DIGIT_BIT 60 ------------------ 55| 2.49M| } 56| | /* propagate upwards */ 57| 70.7k| while (u != 0uL) { ------------------ | Branch (57:14): [True: 32.8k, False: 37.9k] ------------------ 58| 32.8k| r = (mp_word)*tmpt + (mp_word)u; 59| 32.8k| *tmpt++ = (mp_digit)(r & (mp_word)MP_MASK); ------------------ | | 106| 32.8k|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 32.8k|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 60| 32.8k| u = (mp_digit)(r >> (mp_word)MP_DIGIT_BIT); ------------------ | | 82| 32.8k|# define MP_DIGIT_BIT 60 ------------------ 61| 32.8k| } 62| 37.9k| } 63| | 64| 286| mp_clamp(&t); 65| 286| mp_exch(&t, b); 66| 286| mp_clear(&t); 67| 286| return MP_OKAY; ------------------ | | 161| 286|#define MP_OKAY 0 /* no error */ ------------------ 68| 286|} s_mp_sqr_fast: 17| 909k|{ 18| 909k| int olduse, pa, ix, iz; 19| 909k| mp_digit W[MP_WARRAY], *tmpx; 20| 909k| mp_word W1; 21| 909k| mp_err err; 22| | 23| | /* grow the destination as required */ 24| 909k| pa = a->used + a->used; 25| 909k| if (b->alloc < pa) { ------------------ | Branch (25:8): [True: 1.00k, False: 908k] ------------------ 26| 1.00k| if ((err = mp_grow(b, pa)) != MP_OKAY) { ------------------ | | 161| 1.00k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (26:11): [True: 0, False: 1.00k] ------------------ 27| 0| return err; 28| 0| } 29| 1.00k| } 30| | 31| | /* number of output digits to produce */ 32| 909k| W1 = 0; 33| 10.9M| for (ix = 0; ix < pa; ix++) { ------------------ | Branch (33:17): [True: 10.0M, False: 909k] ------------------ 34| 10.0M| int tx, ty, iy; 35| 10.0M| mp_word _W; 36| 10.0M| mp_digit *tmpy; 37| | 38| | /* clear counter */ 39| 10.0M| _W = 0; 40| | 41| | /* get offsets into the two bignums */ 42| 10.0M| ty = MP_MIN(a->used-1, ix); ------------------ | | 156| 10.0M|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 5.04M, False: 5.04M] | | ------------------ ------------------ 43| 10.0M| tx = ix - ty; 44| | 45| | /* setup temp aliases */ 46| 10.0M| tmpx = a->dp + tx; 47| 10.0M| tmpy = a->dp + ty; 48| | 49| | /* this is the number of times the loop will iterrate, essentially 50| | while (tx++ < a->used && ty-- >= 0) { ... } 51| | */ 52| 10.0M| iy = MP_MIN(a->used-tx, ty+1); ------------------ | | 156| 10.0M|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 5.04M, False: 5.04M] | | ------------------ ------------------ 53| | 54| | /* now for squaring tx can never equal ty 55| | * we halve the distance since they approach at a rate of 2x 56| | * and we have to round because odd cases need to be executed 57| | */ 58| 10.0M| iy = MP_MIN(iy, ((ty-tx)+1)>>1); ------------------ | | 156| 10.0M|#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (156:23): [True: 0, False: 10.0M] | | ------------------ ------------------ 59| | 60| | /* execute loop */ 61| 27.8M| for (iz = 0; iz < iy; iz++) { ------------------ | Branch (61:20): [True: 17.7M, False: 10.0M] ------------------ 62| 17.7M| _W += (mp_word)*tmpx++ * (mp_word)*tmpy--; 63| 17.7M| } 64| | 65| | /* double the inner product and add carry */ 66| 10.0M| _W = _W + _W + W1; 67| | 68| | /* even columns have the square term in them */ 69| 10.0M| if (((unsigned)ix & 1u) == 0u) { ------------------ | Branch (69:11): [True: 5.04M, False: 5.04M] ------------------ 70| 5.04M| _W += (mp_word)a->dp[ix>>1] * (mp_word)a->dp[ix>>1]; 71| 5.04M| } 72| | 73| | /* store it */ 74| 10.0M| W[ix] = (mp_digit)_W & MP_MASK; ------------------ | | 106| 10.0M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 10.0M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 75| | 76| | /* make next carry */ 77| 10.0M| W1 = _W >> (mp_word)MP_DIGIT_BIT; ------------------ | | 82| 10.0M|# define MP_DIGIT_BIT 60 ------------------ 78| 10.0M| } 79| | 80| | /* setup dest */ 81| 909k| olduse = b->used; 82| 909k| b->used = a->used+a->used; 83| | 84| 909k| { 85| 909k| mp_digit *tmpb; 86| 909k| tmpb = b->dp; 87| 10.9M| for (ix = 0; ix < pa; ix++) { ------------------ | Branch (87:20): [True: 10.0M, False: 909k] ------------------ 88| 10.0M| *tmpb++ = W[ix] & MP_MASK; ------------------ | | 106| 10.0M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 10.0M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 89| 10.0M| } 90| | 91| | /* clear unused digits [that existed in the old copy of c] */ 92| 909k| MP_ZERO_DIGITS(tmpb, olduse - ix); ------------------ | | 89| 909k|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 909k|do { \ | | 91| 909k| int zd_ = (digits); \ | | 92| 909k| mp_digit* zm_ = (mem); \ | | 93| 926k| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 17.0k, False: 909k] | | ------------------ | | 94| 17.0k| *zm_++ = 0; \ | | 95| 17.0k| } \ | | 96| 909k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 909k] | | ------------------ ------------------ 93| 909k| } 94| 909k| mp_clamp(b); 95| 909k| return MP_OKAY; ------------------ | | 161| 909k|#define MP_OKAY 0 /* no error */ ------------------ 96| 909k|} s_mp_sub: 8| 4.16M|{ 9| 4.16M| int olduse, min, max; 10| 4.16M| mp_err err; 11| | 12| | /* find sizes */ 13| 4.16M| min = b->used; 14| 4.16M| max = a->used; 15| | 16| | /* init result */ 17| 4.16M| if (c->alloc < max) { ------------------ | Branch (17:8): [True: 39, False: 4.16M] ------------------ 18| 39| if ((err = mp_grow(c, max)) != MP_OKAY) { ------------------ | | 161| 39|#define MP_OKAY 0 /* no error */ ------------------ | Branch (18:11): [True: 0, False: 39] ------------------ 19| 0| return err; 20| 0| } 21| 39| } 22| 4.16M| olduse = c->used; 23| 4.16M| c->used = max; 24| | 25| 4.16M| { 26| 4.16M| mp_digit u, *tmpa, *tmpb, *tmpc; 27| 4.16M| int i; 28| | 29| | /* alias for digit pointers */ 30| 4.16M| tmpa = a->dp; 31| 4.16M| tmpb = b->dp; 32| 4.16M| tmpc = c->dp; 33| | 34| | /* set carry to zero */ 35| 4.16M| u = 0; 36| 75.6M| for (i = 0; i < min; i++) { ------------------ | Branch (36:19): [True: 71.5M, False: 4.16M] ------------------ 37| | /* T[i] = A[i] - B[i] - U */ 38| 71.5M| *tmpc = (*tmpa++ - *tmpb++) - u; 39| | 40| | /* U = carry bit of T[i] 41| | * Note this saves performing an AND operation since 42| | * if a carry does occur it will propagate all the way to the 43| | * MSB. As a result a single shift is enough to get the carry 44| | */ 45| 71.5M| u = *tmpc >> (MP_SIZEOF_BITS(mp_digit) - 1u); ------------------ | | 167| 71.5M|#define MP_SIZEOF_BITS(type) ((size_t)CHAR_BIT * sizeof(type)) ------------------ 46| | 47| | /* Clear carry from T[i] */ 48| 71.5M| *tmpc++ &= MP_MASK; ------------------ | | 106| 71.5M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 71.5M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 49| 71.5M| } 50| | 51| | /* now copy higher words if any, e.g. if A has more digits than B */ 52| 31.3M| for (; i < max; i++) { ------------------ | Branch (52:14): [True: 27.1M, False: 4.16M] ------------------ 53| | /* T[i] = A[i] - U */ 54| 27.1M| *tmpc = *tmpa++ - u; 55| | 56| | /* U = carry bit of T[i] */ 57| 27.1M| u = *tmpc >> (MP_SIZEOF_BITS(mp_digit) - 1u); ------------------ | | 167| 27.1M|#define MP_SIZEOF_BITS(type) ((size_t)CHAR_BIT * sizeof(type)) ------------------ 58| | 59| | /* Clear carry from T[i] */ 60| 27.1M| *tmpc++ &= MP_MASK; ------------------ | | 106| 27.1M|#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1)) | | ------------------ | | | | 82| 27.1M|# define MP_DIGIT_BIT 60 | | ------------------ ------------------ 61| 27.1M| } 62| | 63| | /* clear digits above used (since we may not have grown result above) */ 64| 4.16M| MP_ZERO_DIGITS(tmpc, olduse - c->used); ------------------ | | 89| 4.16M|# define MP_ZERO_DIGITS(mem, digits) \ | | 90| 4.16M|do { \ | | 91| 4.16M| int zd_ = (digits); \ | | 92| 4.16M| mp_digit* zm_ = (mem); \ | | 93| 4.16M| while (zd_-- > 0) { \ | | ------------------ | | | Branch (93:11): [True: 975, False: 4.16M] | | ------------------ | | 94| 975| *zm_++ = 0; \ | | 95| 975| } \ | | 96| 4.16M|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 4.16M] | | ------------------ ------------------ 65| 4.16M| } 66| | 67| 4.16M| mp_clamp(c); 68| 4.16M| return MP_OKAY; ------------------ | | 161| 4.16M|#define MP_OKAY 0 /* no error */ ------------------ 69| 4.16M|} mp_get_i32: 298| 44| { \ 299| 44| utype res = mag(a); \ 300| 44| return (a->sign == MP_NEG) ? (type)-res : (type)res; \ ------------------ | | 152| 44|#define MP_NEG 1 /* negative */ ------------------ | Branch (300:16): [True: 0, False: 44] ------------------ 301| 44| } mp_init_u32: 274| 44| { \ 275| 44| mp_err err; \ 276| 44| if ((err = mp_init(a)) != MP_OKAY) { \ ------------------ | | 161| 44|#define MP_OKAY 0 /* no error */ ------------------ | Branch (276:13): [True: 0, False: 44] ------------------ 277| 0| return err; \ 278| 0| } \ 279| 44| set(a, b); \ 280| 44| return MP_OKAY; \ ------------------ | | 161| 44|#define MP_OKAY 0 /* no error */ ------------------ 281| 44| } m_mp_init_multi: 41| 1.13k|{ 42| 1.13k| mp_int* cur_arg = mp; 43| 1.13k| va_list args; 44| | 45| 1.13k| va_start(args, mp); /* init args to next argument from caller */ 46| 4.78k| while (cur_arg != NULL) { ------------------ | Branch (46:9): [True: 3.64k, False: 1.13k] ------------------ 47| 3.64k| if (mp_init(cur_arg) != MP_OKAY) { ------------------ | | 161| 3.64k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (47:7): [True: 0, False: 3.64k] ------------------ 48| 0| dropbear_exit("Mem alloc error"); 49| 0| } 50| 3.64k| cur_arg = va_arg(args, mp_int*); 51| 3.64k| } 52| 1.13k| va_end(args); 53| 1.13k|} m_mp_alloc_init_multi: 56| 2.57k|{ 57| 2.57k| mp_int** cur_arg = mp; 58| 2.57k| va_list args; 59| | 60| 2.57k| va_start(args, mp); /* init args to next argument from caller */ 61| 10.4k| while (cur_arg != NULL) { ------------------ | Branch (61:9): [True: 7.92k, False: 2.57k] ------------------ 62| 7.92k| *cur_arg = m_malloc(sizeof(mp_int)); 63| 7.92k| if (mp_init(*cur_arg) != MP_OKAY) { ------------------ | | 161| 7.92k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (63:7): [True: 0, False: 7.92k] ------------------ 64| 0| dropbear_exit("Mem alloc error"); 65| 0| } 66| 7.92k| cur_arg = va_arg(args, mp_int**); 67| 7.92k| } 68| 2.57k| va_end(args); 69| 2.57k|} m_mp_free_multi: 72| 1.55k|{ 73| 1.55k| mp_int** cur_arg = mp; 74| 1.55k| va_list args; 75| | 76| 1.55k| va_start(args, mp); /* init args to next argument from caller */ 77| 8.83k| while (cur_arg != NULL) { ------------------ | Branch (77:9): [True: 7.28k, False: 1.55k] ------------------ 78| 7.28k| if (*cur_arg) { ------------------ | Branch (78:7): [True: 3.31k, False: 3.97k] ------------------ 79| 3.31k| mp_clear(*cur_arg); 80| 3.31k| } 81| 7.28k| m_free(*cur_arg); ------------------ | | 24| 7.28k|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 7.28k] | | ------------------ ------------------ 82| 7.28k| cur_arg = va_arg(args, mp_int**); 83| 7.28k| } 84| | va_end(args); 85| 1.55k|} bytes_to_mp: 87| 1.45k|void bytes_to_mp(mp_int *mp, const unsigned char* bytes, unsigned int len) { 88| | 89| 1.45k| if (mp_from_ubin(mp, (unsigned char*)bytes, len) != MP_OKAY) { ------------------ | | 161| 1.45k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (89:6): [True: 0, False: 1.45k] ------------------ 90| 0| dropbear_exit("Mem alloc error"); 91| 0| } 92| 1.45k|} buf_new: 41| 1.50k|buffer* buf_new(unsigned int size) { 42| 1.50k| buffer* buf; 43| 1.50k| if (size > BUF_MAX_SIZE) { ------------------ | | 35| 1.50k|#define BUF_MAX_SIZE 1000000000 ------------------ | Branch (43:6): [True: 0, False: 1.50k] ------------------ 44| 0| dropbear_exit("buf->size too big"); 45| 0| } 46| | 47| 1.50k| buf = (buffer*)m_malloc(sizeof(buffer)+size); 48| 1.50k| buf->data = (unsigned char*)buf + sizeof(buffer); 49| 1.50k| buf->size = size; 50| 1.50k| return buf; 51| 1.50k|} buf_free: 54| 1.49k|void buf_free(buffer* buf) { 55| | m_free(buf); ------------------ | | 24| 1.49k|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 1.49k] | | ------------------ ------------------ 56| 1.49k|} buf_incrlen: 104| 194k|void buf_incrlen(buffer* buf, unsigned int incr) { 105| 194k| if (incr > BUF_MAX_INCR || buf->len + incr > buf->size) { ------------------ | | 34| 389k|#define BUF_MAX_INCR 1000000000 ------------------ | Branch (105:6): [True: 0, False: 194k] | Branch (105:29): [True: 0, False: 194k] ------------------ 106| 0| dropbear_exit("Bad buf_incrlen"); 107| 0| } 108| 194k| buf->len += incr; 109| 194k|} buf_setpos: 111| 1.97k|void buf_setpos(buffer* buf, unsigned int pos) { 112| | 113| 1.97k| if (pos > buf->len) { ------------------ | Branch (113:6): [True: 0, False: 1.97k] ------------------ 114| 0| dropbear_exit("Bad buf_setpos"); 115| 0| } 116| 1.97k| buf->pos = pos; 117| 1.97k|} buf_incrwritepos: 120| 1.83k|void buf_incrwritepos(buffer* buf, unsigned int incr) { 121| 1.83k| if (incr > BUF_MAX_INCR || buf->pos + incr > buf->size) { ------------------ | | 34| 3.66k|#define BUF_MAX_INCR 1000000000 ------------------ | Branch (121:6): [True: 0, False: 1.83k] | Branch (121:29): [True: 0, False: 1.83k] ------------------ 122| 0| dropbear_exit("Bad buf_incrwritepos"); 123| 0| } 124| 1.83k| buf->pos += incr; 125| 1.83k| if (buf->pos > buf->len) { ------------------ | Branch (125:6): [True: 1.83k, False: 0] ------------------ 126| 1.83k| buf->len = buf->pos; 127| 1.83k| } 128| 1.83k|} buf_incrpos: 131| 28.8k|void buf_incrpos(buffer* buf, unsigned int incr) { 132| 28.8k| if (incr > BUF_MAX_INCR ------------------ | | 34| 57.6k|#define BUF_MAX_INCR 1000000000 ------------------ | Branch (132:6): [True: 0, False: 28.8k] ------------------ 133| 28.8k| || (buf->pos + incr) > buf->len) { ------------------ | Branch (133:6): [True: 0, False: 28.8k] ------------------ 134| 0| dropbear_exit("Bad buf_incrpos"); 135| 0| } 136| 28.8k| buf->pos += incr; 137| 28.8k|} buf_decrpos: 140| 2.85k|void buf_decrpos(buffer* buf, unsigned int decr) { 141| 2.85k| if (decr > buf->pos) { ------------------ | Branch (141:6): [True: 0, False: 2.85k] ------------------ 142| 0| dropbear_exit("Bad buf_decrpos"); 143| 0| } 144| 2.85k| buf->pos -= decr; 145| 2.85k|} buf_getbyte: 148| 1.58k|unsigned char buf_getbyte(buffer* buf) { 149| | 150| | /* This check is really just ==, but the >= allows us to check for the 151| | * bad case of pos > len, which should _never_ happen. */ 152| 1.58k| if (buf->pos >= buf->len) { ------------------ | Branch (152:6): [True: 25, False: 1.56k] ------------------ 153| 25| dropbear_exit("Bad buf_getbyte"); 154| 25| } 155| 1.56k| return buf->data[buf->pos++]; 156| 1.58k|} buf_putbyte: 169| 193k|void buf_putbyte(buffer* buf, unsigned char val) { 170| | 171| 193k| if (buf->pos >= buf->len) { ------------------ | Branch (171:6): [True: 193k, False: 0] ------------------ 172| 193k| buf_incrlen(buf, 1); 173| 193k| } 174| 193k| buf->data[buf->pos] = val; 175| 193k| buf->pos++; 176| 193k|} buf_getptr: 180| 32.4k|unsigned char* buf_getptr(const buffer* buf, unsigned int len) { 181| | 182| 32.4k| if (len > BUF_MAX_INCR || buf->pos + len > buf->len) { ------------------ | | 34| 64.8k|#define BUF_MAX_INCR 1000000000 ------------------ | Branch (182:6): [True: 0, False: 32.4k] | Branch (182:28): [True: 368, False: 32.0k] ------------------ 183| 368| dropbear_exit("Bad buf_getptr"); 184| 368| } 185| 32.0k| return &buf->data[buf->pos]; 186| 32.4k|} buf_getwriteptr: 190| 2.45k|unsigned char* buf_getwriteptr(const buffer* buf, unsigned int len) { 191| | 192| 2.45k| if (len > BUF_MAX_INCR || buf->pos + len > buf->size) { ------------------ | | 34| 4.90k|#define BUF_MAX_INCR 1000000000 ------------------ | Branch (192:6): [True: 0, False: 2.45k] | Branch (192:28): [True: 0, False: 2.45k] ------------------ 193| 0| dropbear_exit("Bad buf_getwriteptr"); 194| 0| } 195| 2.45k| return &buf->data[buf->pos]; 196| 2.45k|} buf_getstring: 201| 7.06k|char* buf_getstring(buffer* buf, unsigned int *retlen) { 202| | 203| 7.06k| unsigned int len; 204| 7.06k| char* ret; 205| 7.06k| void* src = NULL; 206| 7.06k| len = buf_getint(buf); 207| 7.06k| if (len > MAX_STRING_LEN) { ------------------ | | 259| 7.06k|#define MAX_STRING_LEN (MAX(MAX_CMD_LEN, 2400)) /* Sun SSH needs 2400 for algos, ------------------ | Branch (207:6): [True: 39, False: 7.02k] | Branch (207:12): [True: 6.97k, Folded] ------------------ 208| 39| dropbear_exit("String too long"); 209| 39| } 210| | 211| 7.02k| if (retlen != NULL) { ------------------ | Branch (211:6): [True: 6.93k, False: 86] ------------------ 212| 6.93k| *retlen = len; 213| 6.93k| } 214| 7.02k| src = buf_getptr(buf, len); 215| 7.02k| ret = m_malloc(len+1); 216| 7.02k| memcpy(ret, src, len); 217| 7.02k| buf_incrpos(buf, len); 218| 7.02k| ret[len] = '\0'; 219| | 220| 7.02k| return ret; 221| 7.06k|} buf_getstringbuf: 246| 662|buffer * buf_getstringbuf(buffer *buf) { 247| 662| return buf_getstringbuf_int(buf, 0); 248| 662|} buf_getint: 272| 15.5k|unsigned int buf_getint(buffer* buf) { 273| 15.5k| unsigned int ret; 274| | 275| 15.5k| LOAD32H(ret, buf_getptr(buf, 4)); ------------------ | | 66| 15.5k|#define LOAD32H(x, y) \ | | 67| 15.5k|do { XMEMCPY (&(x), (y), 4); \ | | ------------------ | | | | 39| 15.5k|#define XMEMCPY memcpy | | ------------------ | | 68| 15.5k| (x) = __builtin_bswap32 ((x)); } while(0) | | ------------------ | | | Branch (68:46): [Folded, False: 15.5k] | | ------------------ ------------------ 276| 15.5k| buf_incrpos(buf, 4); 277| 15.5k| return ret; 278| 15.5k|} buf_putint: 281| 74|void buf_putint(buffer* buf, int unsigned val) { 282| | 283| 74| STORE32H(val, buf_getwriteptr(buf, 4)); ------------------ | | 62| 74|#define STORE32H(x, y) \ | | 63| 74|do { ulong32 __t = __builtin_bswap32 ((x)); \ | | 64| 74| XMEMCPY ((y), &__t, 4); } while(0) | | ------------------ | | | | 39| 74|#define XMEMCPY memcpy | | ------------------ | | | Branch (64:39): [Folded, False: 74] | | ------------------ ------------------ 284| 74| buf_incrwritepos(buf, 4); 285| | 286| 74|} buf_putstring: 289| 1|void buf_putstring(buffer* buf, const char* str, unsigned int len) { 290| | 291| 1| buf_putint(buf, len); 292| 1| buf_putbytes(buf, (const unsigned char*)str, len); 293| | 294| 1|} buf_putbytes: 303| 952|void buf_putbytes(buffer *buf, const unsigned char *bytes, unsigned int len) { 304| 952| memcpy(buf_getwriteptr(buf, len), bytes, len); 305| 952| buf_incrwritepos(buf, len); 306| 952|} buf_getmpint: 356| 4.22k|int buf_getmpint(buffer* buf, mp_int* mp) { 357| | 358| 4.22k| unsigned int len; 359| 4.22k| len = buf_getint(buf); 360| | 361| 4.22k| if (len == 0) { ------------------ | Branch (361:6): [True: 889, False: 3.33k] ------------------ 362| 889| mp_zero(mp); 363| 889| return DROPBEAR_SUCCESS; ------------------ | | 111| 889|#define DROPBEAR_SUCCESS 0 ------------------ 364| 889| } 365| | 366| 3.33k| if (len > BUF_MAX_MPINT) { ------------------ | | 38| 3.33k|#define BUF_MAX_MPINT (8240 / 8) ------------------ | Branch (366:6): [True: 63, False: 3.27k] ------------------ 367| 63| return DROPBEAR_FAILURE; ------------------ | | 112| 63|#define DROPBEAR_FAILURE -1 ------------------ 368| 63| } 369| | 370| | /* check for negative */ 371| 3.27k| if (*buf_getptr(buf, 1) & (1 << (CHAR_BIT-1))) { ------------------ | Branch (371:6): [True: 9, False: 3.26k] ------------------ 372| 9| return DROPBEAR_FAILURE; ------------------ | | 112| 9|#define DROPBEAR_FAILURE -1 ------------------ 373| 9| } 374| | 375| 3.26k| if (mp_from_ubin(mp, buf_getptr(buf, len), len) != MP_OKAY) { ------------------ | | 161| 3.26k|#define MP_OKAY 0 /* no error */ ------------------ | Branch (375:6): [True: 0, False: 3.26k] ------------------ 376| 0| return DROPBEAR_FAILURE; ------------------ | | 112| 0|#define DROPBEAR_FAILURE -1 ------------------ 377| 0| } 378| | 379| 3.26k| buf_incrpos(buf, len); 380| 3.26k| return DROPBEAR_SUCCESS; ------------------ | | 111| 3.26k|#define DROPBEAR_SUCCESS 0 ------------------ 381| 3.26k|} buffer.c:buf_getstringbuf_int: 224| 662|static buffer * buf_getstringbuf_int(buffer *buf, int incllen) { 225| 662| buffer *ret = NULL; 226| 662| unsigned int len = buf_getint(buf); 227| 662| int extra = 0; 228| 662| if (len > MAX_STRING_LEN) { ------------------ | | 259| 662|#define MAX_STRING_LEN (MAX(MAX_CMD_LEN, 2400)) /* Sun SSH needs 2400 for algos, ------------------ | Branch (228:6): [True: 28, False: 634] | Branch (228:12): [True: 651, Folded] ------------------ 229| 28| dropbear_exit("String too long"); 230| 28| } 231| 634| if (incllen) { ------------------ | Branch (231:6): [True: 0, False: 634] ------------------ 232| 0| extra = 4; 233| 0| } 234| 634| ret = buf_new(len+extra); 235| 634| if (incllen) { ------------------ | Branch (235:6): [True: 0, False: 634] ------------------ 236| 0| buf_putint(ret, len); 237| 0| } 238| 634| memcpy(buf_getwriteptr(ret, len), buf_getptr(buf, len), len); 239| 634| buf_incrpos(buf, len); 240| 634| buf_incrlen(ret, len); 241| 634| buf_setpos(ret, 0); 242| 634| return ret; 243| 662|} crypto_init: 21| 1|void crypto_init() { 22| | 23| 1| const struct ltc_cipher_descriptor *regciphers[] = { 24| 1|#if DROPBEAR_AES 25| 1| &aes_desc, 26| 1|#endif 27| |#if DROPBEAR_3DES 28| | &des3_desc, 29| |#endif 30| 1| NULL 31| 1| }; 32| | 33| 1| const struct ltc_hash_descriptor *reghashes[] = { 34| |#if DROPBEAR_SHA1_HMAC 35| | &sha1_desc, 36| |#endif 37| 1|#if DROPBEAR_SHA256 38| 1| &sha256_desc, 39| 1|#endif 40| 1|#if DROPBEAR_SHA384 41| 1| &sha384_desc, 42| 1|#endif 43| 1|#if DROPBEAR_SHA512 44| 1| &sha512_desc, 45| 1|#endif 46| 1| NULL 47| 1| }; 48| 1| int i; 49| | 50| 2| for (i = 0; regciphers[i] != NULL; i++) { ------------------ | Branch (50:14): [True: 1, False: 1] ------------------ 51| 1| if (register_cipher(regciphers[i]) == -1) { ------------------ | Branch (51:7): [True: 0, False: 1] ------------------ 52| 0| dropbear_exit("Error registering crypto"); 53| 0| } 54| 1| } 55| | 56| 4| for (i = 0; reghashes[i] != NULL; i++) { ------------------ | Branch (56:14): [True: 3, False: 1] ------------------ 57| 3| if (register_hash(reghashes[i]) == -1) { ------------------ | Branch (57:7): [True: 0, False: 3] ------------------ 58| 0| dropbear_exit("Error registering crypto"); 59| 0| } 60| 3| } 61| | 62| 1|#if DROPBEAR_LTC_PRNG 63| 1| dropbear_ltc_prng = register_prng(&dropbear_prng_desc); 64| 1| if (dropbear_ltc_prng == -1) { ------------------ | Branch (64:6): [True: 0, False: 1] ------------------ 65| 0| dropbear_exit("Error registering crypto"); 66| 0| } 67| 1|#endif 68| | 69| 1| mp_rand_source(dropbear_rand_source); 70| | 71| 1|#if DROPBEAR_ECC 72| 1| ltc_mp = ltm_desc; 73| 1| dropbear_ecc_fill_dp(); 74| 1|#endif 75| 1|} crypto_desc.c:dropbear_rand_source: 13| 3.85k|static mp_err dropbear_rand_source(void* out, size_t size) { 14| 3.85k| genrandom((unsigned char*)out, (unsigned int)size); 15| 3.85k| return MP_OKAY; ------------------ | | 161| 3.85k|#define MP_OKAY 0 /* no error */ ------------------ 16| 3.85k|} dropbear_ed25519_verify: 506| 115|{ 507| 115| hash_state hs; 508| 115| u8 t[32],h[64]; 509| 115| gf p[4],q[4]; 510| | 511| 115| if (slen < 64) return -1; ------------------ | Branch (511:7): [True: 0, False: 115] ------------------ 512| | 513| 115| if (s_lt_l(s + 32) == -1) { ------------------ | Branch (513:7): [True: 67, False: 48] ------------------ 514| 67| return -1; 515| 67| } 516| | 517| 48| if (unpackneg(q,pk)) return -1; ------------------ | Branch (517:7): [True: 26, False: 22] ------------------ 518| | 519| 22| sha512_init(&hs); 520| 22| sha512_process(&hs,s,32); 521| 22| sha512_process(&hs,pk,32); 522| 22| sha512_process(&hs,m,mlen); 523| 22| sha512_done(&hs,h); 524| | 525| 22| reduce(h); 526| 22| scalarmult(p,q,h); 527| | 528| 22| scalarbase(q,s + 32); 529| 22| add(p,q); 530| 22| pack(t,p); 531| | 532| 22| if (crypto_verify_32(s, t)) ------------------ | Branch (532:7): [True: 20, False: 2] ------------------ 533| 20| return -1; 534| | 535| 2| return 0; 536| 22|} curve25519.c:unpack25519: 152| 48|{ 153| 48| int i; 154| 768| FOR(i,16) o[i]=n[2*i]+((i64)n[2*i+1]<<8); ------------------ | | 34| 816|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 768, False: 48] | | ------------------ ------------------ 155| 48| o[15]&=0x7fff; 156| 48|} curve25519.c:sel25519: 98| 90.5k|{ 99| 90.5k| i64 t,i,c=~(b-1); 100| 1.44M| FOR(i,16) { ------------------ | | 34| 1.53M|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 1.44M, False: 90.5k] | | ------------------ ------------------ 101| 1.44M| t= c&(p[i]^q[i]); 102| 1.44M| p[i]^=t; 103| 1.44M| q[i]^=t; 104| 1.44M| } 105| 90.5k|} curve25519.c:A: 159| 112k|{ 160| 112k| int i; 161| 1.80M| FOR(i,16) o[i]=a[i]+b[i]; ------------------ | | 34| 1.91M|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 1.80M, False: 112k] | | ------------------ ------------------ 162| 112k|} curve25519.c:Z: 165| 90.2k|{ 166| 90.2k| int i; 167| 1.44M| FOR(i,16) o[i]=a[i]-b[i]; ------------------ | | 34| 1.53M|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 1.44M, False: 90.2k] | | ------------------ ------------------ 168| 90.2k|} curve25519.c:S: 182| 16.3k|{ 183| 16.3k| M(o,a,a); 184| 16.3k|} curve25519.c:M: 171| 235k|{ 172| 235k| i64 i,j,t[31]; 173| 7.31M| FOR(i,31) t[i]=0; ------------------ | | 34| 7.54M|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 7.31M, False: 235k] | | ------------------ ------------------ 174| 60.3M| FOR(i,16) FOR(j,16) t[i+j]+=a[i]*b[j]; ------------------ | | 34| 4.00M|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 3.77M, False: 235k] | | ------------------ ------------------ FOR(i,16) FOR(j,16) t[i+j]+=a[i]*b[j]; ------------------ | | 34| 64.1M|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 60.3M, False: 3.77M] | | ------------------ ------------------ 175| 3.53M| FOR(i,15) t[i]+=38*t[i+16]; ------------------ | | 34| 3.77M|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 3.53M, False: 235k] | | ------------------ ------------------ 176| 3.77M| FOR(i,16) o[i]=t[i]; ------------------ | | 34| 4.00M|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 3.77M, False: 235k] | | ------------------ ------------------ 177| 235k| car25519(o); 178| 235k| car25519(o); 179| 235k|} curve25519.c:car25519: 86| 472k|{ 87| 472k| int i; 88| 472k| i64 c; 89| 7.55M| FOR(i,16) { ------------------ | | 34| 8.03M|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 7.55M, False: 472k] | | ------------------ ------------------ 90| 7.55M| o[i]+=(1LL<<16); 91| 7.55M| c=o[i]>>16; 92| 7.55M| o[(i+1)*(i<15)]+=c-1+37*(c-1)*(i==15); 93| 7.55M| o[i]-=((u64)c)<<16; 94| 7.55M| } 95| 472k|} curve25519.c:inv25519: 187| 22|{ 188| 22| gf c; 189| 22| int a; 190| 352| FOR(a,16) c[a]=i[a]; ------------------ | | 34| 374|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 352, False: 22] | | ------------------ ------------------ 191| 5.61k| for(a=253;a>=0;a--) { ------------------ | Branch (191:13): [True: 5.58k, False: 22] ------------------ 192| 5.58k| S(c,c); 193| 5.58k| if(a!=2&&a!=4) M(c,c,i); ------------------ | Branch (193:8): [True: 5.56k, False: 22] | Branch (193:14): [True: 5.54k, False: 22] ------------------ 194| 5.58k| } 195| 352| FOR(a,16) o[a]=c[a]; ------------------ | | 34| 374|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 352, False: 22] | | ------------------ ------------------ 196| 22|} curve25519.c:pack25519: 108| 234|{ 109| 234| int i,j,b; 110| 234| gf m,t; 111| 3.74k| FOR(i,16) t[i]=n[i]; ------------------ | | 34| 3.97k|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 3.74k, False: 234] | | ------------------ ------------------ 112| 234| car25519(t); 113| 234| car25519(t); 114| 234| car25519(t); 115| 468| FOR(j,2) { ------------------ | | 34| 702|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 468, False: 234] | | ------------------ ------------------ 116| 468| m[0]=t[0]-0xffed; 117| 7.02k| for(i=1;i<15;i++) { ------------------ | Branch (117:13): [True: 6.55k, False: 468] ------------------ 118| 6.55k| m[i]=t[i]-0xffff-((m[i-1]>>16)&1); 119| 6.55k| m[i-1]&=0xffff; 120| 6.55k| } 121| 468| m[15]=t[15]-0x7fff-((m[14]>>16)&1); 122| 468| b=(m[15]>>16)&1; 123| 468| m[14]&=0xffff; 124| 468| sel25519(t,m,1-b); 125| 468| } 126| 3.74k| FOR(i,16) { ------------------ | | 34| 3.97k|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 3.74k, False: 234] | | ------------------ ------------------ 127| 3.74k| o[2*i]=t[i]&0xff; 128| 3.74k| o[2*i+1]=t[i]>>8; 129| 3.74k| } 130| 234|} curve25519.c:scalarbase: 333| 22|{ 334| 22| gf q[4]; 335| 22| set25519(q[0],X); 336| 22| set25519(q[1],Y); 337| 22| set25519(q[2],gf1); 338| 22| M(q[3],X,Y); 339| 22| scalarmult(p,q,s); 340| 22|} curve25519.c:set25519: 79| 290|{ 80| 290| int i; 81| 4.64k| FOR(i,16) r[i]=a[i]; ------------------ | | 34| 4.93k|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 4.64k, False: 290] | | ------------------ ------------------ 82| 290|} curve25519.c:pack: 307| 22|{ 308| 22| gf tx, ty, zi; 309| 22| inv25519(zi, p[2]); 310| 22| M(tx, p[0], zi); 311| 22| M(ty, p[1], zi); 312| 22| pack25519(r, ty); 313| 22| r[31] ^= par25519(tx) << 7; 314| 22|} curve25519.c:par25519: 144| 44|{ 145| 44| u8 d[32]; 146| 44| pack25519(d,a); 147| 44| return d[0]&1; 148| 44|} curve25519.c:reduce: 387| 22|{ 388| 22| i64 x[64],i; 389| 1.40k| FOR(i,64) x[i] = (u64) r[i]; ------------------ | | 34| 1.43k|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 1.40k, False: 22] | | ------------------ ------------------ 390| 1.40k| FOR(i,64) r[i] = 0; ------------------ | | 34| 1.43k|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 1.40k, False: 22] | | ------------------ ------------------ 391| 22| modL(r,x); 392| 22|} curve25519.c:modL: 361| 22|{ 362| 22| i64 carry,i,j; 363| 726| for (i = 63;i >= 32;--i) { ------------------ | Branch (363:15): [True: 704, False: 22] ------------------ 364| 704| carry = 0; 365| 14.7k| for (j = i - 32;j < i - 12;++j) { ------------------ | Branch (365:21): [True: 14.0k, False: 704] ------------------ 366| 14.0k| x[j] += carry - 16 * x[i] * L[j - (i - 32)]; 367| 14.0k| carry = (x[j] + 128) >> 8; 368| 14.0k| x[j] -= ((u64)carry) << 8; 369| 14.0k| } 370| 704| x[j] += carry; 371| 704| x[i] = 0; 372| 704| } 373| 22| carry = 0; 374| 704| FOR(j,32) { ------------------ | | 34| 726|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 704, False: 22] | | ------------------ ------------------ 375| 704| x[j] += carry - (x[31] >> 4) * L[j]; 376| 704| carry = x[j] >> 8; 377| 704| x[j] &= 255; 378| 704| } 379| 704| FOR(j,32) x[j] -= carry * L[j]; ------------------ | | 34| 726|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 704, False: 22] | | ------------------ ------------------ 380| 704| FOR(i,32) { ------------------ | | 34| 726|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 704, False: 22] | | ------------------ ------------------ 381| 704| x[i+1] += x[i] >> 8; 382| 704| r[i] = x[i] & 255; 383| 704| } 384| 22|} curve25519.c:s_lt_l: 434| 115|static int s_lt_l(const u8 *s) { 435| 115| int i; 436| 204| for (i = 31; i >= 0; i--) { ------------------ | Branch (436:16): [True: 204, False: 0] ------------------ 437| 204| if (s[i] < L[i]) { ------------------ | Branch (437:9): [True: 48, False: 156] ------------------ 438| 48| return 0; 439| 48| } 440| 156| if (s[i] > L[i]) { ------------------ | Branch (440:9): [True: 67, False: 89] ------------------ 441| 67| return -1; 442| 67| } 443| 156| } 444| 0| return -1; 445| 115|} curve25519.c:unpackneg: 464| 48|{ 465| 48| gf t, chk, num, den, den2, den4, den6; 466| 48| set25519(r[2],gf1); 467| 48| unpack25519(r[1],p); 468| | 469| | /* Check that pubkey y < 2^255 - 19 */ 470| 48| if (y_lt_p(r[1])) { ------------------ | Branch (470:7): [True: 6, False: 42] ------------------ 471| 6| return -1; 472| 6| } 473| | 474| 42| S(num,r[1]); 475| 42| M(den,num,D); 476| 42| Z(num,num,r[2]); 477| 42| A(den,r[2],den); 478| | 479| 42| S(den2,den); 480| 42| S(den4,den2); 481| 42| M(den6,den4,den2); 482| 42| M(t,den6,num); 483| 42| M(t,t,den); 484| | 485| 42| pow2523(t,t); 486| 42| M(t,t,num); 487| 42| M(t,t,den); 488| 42| M(t,t,den); 489| 42| M(r[0],t,den); 490| | 491| 42| S(chk,r[0]); 492| 42| M(chk,chk,den); 493| 42| if (neq25519(chk, num)) M(r[0],r[0],I); ------------------ | Branch (493:7): [True: 32, False: 10] ------------------ 494| | 495| 42| S(chk,r[0]); 496| 42| M(chk,chk,den); 497| 42| if (neq25519(chk, num)) return -1; ------------------ | Branch (497:7): [True: 20, False: 22] ------------------ 498| | 499| 22| if (par25519(r[0]) == (p[31]>>7)) Z(r[0],gf0,r[0]); ------------------ | Branch (499:7): [True: 9, False: 13] ------------------ 500| | 501| 22| M(r[3],r[0],r[1]); 502| 22| return 0; 503| 42|} curve25519.c:y_lt_p: 450| 48|static int y_lt_p(const gf y) { 451| 48| int i; 452| 204| for (i = 15; i >= 0; i--) { ------------------ | Branch (452:16): [True: 203, False: 1] ------------------ 453| 203| if (y[i] < field_prime[i]) { ------------------ | Branch (453:9): [True: 42, False: 161] ------------------ 454| 42| return 0; 455| 42| } 456| 161| if (y[i] > field_prime[i]) { ------------------ | Branch (456:9): [True: 5, False: 156] ------------------ 457| 5| return -1; 458| 5| } 459| 161| } 460| 1| return -1; 461| 48|} curve25519.c:pow2523: 200| 42|{ 201| 42| gf c; 202| 42| int a; 203| 672| FOR(a,16) c[a]=i[a]; ------------------ | | 34| 714|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 672, False: 42] | | ------------------ ------------------ 204| 10.5k| for(a=250;a>=0;a--) { ------------------ | Branch (204:13): [True: 10.5k, False: 42] ------------------ 205| 10.5k| S(c,c); 206| 10.5k| if(a!=1) M(c,c,i); ------------------ | Branch (206:8): [True: 10.5k, False: 42] ------------------ 207| 10.5k| } 208| 672| FOR(a,16) o[a]=c[a]; ------------------ | | 34| 714|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 672, False: 42] | | ------------------ ------------------ 209| 42|} curve25519.c:neq25519: 135| 84|{ 136| 84| u8 c[32],d[32]; 137| 84| pack25519(c,a); 138| 84| pack25519(d,b); 139| 84| return crypto_verify_32(c,d); 140| 84|} curve25519.c:scalarmult: 317| 44|{ 318| 44| int i; 319| 44| set25519(p[0],gf0); 320| 44| set25519(p[1],gf1); 321| 44| set25519(p[2],gf1); 322| 44| set25519(p[3],gf0); 323| 11.3k| for (i = 255;i >= 0;--i) { ------------------ | Branch (323:16): [True: 11.2k, False: 44] ------------------ 324| 11.2k| u8 b = (s[i/8]>>(i&7))&1; 325| 11.2k| cswap(p,q,b); 326| 11.2k| add(q,p); 327| 11.2k| add(p,p); 328| 11.2k| cswap(p,q,b); 329| 11.2k| } 330| 44|} curve25519.c:cswap: 300| 22.5k|{ 301| 22.5k| int i; 302| 22.5k| FOR(i,4) ------------------ | | 34| 112k|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 90.1k, False: 22.5k] | | ------------------ ------------------ 303| 90.1k| sel25519(p[i],q[i],b); 304| 22.5k|} curve25519.c:add: 275| 22.5k|{ 276| 22.5k| gf a,b,c,d,t,e,f,g,h; 277| | 278| 22.5k| Z(a, p[1], p[0]); 279| 22.5k| Z(t, q[1], q[0]); 280| 22.5k| M(a, a, t); 281| 22.5k| A(b, p[0], p[1]); 282| 22.5k| A(t, q[0], q[1]); 283| 22.5k| M(b, b, t); 284| 22.5k| M(c, p[3], q[3]); 285| 22.5k| M(c, c, D2); 286| 22.5k| M(d, p[2], q[2]); 287| 22.5k| A(d, d, d); 288| 22.5k| Z(e, b, a); 289| 22.5k| Z(f, d, c); 290| 22.5k| A(g, d, c); 291| 22.5k| A(h, b, a); 292| | 293| 22.5k| M(p[0], e, f); 294| 22.5k| M(p[1], h, g); 295| 22.5k| M(p[2], g, f); 296| 22.5k| M(p[3], e, h); 297| 22.5k|} curve25519.c:crypto_verify_32: 73| 106|{ 74| 106| return vn(x,y,32); 75| 106|} curve25519.c:vn: 66| 106|{ 67| 106| u32 i,d = 0; 68| 3.39k| FOR(i,n) d |= x[i]^y[i]; ------------------ | | 34| 3.49k|#define FOR(i,n) for (i = 0;i < n;++i) | | ------------------ | | | Branch (34:29): [True: 3.39k, False: 106] | | ------------------ ------------------ 69| 106| return (1 & ((d - 1) >> 8)) - 1; 70| 106|} m_burn: 5| 4.35k|void m_burn(void *data, unsigned int len) { 6| | 7| |#if defined(HAVE_MEMSET_S) 8| | memset_s(data, len, 0x0, len); 9| |#elif defined(HAVE_EXPLICIT_BZERO) 10| | explicit_bzero(data, len); 11| |#else 12| | /* This must be volatile to avoid compiler optimisation */ 13| | volatile void *p = data; 14| | memset((void*)p, 0x0, len); 15| |#endif 16| 4.35k|} m_calloc: 5| 1.68M|void * m_calloc(size_t nmemb, size_t size) { 6| 1.68M| if (SIZE_T_MAX / nmemb < size) { ------------------ | | 175| 1.68M|#define SIZE_T_MAX ULONG_MAX ------------------ | Branch (6:9): [True: 0, False: 1.68M] ------------------ 7| 0| dropbear_exit("m_calloc failed"); 8| 0| } 9| 1.68M| return m_malloc(nmemb*size); 10| 1.68M|} m_malloc_set_epoch: 76| 2.91k|void m_malloc_set_epoch(unsigned int epoch) { 77| 2.91k| current_epoch = epoch; 78| 2.91k|} m_malloc_free_epoch: 80| 2.91k|void m_malloc_free_epoch(unsigned int epoch, int dofree) { 81| 2.91k| struct dbmalloc_header* header; 82| 2.91k| struct dbmalloc_header* nextheader = NULL; 83| 2.91k| struct dbmalloc_header* oldstaple = staple; 84| 2.91k| staple = NULL; 85| | /* free allocations from this epoch, create a new staple-anchored list from 86| | the remainder */ 87| 11.0k| for (header = oldstaple; header; header = nextheader) ------------------ | Branch (87:30): [True: 8.12k, False: 2.91k] ------------------ 88| 8.12k| { 89| 8.12k| nextheader = header->next; 90| 8.12k| if (header->epoch == epoch) { ------------------ | Branch (90:13): [True: 2.29k, False: 5.83k] ------------------ 91| 2.29k| if (dofree) { ------------------ | Branch (91:17): [True: 2.29k, False: 0] ------------------ 92| 2.29k| free(header); 93| 2.29k| } 94| 5.83k| } else { 95| 5.83k| header->prev = NULL; 96| | header->next = NULL; 97| 5.83k| put_alloc(header); 98| 5.83k| } 99| 8.12k| } 100| 2.91k|} m_malloc: 131| 1.70M|void * m_malloc(size_t size) { 132| 1.70M| char* mem = NULL; 133| 1.70M| struct dbmalloc_header* header = NULL; 134| | 135| 1.70M| if (size == 0 || size > 1e9) { ------------------ | Branch (135:9): [True: 0, False: 1.70M] | Branch (135:22): [True: 0, False: 1.70M] ------------------ 136| 0| dropbear_exit("m_malloc failed"); 137| 0| } 138| | 139| 1.70M| size = size + sizeof(struct dbmalloc_header); 140| | 141| 1.70M| mem = calloc(1, size); 142| 1.70M| if (mem == NULL) { ------------------ | Branch (142:9): [True: 0, False: 1.70M] ------------------ 143| 0| dropbear_exit("m_malloc failed"); 144| 0| } 145| 1.70M| header = (struct dbmalloc_header*)mem; 146| 1.70M| put_alloc(header); 147| 1.70M| header->epoch = current_epoch; 148| 1.70M| return &mem[sizeof(struct dbmalloc_header)]; 149| 1.70M|} m_realloc: 151| 447k|void * m_realloc(void* ptr, size_t size) { 152| 447k| char* mem = NULL; 153| 447k| struct dbmalloc_header* header = NULL; 154| 447k| if (size == 0 || size > 1e9) { ------------------ | Branch (154:9): [True: 0, False: 447k] | Branch (154:22): [True: 0, False: 447k] ------------------ 155| 0| dropbear_exit("m_realloc failed"); 156| 0| } 157| | 158| 447k| header = get_header(ptr); 159| 447k| remove_alloc(header); 160| | 161| 447k| size = size + sizeof(struct dbmalloc_header); 162| 447k| mem = realloc(header, size); 163| 447k| if (mem == NULL) { ------------------ | Branch (163:9): [True: 0, False: 447k] ------------------ 164| 0| dropbear_exit("m_realloc failed"); 165| 0| } 166| | 167| 447k| header = (struct dbmalloc_header*)mem; 168| 447k| put_alloc(header); 169| 447k| return &mem[sizeof(struct dbmalloc_header)]; 170| 447k|} m_free_direct: 172| 1.70M|void m_free_direct(void* ptr) { 173| 1.70M| struct dbmalloc_header* header = NULL; 174| 1.70M| if (!ptr) { ------------------ | Branch (174:9): [True: 6.38k, False: 1.70M] ------------------ 175| 6.38k| return; 176| 6.38k| } 177| 1.70M| header = get_header(ptr); 178| 1.70M| remove_alloc(header); 179| 1.70M| free(header); 180| 1.70M|} m_realloc_ltm: 184| 447k|void * m_realloc_ltm(void* ptr, size_t oldsize, size_t newsize) { 185| 447k| (void)oldsize; 186| 447k| return m_realloc(ptr, newsize); 187| 447k|} m_free_ltm: 189| 1.27M|void m_free_ltm(void *mem, size_t size) { 190| 1.27M| (void)size; 191| 1.27M| m_free_direct(mem); 192| 1.27M|} dbmalloc.c:put_alloc: 102| 2.15M|static void put_alloc(struct dbmalloc_header *header) { 103| 2.15M| assert(header->next == NULL); ------------------ | Branch (103:5): [True: 0, False: 2.15M] | Branch (103:5): [True: 2.15M, False: 0] ------------------ 104| 2.15M| assert(header->prev == NULL); ------------------ | Branch (104:5): [True: 0, False: 2.15M] | Branch (104:5): [True: 2.15M, False: 0] ------------------ 105| 2.15M| if (staple) { ------------------ | Branch (105:9): [True: 2.15M, False: 2.92k] ------------------ 106| 2.15M| staple->prev = header; 107| 2.15M| } 108| 2.15M| header->next = staple; 109| 2.15M| staple = header; 110| 2.15M|} dbmalloc.c:get_header: 126| 2.14M|static struct dbmalloc_header* get_header(void* ptr) { 127| 2.14M| char* bptr = ptr; 128| 2.14M| return (struct dbmalloc_header*)&bptr[-sizeof(struct dbmalloc_header)]; 129| 2.14M|} dbmalloc.c:remove_alloc: 112| 2.14M|static void remove_alloc(struct dbmalloc_header *header) { 113| 2.14M| if (header->prev) { ------------------ | Branch (113:9): [True: 1.39M, False: 748k] ------------------ 114| 1.39M| header->prev->next = header->next; 115| 1.39M| } 116| 2.14M| if (header->next) { ------------------ | Branch (116:9): [True: 2.14M, False: 0] ------------------ 117| 2.14M| header->next->prev = header->prev; 118| 2.14M| } 119| 2.14M| if (staple == header) { ------------------ | Branch (119:9): [True: 748k, False: 1.39M] ------------------ 120| 748k| staple = header->next; 121| 748k| } 122| 2.14M| header->prev = NULL; 123| | header->next = NULL; 124| 2.14M|} fuzz_seed: 153| 2.92k|void fuzz_seed(const unsigned char* dat, unsigned int len) { 154| 2.92k| hash_state hs; 155| 2.92k| sha256_init(&hs); 156| 2.92k| sha256_process(&hs, "fuzzfuzzfuzz", strlen("fuzzfuzzfuzz")); 157| 2.92k| sha256_process(&hs, dat, len); 158| 2.92k| sha256_done(&hs, hashpool); 159| 2.92k| counter = 0; 160| 2.92k| donerandinit = 1; 161| 2.92k|} genrandom: 313| 3.85k|void genrandom(unsigned char* buf, unsigned int len) { 314| | 315| 3.85k| hash_state hs; 316| 3.85k| unsigned char hash[SHA256_HASH_SIZE]; 317| 3.85k| unsigned int copylen; 318| | 319| 3.85k| if (!donerandinit) { ------------------ | Branch (319:6): [True: 0, False: 3.85k] ------------------ 320| 0| dropbear_exit("seedrandom not done"); 321| 0| } 322| | 323| 7.70k| while (len > 0) { ------------------ | Branch (323:9): [True: 3.85k, False: 3.85k] ------------------ 324| 3.85k| sha256_init(&hs); 325| 3.85k| sha256_process(&hs, (void*)hashpool, sizeof(hashpool)); 326| 3.85k| sha256_process(&hs, (void*)&counter, sizeof(counter)); 327| 3.85k| sha256_done(&hs, hash); 328| | 329| 3.85k| counter++; 330| 3.85k| if (counter > MAX_COUNTER) { ------------------ | | 35| 3.85k|#define MAX_COUNTER (1<<30) ------------------ | Branch (330:7): [True: 0, False: 3.85k] ------------------ 331| 0| seedrandom(); 332| 0| } 333| | 334| | copylen = MIN(len, SHA256_HASH_SIZE); ------------------ | Branch (334:13): [True: 3.85k, False: 0] ------------------ 335| 3.85k| memcpy(buf, hash, copylen); 336| 3.85k| len -= copylen; 337| 3.85k| buf += copylen; 338| 3.85k| } 339| 3.85k| m_burn(hash, sizeof(hash)); 340| 3.85k|} dropbear_exit: 105| 544|void dropbear_exit(const char* format, ...) { 106| | 107| 544| va_list param; 108| | 109| 544| va_start(param, format); 110| 544| _dropbear_exit(EXIT_FAILURE, format, param); 111| 544| va_end(param); 112| 0|} dropbear_log: 148| 146|void dropbear_log(int priority, const char* format, ...) { 149| | 150| 146| va_list param; 151| | 152| 146| va_start(param, format); 153| 146| _dropbear_log(priority, format, param); 154| | va_end(param); 155| 146|} disallow_core: 660| 1|void disallow_core() { 661| 1| struct rlimit lim = {0}; 662| 1| if (getrlimit(RLIMIT_CORE, &lim) < 0) { ------------------ | Branch (662:6): [True: 0, False: 1] ------------------ 663| 0| TRACE(("getrlimit(RLIMIT_CORE) failed")); 664| 0| } 665| 1| lim.rlim_cur = 0; 666| 1| if (setrlimit(RLIMIT_CORE, &lim) < 0) { ------------------ | Branch (666:6): [True: 0, False: 1] ------------------ 667| 0| TRACE(("setrlimit(RLIMIT_CORE) failed")); 668| 0| } 669| 1|} dbutil.c:generic_dropbear_exit: 115| 544| va_list param) { 116| | 117| 544| char fmtbuf[300]; 118| | 119| 544| snprintf(fmtbuf, sizeof(fmtbuf), "Exited: %s", format); 120| | 121| 544| _dropbear_log(LOG_INFO, fmtbuf, param); 122| | 123| 544|#if DROPBEAR_FUZZ 124| 544| if (fuzz.do_jmp) { ------------------ | Branch (124:9): [True: 544, False: 0] ------------------ 125| 544| longjmp(fuzz.jmp, 1); 126| 544| } 127| 0|#endif 128| | 129| 0| exit(exitcode); 130| 544|} buf_get_dss_pub_key: 46| 359|int buf_get_dss_pub_key(buffer* buf, dropbear_dss_key *key) { 47| 359| int ret = DROPBEAR_FAILURE; ------------------ | | 112| 359|#define DROPBEAR_FAILURE -1 ------------------ 48| | 49| 359| TRACE(("enter buf_get_dss_pub_key")) 50| 359| dropbear_assert(key != NULL); ------------------ | | 86| 359|#define dropbear_assert(X) do { if (!(X)) { fail_assert(#X, __FILE__, __LINE__); } } while (0) | | ------------------ | | | Branch (86:37): [True: 0, False: 359] | | | Branch (86:93): [Folded, False: 359] | | ------------------ ------------------ 51| 359| m_mp_alloc_init_multi(&key->p, &key->q, &key->g, &key->y, NULL); 52| 359| key->x = NULL; 53| | 54| 359| buf_incrpos(buf, 4+SSH_SIGNKEY_DSS_LEN); /* int + "ssh-dss" */ ------------------ | | 115| 359|#define SSH_SIGNKEY_DSS_LEN 7 ------------------ 55| 359| if (buf_getmpint(buf, key->p) == DROPBEAR_FAILURE ------------------ | | 112| 718|#define DROPBEAR_FAILURE -1 ------------------ | Branch (55:6): [True: 21, False: 338] ------------------ 56| 338| || buf_getmpint(buf, key->q) == DROPBEAR_FAILURE ------------------ | | 112| 697|#define DROPBEAR_FAILURE -1 ------------------ | Branch (56:6): [True: 27, False: 311] ------------------ 57| 311| || buf_getmpint(buf, key->g) == DROPBEAR_FAILURE ------------------ | | 112| 670|#define DROPBEAR_FAILURE -1 ------------------ | Branch (57:6): [True: 8, False: 303] ------------------ 58| 303| || buf_getmpint(buf, key->y) == DROPBEAR_FAILURE) { ------------------ | | 112| 303|#define DROPBEAR_FAILURE -1 ------------------ | Branch (58:6): [True: 8, False: 295] ------------------ 59| 19| TRACE(("leave buf_get_dss_pub_key: failed reading mpints")) 60| 19| ret = DROPBEAR_FAILURE; ------------------ | | 112| 19|#define DROPBEAR_FAILURE -1 ------------------ 61| 19| goto out; 62| 19| } 63| | 64| 340| if (mp_count_bits(key->p) != DSS_P_BITS) { ------------------ | | 44| 340|#define DSS_P_BITS 1024 ------------------ | Branch (64:6): [True: 24, False: 316] ------------------ 65| 24| dropbear_log(LOG_WARNING, "Bad DSS p"); 66| 24| ret = DROPBEAR_FAILURE; ------------------ | | 112| 24|#define DROPBEAR_FAILURE -1 ------------------ 67| 24| goto out; 68| 24| } 69| | 70| 316| if (mp_count_bits(key->q) != DSS_Q_BITS) { ------------------ | | 45| 316|#define DSS_Q_BITS 160 ------------------ | Branch (70:6): [True: 26, False: 290] ------------------ 71| 26| dropbear_log(LOG_WARNING, "Bad DSS q"); 72| 26| ret = DROPBEAR_FAILURE; ------------------ | | 112| 26|#define DROPBEAR_FAILURE -1 ------------------ 73| 26| goto out; 74| 26| } 75| | 76| | /* test 1 < g < p */ 77| 290| if (mp_cmp_d(key->g, 1) != MP_GT) { ------------------ | | 156| 290|#define MP_GT 1 /* greater than */ ------------------ | Branch (77:6): [True: 2, False: 288] ------------------ 78| 2| dropbear_log(LOG_WARNING, "Bad DSS g"); 79| 2| ret = DROPBEAR_FAILURE; ------------------ | | 112| 2|#define DROPBEAR_FAILURE -1 ------------------ 80| 2| goto out; 81| 2| } 82| 288| if (mp_cmp(key->g, key->p) != MP_LT) { ------------------ | | 154| 288|#define MP_LT -1 /* less than */ ------------------ | Branch (82:6): [True: 2, False: 286] ------------------ 83| 2| dropbear_log(LOG_WARNING, "Bad DSS g"); 84| 2| ret = DROPBEAR_FAILURE; ------------------ | | 112| 2|#define DROPBEAR_FAILURE -1 ------------------ 85| 2| goto out; 86| 2| } 87| | 88| 286| ret = DROPBEAR_SUCCESS; ------------------ | | 111| 286|#define DROPBEAR_SUCCESS 0 ------------------ 89| 286| TRACE(("leave buf_get_dss_pub_key: success")) 90| 314|out: 91| 314| if (ret == DROPBEAR_FAILURE) { ------------------ | | 112| 314|#define DROPBEAR_FAILURE -1 ------------------ | Branch (91:6): [True: 73, False: 241] ------------------ 92| | m_mp_free_multi(&key->p, &key->q, &key->g, &key->y, NULL); 93| 73| } 94| 314| return ret; 95| 286|} dss_key_free: 122| 2.80k|void dss_key_free(dropbear_dss_key *key) { 123| | 124| 2.80k| TRACE2(("enter dsa_key_free")) 125| 2.80k| if (key == NULL) { ------------------ | Branch (125:6): [True: 2.49k, False: 312] ------------------ 126| 2.49k| TRACE2(("enter dsa_key_free: key == NULL")) 127| 2.49k| return; 128| 2.49k| } 129| 312| m_mp_free_multi(&key->p, &key->q, &key->g, &key->y, &key->x, NULL); 130| | m_free(key); ------------------ | | 24| 312|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 312] | | ------------------ ------------------ 131| 312| TRACE2(("leave dsa_key_free")) 132| 312|} buf_dss_verify: 165| 240|int buf_dss_verify(buffer* buf, const dropbear_dss_key *key, const buffer *data_buf) { 166| 240| unsigned char msghash[SHA1_HASH_SIZE]; 167| 240| hash_state hs; 168| 240| int ret = DROPBEAR_FAILURE; ------------------ | | 112| 240|#define DROPBEAR_FAILURE -1 ------------------ 169| 240| DEF_MP_INT(val1); ------------------ | | 83| 240|#define DEF_MP_INT(X) mp_int X = {0, 0, 0, NULL} ------------------ 170| 240| DEF_MP_INT(val2); ------------------ | | 83| 240|#define DEF_MP_INT(X) mp_int X = {0, 0, 0, NULL} ------------------ 171| 240| DEF_MP_INT(val3); ------------------ | | 83| 240|#define DEF_MP_INT(X) mp_int X = {0, 0, 0, NULL} ------------------ 172| 240| DEF_MP_INT(val4); ------------------ | | 83| 240|#define DEF_MP_INT(X) mp_int X = {0, 0, 0, NULL} ------------------ 173| 240| char * string = NULL; 174| 240| unsigned int stringlen; 175| | 176| 240| TRACE(("enter buf_dss_verify")) 177| 240| dropbear_assert(key != NULL); ------------------ | | 86| 240|#define dropbear_assert(X) do { if (!(X)) { fail_assert(#X, __FILE__, __LINE__); } } while (0) | | ------------------ | | | Branch (86:37): [True: 0, False: 240] | | | Branch (86:93): [Folded, False: 240] | | ------------------ ------------------ 178| | 179| 240| m_mp_init_multi(&val1, &val2, &val3, &val4, NULL); 180| | 181| | /* get blob, check length */ 182| 240| string = buf_getstring(buf, &stringlen); 183| 240| if (stringlen != 2*SHA1_HASH_SIZE) { ------------------ | | 133| 240|#define SHA1_HASH_SIZE 20 ------------------ | Branch (183:6): [True: 14, False: 226] ------------------ 184| 14| goto out; 185| 14| } 186| | 187| |#if DEBUG_DSS_VERIFY 188| | printmpint("dss verify p", key->p); 189| | printmpint("dss verify q", key->q); 190| | printmpint("dss verify g", key->g); 191| | printmpint("dss verify y", key->y); 192| |#endif 193| | 194| | /* hash the data */ 195| 226| sha1_init(&hs); 196| 226| sha1_process(&hs, data_buf->data, data_buf->len); 197| 226| sha1_done(&hs, msghash); 198| | 199| | /* create the signature - s' and r' are the received signatures in buf */ 200| | /* w = (s')-1 mod q */ 201| | /* let val1 = s' */ 202| 226| bytes_to_mp(&val1, (const unsigned char*) &string[SHA1_HASH_SIZE], SHA1_HASH_SIZE); ------------------ | | 133| 226|#define SHA1_HASH_SIZE 20 ------------------ bytes_to_mp(&val1, (const unsigned char*) &string[SHA1_HASH_SIZE], SHA1_HASH_SIZE); ------------------ | | 133| 226|#define SHA1_HASH_SIZE 20 ------------------ 203| |#if DEBUG_DSS_VERIFY 204| | printmpint("dss verify s'", &val1); 205| |#endif 206| | 207| 226| if (mp_cmp(&val1, key->q) != MP_LT) { ------------------ | | 154| 226|#define MP_LT -1 /* less than */ ------------------ | Branch (207:6): [True: 2, False: 224] ------------------ 208| 2| TRACE(("verify failed, s' >= q")) 209| 2| goto out; 210| 2| } 211| 224| if (mp_cmp_d(&val1, 0) != MP_GT) { ------------------ | | 156| 224|#define MP_GT 1 /* greater than */ ------------------ | Branch (211:6): [True: 1, False: 223] ------------------ 212| 1| TRACE(("verify failed, s' <= 0")) 213| 1| goto out; 214| 1| } 215| | /* let val2 = w = (s')^-1 mod q*/ 216| 223| if (mp_invmod(&val1, key->q, &val2) != MP_OKAY) { ------------------ | | 161| 223|#define MP_OKAY 0 /* no error */ ------------------ | Branch (216:6): [True: 10, False: 213] ------------------ 217| 10| goto out; 218| 10| } 219| | 220| | /* u1 = ((SHA(M')w) mod q */ 221| | /* let val1 = SHA(M') = msghash */ 222| 213| bytes_to_mp(&val1, msghash, SHA1_HASH_SIZE); ------------------ | | 133| 213|#define SHA1_HASH_SIZE 20 ------------------ 223| |#if DEBUG_DSS_VERIFY 224| | printmpint("dss verify r'", &val1); 225| |#endif 226| | 227| | /* let val3 = u1 = ((SHA(M')w) mod q */ 228| 213| if (mp_mulmod(&val1, &val2, key->q, &val3) != MP_OKAY) { ------------------ | | 161| 213|#define MP_OKAY 0 /* no error */ ------------------ | Branch (228:6): [True: 0, False: 213] ------------------ 229| 0| goto out; 230| 0| } 231| | 232| | /* u2 = ((r')w) mod q */ 233| | /* let val1 = r' */ 234| 213| bytes_to_mp(&val1, (const unsigned char*) &string[0], SHA1_HASH_SIZE); ------------------ | | 133| 213|#define SHA1_HASH_SIZE 20 ------------------ 235| 213| if (mp_cmp(&val1, key->q) != MP_LT) { ------------------ | | 154| 213|#define MP_LT -1 /* less than */ ------------------ | Branch (235:6): [True: 6, False: 207] ------------------ 236| 6| TRACE(("verify failed, r' >= q")) 237| 6| goto out; 238| 6| } 239| 207| if (mp_cmp_d(&val1, 0) != MP_GT) { ------------------ | | 156| 207|#define MP_GT 1 /* greater than */ ------------------ | Branch (239:6): [True: 1, False: 206] ------------------ 240| 1| TRACE(("verify failed, r' <= 0")) 241| 1| goto out; 242| 1| } 243| | /* let val4 = u2 = ((r')w) mod q */ 244| 206| if (mp_mulmod(&val1, &val2, key->q, &val4) != MP_OKAY) { ------------------ | | 161| 206|#define MP_OKAY 0 /* no error */ ------------------ | Branch (244:6): [True: 0, False: 206] ------------------ 245| 0| goto out; 246| 0| } 247| | 248| | /* v = (((g)^u1 (y)^u2) mod p) mod q */ 249| | /* val2 = g^u1 mod p */ 250| 206| if (mp_exptmod(key->g, &val3, key->p, &val2) != MP_OKAY) { ------------------ | | 161| 206|#define MP_OKAY 0 /* no error */ ------------------ | Branch (250:6): [True: 0, False: 206] ------------------ 251| 0| goto out; 252| 0| } 253| | /* val3 = y^u2 mod p */ 254| 206| if (mp_exptmod(key->y, &val4, key->p, &val3) != MP_OKAY) { ------------------ | | 161| 206|#define MP_OKAY 0 /* no error */ ------------------ | Branch (254:6): [True: 0, False: 206] ------------------ 255| 0| goto out; 256| 0| } 257| | /* val4 = ((g)^u1 (y)^u2) mod p */ 258| 206| if (mp_mulmod(&val2, &val3, key->p, &val4) != MP_OKAY) { ------------------ | | 161| 206|#define MP_OKAY 0 /* no error */ ------------------ | Branch (258:6): [True: 0, False: 206] ------------------ 259| 0| goto out; 260| 0| } 261| | /* val2 = v = (((g)^u1 (y)^u2) mod p) mod q */ 262| 206| if (mp_mod(&val4, key->q, &val2) != MP_OKAY) { ------------------ | | 161| 206|#define MP_OKAY 0 /* no error */ ------------------ | Branch (262:6): [True: 0, False: 206] ------------------ 263| 0| goto out; 264| 0| } 265| | 266| | /* check whether signatures verify */ 267| 206| if (mp_cmp(&val2, &val1) == MP_EQ) { ------------------ | | 155| 206|#define MP_EQ 0 /* equal to */ ------------------ | Branch (267:6): [True: 119, False: 87] ------------------ 268| | /* good sig */ 269| 119| ret = DROPBEAR_SUCCESS; ------------------ | | 111| 119|#define DROPBEAR_SUCCESS 0 ------------------ 270| 119| } 271| | 272| 239|out: 273| 239| mp_clear_multi(&val1, &val2, &val3, &val4, NULL); 274| 239| m_free(string); ------------------ | | 24| 239|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 239] | | ------------------ ------------------ 275| | 276| 239| return ret; 277| | 278| 206|} dropbear_ecc_fill_dp: 47| 1|void dropbear_ecc_fill_dp() { 48| 1| struct dropbear_ecc_curve **curve; 49| | /* libtomcrypt guarantees they're ordered by size */ 50| 1| const ltc_ecc_set_type *dp = ltc_ecc_sets; 51| 4| for (curve = dropbear_ecc_curves; *curve; curve++) { ------------------ | Branch (51:36): [True: 3, False: 1] ------------------ 52| 5| for (;dp->size > 0; dp++) { ------------------ | Branch (52:9): [True: 5, False: 0] ------------------ 53| 5| if (dp->size == (*curve)->ltc_size) { ------------------ | Branch (53:8): [True: 3, False: 2] ------------------ 54| 3| (*curve)->dp = dp; 55| 3| break; 56| 3| } 57| 5| } 58| 3| if (!(*curve)->dp) { ------------------ | Branch (58:7): [True: 0, False: 3] ------------------ 59| 0| dropbear_exit("Missing ECC params %s", (*curve)->name); 60| 0| } 61| 3| } 62| 1|} curve_for_dp: 64| 306|struct dropbear_ecc_curve* curve_for_dp(const ltc_ecc_set_type *dp) { 65| 306| struct dropbear_ecc_curve **curve = NULL; 66| 472| for (curve = dropbear_ecc_curves; *curve; curve++) { ------------------ | Branch (66:36): [True: 472, False: 0] ------------------ 67| 472| if ((*curve)->dp == dp) { ------------------ | Branch (67:7): [True: 306, False: 166] ------------------ 68| 306| break; 69| 306| } 70| 472| } 71| 306| assert(*curve); ------------------ | Branch (71:2): [True: 0, False: 306] | Branch (71:2): [True: 306, False: 0] ------------------ 72| 306| return *curve; 73| 306|} new_ecc_key: 75| 513|ecc_key * new_ecc_key(void) { 76| 513| ecc_key *key = m_malloc(sizeof(*key)); 77| 513| m_mp_alloc_init_multi((mp_int**)&key->pubkey.x, (mp_int**)&key->pubkey.y, 78| | (mp_int**)&key->pubkey.z, (mp_int**)&key->k, NULL); 79| 513| return key; 80| 513|} buf_get_ecc_raw_pubkey: 147| 583|ecc_key * buf_get_ecc_raw_pubkey(buffer *buf, const struct dropbear_ecc_curve *curve) { 148| 583| ecc_key *key = NULL; 149| 583| int ret = DROPBEAR_FAILURE; ------------------ | | 112| 583|#define DROPBEAR_FAILURE -1 ------------------ 150| 583| const unsigned int size = curve->dp->size; 151| 583| unsigned char first; 152| | 153| 583| TRACE(("enter buf_get_ecc_raw_pubkey")) 154| | 155| 583| buf_setpos(buf, 0); 156| 583| first = buf_getbyte(buf); 157| 583| if (first == 2 || first == 3) { ------------------ | Branch (157:6): [True: 9, False: 574] | Branch (157:20): [True: 2, False: 572] ------------------ 158| 4| dropbear_log(LOG_WARNING, "Dropbear doesn't support ECC point compression"); 159| 4| return NULL; 160| 4| } 161| 579| if (first != 4 || buf->len != 1+2*size) { ------------------ | Branch (161:6): [True: 38, False: 541] | Branch (161:20): [True: 28, False: 513] ------------------ 162| 59| TRACE(("leave, wrong size")) 163| 59| return NULL; 164| 59| } 165| | 166| 520| key = new_ecc_key(); 167| 520| key->dp = curve->dp; 168| | 169| 520| if (mp_from_ubin(key->pubkey.x, buf_getptr(buf, size), size) != MP_OKAY) { ------------------ | | 161| 520|#define MP_OKAY 0 /* no error */ ------------------ | Branch (169:6): [True: 0, False: 520] ------------------ 170| 0| TRACE(("failed to read x")) 171| 0| goto out; 172| 0| } 173| 520| buf_incrpos(buf, size); 174| | 175| 520| if (mp_from_ubin(key->pubkey.y, buf_getptr(buf, size), size) != MP_OKAY) { ------------------ | | 161| 520|#define MP_OKAY 0 /* no error */ ------------------ | Branch (175:6): [True: 0, False: 520] ------------------ 176| 0| TRACE(("failed to read y")) 177| 0| goto out; 178| 0| } 179| 520| buf_incrpos(buf, size); 180| | 181| 520| mp_set(key->pubkey.z, 1); 182| | 183| 520| if (ecc_is_point(key) != CRYPT_OK) { ------------------ | Branch (183:6): [True: 204, False: 316] ------------------ 184| 204| TRACE(("failed, not a point")) 185| 204| goto out; 186| 204| } 187| | 188| | /* SEC1 3.2.3.1 Check that Q != 0 */ 189| 316| if (mp_cmp_d(key->pubkey.x, 0) == LTC_MP_EQ) { ------------------ | | 13| 316|#define LTC_MP_EQ 0 ------------------ | Branch (189:6): [True: 0, False: 316] ------------------ 190| 0| TRACE(("failed, x == 0")) 191| 0| goto out; 192| 0| } 193| 316| if (mp_cmp_d(key->pubkey.y, 0) == LTC_MP_EQ) { ------------------ | | 13| 316|#define LTC_MP_EQ 0 ------------------ | Branch (193:6): [True: 0, False: 316] ------------------ 194| 0| TRACE(("failed, y == 0")) 195| 0| goto out; 196| 0| } 197| | 198| 316| ret = DROPBEAR_SUCCESS; ------------------ | | 111| 316|#define DROPBEAR_SUCCESS 0 ------------------ 199| | 200| 513| out: 201| 513| if (ret == DROPBEAR_FAILURE) { ------------------ | | 112| 513|#define DROPBEAR_FAILURE -1 ------------------ | Branch (201:6): [True: 204, False: 309] ------------------ 202| 204| if (key) { ------------------ | Branch (202:7): [True: 204, False: 0] ------------------ 203| 204| ecc_free(key); 204| 204| m_free(key); ------------------ | | 24| 204|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 204] | | ------------------ ------------------ 205| 204| key = NULL; 206| 204| } 207| 204| } 208| | 209| 513| return key; 210| | 211| 316|} ecc.c:ecc_is_point: 85| 513|{ 86| 513| mp_int *prime, *b, *t1, *t2; 87| 513| int err; 88| | 89| 513| m_mp_alloc_init_multi(&prime, &b, &t1, &t2, NULL); 90| | 91| | /* load prime and b */ 92| 513| if ((err = mp_read_radix(prime, key->dp->prime, 16)) != CRYPT_OK) { goto error; } ------------------ | Branch (92:6): [True: 0, False: 513] ------------------ 93| 513| if ((err = mp_read_radix(b, key->dp->B, 16)) != CRYPT_OK) { goto error; } ------------------ | Branch (93:6): [True: 0, False: 513] ------------------ 94| | 95| | /* compute y^2 */ 96| 513| if ((err = mp_sqr(key->pubkey.y, t1)) != CRYPT_OK) { goto error; } ------------------ | Branch (96:6): [True: 0, False: 513] ------------------ 97| | 98| | /* compute x^3 */ 99| 513| if ((err = mp_sqr(key->pubkey.x, t2)) != CRYPT_OK) { goto error; } ------------------ | Branch (99:6): [True: 0, False: 513] ------------------ 100| 513| if ((err = mp_mod(t2, prime, t2)) != CRYPT_OK) { goto error; } ------------------ | Branch (100:6): [True: 0, False: 513] ------------------ 101| 513| if ((err = mp_mul(key->pubkey.x, t2, t2)) != CRYPT_OK) { goto error; } ------------------ | Branch (101:6): [True: 0, False: 513] ------------------ 102| | 103| | /* compute y^2 - x^3 */ 104| 513| if ((err = mp_sub(t1, t2, t1)) != CRYPT_OK) { goto error; } ------------------ | Branch (104:6): [True: 0, False: 513] ------------------ 105| | 106| | /* compute y^2 - x^3 + 3x */ 107| 513| if ((err = mp_add(t1, key->pubkey.x, t1)) != CRYPT_OK) { goto error; } ------------------ | Branch (107:6): [True: 0, False: 513] ------------------ 108| 513| if ((err = mp_add(t1, key->pubkey.x, t1)) != CRYPT_OK) { goto error; } ------------------ | Branch (108:6): [True: 0, False: 513] ------------------ 109| 513| if ((err = mp_add(t1, key->pubkey.x, t1)) != CRYPT_OK) { goto error; } ------------------ | Branch (109:6): [True: 0, False: 513] ------------------ 110| 513| if ((err = mp_mod(t1, prime, t1)) != CRYPT_OK) { goto error; } ------------------ | Branch (110:6): [True: 0, False: 513] ------------------ 111| 513| while (mp_cmp_d(t1, 0) == LTC_MP_LT) { ------------------ | | 12| 513|#define LTC_MP_LT -1 ------------------ | Branch (111:9): [True: 0, False: 513] ------------------ 112| 0| if ((err = mp_add(t1, prime, t1)) != CRYPT_OK) { goto error; } ------------------ | Branch (112:7): [True: 0, False: 0] ------------------ 113| 0| } 114| 513| while (mp_cmp(t1, prime) != LTC_MP_LT) { ------------------ | | 12| 513|#define LTC_MP_LT -1 ------------------ | Branch (114:9): [True: 0, False: 513] ------------------ 115| 0| if ((err = mp_sub(t1, prime, t1)) != CRYPT_OK) { goto error; } ------------------ | Branch (115:7): [True: 0, False: 0] ------------------ 116| 0| } 117| | 118| | /* compare to b */ 119| 513| if (mp_cmp(t1, b) != LTC_MP_EQ) { ------------------ | | 13| 513|#define LTC_MP_EQ 0 ------------------ | Branch (119:6): [True: 204, False: 309] ------------------ 120| 204| err = CRYPT_INVALID_PACKET; 121| 309| } else { 122| 309| err = CRYPT_OK; 123| 309| } 124| | 125| 513| error: 126| 513| mp_clear_multi(prime, b, t1, t2, NULL); 127| 513| m_free(prime); ------------------ | | 24| 513|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 513] | | ------------------ ------------------ 128| 513| m_free(b); ------------------ | | 24| 513|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 513] | | ------------------ ------------------ 129| 513| m_free(t1); ------------------ | | 24| 513|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 513] | | ------------------ ------------------ 130| | m_free(t2); ------------------ | | 24| 513|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 513] | | ------------------ ------------------ 131| 513| return err; 132| 513|} signkey_is_ecdsa: 11| 3.20k|{ 12| 3.20k| return type == DROPBEAR_SIGNKEY_ECDSA_NISTP256 ------------------ | Branch (12:9): [True: 657, False: 2.54k] ------------------ 13| 2.54k| || type == DROPBEAR_SIGNKEY_ECDSA_NISTP384 ------------------ | Branch (13:6): [True: 162, False: 2.38k] ------------------ 14| 2.38k| || type == DROPBEAR_SIGNKEY_ECDSA_NISTP521; ------------------ | Branch (14:6): [True: 184, False: 2.19k] ------------------ 15| 3.20k|} buf_get_ecdsa_pub_key: 77| 792|ecc_key *buf_get_ecdsa_pub_key(buffer* buf) { 78| 792| unsigned char *key_ident = NULL, *identifier = NULL; 79| 792| unsigned int key_ident_len, identifier_len; 80| 792| buffer *q_buf = NULL; 81| 792| struct dropbear_ecc_curve **curve; 82| 792| ecc_key *new_key = NULL; 83| | 84| | /* string "ecdsa-sha2-[identifier]" or "sk-ecdsa-sha2-nistp256@openssh.com" */ 85| 792| key_ident = (unsigned char*)buf_getstring(buf, &key_ident_len); 86| | /* string "[identifier]" */ 87| 792| identifier = (unsigned char*)buf_getstring(buf, &identifier_len); 88| | 89| 792| if (strcmp (key_ident, "sk-ecdsa-sha2-nistp256@openssh.com") == 0) { ------------------ | Branch (89:6): [True: 94, False: 698] ------------------ 90| 94| if (strcmp (identifier, "nistp256") != 0) { ------------------ | Branch (90:7): [True: 77, False: 17] ------------------ 91| 77| TRACE(("mismatching identifiers")) 92| 77| goto out; 93| 77| } 94| 698| } else { 95| 698| if (key_ident_len != identifier_len + strlen ("ecdsa-sha2-")) { ------------------ | Branch (95:7): [True: 30, False: 668] ------------------ 96| 30| TRACE(("Bad identifier lengths")) 97| 30| goto out; 98| 30| } 99| 668| if (memcmp(&key_ident[strlen ("ecdsa-sha2-")], identifier, identifier_len) != 0) { ------------------ | Branch (99:7): [True: 18, False: 650] ------------------ 100| 18| TRACE(("mismatching identifiers")) 101| 18| goto out; 102| 18| } 103| 668| } 104| | 105| 992| for (curve = dropbear_ecc_curves; *curve; curve++) { ------------------ | Branch (105:36): [True: 987, False: 5] ------------------ 106| 987| if (strcmp((char*)identifier, (*curve)->name) == 0) { ------------------ | Branch (106:7): [True: 662, False: 325] ------------------ 107| 662| break; 108| 662| } 109| 987| } 110| 667| if (!*curve) { ------------------ | Branch (110:6): [True: 0, False: 667] ------------------ 111| 0| TRACE(("couldn't match ecc curve")) 112| 0| goto out; 113| 0| } 114| | 115| | /* string Q */ 116| 667| q_buf = buf_getstringbuf(buf); 117| 667| new_key = buf_get_ecc_raw_pubkey(q_buf, *curve); 118| | 119| 701|out: 120| 701| m_free(key_ident); ------------------ | | 24| 701|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 701] | | ------------------ ------------------ 121| 701| m_free(identifier); ------------------ | | 24| 701|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 701] | | ------------------ ------------------ 122| 701| if (q_buf) { ------------------ | Branch (122:6): [True: 576, False: 125] ------------------ 123| 576| buf_free(q_buf); 124| | q_buf = NULL; 125| 576| } 126| 701| TRACE(("leave buf_get_ecdsa_pub_key")) 127| 701| return new_key; 128| 667|} buf_ecdsa_verify: 281| 306|int buf_ecdsa_verify(buffer *buf, const ecc_key *key, const buffer *data_buf) { 282| | /* Based on libtomcrypt's ecc_verify_hash but without the asn1 */ 283| 306| int ret = DROPBEAR_FAILURE; ------------------ | | 112| 306|#define DROPBEAR_FAILURE -1 ------------------ 284| 306| hash_state hs; 285| 306| struct dropbear_ecc_curve *curve = NULL; 286| 306| unsigned char hash[64]; 287| 306| ecc_point *mG = NULL, *mQ = NULL; 288| 306| void *r = NULL, *s = NULL, *v = NULL, *w = NULL, *u1 = NULL, *u2 = NULL, 289| 306| *e = NULL, *p = NULL, *m = NULL; 290| 306| void *mp = NULL; 291| | 292| | /* verify 293| | * 294| | * w = s^-1 mod n 295| | * u1 = xw 296| | * u2 = rw 297| | * X = u1*G + u2*Q 298| | * v = X_x1 mod n 299| | * accept if v == r 300| | */ 301| | 302| 306| TRACE(("buf_ecdsa_verify")) 303| 306| curve = curve_for_dp(key->dp); 304| | 305| 306| mG = ltc_ecc_new_point(); 306| 306| mQ = ltc_ecc_new_point(); 307| 306| if (ltc_init_multi(&r, &s, &v, &w, &u1, &u2, &p, &e, &m, NULL) != CRYPT_OK ------------------ | Branch (307:6): [True: 0, False: 306] ------------------ 308| 306| || !mG ------------------ | Branch (308:6): [True: 0, False: 306] ------------------ 309| 306| || !mQ) { ------------------ | Branch (309:6): [True: 0, False: 306] ------------------ 310| 0| dropbear_exit("ECC error"); 311| 0| } 312| | 313| 306| if (buf_get_ecdsa_verify_params(buf, r, s) != DROPBEAR_SUCCESS) { ------------------ | | 111| 306|#define DROPBEAR_SUCCESS 0 ------------------ | Branch (313:6): [True: 36, False: 270] ------------------ 314| 36| goto out; 315| 36| } 316| | 317| 270| curve->hash_desc->init(&hs); 318| 270| curve->hash_desc->process(&hs, data_buf->data, data_buf->len); 319| 270| curve->hash_desc->done(&hs, hash); 320| | 321| 270| if (ltc_mp.unsigned_read(e, hash, curve->hash_desc->hashsize) != CRYPT_OK) { ------------------ | Branch (321:6): [True: 0, False: 270] ------------------ 322| 0| goto out; 323| 0| } 324| | 325| | /* get the order */ 326| 270| if (ltc_mp.read_radix(p, (char *)key->dp->order, 16) != CRYPT_OK) { ------------------ | Branch (326:6): [True: 0, False: 270] ------------------ 327| 0| goto out; 328| 0| } 329| | 330| | /* get the modulus */ 331| 270| if (ltc_mp.read_radix(m, (char *)key->dp->prime, 16) != CRYPT_OK) { ------------------ | Branch (331:6): [True: 0, False: 270] ------------------ 332| 0| goto out; 333| 0| } 334| | 335| | /* check for zero */ 336| 270| if (ltc_mp.compare_d(r, 0) == LTC_MP_EQ ------------------ | | 13| 540|#define LTC_MP_EQ 0 ------------------ | Branch (336:6): [True: 7, False: 263] ------------------ 337| 263| || ltc_mp.compare_d(s, 0) == LTC_MP_EQ ------------------ | | 13| 533|#define LTC_MP_EQ 0 ------------------ | Branch (337:6): [True: 1, False: 262] ------------------ 338| 262| || ltc_mp.compare(r, p) != LTC_MP_LT ------------------ | | 12| 532|#define LTC_MP_LT -1 ------------------ | Branch (338:6): [True: 1, False: 261] ------------------ 339| 261| || ltc_mp.compare(s, p) != LTC_MP_LT) { ------------------ | | 12| 261|#define LTC_MP_LT -1 ------------------ | Branch (339:6): [True: 1, False: 260] ------------------ 340| 6| goto out; 341| 6| } 342| | 343| | /* w = s^-1 mod n */ 344| 264| if (ltc_mp.invmod(s, p, w) != CRYPT_OK) { ------------------ | Branch (344:6): [True: 0, False: 264] ------------------ 345| 0| goto out; 346| 0| } 347| | 348| | /* u1 = ew */ 349| 264| if (ltc_mp.mulmod(e, w, p, u1) != CRYPT_OK) { ------------------ | Branch (349:6): [True: 0, False: 264] ------------------ 350| 0| goto out; 351| 0| } 352| | 353| | /* u2 = rw */ 354| 264| if (ltc_mp.mulmod(r, w, p, u2) != CRYPT_OK) { ------------------ | Branch (354:6): [True: 0, False: 264] ------------------ 355| 0| goto out; 356| 0| } 357| | 358| | /* find mG and mQ */ 359| 264| if (ltc_mp.read_radix(mG->x, (char *)key->dp->Gx, 16) != CRYPT_OK) { ------------------ | Branch (359:6): [True: 0, False: 264] ------------------ 360| 0| goto out; 361| 0| } 362| 264| if (ltc_mp.read_radix(mG->y, (char *)key->dp->Gy, 16) != CRYPT_OK) { ------------------ | Branch (362:6): [True: 0, False: 264] ------------------ 363| 0| goto out; 364| 0| } 365| 264| if (ltc_mp.set_int(mG->z, 1) != CRYPT_OK) { ------------------ | Branch (365:6): [True: 0, False: 264] ------------------ 366| 0| goto out; 367| 0| } 368| | 369| 264| if (ltc_mp.copy(key->pubkey.x, mQ->x) != CRYPT_OK ------------------ | Branch (369:6): [True: 4, False: 260] ------------------ 370| 260| || ltc_mp.copy(key->pubkey.y, mQ->y) != CRYPT_OK ------------------ | Branch (370:6): [True: 0, False: 260] ------------------ 371| 260| || ltc_mp.copy(key->pubkey.z, mQ->z) != CRYPT_OK) { ------------------ | Branch (371:6): [True: 0, False: 260] ------------------ 372| 0| goto out; 373| 0| } 374| | 375| | /* compute u1*mG + u2*mQ = mG */ 376| 264| if (ltc_mp.ecc_mul2add == NULL) { ------------------ | Branch (376:6): [True: 0, False: 264] ------------------ 377| 0| if (ltc_mp.ecc_ptmul(u1, mG, mG, m, 0) != CRYPT_OK) { ------------------ | Branch (377:7): [True: 0, False: 0] ------------------ 378| 0| goto out; 379| 0| } 380| 0| if (ltc_mp.ecc_ptmul(u2, mQ, mQ, m, 0) != CRYPT_OK) { ------------------ | Branch (380:7): [True: 0, False: 0] ------------------ 381| 0| goto out; 382| 0| } 383| | 384| | /* find the montgomery mp */ 385| 0| if (ltc_mp.montgomery_setup(m, &mp) != CRYPT_OK) { ------------------ | Branch (385:7): [True: 0, False: 0] ------------------ 386| 0| goto out; 387| 0| } 388| | 389| | /* add them */ 390| 0| if (ltc_mp.ecc_ptadd(mQ, mG, mG, m, mp) != CRYPT_OK) { ------------------ | Branch (390:7): [True: 0, False: 0] ------------------ 391| 0| goto out; 392| 0| } 393| | 394| | /* reduce */ 395| 0| if (ltc_mp.ecc_map(mG, m, mp) != CRYPT_OK) { ------------------ | Branch (395:7): [True: 0, False: 0] ------------------ 396| 0| goto out; 397| 0| } 398| 264| } else { 399| | /* use Shamir's trick to compute u1*mG + u2*mQ using half of the doubles */ 400| 264| if (ltc_mp.ecc_mul2add(mG, u1, mQ, u2, mG, m) != CRYPT_OK) { ------------------ | Branch (400:7): [True: 0, False: 264] ------------------ 401| 0| goto out; 402| 0| } 403| 264| } 404| | 405| | /* v = X_x1 mod n */ 406| 264| if (ltc_mp.mpdiv(mG->x, p, NULL, v) != CRYPT_OK) { ------------------ | Branch (406:6): [True: 0, False: 264] ------------------ 407| 0| goto out; 408| 0| } 409| | 410| | /* does v == r */ 411| 264| if (ltc_mp.compare(v, r) == LTC_MP_EQ) { ------------------ | | 13| 264|#define LTC_MP_EQ 0 ------------------ | Branch (411:6): [True: 0, False: 264] ------------------ 412| 0| ret = DROPBEAR_SUCCESS; ------------------ | | 111| 0|#define DROPBEAR_SUCCESS 0 ------------------ 413| 0| } 414| | 415| 302|out: 416| 302| ltc_ecc_del_point(mG); 417| 302| ltc_ecc_del_point(mQ); 418| 302| ltc_deinit_multi(r, s, v, w, u1, u2, p, e, m, NULL); 419| 302| if (mp != NULL) { ------------------ | Branch (419:6): [True: 0, False: 302] ------------------ 420| 0| ltc_mp.montgomery_deinit(mp); 421| 0| } 422| 302| return ret; 423| 264|} ecdsa.c:buf_get_ecdsa_verify_params: 258| 306| void *r, void* s) { 259| 306| int ret = DROPBEAR_FAILURE; ------------------ | | 112| 306|#define DROPBEAR_FAILURE -1 ------------------ 260| 306| unsigned int sig_len; 261| 306| unsigned int sig_pos; 262| | 263| 306| sig_len = buf_getint(buf); 264| 306| sig_pos = buf->pos; 265| 306| if (buf_getmpint(buf, r) != DROPBEAR_SUCCESS) { ------------------ | | 111| 306|#define DROPBEAR_SUCCESS 0 ------------------ | Branch (265:6): [True: 3, False: 303] ------------------ 266| 3| goto out; 267| 3| } 268| 303| if (buf_getmpint(buf, s) != DROPBEAR_SUCCESS) { ------------------ | | 111| 303|#define DROPBEAR_SUCCESS 0 ------------------ | Branch (268:6): [True: 1, False: 302] ------------------ 269| 1| goto out; 270| 1| } 271| 302| if (buf->pos - sig_pos != sig_len) { ------------------ | Branch (271:6): [True: 32, False: 270] ------------------ 272| 32| goto out; 273| 32| } 274| 270| ret = DROPBEAR_SUCCESS; ------------------ | | 111| 270|#define DROPBEAR_SUCCESS 0 ------------------ 275| | 276| 302|out: 277| 302| return ret; 278| 270|} buf_get_ed25519_pub_key: 42| 361| enum signkey_type expect_keytype) { 43| | 44| | 45| 361| unsigned int len, typelen; 46| 361| char *keytype = NULL; 47| 361| enum signkey_type buf_keytype; 48| | 49| 361| TRACE(("enter buf_get_ed25519_pub_key")) 50| 361| dropbear_assert(key != NULL); ------------------ | | 86| 361|#define dropbear_assert(X) do { if (!(X)) { fail_assert(#X, __FILE__, __LINE__); } } while (0) | | ------------------ | | | Branch (86:37): [True: 0, False: 361] | | | Branch (86:93): [Folded, False: 361] | | ------------------ ------------------ 51| | 52| | /* consume and check the key string */ 53| 361| keytype = buf_getstring(buf, &typelen); 54| 361| buf_keytype = signkey_type_from_name(keytype, typelen); 55| 361| m_free(keytype); ------------------ | | 24| 361|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 361] | | ------------------ ------------------ 56| 361| if (buf_keytype != expect_keytype) { ------------------ | Branch (56:6): [True: 0, False: 361] ------------------ 57| 0| TRACE(("leave buf_get_ed25519_pub_key: mismatch key type")) 58| 0| return DROPBEAR_FAILURE; ------------------ | | 112| 0|#define DROPBEAR_FAILURE -1 ------------------ 59| 0| } 60| | 61| 361| len = buf_getint(buf); 62| 361| if (len != CURVE25519_LEN || buf->len - buf->pos < len) { ------------------ | | 34| 722|#define CURVE25519_LEN 32 ------------------ | Branch (62:6): [True: 55, False: 306] | Branch (62:31): [True: 9, False: 297] ------------------ 63| 58| TRACE(("leave buf_get_ed25519_pub_key: failure")) 64| 58| return DROPBEAR_FAILURE; ------------------ | | 112| 58|#define DROPBEAR_FAILURE -1 ------------------ 65| 58| } 66| | 67| 303| m_burn(key->priv, CURVE25519_LEN); ------------------ | | 34| 303|#define CURVE25519_LEN 32 ------------------ 68| 303| memcpy(key->pub, buf_getptr(buf, CURVE25519_LEN), CURVE25519_LEN); ------------------ | | 34| 303|#define CURVE25519_LEN 32 ------------------ memcpy(key->pub, buf_getptr(buf, CURVE25519_LEN), CURVE25519_LEN); ------------------ | | 34| 303|#define CURVE25519_LEN 32 ------------------ 69| 303| buf_incrpos(buf, CURVE25519_LEN); ------------------ | | 34| 303|#define CURVE25519_LEN 32 ------------------ 70| | 71| 303| TRACE(("leave buf_get_ed25519_pub_key: success")) 72| 303| return DROPBEAR_SUCCESS; ------------------ | | 111| 303|#define DROPBEAR_SUCCESS 0 ------------------ 73| 361|} ed25519_key_free: 103| 2.73k|void ed25519_key_free(dropbear_ed25519_key *key) { 104| | 105| 2.73k| TRACE2(("enter ed25519_key_free")) 106| | 107| 2.73k| if (key == NULL) { ------------------ | Branch (107:6): [True: 2.52k, False: 209] ------------------ 108| 2.52k| TRACE2(("leave ed25519_key_free: key == NULL")) 109| 2.52k| return; 110| 2.52k| } 111| 209| m_burn(key->priv, CURVE25519_LEN); ------------------ | | 34| 209|#define CURVE25519_LEN 32 ------------------ 112| 209| m_free(key); ------------------ | | 24| 209|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 209] | | ------------------ ------------------ 113| | 114| 209| TRACE2(("leave ed25519_key_free")) 115| 209|} buf_ed25519_verify: 163| 94|int buf_ed25519_verify(buffer *buf, const dropbear_ed25519_key *key, const buffer *data_buf) { 164| | 165| 94| int ret = DROPBEAR_FAILURE; ------------------ | | 112| 94|#define DROPBEAR_FAILURE -1 ------------------ 166| 94| unsigned char *s; 167| 94| unsigned long slen; 168| | 169| 94| TRACE(("enter buf_ed25519_verify")) 170| 94| dropbear_assert(key != NULL); ------------------ | | 86| 94|#define dropbear_assert(X) do { if (!(X)) { fail_assert(#X, __FILE__, __LINE__); } } while (0) | | ------------------ | | | Branch (86:37): [True: 0, False: 94] | | | Branch (86:93): [Folded, False: 94] | | ------------------ ------------------ 171| | 172| 94| slen = buf_getint(buf); 173| 94| if (slen != 64 || buf->len - buf->pos < slen) { ------------------ | Branch (173:6): [True: 41, False: 53] | Branch (173:20): [True: 11, False: 42] ------------------ 174| 51| TRACE(("leave buf_ed25519_verify: bad size")) 175| 51| goto out; 176| 51| } 177| 43| s = buf_getptr(buf, slen); 178| | 179| 43| if (dropbear_ed25519_verify(data_buf->data, data_buf->len, ------------------ | Branch (179:6): [True: 0, False: 43] ------------------ 180| 43| s, slen, key->pub) == 0) { 181| | /* signature is valid */ 182| 0| TRACE(("leave buf_ed25519_verify: success!")) 183| 0| ret = DROPBEAR_SUCCESS; ------------------ | | 111| 0|#define DROPBEAR_SUCCESS 0 ------------------ 184| 0| } 185| | 186| 93|out: 187| 93| TRACE(("leave buf_ed25519_verify: ret %d", ret)) 188| 93| return ret; 189| 43|} buf_get_rsa_pub_key: 53| 1.19k|int buf_get_rsa_pub_key(buffer* buf, dropbear_rsa_key *key) { 54| | 55| 1.19k| int ret = DROPBEAR_FAILURE; ------------------ | | 112| 1.19k|#define DROPBEAR_FAILURE -1 ------------------ 56| 1.19k| TRACE(("enter buf_get_rsa_pub_key")) 57| 1.19k| dropbear_assert(key != NULL); ------------------ | | 86| 1.19k|#define dropbear_assert(X) do { if (!(X)) { fail_assert(#X, __FILE__, __LINE__); } } while (0) | | ------------------ | | | Branch (86:37): [True: 0, False: 1.19k] | | | Branch (86:93): [Folded, False: 1.19k] | | ------------------ ------------------ 58| 1.19k| m_mp_alloc_init_multi(&key->e, &key->n, NULL); 59| 1.19k| key->d = NULL; 60| 1.19k| key->p = NULL; 61| 1.19k| key->q = NULL; 62| | 63| 1.19k| buf_incrpos(buf, 4+SSH_SIGNKEY_RSA_LEN); /* int + "ssh-rsa" */ ------------------ | | 117| 1.19k|#define SSH_SIGNKEY_RSA_LEN 7 ------------------ 64| | 65| 1.19k| if (buf_getmpint(buf, key->e) == DROPBEAR_FAILURE ------------------ | | 112| 2.38k|#define DROPBEAR_FAILURE -1 ------------------ | Branch (65:6): [True: 72, False: 1.11k] ------------------ 66| 1.11k| || buf_getmpint(buf, key->n) == DROPBEAR_FAILURE) { ------------------ | | 112| 1.11k|#define DROPBEAR_FAILURE -1 ------------------ | Branch (66:6): [True: 100, False: 1.01k] ------------------ 67| 49| TRACE(("leave buf_get_rsa_pub_key: failure")) 68| 49| goto out; 69| 49| } 70| | 71| 1.14k| if (mp_count_bits(key->n) < MIN_RSA_KEYLEN) { ------------------ | | 69| 1.14k|#define MIN_RSA_KEYLEN 1024 ------------------ | Branch (71:6): [True: 81, False: 1.06k] ------------------ 72| 81| dropbear_log(LOG_WARNING, "RSA key too short"); 73| 81| goto out; 74| 81| } 75| | 76| | /* 64 bit is limit used by openssl, so we won't block any keys in the wild */ 77| 1.06k| if (mp_count_bits(key->e) > 64) { ------------------ | Branch (77:6): [True: 7, False: 1.05k] ------------------ 78| 7| dropbear_log(LOG_WARNING, "RSA key bad e"); 79| 7| goto out; 80| 7| } 81| | 82| 1.05k| TRACE(("leave buf_get_rsa_pub_key: success")) 83| 1.05k| ret = DROPBEAR_SUCCESS; ------------------ | | 111| 1.05k|#define DROPBEAR_SUCCESS 0 ------------------ 84| 1.06k|out: 85| 1.06k| if (ret == DROPBEAR_FAILURE) { ------------------ | | 112| 1.06k|#define DROPBEAR_FAILURE -1 ------------------ | Branch (85:6): [True: 137, False: 930] ------------------ 86| | m_mp_free_multi(&key->e, &key->n, NULL); 87| 137| } 88| 1.06k| return ret; 89| 1.05k|} rsa_key_free: 143| 3.70k|void rsa_key_free(dropbear_rsa_key *key) { 144| | 145| 3.70k| TRACE2(("enter rsa_key_free")) 146| | 147| 3.70k| if (key == NULL) { ------------------ | Branch (147:6): [True: 2.67k, False: 1.03k] ------------------ 148| 2.67k| TRACE2(("leave rsa_key_free: key == NULL")) 149| 2.67k| return; 150| 2.67k| } 151| 1.03k| m_mp_free_multi(&key->d, &key->e, &key->p, &key->q, &key->n, NULL); 152| | m_free(key); ------------------ | | 24| 1.03k|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 1.03k] | | ------------------ ------------------ 153| 1.03k| TRACE2(("leave rsa_key_free")) 154| 1.03k|} buf_rsa_verify: 201| 896| enum signature_type sigtype, const buffer *data_buf) { 202| 896| unsigned int slen; 203| 896| DEF_MP_INT(rsa_s); ------------------ | | 83| 896|#define DEF_MP_INT(X) mp_int X = {0, 0, 0, NULL} ------------------ 204| 896| DEF_MP_INT(rsa_mdash); ------------------ | | 83| 896|#define DEF_MP_INT(X) mp_int X = {0, 0, 0, NULL} ------------------ 205| 896| DEF_MP_INT(rsa_em); ------------------ | | 83| 896|#define DEF_MP_INT(X) mp_int X = {0, 0, 0, NULL} ------------------ 206| 896| int ret = DROPBEAR_FAILURE; ------------------ | | 112| 896|#define DROPBEAR_FAILURE -1 ------------------ 207| | 208| 896| TRACE(("enter buf_rsa_verify")) 209| | 210| 896| dropbear_assert(key != NULL); ------------------ | | 86| 896|#define dropbear_assert(X) do { if (!(X)) { fail_assert(#X, __FILE__, __LINE__); } } while (0) | | ------------------ | | | Branch (86:37): [True: 0, False: 896] | | | Branch (86:93): [Folded, False: 896] | | ------------------ ------------------ 211| | 212| 896| m_mp_init_multi(&rsa_mdash, &rsa_s, &rsa_em, NULL); 213| | 214| 896| slen = buf_getint(buf); 215| 896| if (slen != (unsigned int)mp_ubin_size(key->n)) { ------------------ | Branch (215:6): [True: 51, False: 845] ------------------ 216| 51| TRACE(("bad size")) 217| 51| goto out; 218| 51| } 219| | 220| 845| if (mp_from_ubin(&rsa_s, buf_getptr(buf, buf->len - buf->pos), ------------------ | Branch (220:6): [True: 0, False: 845] ------------------ 221| 845| buf->len - buf->pos) != MP_OKAY) { ------------------ | | 161| 845|#define MP_OKAY 0 /* no error */ ------------------ 222| 0| TRACE(("failed reading rsa_s")) 223| 0| goto out; 224| 0| } 225| | 226| | /* check that s <= n-1 */ 227| 845| if (mp_cmp(&rsa_s, key->n) != MP_LT) { ------------------ | | 154| 845|#define MP_LT -1 /* less than */ ------------------ | Branch (227:6): [True: 38, False: 807] ------------------ 228| 38| TRACE(("s > n-1")) 229| 38| goto out; 230| 38| } 231| | 232| | /* create the magic PKCS padded value */ 233| 807| rsa_pad_em(key, data_buf, &rsa_em, sigtype); 234| | 235| 807| if (mp_exptmod(&rsa_s, key->e, key->n, &rsa_mdash) != MP_OKAY) { ------------------ | | 161| 807|#define MP_OKAY 0 /* no error */ ------------------ | Branch (235:6): [True: 0, False: 807] ------------------ 236| 0| TRACE(("failed exptmod rsa_s")) 237| 0| goto out; 238| 0| } 239| | 240| 807| if (mp_cmp(&rsa_em, &rsa_mdash) == MP_EQ) { ------------------ | | 155| 807|#define MP_EQ 0 /* equal to */ ------------------ | Branch (240:6): [True: 0, False: 807] ------------------ 241| | /* signature is valid */ 242| 0| TRACE(("success!")) 243| 0| ret = DROPBEAR_SUCCESS; ------------------ | | 111| 0|#define DROPBEAR_SUCCESS 0 ------------------ 244| 0| } 245| | 246| 894|out: 247| | mp_clear_multi(&rsa_mdash, &rsa_s, &rsa_em, NULL); 248| 894| TRACE(("leave buf_rsa_verify: ret %d", ret)) 249| 894| return ret; 250| 807|} rsa.c:rsa_pad_em: 398| 805| const buffer *data_buf, mp_int * rsa_em, enum signature_type sigtype) { 399| | /* EM = 0x00 || 0x01 || PS || 0x00 || T 400| | PS is padding of 0xff to make EM the size of key->n 401| | 402| | T is the DER encoding of the hash alg (sha1 or sha256) 403| | */ 404| | 405| | /* From rfc8017 page 46 */ 406| 805|#if DROPBEAR_RSA_SHA1 407| 805| const unsigned char T_sha1[] = 408| 805| {0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 409| 805| 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14}; 410| 805|#endif 411| 805|#if DROPBEAR_RSA_SHA256 412| 805| const unsigned char T_sha256[] = 413| 805| {0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 414| 805| 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20}; 415| 805|#endif 416| | 417| 805| int Tlen = 0; 418| 805| const unsigned char *T = NULL; 419| 805| const struct ltc_hash_descriptor *hash_desc = NULL; 420| 805| buffer * rsa_EM = NULL; 421| 805| hash_state hs; 422| 805| unsigned int nsize; 423| | 424| 805| switch (sigtype) { 425| 0|#if DROPBEAR_RSA_SHA1 426| 799| case DROPBEAR_SIGNATURE_RSA_SHA1: ------------------ | Branch (426:3): [True: 799, False: 6] ------------------ 427| 799| Tlen = sizeof(T_sha1); 428| 799| T = T_sha1; 429| 799| hash_desc = &sha1_desc; 430| 799| break; 431| 0|#endif 432| 0|#if DROPBEAR_RSA_SHA256 433| 6| case DROPBEAR_SIGNATURE_RSA_SHA256: ------------------ | Branch (433:3): [True: 6, False: 799] ------------------ 434| 6| Tlen = sizeof(T_sha256); 435| 6| T = T_sha256; 436| 6| hash_desc = &sha256_desc; 437| 6| break; 438| 0|#endif 439| 0| default: ------------------ | Branch (439:3): [True: 0, False: 805] ------------------ 440| 0| assert(0); ------------------ | Branch (440:4): [Folded, False: 0] | Branch (440:4): [Folded, False: 0] ------------------ 441| 805| } 442| | 443| | 444| 805| nsize = mp_ubin_size(key->n); 445| | 446| 805| rsa_EM = buf_new(nsize); 447| | /* type byte */ 448| 805| buf_putbyte(rsa_EM, 0x00); 449| 805| buf_putbyte(rsa_EM, 0x01); 450| | /* Padding with PS 0xFF bytes */ 451| 192k| while(rsa_EM->pos != rsa_EM->size - (1 + Tlen + hash_desc->hashsize)) { ------------------ | Branch (451:8): [True: 191k, False: 805] ------------------ 452| 191k| buf_putbyte(rsa_EM, 0xff); 453| 191k| } 454| 805| buf_putbyte(rsa_EM, 0x00); 455| | /* Magic ASN1 stuff */ 456| 805| buf_putbytes(rsa_EM, T, Tlen); 457| | 458| | /* The hash of the data */ 459| 805| hash_desc->init(&hs); 460| 805| hash_desc->process(&hs, data_buf->data, data_buf->len); 461| 805| hash_desc->done(&hs, buf_getwriteptr(rsa_EM, hash_desc->hashsize)); 462| 805| buf_incrwritepos(rsa_EM, hash_desc->hashsize); 463| | 464| 805| dropbear_assert(rsa_EM->pos == rsa_EM->size); ------------------ | | 86| 805|#define dropbear_assert(X) do { if (!(X)) { fail_assert(#X, __FILE__, __LINE__); } } while (0) | | ------------------ | | | Branch (86:37): [True: 0, False: 805] | | | Branch (86:93): [Folded, False: 805] | | ------------------ ------------------ 465| | 466| | /* Create the mp_int from the encoded bytes */ 467| 805| buf_setpos(rsa_EM, 0); 468| 805| bytes_to_mp(rsa_em, buf_getptr(rsa_EM, rsa_EM->size), 469| 805| rsa_EM->size); 470| 805| buf_free(rsa_EM); 471| 805|} new_sign_key: 62| 2.91k|sign_key * new_sign_key() { 63| | 64| 2.91k| sign_key * ret; 65| | 66| 2.91k| ret = (sign_key*)m_malloc(sizeof(sign_key)); 67| 2.91k| ret->type = DROPBEAR_SIGNKEY_NONE; 68| 2.91k| ret->source = SIGNKEY_SOURCE_INVALID; 69| 2.91k| return ret; 70| 2.91k|} signkey_type_from_name: 86| 4.05k|enum signkey_type signkey_type_from_name(const char* name, unsigned int namelen) { 87| 4.05k| int i; 88| 15.4k| for (i = 0; i < DROPBEAR_SIGNKEY_NUM_NAMED; i++) { ------------------ | Branch (88:14): [True: 15.2k, False: 228] ------------------ 89| 15.2k| const char *fixed_name = signkey_names[i]; 90| 15.2k| if (namelen == strlen(fixed_name) ------------------ | Branch (90:7): [True: 5.23k, False: 10.0k] ------------------ 91| 5.23k| && memcmp(fixed_name, name, namelen) == 0) { ------------------ | Branch (91:7): [True: 3.82k, False: 1.41k] ------------------ 92| | 93| 3.82k|#if DROPBEAR_ECDSA 94| | /* Some of the ECDSA key sizes are defined even if they're not compiled in */ 95| 3.82k| if (0 ------------------ | Branch (95:8): [Folded, False: 3.82k] ------------------ 96| |#if !DROPBEAR_ECC_256 97| | || i == DROPBEAR_SIGNKEY_ECDSA_NISTP256 98| |#endif 99| |#if !DROPBEAR_ECC_384 100| | || i == DROPBEAR_SIGNKEY_ECDSA_NISTP384 101| |#endif 102| |#if !DROPBEAR_ECC_521 103| | || i == DROPBEAR_SIGNKEY_ECDSA_NISTP521 104| |#endif 105| 3.82k| ) { 106| 0| TRACE(("attempt to use ecdsa type %d not compiled in", i)) 107| 0| return DROPBEAR_SIGNKEY_NONE; 108| 0| } 109| 3.82k|#endif 110| | 111| 3.82k| return (enum signkey_type)i; 112| 3.82k| } 113| 15.2k| } 114| | 115| 228| TRACE(("signkey_type_from_name unexpected key type.")) 116| | 117| 228| return DROPBEAR_SIGNKEY_NONE; 118| 4.05k|} signature_type_from_name: 145| 1.73k|enum signature_type signature_type_from_name(const char* name, unsigned int namelen) { 146| 1.73k|#if DROPBEAR_RSA 147| 1.73k|#if DROPBEAR_RSA_SHA256 148| 1.73k| if (namelen == strlen(SSH_SIGNATURE_RSA_SHA256) ------------------ | | 121| 1.73k|#define SSH_SIGNATURE_RSA_SHA256 "rsa-sha2-256" ------------------ | Branch (148:6): [True: 26, False: 1.71k] ------------------ 149| 26| && memcmp(name, SSH_SIGNATURE_RSA_SHA256, namelen) == 0) { ------------------ | | 121| 26|#define SSH_SIGNATURE_RSA_SHA256 "rsa-sha2-256" ------------------ | Branch (149:6): [True: 8, False: 18] ------------------ 150| 8| return DROPBEAR_SIGNATURE_RSA_SHA256; 151| 8| } 152| 1.73k|#endif 153| 1.73k|#if DROPBEAR_RSA_SHA1 154| 1.73k| if (namelen == strlen(SSH_SIGNKEY_RSA) ------------------ | | 116| 1.73k|#define SSH_SIGNKEY_RSA "ssh-rsa" ------------------ | Branch (154:6): [True: 1.13k, False: 596] ------------------ 155| 1.13k| && memcmp(name, SSH_SIGNKEY_RSA, namelen) == 0) { ------------------ | | 116| 1.13k|#define SSH_SIGNKEY_RSA "ssh-rsa" ------------------ | Branch (155:6): [True: 890, False: 244] ------------------ 156| 890| return DROPBEAR_SIGNATURE_RSA_SHA1; 157| 890| } 158| 840|#endif 159| 840|#endif /* DROPBEAR_RSA */ 160| 840| return (enum signature_type)signkey_type_from_name(name, namelen); 161| 1.73k|} signature_type_from_signkey: 165| 847|enum signature_type signature_type_from_signkey(enum signkey_type keytype) { 166| 847|#if DROPBEAR_RSA 167| 847| assert(keytype != DROPBEAR_SIGNKEY_RSA); ------------------ | Branch (167:2): [True: 0, False: 847] | Branch (167:2): [True: 847, False: 0] ------------------ 168| 847|#endif 169| 847| assert(keytype < DROPBEAR_SIGNKEY_NUM_NAMED); ------------------ | Branch (169:2): [True: 0, False: 847] | Branch (169:2): [True: 847, False: 0] ------------------ 170| 847| return (enum signature_type)keytype; 171| 847|} signkey_type_from_signature: 173| 1.65k|enum signkey_type signkey_type_from_signature(enum signature_type sigtype) { 174| 1.65k|#if DROPBEAR_RSA 175| 1.65k|#if DROPBEAR_RSA_SHA256 176| 1.65k| if (sigtype == DROPBEAR_SIGNATURE_RSA_SHA256) { ------------------ | Branch (176:6): [True: 7, False: 1.64k] ------------------ 177| 7| return DROPBEAR_SIGNKEY_RSA; 178| 7| } 179| 1.64k|#endif 180| 1.64k|#if DROPBEAR_RSA_SHA1 181| 1.64k| if (sigtype == DROPBEAR_SIGNATURE_RSA_SHA1) { ------------------ | Branch (181:6): [True: 889, False: 758] ------------------ 182| 889| return DROPBEAR_SIGNKEY_RSA; 183| 889| } 184| 758|#endif 185| 758|#endif /* DROPBEAR_RSA */ 186| 1.64k| assert((int)sigtype < (int)DROPBEAR_SIGNKEY_NUM_NAMED); ------------------ | Branch (186:2): [True: 0, False: 758] | Branch (186:2): [True: 758, False: 0] ------------------ 187| 758| return (enum signkey_type)sigtype; 188| 758|} signkey_key_ptr: 193| 1.21k|signkey_key_ptr(sign_key *key, enum signkey_type type) { 194| 1.21k| switch (type) { 195| 0|#if DROPBEAR_ED25519 196| 0| case DROPBEAR_SIGNKEY_ED25519: ------------------ | Branch (196:3): [True: 0, False: 1.21k] ------------------ 197| 0|#if DROPBEAR_SK_ED25519 198| 120| case DROPBEAR_SIGNKEY_SK_ED25519: ------------------ | Branch (198:3): [True: 120, False: 1.09k] ------------------ 199| 120|#endif 200| 120| return (void**)&key->ed25519key; 201| 0|#endif 202| 0|#if DROPBEAR_ECDSA 203| 0|#if DROPBEAR_ECC_256 204| 657| case DROPBEAR_SIGNKEY_ECDSA_NISTP256: ------------------ | Branch (204:3): [True: 657, False: 561] ------------------ 205| 657|#if DROPBEAR_SK_ECDSA 206| 752| case DROPBEAR_SIGNKEY_SK_ECDSA_NISTP256: ------------------ | Branch (206:3): [True: 95, False: 1.12k] ------------------ 207| 752|#endif 208| 752| return (void**)&key->ecckey256; 209| 0|#endif 210| 0|#if DROPBEAR_ECC_384 211| 162| case DROPBEAR_SIGNKEY_ECDSA_NISTP384: ------------------ | Branch (211:3): [True: 162, False: 1.05k] ------------------ 212| 162| return (void**)&key->ecckey384; 213| 0|#endif 214| 0|#if DROPBEAR_ECC_521 215| 184| case DROPBEAR_SIGNKEY_ECDSA_NISTP521: ------------------ | Branch (215:3): [True: 184, False: 1.03k] ------------------ 216| 184| return (void**)&key->ecckey521; 217| 0|#endif 218| 0|#endif /* DROPBEAR_ECDSA */ 219| 0|#if DROPBEAR_RSA 220| 0| case DROPBEAR_SIGNKEY_RSA: ------------------ | Branch (220:3): [True: 0, False: 1.21k] ------------------ 221| 0| return (void**)&key->rsakey; 222| 0|#endif 223| 0|#if DROPBEAR_DSS 224| 0| case DROPBEAR_SIGNKEY_DSS: ------------------ | Branch (224:3): [True: 0, False: 1.21k] ------------------ 225| 0| return (void**)&key->dsskey; 226| 0|#endif 227| 0| default: ------------------ | Branch (227:3): [True: 0, False: 1.21k] ------------------ 228| | return NULL; 229| 1.21k| } 230| 1.21k|} buf_get_pub_key: 235| 2.91k|int buf_get_pub_key(buffer *buf, sign_key *key, enum signkey_type *type) { 236| | 237| 2.91k| char *ident; 238| 2.91k| unsigned int len; 239| 2.91k| enum signkey_type keytype; 240| 2.91k| int ret = DROPBEAR_FAILURE; ------------------ | | 112| 2.91k|#define DROPBEAR_FAILURE -1 ------------------ 241| | 242| 2.91k| TRACE2(("enter buf_get_pub_key")) 243| | 244| 2.91k| ident = buf_getstring(buf, &len); 245| 2.91k| keytype = signkey_type_from_name(ident, len); 246| 2.91k| m_free(ident); ------------------ | | 24| 2.91k|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 2.91k] | | ------------------ ------------------ 247| | 248| 2.91k| if (*type != DROPBEAR_SIGNKEY_ANY && *type != keytype) { ------------------ | Branch (248:6): [True: 0, False: 2.91k] | Branch (248:39): [True: 0, False: 0] ------------------ 249| 0| TRACE(("buf_get_pub_key bad type - got %d, expected %d", keytype, *type)) 250| 0| return DROPBEAR_FAILURE; ------------------ | | 112| 0|#define DROPBEAR_FAILURE -1 ------------------ 251| 0| } 252| | 253| 2.91k| TRACE2(("buf_get_pub_key keytype is %d", keytype)) 254| | 255| 2.91k| *type = keytype; 256| | 257| | /* Rewind the buffer back before "ssh-rsa" etc */ 258| 2.91k| buf_decrpos(buf, len + 4); 259| | 260| 2.91k|#if DROPBEAR_DSS 261| 2.91k| if (keytype == DROPBEAR_SIGNKEY_DSS) { ------------------ | Branch (261:6): [True: 359, False: 2.56k] ------------------ 262| 359| dss_key_free(key->dsskey); 263| 359| key->dsskey = m_malloc(sizeof(*key->dsskey)); 264| 359| ret = buf_get_dss_pub_key(buf, key->dsskey); 265| 359| if (ret == DROPBEAR_FAILURE) { ------------------ | | 112| 359|#define DROPBEAR_FAILURE -1 ------------------ | Branch (265:7): [True: 73, False: 286] ------------------ 266| 73| dss_key_free(key->dsskey); 267| 73| key->dsskey = NULL; 268| 73| } 269| 359| } 270| 2.91k|#endif 271| 2.91k|#if DROPBEAR_RSA 272| 2.91k| if (keytype == DROPBEAR_SIGNKEY_RSA) { ------------------ | Branch (272:6): [True: 1.19k, False: 1.72k] ------------------ 273| 1.19k| rsa_key_free(key->rsakey); 274| 1.19k| key->rsakey = m_malloc(sizeof(*key->rsakey)); 275| 1.19k| ret = buf_get_rsa_pub_key(buf, key->rsakey); 276| 1.19k| if (ret == DROPBEAR_FAILURE) { ------------------ | | 112| 1.19k|#define DROPBEAR_FAILURE -1 ------------------ | Branch (276:7): [True: 137, False: 1.05k] ------------------ 277| 137| rsa_key_free(key->rsakey); 278| 137| key->rsakey = NULL; 279| 137| } 280| 1.19k| } 281| 2.91k|#endif 282| 2.91k|#if DROPBEAR_ECDSA 283| 2.91k| if (signkey_is_ecdsa(keytype) ------------------ | Branch (283:6): [True: 932, False: 1.98k] ------------------ 284| 1.98k|#if DROPBEAR_SK_ECDSA 285| 1.98k| || keytype == DROPBEAR_SIGNKEY_SK_ECDSA_NISTP256 ------------------ | Branch (285:6): [True: 95, False: 1.89k] ------------------ 286| 2.91k|#endif 287| 2.91k| ) { 288| 792| ecc_key **eck = (ecc_key**)signkey_key_ptr(key, keytype); 289| 792| if (eck) { ------------------ | Branch (289:7): [True: 792, False: 0] ------------------ 290| 792| if (*eck) { ------------------ | Branch (290:8): [True: 0, False: 792] ------------------ 291| 0| ecc_free(*eck); 292| 0| m_free(*eck); ------------------ | | 24| 0|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 0] | | ------------------ ------------------ 293| 0| *eck = NULL; 294| 0| } 295| 792| *eck = buf_get_ecdsa_pub_key(buf); 296| 792| if (*eck) { ------------------ | Branch (296:8): [True: 309, False: 483] ------------------ 297| 309| ret = DROPBEAR_SUCCESS; ------------------ | | 111| 309|#define DROPBEAR_SUCCESS 0 ------------------ 298| 309| } 299| 792| } 300| 792| } 301| 2.91k|#endif 302| 2.91k|#if DROPBEAR_ED25519 303| 2.91k| if (keytype == DROPBEAR_SIGNKEY_ED25519 ------------------ | Branch (303:6): [True: 557, False: 2.36k] ------------------ 304| 2.36k|#if DROPBEAR_SK_ED25519 305| 2.36k| || keytype == DROPBEAR_SIGNKEY_SK_ED25519 ------------------ | Branch (305:6): [True: 130, False: 2.23k] ------------------ 306| 2.91k|#endif 307| 2.91k| ) { 308| 361| ed25519_key_free(key->ed25519key); 309| 361| key->ed25519key = m_malloc(sizeof(*key->ed25519key)); 310| 361| ret = buf_get_ed25519_pub_key(buf, key->ed25519key, keytype); 311| 361| if (ret == DROPBEAR_FAILURE) { ------------------ | | 112| 361|#define DROPBEAR_FAILURE -1 ------------------ | Branch (311:7): [True: 58, False: 303] ------------------ 312| 58| m_free(key->ed25519key); ------------------ | | 24| 58|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 58] | | ------------------ ------------------ 313| 58| key->ed25519key = NULL; 314| 58| } 315| 361| } 316| 2.91k|#endif 317| | 318| 2.91k|#if DROPBEAR_SK_ECDSA || DROPBEAR_SK_ED25519 319| 2.91k| if (0 ------------------ | Branch (319:6): [Folded, False: 2.58k] ------------------ 320| 2.58k|#if DROPBEAR_SK_ED25519 321| 2.58k| || keytype == DROPBEAR_SIGNKEY_SK_ED25519 ------------------ | Branch (321:6): [True: 128, False: 2.45k] ------------------ 322| 2.45k|#endif 323| 2.45k|#if DROPBEAR_SK_ECDSA 324| 2.45k| || keytype == DROPBEAR_SIGNKEY_SK_ECDSA_NISTP256 ------------------ | Branch (324:6): [True: 82, False: 2.37k] ------------------ 325| 2.91k|#endif 326| 2.91k| ) { 327| 210| key->sk_app = buf_getstring(buf, &key->sk_applen); 328| 210| } 329| 2.91k|#endif 330| | 331| 2.91k| TRACE2(("leave buf_get_pub_key")) 332| | 333| 2.91k| return ret; 334| 2.91k|} sign_key_free: 506| 2.37k|void sign_key_free(sign_key *key) { 507| | 508| 2.37k| TRACE2(("enter sign_key_free")) 509| | 510| 2.37k|#if DROPBEAR_DSS 511| 2.37k| dss_key_free(key->dsskey); 512| 2.37k| key->dsskey = NULL; 513| 2.37k|#endif 514| 2.37k|#if DROPBEAR_RSA 515| 2.37k| rsa_key_free(key->rsakey); 516| 2.37k| key->rsakey = NULL; 517| 2.37k|#endif 518| 2.37k|#if DROPBEAR_ECDSA 519| 2.37k|#if DROPBEAR_ECC_256 520| 2.37k| if (key->ecckey256) { ------------------ | Branch (520:6): [True: 194, False: 2.18k] ------------------ 521| 194| ecc_free(key->ecckey256); 522| 194| m_free(key->ecckey256); ------------------ | | 24| 194|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 194] | | ------------------ ------------------ 523| 194| key->ecckey256 = NULL; 524| 194| } 525| 2.37k|#endif 526| 2.37k|#if DROPBEAR_ECC_384 527| 2.37k| if (key->ecckey384) { ------------------ | Branch (527:6): [True: 53, False: 2.32k] ------------------ 528| 53| ecc_free(key->ecckey384); 529| 53| m_free(key->ecckey384); ------------------ | | 24| 53|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 53] | | ------------------ ------------------ 530| 53| key->ecckey384 = NULL; 531| 53| } 532| 2.37k|#endif 533| 2.37k|#if DROPBEAR_ECC_521 534| 2.37k| if (key->ecckey521) { ------------------ | Branch (534:6): [True: 55, False: 2.32k] ------------------ 535| 55| ecc_free(key->ecckey521); 536| 55| m_free(key->ecckey521); ------------------ | | 24| 55|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 55] | | ------------------ ------------------ 537| 55| key->ecckey521 = NULL; 538| 55| } 539| 2.37k|#endif 540| 2.37k|#endif 541| 2.37k|#if DROPBEAR_ED25519 542| 2.37k| ed25519_key_free(key->ed25519key); 543| 2.37k| key->ed25519key = NULL; 544| 2.37k|#endif 545| | 546| 2.37k| m_free(key->filename); ------------------ | | 24| 2.37k|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 2.37k] | | ------------------ ------------------ 547| 2.37k|#if DROPBEAR_SK_ECDSA || DROPBEAR_SK_ED25519 548| 2.37k| if (key->sk_app) { ------------------ | Branch (548:6): [True: 121, False: 2.25k] ------------------ 549| 121| m_free(key->sk_app); ------------------ | | 24| 121|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 121] | | ------------------ ------------------ 550| 121| } 551| 2.37k|#endif 552| | 553| | m_free(key); ------------------ | | 24| 2.37k|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 2.37k] | | ------------------ ------------------ 554| 2.37k| TRACE2(("leave sign_key_free")) 555| 2.37k|} buf_verify: 645| 1.75k|int buf_verify(buffer * buf, sign_key *key, enum signature_type expect_sigtype, const buffer *data_buf) { 646| | 647| 1.75k| char *type_name = NULL; 648| 1.75k| unsigned int type_name_len = 0; 649| 1.75k| enum signature_type sigtype; 650| 1.75k| enum signkey_type keytype; 651| | 652| 1.75k| TRACE(("enter buf_verify")) 653| | 654| 1.75k| buf_getint(buf); /* blob length */ 655| 1.75k| type_name = buf_getstring(buf, &type_name_len); 656| 1.75k| sigtype = signature_type_from_name(type_name, type_name_len); 657| 1.75k| m_free(type_name); ------------------ | | 24| 1.75k|#define m_free(X) do {m_free_direct(X); (X) = NULL;} while (0) | | ------------------ | | | Branch (24:61): [Folded, False: 1.75k] | | ------------------ ------------------ 658| | 659| 1.75k| if (expect_sigtype != sigtype) { ------------------ | Branch (659:6): [True: 84, False: 1.67k] ------------------ 660| 84| dropbear_exit("Non-matching signing type"); 661| 84| } 662| | 663| 1.67k| keytype = signkey_type_from_signature(sigtype); 664| 1.67k|#if DROPBEAR_DSS 665| 1.67k| if (keytype == DROPBEAR_SIGNKEY_DSS) { ------------------ | Branch (665:6): [True: 240, False: 1.43k] ------------------ 666| 240| if (key->dsskey == NULL) { ------------------ | Branch (666:7): [True: 0, False: 240] ------------------ 667| 0| dropbear_exit("No DSS key to verify signature"); 668| 0| } 669| 240| return buf_dss_verify(buf, key->dsskey, data_buf); 670| 240| } 671| 1.43k|#endif 672| | 673| 1.43k|#if DROPBEAR_RSA 674| 1.43k| if (keytype == DROPBEAR_SIGNKEY_RSA) { ------------------ | Branch (674:6): [True: 896, False: 539] ------------------ 675| 896| if (key->rsakey == NULL) { ------------------ | Branch (675:7): [True: 0, False: 896] ------------------ 676| 0| dropbear_exit("No RSA key to verify signature"); 677| 0| } 678| 896| return buf_rsa_verify(buf, key->rsakey, sigtype, data_buf); 679| 896| } 680| 539|#endif 681| 539|#if DROPBEAR_ECDSA 682| 539| if (signkey_is_ecdsa(keytype)) { ------------------ | Branch (682:6): [True: 306, False: 233] ------------------ 683| 306| ecc_key **eck = (ecc_key**)signkey_key_ptr(key, keytype); 684| 306| if (eck && *eck) { ------------------ | Branch (684:7): [True: 306, False: 0] | Branch (684:14): [True: 306, False: 0] ------------------ 685| 306| return buf_ecdsa_verify(buf, *eck, data_buf); 686| 306| } 687| 306| } 688| 233|#endif 689| 233|#if DROPBEAR_ED25519 690| 233| if (keytype == DROPBEAR_SIGNKEY_ED25519) { ------------------ | Branch (690:6): [True: 94, False: 139] ------------------ 691| 94| if (key->ed25519key == NULL) { ------------------ | Branch (691:7): [True: 0, False: 94] ------------------ 692| 0| dropbear_exit("No Ed25519 key to verify signature"); 693| 0| } 694| 94| return buf_ed25519_verify(buf, key->ed25519key, data_buf); 695| 94| } 696| 139|#endif 697| 139|#if DROPBEAR_SK_ECDSA 698| 139| if (keytype == DROPBEAR_SIGNKEY_SK_ECDSA_NISTP256) { ------------------ | Branch (698:6): [True: 0, False: 139] ------------------ 699| 0| ecc_key **eck = (ecc_key**)signkey_key_ptr(key, keytype); 700| 0| if (eck && *eck) { ------------------ | Branch (700:7): [True: 0, False: 0] | Branch (700:14): [True: 0, False: 0] ------------------ 701| 0| return buf_sk_ecdsa_verify(buf, *eck, data_buf, key->sk_app, key->sk_applen, key->sk_flags_mask); 702| 0| } 703| 0| } 704| 139|#endif 705| 139|#if DROPBEAR_SK_ED25519 706| 139| if (keytype == DROPBEAR_SIGNKEY_SK_ED25519) { ------------------ | Branch (706:6): [True: 118, False: 21] ------------------ 707| 118| dropbear_ed25519_key **eck = (dropbear_ed25519_key**)signkey_key_ptr(key, keytype); 708| 118| if (eck && *eck) { ------------------ | Branch (708:7): [True: 118, False: 0] | Branch (708:14): [True: 118, False: 0] ------------------ 709| 118| return buf_sk_ed25519_verify(buf, *eck, data_buf, key->sk_app, key->sk_applen, key->sk_flags_mask); 710| 118| } 711| 118| } 712| 21|#endif 713| | 714| 21| dropbear_exit("Non-matching signing type"); 715| 0| return DROPBEAR_FAILURE; ------------------ | | 112| 0|#define DROPBEAR_FAILURE -1 ------------------ 716| 139|} buf_sk_ed25519_verify: 13| 118| unsigned char sk_flags_mask) { 14| | 15| 118| int ret = DROPBEAR_FAILURE; ------------------ | | 112| 118|#define DROPBEAR_FAILURE -1 ------------------ 16| 118| unsigned char *s; 17| 118| unsigned long slen; 18| 118| hash_state hs; 19| 118| unsigned char hash[SHA256_HASH_SIZE]; 20| 118| buffer *sk_buffer = NULL; 21| 118| unsigned char flags; 22| 118| unsigned int counter; 23| | 24| 118| TRACE(("enter buf_sk_ed25519_verify")) 25| 118| dropbear_assert(key != NULL); ------------------ | | 86| 118|#define dropbear_assert(X) do { if (!(X)) { fail_assert(#X, __FILE__, __LINE__); } } while (0) | | ------------------ | | | Branch (86:37): [True: 0, False: 118] | | | Branch (86:93): [Folded, False: 118] | | ------------------ ------------------ 26| | 27| 118| slen = buf_getint(buf); 28| 118| if (slen != 64 || buf->len - buf->pos < slen) { ------------------ | Branch (28:6): [True: 40, False: 78] | Branch (28:20): [True: 4, False: 74] ------------------ 29| 43| TRACE(("leave buf_sk_ed25519_verify: bad size")) 30| 43| goto out; 31| 43| } 32| 75| s = buf_getptr(buf, slen); 33| 75| buf_incrpos(buf, slen); 34| | 35| 75| flags = buf_getbyte (buf); 36| 75| counter = buf_getint (buf); 37| | /* create the message to be signed */ 38| 75| sk_buffer = buf_new (2*SHA256_HASH_SIZE+5); ------------------ | | 134| 75|#define SHA256_HASH_SIZE 32 ------------------ 39| 75| sha256_init (&hs); 40| 75| sha256_process (&hs, app, applen); 41| 75| sha256_done (&hs, hash); 42| 75| buf_putbytes (sk_buffer, hash, sizeof (hash)); 43| 75| buf_putbyte (sk_buffer, flags); 44| 75| buf_putint (sk_buffer, counter); 45| 75| sha256_init (&hs); 46| 75| sha256_process (&hs, data_buf->data, data_buf->len); 47| 75| sha256_done (&hs, hash); 48| 75| buf_putbytes (sk_buffer, hash, sizeof (hash)); 49| | 50| 75| if (dropbear_ed25519_verify(sk_buffer->data, sk_buffer->len, ------------------ | Branch (50:6): [True: 2, False: 73] ------------------ 51| 75| s, slen, key->pub) == 0) { 52| | /* signature is valid */ 53| 2| TRACE(("leave buf_sk_ed25519_verify: success!")) 54| 2| ret = DROPBEAR_SUCCESS; ------------------ | | 111| 2|#define DROPBEAR_SUCCESS 0 ------------------ 55| 2| } 56| | 57| 75| if (~flags & sk_flags_mask & SSH_SK_USER_PRESENCE_REQD) { ------------------ | | 135| 75|#define SSH_SK_USER_PRESENCE_REQD 0x01 ------------------ | Branch (57:6): [True: 0, False: 75] ------------------ 58| 0| if (ret == DROPBEAR_SUCCESS) { ------------------ | | 111| 0|#define DROPBEAR_SUCCESS 0 ------------------ | Branch (58:7): [True: 0, False: 0] ------------------ 59| 0| dropbear_log(LOG_WARNING, "Rejecting, user-presence not set"); 60| 0| } 61| 0| ret = DROPBEAR_FAILURE; ------------------ | | 112| 0|#define DROPBEAR_FAILURE -1 ------------------ 62| 0| } 63| 75| if (~flags & sk_flags_mask & SSH_SK_USER_VERIFICATION_REQD) { ------------------ | | 136| 75|#define SSH_SK_USER_VERIFICATION_REQD 0x04 ------------------ | Branch (63:6): [True: 0, False: 75] ------------------ 64| 0| if (ret == DROPBEAR_SUCCESS) { ------------------ | | 111| 0|#define DROPBEAR_SUCCESS 0 ------------------ | Branch (64:7): [True: 0, False: 0] ------------------ 65| 0| dropbear_log(LOG_WARNING, "Rejecting, user-verification not set"); 66| 0| } 67| 0| ret = DROPBEAR_FAILURE; ------------------ | | 112| 0|#define DROPBEAR_FAILURE -1 ------------------ 68| 0| } 69| 116|out: 70| 116| buf_free(sk_buffer); 71| 116| TRACE(("leave buf_sk_ed25519_verify: ret %d", ret)) 72| 116| return ret; 73| 75|}