crypto/rsa/rsa_x931g.c:109: error: BUFFER_OVERRUN_L3
  Offset: [4, +oo] (⇐ [0, +oo] + 4) Size: [0, 8388607] by call to `BN_X931_derive_prime_ex`.
Showing all 17 steps of the trace


crypto/rsa/rsa_x931g.c:93:18: Call
91.           goto err;
92.       if (!rsa->e) {
93.           rsa->e = BN_dup(e);
                       ^
94.           if (!rsa->e)
95.               goto err;

crypto/bn/bn_lib.c:421:10: Call
  419.       if (t == NULL)
  420.           return NULL;
  421.       if (!BN_copy(t, a)) {
                  ^
  422.           BN_free(t);
  423.           return NULL;

crypto/bn/bn_lib.c:429:1: Parameter `*a->d`
    427.   }
    428.   
    429. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
    430.   {
    431.       int i;

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:98:1: Parameter `*p->d`
  96.    */
  97.   
  98. > int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
  99.                               const BIGNUM *Xp, const BIGNUM *Xp1,
  100.                               const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx,

crypto/bn/bn_x931p.c:135:10: Call
  133.       /* First set p to value of Rp */
  134.   
  135.       if (!BN_mod_inverse(p, p2, p1, ctx))
                  ^
  136.           goto err;
  137.   

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/bn/bn_x931p.c:138:10: Call
  136.           goto err;
  137.   
  138.       if (!BN_mul(p, p, p2, ctx))
                  ^
  139.           goto err;
  140.   

crypto/bn/bn_mul.c:883:1: Parameter `*a->d`
    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:964:17: Call
    962.                   if (bn_wexpand(rr, k * 4) == NULL)
    963.                       goto err;
    964.                   bn_mul_part_recursive(rr->d, a->d, b->d,
                           ^
    965.                                         j, al - j, bl - j, t->d);
    966.               } else {            /* al <= j || bl <= j */

crypto/bn/bn_mul.c:534:1: Parameter `*a`
      532.    */
      533.   /* tnX may not be negative but less than n */
      534. > void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n,
      535.                              int tna, int tnb, BN_ULONG *t)
      536.   {

crypto/bn/bn_mul.c:542:9: Call
      540.   
      541.       if (n < 8) {
      542.           bn_mul_normal(r, a, n + tna, b, n + tnb);
                     ^
      543.           return;
      544.       }

crypto/bn/bn_mul.c:1037:1: <Length trace>
1035.   }
1036.   
1037. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
1038.   {
1039.       BN_ULONG *rr;

crypto/bn/bn_mul.c:1037:1: Parameter `*b`
        1035.   }
        1036.   
        1037. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
        1038.   {
        1039.       BN_ULONG *rr;

crypto/bn/bn_mul.c:1072:50: Array access: Offset: [4, +oo] (⇐ [0, +oo] + 4) Size: [0, 8388607] by call to `BN_X931_derive_prime_ex` 
        1070.           if (--nb <= 0)
        1071.               return;
        1072.           rr[4] = bn_mul_add_words(&(r[4]), a, na, b[4]);
                                                                 ^
        1073.           rr += 4;
        1074.           r += 4;
