apps/s_client.c:258: error: BUFFER_OVERRUN_L3
  Offset: [-1, +oo] Size: [1, +oo] by call to `BN_mod_exp`.
Showing all 23 steps of the trace


apps/s_client.c:252:9: Call
250.       int ret =
251.           g != NULL && N != NULL && bn_ctx != NULL && BN_is_odd(N) &&
252.           BN_is_prime_ex(N, SRP_NUMBER_ITERATIONS_FOR_PRIME, bn_ctx, NULL) == 1 &&
               ^
253.           p != NULL && BN_rshift1(p, N) &&
254.           /* p = (N-1)/2 */

crypto/bn/bn_prime.c:194:1: Parameter `ctx_passed->stack.depth`
  192.   }
  193.   
  194. > int BN_is_prime_ex(const BIGNUM *a, int checks, BN_CTX *ctx_passed,
  195.                      BN_GENCB *cb)
  196.   {

crypto/bn/bn_prime.c:197:12: Call
  195.                      BN_GENCB *cb)
  196.   {
  197.       return BN_is_prime_fasttest_ex(a, checks, ctx_passed, 0, cb);
                    ^
  198.   }
  199.   

crypto/bn/bn_prime.c:200:1: Parameter `ctx_passed->stack.depth`
    198.   }
    199.   
    200. > int BN_is_prime_fasttest_ex(const BIGNUM *a, int checks, BN_CTX *ctx_passed,
    201.                               int do_trial_division, BN_GENCB *cb)
    202.   {

apps/s_client.c:258:9: Call
256.           r != NULL &&
257.           /* verify g^((N-1)/2) == -1 (mod N) */
258.           BN_mod_exp(r, g, p, N, bn_ctx) &&
               ^
259.           BN_add_word(r, 1) && BN_cmp(r, N) == 0;
260.   

crypto/bn/bn_exp.c:90:1: Parameter `ctx->stack.depth`
  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:155:15: Call
  153.   #ifdef RECP_MUL_MOD
  154.       {
  155.           ret = BN_mod_exp_recp(r, a, p, m, ctx);
                       ^
  156.       }
  157.   #else

crypto/bn/bn_exp.c:167:1: Parameter `ctx->stack.depth`
    165.   }
    166.   
    167. > int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
    168.                       const BIGNUM *m, BN_CTX *ctx)
    169.   {

crypto/bn/bn_exp.c:195:5: Call
    193.       }
    194.   
    195.       BN_CTX_start(ctx);
               ^
    196.       aa = BN_CTX_get(ctx);
    197.       val[0] = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:181:1: Parameter `ctx->stack.depth`
      179.   }
      180.   
      181. > void BN_CTX_start(BN_CTX *ctx)
      182.   {
      183.       CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_exp.c:214:10: Call
    212.       }
    213.   
    214.       if (!BN_nnmod(val[0], a, m, ctx))
                    ^
    215.           goto err;               /* 1 */
    216.       if (BN_is_zero(val[0])) {

crypto/bn/bn_mod.c:13:1: Parameter `ctx->stack.depth`
      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:193:5: Call
        191.       }
        192.   
        193.       BN_CTX_start(ctx);
                   ^
        194.       tmp = BN_CTX_get(ctx);
        195.       snum = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:181:1: Parameter `*ctx->stack.indexes`
          179.   }
          180.   
          181. > void BN_CTX_start(BN_CTX *ctx)
          182.   {
          183.       CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_div.c:416:5: Call
        414.       if (no_branch)
        415.           bn_correct_top(res);
        416.       BN_CTX_end(ctx);
                   ^
        417.       return (1);
        418.    err:

crypto/bn/bn_ctx.c:195:1: Parameter `*ctx->stack.indexes`
          193.   }
          194.   
          195. > void BN_CTX_end(BN_CTX *ctx)
          196.   {
          197.       CTXDBG_ENTRY("BN_CTX_end", ctx);

crypto/bn/bn_ctx.c:201:27: Call
          199.           ctx->err_stack--;
          200.       else {
          201.           unsigned int fp = BN_STACK_pop(&ctx->stack);
                                           ^
          202.           /* Does this stack frame have anything to release? */
          203.           if (fp < ctx->used)

crypto/bn/bn_ctx.c:271:1: <Offset trace>
269.   }
270.   
271. > static unsigned int BN_STACK_pop(BN_STACK *st)
272.   {
273.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:271:1: Parameter `st->depth`
            269.   }
            270.   
            271. > static unsigned int BN_STACK_pop(BN_STACK *st)
            272.   {
            273.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:271:1: <Length trace>
269.   }
270.   
271. > static unsigned int BN_STACK_pop(BN_STACK *st)
272.   {
273.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:271:1: Parameter `*st->indexes`
            269.   }
            270.   
            271. > static unsigned int BN_STACK_pop(BN_STACK *st)
            272.   {
            273.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:273:12: Array access: Offset: [-1, +oo] Size: [1, +oo] by call to `BN_mod_exp` 
            271.   static unsigned int BN_STACK_pop(BN_STACK *st)
            272.   {
            273.       return st->indexes[--(st->depth)];
                              ^
            274.   }
            275.   
