crypto/bn/bn_gf2m.c:749: error: BUFFER_OVERRUN_L3
  Offset added: [8, +oo] Size: [0, 67108856] by call to `BN_GF2m_mod_mul`.
Showing all 31 steps of the trace


crypto/bn/bn_gf2m.c:741:10: Call
739.   
740.       /* r := a * b */
741.       if (!BN_GF2m_mod_mul(r, a, b, p, ctx))
                ^
742.           goto err;
743.   

crypto/bn/bn_gf2m.c:465:1: Parameter `r->top`
  463.    * BN_GF2m_mod_mul_arr function.
  464.    */
  465. > int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
  466.                       const BIGNUM *p, BN_CTX *ctx)
  467.   {

crypto/bn/bn_gf2m.c:745:10: Call
743.   
744.       /* r := 1/(a * b) */
745.       if (!BN_GF2m_mod_inv_vartime(r, r, p, ctx))
                ^
746.           goto err;
747.   

crypto/bn/bn_gf2m.c:552:1: Parameter `a->top`
  550.    * Curve Cryptography Over Binary Fields".
  551.    */
  552. > static int BN_GF2m_mod_inv_vartime(BIGNUM *r, const BIGNUM *a,
  553.                                      const BIGNUM *p, BN_CTX *ctx)
  554.   {

crypto/bn/bn_gf2m.c:749:10: Call
747.   
748.       /* r := b/(a * b) = 1/a */
749.       if (!BN_GF2m_mod_mul(r, r, b, p, ctx))
                ^
750.           goto err;
751.   

crypto/bn/bn_gf2m.c:465:1: Parameter `r->top`
  463.    * BN_GF2m_mod_mul_arr function.
  464.    */
  465. > int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
  466.                       const BIGNUM *p, BN_CTX *ctx)
  467.   {

crypto/bn/bn_gf2m.c:481:11: Call
  479.           goto err;
  480.       }
  481.       ret = BN_GF2m_mod_mul_arr(r, a, b, arr, ctx);
                   ^
  482.       bn_check_top(r);
  483.    err:

crypto/bn/bn_gf2m.c:410:1: Parameter `r->top`
    408.    * the result in r.  r could be a or b; a could be b.
    409.    */
    410. > int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
    411.                           const int p[], BN_CTX *ctx)
    412.   {

crypto/bn/bn_gf2m.c:421:16: Call
    419.   
    420.       if (a == b) {
    421.           return BN_GF2m_mod_sqr_arr(r, a, p, ctx);
                          ^
    422.       }
    423.   

crypto/bn/bn_gf2m.c:489:1: Parameter `r->top`
      487.   
      488.   /* Square a, reduce the result mod p, and store it in a.  r could be a. */
      489. > int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[],
      490.                           BN_CTX *ctx)
      491.   {

crypto/bn/bn_gf2m.c:509:10: Call
      507.       s->top = 2 * a->top;
      508.       bn_correct_top(s);
      509.       if (!BN_GF2m_mod_arr(r, s, p))
                      ^
      510.           goto err;
      511.       bn_check_top(r);

crypto/bn/bn_gf2m.c:292:1: Parameter `r->top`
        290.   
        291.   /* Performs modular reduction of a and store result in r.  r could be a. */
        292. > int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[])
        293.   {
        294.       int j, k;

crypto/bn/bn_gf2m.c:302:9: Call
        300.       if (!p[0]) {
        301.           /* reduction mod 1 => return 0 */
        302.           BN_zero(r);
                       ^
        303.           return 1;
        304.       }

crypto/bn/bn_lib.c:359:1: Parameter `a->top`
          357.   }
          358.   
          359. > int BN_set_word(BIGNUM *a, BN_ULONG w)
          360.   {
          361.       bn_check_top(a);

crypto/bn/bn_lib.c:362:9: Call
          360.   {
          361.       bn_check_top(a);
          362.       if (bn_expand(a, (int)sizeof(BN_ULONG) * 8) == NULL)
                         ^
          363.           return 0;
          364.       a->neg = 0;

crypto/bn/bn_lcl.h:660:1: Parameter `a->top`
            658.                            const BIGNUM *add, const BIGNUM *rem, BN_CTX *ctx);
            659.   
            660. > static ossl_inline BIGNUM *bn_expand(BIGNUM *a, int bits)
            661.   {
            662.       if (bits > (INT_MAX - BN_BITS2 + 1))

crypto/bn/bn_lcl.h:668:12: Call
            666.           return a;
            667.   
            668.       return bn_expand2((a),(bits+BN_BITS2-1)/BN_BITS2);
                              ^
            669.   }
            670.   

crypto/bn/bn_lib.c:245:1: Parameter `b->top`
              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 `words`
                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:224:13: Call
                222.           a = OPENSSL_secure_zalloc(words * sizeof(*a));
                223.       else
                224.           a = OPENSSL_zalloc(words * sizeof(*a));
                                   ^
                225.       if (a == NULL) {
                226.           BNerr(BN_F_BN_EXPAND_INTERNAL, ERR_R_MALLOC_FAILURE);

crypto/mem.c:228:1: Parameter `num`
                  226.   }
                  227.   
                  228. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
                  229.   {
                  230.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:230:17: Call
                  228.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
                  229.   {
                  230.       void *ret = CRYPTO_malloc(num, file, line);
                                         ^
                  231.   
                  232.       FAILTEST();

crypto/mem.c:201:9: Assignment
                    199.   
                    200.       if (num == 0)
                    201.           return NULL;
                                   ^
                    202.   
                    203.       FAILTEST();

crypto/mem.c:230:5: Assignment
                  228.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
                  229.   {
                  230.       void *ret = CRYPTO_malloc(num, file, line);
                             ^
                  231.   
                  232.       FAILTEST();

crypto/mem.c:235:5: Assignment
                  233.       if (ret != NULL)
                  234.           memset(ret, 0, num);
                  235.       return ret;
                             ^
                  236.   }
                  237.   

crypto/bn/bn_lib.c:224:9: Assignment
                222.           a = OPENSSL_secure_zalloc(words * sizeof(*a));
                223.       else
                224.           a = OPENSSL_zalloc(words * sizeof(*a));
                               ^
                225.       if (a == NULL) {
                226.           BNerr(BN_F_BN_EXPAND_INTERNAL, ERR_R_MALLOC_FAILURE);

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