crypto/ec/ecp_smpl.c:1325: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `BN_mod_inverse`.
Showing all 23 steps of the trace


crypto/ec/ecp_smpl.c:1257:1: Parameter `ctx->stack.depth`
1255.   }
1256.   
1257. > int ec_GFp_simple_points_make_affine(const EC_GROUP *group, size_t num,
1258.                                        EC_POINT *points[], BN_CTX *ctx)
1259.   {

crypto/ec/ecp_smpl.c:1275:5: Call
1273.       }
1274.   
1275.       BN_CTX_start(ctx);
            ^
1276.       tmp = BN_CTX_get(ctx);
1277.       tmp_Z = 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/ec/ecp_smpl.c:1325:10: Call
1323.        */
1324.   
1325.       if (!BN_mod_inverse(tmp, prod_Z[num - 1], group->field, ctx)) {
                 ^
1326.           ECerr(EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE, ERR_R_BN_LIB);
1327.           goto err;

crypto/bn/bn_gcd.c:226:1: Parameter `ctx->stack.depth`
  224.                                           BN_CTX *ctx);
  225.   
  226. > BIGNUM *BN_mod_inverse(BIGNUM *in,
  227.                          const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx)
  228.   {

crypto/bn/bn_gcd.c:231:10: Call
  229.       BIGNUM *rv;
  230.       int noinv;
  231.       rv = int_bn_mod_inverse(in, a, n, ctx, &noinv);
                  ^
  232.       if (noinv)
  233.           BNerr(BN_F_BN_MOD_INVERSE, BN_R_NO_INVERSE);

crypto/bn/bn_gcd.c:237:1: Parameter `ctx->stack.depth`
    235.   }
    236.   
    237. > BIGNUM *int_bn_mod_inverse(BIGNUM *in,
    238.                              const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx,
    239.                              int *pnoinv)

crypto/bn/bn_gcd.c:250:16: Call
    248.       if ((BN_get_flags(a, BN_FLG_CONSTTIME) != 0)
    249.           || (BN_get_flags(n, BN_FLG_CONSTTIME) != 0)) {
    250.           return BN_mod_inverse_no_branch(in, a, n, ctx);
                          ^
    251.       }
    252.   

crypto/bn/bn_gcd.c:557:1: Parameter `ctx->stack.depth`
      555.    * not contain branches that may leak sensitive information.
      556.    */
      557. > static BIGNUM *BN_mod_inverse_no_branch(BIGNUM *in,
      558.                                           const BIGNUM *a, const BIGNUM *n,
      559.                                           BN_CTX *ctx)

crypto/bn/bn_gcd.c:570:5: Call
      568.       bn_check_top(n);
      569.   
      570.       BN_CTX_start(ctx);
                 ^
      571.       A = BN_CTX_get(ctx);
      572.       B = 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_gcd.c:603:14: Call
      601.           pB = &local_B;
      602.           BN_with_flags(pB, B, BN_FLG_CONSTTIME);
      603.           if (!BN_nnmod(B, pB, A, ctx))
                          ^
      604.               goto err;
      605.       }

crypto/bn/bn_mod.c:127:1: Parameter `ctx->stack.depth`
        125.   #endif
        126.   
        127. > int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx)
        128.   {
        129.       /*

crypto/bn/bn_mod.c:134:11: Call
        132.        */
        133.   
        134.       if (!(BN_mod(r, m, d, ctx)))
                         ^
        135.           return 0;
        136.       if (!r->neg)

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_mod_inverse` 
              351.   static unsigned int BN_STACK_pop(BN_STACK *st)
              352.   {
              353.       return st->indexes[--(st->depth)];
                                ^
              354.   }
              355.   
