make update

[oweals/openssl.git] / crypto / bn / bn_nist.c

diff --git a/crypto/bn/bn_nist.c b/crypto/bn/bn_nist.c
index ea991c95b1ceb37249ddd3c3b336d2fc1cba3018..c6de032696e05ffe56a6ad4fad18cd28b8c10aae 100644 (file)
--- a/crypto/bn/bn_nist.c
+++ b/crypto/bn/bn_nist.c
@@ -354,7 +354,7 @@ int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
                 buf[BN_NIST_192_TOP],
                 c_d[BN_NIST_192_TOP],
                *res;
-       size_t   mask;
+       PTR_SIZE_INT mask;
        static const BIGNUM _bignum_nist_p_192_sqr = {
                (BN_ULONG *)_nist_p_192_sqr,
                sizeof(_nist_p_192_sqr)/sizeof(_nist_p_192_sqr[0]),
@@ -388,14 +388,14 @@ int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
        nist_cp_bn_0(buf, a_d + BN_NIST_192_TOP, top - BN_NIST_192_TOP, BN_NIST_192_TOP);
 
        nist_set_192(t_d, buf, 0, 3, 3);
-       carry = bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP);
+       carry = (int)bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP);
        nist_set_192(t_d, buf, 4, 4, 0);
-       carry += bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP);
+       carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP);
        nist_set_192(t_d, buf, 5, 5, 5)
-       carry += bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP);
+       carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP);
 
        if (carry > 0)
-               carry = bn_sub_words(r_d,r_d,_nist_p_192[carry-1],BN_NIST_192_TOP);
+               carry = (int)bn_sub_words(r_d,r_d,_nist_p_192[carry-1],BN_NIST_192_TOP);
        else
                carry = 1;
 
@@ -405,9 +405,10 @@ int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
         * 'tmp=result-modulus; if (!carry || !borrow) result=tmp;'
         * this is what happens below, but without explicit if:-) a.
         */
-       mask  = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_192[0],BN_NIST_192_TOP);
-       mask &= 0-(size_t)carry;
-       res   = (BN_ULONG *)(((size_t)c_d&~mask) | ((size_t)r_d&mask));
+       mask  = 0-(PTR_SIZE_INT)bn_sub_words(c_d,r_d,_nist_p_192[0],BN_NIST_192_TOP);
+       mask &= 0-(PTR_SIZE_INT)carry;
+       res   = (BN_ULONG *)
+        (((PTR_SIZE_INT)c_d&~mask) | ((PTR_SIZE_INT)r_d&mask));
        nist_cp_bn(r_d, res, BN_NIST_192_TOP);
        r->top = BN_NIST_192_TOP;
        bn_correct_top(r);
@@ -438,8 +439,8 @@ int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
                 buf[BN_NIST_224_TOP],
                 c_d[BN_NIST_224_TOP],
                *res;
-       size_t   mask;
-       union { bn_addsub_f f; size_t p; } u;
+       PTR_SIZE_INT mask;
+       union { bn_addsub_f f; PTR_SIZE_INT p; } u;
        static const BIGNUM _bignum_nist_p_224_sqr = {
                (BN_ULONG *)_nist_p_224_sqr,
                sizeof(_nist_p_224_sqr)/sizeof(_nist_p_224_sqr[0]),
@@ -482,13 +483,13 @@ int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
        nist_cp_bn_0(buf, a_d + BN_NIST_224_TOP, top - BN_NIST_224_TOP, BN_NIST_224_TOP);
 #endif
        nist_set_224(t_d, buf, 10, 9, 8, 7, 0, 0, 0);
-       carry = bn_add_words(r_d, r_d, t_d, BN_NIST_224_TOP);
+       carry = (int)bn_add_words(r_d, r_d, t_d, BN_NIST_224_TOP);
        nist_set_224(t_d, buf, 0, 13, 12, 11, 0, 0, 0);
-       carry += bn_add_words(r_d, r_d, t_d, BN_NIST_224_TOP);
+       carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_224_TOP);
        nist_set_224(t_d, buf, 13, 12, 11, 10, 9, 8, 7);
