crypto/ec/ecdsa_ossl.c:156: error: BUFFER_OVERRUN_L3
  Offset added: [8, +oo] Size: [0, 67108856] by call to `BN_mod_exp_mont_consttime`.
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:109:14: Call
107.   
108.           /* compute r the x-coordinate of generator * k */
109.           if (!EC_POINT_mul(group, tmp_point, k, NULL, NULL, ctx)) {
                    ^
110.               ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);
111.               goto err;

crypto/ec/ec_lib.c:929:1: Parameter `group->order->top`
  927.   }
  928.   
  929. > int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_scalar,
  930.                    const EC_POINT *point, const BIGNUM *p_scalar, BN_CTX *ctx)
  931.   {

crypto/ec/ec_lib.c:940:12: Call
  938.       scalars[0] = p_scalar;
  939.   
  940.       return EC_POINTs_mul(group, r, g_scalar,
                    ^
  941.                            (point != NULL
  942.                             && p_scalar != NULL), points, scalars, ctx);

crypto/ec/ec_lib.c:918:1: Parameter `group->order->top`
    916.    */
    917.   
    918. > int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
    919.                     size_t num, const EC_POINT *points[],
    920.                     const BIGNUM *scalars[], BN_CTX *ctx)

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:151:18: Call
149.                   goto err;
150.               }
151.               if (!BN_mod_sub(X, order, X, order, ctx)) {
                        ^
152.                   ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
153.                   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:156:18: Call
154.               }
155.               BN_set_flags(X, BN_FLG_CONSTTIME);
156.               if (!BN_mod_exp_mont_consttime(k, k, X, order, ctx,
                        ^
157.                                              group->mont_data)) {
158.                   ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);

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

crypto/bn/bn_exp.c:619:10: Call
  617.       bn_check_top(m);
  618.   
  619.       if (!BN_is_odd(m)) {
                  ^
  620.           BNerr(BN_F_BN_MOD_EXP_MONT_CONSTTIME, BN_R_CALLED_WITH_EVEN_MODULUS);
  621.           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:653:14: Call
  651.           if ((mont = BN_MONT_CTX_new()) == NULL)
  652.               goto err;
  653.           if (!BN_MONT_CTX_set(mont, m, ctx))
                      ^
  654.               goto err;
  655.       }

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 `BN_mod_exp_mont_consttime` 
      293.   
      294.       if (b->top > 0)
      295.           memcpy(a->d, b->d, sizeof(b->d[0]) * b->top);
                     ^
      296.   
      297.       a->top = b->top;
