|
--- |
|
arxiv: 2102.07995 |
|
dataset_info: |
|
- config_name: code |
|
features: |
|
- name: id |
|
dtype: int64 |
|
- name: label |
|
dtype: int64 |
|
- name: bug_url |
|
dtype: string |
|
- name: bug_function |
|
dtype: string |
|
- name: functions |
|
dtype: string |
|
splits: |
|
- name: train |
|
num_bytes: 357876131 |
|
num_examples: 36719 |
|
- name: dev |
|
num_bytes: 48017743 |
|
num_examples: 4634 |
|
- name: test |
|
num_bytes: 43035964 |
|
num_examples: 4604 |
|
download_size: 139316551 |
|
dataset_size: 448929838 |
|
- config_name: code_trace |
|
features: |
|
- name: id |
|
dtype: int64 |
|
- name: label |
|
dtype: int64 |
|
- name: trace |
|
dtype: string |
|
- name: bug_url |
|
dtype: string |
|
- name: bug_function |
|
dtype: string |
|
- name: functions |
|
dtype: string |
|
splits: |
|
- name: train |
|
num_bytes: 531973771 |
|
num_examples: 36719 |
|
- name: dev |
|
num_bytes: 66958385 |
|
num_examples: 4634 |
|
- name: test |
|
num_bytes: 64518442 |
|
num_examples: 4604 |
|
download_size: 208837991 |
|
dataset_size: 663450598 |
|
- config_name: function |
|
features: |
|
- name: id |
|
dtype: int64 |
|
- name: label |
|
dtype: int64 |
|
- name: code |
|
dtype: string |
|
splits: |
|
- name: train |
|
num_bytes: 8913129 |
|
num_examples: 4643 |
|
- name: dev |
|
num_bytes: 1107843 |
|
num_examples: 596 |
|
- name: test |
|
num_bytes: 1193137 |
|
num_examples: 618 |
|
download_size: 4715682 |
|
dataset_size: 11214109 |
|
- config_name: trace |
|
features: |
|
- name: id |
|
dtype: int64 |
|
- name: label |
|
dtype: int64 |
|
- name: trace |
|
dtype: string |
|
splits: |
|
- name: train |
|
num_bytes: 174685144 |
|
num_examples: 36719 |
|
- name: dev |
|
num_bytes: 19014786 |
|
num_examples: 4634 |
|
- name: test |
|
num_bytes: 21556142 |
|
num_examples: 4604 |
|
download_size: 68014392 |
|
dataset_size: 215256072 |
|
configs: |
|
- config_name: code |
|
data_files: |
|
- split: train |
|
path: code/train-* |
|
- split: dev |
|
path: code/dev-* |
|
- split: test |
|
path: code/test-* |
|
- config_name: code_trace |
|
data_files: |
|
- split: train |
|
path: code_trace/train-* |
|
- split: dev |
|
path: code_trace/dev-* |
|
- split: test |
|
path: code_trace/test-* |
|
- config_name: function |
|
data_files: |
|
- split: train |
|
path: function/train-* |
|
- split: dev |
|
path: function/dev-* |
|
- split: test |
|
path: function/test-* |
|
- config_name: trace |
|
data_files: |
|
- split: train |
|
path: trace/train-* |
|
- split: dev |
|
path: trace/dev-* |
|
- split: test |
|
path: trace/test-* |
|
license: apache-2.0 |
|
task_categories: |
|
- text-classification |
|
tags: |
|
- code |
|
--- |
|
|
|
# D2A: A Dataset Built for AI-Based Vulnerability Detection Methods Using Differential Analysis |
|
This is an unofficial HuggingFace upload of the D2A dataset from "[D2A: A Dataset Built for AI-Based Vulnerability Detection Methods Using Differential Analysis](https://arxiv.org/abs/2102.07995)". "Test" splits have all labels as -1 as they are not provided. |
|
|
|
Usage: |
|
```python |
|
from datasets import load_dataset |
|
|
|
# Use "code", "code_trace", "function", or "trace" to load the different variants. |
|
dataset = load_dataset("claudios/D2A", "code") |
|
``` |
|
*** |
|
|
|
# D2A Leaderboard Data |
|
|
|
This document describes D2A V1 Leaderboard data. You can download them from the Leaderboard section of the [D2A Dataset](https://dax-cdn.cdn.appdomain.cloud/dax-d2a/1.1.0/d2a.html?cm_mc_uid=52096571630515722723826&cm_mc_sid_50200000=65851751618339788874&_ga=2.42786284.851757668.1618339789-1229357178.1617837310) page. To begin download directly you can click [here](https://dax-cdn.cdn.appdomain.cloud/dax-d2a/1.1.0/d2a_leaderboard_data.tar.gz). |
|
|
|
## Source files: |
|
|
|
The files were created using the [default security errors](#default-security-errors) of datasets Libav, OpenSSL, Nginx, Httpd and Libtiff from [D2A](https://developer.ibm.com/exchanges/data/all/d2a/). |
|
|
|
There are 4 directories corresponding to 4 tasks of the leaderboard. Each directory contains 3 csv files corresponding to the train (80%), dev (10%) and test (10%) split. |
|
The columns in the split files are identical except the test split which does not contain the label column. |
|
|
|
## Columns: |
|
|
|
1. **id**: A unique id for every example in a task. |
|
2. **label**: Values are 0 or 1. |
|
1. Value 0: No vulnerability/defect in the example. |
|
2. Value 1: Example contains some vulnerability/defect. |
|
3. **trace**: Bug trace or bug report generated by Infer static analyzer. Infer predictions contain a lot of False positives which is why even 0 label examples have a bug report. |
|
4. **bug_function/code**: Full source code of the function where the vulnerability originates. |
|
5. **bug_url**: URL of the file which contains the bug_function. |
|
6. **functions**: Full source code of all the functions in the bug trace, with the duplicates removed. This will include the function in bug_function. |
|
|
|
## Default Security Errors: |
|
|
|
These are security errors enabled by default by Infer. |
|
|
|
* BIABD_USE_AFTER_FREE |
|
* BUFFER_OVERRUN_L1 |
|
* BUFFER_OVERRUN_L2 |
|
* BUFFER_OVERRUN_L3 |
|
* BUFFER_OVERRUN_R2 |
|
* BUFFER_OVERRUN_S2 |
|
* BUFFER_OVERRUN_T1 |
|
* INTEGER_OVERFLOW_L1 |
|
* INTEGER_OVERFLOW_L2 |
|
* INTEGER_OVERFLOW_R2 |
|
* MEMORY_LEAK |
|
* NULL_DEREFERENCE |
|
* RESOURCE_LEAK |
|
* LAB_RESOURCE_LEAK |
|
* UNINITIALIZED_VALUE |
|
* USE_AFTER_DELETE |
|
* USE_AFTER_FREE |
|
* USE_AFTER_LIFETIME |
|
|
|
## Data Examples: |
|
|
|
1. Trace: |
|
|
|
```"test/bntest.c:1802: error: BUFFER_OVERRUN_L3 |
|
Offset: [4, +oo] (‚áê [0, +oo] + 4) Size: [0, 8388607] by call to `BN_mul`. |
|
Showing all 12 steps of the trace |
|
|
|
|
|
test/bntest.c:1798:10: Call |
|
1796. |
|
1797. /* Test that BN_mul never gives negative zero. */ |
|
1798. if (!BN_set_word(a, 1)) |
|
^ |
|
1799. goto err; |
|
1800. BN_set_negative(a, 1); |
|
|
|
crypto/bn/bn_lib.c:463:1: Parameter `*a->d` |
|
461. } |
|
462. |
|
463. > int BN_set_word(BIGNUM *a, BN_ULONG w) |
|
464. { |
|
465. bn_check_top(a); |
|
|
|
crypto/bn/bn_lib.c:466:9: Call |
|
464. { |
|
465. bn_check_top(a); |
|
466. if (bn_expand(a, (int)sizeof(BN_ULONG) * 8) == NULL) |
|
^ |
|
467. return (0); |
|
468. a->neg = 0; |
|
|
|
crypto/bn/bn_lcl.h:676:1: Parameter `*a->d` |
|
674. int bn_probable_prime_dh_coprime(BIGNUM *rnd, int bits, BN_CTX *ctx); |
|
675. |
|
676. > static ossl_inline BIGNUM *bn_expand(BIGNUM *a, int bits) |
|
677. { |
|
678. if (bits > (INT_MAX - BN_BITS2 + 1)) |
|
|
|
test/bntest.c:1802:10: Call |
|
1800. BN_set_negative(a, 1); |
|
1801. BN_zero(b); |
|
1802. if (!BN_mul(c, a, b, ctx)) |
|
^ |
|
1803. goto err; |
|
1804. if (!BN_is_zero(c) || BN_is_negative(c)) { |
|
|
|
crypto/bn/bn_mul.c:828:1: Parameter `*b->d` |
|
826. #endif /* BN_RECURSION */ |
|
827. |
|
828. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx) |
|
829. { |
|
830. int ret = 0; |
|
|
|
crypto/bn/bn_mul.c:909:17: Call |
|
907. if (bn_wexpand(rr, k * 4) == NULL) |
|
908. goto err; |
|
909. bn_mul_part_recursive(rr->d, a->d, b->d, |
|
^ |
|
910. j, al - j, bl - j, t->d); |
|
911. } else { /* al <= j || bl <= j */ |
|
|
|
crypto/bn/bn_mul.c:480:1: Parameter `*b` |
|
478. */ |
|
479. /* tnX may not be negative but less than n */ |
|
480. > void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n, |
|
481. int tna, int tnb, BN_ULONG *t) |
|
482. { |
|
|
|
crypto/bn/bn_mul.c:488:9: Call |
|
486. |
|
487. if (n < 8) { |
|
488. bn_mul_normal(r, a, n + tna, b, n + tnb); |
|
^ |
|
489. return; |
|
490. } |
|
|
|
crypto/bn/bn_mul.c:983:1: <Length trace> |
|
981. } |
|
982. |
|
983. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb) |
|
984. { |
|
985. BN_ULONG *rr; |
|
|
|
crypto/bn/bn_mul.c:983:1: Parameter `*b` |
|
981. } |
|
982. |
|
983. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb) |
|
984. { |
|
985. BN_ULONG *rr; |
|
|
|
crypto/bn/bn_mul.c:1018:50: Array access: Offset: [4, +oo] (‚áê [0, +oo] + 4) Size: [0, 8388607] by call to `BN_mul` |
|
1016. if (--nb <= 0) |
|
1017. return; |
|
1018. rr[4] = bn_mul_add_words(&(r[4]), a, na, b[4]); |
|
^ |
|
1019. rr += 4; |
|
1020. r += 4; |
|
" |
|
``` |
|
|
|
2. Bug URL: |
|
|
|
``` |
|
https://github.com/openssl/openssl/blob/0282aeb690d63fab73a07191b63300a2fe30d212/crypto/bn/bn_mul.c/#L1018 |
|
``` |
|
|
|
3. Bug Function: |
|
|
|
``` |
|
"void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb) |
|
{ |
|
BN_ULONG *rr; |
|
if (na < nb) { |
|
int itmp; |
|
BN_ULONG *ltmp; |
|
itmp = na; |
|
na = nb; |
|
nb = itmp; |
|
ltmp = a; |
|
a = b; |
|
b = ltmp; |
|
} |
|
rr = &(r[na]); |
|
if (nb <= 0) { |
|
(void)bn_mul_words(r, a, na, 0); |
|
return; |
|
} else |
|
rr[0] = bn_mul_words(r, a, na, b[0]); |
|
for (;;) { |
|
if (--nb <= 0) |
|
return; |
|
rr[1] = bn_mul_add_words(&(r[1]), a, na, b[1]); |
|
if (--nb <= 0) |
|
return; |
|
rr[2] = bn_mul_add_words(&(r[2]), a, na, b[2]); |
|
if (--nb <= 0) |
|
return; |
|
rr[3] = bn_mul_add_words(&(r[3]), a, na, b[3]); |
|
if (--nb <= 0) |
|
return; |
|
rr[4] = bn_mul_add_words(&(r[4]), a, na, b[4]); |
|
rr += 4; |
|
r += 4; |
|
b += 4; |
|
} |
|
}" |
|
``` |
|
|
|
4. Functions: |
|
|
|
``` |
|
[ |
|
'static int test_negzero() { |
|
BIGNUM * a = BN_new(); |
|
BIGNUM * b = BN_new(); |
|
BIGNUM * c = BN_new(); |
|
BIGNUM * d = BN_new(); |
|
BIGNUM * numerator = NULL, * denominator = NULL; |
|
int consttime, st = 0; |
|
if (a == NULL || b == NULL || c == NULL || d == NULL) goto err; |
|
if (!BN_set_word(a, 1)) goto err; |
|
BN_set_negative(a, 1); |
|
BN_zero(b); |
|
if (!BN_mul(c, a, b, ctx)) goto err; |
|
if (!BN_is_zero(c) || BN_is_negative(c)) { |
|
fprintf(stderr, "Multiplication test failed!"); |
|
goto err; |
|
} |
|
for (consttime = 0; consttime < 2; consttime++) { |
|
numerator = BN_new(); |
|
denominator = BN_new(); |
|
if (numerator == NULL || denominator == NULL) goto err; |
|
if (consttime) { |
|
BN_set_flags(numerator, BN_FLG_CONSTTIME); |
|
BN_set_flags(denominator, BN_FLG_CONSTTIME); |
|
} |
|
if (!BN_set_word(numerator, 1) || !BN_set_word(denominator, 2)) goto err; |
|
BN_set_negative(numerator, 1); |
|
if (!BN_div(a, b, numerator, denominator, ctx)) goto err; |
|
if (!BN_is_zero(a) || BN_is_negative(a)) { |
|
fprintf(stderr, "Incorrect quotient (consttime = %d).", consttime); |
|
goto err; |
|
} |
|
if (!BN_set_word(denominator, 1)) goto err; |
|
if (!BN_div(a, b, numerator, denominator, ctx)) goto err; |
|
if (!BN_is_zero(b) || BN_is_negative(b)) { |
|
fprintf(stderr, "Incorrect remainder (consttime = %d).", consttime); |
|
goto err; |
|
} |
|
BN_free(numerator); |
|
BN_free(denominator); |
|
numerator = denominator = NULL; |
|
} |
|
BN_zero(a); |
|
BN_set_negative(a, 1); |
|
if (BN_is_negative(a)) { |
|
fprintf(stderr, "BN_set_negative produced a negative zero."); |
|
goto err; |
|
} |
|
st = 1; |
|
err: BN_free(a); |
|
BN_free(b); |
|
BN_free(c); |
|
BN_free(d); |
|
BN_free(numerator); |
|
BN_free(denominator); |
|
return st; |
|
}', |
|
'int BN_set_word(BIGNUM * a, BN_ULONG w) { |
|
bn_check_top(a); |
|
if (bn_expand(a, (int) sizeof(BN_ULONG) * 8) == NULL) return (0); |
|
a -> neg = 0; |
|
a -> d[0] = w; |
|
a -> top = (w ? 1 : 0); |
|
bn_check_top(a); |
|
return (1); |
|
}', |
|
'static ossl_inline BIGNUM * bn_expand(BIGNUM * a, int bits) { |
|
if (bits > (INT_MAX - BN_BITS2 + 1)) return NULL; |
|
if (((bits + BN_BITS2 - 1) / BN_BITS2) <= (a) -> dmax) return a; |
|
return bn_expand2((a), (bits + BN_BITS2 - 1) / BN_BITS2); |
|
}', |
|
'int BN_mul(BIGNUM * r, |
|
const BIGNUM * a, |
|
const BIGNUM * b, BN_CTX * ctx) { |
|
int ret = 0; |
|
int top, al, bl; |
|
BIGNUM * rr; |
|
#if defined(BN_MUL_COMBA) || defined(BN_RECURSION) int i; |
|
#endif #ifdef BN_RECURSION BIGNUM * t = NULL; |
|
int j = 0, k; |
|
#endif bn_check_top(a); |
|
bn_check_top(b); |
|
bn_check_top(r); |
|
al = a -> top; |
|
bl = b -> top; |
|
if ((al == 0) || (bl == 0)) { |
|
BN_zero(r); |
|
return (1); |
|
} |
|
top = al + bl; |
|
BN_CTX_start(ctx); |
|
if ((r == a) || (r == b)) { |
|
if ((rr = BN_CTX_get(ctx)) == NULL) goto err; |
|
} else rr = r; |
|
rr -> neg = a -> neg ^ b -> neg; |
|
#if defined(BN_MUL_COMBA) || defined(BN_RECURSION) i = al - bl; |
|
#endif #ifdef BN_MUL_COMBA |
|
if (i == 0) { |
|
# |
|
if 0 |
|
if (al == 4) { |
|
if (bn_wexpand(rr, 8) == NULL) goto err; |
|
rr -> top = 8; |
|
bn_mul_comba4(rr -> d, a -> d, b -> d); |
|
goto end; |
|
} |
|
# endif |
|
if (al == 8) { |
|
if (bn_wexpand(rr, 16) == NULL) goto err; |
|
rr -> top = 16; |
|
bn_mul_comba8(rr -> d, a -> d, b -> d); |
|
goto end; |
|
} |
|
} |
|
#endif #ifdef BN_RECURSION |
|
if ((al >= BN_MULL_SIZE_NORMAL) && (bl >= BN_MULL_SIZE_NORMAL)) { |
|
if (i >= -1 && i <= 1) { |
|
if (i >= 0) { |
|
j = BN_num_bits_word((BN_ULONG) al); |
|
} |
|
if (i == -1) { |
|
j = BN_num_bits_word((BN_ULONG) bl); |
|
} |
|
j = 1 << (j - 1); |
|
assert(j <= al || j <= bl); |
|
k = j + j; |
|
t = BN_CTX_get(ctx); |
|
if (t == NULL) goto err; |
|
if (al > j || bl > j) { |
|
if (bn_wexpand(t, k * 4) == NULL) goto err; |
|
if (bn_wexpand(rr, k * 4) == NULL) goto err; |
|
bn_mul_part_recursive(rr -> d, a -> d, b -> d, j, al - j, bl - j, t -> d); |
|
} else { |
|
if (bn_wexpand(t, k * 2) == NULL) goto err; |
|
if (bn_wexpand(rr, k * 2) == NULL) goto err; |
|
bn_mul_recursive(rr -> d, a -> d, b -> d, j, al - j, bl - j, t -> d); |
|
} |
|
rr -> top = top; |
|
goto end; |
|
} |
|
# |
|
if 0 |
|
if (i == 1 && !BN_get_flags(b, BN_FLG_STATIC_DATA)) { |
|
BIGNUM * tmp_bn = (BIGNUM * ) b; |
|
if (bn_wexpand(tmp_bn, al) == NULL) goto err; |
|
tmp_bn -> d[bl] = 0; |
|
bl++; |
|
i--; |
|
} else if (i == -1 && !BN_get_flags(a, BN_FLG_STATIC_DATA)) { |
|
BIGNUM * tmp_bn = (BIGNUM * ) a; |
|
if (bn_wexpand(tmp_bn, bl) == NULL) goto err; |
|
tmp_bn -> d[al] = 0; |
|
al++; |
|
i++; |
|
} |
|
if (i == 0) { |
|
j = BN_num_bits_word((BN_ULONG) al); |
|
j = 1 << (j - 1); |
|
k = j + j; |
|
t = BN_CTX_get(ctx); |
|
if (al == j) { |
|
if (bn_wexpand(t, k * 2) == NULL) goto err; |
|
if (bn_wexpand(rr, k * 2) == NULL) goto err; |
|
bn_mul_recursive(rr -> d, a -> d, b -> d, al, t -> d); |
|
} else { |
|
if (bn_wexpand(t, k * 4) == NULL) goto err; |
|
if (bn_wexpand(rr, k * 4) == NULL) goto err; |
|
bn_mul_part_recursive(rr -> d, a -> d, b -> d, al - j, j, t -> d); |
|
} |
|
rr -> top = top; |
|
goto end; |
|
} |
|
# endif |
|
} |
|
#endif |
|
if (bn_wexpand(rr, top) == NULL) goto err; |
|
rr -> top = top; |
|
bn_mul_normal(rr -> d, a -> d, al, b -> d, bl); |
|
#if defined(BN_MUL_COMBA) || defined(BN_RECURSION) end: #endif bn_correct_top(rr); |
|
if (r != rr && BN_copy(r, rr) == NULL) goto err; |
|
ret = 1; |
|
err: bn_check_top(r); |
|
BN_CTX_end(ctx); |
|
return (ret); |
|
}', |
|
'void bn_mul_part_recursive(BN_ULONG * r, BN_ULONG * a, BN_ULONG * b, int n, int tna, int tnb, BN_ULONG * t) { |
|
int i, j, n2 = n * 2; |
|
int c1, c2, neg; |
|
BN_ULONG ln, lo, * p; |
|
if (n < 8) { |
|
bn_mul_normal(r, a, n + tna, b, n + tnb); |
|
return; |
|
} |
|
c1 = bn_cmp_part_words(a, & (a[n]), tna, n - tna); |
|
c2 = bn_cmp_part_words( & (b[n]), b, tnb, tnb - n); |
|
neg = 0; |
|
switch (c1 * 3 + c2) { |
|
case -4: |
|
bn_sub_part_words(t, & (a[n]), a, tna, tna - n); |
|
bn_sub_part_words( & (t[n]), b, & (b[n]), tnb, n - tnb); |
|
break; |
|
case -3: |
|
case -2: |
|
bn_sub_part_words(t, & (a[n]), a, tna, tna - n); |
|
bn_sub_part_words( & (t[n]), & (b[n]), b, tnb, tnb - n); |
|
neg = 1; |
|
break; |
|
case -1: |
|
case 0: |
|
case 1: |
|
case 2: |
|
bn_sub_part_words(t, a, & (a[n]), tna, n - tna); |
|
bn_sub_part_words( & (t[n]), b, & (b[n]), tnb, n - tnb); |
|
neg = 1; |
|
break; |
|
case 3: |
|
case 4: |
|
bn_sub_part_words(t, a, & (a[n]), tna, n - tna); |
|
bn_sub_part_words( & (t[n]), & (b[n]), b, tnb, tnb - n); |
|
break; |
|
} |
|
# |
|
if 0 |
|
if (n == 4) { |
|
bn_mul_comba4( & (t[n2]), t, & (t[n])); |
|
bn_mul_comba4(r, a, b); |
|
bn_mul_normal( & (r[n2]), & (a[n]), tn, & (b[n]), tn); |
|
memset( & r[n2 + tn * 2], 0, sizeof( * r) * (n2 - tn * 2)); |
|
} else # endif |
|
if (n == 8) { |
|
bn_mul_comba8( & (t[n2]), t, & (t[n])); |
|
bn_mul_comba8(r, a, b); |
|
bn_mul_normal( & (r[n2]), & (a[n]), tna, & (b[n]), tnb); |
|
memset( & r[n2 + tna + tnb], 0, sizeof( * r) * (n2 - tna - tnb)); |
|
} else { |
|
p = & (t[n2 * 2]); |
|
bn_mul_recursive( & (t[n2]), t, & (t[n]), n, 0, 0, p); |
|
bn_mul_recursive(r, a, b, n, 0, 0, p); |
|
i = n / 2; |
|
if (tna > tnb) j = tna - i; |
|
else j = tnb - i; |
|
if (j == 0) { |
|
bn_mul_recursive( & (r[n2]), & (a[n]), & (b[n]), i, tna - i, tnb - i, p); |
|
memset( & r[n2 + i * 2], 0, sizeof( * r) * (n2 - i * 2)); |
|
} else if (j > 0) { |
|
bn_mul_part_recursive( & (r[n2]), & (a[n]), & (b[n]), i, tna - i, tnb - i, p); |
|
memset( & (r[n2 + tna + tnb]), 0, sizeof(BN_ULONG) * (n2 - tna - tnb)); |
|
} else { |
|
memset( & r[n2], 0, sizeof( * r) * n2); |
|
if (tna < BN_MUL_RECURSIVE_SIZE_NORMAL && tnb < BN_MUL_RECURSIVE_SIZE_NORMAL) { |
|
bn_mul_normal( & (r[n2]), & (a[n]), tna, & (b[n]), tnb); |
|
} else { |
|
for (;;) { |
|
i /= 2; |
|
if (i < tna || i < tnb) { |
|
bn_mul_part_recursive( & (r[n2]), & (a[n]), & (b[n]), i, tna - i, tnb - i, p); |
|
break; |
|
} else if (i == tna || i == tnb) { |
|
bn_mul_recursive( & (r[n2]), & (a[n]), & (b[n]), i, tna - i, tnb - i, p); |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
c1 = (int)(bn_add_words(t, r, & (r[n2]), n2)); |
|
if (neg) { |
|
c1 -= (int)(bn_sub_words( & (t[n2]), t, & (t[n2]), n2)); |
|
} else { |
|
c1 += (int)(bn_add_words( & (t[n2]), & (t[n2]), t, n2)); |
|
} |
|
c1 += (int)(bn_add_words( & (r[n]), & (r[n]), & (t[n2]), n2)); |
|
if (c1) { |
|
p = & (r[n + n2]); |
|
lo = * p; |
|
ln = (lo + c1) & BN_MASK2;* p = ln; |
|
if (ln < (BN_ULONG) c1) { |
|
do { |
|
p++; |
|
lo = * p; |
|
ln = (lo + 1) & BN_MASK2;* p = ln; |
|
} while (ln == 0); |
|
} |
|
} |
|
}', |
|
'void bn_mul_normal(BN_ULONG * r, BN_ULONG * a, int na, BN_ULONG * b, int nb) { |
|
BN_ULONG * rr; |
|
if (na < nb) { |
|
int itmp; |
|
BN_ULONG * ltmp; |
|
itmp = na; |
|
na = nb; |
|
nb = itmp; |
|
ltmp = a; |
|
a = b; |
|
b = ltmp; |
|
} |
|
rr = & (r[na]); |
|
if (nb <= 0) { |
|
(void) bn_mul_words(r, a, na, 0); |
|
return; |
|
} else rr[0] = bn_mul_words(r, a, na, b[0]); |
|
for (;;) { |
|
if (--nb <= 0) return; |
|
rr[1] = bn_mul_add_words( & (r[1]), a, na, b[1]); |
|
if (--nb <= 0) return; |
|
rr[2] = bn_mul_add_words( & (r[2]), a, na, b[2]); |
|
if (--nb <= 0) return; |
|
rr[3] = bn_mul_add_words( & (r[3]), a, na, b[3]); |
|
if (--nb <= 0) return; |
|
rr[4] = bn_mul_add_words( & (r[4]), a, na, b[4]); |
|
rr += 4; |
|
r += 4; |
|
b += 4; |
|
} |
|
}' |
|
] |
|
``` |
|
|
|
[Leaderboard README](https://github.com/IBM/D2A/blob/main/leaderboard/README.md) || [Leaderboard page](https://ibm.github.io/D2A) |
