Upgrade chrome's OpenSSL to same version Android ships with.

openssl/crypto/bn/bn_nist.c

 /* crypto/bn/bn_nist.c */
 /*
  * Written by Nils Larsch for the OpenSSL project
  */
 /* ====================================================================
  * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 336 matching lines @@
 int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
         BN_CTX *ctx)
         {
         int      top = a->top, i;
         int      carry;
         register BN_ULONG *r_d, *a_d = a->d;
         BN_ULONG t_d[BN_NIST_192_TOP],
                  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]),
                 sizeof(_nist_p_192_sqr)/sizeof(_nist_p_192_sqr[0]),
                 0,BN_FLG_STATIC_DATA };
 
         field = &_bignum_nist_p_192; /* just to make sure */
 
         if (BN_is_negative(a) || BN_ucmp(a,&_bignum_nist_p_192_sqr)>=0)
                 return BN_nnmod(r, a, field, ctx);
@@ skipping 30 matching lines @@
                 carry = (int)bn_sub_words(r_d,r_d,_nist_p_192[carry-1],BN_NIST_192_TOP);
         else
                 carry = 1;
 
         /*
          * we need 'if (carry==0 || result>=modulus) result-=modulus;'
          * as comparison implies subtraction, we can write
          * '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);
 
         return 1;
         }
 
 typedef BN_ULONG (*bn_addsub_f)(BN_ULONG *,const BN_ULONG *,const BN_ULONG *,int);
 
 #define nist_set_224(to, from, a1, a2, a3, a4, a5, a6, a7) \
@@ skipping 10 matching lines @@
 int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
         BN_CTX *ctx)
         {
         int     top = a->top, i;
         int     carry;
         BN_ULONG *r_d, *a_d = a->d;
         BN_ULONG t_d[BN_NIST_224_TOP],
                  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]),
                 sizeof(_nist_p_224_sqr)/sizeof(_nist_p_224_sqr[0]),
                 0,BN_FLG_STATIC_DATA };
 
 
         field = &_bignum_nist_p_224; /* just to make sure */
 
         if (BN_is_negative(a) || BN_ucmp(a,&_bignum_nist_p_224_sqr)>=0)
@@ skipping 50 matching lines @@
                 }
         else if (carry < 0)
                 {
                 /* it's a bit more comlicated logic in this case.
                  * if bn_add_words yields no carry, then result
                  * has to be adjusted by unconditionally *adding*
                  * the modulus. but if it does, then result has
                  * to be compared to the modulus and conditionally
                  * adjusted by *subtracting* the latter. */
                 carry = (int)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);
+                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);
 
         return 1;
         }
 
 #define nist_set_256(to, from, a1, a2, a3, a4, a5, a6, a7, a8) \
         { \
         bn_cp_32(to, 0, from, (a8) - 8) \
         bn_cp_32(to, 1, from, (a7) - 8) \
         bn_cp_32(to, 2, from, (a6) - 8) \
         bn_cp_32(to, 3, from, (a5) - 8) \
         bn_cp_32(to, 4, from, (a4) - 8) \
         bn_cp_32(to, 5, from, (a3) - 8) \
         bn_cp_32(to, 6, from, (a2) - 8) \
         bn_cp_32(to, 7, from, (a1) - 8) \
         }
 
 int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
         BN_CTX *ctx)
         {
         int     i, top = a->top;
         int     carry = 0;
         register BN_ULONG *a_d = a->d, *r_d;
         BN_ULONG t_d[BN_NIST_256_TOP],
                  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]),
                 sizeof(_nist_p_256_sqr)/sizeof(_nist_p_256_sqr[0]),
                 0,BN_FLG_STATIC_DATA };
 
         field = &_bignum_nist_p_256; /* just to make sure */
 
         if (BN_is_negative(a) || BN_ucmp(a,&_bignum_nist_p_256_sqr)>=0)
                 return BN_nnmod(r, a, field, ctx);
@@ skipping 58 matching lines @@
         nist_set_256(t_d, buf, 13, 0, 11, 10, 9, 0, 15, 14);
         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 = (int)bn_sub_words(r_d,r_d,_nist_p_256[carry-1],BN_NIST_256_TOP);
         else if (carry < 0)
                 {
                 carry = (int)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);
+                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);
 
         return 1;
         }
 
 #define nist_set_384(to,from,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) \
         { \
         bn_cp_32(to, 0, from,  (a12) - 12) \
@@ skipping 13 matching lines @@
 int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
         BN_CTX *ctx)
         {
         int     i, top = a->top;
         int     carry = 0;
         register BN_ULONG *r_d, *a_d = a->d;
         BN_ULONG t_d[BN_NIST_384_TOP],
                  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]),
                 sizeof(_nist_p_384_sqr)/sizeof(_nist_p_384_sqr[0]),
                 0,BN_FLG_STATIC_DATA };
 
 
         field = &_bignum_nist_p_384; /* just to make sure */
 
         if (BN_is_negative(a) || BN_ucmp(a,&_bignum_nist_p_384_sqr)>=0)
@@ skipping 61 matching lines @@
         nist_set_384(t_d,buf,0,0,0,0,0,0,0,23,23,0,0,0);
         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 = (int)bn_sub_words(r_d,r_d,_nist_p_384[carry-1],BN_NIST_384_TOP);
         else if (carry < 0)
                 {
                 carry = (int)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);
+                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);
 
         return 1;
         }
 
 #define BN_NIST_521_RSHIFT      (521%BN_BITS2)
 #define BN_NIST_521_LSHIFT      (BN_BITS2-BN_NIST_521_RSHIFT)
 #define BN_NIST_521_TOP_MASK    ((BN_ULONG)BN_MASK2>>BN_NIST_521_LSHIFT)
 
 int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
         BN_CTX *ctx)
         {
         int     top = a->top, i;
         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]),
                 sizeof(_nist_p_521_sqr)/sizeof(_nist_p_521_sqr[0]),
                 0,BN_FLG_STATIC_DATA };
 
         field = &_bignum_nist_p_521; /* just to make sure */
 
         if (BN_is_negative(a) || BN_ucmp(a,&_bignum_nist_p_521_sqr)>=0)
                 return BN_nnmod(r, a, field, ctx);
@@ skipping 24 matching lines @@
                 {
                 tmp = val>>BN_NIST_521_RSHIFT;
                 val = t_d[i+1];
                 t_d[i] = (tmp | val<<BN_NIST_521_LSHIFT) & BN_MASK2;
                 }
         t_d[i] = val>>BN_NIST_521_RSHIFT;
         /* lower 521 bits */
         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);
 
         return 1;
         }