crypto/ec/ecdsa_ossl.c:277: error: BUFFER_OVERRUN_L3
  Offset: [16, +oo] (⇐ 1 + [15, +oo]) Size: [0, 8388607] by call to `ecdsa_sign_setup`.
Showing all 47 steps of the trace


crypto/ec/ecdsa_ossl.c:211:1: Parameter `eckey->group->order->top`
209.   }
210.   
211. > ECDSA_SIG *ossl_ecdsa_sign_sig(const unsigned char *dgst, int dgst_len,
212.                                  const BIGNUM *in_kinv, const BIGNUM *in_r,
213.                                  EC_KEY *eckey)

crypto/ec/ecdsa_ossl.c:260:9: Call
258.           goto err;
259.       }
260.       i = BN_num_bits(order);
               ^
261.       /*
262.        * Need to truncate digest if it is too long: first truncate whole bytes.

crypto/bn/bn_lib.c:139:9: Call
  137.       bn_check_top(a);
  138.   
  139.       if (BN_is_zero(a))
                 ^
  140.           return 0;
  141.       return ((i * BN_BITS2) + BN_num_bits_word(a->d[i]));

crypto/bn/bn_lib.c:814:1: Parameter `a->top`
    812.   }
    813.   
    814. > int BN_is_zero(const BIGNUM *a)
    815.   {
    816.       return a->top == 0;

crypto/ec/ecdsa_ossl.c:277:18: Call
275.       do {
276.           if (in_kinv == NULL || in_r == NULL) {
277.               if (!ecdsa_sign_setup(eckey, ctx, &kinv, &ret->r, dgst, dgst_len)) {
                        ^
278.                   ECerr(EC_F_OSSL_ECDSA_SIGN_SIG, ERR_R_ECDSA_LIB);
279.                   goto err;

crypto/ec/ecdsa_ossl.c:34:1: Parameter `eckey->group->order->top`
  32.   }
  33.   
  34. > static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in,
  35.                               BIGNUM **kinvp, BIGNUM **rp,
  36.                               const unsigned char *dgst, int dlen)

crypto/ec/ecdsa_ossl.c:82:18: Call
  80.   
  81.       /* Preallocate space */
  82.       order_bits = BN_num_bits(order);
                         ^
  83.       if (!BN_set_bit(k, order_bits)
  84.           || !BN_set_bit(r, order_bits)

crypto/bn/bn_lib.c:139:9: Call
    137.       bn_check_top(a);
    138.   
    139.       if (BN_is_zero(a))
                   ^
    140.           return 0;
    141.       return ((i * BN_BITS2) + BN_num_bits_word(a->d[i]));

crypto/bn/bn_lib.c:814:1: Parameter `a->top`
      812.   }
      813.   
      814. > int BN_is_zero(const BIGNUM *a)
      815.   {
      816.       return a->top == 0;

crypto/ec/ecdsa_ossl.c:100:22: Call
  98.                   }
  99.               } else {
  100.                   if (!BN_priv_rand_range(k, order)) {
                              ^
  101.                       ECerr(EC_F_ECDSA_SIGN_SETUP,
  102.                                EC_R_RANDOM_NUMBER_GENERATION_FAILED);

crypto/bn/bn_rand.c:182:1: Parameter `range->top`
    180.   }
    181.   
    182. > int BN_priv_rand_range(BIGNUM *r, const BIGNUM *range)
    183.   {
    184.       return bnrand_range(PRIVATE, r, range);

crypto/bn/bn_rand.c:184:12: Call
    182.   int BN_priv_rand_range(BIGNUM *r, const BIGNUM *range)
    183.   {
    184.       return bnrand_range(PRIVATE, r, range);
                      ^
    185.   }
    186.   

crypto/bn/bn_rand.c:113:1: Parameter `range->top`
      111.   
      112.   /* random number r:  0 <= r < range */
      113. > static int bnrand_range(BNRAND_FLAG flag, BIGNUM *r, const BIGNUM *range)
      114.   {
      115.       int n;

crypto/ec/ecdsa_ossl.c:120:14: Call
  118.            * conditional copy.
  119.            */
  120.           if (!BN_add(r, k, order)
                      ^
  121.               || !BN_add(X, r, order)
  122.               || !BN_copy(k, BN_num_bits(r) > order_bits ? r : X))

crypto/bn/bn_add.c:14:1: Parameter `b->top`
    12.   
    13.   /* signed add of b to a. */
    14. > int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
    15.   {
    16.       int ret, r_neg, cmp_res;

crypto/ec/ecdsa_ossl.c:121:17: Call
  119.            */
  120.           if (!BN_add(r, k, order)
  121.               || !BN_add(X, r, order)
                         ^
  122.               || !BN_copy(k, BN_num_bits(r) > order_bits ? r : X))
  123.               goto err;

crypto/bn/bn_add.c:14:1: Parameter `b->top`
    12.   
    13.   /* signed add of b to a. */
    14. > int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
    15.   {
    16.       int ret, r_neg, cmp_res;

crypto/ec/ecdsa_ossl.c:149:14: Call
  147.           }
  148.   #endif
  149.           if (!BN_nnmod(r, X, order, ctx)) {
                      ^
  150.               ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
  151.               goto err;

crypto/bn/bn_mod.c:13:1: Parameter `d->top`
    11.   #include "bn_lcl.h"
    12.   
    13. > int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx)
    14.   {
    15.       /*

crypto/bn/bn_mod.c:20:11: Call
    18.        */
    19.   
    20.       if (!(BN_mod(r, m, d, ctx)))
                    ^
    21.           return 0;
    22.       if (!r->neg)

crypto/bn/bn_div.c:137:1: Parameter `divisor->top`
      135.    * If 'dv' or 'rm' is NULL, the respective value is not returned.
      136.    */
      137. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
      138.              BN_CTX *ctx)
      139.   {

crypto/ec/ecdsa_ossl.c:168:18: Call
  166.                   goto err;
  167.               }
  168.               if (!BN_mod_sub(X, order, X, order, ctx)) {
                          ^
  169.                   ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
  170.                   goto err;

crypto/bn/bn_mod.c:50:1: Parameter `a->top`
    48.   }
    49.   
    50. > int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
    51.                  BN_CTX *ctx)
    52.   {

crypto/bn/bn_mod.c:53:10: Call
    51.                  BN_CTX *ctx)
    52.   {
    53.       if (!BN_sub(r, a, b))
                   ^
    54.           return 0;
    55.       return BN_nnmod(r, r, m, ctx);

crypto/bn/bn_add.c:45:1: Parameter `a->top`
      43.   
      44.   /* signed sub of b from a. */
      45. > int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
      46.   {
      47.       int ret, r_neg, cmp_res;

crypto/ec/ecdsa_ossl.c:173:18: Call
  171.               }
  172.               BN_set_flags(X, BN_FLG_CONSTTIME);
  173.               if (!BN_mod_exp_mont_consttime(k, k, X, order, ctx,
                          ^
  174.                                              group->mont_data)) {
  175.                   ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);

crypto/bn/bn_exp.c:747:14: Assignment
    745.           /* 2^(top*BN_BITS2) - m */
    746.           tmp.d[0] = (0 - m->d[0]) & BN_MASK2;
    747.           for (i = 1; i < top; i++)
                        ^
    748.               tmp.d[i] = (~m->d[i]) & BN_MASK2;
    749.           tmp.top = top;

crypto/bn/bn_exp.c:1046:14: Call
    1044.           for (wvalue = 0, i = bits % window; i >= 0; i--, bits--)
    1045.               wvalue = (wvalue << 1) + BN_is_bit_set(p, bits);
    1046.           if (!MOD_EXP_CTIME_COPY_FROM_PREBUF(&tmp, top, powerbuf, wvalue,
                         ^
    1047.                                               window))
    1048.               goto err;

crypto/bn/bn_exp.c:522:1: Parameter `top`
      520.   }
      521.   
      522. > static int MOD_EXP_CTIME_COPY_FROM_PREBUF(BIGNUM *b, int top,
      523.                                             unsigned char *buf, int idx,
      524.                                             int window)

crypto/bn/bn_exp.c:579:5: Assignment
      577.       }
      578.   
      579.       b->top = top;
                 ^
      580.       bn_correct_top(b);
      581.       return 1;

crypto/bn/bn_exp.c:580:5: Call
      578.   
      579.       b->top = top;
      580.       bn_correct_top(b);
                 ^
      581.       return 1;
      582.   }

crypto/bn/bn_lib.c:915:1: Parameter `a->top`
        913.   }
        914.   
        915. > void bn_correct_top(BIGNUM *a)
        916.   {
        917.       BN_ULONG *ftl;

crypto/bn/bn_exp.c:1059:22: Call
    1057.               /* Scan the window, squaring the result as we go */
    1058.               for (i = 0; i < window; i++, bits--) {
    1059.                   if (!BN_mod_mul_montgomery(&tmp, &tmp, &tmp, mont, ctx))
                                 ^
    1060.                       goto err;
    1061.                   wvalue = (wvalue << 1) + BN_is_bit_set(p, bits);

crypto/bn/bn_mont.c:26:1: Parameter `a->top`
      24.   #endif
      25.   
      26. > int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
      27.                             BN_MONT_CTX *mont, BN_CTX *ctx)
      28.   {

crypto/bn/bn_mont.c:53:14: Call
      51.       bn_check_top(tmp);
      52.       if (a == b) {
      53.           if (!BN_sqr(tmp, a, ctx))
                         ^
      54.               goto err;
      55.       } 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 `ecdsa_sign_setup` 
          118.       if (--j > 0) {
          119.           ap++;
          120.           rp[j] = bn_mul_words(rp, ap, j, ap[-1]);
                         ^
          121.           rp += 2;
          122.       }
