crypto/rsa/rsa_ossl.c:450: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `rsa_blinding_invert`.
Showing all 20 steps of the trace


crypto/rsa/rsa_ossl.c:358:5: Call
356.       if ((ctx = BN_CTX_new()) == NULL)
357.           goto err;
358.       BN_CTX_start(ctx);
           ^
359.       f = BN_CTX_get(ctx);
360.       ret = BN_CTX_get(ctx);

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

crypto/rsa/rsa_ossl.c:450:14: Call
448.   
449.       if (blinding)
450.           if (!rsa_blinding_invert(blinding, ret, unblind, ctx))
                    ^
451.               goto err;
452.   

crypto/rsa/rsa_ossl.c:325:1: Parameter `ctx->stack.depth`
  323.   }
  324.   
  325. > static int rsa_blinding_invert(BN_BLINDING *b, BIGNUM *f, BIGNUM *unblind,
  326.                                  BN_CTX *ctx)
  327.   {

crypto/rsa/rsa_ossl.c:336:12: Call
  334.        * to access the blinding without a lock.
  335.        */
  336.       return BN_BLINDING_invert_ex(f, unblind, b, ctx);
                    ^
  337.   }
  338.   

crypto/bn/bn_blind.c:254:1: Parameter `ctx->stack.depth`
    252.   }
    253.   
    254. > int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,
    255.                             BN_CTX *ctx)
    256.   {

crypto/bn/bn_blind.c:262:15: Call
    260.   
    261.       if (r != NULL)
    262.           ret = BN_mod_mul(n, n, r, b->mod, ctx);
                         ^
    263.       else {
    264.           if (b->Ai == NULL) {

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

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

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

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

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

crypto/bn/bn_sqr.c:81:5: Call
        79.       }
        80.   
        81.       BN_CTX_start(ctx);
                  ^
        82.       rr = (a != r) ? r : BN_CTX_get(ctx);
        83.       tmp = BN_CTX_get(ctx);

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

crypto/bn/bn_sqr.c:148:5: Call
        146.       bn_check_top(rr);
        147.       bn_check_top(tmp);
        148.       BN_CTX_end(ctx);
                   ^
        149.       return (ret);
        150.   }

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

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

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

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

crypto/bn/bn_ctx.c:328:12: Binary operation: ([0, +oo] - 1):unsigned32 by call to `rsa_blinding_invert` 
            326.   static unsigned int BN_STACK_pop(BN_STACK *st)
            327.   {
            328.       return st->indexes[--(st->depth)];
                              ^
            329.   }
            330.   