-       carry -= bn_sub_words(r_d, r_d, t_d, BN_NIST_224_TOP);
+       carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_224_TOP);
        nist_set_224(t_d, buf, 0, 0, 0, 0, 13, 12, 11);
-       carry -= bn_sub_words(r_d, r_d, t_d, BN_NIST_224_TOP);
+       carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_224_TOP);
 
 #if BN_BITS2==64
        carry = (int)(r_d[BN_NIST_224_TOP-1]>>32);
@@ -496,7 +497,7 @@ int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
        u.f = bn_sub_words;
        if (carry > 0)
                {
-               carry = bn_sub_words(r_d,r_d,_nist_p_224[carry-1],BN_NIST_224_TOP);
+               carry = (int)bn_sub_words(r_d,r_d,_nist_p_224[carry-1],BN_NIST_224_TOP);
 #if BN_BITS2==64
                carry=(int)(~(r_d[BN_NIST_224_TOP-1]>>32))&1;
 #endif
@@ -509,17 +510,19 @@ int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
                 * the modulus. but if it does, then result has
                 * to be compared to the modulus and conditionally
                 * adjusted by *subtracting* the latter. */
-               carry = bn_add_words(r_d,r_d,_nist_p_224[-carry-1],BN_NIST_224_TOP);
-               mask = 0-(size_t)carry;
-               u.p = ((size_t)bn_sub_words&mask) | ((size_t)bn_add_words&~mask);
+               carry = (int)bn_add_words(r_d,r_d,_nist_p_224[-carry-1],BN_NIST_224_TOP);
+               mask = 0-(PTR_SIZE_INT)carry;
+               u.p = ((PTR_SIZE_INT)bn_sub_words&mask) |
+                ((PTR_SIZE_INT)bn_add_words&~mask);
                }
        else
                carry = 1;
 
        /* otherwise it's effectively same as in BN_nist_mod_192... */
-       mask  = 0-(size_t)(*u.f)(c_d,r_d,_nist_p_224[0],BN_NIST_224_TOP);
-       mask &= 0-(size_t)carry;
-       res   = (BN_ULONG *)(((size_t)c_d&~mask) | ((size_t)r_d&mask));
+       mask  = 0-(PTR_SIZE_INT)(*u.f)(c_d,r_d,_nist_p_224[0],BN_NIST_224_TOP);
+       mask &= 0-(PTR_SIZE_INT)carry;
+       res   = (BN_ULONG *)(((PTR_SIZE_INT)c_d&~mask) |
+        ((PTR_SIZE_INT)r_d&mask));
        nist_cp_bn(r_d, res, BN_NIST_224_TOP);
        r->top = BN_NIST_224_TOP;
        bn_correct_top(r);
@@ -549,8 +552,8 @@ int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
                 buf[BN_NIST_256_TOP],
                 c_d[BN_NIST_256_TOP],
                *res;
-       size_t   mask;
-       union { bn_addsub_f f; size_t p; } u;
+       PTR_SIZE_INT mask;
+       union { bn_addsub_f f; PTR_SIZE_INT p; } u;
        static const BIGNUM _bignum_nist_p_256_sqr = {
                (BN_ULONG *)_nist_p_256_sqr,
                sizeof(_nist_p_256_sqr)/sizeof(_nist_p_256_sqr[0]),
@@ -587,7 +590,7 @@ int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
        nist_set_256(t_d, buf, 15, 14, 13, 12, 11, 0, 0, 0);
        /*S2*/
        nist_set_256(c_d, buf, 0, 15, 14, 13, 12, 0, 0, 0);
-       carry = bn_add_words(t_d, t_d, c_d, BN_NIST_256_TOP);
+       carry = (int)bn_add_words(t_d, t_d, c_d, BN_NIST_256_TOP);
        /* left shift */
                {
                register BN_ULONG *ap,t,c;
@@ -602,42 +605,44 @@ int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
                carry <<= 1;
                carry  |= c;
                }
-       carry += bn_add_words(r_d, r_d, t_d, BN_NIST_256_TOP);
+       carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_256_TOP);
        /*S3*/
        nist_set_256(t_d, buf, 15, 14, 0, 0, 0, 10, 9, 8);
