crypto/ec/ecdsa_ossl.c:404: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `ec_group_do_inverse_ord`.
Showing all 40 steps of the trace


crypto/ec/ecdsa_ossl.c:380:5: Call
378.           return -1;
379.       }
380.       BN_CTX_start(ctx);
           ^
381.       u1 = BN_CTX_get(ctx);
382.       u2 = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:194:1: Parameter `ctx->stack.depth`
  192.   }
  193.   
  194. > void BN_CTX_start(BN_CTX *ctx)
  195.   {
  196.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/ec/ecdsa_ossl.c:404:10: Call
402.       }
403.       /* calculate tmp1 = inv(S) mod order */
404.       if (!ec_group_do_inverse_ord(group, u2, sig->s, ctx)) {
                ^
405.           ECerr(EC_F_ECDSA_SIMPLE_VERIFY_SIG, ERR_R_BN_LIB);
406.           goto err;

crypto/ec/ec_lib.c:1143:1: Parameter `ctx->stack.depth`
  1141.    * other functionality.
  1142.    */
  1143. > int ec_group_do_inverse_ord(const EC_GROUP *group, BIGNUM *res,
  1144.                               const BIGNUM *x, BN_CTX *ctx)
  1145.   {

crypto/ec/ec_lib.c:1149:16: Call
  1147.           return group->meth->field_inverse_mod_ord(group, res, x, ctx);
  1148.       else
  1149.           return ec_field_inverse_mod_ord(group, res, x, ctx);
                         ^
  1150.   }
  1151.   

crypto/ec/ec_lib.c:1084:1: Parameter `ctx->stack.depth`
    1082.   }
    1083.   
    1084. > static int ec_field_inverse_mod_ord(const EC_GROUP *group, BIGNUM *r,
    1085.                                       const BIGNUM *x, BN_CTX *ctx)
    1086.   {

crypto/ec/ec_lib.c:1101:5: Call
    1099.           goto err;
    1100.   
    1101.       BN_CTX_start(ctx);
                ^
    1102.       if ((e = BN_CTX_get(ctx)) == NULL)
    1103.           goto err;

crypto/bn/bn_ctx.c:194:1: Parameter `ctx->stack.depth`
      192.   }
      193.   
      194. > void BN_CTX_start(BN_CTX *ctx)
      195.   {
      196.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/ec/ec_lib.c:1117:10: Call
    1115.        * No need for scatter-gather or BN_FLG_CONSTTIME.
    1116.        */
    1117.       if (!BN_mod_exp_mont(r, x, e, group->order, ctx, group->mont_data))
                     ^
    1118.           goto err;
    1119.   

crypto/bn/bn_exp.c:296:1: Parameter `ctx->stack.depth`
      294.   }
      295.   
      296. > int BN_mod_exp_mont(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
      297.                       const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
      298.   {

crypto/bn/bn_exp.c:310:16: Call
      308.               || BN_get_flags(a, BN_FLG_CONSTTIME) != 0
      309.               || BN_get_flags(m, BN_FLG_CONSTTIME) != 0) {
      310.           return BN_mod_exp_mont_consttime(rr, a, p, m, ctx, in_mont);
                            ^
      311.       }
      312.   

crypto/bn/bn_exp.c:592:1: Parameter `ctx->stack.depth`
        590.    * http://www.daemonology.net/hyperthreading-considered-harmful/)
        591.    */
        592. > int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
        593.                                 const BIGNUM *m, BN_CTX *ctx,
        594.                                 BN_MONT_CTX *in_mont)

crypto/bn/bn_exp.c:636:5: Call
        634.       }
        635.   
        636.       BN_CTX_start(ctx);
                   ^
        637.   
        638.       /*

crypto/bn/bn_ctx.c:194:1: Parameter `ctx->stack.depth`
          192.   }
          193.   
          194. > void BN_CTX_start(BN_CTX *ctx)
          195.   {
          196.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_exp.c:647:14: Call
        645.           if ((mont = BN_MONT_CTX_new()) == NULL)
        646.               goto err;
        647.           if (!BN_MONT_CTX_set(mont, m, ctx))
                            ^
        648.               goto err;
        649.       }

crypto/bn/bn_mont.c:263:1: Parameter `ctx->stack.depth`
          261.   }
          262.   
          263. > int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx)
          264.   {
          265.       int i, ret = 0;

crypto/bn/bn_mont.c:271:5: Call
          269.           return 0;
          270.   
          271.       BN_CTX_start(ctx);
                     ^
          272.       if ((Ri = BN_CTX_get(ctx)) == NULL)
          273.           goto err;

crypto/bn/bn_ctx.c:194:1: Parameter `ctx->stack.depth`
            192.   }
            193.   
            194. > void BN_CTX_start(BN_CTX *ctx)
            195.   {
            196.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_mont.c:351:19: Call
          349.           if (BN_is_one(&tmod))
          350.               BN_zero(Ri);
          351.           else if ((BN_mod_inverse(Ri, R, &tmod, ctx)) == NULL)
                                   ^
          352.               goto err;
          353.           if (!BN_lshift(Ri, Ri, BN_BITS2))

crypto/bn/bn_gcd.c:124:1: Parameter `ctx->stack.depth`
            122.                                           BN_CTX *ctx);
            123.   
            124. > BIGNUM *BN_mod_inverse(BIGNUM *in,
            125.                          const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx)
            126.   {

crypto/bn/bn_gcd.c:129:10: Call
            127.       BIGNUM *rv;
            128.       int noinv;
            129.       rv = int_bn_mod_inverse(in, a, n, ctx, &noinv);
                            ^
            130.       if (noinv)
            131.           BNerr(BN_F_BN_MOD_INVERSE, BN_R_NO_INVERSE);

crypto/bn/bn_gcd.c:135:1: Parameter `ctx->stack.depth`
              133.   }
              134.   
              135. > BIGNUM *int_bn_mod_inverse(BIGNUM *in,
              136.                              const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx,
              137.                              int *pnoinv)

crypto/bn/bn_gcd.c:155:16: Call
              153.       if ((BN_get_flags(a, BN_FLG_CONSTTIME) != 0)
              154.           || (BN_get_flags(n, BN_FLG_CONSTTIME) != 0)) {
              155.           return BN_mod_inverse_no_branch(in, a, n, ctx);
                                    ^
              156.       }
              157.   

crypto/bn/bn_gcd.c:458:1: Parameter `ctx->stack.depth`
                456.    * not contain branches that may leak sensitive information.
                457.    */
                458. > static BIGNUM *BN_mod_inverse_no_branch(BIGNUM *in,
                459.                                           const BIGNUM *a, const BIGNUM *n,
                460.                                           BN_CTX *ctx)

