crypto/rsa/rsa_x931g.c:61: error: BUFFER_OVERRUN_L3
  Offset added: [8, +oo] Size: [0, +oo] by call to `BN_X931_derive_prime_ex`.
Showing all 23 steps of the trace


crypto/rsa/rsa_x931g.c:44:18: Call
42.           goto err;
43.       if (!rsa->e) {
44.           rsa->e = BN_dup(e);
                       ^
45.           if (!rsa->e)
46.               goto err;

crypto/bn/bn_lib.c:273:10: Call
  271.       if (t == NULL)
  272.           return NULL;
  273.       if (!BN_copy(t, a)) {
                  ^
  274.           BN_free(t);
  275.           return NULL;

crypto/bn/bn_lib.c:281:1: Parameter `*a->d`
    279.   }
    280.   
    281. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
    282.   {
    283.       bn_check_top(b);

crypto/rsa/rsa_x931g.c:61:14: Call
59.               goto err;
60.   
61.           if (!BN_X931_derive_prime_ex(rsa->p, p1, p2,
                   ^
62.                                        Xp, Xp1, Xp2, e, ctx, cb))
63.               goto err;

crypto/bn/bn_x931p.c:51:1: Parameter `*p->d`
  49.    */
  50.   
  51. > int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
  52.                               const BIGNUM *Xp, const BIGNUM *Xp1,
  53.                               const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx,

crypto/bn/bn_x931p.c:91:10: Call
  89.       /* First set p to value of Rp */
  90.   
  91.       if (!BN_mod_inverse(p, p2, p1, ctx))
                 ^
  92.           goto err;
  93.   

crypto/bn/bn_gcd.c:124:1: Parameter `*in->d`
    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 `*in->d`
      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 `*in->d`
        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:606:18: Call
        604.           /* Y*a == 1  (mod |n|) */
        605.           if (!Y->neg && BN_ucmp(Y, n) < 0) {
        606.               if (!BN_copy(R, Y))
                                ^
        607.                   goto err;
        608.           } else {

crypto/bn/bn_lib.c:281:1: Parameter `*a->d`
          279.   }
          280.   
          281. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
          282.   {
          283.       bn_check_top(b);

crypto/bn/bn_lib.c:287:9: Call
          285.       if (a == b)
          286.           return a;
          287.       if (bn_wexpand(a, b->top) == NULL)
                         ^
          288.           return NULL;
          289.   

crypto/bn/bn_lib.c:948:1: Parameter `*a->d`
            946.   }
            947.   
            948. > BIGNUM *bn_wexpand(BIGNUM *a, int words)
            949.   {
            950.       return (words <= a->dmax) ? a : bn_expand2(a, words);

crypto/bn/bn_lib.c:950:37: Call
            948.   BIGNUM *bn_wexpand(BIGNUM *a, int words)
            949.   {
            950.       return (words <= a->dmax) ? a : bn_expand2(a, words);
                                                       ^
            951.   }
            952.   

crypto/bn/bn_lib.c:245:1: Parameter `*b->d`
              243.    */
              244.   
              245. > BIGNUM *bn_expand2(BIGNUM *b, int words)
              246.   {
              247.       if (words > b->dmax) {

crypto/bn/bn_lib.c:248:23: Call
              246.   {
              247.       if (words > b->dmax) {
              248.           BN_ULONG *a = bn_expand_internal(b, words);
                                           ^
              249.           if (!a)
              250.               return NULL;

crypto/bn/bn_lib.c:209:1: <Offset trace>
207.   /* This is used by bn_expand2() */
208.   /* The caller MUST check that words > b->dmax before calling this */
209. > static BN_ULONG *bn_expand_internal(const BIGNUM *b, int words)
210.   {
211.       BN_ULONG *a = NULL;

crypto/bn/bn_lib.c:209:1: Parameter `b->top`
                207.   /* This is used by bn_expand2() */
                208.   /* The caller MUST check that words > b->dmax before calling this */
                209. > static BN_ULONG *bn_expand_internal(const BIGNUM *b, int words)
                210.   {
                211.       BN_ULONG *a = NULL;

crypto/bn/bn_lib.c:209:1: <Length trace>
207.   /* This is used by bn_expand2() */
208.   /* The caller MUST check that words > b->dmax before calling this */
209. > static BN_ULONG *bn_expand_internal(const BIGNUM *b, int words)
210.   {
211.       BN_ULONG *a = NULL;

crypto/bn/bn_lib.c:209:1: Parameter `*b->d`
                207.   /* This is used by bn_expand2() */
                208.   /* The caller MUST check that words > b->dmax before calling this */
                209. > static BN_ULONG *bn_expand_internal(const BIGNUM *b, int words)
                210.   {
                211.       BN_ULONG *a = NULL;

crypto/bn/bn_lib.c:232:9: Array access: Offset added: [8, +oo] Size: [0, +oo] by call to `BN_X931_derive_prime_ex` 
                230.       assert(b->top <= words);
                231.       if (b->top > 0)
                232.           memcpy(a, b->d, sizeof(*a) * b->top);
                               ^
                233.   
                234.       return a;
