crypto/bn/bn_prime.c:244: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `bn_probable_prime_dh`.
Showing all 16 steps of the trace


crypto/bn/bn_prime.c:230:5: Call
228.       if (ctx == NULL)
229.           goto err;
230.       BN_CTX_start(ctx);
           ^
231.       t = BN_CTX_get(ctx);
232.       if (!t)

crypto/bn/bn_ctx.c:253:1: Parameter `ctx->stack.depth`
  251.   }
  252.   
  253. > void BN_CTX_start(BN_CTX *ctx)
  254.   {
  255.       CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_prime.c:244:18: Call
242.                   goto err;
243.           } else {
244.               if (!bn_probable_prime_dh(ret, bits, add, rem, ctx))
                        ^
245.                   goto err;
246.           }

crypto/bn/bn_prime.c:571:1: Parameter `ctx->stack.depth`
  569.   }
  570.   
  571. > int bn_probable_prime_dh(BIGNUM *rnd, int bits,
  572.                            const BIGNUM *add, const BIGNUM *rem, BN_CTX *ctx)
  573.   {

crypto/bn/bn_prime.c:577:5: Call
  575.       BIGNUM *t1;
  576.   
  577.       BN_CTX_start(ctx);
             ^
  578.       if ((t1 = BN_CTX_get(ctx)) == NULL)
  579.           goto err;

crypto/bn/bn_ctx.c:253:1: Parameter `ctx->stack.depth`
    251.   }
    252.   
    253. > void BN_CTX_start(BN_CTX *ctx)
    254.   {
    255.       CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_prime.c:586:10: Call
  584.       /* we need ((rnd-rem) % add) == 0 */
  585.   
  586.       if (!BN_mod(t1, rnd, add, ctx))
                  ^
  587.           goto err;
  588.       if (!BN_sub(rnd, rnd, t1))

crypto/bn/bn_div.c:189:1: Parameter `ctx->stack.depth`
    187.    * If 'dv' or 'rm' is NULL, the respective value is not returned.
    188.    */
    189. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
    190.              BN_CTX *ctx)
    191.   {

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

crypto/bn/bn_ctx.c:253:1: Parameter `ctx->stack.depth`
      251.   }
      252.   
      253. > void BN_CTX_start(BN_CTX *ctx)
      254.   {
      255.       CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_div.c:469:5: Call
    467.       if (no_branch)
    468.           bn_correct_top(res);
    469.       BN_CTX_end(ctx);
               ^
    470.       return (1);
    471.    err:

crypto/bn/bn_ctx.c:267:1: Parameter `ctx->stack.depth`
      265.   }
      266.   
      267. > void BN_CTX_end(BN_CTX *ctx)
      268.   {
      269.       CTXDBG_ENTRY("BN_CTX_end", ctx);

crypto/bn/bn_ctx.c:273:27: Call
      271.           ctx->err_stack--;
      272.       else {
      273.           unsigned int fp = BN_STACK_pop(&ctx->stack);
                                       ^
      274.           /* Does this stack frame have anything to release? */
      275.           if (fp < ctx->used)

crypto/bn/bn_ctx.c:351:1: <LHS trace>
349.   }
350.   
351. > static unsigned int BN_STACK_pop(BN_STACK *st)
352.   {
353.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:351:1: Parameter `st->depth`
        349.   }
        350.   
        351. > static unsigned int BN_STACK_pop(BN_STACK *st)
        352.   {
        353.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:353:12: Binary operation: ([0, +oo] - 1):unsigned32 by call to `bn_probable_prime_dh` 
        351.   static unsigned int BN_STACK_pop(BN_STACK *st)
        352.   {
        353.       return st->indexes[--(st->depth)];
                          ^
        354.   }
        355.   
