crypto/rsa/rsa_ossl.c:425: error: BUFFER_OVERRUN_L3
  Offset: [-1, +oo] Size: [1, +oo] by call to `rsa_blinding_convert`.
Showing all 19 steps of the trace


crypto/rsa/rsa_ossl.c:382:5: Call
380.       if ((ctx = BN_CTX_new()) == NULL)
381.           goto err;
382.       BN_CTX_start(ctx);
           ^
383.       f = BN_CTX_get(ctx);
384.       ret = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:171:1: Parameter `ctx->stack.depth`
  169.   }
  170.   
  171. > void BN_CTX_start(BN_CTX *ctx)
  172.   {
  173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/rsa/rsa_ossl.c:425:14: Call
423.               goto err;
424.           }
425.           if (!rsa_blinding_convert(blinding, f, unblind, ctx))
                    ^
426.               goto err;
427.       }

crypto/rsa/rsa_ossl.c:197:1: Parameter `ctx->stack.depth`
  195.   }
  196.   
  197. > static int rsa_blinding_convert(BN_BLINDING *b, BIGNUM *f, BIGNUM *unblind,
  198.                                   BN_CTX *ctx)
  199.   {

crypto/rsa/rsa_ossl.c:204:16: Call
  202.            * Local blinding: store the unblinding factor in BN_BLINDING.
  203.            */
  204.           return BN_BLINDING_convert_ex(f, NULL, b, ctx);
                        ^
  205.       } else {
  206.           /*

crypto/bn/bn_blind.c:134:1: Parameter `ctx->stack.depth`
    132.   }
    133.   
    134. > int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *ctx)
    135.   {
    136.       int ret = 1;

crypto/bn/bn_blind.c:148:15: Call
    146.           /* Fresh blinding, doesn't need updating. */
    147.           b->counter = 0;
    148.       else if (!BN_BLINDING_update(b, ctx))
                         ^
    149.           return 0;
    150.   

crypto/bn/bn_blind.c:93:1: Parameter `ctx->stack.depth`
      91.   }
      92.   
      93. > int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx)
      94.   {
      95.       int ret = 0;

crypto/bn/bn_blind.c:116:18: Call
      114.                   goto err;
      115.           } else {
      116.               if (!BN_mod_mul(b->Ai, b->Ai, b->Ai, b->mod, ctx)
                              ^
      117.                   || !BN_mod_mul(b->A, b->A, b->A, b->mod, ctx))
      118.                   goto err;

crypto/bn/bn_mod.c:203:5: Call
        201.       bn_check_top(m);
        202.   
        203.       BN_CTX_start(ctx);
                   ^
        204.       if ((t = BN_CTX_get(ctx)) == NULL)
        205.           goto err;

crypto/bn/bn_ctx.c:171:1: Parameter `*ctx->stack.indexes`
          169.   }
          170.   
          171. > void BN_CTX_start(BN_CTX *ctx)
          172.   {
          173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_mod.c:218:5: Call
        216.       ret = 1;
        217.    err:
        218.       BN_CTX_end(ctx);
                   ^
        219.       return ret;
        220.   }

crypto/bn/bn_ctx.c:185:1: Parameter `*ctx->stack.indexes`
          183.   }
          184.   
          185. > void BN_CTX_end(BN_CTX *ctx)
          186.   {
          187.       CTXDBG("ENTER BN_CTX_end()", ctx);

crypto/bn/bn_ctx.c:191:27: Call
          189.           ctx->err_stack--;
          190.       else {
          191.           unsigned int fp = BN_STACK_pop(&ctx->stack);
                                           ^
          192.           /* Does this stack frame have anything to release? */
          193.           if (fp < ctx->used)

crypto/bn/bn_ctx.c:266:1: <Offset trace>
264.   }
265.   
266. > static unsigned int BN_STACK_pop(BN_STACK *st)
267.   {
268.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:266:1: Parameter `st->depth`
            264.   }
            265.   
            266. > static unsigned int BN_STACK_pop(BN_STACK *st)
            267.   {
            268.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:266:1: <Length trace>
264.   }
265.   
266. > static unsigned int BN_STACK_pop(BN_STACK *st)
267.   {
268.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:266:1: Parameter `*st->indexes`
            264.   }
            265.   
            266. > static unsigned int BN_STACK_pop(BN_STACK *st)
            267.   {
            268.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:268:12: Array access: Offset: [-1, +oo] Size: [1, +oo] by call to `rsa_blinding_convert` 
            266.   static unsigned int BN_STACK_pop(BN_STACK *st)
            267.   {
            268.       return st->indexes[--(st->depth)];
                              ^
            269.   }
            270.   
