test/sm2_internal_test.c:167: error: BUFFER_OVERRUN_L3
  Offset added: [8, +oo] Size: [0, 536870848] by call to `EC_POINT_mul`.
Showing all 19 steps of the trace


test/sm2_internal_test.c:156:17: Call
154.   
155.       if (!TEST_ptr(expected)
156.               || !TEST_true(BN_hex2bn(&priv, privkey_hex)))
                       ^
157.           goto done;
158.   

crypto/bn/bn_print.c:166:5: Assignment
  164.       j = i;                      /* least significant 'hex' */
  165.       m = 0;
  166.       h = 0;
             ^
  167.       while (j > 0) {
  168.           m = (BN_BYTES * 2 <= j) ? BN_BYTES * 2 : j;

crypto/bn/bn_print.c:184:5: Assignment
  182.           j -= BN_BYTES * 2;
  183.       }
  184.       ret->top = h;
             ^
  185.       bn_correct_top(ret);
  186.   

test/sm2_internal_test.c:167:17: Call
165.       pt = EC_POINT_new(group);
166.       if (!TEST_ptr(pt)
167.               || !TEST_true(EC_POINT_mul(group, pt, priv, NULL, NULL, NULL))
                       ^
168.               || !TEST_true(EC_KEY_set_public_key(key, pt))
169.               || !TEST_true(sm2_ciphertext_size(key, digest, msg_len, &ctext_len)))

crypto/ec/ec_lib.c:971:1: Parameter `g_scalar->top`
  969.   }
  970.   
  971. > int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_scalar,
  972.                    const EC_POINT *point, const BIGNUM *p_scalar, BN_CTX *ctx)
  973.   {

crypto/ec/ec_lib.c:982:12: Call
  980.       scalars[0] = p_scalar;
  981.   
  982.       return EC_POINTs_mul(group, r, g_scalar,
                    ^
  983.                            (point != NULL
  984.                             && p_scalar != NULL), points, scalars, ctx);

crypto/ec/ec_lib.c:933:1: Parameter `scalar->top`
    931.    */
    932.   
    933. > int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
    934.                     size_t num, const EC_POINT *points[],
    935.                     const BIGNUM *scalars[], BN_CTX *ctx)

crypto/ec/ec_lib.c:965:15: Call
    963.       else
    964.           /* use default */
    965.           ret = ec_wNAF_mul(group, r, scalar, num, points, scalars, ctx);
                         ^
    966.   
    967.       BN_CTX_free(new_ctx);

crypto/ec/ec_mult.c:410:1: Parameter `scalar->top`
      408.    * in the addition if scalar != NULL
      409.    */
      410. > int ec_wNAF_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
      411.                   size_t num, const EC_POINT *points[], const BIGNUM *scalars[],
      412.                   BN_CTX *ctx)

crypto/ec/ec_mult.c:453:20: Call
      451.                * always call the ladder version.
      452.                */
      453.               return ec_scalar_mul_ladder(group, r, scalar, NULL, ctx);
                                ^
      454.           }
      455.           if ((scalar == NULL) && (num == 1) && (scalars[0] != group->order)) {

crypto/ec/ec_mult.c:139:1: Parameter `scalar->top`
        137.    * Returns 1 on success, 0 otherwise.
        138.    */
        139. > int ec_scalar_mul_ladder(const EC_GROUP *group, EC_POINT *r,
        140.                            const BIGNUM *scalar, const EC_POINT *point,
        141.                            BN_CTX *ctx)

crypto/ec/ec_mult.c:215:10: Call
        213.       }
        214.   
        215.       if (!BN_copy(k, scalar)) {
                        ^
        216.           ECerr(EC_F_EC_SCALAR_MUL_LADDER, ERR_R_BN_LIB);
        217.           goto err;

crypto/bn/bn_lib.c:281:1: <Offset trace>
279.   }
280.   
281. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
282.   {
283.       bn_check_top(b);

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

crypto/bn/bn_lib.c:281:1: <Length trace>
279.   }
280.   
281. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
282.   {
283.       bn_check_top(b);

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:962:1: Parameter `*a->d`
            960.   }
            961.   
            962. > BIGNUM *bn_wexpand(BIGNUM *a, int words)
            963.   {
            964.       return (words <= a->dmax) ? a : bn_expand2(a, words);

crypto/bn/bn_lib.c:291:9: Array access: Offset added: [8, +oo] Size: [0, 536870848] by call to `EC_POINT_mul` 
          289.   
          290.       if (b->top > 0)
          291.           memcpy(a->d, b->d, sizeof(b->d[0]) * b->top);
                         ^
          292.   
          293.       a->neg = b->neg;
