crypto/bn/bn_prime.c:387: error: BUFFER_OVERRUN_L3
  Offset: [8, +oo] (⇐ [8, +oo] + [0, +oo]) Size: [0, 8388607] by call to `witness`.
Showing all 22 steps of the trace


crypto/bn/bn_prime.c:343:18: Call
341.       if (a->neg) {
342.           BIGNUM *t;
343.           if ((t = BN_CTX_get(ctx)) == NULL)
                        ^
344.               goto err;
345.           BN_copy(t, a);

crypto/bn/bn_ctx.c:284:5: Call
  282.       }
  283.       /* OK, make sure the returned bignum is "zero" */
  284.       BN_zero(ret);
             ^
  285.       ctx->used++;
  286.       CTXDBG_RET(ctx, ret);

crypto/bn/bn_lib.c:530:1: Parameter `*a->d`
    528.   }
    529.   
    530. > int BN_set_word(BIGNUM *a, BN_ULONG w)
    531.   {
    532.       bn_check_top(a);

crypto/bn/bn_prime.c:387:13: Call
385.           /* now 1 <= check < A */
386.   
387.           j = witness(check, A, A1, A1_odd, k, ctx, mont);
                   ^
388.           if (j == -1)
389.               goto err;

crypto/bn/bn_prime.c:478:1: Parameter `*w->d`
  476.   }
  477.   
  478. > static int witness(BIGNUM *w, const BIGNUM *a, const BIGNUM *a1,
  479.                      const BIGNUM *a1_odd, int k, BN_CTX *ctx,
  480.                      BN_MONT_CTX *mont)

crypto/bn/bn_prime.c:482:10: Call
  480.                      BN_MONT_CTX *mont)
  481.   {
  482.       if (!BN_mod_exp_mont(w, w, a1_odd, a, ctx, mont)) /* w := w^a1_odd mod a */
                  ^
  483.           return -1;
  484.       if (BN_is_one(w))

crypto/bn/bn_exp.c:401:1: Parameter `*rr->d`
    399.   }
    400.   
    401. > int BN_mod_exp_mont(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
    402.                       const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
    403.   {

crypto/bn/bn_prime.c:489:14: Call
  487.           return 0;               /* w == -1 (mod a), 'a' is probably prime */
  488.       while (--k) {
  489.           if (!BN_mod_mul(w, w, w, a, ctx)) /* w := w^2 mod a */
                      ^
  490.               return -1;
  491.           if (BN_is_one(w))

crypto/bn/bn_mod.c:179:1: Parameter `*b->d`
    177.   
    178.   /* slow but works */
    179. > int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
    180.                  BN_CTX *ctx)
    181.   {

crypto/bn/bn_mod.c:196:14: Call
    194.               goto err;
    195.       } else {
    196.           if (!BN_mul(t, a, b, ctx))
                        ^
    197.               goto err;
    198.       }

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 `n`
        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:548:10: Call
        546.       /* r=(a[0]-a[1])*(b[1]-b[0]) */
        547.       c1 = bn_cmp_part_words(a, &(a[n]), tna, n - tna);
        548.       c2 = bn_cmp_part_words(&(b[n]), b, tnb, tnb - n);
                        ^
        549.       neg = 0;
        550.       switch (c1 * 3 + c2) {

crypto/bn/bn_lib.c:782:1: Parameter `cl`
          780.    */
          781.   
          782. > int bn_cmp_part_words(const BN_ULONG *a, const BN_ULONG *b, int cl, int dl)
          783.   {
          784.       int n, i;

crypto/bn/bn_lib.c:799:12: Call
          797.           }
          798.       }
          799.       return bn_cmp_words(a, b, cl);
                            ^
          800.   }
          801.   

crypto/bn/bn_lib.c:755:1: <Offset trace>
753.   }
754.   
755. > int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n)
756.   {
757.       int i;

crypto/bn/bn_lib.c:755:1: Parameter `n`
            753.   }
            754.   
            755. > int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n)
            756.   {
            757.       int i;

crypto/bn/bn_lib.c:764:10: Assignment
            762.       if (aa != bb)
            763.           return ((aa > bb) ? 1 : -1);
            764.       for (i = n - 2; i >= 0; i--) {
                            ^
            765.           aa = a[i];
            766.           bb = b[i];

crypto/bn/bn_lib.c:755:1: <Length trace>
753.   }
754.   
755. > int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n)
756.   {
757.       int i;

crypto/bn/bn_lib.c:755:1: Parameter `*a`
            753.   }
            754.   
            755. > int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n)
            756.   {
            757.       int i;

crypto/bn/bn_lib.c:765:14: Array access: Offset: [8, +oo] (⇐ [8, +oo] + [0, +oo]) Size: [0, 8388607] by call to `witness` 
            763.           return ((aa > bb) ? 1 : -1);
            764.       for (i = n - 2; i >= 0; i--) {
            765.           aa = a[i];
                                ^
            766.           bb = b[i];
            767.           if (aa != bb)