-       carry += bn_add_words(r_d, r_d, t_d, BN_NIST_256_TOP);
+       carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_256_TOP);
        /*S4*/
        nist_set_256(t_d, buf, 8, 13, 15, 14, 13, 11, 10, 9);
-       carry += bn_add_words(r_d, r_d, t_d, BN_NIST_256_TOP);
+       carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_256_TOP);
        /*D1*/
        nist_set_256(t_d, buf, 10, 8, 0, 0, 0, 13, 12, 11);
-       carry -= bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP);
+       carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP);
        /*D2*/
        nist_set_256(t_d, buf, 11, 9, 0, 0, 15, 14, 13, 12);
-       carry -= bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP);
+       carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP);
        /*D3*/
        nist_set_256(t_d, buf, 12, 0, 10, 9, 8, 15, 14, 13);
-       carry -= bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP);
+       carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP);
        /*D4*/
        nist_set_256(t_d, buf, 13, 0, 11, 10, 9, 0, 15, 14);
-       carry -= bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP);
+       carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP);
 
        /* see BN_nist_mod_224 for explanation */
        u.f = bn_sub_words;
        if (carry > 0)
-               carry = bn_sub_words(r_d,r_d,_nist_p_256[carry-1],BN_NIST_256_TOP);
+               carry = (int)bn_sub_words(r_d,r_d,_nist_p_256[carry-1],BN_NIST_256_TOP);
        else if (carry < 0)
                {
-               carry = bn_add_words(r_d,r_d,_nist_p_256[-carry-1],BN_NIST_256_TOP);
-               mask = 0-(size_t)carry;
-               u.p = ((size_t)bn_sub_words&mask) | ((size_t)bn_add_words&~mask);
+               carry = (int)bn_add_words(r_d,r_d,_nist_p_256[-carry-1],BN_NIST_256_TOP);
+               mask = 0-(PTR_SIZE_INT)carry;
+               u.p = ((PTR_SIZE_INT)bn_sub_words&mask) |
+                ((PTR_SIZE_INT)bn_add_words&~mask);
                }
        else
                carry = 1;
 
-       mask  = 0-(size_t)(*u.f)(c_d,r_d,_nist_p_256[0],BN_NIST_256_TOP);
-       mask &= 0-(size_t)carry;
-       res   = (BN_ULONG *)(((size_t)c_d&~mask) | ((size_t)r_d&mask));
+       mask  = 0-(PTR_SIZE_INT)(*u.f)(c_d,r_d,_nist_p_256[0],BN_NIST_256_TOP);
+       mask &= 0-(PTR_SIZE_INT)carry;
+       res   = (BN_ULONG *)(((PTR_SIZE_INT)c_d&~mask) |
+        ((PTR_SIZE_INT)r_d&mask));
        nist_cp_bn(r_d, res, BN_NIST_256_TOP);
        r->top = BN_NIST_256_TOP;
        bn_correct_top(r);
@@ -671,8 +676,8 @@ int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
                 buf[BN_NIST_384_TOP],
                 c_d[BN_NIST_384_TOP],
                *res;
-       size_t   mask;
-       union { bn_addsub_f f; size_t p; } u;
+       PTR_SIZE_INT mask;
+       union { bn_addsub_f f; PTR_SIZE_INT p; } u;
        static const BIGNUM _bignum_nist_p_384_sqr = {
                (BN_ULONG *)_nist_p_384_sqr,
                sizeof(_nist_p_384_sqr)/sizeof(_nist_p_384_sqr[0]),
@@ -721,48 +726,50 @@ int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
                        }
                *ap=c;
                }
-       carry = bn_add_words(r_d+(128/BN_BITS2), r_d+(128/BN_BITS2), 
+       carry = (int)bn_add_words(r_d+(128/BN_BITS2), r_d+(128/BN_BITS2), 
                t_d, BN_NIST_256_TOP);
        /*S2 */
-       carry += bn_add_words(r_d, r_d, buf, BN_NIST_384_TOP);
+       carry += (int)bn_add_words(r_d, r_d, buf, BN_NIST_384_TOP);
        /*S3*/
        nist_set_384(t_d,buf,20,19,18,17,16,15,14,13,12,23,22,21);
-       carry += bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP);
+       carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP);
        /*S4*/
        nist_set_384(t_d,buf,19,18,17,16,15,14,13,12,20,0,23,0);
