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


crypto/bn/bn_blind.c:220:1: Parameter `ctx->stack.depth`
218.   }
219.   
220. > int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *ctx)
221.   {
222.       int ret = 1;

crypto/bn/bn_blind.c:242:10: Call
240.       }
241.   
242.       if (!BN_mod_mul(n, n, b->A, b->mod, ctx))
                ^
243.           ret = 0;
244.   

crypto/bn/bn_mod.c:178:1: Parameter `ctx->stack.depth`
  176.   
  177.   /* slow but works */
  178. > int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
  179.                  BN_CTX *ctx)
  180.   {

crypto/bn/bn_mod.c:188:5: Call
  186.       bn_check_top(m);
  187.   
  188.       BN_CTX_start(ctx);
             ^
  189.       if ((t = BN_CTX_get(ctx)) == NULL)
  190.           goto err;

crypto/bn/bn_ctx.c:235:1: Parameter `ctx->stack.depth`
    233.   }
    234.   
    235. > void BN_CTX_start(BN_CTX *ctx)
    236.   {
    237.       CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_mod.c:192:14: Call
  190.           goto err;
  191.       if (a == b) {
  192.           if (!BN_sqr(t, a, ctx))
                      ^
  193.               goto err;
  194.       } else {

crypto/bn/bn_sqr.c:65:1: Parameter `ctx->stack.depth`
    63.    * I've just gone over this and it is now %20 faster on x86 - eay - 27 Jun 96
    64.    */
    65. > int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx)
    66.   {
    67.       int max, al;

crypto/bn/bn_mod.c:198:10: Call
  196.               goto err;
  197.       }
  198.       if (!BN_nnmod(r, t, m, ctx))
                  ^
  199.           goto err;
  200.       bn_check_top(r);

crypto/bn/bn_mod.c:118:1: Parameter `ctx->stack.depth`
    116.   #include "bn_lcl.h"
    117.   
    118. > int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx)
    119.   {
    120.       /*

crypto/bn/bn_mod.c:125:11: Call
    123.        */
    124.   
    125.       if (!(BN_mod(r, m, d, ctx)))
                     ^
    126.           return 0;
    127.       if (!r->neg)

crypto/bn/bn_div.c:241:5: Call
      239.       }
      240.   
      241.       BN_CTX_start(ctx);
                 ^
      242.       tmp = BN_CTX_get(ctx);
      243.       snum = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:235:1: Parameter `*ctx->stack.indexes`
        233.   }
        234.   
        235. > void BN_CTX_start(BN_CTX *ctx)
        236.   {
        237.       CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_div.c:460:5: Call
      458.       if (no_branch)
      459.           bn_correct_top(res);
      460.       BN_CTX_end(ctx);
                 ^
      461.       return (1);
      462.    err:

crypto/bn/bn_ctx.c:249:1: Parameter `*ctx->stack.indexes`
        247.   }
        248.   
        249. > void BN_CTX_end(BN_CTX *ctx)
        250.   {
        251.       CTXDBG_ENTRY("BN_CTX_end", ctx);

crypto/bn/bn_ctx.c:255:27: Call
        253.           ctx->err_stack--;
        254.       else {
        255.           unsigned int fp = BN_STACK_pop(&ctx->stack);
                                         ^
        256.           /* Does this stack frame have anything to release? */
        257.           if (fp < ctx->used)

crypto/bn/bn_ctx.c:325:1: <Offset trace>
323.   }
324.   
325. > static unsigned int BN_STACK_pop(BN_STACK *st)
326.   {
327.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:325:1: Parameter `st->depth`
          323.   }
          324.   
          325. > static unsigned int BN_STACK_pop(BN_STACK *st)
          326.   {
          327.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:325:1: <Length trace>
323.   }
324.   
325. > static unsigned int BN_STACK_pop(BN_STACK *st)
326.   {
327.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:325:1: Parameter `*st->indexes`
          323.   }
          324.   
          325. > static unsigned int BN_STACK_pop(BN_STACK *st)
          326.   {
          327.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:327:12: Array access: Offset: [-1, +oo] Size: [1, +oo] by call to `BN_mod_mul` 
          325.   static unsigned int BN_STACK_pop(BN_STACK *st)
          326.   {
          327.       return st->indexes[--(st->depth)];
                            ^
          328.   }
          329.   
