engines/ccgost/gost_pmeth.c:339: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned64 by call to `gost_do_verify`.
Showing all 20 steps of the trace


engines/ccgost/gost_pmeth.c:337:13: Call
335.   	int ok = 0;
336.   	EVP_PKEY* pub_key = EVP_PKEY_CTX_get0_pkey(ctx);
337.   	DSA_SIG *s=unpack_cp_signature(sig,siglen);
                   ^
338.   	if (!s) return 0;
339.   	if (pub_key) ok = gost_do_verify(tbs,tbs_len,s,EVP_PKEY_get0(pub_key));

engines/ccgost/gost_sign.c:277:9: Call
  275.   		}
  276.   	s->s = getbnfrombuf(sig , siglen/2);
  277.   	s->r = getbnfrombuf(sig + siglen/2, siglen/2);
                 ^
  278.   	return s;
  279.   	}

engines/ccgost/gost_sign.c:302:10: Call
    300.   	if (len)
    301.   		{
    302.   		return BN_bin2bn(buf,len,NULL);
                    ^
    303.   		}
    304.   	else

crypto/bn/bn_lib.c:597:1: Parameter `ret->top`
      595.   	}
      596.   
      597. > BIGNUM *BN_bin2bn(const unsigned char *s, size_t len, BIGNUM *ret)
      598.   	{
      599.   	unsigned int i,m;

engines/ccgost/gost_pmeth.c:339:20: Call
337.   	DSA_SIG *s=unpack_cp_signature(sig,siglen);
338.   	if (!s) return 0;
339.   	if (pub_key) ok = gost_do_verify(tbs,tbs_len,s,EVP_PKEY_get0(pub_key));
                          ^
340.   	DSA_SIG_free(s);
341.   	return ok;

engines/ccgost/gost_sign.c:135:1: Parameter `dsa->g->top`
  133.    */
  134.   
  135. > int gost_do_verify(const unsigned char *dgst, int dgst_len,
  136.   	DSA_SIG *sig, DSA *dsa)
  137.   	{

engines/ccgost/gost_sign.c:174:2: Call
  172.   	BN_sub(tmp,dsa->q,sig->r);
  173.   	BN_mod_mul(z2,tmp,v,dsa->p,ctx);
  174.   	BN_mod_exp(tmp,dsa->g,z1,dsa->p,ctx);
          ^
  175.   	BN_mod_exp(tmp2,dsa->pub_key,z2,dsa->p,ctx);
  176.   	BN_mod_mul(tmp3,tmp,tmp2,dsa->p,ctx);

crypto/bn/bn_exp.c:163:1: Parameter `a->top`
    161.   
    162.   
    163. > int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
    164.   	       BN_CTX *ctx)
    165.   	{

crypto/bn/bn_exp.c:223:8: Call
    221.   		else
    222.   #  endif
    223.   			ret=BN_mod_exp_mont(r,a,p,m,ctx,NULL);
                  ^
    224.   		}
    225.   	else

crypto/bn/bn_exp.c:371:1: Parameter `a->top`
      369.   
      370.   
      371. > int BN_mod_exp_mont(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
      372.   		    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
      373.   	{

crypto/bn/bn_exp.c:384:10: Call
      382.   	if (BN_get_flags(p, BN_FLG_CONSTTIME) != 0)
      383.   		{
      384.   		return BN_mod_exp_mont_consttime(rr, a, p, m, ctx, in_mont);
                      ^
      385.   		}
      386.   

crypto/bn/bn_exp.c:574:1: Parameter `a->top`
        572.    * http://www.daemonology.net/hyperthreading-considered-harmful/)
        573.    */
        574. > int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
        575.   		    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
        576.   	{

crypto/bn/bn_exp.c:650:8: Call
        648.   	if (a->neg || BN_ucmp(a,m) >= 0)
        649.   		{
        650.   		if (!BN_mod(am,a,m,ctx))
                      ^
        651.   			goto err;
        652.   		aa= am;

crypto/bn/bn_div.c:181:1: Parameter `num->top`
          179.   static int BN_div_no_branch(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num,
          180.           const BIGNUM *divisor, BN_CTX *ctx);
          181. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
          182.   	   BN_CTX *ctx)
          183.   	{

crypto/bn/bn_div.c:204:10: Call
          202.   	if ((BN_get_flags(num, BN_FLG_CONSTTIME) != 0) || (BN_get_flags(divisor, BN_FLG_CONSTTIME) != 0))
          203.   		{
          204.   		return BN_div_no_branch(dv, rm, num, divisor, ctx);
                          ^
          205.   		}
          206.   

crypto/bn/bn_div.c:426:1: Parameter `num->top`
            424.    * branches that may leak sensitive information.
            425.    */
            426. > static int BN_div_no_branch(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, 
            427.   	const BIGNUM *divisor, BN_CTX *ctx)
            428.   	{

crypto/bn/bn_div.c:460:8: Call
            458.   	sdiv->neg=0;
            459.   	norm_shift+=BN_BITS2;
            460.   	if (!(BN_lshift(snum,num,norm_shift))) goto err;
                          ^
            461.   	snum->neg=0;
            462.   

crypto/bn/bn_shift.c:132:1: <LHS trace>
130.   	}
131.   
132. > int BN_lshift(BIGNUM *r, const BIGNUM *a, int n)
133.   	{
134.   	int i,nw,lb,rb;

crypto/bn/bn_shift.c:132:1: Parameter `a->top`
              130.   	}
              131.   
              132. > int BN_lshift(BIGNUM *r, const BIGNUM *a, int n)
              133.   	{
              134.   	int i,nw,lb,rb;

crypto/bn/bn_shift.c:150:8: Binary operation: ([0, +oo] - 1):unsigned64 by call to `gost_do_verify` 
              148.   	t[a->top+nw]=0;
              149.   	if (lb == 0)
              150.   		for (i=a->top-1; i>=0; i--)
                            ^
              151.   			t[nw+i]=f[i];
              152.   	else
