crypto/bn/bn_x931p.c:86: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `BN_mul`.
Showing all 25 steps of the trace


crypto/bn/bn_x931p.c:51:1: Parameter `ctx->stack.depth`
49.    */
50.   
51. > int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
52.                               const BIGNUM *Xp, const BIGNUM *Xp1,
53.                               const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx,

crypto/bn/bn_x931p.c:64:5: Call
62.           return 0;
63.   
64.       BN_CTX_start(ctx);
          ^
65.       if (p1 == NULL)
66.           p1 = 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/bn/bn_x931p.c:71:9: Call
69.           p2 = BN_CTX_get(ctx);
70.   
71.       t = BN_CTX_get(ctx);
              ^
72.   
73.       p1p2 = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:202:1: Parameter `ctx->stack.depth`
  200.   }
  201.   
  202. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  203.   {
  204.       BIGNUM *ret;

crypto/bn/bn_x931p.c:73:12: Call
71.       t = BN_CTX_get(ctx);
72.   
73.       p1p2 = BN_CTX_get(ctx);
                 ^
74.   
75.       pm1 = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:202:1: Parameter `ctx->stack.depth`
  200.   }
  201.   
  202. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  203.   {
  204.       BIGNUM *ret;

crypto/bn/bn_x931p.c:75:11: Call
73.       p1p2 = BN_CTX_get(ctx);
74.   
75.       pm1 = BN_CTX_get(ctx);
                ^
76.   
77.       if (pm1 == NULL)

crypto/bn/bn_ctx.c:202:1: Parameter `ctx->stack.depth`
  200.   }
  201.   
  202. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  203.   {
  204.       BIGNUM *ret;

crypto/bn/bn_x931p.c:80:10: Call
78.           goto err;
79.   
80.       if (!bn_x931_derive_pi(p1, Xp1, ctx, cb))
               ^
81.           goto err;
82.   

crypto/bn/bn_x931p.c:21:1: Parameter `ctx->stack.depth`
  19.    */
  20.   
  21. > static int bn_x931_derive_pi(BIGNUM *pi, const BIGNUM *Xpi, BN_CTX *ctx,
  22.                                BN_GENCB *cb)
  23.   {

crypto/bn/bn_x931p.c:83:10: Call
81.           goto err;
82.   
83.       if (!bn_x931_derive_pi(p2, Xp2, ctx, cb))
               ^
84.           goto err;
85.   

crypto/bn/bn_x931p.c:21:1: Parameter `ctx->stack.depth`
  19.    */
  20.   
  21. > static int bn_x931_derive_pi(BIGNUM *pi, const BIGNUM *Xpi, BN_CTX *ctx,
  22.                                BN_GENCB *cb)
  23.   {

crypto/bn/bn_x931p.c:86:10: Call
84.           goto err;
85.   
86.       if (!BN_mul(p1p2, p1, p2, ctx))
               ^
87.           goto err;
88.   

crypto/bn/bn_mul.c:497:1: Parameter `ctx->stack.depth`
  495.   #endif                          /* BN_RECURSION */
  496.   
  497. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
  498.   {
  499.       int ret = bn_mul_fixed_top(r, a, b, ctx);

crypto/bn/bn_mul.c:499:15: Call
  497.   int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
  498.   {
  499.       int ret = bn_mul_fixed_top(r, a, b, ctx);
                       ^
  500.   
  501.       bn_correct_top(r);

crypto/bn/bn_mul.c:507:1: Parameter `ctx->stack.depth`
    505.   }
    506.   
    507. > int bn_mul_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
    508.   {
    509.       int ret = 0;

crypto/bn/bn_mul.c:533:5: Call
    531.       top = al + bl;
    532.   
    533.       BN_CTX_start(ctx);
               ^
    534.       if ((r == a) || (r == b)) {
    535.           if ((rr = BN_CTX_get(ctx)) == NULL)

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/bn/bn_mul.c:618:5: Call
    616.    err:
    617.       bn_check_top(r);
    618.       BN_CTX_end(ctx);
               ^
    619.       return ret;
    620.   }

crypto/bn/bn_ctx.c:185:1: Parameter `ctx->stack.depth`
      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: <LHS 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:268:12: Binary operation: ([0, +oo] - 1):unsigned32 by call to `BN_mul` 
        266.   static unsigned int BN_STACK_pop(BN_STACK *st)
        267.   {
        268.       return st->indexes[--(st->depth)];
                          ^
        269.   }
        270.   
