test/srptest.c:180: error: BUFFER_OVERRUN_L3
  Offset: [16, +oo] (⇐ 1 + [15, +oo]) Size: [0, 8388607] by call to `SRP_create_verifier_BN`.
Showing all 25 steps of the trace


test/srptest.c:180:10: Call
178.       BN_hex2bn(&s, "BEB25379D1A8581EB5A727673A2441EE");
179.       /* Set up server's password entry */
180.       if (!SRP_create_verifier_BN("alice", "password123", &s, &v, GN->N,
                ^
181.                                   GN->g)) {
182.           fprintf(stderr, "Failed to create SRP verifier\n");

crypto/srp/srp_vfy.c:630:1: Parameter `g->top`
  628.    * BIGNUMS.
  629.    */
  630. > int SRP_create_verifier_BN(const char *user, const char *pass, BIGNUM **salt,
  631.                              BIGNUM **verifier, const BIGNUM *N,
  632.                              const BIGNUM *g)

crypto/srp/srp_vfy.c:661:10: Call
  659.           goto err;
  660.   
  661.       if (!BN_mod_exp(*verifier, g, x, N, bn_ctx)) {
                  ^
  662.           BN_clear_free(*verifier);
  663.           goto err;

crypto/bn/bn_exp.c:90:1: Parameter `a->top`
    88.   }
    89.   
    90. > int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
    91.                  BN_CTX *ctx)
    92.   {

crypto/bn/bn_exp.c:150:19: Call
    148.           } else
    149.   # endif
    150.               ret = BN_mod_exp_mont(r, a, p, m, ctx, NULL);
                             ^
    151.       } else
    152.   #endif

crypto/bn/bn_exp.c:300:1: Parameter `a->top`
      298.   }
      299.   
      300. > int BN_mod_exp_mont(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
      301.                       const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
      302.   {

crypto/bn/bn_exp.c:312:16: Call
      310.   
      311.       if (BN_get_flags(p, BN_FLG_CONSTTIME) != 0) {
      312.           return BN_mod_exp_mont_consttime(rr, a, p, m, ctx, in_mont);
                            ^
      313.       }
      314.   

crypto/bn/bn_exp.c:600:1: Parameter `a->top`
        598.    * http://www.daemonology.net/hyperthreading-considered-harmful/)
        599.    */
        600. > int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
        601.                                 const BIGNUM *m, BN_CTX *ctx,
        602.                                 BN_MONT_CTX *in_mont)

crypto/bn/bn_exp.c:757:17: Call
        755.           if (!BN_to_montgomery(&am, &am, mont, ctx))
        756.               goto err;
        757.       } else if (!BN_to_montgomery(&am, a, mont, ctx))
                               ^
        758.           goto err;
        759.   

crypto/bn/bn_lib.c:945:1: Parameter `a->top`
          943.   }
          944.   
          945. > int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
          946.                        BN_CTX *ctx)
          947.   {

crypto/bn/bn_lib.c:948:12: Call
          946.                        BN_CTX *ctx)
          947.   {
          948.       return BN_mod_mul_montgomery(r, a, &(mont->RR), mont, ctx);
                            ^
          949.   }
          950.   

crypto/bn/bn_mont.c:26:1: Parameter `a->top`
            24.   #endif
            25.   
            26. > int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
            27.                             BN_MONT_CTX *mont, BN_CTX *ctx)
            28.   {

crypto/bn/bn_mont.c:53:14: Call
            51.       bn_check_top(tmp);
            52.       if (a == b) {
            53.           if (!BN_sqr(tmp, a, ctx))
                               ^
            54.               goto err;
            55.       } else {

crypto/bn/bn_sqr.c:17:1: Parameter `a->top`
              15.    * I've just gone over this and it is now %20 faster on x86 - eay - 27 Jun 96
              16.    */
              17. > int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx)
              18.   {
              19.       int max, al;

crypto/bn/bn_sqr.c:25:5: Assignment
              23.       bn_check_top(a);
              24.   
              25.       al = a->top;
                        ^
              26.       if (al <= 0) {
              27.           r->top = 0;

crypto/bn/bn_sqr.c:74:17: Call
              72.                   if (bn_wexpand(tmp, max) == NULL)
              73.                       goto err;
              74.                   bn_sqr_normal(rr->d, a->d, al, tmp->d);
                                    ^
              75.               }
              76.           }

crypto/bn/bn_sqr.c:104:1: <Offset trace>
102.   
103.   /* tmp must have 2*n words */
104. > void bn_sqr_normal(BN_ULONG *r, const BN_ULONG *a, int n, BN_ULONG *tmp)
105.   {
106.       int i, j, max;

crypto/bn/bn_sqr.c:104:1: Parameter `n`
                102.   
                103.   /* tmp must have 2*n words */
                104. > void bn_sqr_normal(BN_ULONG *r, const BN_ULONG *a, int n, BN_ULONG *tmp)
                105.   {
                106.       int i, j, max;

crypto/bn/bn_sqr.c:115:5: Assignment
                113.       rp[0] = rp[max - 1] = 0;
                114.       rp++;
                115.       j = n;
                           ^
                116.   
                117.       if (--j > 0) {

crypto/bn/bn_sqr.c:117:9: Assignment
                115.       j = n;
                116.   
                117.       if (--j > 0) {
                               ^
                118.           ap++;
                119.           rp[j] = bn_mul_words(rp, ap, j, ap[-1]);

crypto/bn/bn_sqr.c:104:1: <Length trace>
102.   
103.   /* tmp must have 2*n words */
104. > void bn_sqr_normal(BN_ULONG *r, const BN_ULONG *a, int n, BN_ULONG *tmp)
105.   {
106.       int i, j, max;

crypto/bn/bn_sqr.c:104:1: Parameter `*r`
                102.   
                103.   /* tmp must have 2*n words */
                104. > void bn_sqr_normal(BN_ULONG *r, const BN_ULONG *a, int n, BN_ULONG *tmp)
                105.   {
                106.       int i, j, max;

crypto/bn/bn_sqr.c:112:5: Assignment
                110.       max = n * 2;
                111.       ap = a;
                112.       rp = r;
                           ^
                113.       rp[0] = rp[max - 1] = 0;
                114.       rp++;

crypto/bn/bn_sqr.c:114:5: Assignment
                112.       rp = r;
                113.       rp[0] = rp[max - 1] = 0;
                114.       rp++;
                           ^
                115.       j = n;
                116.   

crypto/bn/bn_sqr.c:119:9: Array access: Offset: [16, +oo] (⇐ 1 + [15, +oo]) Size: [0, 8388607] by call to `SRP_create_verifier_BN` 
                117.       if (--j > 0) {
                118.           ap++;
                119.           rp[j] = bn_mul_words(rp, ap, j, ap[-1]);
                               ^
                120.           rp += 2;
                121.       }
