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 29 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:311:14: Call
        309.        */
        310.       if (a != r) {
        311.           if (!bn_wexpand(r, a->top))
                            ^
        312.               return 0;
        313.           for (j = 0; j < a->top; j++) {

crypto/bn/bn_lib.c:942:1: Parameter `a->top`
          940.   }
          941.   
          942. > BIGNUM *bn_wexpand(BIGNUM *a, int words)
          943.   {
          944.       return (words <= a->dmax) ? a : bn_expand2(a, words);

crypto/bn/bn_lib.c:944:37: Call
          942.   BIGNUM *bn_wexpand(BIGNUM *a, int words)
          943.   {
          944.       return (words <= a->dmax) ? a : bn_expand2(a, words);
                                                     ^
          945.   }
          946.   

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

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

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

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

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

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

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

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