crypto/sm2/sm2_sign.c:123: error: BUFFER_OVERRUN_L3
  Offset: [16, +oo] (⇐ 1 + [15, +oo]) Size: [0, 8388607] by call to `BN_mod_mul`.
Showing all 22 steps of the trace


crypto/sm2/sm2_sign.c:120:9: Call
118.               continue;
119.   
120.           BN_add(s, dA, BN_value_one());
               ^
121.           BN_mod_inverse(s, s, order, ctx);
122.   

crypto/bn/bn_add.c:40:18: Call
  38.   
  39.           if (BN_ucmp(a, b) < 0) {
  40.               if (!BN_usub(r, b, a))
                         ^
  41.                   return 0;
  42.               r->neg = 1;

crypto/bn/bn_add.c:107:1: Parameter `r->top`
    105.   
    106.   /* unsigned subtraction of b from a, a must be larger than b. */
    107. > int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
    108.   {
    109.       int max, min, dif;

crypto/sm2/sm2_sign.c:121:9: Call
119.   
120.           BN_add(s, dA, BN_value_one());
121.           BN_mod_inverse(s, s, order, ctx);
               ^
122.   
123.           BN_mod_mul(tmp, dA, r, order, ctx);

crypto/bn/bn_gcd.c:124:1: Parameter `a->top`
  122.                                           BN_CTX *ctx);
  123.   
  124. > BIGNUM *BN_mod_inverse(BIGNUM *in,
  125.                          const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx)
  126.   {

crypto/bn/bn_gcd.c:129:10: Call
  127.       BIGNUM *rv;
  128.       int noinv;
  129.       rv = int_bn_mod_inverse(in, a, n, ctx, &noinv);
                  ^
  130.       if (noinv)
  131.           BNerr(BN_F_BN_MOD_INVERSE, BN_R_NO_INVERSE);

crypto/bn/bn_gcd.c:135:1: Parameter `a->top`
    133.   }
    134.   
    135. > BIGNUM *int_bn_mod_inverse(BIGNUM *in,
    136.                              const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx,
    137.                              int *pnoinv)

crypto/sm2/sm2_sign.c:123:9: Call
121.           BN_mod_inverse(s, s, order, ctx);
122.   
123.           BN_mod_mul(tmp, dA, r, order, ctx);
               ^
124.           BN_sub(tmp, k, tmp);
125.   

crypto/bn/bn_mod.c:73:1: Parameter `a->top`
  71.   
  72.   /* slow but works */
  73. > int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
  74.                  BN_CTX *ctx)
  75.   {

crypto/bn/bn_mod.c:87:14: Call
  85.           goto err;
  86.       if (a == b) {
  87.           if (!BN_sqr(t, a, ctx))
                     ^
  88.               goto err;
  89.       } else {

crypto/bn/bn_sqr.c:17:1: Parameter `a->top`
    15.    * I've just gone over this and it is now %20 faster on x86 - eay - 27 Jun 96
    16.    */
    17. > int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx)
    18.   {
    19.       int max, al;

crypto/bn/bn_sqr.c:25:5: Assignment
    23.       bn_check_top(a);
    24.   
    25.       al = a->top;
              ^
    26.       if (al <= 0) {
    27.           r->top = 0;

crypto/bn/bn_sqr.c:74:17: Call
    72.                   if (bn_wexpand(tmp, max) == NULL)
    73.                       goto err;
    74.                   bn_sqr_normal(rr->d, a->d, al, tmp->d);
                          ^
    75.               }
    76.           }

crypto/bn/bn_sqr.c:105:1: <Offset trace>
103.   
104.   /* tmp must have 2*n words */
105. > void bn_sqr_normal(BN_ULONG *r, const BN_ULONG *a, int n, BN_ULONG *tmp)
106.   {
107.       int i, j, max;

crypto/bn/bn_sqr.c:105:1: Parameter `n`
      103.   
      104.   /* tmp must have 2*n words */
      105. > void bn_sqr_normal(BN_ULONG *r, const BN_ULONG *a, int n, BN_ULONG *tmp)
      106.   {
      107.       int i, j, max;

crypto/bn/bn_sqr.c:116:5: Assignment
      114.       rp[0] = rp[max - 1] = 0;
      115.       rp++;
      116.       j = n;
                 ^
      117.   
      118.       if (--j > 0) {

crypto/bn/bn_sqr.c:118:9: Assignment
      116.       j = n;
      117.   
      118.       if (--j > 0) {
                     ^
      119.           ap++;
      120.           rp[j] = bn_mul_words(rp, ap, j, ap[-1]);

crypto/bn/bn_sqr.c:105:1: <Length trace>
103.   
104.   /* tmp must have 2*n words */
105. > void bn_sqr_normal(BN_ULONG *r, const BN_ULONG *a, int n, BN_ULONG *tmp)
106.   {
107.       int i, j, max;

crypto/bn/bn_sqr.c:105:1: Parameter `*r`
      103.   
      104.   /* tmp must have 2*n words */
      105. > void bn_sqr_normal(BN_ULONG *r, const BN_ULONG *a, int n, BN_ULONG *tmp)
      106.   {
      107.       int i, j, max;

crypto/bn/bn_sqr.c:113:5: Assignment
      111.       max = n * 2;
      112.       ap = a;
      113.       rp = r;
                 ^
      114.       rp[0] = rp[max - 1] = 0;
      115.       rp++;

crypto/bn/bn_sqr.c:115:5: Assignment
      113.       rp = r;
      114.       rp[0] = rp[max - 1] = 0;
      115.       rp++;
                 ^
      116.       j = n;
      117.   

crypto/bn/bn_sqr.c:120:9: Array access: Offset: [16, +oo] (⇐ 1 + [15, +oo]) Size: [0, 8388607] by call to `BN_mod_mul` 
      118.       if (--j > 0) {
      119.           ap++;
      120.           rp[j] = bn_mul_words(rp, ap, j, ap[-1]);
                     ^
      121.           rp += 2;
      122.       }
