crypto/bn/bn_exp.c:220: error: BUFFER_OVERRUN_L3
  Offset: [1, +oo] Size: [0, 8388607] by call to `BN_mod_mul_reciprocal`.
Showing all 18 steps of the trace


crypto/bn/bn_exp.c:203:13: Call
201.               goto err;
202.           aa->neg = 0;
203.           if (BN_RECP_CTX_set(&recp, aa, ctx) <= 0)
                   ^
204.               goto err;
205.       } else {

crypto/bn/bn_recp.c:45:1: Parameter `*recp->Nr.d`
  43.   }
  44.   
  45. > int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *d, BN_CTX *ctx)
  46.   {
  47.       if (!BN_copy(&(recp->N), d))

crypto/bn/bn_exp.c:220:14: Call
218.       window = BN_window_bits_for_exponent_size(bits);
219.       if (window > 1) {
220.           if (!BN_mod_mul_reciprocal(aa, val[0], val[0], &recp, ctx))
                    ^
221.               goto err;           /* 2 */
222.           j = 1 << (window - 1);

crypto/bn/bn_recp.c:55:1: Parameter `*recp->Nr.d`
  53.   }
  54.   
  55. > int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,
  56.                             BN_RECP_CTX *recp, BN_CTX *ctx)
  57.   {

crypto/bn/bn_recp.c:77:11: Call
  75.           ca = x;                 /* Just do the mod */
  76.   
  77.       ret = BN_div_recp(NULL, r, ca, recp, ctx);
                  ^
  78.    err:
  79.       BN_CTX_end(ctx);

crypto/bn/bn_recp.c:84:1: Parameter `*recp->Nr.d`
    82.   }
    83.   
    84. > int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
    85.                   BN_RECP_CTX *recp, BN_CTX *ctx)
    86.   {

crypto/bn/bn_recp.c:121:23: Call
    119.       /* Nr := round(2^i / N) */
    120.       if (i != recp->shift)
    121.           recp->shift = BN_reciprocal(&(recp->Nr), &(recp->N), i, ctx);
                                 ^
    122.       /* BN_reciprocal could have returned -1 for an error */
    123.       if (recp->shift == -1)

crypto/bn/bn_recp.c:174:1: Parameter `*r->d`
      172.    */
      173.   /* r := 2^len / m */
      174. > int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx)
      175.   {
      176.       int ret = -1;

crypto/bn/bn_recp.c:186:10: Call
      184.           goto err;
      185.   
      186.       if (!BN_div(r, NULL, t, m, ctx))
                      ^
      187.           goto err;
      188.   

crypto/bn/bn_div.c:229:11: Call
        227.       }
        228.   
        229.       ret = bn_div_fixed_top(dv, rm, num, divisor, ctx);
                         ^
        230.   
        231.       if (ret) {

crypto/bn/bn_div.c:264:1: Parameter `dv->top`
          262.    *       divisor's length is considered public;
          263.    */
          264. > int bn_div_fixed_top(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num,
          265.                        const BIGNUM *divisor, BN_CTX *ctx)
          266.   {

crypto/bn/bn_div.c:233:13: Call
        231.       if (ret) {
        232.           if (dv != NULL)
        233.               bn_correct_top(dv);
                           ^
        234.           if (rm != NULL)
        235.               bn_correct_top(rm);

crypto/bn/bn_lib.c:965:1: <Offset trace>
963.   }
964.   
965. > void bn_correct_top(BIGNUM *a)
966.   {
967.       BN_ULONG *ftl;

crypto/bn/bn_lib.c:965:1: Parameter `a->top`
          963.   }
          964.   
          965. > void bn_correct_top(BIGNUM *a)
          966.   {
          967.       BN_ULONG *ftl;

crypto/bn/bn_lib.c:968:5: Assignment
          966.   {
          967.       BN_ULONG *ftl;
          968.       int tmp_top = a->top;
                     ^
          969.   
          970.       if (tmp_top > 0) {

crypto/bn/bn_lib.c:965:1: <Length trace>
963.   }
964.   
965. > void bn_correct_top(BIGNUM *a)
966.   {
967.       BN_ULONG *ftl;

crypto/bn/bn_lib.c:965:1: Parameter `*a->d`
          963.   }
          964.   
          965. > void bn_correct_top(BIGNUM *a)
          966.   {
          967.       BN_ULONG *ftl;

crypto/bn/bn_lib.c:971:14: Array access: Offset: [1, +oo] Size: [0, 8388607] by call to `BN_mod_mul_reciprocal` 
          969.   
          970.       if (tmp_top > 0) {
          971.           for (ftl = &(a->d[tmp_top]); tmp_top > 0; tmp_top--) {
                              ^
          972.               ftl--;
          973.               if (*ftl != 0)