-       carry += bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP);
+       carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP);
        /*S5*/
        nist_set_384(t_d, buf,0,0,0,0,23,22,21,20,0,0,0,0);
-       carry += bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP);
+       carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP);
        /*S6*/
        nist_set_384(t_d,buf,0,0,0,0,0,0,23,22,21,0,0,20);
-       carry += bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP);
+       carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP);
        /*D1*/
        nist_set_384(t_d,buf,22,21,20,19,18,17,16,15,14,13,12,23);
-       carry -= bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP);
+       carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP);
        /*D2*/
        nist_set_384(t_d,buf,0,0,0,0,0,0,0,23,22,21,20,0);
-       carry -= bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP);
+       carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP);
        /*D3*/
        nist_set_384(t_d,buf,0,0,0,0,0,0,0,23,23,0,0,0);
-       carry -= bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP);
+       carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP);
 
        /* see BN_nist_mod_224 for explanation */
        u.f = bn_sub_words;
        if (carry > 0)
-               carry = bn_sub_words(r_d,r_d,_nist_p_384[carry-1],BN_NIST_384_TOP);
+               carry = (int)bn_sub_words(r_d,r_d,_nist_p_384[carry-1],BN_NIST_384_TOP);
        else if (carry < 0)
                {
-               carry = bn_add_words(r_d,r_d,_nist_p_384[-carry-1],BN_NIST_384_TOP);
-               mask = 0-(size_t)carry;
-               u.p = ((size_t)bn_sub_words&mask) | ((size_t)bn_add_words&~mask);
+               carry = (int)bn_add_words(r_d,r_d,_nist_p_384[-carry-1],BN_NIST_384_TOP);
+               mask = 0-(PTR_SIZE_INT)carry;
+               u.p = ((PTR_SIZE_INT)bn_sub_words&mask) |
+                ((PTR_SIZE_INT)bn_add_words&~mask);
                }
        else
                carry = 1;
 
-       mask  = 0-(size_t)(*u.f)(c_d,r_d,_nist_p_384[0],BN_NIST_384_TOP);
-       mask &= 0-(size_t)carry;
-       res   = (BN_ULONG *)(((size_t)c_d&~mask) | ((size_t)r_d&mask));
+       mask  = 0-(PTR_SIZE_INT)(*u.f)(c_d,r_d,_nist_p_384[0],BN_NIST_384_TOP);
+       mask &= 0-(PTR_SIZE_INT)carry;
+       res   = (BN_ULONG *)(((PTR_SIZE_INT)c_d&~mask) |
+        ((PTR_SIZE_INT)r_d&mask));
        nist_cp_bn(r_d, res, BN_NIST_384_TOP);
        r->top = BN_NIST_384_TOP;
        bn_correct_top(r);
@@ -781,7 +788,7 @@ int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
        BN_ULONG *r_d, *a_d = a->d,
                 t_d[BN_NIST_521_TOP],
                 val,tmp,*res;
-       size_t  mask;
+       PTR_SIZE_INT mask;
        static const BIGNUM _bignum_nist_p_521_sqr = {
                (BN_ULONG *)_nist_p_521_sqr,
                sizeof(_nist_p_521_sqr)/sizeof(_nist_p_521_sqr[0]),
@@ -826,8 +833,9 @@ int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
        r_d[i] &= BN_NIST_521_TOP_MASK;
 
        bn_add_words(r_d,r_d,t_d,BN_NIST_521_TOP);
-       mask = 0-(size_t)bn_sub_words(t_d,r_d,_nist_p_521,BN_NIST_521_TOP);
-       res  = (BN_ULONG *)(((size_t)t_d&~mask) | ((size_t)r_d&mask));
+       mask = 0-(PTR_SIZE_INT)bn_sub_words(t_d,r_d,_nist_p_521,BN_NIST_521_TOP);
+       res  = (BN_ULONG *)(((PTR_SIZE_INT)t_d&~mask) |
+        ((PTR_SIZE_INT)r_d&mask));
        nist_cp_bn(r_d,res,BN_NIST_521_TOP);
        r->top = BN_NIST_521_TOP;
        bn_correct_top(r);