crypto/bn/bn_exp2.c:111: error: BUFFER_OVERRUN_L3
  Offset: [-1, +oo] Size: [1, +oo] by call to `BN_to_montgomery`.
Showing all 24 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:839:1: Parameter `ctx->stack.depth`
  837.   }
  838.   
  839. > int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
  840.                        BN_CTX *ctx)
  841.   {

crypto/bn/bn_lib.c:842:12: Call
  840.                        BN_CTX *ctx)
  841.   {
  842.       return BN_mod_mul_montgomery(r, a, &(mont->RR), mont, ctx);
                    ^
  843.   }
  844.   

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_exp2.c:111:10: Call
109.           goto err;
110.       }
111.       if (!BN_to_montgomery(val2[0], a_mod_m, mont, ctx))
                ^
112.           goto err;
113.       if (window2 > 1) {

crypto/bn/bn_lib.c:839:1: Parameter `ctx->stack.depth`
  837.   }
  838.   
  839. > int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
  840.                        BN_CTX *ctx)
  841.   {

crypto/bn/bn_lib.c:842:12: Call
  840.                        BN_CTX *ctx)
  841.   {
  842.       return BN_mod_mul_montgomery(r, a, &(mont->RR), mont, ctx);
                    ^
  843.   }
  844.   

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:56:14: Call
    54.               goto err;
    55.       } else {
    56.           if (!BN_mul(tmp, a, b, ctx))
                       ^
    57.               goto err;
    58.       }

crypto/bn/bn_mul.c:523:5: Call
      521.       top = al + bl;
      522.   
      523.       BN_CTX_start(ctx);
                 ^
      524.       if ((r == a) || (r == b)) {
      525.           if ((rr = BN_CTX_get(ctx)) == NULL)

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_mul.c:608:5: Call
      606.    err:
      607.       bn_check_top(r);
      608.       BN_CTX_end(ctx);
                 ^
      609.       return ret;
      610.   }

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.   
