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


crypto/rsa/rsa_ossl.c:251:5: Call
249.       if ((ctx = BN_CTX_new()) == NULL)
250.           goto err;
251.       BN_CTX_start(ctx);
           ^
252.       f = BN_CTX_get(ctx);
253.       ret = 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/rsa/rsa_ossl.c:302:14: Call
300.               goto err;
301.           }
302.           if (!rsa_blinding_convert(blinding, f, unblind, ctx))
                    ^
303.               goto err;
304.       }

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:112:18: Call
      110.       } else if (!(b->flags & BN_BLINDING_NO_UPDATE)) {
      111.           if (b->m_ctx != NULL) {
      112.               if (!bn_mul_mont_fixed_top(b->Ai, b->Ai, b->Ai, b->m_ctx, ctx)
                              ^
      113.                   || !bn_mul_mont_fixed_top(b->A, b->A, b->A, b->m_ctx, ctx))
      114.                   goto err;

crypto/bn/bn_mont.c:37:1: Parameter `ctx->stack.depth`
        35.   }
        36.   
        37. > int bn_mul_mont_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
        38.                             BN_MONT_CTX *mont, BN_CTX *ctx)
        39.   {

crypto/bn/bn_blind.c:113:21: Call
      111.           if (b->m_ctx != NULL) {
      112.               if (!bn_mul_mont_fixed_top(b->Ai, b->Ai, b->Ai, b->m_ctx, ctx)
      113.                   || !bn_mul_mont_fixed_top(b->A, b->A, b->A, b->m_ctx, ctx))
                                 ^
      114.                   goto err;
      115.           } else {

crypto/bn/bn_mont.c:60:5: Call
        58.           return 0;
        59.   
        60.       BN_CTX_start(ctx);
                  ^
        61.       tmp = BN_CTX_get(ctx);
        62.       if (tmp == 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_mont.c:83:5: Call
        81.       ret = 1;
        82.    err:
        83.       BN_CTX_end(ctx);
                  ^
        84.       return ret;
        85.   }

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:274:1: <Offset trace>
272.   }
273.   
274. > static unsigned int BN_STACK_pop(BN_STACK *st)
275.   {
276.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:274:1: Parameter `st->depth`
            272.   }
            273.   
            274. > static unsigned int BN_STACK_pop(BN_STACK *st)
            275.   {
            276.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:274:1: <Length trace>
272.   }
273.   
274. > static unsigned int BN_STACK_pop(BN_STACK *st)
275.   {
276.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:274:1: Parameter `*st->indexes`
            272.   }
            273.   
            274. > static unsigned int BN_STACK_pop(BN_STACK *st)
            275.   {
            276.       return st->indexes[--(st->depth)];

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