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


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

crypto/ec/ecdsa_ossl.c:76:18: Call
74.   
75.       /* Preallocate space */
76.       order_bits = BN_num_bits(order);
                       ^
77.       if (!BN_set_bit(k, order_bits)
78.           || !BN_set_bit(r, order_bits)

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

crypto/bn/bn_lib.c:852:1: Parameter `a->top`
    850.   }
    851.   
    852. > int BN_is_zero(const BIGNUM *a)
    853.   {
    854.       return a->top == 0;

crypto/ec/ecdsa_ossl.c:94:22: Call
92.                   }
93.               } else {
94.                   if (!BN_priv_rand_range(k, order)) {
                           ^
95.                       ECerr(EC_F_ECDSA_SIGN_SETUP,
96.                             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:103:14: Call
101.   
102.           /* compute r the x-coordinate of generator * k */
103.           if (!EC_POINT_mul(group, tmp_point, k, NULL, NULL, ctx)) {
                    ^
104.               ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);
105.               goto err;

crypto/ec/ec_lib.c:956:1: Parameter `group->order->top`
  954.   }
  955.   
  956. > int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_scalar,
  957.                    const EC_POINT *point, const BIGNUM *p_scalar, BN_CTX *ctx)
  958.   {

crypto/ec/ec_lib.c:967:12: Call
  965.       scalars[0] = p_scalar;
  966.   
  967.       return EC_POINTs_mul(group, r, g_scalar,
                    ^
  968.                            (point != NULL
  969.                             && 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:124:14: Call
122.           }
123.   #endif
124.           if (!BN_nnmod(r, X, order, ctx)) {
                    ^
125.               ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
126.               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:131:10: Call
129.   
130.       /* compute the inverse of k */
131.       if (!ec_group_do_inverse_ord(group, k, k, ctx)) {
                ^
132.           ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
133.           goto err;

crypto/ec/ec_lib.c:1101:1: Parameter `group->order->top`
  1099.    * other functionality.
  1100.    */
  1101. > int ec_group_do_inverse_ord(const EC_GROUP *group, BIGNUM *res,
  1102.                               const BIGNUM *x, BN_CTX *ctx)
  1103.   {

crypto/ec/ec_lib.c:1107:16: Call
  1105.           return group->meth->field_inverse_mod_ord(group, res, x, ctx);
  1106.       else
  1107.           return ec_field_inverse_mod_ord(group, res, x, ctx);
                         ^
  1108.   }
  1109.   

crypto/ec/ec_lib.c:1047:1: Parameter `group->order->top`
    1045.   }
    1046.   
    1047. > static int ec_field_inverse_mod_ord(const EC_GROUP *group, BIGNUM *r,
    1048.                                       const BIGNUM *x, BN_CTX *ctx)
    1049.   {

crypto/ec/ec_lib.c:1070:10: Call
    1068.       if (!BN_set_word(e, 2))
    1069.           goto err;
    1070.       if (!BN_sub(e, group->order, e))
                     ^
    1071.           goto err;
    1072.       /*-

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:1076:10: Call
    1074.        * No need for scatter-gather or BN_FLG_CONSTTIME.
    1075.        */
    1076.       if (!BN_mod_exp_mont(r, x, e, group->order, ctx, group->mont_data))
                     ^
    1077.           goto err;
    1078.   

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:597:1: Parameter `m->top`
        595.    * http://www.daemonology.net/hyperthreading-considered-harmful/)
        596.    */
        597. > int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
        598.                                 const BIGNUM *m, BN_CTX *ctx,
        599.                                 BN_MONT_CTX *in_mont)

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

crypto/bn/bn_lib.c:867:1: Parameter `a->top`
          865.   }
          866.   
          867. > int BN_is_odd(const BIGNUM *a)
          868.   {
          869.       return (a->top > 0) && (a->d[0] & 1);

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

crypto/bn/bn_mont.c:251:1: Parameter `mod->top`
          249.   }
          250.   
          251. > int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx)
          252.   {
          253.       int i, ret = 0;

crypto/bn/bn_mont.c:256:9: Call
          254.       BIGNUM *Ri, *R;
          255.   
          256.       if (BN_is_zero(mod))
                         ^
          257.           return 0;
          258.   

crypto/bn/bn_lib.c:852:1: Parameter `a->top`
            850.   }
            851.   
            852. > int BN_is_zero(const BIGNUM *a)
            853.   {
            854.       return a->top == 0;

crypto/bn/bn_mont.c:263:10: Call
          261.           goto err;
          262.       R = &(mont->RR);            /* grab RR as a temp */
          263.       if (!BN_copy(&(mont->N), mod))
                          ^
          264.           goto err;               /* Set N */
          265.       if (BN_get_flags(mod, BN_FLG_CONSTTIME) != 0)

crypto/bn/bn_lib.c:281:1: <Offset trace>
279.   }
280.   
281. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
282.   {
283.       bn_check_top(b);

crypto/bn/bn_lib.c:281:1: Parameter `b->top`
            279.   }
            280.   
            281. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
            282.   {
            283.       bn_check_top(b);

crypto/bn/bn_lib.c:281:1: <Length trace>
279.   }
280.   
281. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
282.   {
283.       bn_check_top(b);

crypto/bn/bn_lib.c:281:1: Parameter `*a->d`
            279.   }
            280.   
            281. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
            282.   {
            283.       bn_check_top(b);

crypto/bn/bn_lib.c:287:9: Call
            285.       if (a == b)
            286.           return a;
            287.       if (bn_wexpand(a, b->top) == NULL)
                           ^
            288.           return NULL;
            289.   

crypto/bn/bn_lib.c:948:1: Parameter `*a->d`
              946.   }
              947.   
              948. > BIGNUM *bn_wexpand(BIGNUM *a, int words)
              949.   {
              950.       return (words <= a->dmax) ? a : bn_expand2(a, words);

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