crypto/bn/bn_gcd.c:469:5: Call
                467.       bn_check_top(n);
                468.   
                469.       BN_CTX_start(ctx);
                           ^
                470.       A = BN_CTX_get(ctx);
                471.       B = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:194:1: Parameter `ctx->stack.depth`
                  192.   }
                  193.   
                  194. > void BN_CTX_start(BN_CTX *ctx)
                  195.   {
                  196.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_gcd.c:504:18: Call
                502.               bn_init(&local_B);
                503.               BN_with_flags(&local_B, B, BN_FLG_CONSTTIME);
                504.               if (!BN_nnmod(B, &local_B, A, ctx))
                                        ^
                505.                   goto err;
                506.               /* Ensure local_B goes out of scope before any further use of B */

crypto/bn/bn_mod.c:13:1: Parameter `ctx->stack.depth`
                  11.   #include "bn_lcl.h"
                  12.   
                  13. > int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx)
                  14.   {
                  15.       /*

crypto/bn/bn_mod.c:20:11: Call
                  18.        */
                  19.   
                  20.       if (!(BN_mod(r, m, d, ctx)))
                                  ^
                  21.           return 0;
                  22.       if (!r->neg)

crypto/bn/bn_div.c:209:1: Parameter `ctx->stack.depth`
                    207.    * If 'dv' or 'rm' is NULL, the respective value is not returned.
                    208.    */
                    209. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
                    210.              BN_CTX *ctx)
                    211.   {

crypto/bn/bn_div.c:229:11: Call
                    227.       }
                    228.   
                    229.       ret = bn_div_fixed_top(dv, rm, num, divisor, ctx);
                                     ^
                    230.   
                    231.       if (ret) {

crypto/bn/bn_div.c:264:1: Parameter `ctx->stack.depth`
                      262.    *       divisor's length is considered public;
                      263.    */
                      264. > int bn_div_fixed_top(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num,
                      265.                        const BIGNUM *divisor, BN_CTX *ctx)
                      266.   {

crypto/bn/bn_div.c:280:5: Call
                      278.       bn_check_top(rm);
                      279.   
                      280.       BN_CTX_start(ctx);
                                 ^
                      281.       res = (dv == NULL) ? BN_CTX_get(ctx) : dv;
                      282.       tmp = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:194:1: Parameter `ctx->stack.depth`
                        192.   }
                        193.   
                        194. > void BN_CTX_start(BN_CTX *ctx)
                        195.   {
                        196.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_div.c:450:5: Call
                      448.       if (rm != NULL)
                      449.           bn_rshift_fixed_top(rm, snum, norm_shift);
                      450.       BN_CTX_end(ctx);
                                 ^
                      451.       return 1;
                      452.    err:

crypto/bn/bn_ctx.c:208:1: Parameter `ctx->stack.depth`
                        206.   }
                        207.   
                        208. > void BN_CTX_end(BN_CTX *ctx)
                        209.   {
                        210.       if (ctx == NULL)

crypto/bn/bn_ctx.c:216:27: Call
                        214.           ctx->err_stack--;
                        215.       else {
                        216.           unsigned int fp = BN_STACK_pop(&ctx->stack);
                                                         ^
                        217.           /* Does this stack frame have anything to release? */
                        218.           if (fp < ctx->used)

crypto/bn/bn_ctx.c:298:1: <LHS trace>
296.   }
297.   
298. > static unsigned int BN_STACK_pop(BN_STACK *st)
299.   {
300.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:298:1: Parameter `st->depth`
                          296.   }
                          297.   
                          298. > static unsigned int BN_STACK_pop(BN_STACK *st)
                          299.   {
                          300.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:300:12: Binary operation: ([0, +oo] - 1):unsigned32 by call to `ec_group_do_inverse_ord` 
                          298.   static unsigned int BN_STACK_pop(BN_STACK *st)
                          299.   {
                          300.       return st->indexes[--(st->depth)];
                                            ^
                          301.   }
                          302.   
