crypto/sm2/sm2_crypt.c:329: error: BUFFER_OVERRUN_L3
  Offset: [1, +oo] Size: [0, 8388607] by call to `EC_POINT_mul`.
Showing all 27 steps of the trace


crypto/sm2/sm2_crypt.c:329:17: Call
327.       if (!EC_POINT_set_affine_coordinates_GFp(group, C1, sm2_ctext->C1x,
328.                                               sm2_ctext->C1y, ctx)
329.               || !EC_POINT_mul(group, C1, NULL, C1, EC_KEY_get0_private_key(key),
                       ^
330.                                ctx)
331.               || !EC_POINT_get_affine_coordinates_GFp(group, C1, x2, y2, ctx)) {

crypto/ec/ec_lib.c:929:1: Parameter `group->order->top`
  927.   }
  928.   
  929. > int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_scalar,
  930.                    const EC_POINT *point, const BIGNUM *p_scalar, BN_CTX *ctx)
  931.   {

crypto/ec/ec_lib.c:940:12: Call
  938.       scalars[0] = p_scalar;
  939.   
  940.       return EC_POINTs_mul(group, r, g_scalar,
                    ^
  941.                            (point != NULL
  942.                             && p_scalar != NULL), points, scalars, ctx);

crypto/ec/ec_lib.c:918:1: Parameter `group->order->top`
    916.    */
    917.   
    918. > int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
    919.                     size_t num, const EC_POINT *points[],
    920.                     const BIGNUM *scalars[], BN_CTX *ctx)

crypto/ec/ec_lib.c:924:16: Call
    922.       if (group->meth->mul == 0)
    923.           /* use default */
    924.           return ec_wNAF_mul(group, r, scalar, num, points, scalars, ctx);
                          ^
    925.   
    926.       return group->meth->mul(group, r, scalar, num, points, scalars, ctx);

crypto/ec/ec_mult.c:342:1: Parameter `group->order->top`
      340.    * in the addition if scalar != NULL
      341.    */
      342. > int ec_wNAF_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
      343.                   size_t num, const EC_POINT *points[], const BIGNUM *scalars[],
      344.                   BN_CTX *ctx)

crypto/ec/ec_mult.c:393:16: Call
      391.            * constant time version.
      392.            */
      393.           return ec_mul_consttime(group, r, scalar, NULL, ctx);
                            ^
      394.       }
      395.       if ((scalar == NULL) && (num == 1)) {

crypto/ec/ec_mult.c:131:1: Parameter `group->order->top`
        129.    * Returns 1 on success, 0 otherwise.
        130.    */
        131. > static int ec_mul_consttime(const EC_GROUP *group, EC_POINT *r,
        132.                               const BIGNUM *scalar, const EC_POINT *point,
        133.                               BN_CTX *ctx)

crypto/ec/ec_mult.c:147:18: Call
        145.       BN_CTX_start(ctx);
        146.   
        147.       order_bits = BN_num_bits(group->order);
                                ^
        148.   
        149.       s = EC_POINT_new(group);

crypto/bn/bn_lib.c:139:9: Call
          137.       bn_check_top(a);
          138.   
          139.       if (BN_is_zero(a))
                         ^
          140.           return 0;
          141.       return ((i * BN_BITS2) + BN_num_bits_word(a->d[i]));

crypto/bn/bn_lib.c:845:1: Parameter `a->top`
            843.   }
            844.   
            845. > int BN_is_zero(const BIGNUM *a)
            846.   {
            847.       return a->top == 0;

crypto/ec/ec_mult.c:189:14: Call
        187.            * constant-timeness
        188.            */
        189.           if (!BN_nnmod(k, k, group->order, ctx))
                            ^
        190.               goto err;
        191.       }

crypto/bn/bn_mod.c:13:1: Parameter `d->top`
          11.   #include "bn_lcl.h"
          12.   
          13. > int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx)
          14.   {
          15.       /*

crypto/bn/bn_mod.c:20:11: Call
          18.        */
          19.   
          20.       if (!(BN_mod(r, m, d, ctx)))
                          ^
          21.           return 0;
          22.       if (!r->neg)

crypto/bn/bn_div.c:199:31: Call
            197.   
            198.       /* First we normalise the numbers */
            199.       norm_shift = BN_BITS2 - ((BN_num_bits(divisor)) % BN_BITS2);
                                                 ^
            200.       if (!(BN_lshift(sdiv, divisor, norm_shift)))
            201.           goto err;

crypto/bn/bn_lib.c:140:9: Assignment
              138.   
              139.       if (BN_is_zero(a))
              140.           return 0;
                             ^
              141.       return ((i * BN_BITS2) + BN_num_bits_word(a->d[i]));
              142.   }

crypto/bn/bn_div.c:199:5: Assignment
            197.   
            198.       /* First we normalise the numbers */
            199.       norm_shift = BN_BITS2 - ((BN_num_bits(divisor)) % BN_BITS2);
                       ^
            200.       if (!(BN_lshift(sdiv, divisor, norm_shift)))
            201.           goto err;

crypto/bn/bn_div.c:200:11: Call
            198.       /* First we normalise the numbers */
            199.       norm_shift = BN_BITS2 - ((BN_num_bits(divisor)) % BN_BITS2);
            200.       if (!(BN_lshift(sdiv, divisor, norm_shift)))
                             ^
            201.           goto err;
            202.       sdiv->neg = 0;

crypto/bn/bn_shift.c:83:1: <Offset trace>
81.   }
82.   
83. > int BN_lshift(BIGNUM *r, const BIGNUM *a, int n)
84.   {
85.       int i, nw, lb, rb;

crypto/bn/bn_shift.c:83:1: Parameter `n`
              81.   }
              82.   
              83. > int BN_lshift(BIGNUM *r, const BIGNUM *a, int n)
              84.   {
              85.       int i, nw, lb, rb;

crypto/bn/bn_shift.c:97:5: Assignment
              95.       }
              96.   
              97.       nw = n / BN_BITS2;
                         ^
              98.       if (bn_wexpand(r, a->top + nw + 1) == NULL)
              99.           return 0;

crypto/bn/bn_shift.c:83:1: <Length trace>
81.   }
82.   
83. > int BN_lshift(BIGNUM *r, const BIGNUM *a, int n)
84.   {
85.       int i, nw, lb, rb;

crypto/bn/bn_shift.c:83:1: Parameter `*r->d`
              81.   }
              82.   
              83. > int BN_lshift(BIGNUM *r, const BIGNUM *a, int n)
              84.   {
              85.       int i, nw, lb, rb;

crypto/bn/bn_shift.c:98:9: Call
              96.   
              97.       nw = n / BN_BITS2;
              98.       if (bn_wexpand(r, a->top + nw + 1) == NULL)
                             ^
              99.           return 0;
              100.       r->neg = a->neg;

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

crypto/bn/bn_shift.c:104:5: Assignment
              102.       rb = BN_BITS2 - lb;
              103.       f = a->d;
              104.       t = r->d;
                         ^
              105.       t[a->top + nw] = 0;
              106.       if (lb == 0)

crypto/bn/bn_shift.c:112:13: Array access: Offset: [1, +oo] Size: [0, 8388607] by call to `EC_POINT_mul` 
              110.           for (i = a->top - 1; i >= 0; i--) {
              111.               l = f[i];
              112.               t[nw + i + 1] |= (l >> rb) & BN_MASK2;
                                 ^
              113.               t[nw + i] = (l << lb) & BN_MASK2;
              114.           }
