crypto/bn/bn_exp.c:360: error: BUFFER_OVERRUN_L3
  Offset: [-1, +oo] Size: [1, +oo] by call to `BN_to_montgomery`.
Showing all 20 steps of the trace


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

crypto/bn/bn_exp.c:329:5: Call
327.       }
328.   
329.       BN_CTX_start(ctx);
           ^
330.       d = BN_CTX_get(ctx);
331.       r = 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_exp.c:360:10: Call
358.           goto err;
359.       }
360.       if (!BN_to_montgomery(val[0], aa, mont, ctx))
                ^
361.           goto err;               /* 1 */
362.   

crypto/bn/bn_lib.c:877:1: Parameter `ctx->stack.depth`
  875.   }
  876.   
  877. > int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
  878.                        BN_CTX *ctx)
  879.   {

crypto/bn/bn_lib.c:880:12: Call
  878.                        BN_CTX *ctx)
  879.   {
  880.       return BN_mod_mul_montgomery(r, a, &(mont->RR), mont, ctx);
                    ^
  881.   }
  882.   

crypto/bn/bn_mont.c:26:1: Parameter `ctx->stack.depth`
    24.   #endif
    25.   
    26. > int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
    27.                             BN_MONT_CTX *mont, BN_CTX *ctx)
    28.   {

crypto/bn/bn_mont.c:46:5: Call
    44.   #endif
    45.   
    46.       BN_CTX_start(ctx);
              ^
    47.       tmp = BN_CTX_get(ctx);
    48.       if (tmp == NULL)

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:53:14: Call
    51.       bn_check_top(tmp);
    52.       if (a == b) {
    53.           if (!BN_sqr(tmp, a, ctx))
                       ^
    54.               goto err;
    55.       } else {

crypto/bn/bn_sqr.c:32:5: Call
      30.       }
      31.   
      32.       BN_CTX_start(ctx);
                ^
      33.       rr = (a != r) ? r : BN_CTX_get(ctx);
      34.       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_sqr.c:100:5: Call
      98.       bn_check_top(rr);
      99.       bn_check_top(tmp);
      100.       BN_CTX_end(ctx);
                 ^
      101.       return (ret);
      102.   }

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:271:1: <Offset trace>
269.   }
270.   
271. > static unsigned int BN_STACK_pop(BN_STACK *st)
272.   {
273.       return st->indexes[--(st->depth)];

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

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

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

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