crypto/rsa/rsa_x931g.c:167: error: BUFFER_OVERRUN_L3
  Offset: [1, +oo] Size: [0, 8388607] by call to `BN_div`.
Showing all 21 steps of the trace


crypto/rsa/rsa_x931g.c:109:14: Call
107.               goto err;
108.   
109.           if (!BN_X931_derive_prime_ex(rsa->p, p1, p2,
                    ^
110.                                        Xp, Xp1, Xp2, e, ctx, cb))
111.               goto err;

crypto/bn/bn_x931p.c:155:10: Call
  153.       /* p now equals Rp */
  154.   
  155.       if (!BN_mod_sub(p, p, Xp, p1p2, ctx))
                  ^
  156.           goto err;
  157.   

crypto/bn/bn_mod.c:161:12: Call
    159.       if (!BN_sub(r, a, b))
    160.           return 0;
    161.       return BN_nnmod(r, r, m, ctx);
                      ^
    162.   }
    163.   

crypto/bn/bn_mod.c:126:11: Call
      124.        */
      125.   
      126.       if (!(BN_mod(r, m, d, ctx)))
                       ^
      127.           return 0;
      128.       if (!r->neg)

crypto/bn/bn_div.c:189:1: Parameter `*dv->d`
        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/rsa/rsa_x931g.c:152:10: Call
150.           goto err;
151.   
152.       if (!BN_div(r0, NULL, r0, r3, ctx))
                ^
153.           goto err;               /* LCM((p-1)(q-1)) */
154.   

crypto/bn/bn_div.c:189:1: Parameter `*rm->d`
  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/rsa/rsa_x931g.c:159:14: Call
157.           goto err;
158.   
159.       rsa->d = BN_mod_inverse(NULL, rsa->e, r0, ctx2); /* d */
                    ^
160.       if (rsa->d == NULL)
161.           goto err;

crypto/bn/bn_gcd.c:226:1: Parameter `*in->d`
  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 `*in->d`
    235.   }
    236.   
    237. > BIGNUM *int_bn_mod_inverse(BIGNUM *in,
    238.                              const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx,
    239.                              int *pnoinv)

crypto/rsa/rsa_x931g.c:167:10: Call
165.       if (rsa->dmp1 == NULL)
166.           goto err;
167.       if (!BN_mod(rsa->dmp1, rsa->d, r1, ctx))
                ^
168.           goto err;
169.   

crypto/bn/bn_div.c:243:11: Call
  241.   
  242.       BN_CTX_start(ctx);
  243.       tmp = BN_CTX_get(ctx);
                   ^
  244.       snum = BN_CTX_get(ctx);
  245.       sdiv = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:284:5: Call
    282.       }
    283.       /* OK, make sure the returned bignum is "zero" */
    284.       BN_zero(ret);
               ^
    285.       ctx->used++;
    286.       CTXDBG_RET(ctx, ret);

crypto/bn/bn_lib.c:530:1: Parameter `*a->d`
      528.   }
      529.   
      530. > int BN_set_word(BIGNUM *a, BN_ULONG w)
      531.   {
      532.       bn_check_top(a);

crypto/bn/bn_div.c:462:9: Call
  460.            */
  461.           int neg = num->neg;
  462.           BN_rshift(rm, snum, norm_shift);
                 ^
  463.           if (!BN_is_zero(rm))
  464.               rm->neg = neg;

crypto/bn/bn_shift.c:169:1: <Length trace>
167.   }
168.   
169. > int BN_rshift(BIGNUM *r, const BIGNUM *a, int n)
170.   {
171.       int i, j, nw, lb, rb;

crypto/bn/bn_shift.c:169:1: Parameter `*a->d`
    167.   }
    168.   
    169. > int BN_rshift(BIGNUM *r, const BIGNUM *a, int n)
    170.   {
    171.       int i, j, nw, lb, rb;

crypto/bn/bn_shift.c:200:5: Assignment
    198.       }
    199.   
    200.       f = &(a->d[nw]);
               ^
    201.       t = r->d;
    202.       j = a->top - nw;

crypto/bn/bn_shift.c:209:15: Assignment
    207.               *(t++) = *(f++);
    208.       } else {
    209.           l = *(f++);
                         ^
    210.           for (i = j - 1; i != 0; i--) {
    211.               tmp = (l >> rb) & BN_MASK2;

crypto/bn/bn_shift.c:212:17: Array access: Offset: [1, +oo] Size: [0, 8388607] by call to `BN_div` 
    210.           for (i = j - 1; i != 0; i--) {
    211.               tmp = (l >> rb) & BN_MASK2;
    212.               l = *(f++);
                           ^
    213.               *(t++) = (tmp | (l << lb)) & BN_MASK2;
    214.           }
