crypto/ec/ecp_mont.c:201: error: BUFFER_OVERRUN_L3
  Offset: 0 Size: [0, 8388607] by call to `BN_to_montgomery`.
Showing all 14 steps of the trace


crypto/ec/ecp_mont.c:194:10: Call
192.       if (mont == NULL)
193.           goto err;
194.       if (!BN_MONT_CTX_set(mont, p, ctx)) {
                ^
195.           ECerr(EC_F_EC_GFP_MONT_GROUP_SET_CURVE, ERR_R_BN_LIB);
196.           goto err;

crypto/bn/bn_mont.c:349:1: Parameter `*mont->RR.d`
  347.   }
  348.   
  349. > int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx)
  350.   {
  351.       int ret = 0;

crypto/ec/ecp_mont.c:201:10: Call
199.       if (one == NULL)
200.           goto err;
201.       if (!BN_to_montgomery(one, BN_value_one(), mont, ctx))
                ^
202.           goto err;
203.   

crypto/bn/bn_lib.c:924:1: Parameter `*mont->RR.d`
  922.   }
  923.   
  924. > int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
  925.                        BN_CTX *ctx)
  926.   {

crypto/bn/bn_lib.c:927:12: Call
  925.                        BN_CTX *ctx)
  926.   {
  927.       return BN_mod_mul_montgomery(r, a, &(mont->RR), mont, ctx);
                    ^
  928.   }
  929.   

crypto/bn/bn_mont.c:128:1: Parameter `*b->d`
    126.   #endif
    127.   
    128. > int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
    129.                             BN_MONT_CTX *mont, BN_CTX *ctx)
    130.   {

crypto/bn/bn_mont.c:158:14: Call
    156.               goto err;
    157.       } else {
    158.           if (!BN_mul(tmp, a, b, ctx))
                        ^
    159.               goto err;
    160.       }

crypto/bn/bn_mul.c:883:1: Parameter `*b->d`
      881.   #endif                          /* BN_RECURSION */
      882.   
      883. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
      884.   {
      885.       int ret = 0;

crypto/bn/bn_mul.c:964:17: Call
      962.                   if (bn_wexpand(rr, k * 4) == NULL)
      963.                       goto err;
      964.                   bn_mul_part_recursive(rr->d, a->d, b->d,
                             ^
      965.                                         j, al - j, bl - j, t->d);
      966.               } else {            /* al <= j || bl <= j */

crypto/bn/bn_mul.c:534:1: Parameter `*b`
        532.    */
        533.   /* tnX may not be negative but less than n */
        534. > void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n,
        535.                              int tna, int tnb, BN_ULONG *t)
        536.   {

crypto/bn/bn_mul.c:542:9: Call
        540.   
        541.       if (n < 8) {
        542.           bn_mul_normal(r, a, n + tna, b, n + tnb);
                       ^
        543.           return;
        544.       }

crypto/bn/bn_mul.c:1037:1: <Length trace>
1035.   }
1036.   
1037. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
1038.   {
1039.       BN_ULONG *rr;

crypto/bn/bn_mul.c:1037:1: Parameter `*b`
          1035.   }
          1036.   
          1037. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
          1038.   {
          1039.       BN_ULONG *rr;

crypto/bn/bn_mul.c:1058:40: Array access: Offset: 0 Size: [0, 8388607] by call to `BN_to_montgomery` 
          1056.           return;
          1057.       } else
          1058.           rr[0] = bn_mul_words(r, a, na, b[0]);
                                                         ^
          1059.   
          1060.       for (;;) {
