crypto/ec/ecdsa_ossl.c:140: error: BUFFER_OVERRUN_L3
  Offset added: [8, +oo] Size: [0, 67108856] by call to `ec_group_do_inverse_ord`.
Showing all 36 steps of the trace


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:845:1: Parameter `a->top`
    843.   }
    844.   
    845. > int BN_is_zero(const BIGNUM *a)
    846.   {
    847.       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:132:14: Call
130.           }
131.   #endif
132.           if (!BN_nnmod(r, X, order, ctx)) {
                    ^
133.               ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
134.               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:140:10: Call
138.   
139.       /* compute the inverse of k */
140.       if (!ec_group_do_inverse_ord(group, k, k, ctx)) {
                ^
141.           ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
142.           goto err;

crypto/ec/ec_lib.c:1074:1: Parameter `group->order->top`
  1072.    * other functionality.
  1073.    */
  1074. > int ec_group_do_inverse_ord(const EC_GROUP *group, BIGNUM *res,
  1075.                               const BIGNUM *x, BN_CTX *ctx)
  1076.   {

crypto/ec/ec_lib.c:1080:16: Call
  1078.           return group->meth->field_inverse_mod_ord(group, res, x, ctx);
  1079.       else
  1080.           return ec_field_inverse_mod_ord(group, res, x, ctx);
                         ^
  1081.   }
  1082.   

crypto/ec/ec_lib.c:1020:1: Parameter `group->order->top`
    1018.   }
    1019.   
    1020. > static int ec_field_inverse_mod_ord(const EC_GROUP *group, BIGNUM *r,
    1021.                                       const BIGNUM *x, BN_CTX *ctx)
    1022.   {

crypto/ec/ec_lib.c:1043:10: Call
    1041.       if (!BN_set_word(e, 2))
    1042.           goto err;
    1043.       if (!BN_sub(e, group->order, e))
                     ^
    1044.           goto err;
    1045.       /*-

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/ec_lib.c:1049:10: Call
    1047.        * No need for scatter-gather or BN_FLG_CONSTTIME.
    1048.        */
    1049.       if (!BN_mod_exp_mont(r, x, e, group->order, ctx, group->mont_data))
                     ^
    1050.           goto err;
    1051.   

crypto/bn/bn_exp.c:296:1: Parameter `m->top`
      294.   }
      295.   
      296. > int BN_mod_exp_mont(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
      297.                       const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
      298.   {

crypto/bn/bn_exp.c:310:16: Call
      308.               || BN_get_flags(a, BN_FLG_CONSTTIME) != 0
      309.               || BN_get_flags(m, BN_FLG_CONSTTIME) != 0) {
      310.           return BN_mod_exp_mont_consttime(rr, a, p, m, ctx, in_mont);
                            ^
      311.       }
      312.   

crypto/bn/bn_exp.c:596:1: Parameter `m->top`
        594.    * http://www.daemonology.net/hyperthreading-considered-harmful/)
        595.    */
        596. > int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
        597.                                 const BIGNUM *m, BN_CTX *ctx,
        598.                                 BN_MONT_CTX *in_mont)

crypto/bn/bn_exp.c:617:10: Call
        615.       bn_check_top(m);
        616.   
        617.       if (!BN_is_odd(m)) {
                        ^
        618.           BNerr(BN_F_BN_MOD_EXP_MONT_CONSTTIME, BN_R_CALLED_WITH_EVEN_MODULUS);
        619.           return 0;

crypto/bn/bn_lib.c:860:1: Parameter `a->top`
          858.   }
          859.   
          860. > int BN_is_odd(const BIGNUM *a)
          861.   {
          862.       return (a->top > 0) && (a->d[0] & 1);

crypto/bn/bn_exp.c:651:14: Call
        649.           if ((mont = BN_MONT_CTX_new()) == NULL)
        650.               goto err;
        651.           if (!BN_MONT_CTX_set(mont, m, ctx))
                            ^
        652.               goto err;
        653.       }

crypto/bn/bn_mont.c:233:1: Parameter `mod->top`
          231.   }
          232.   
          233. > int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx)
          234.   {
          235.       int ret = 0;

crypto/bn/bn_mont.c:238:9: Call
          236.       BIGNUM *Ri, *R;
          237.   
          238.       if (BN_is_zero(mod))
                         ^
          239.           return 0;
          240.   

crypto/bn/bn_lib.c:845:1: Parameter `a->top`
            843.   }
            844.   
            845. > int BN_is_zero(const BIGNUM *a)
            846.   {
            847.       return a->top == 0;

crypto/bn/bn_mont.c:245:10: Call
          243.           goto err;
          244.       R = &(mont->RR);            /* grab RR as a temp */
          245.       if (!BN_copy(&(mont->N), mod))
                          ^
          246.           goto err;               /* Set N */
          247.       if (BN_get_flags(mod, BN_FLG_CONSTTIME) != 0)

crypto/bn/bn_lib.c:285:1: <Offset trace>
283.   }
284.   
285. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
286.   {
287.       bn_check_top(b);

crypto/bn/bn_lib.c:285:1: Parameter `b->top`
            283.   }
            284.   
            285. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
            286.   {
            287.       bn_check_top(b);

crypto/bn/bn_lib.c:285:1: <Length trace>
283.   }
284.   
285. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
286.   {
287.       bn_check_top(b);

crypto/bn/bn_lib.c:285:1: Parameter `*a->d`
            283.   }
            284.   
            285. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
            286.   {
            287.       bn_check_top(b);

crypto/bn/bn_lib.c:291:9: Call
            289.       if (a == b)
            290.           return a;
            291.       if (bn_wexpand(a, b->top) == NULL)
                           ^
            292.           return NULL;
            293.   

crypto/bn/bn_lib.c:941:1: Parameter `*a->d`
              939.   }
              940.   
              941. > BIGNUM *bn_wexpand(BIGNUM *a, int words)
              942.   {
              943.       return (words <= a->dmax) ? a : bn_expand2(a, words);

crypto/bn/bn_lib.c:295:9: Array access: Offset added: [8, +oo] Size: [0, 67108856] by call to `ec_group_do_inverse_ord` 
            293.   
            294.       if (b->top > 0)
            295.           memcpy(a->d, b->d, sizeof(b->d[0]) * b->top);
                           ^
            296.   
            297.       a->top = b->top;
