crypto/rsa/rsa_crpt.c:180: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `rsa_get_public_exp`.
Showing all 17 steps of the trace


crypto/rsa/rsa_crpt.c:160:1: Parameter `in_ctx->stack.depth`
158.   }
159.   
160. > BN_BLINDING *RSA_setup_blinding(RSA *rsa, BN_CTX *in_ctx)
161.   {
162.       BIGNUM *e;

crypto/rsa/rsa_crpt.c:172:5: Call
170.           ctx = in_ctx;
171.   
172.       BN_CTX_start(ctx);
           ^
173.       e = BN_CTX_get(ctx);
174.       if (e == NULL) {

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_crpt.c:180:13: Call
178.   
179.       if (rsa->e == NULL) {
180.           e = rsa_get_public_exp(rsa->d, rsa->p, rsa->q, ctx);
                   ^
181.           if (e == NULL) {
182.               RSAerr(RSA_F_RSA_SETUP_BLINDING, RSA_R_NO_PUBLIC_EXPONENT);

crypto/rsa/rsa_crpt.c:132:1: Parameter `ctx->stack.depth`
  130.   }
  131.   
  132. > static BIGNUM *rsa_get_public_exp(const BIGNUM *d, const BIGNUM *p,
  133.                                     const BIGNUM *q, BN_CTX *ctx)
  134.   {

crypto/rsa/rsa_crpt.c:140:5: Call
  138.           return NULL;
  139.   
  140.       BN_CTX_start(ctx);
             ^
  141.       r0 = BN_CTX_get(ctx);
  142.       r1 = 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_crpt.c:151:10: Call
  149.       if (!BN_sub(r2, q, BN_value_one()))
  150.           goto err;
  151.       if (!BN_mul(r0, r1, r2, ctx))
                  ^
  152.           goto err;
  153.   

crypto/bn/bn_mul.c:883:1: Parameter `ctx->stack.depth`
    881.   #endif                          /* BN_RECURSION */
    882.   
    883. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
    884.   {
    885.       int ret = 0;

crypto/bn/bn_mul.c:909:5: Call
    907.       top = al + bl;
    908.   
    909.       BN_CTX_start(ctx);
               ^
    910.       if ((r == a) || (r == b)) {
    911.           if ((rr = BN_CTX_get(ctx)) == NULL)

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_mul.c:1033:5: Call
    1031.    err:
    1032.       bn_check_top(r);
    1033.       BN_CTX_end(ctx);
                ^
    1034.       return (ret);
    1035.   }

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_get_public_exp` 
        326.   static unsigned int BN_STACK_pop(BN_STACK *st)
        327.   {
        328.       return st->indexes[--(st->depth)];
                          ^
        329.   }
        330.   
