crypto/bn/bn_exp2.c:83: 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_exp2.c:16:1: Parameter `ctx->stack.depth`
14.   #define TABLE_SIZE      32
15.   
16. > int BN_mod_exp2_mont(BIGNUM *rr, const BIGNUM *a1, const BIGNUM *p1,
17.                        const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m,
18.                        BN_CTX *ctx, BN_MONT_CTX *in_mont)

crypto/bn/bn_exp2.c:48:5: Call
46.       bits = (bits1 > bits2) ? bits1 : bits2;
47.   
48.       BN_CTX_start(ctx);
          ^
49.       d = BN_CTX_get(ctx);
50.       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_exp2.c:83:10: Call
81.       }
82.   
83.       if (!BN_to_montgomery(val1[0], a_mod_m, mont, ctx))
               ^
84.           goto err;
85.       if (window1 > 1) {

crypto/bn/bn_lib.c:943:1: Parameter `ctx->stack.depth`
  941.   }
  942.   
  943. > int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
  944.                        BN_CTX *ctx)
  945.   {

crypto/bn/bn_lib.c:946:12: Call
  944.                        BN_CTX *ctx)
  945.   {
  946.       return BN_mod_mul_montgomery(r, a, &(mont->RR), mont, ctx);
                    ^
  947.   }
  948.   

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:99:5: Call
      97.       bn_check_top(rr);
      98.       bn_check_top(tmp);
      99.       BN_CTX_end(ctx);
                 ^
      100.       return (ret);
      101.   }

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.   
