crypto/rsa/rsa_ossl.c:423: 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:380:5: Call
378.       if ((ctx = BN_CTX_new()) == NULL)
379.           goto err;
380.       BN_CTX_start(ctx);
           ^
381.       f = BN_CTX_get(ctx);
382.       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:423:14: Call
421.               goto err;
422.           }
423.           if (!rsa_blinding_convert(blinding, f, unblind, ctx))
                    ^
424.               goto err;
425.       }

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

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

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.       if (ctx == NULL)

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

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

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

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

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

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