crypto/ec/ec_lib.c:1049: error: BUFFER_OVERRUN_L3
  Offset: [-1, +oo] Size: [1, +oo] by call to `BN_mod_exp_mont`.
Showing all 34 steps of the trace


crypto/ec/ec_lib.c:1020:1: Parameter `ctx->stack.depth`
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:1033:5: Call
1031.           return 0;
1032.   
1033.       BN_CTX_start(ctx);
            ^
1034.       if ((e = BN_CTX_get(ctx)) == NULL)
1035.           goto err;

crypto/bn/bn_ctx.c:181:1: Parameter `ctx->stack.depth`
  179.   }
  180.   
  181. > void BN_CTX_start(BN_CTX *ctx)
  182.   {
  183.       CTXDBG_ENTRY("BN_CTX_start", ctx);

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 `ctx->stack.depth`
  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 `ctx->stack.depth`
    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:640:5: Call
    638.       }
    639.   
    640.       BN_CTX_start(ctx);
               ^
    641.   
    642.       /*

crypto/bn/bn_ctx.c:181:1: Parameter `ctx->stack.depth`
      179.   }
      180.   
      181. > void BN_CTX_start(BN_CTX *ctx)
      182.   {
      183.       CTXDBG_ENTRY("BN_CTX_start", ctx);

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 `ctx->stack.depth`
      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:241:5: Call
      239.           return 0;
      240.   
      241.       BN_CTX_start(ctx);
                 ^
      242.       if ((Ri = BN_CTX_get(ctx)) == NULL)
      243.           goto err;

crypto/bn/bn_ctx.c:181:1: Parameter `ctx->stack.depth`
        179.   }
        180.   
        181. > void BN_CTX_start(BN_CTX *ctx)
        182.   {
        183.       CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_mont.c:321:19: Call
      319.           if (BN_is_one(&tmod))
      320.               BN_zero(Ri);
      321.           else if ((BN_mod_inverse(Ri, R, &tmod, ctx)) == NULL)
                               ^
      322.               goto err;
      323.           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:181:1: Parameter `ctx->stack.depth`
              179.   }
              180.   
              181. > void BN_CTX_start(BN_CTX *ctx)
              182.   {
              183.       CTXDBG_ENTRY("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:190:5: Call
                188.       }
                189.   
                190.       BN_CTX_start(ctx);
                           ^
                191.       res = (dv == NULL) ? BN_CTX_get(ctx) : dv;
                192.       tmp = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:181:1: Parameter `*ctx->stack.indexes`
                  179.   }
                  180.   
                  181. > void BN_CTX_start(BN_CTX *ctx)
                  182.   {
                  183.       CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_div.c:410:5: Call
                408.       if (no_branch)
                409.           bn_correct_top(res);
                410.       BN_CTX_end(ctx);
                           ^
                411.       return 1;
                412.    err:

crypto/bn/bn_ctx.c:195:1: Parameter `*ctx->stack.indexes`
                  193.   }
                  194.   
                  195. > void BN_CTX_end(BN_CTX *ctx)
                  196.   {
                  197.       CTXDBG_ENTRY("BN_CTX_end", ctx);

crypto/bn/bn_ctx.c:201:27: Call
                  199.           ctx->err_stack--;
                  200.       else {
                  201.           unsigned int fp = BN_STACK_pop(&ctx->stack);
                                                   ^
                  202.           /* Does this stack frame have anything to release? */
                  203.           if (fp < ctx->used)

crypto/bn/bn_ctx.c:274:1: <Offset trace>
272.   }
273.   
274. > static unsigned int BN_STACK_pop(BN_STACK *st)
275.   {
276.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:274:1: Parameter `st->depth`
                    272.   }
                    273.   
                    274. > static unsigned int BN_STACK_pop(BN_STACK *st)
                    275.   {
                    276.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:274:1: <Length trace>
272.   }
273.   
274. > static unsigned int BN_STACK_pop(BN_STACK *st)
275.   {
276.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:274:1: Parameter `*st->indexes`
                    272.   }
                    273.   
                    274. > static unsigned int BN_STACK_pop(BN_STACK *st)
                    275.   {
                    276.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:276:12: Array access: Offset: [-1, +oo] Size: [1, +oo] by call to `BN_mod_exp_mont` 
                    274.   static unsigned int BN_STACK_pop(BN_STACK *st)
                    275.   {
                    276.       return st->indexes[--(st->depth)];
                                      ^
                    277.   }
                    278.   
