crypto/bn/bn_exp.c:733: error: INTEGER_OVERFLOW_L2
  ([0, max(4294967295, `*in_mont->RR.d`)] - [0, max(4294967295, `*in_mont->RR.d`)]):unsigned32 by call to `BN_mod_mul_montgomery`.
Showing all 19 steps of the trace


crypto/bn/bn_exp.c:625:1: Parameter `*in_mont->RR.d`
623.    * http://www.daemonology.net/hyperthreading-considered-harmful/)
624.    */
625. > int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
626.   		    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
627.   	{

crypto/bn/bn_exp.c:733:12: Call
731.   		if (!BN_to_montgomery(&am,&am,mont,ctx))	goto err;
732.   		}
733.   	else	if (!BN_to_montgomery(&am,a,mont,ctx))		goto err;
                  ^
734.   
735.   #if defined(OPENSSL_BN_ASM_MONT) && (defined(__sparc__) || defined(__sparc))

crypto/bn/bn_mont.c:131:1: Parameter `*b->d`
  129.   #endif
  130.   
  131. > int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
  132.   			  BN_MONT_CTX *mont, BN_CTX *ctx)
  133.   	{

crypto/bn/bn_mont.c:163:8: Call
  161.   	else
  162.   		{
  163.   		if (!BN_mul(tmp,a,b,ctx)) goto err;
                ^
  164.   		}
  165.   	/* reduce from aRR to aR */

crypto/bn/bn_mul.c:943:1: Parameter `*b->d`
    941.   #endif /* BN_RECURSION */
    942.   
    943. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
    944.   	{
    945.   	int ret=0;

crypto/bn/bn_mul.c:1032:5: Call
    1030.   				if (bn_wexpand(t,k*4) == NULL) goto err;
    1031.   				if (bn_wexpand(rr,k*4) == NULL) goto err;
    1032.   				bn_mul_part_recursive(rr->d,a->d,b->d,
                ^
    1033.   					j,al-j,bl-j,t->d);
    1034.   				}

crypto/bn/bn_mul.c:550:1: Parameter `*b`
      548.    * t needs to be n*4 is size, as does r */
      549.   /* tnX may not be negative but less than n */
      550. > void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n,
      551.   	     int tna, int tnb, BN_ULONG *t)
      552.   	{

crypto/bn/bn_mul.c:569:5: Call
      567.   	/* r=(a[0]-a[1])*(b[1]-b[0]) */
      568.   	c1=bn_cmp_part_words(a,&(a[n]),tna,n-tna);
      569.   	c2=bn_cmp_part_words(&(b[n]),b,tnb,tnb-n);
                 ^
      570.   	neg=0;
      571.   	switch (c1*3+c2)

crypto/bn/bn_lib.c:807:1: Parameter `*b`
        805.      All lengths are the number of BN_ULONGs...  */
        806.   
        807. > int bn_cmp_part_words(const BN_ULONG *a, const BN_ULONG *b,
        808.   	int cl, int dl)
        809.   	{

crypto/bn/bn_mul.c:575:3: Call
      573.   	case -4:
      574.   		bn_sub_part_words(t,      &(a[n]),a,      tna,tna-n); /* - */
      575.   		bn_sub_part_words(&(t[n]),b,      &(b[n]),tnb,n-tnb); /* - */
               ^
      576.   		break;
      577.   	case -3:

crypto/bn/bn_mul.c:80:1: Parameter `*b`
        78.      assembler counterparts for the systems that use assembler files.  */
        79.   
        80. > BN_ULONG bn_sub_part_words(BN_ULONG *r,
        81.   	const BN_ULONG *a, const BN_ULONG *b,
        82.   	int cl, int dl)

crypto/bn/bn_mul.c:87:6: Call
        85.   
        86.   	assert(cl >= 0);
        87.   	c = bn_sub_words(r, a, b, cl);
                   ^
        88.   
        89.   	if (dl == 0)

crypto/bn/bn_asm.c:394:1: <LHS trace>
392.   #endif /* !BN_LLONG */
393.   
394. > BN_ULONG bn_sub_words(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b, int n)
395.           {
396.   	BN_ULONG t1,t2;

crypto/bn/bn_asm.c:394:1: Parameter `*a`
          392.   #endif /* !BN_LLONG */
          393.   
          394. > BN_ULONG bn_sub_words(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b, int n)
          395.           {
          396.   	BN_ULONG t1,t2;

crypto/bn/bn_asm.c:405:3: Assignment
          403.   	while (n&~3)
          404.   		{
          405.   		t1=a[0]; t2=b[0];
                   ^
          406.   		r[0]=(t1-t2-c)&BN_MASK2;
          407.   		if (t1 != t2) c=(t1 < t2);

crypto/bn/bn_asm.c:394:1: <RHS trace>
392.   #endif /* !BN_LLONG */
393.   
394. > BN_ULONG bn_sub_words(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b, int n)
395.           {
396.   	BN_ULONG t1,t2;

crypto/bn/bn_asm.c:394:1: Parameter `*b`
          392.   #endif /* !BN_LLONG */
          393.   
          394. > BN_ULONG bn_sub_words(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b, int n)
          395.           {
          396.   	BN_ULONG t1,t2;

crypto/bn/bn_asm.c:405:12: Assignment
          403.   	while (n&~3)
          404.   		{
          405.   		t1=a[0]; t2=b[0];
                            ^
          406.   		r[0]=(t1-t2-c)&BN_MASK2;
          407.   		if (t1 != t2) c=(t1 < t2);

crypto/bn/bn_asm.c:406:3: Binary operation: ([0, max(4294967295, *in_mont->RR.d)] - [0, max(4294967295, *in_mont->RR.d)]):unsigned32 by call to `BN_mod_mul_montgomery` 
          404.   		{
          405.   		t1=a[0]; t2=b[0];
          406.   		r[0]=(t1-t2-c)&BN_MASK2;
                   ^
          407.   		if (t1 != t2) c=(t1 < t2);
          408.   		t1=a[1]; t2=b[1];
