crypto/ec/ecp_mont.c:157: error: BUFFER_OVERRUN_L3
  Offset: [-1, +oo] Size: [1, +oo] by call to `BN_MONT_CTX_set`.
Showing all 28 steps of the trace


crypto/ec/ecp_mont.c:135:1: Parameter `ctx->stack.depth`
133.   }
134.   
135. > int ec_GFp_mont_group_set_curve(EC_GROUP *group, const BIGNUM *p,
136.                                   const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
137.   {

crypto/ec/ecp_mont.c:157:10: Call
155.       if (mont == NULL)
156.           goto err;
157.       if (!BN_MONT_CTX_set(mont, p, ctx)) {
                ^
158.           ECerr(EC_F_EC_GFP_MONT_GROUP_SET_CURVE, ERR_R_BN_LIB);
159.           goto err;

crypto/bn/bn_mont.c:263:1: Parameter `ctx->stack.depth`
  261.   }
  262.   
  263. > int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx)
  264.   {
  265.       int i, ret = 0;

crypto/bn/bn_mont.c:271:5: Call
  269.           return 0;
  270.   
  271.       BN_CTX_start(ctx);
             ^
  272.       if ((Ri = BN_CTX_get(ctx)) == NULL)
  273.           goto err;

crypto/bn/bn_ctx.c:171:1: Parameter `ctx->stack.depth`
    169.   }
    170.   
    171. > void BN_CTX_start(BN_CTX *ctx)
    172.   {
    173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_mont.c:351:19: Call
  349.           if (BN_is_one(&tmod))
  350.               BN_zero(Ri);
  351.           else if ((BN_mod_inverse(Ri, R, &tmod, ctx)) == NULL)
                           ^
  352.               goto err;
  353.           if (!BN_lshift(Ri, Ri, BN_BITS2))

crypto/bn/bn_gcd.c:124:1: Parameter `ctx->stack.depth`
    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 `ctx->stack.depth`
      133.   }
      134.   
      135. > BIGNUM *int_bn_mod_inverse(BIGNUM *in,
      136.                              const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx,
      137.                              int *pnoinv)

crypto/bn/bn_gcd.c:155:16: Call
      153.       if ((BN_get_flags(a, BN_FLG_CONSTTIME) != 0)
      154.           || (BN_get_flags(n, BN_FLG_CONSTTIME) != 0)) {
      155.           return BN_mod_inverse_no_branch(in, a, n, ctx);
                            ^
      156.       }
      157.   

crypto/bn/bn_gcd.c:458:1: Parameter `ctx->stack.depth`
        456.    * not contain branches that may leak sensitive information.
        457.    */
        458. > static BIGNUM *BN_mod_inverse_no_branch(BIGNUM *in,
        459.                                           const BIGNUM *a, const BIGNUM *n,
        460.                                           BN_CTX *ctx)

crypto/bn/bn_gcd.c:469:5: Call
        467.       bn_check_top(n);
        468.   
        469.       BN_CTX_start(ctx);
                   ^
        470.       A = BN_CTX_get(ctx);
        471.       B = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:171:1: Parameter `ctx->stack.depth`
          169.   }
          170.   
          171. > void BN_CTX_start(BN_CTX *ctx)
          172.   {
          173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_gcd.c:504:18: Call
        502.               bn_init(&local_B);
        503.               BN_with_flags(&local_B, B, BN_FLG_CONSTTIME);
        504.               if (!BN_nnmod(B, &local_B, A, ctx))
                                ^
        505.                   goto err;
        506.               /* Ensure local_B goes out of scope before any further use of B */

crypto/bn/bn_mod.c:13:1: Parameter `ctx->stack.depth`
          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:209:1: Parameter `ctx->stack.depth`
            207.    * If 'dv' or 'rm' is NULL, the respective value is not returned.
            208.    */
            209. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
            210.              BN_CTX *ctx)
            211.   {

crypto/bn/bn_div.c:229:11: Call
            227.       }
            228.   
            229.       ret = bn_div_fixed_top(dv, rm, num, divisor, ctx);
                             ^
            230.   
            231.       if (ret) {

crypto/bn/bn_div.c:280:5: Call
              278.       bn_check_top(rm);
              279.   
              280.       BN_CTX_start(ctx);
                         ^
              281.       res = (dv == NULL) ? BN_CTX_get(ctx) : dv;
              282.       tmp = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:171:1: Parameter `*ctx->stack.indexes`
                169.   }
                170.   
                171. > void BN_CTX_start(BN_CTX *ctx)
                172.   {
                173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_div.c:450:5: Call
              448.       if (rm != NULL)
              449.           bn_rshift_fixed_top(rm, snum, norm_shift);
              450.       BN_CTX_end(ctx);
                         ^
              451.       return 1;
              452.    err:

crypto/bn/bn_ctx.c:185:1: Parameter `*ctx->stack.indexes`
                183.   }
                184.   
                185. > void BN_CTX_end(BN_CTX *ctx)
                186.   {
                187.       if (ctx == NULL)

crypto/bn/bn_ctx.c:193:27: Call
                191.           ctx->err_stack--;
                192.       else {
                193.           unsigned int fp = BN_STACK_pop(&ctx->stack);
                                                 ^
                194.           /* Does this stack frame have anything to release? */
                195.           if (fp < ctx->used)

crypto/bn/bn_ctx.c:268:1: <Offset trace>
266.   }
267.   
268. > static unsigned int BN_STACK_pop(BN_STACK *st)
269.   {
270.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:268:1: Parameter `st->depth`
                  266.   }
                  267.   
                  268. > static unsigned int BN_STACK_pop(BN_STACK *st)
                  269.   {
                  270.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:268:1: <Length trace>
266.   }
267.   
268. > static unsigned int BN_STACK_pop(BN_STACK *st)
269.   {
270.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:268:1: Parameter `*st->indexes`
                  266.   }
                  267.   
                  268. > static unsigned int BN_STACK_pop(BN_STACK *st)
                  269.   {
                  270.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:270:12: Array access: Offset: [-1, +oo] Size: [1, +oo] by call to `BN_MONT_CTX_set` 
                  268.   static unsigned int BN_STACK_pop(BN_STACK *st)
                  269.   {
                  270.       return st->indexes[--(st->depth)];
                                    ^
                  271.   }
                  272.   
