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

openssl/crypto/ec/ec_mult.c

 /* crypto/ec/ec_mult.c */
 /*
  * Originally written by Bodo Moeller and Nils Larsch for the OpenSSL project.
  */
 /* ====================================================================
  * Copyright (c) 1998-2007 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 151 matching lines @@
 
         i = CRYPTO_add(&pre->references, -1, CRYPTO_LOCK_EC_PRE_COMP);
         if (i > 0)
                 return;
 
         if (pre->points)
                 {
                 EC_POINT **p;
 
                 for (p = pre->points; *p != NULL; p++)
+                        {
                         EC_POINT_clear_free(*p);
-                OPENSSL_cleanse(pre->points, sizeof pre->points);
+                        OPENSSL_cleanse(p, sizeof *p);
+                        }
                 OPENSSL_free(pre->points);
                 }
-        OPENSSL_cleanse(pre, sizeof pre);
+        OPENSSL_cleanse(pre, sizeof *pre);
         OPENSSL_free(pre);
         }
 
 
 
 
 /* Determine the modified width-(w+1) Non-Adjacent Form (wNAF) of 'scalar'.
  * This is an array  r[]  of values that are either zero or odd with an
  * absolute value less than  2^w  satisfying
  *     scalar = \sum_j r[j]*2^j
@@ skipping 30 matching lines @@
                 }
         bit = 1 << w; /* at most 128 */
         next_bit = bit << 1; /* at most 256 */
         mask = next_bit - 1; /* at most 255 */
 
         if (BN_is_negative(scalar))
                 {
                 sign = -1;
                 }
 
+        if (scalar->d == NULL || scalar->top == 0)
+                {
+                ECerr(EC_F_COMPUTE_WNAF, ERR_R_INTERNAL_ERROR);
+                goto err;
+                }
+
         len = BN_num_bits(scalar);
         r = OPENSSL_malloc(len + 1); /* modified wNAF may be one digit longer than binary representation
                                       * (*ret_len will be set to the actual length, i.e. at most
                                       * BN_num_bits(scalar) + 1) */
         if (r == NULL)
                 {
                 ECerr(EC_F_COMPUTE_WNAF, ERR_R_MALLOC_FAILURE);
                 goto err;
                 }
-
-        if (scalar->d == NULL || scalar->top == 0)
-                {
-                ECerr(EC_F_COMPUTE_WNAF, ERR_R_INTERNAL_ERROR);
-                goto err;
-                }
         window_val = scalar->d[0] & mask;
         j = 0;
         while ((window_val != 0) || (j + w + 1 < len)) /* if j+w+1 >= len, window_val will not increase */
                 {
                 int digit = 0;
 
                 /* 0 <= window_val <= 2^(w+1) */
 
                 if (window_val & 1)
                         {
@@ skipping 160 matching lines @@
                         blocksize = pre_comp->blocksize;
 
                         /* determine maximum number of blocks that wNAF splitting may yield
                          * (NB: maximum wNAF length is bit length plus one) */
                         numblocks = (BN_num_bits(scalar) / blocksize) + 1;
 
                         /* we cannot use more blocks than we have precomputation for */
                         if (numblocks > pre_comp->numblocks)
                                 numblocks = pre_comp->numblocks;
 
-                        pre_points_per_block = 1u << (pre_comp->w - 1);
+                        pre_points_per_block = (size_t)1 << (pre_comp->w - 1);
 
                         /* check that pre_comp looks sane */
                         if (pre_comp->num != (pre_comp->numblocks * pre_points_per_block))
                                 {
                                 ECerr(EC_F_EC_WNAF_MUL, ERR_R_INTERNAL_ERROR);
                                 goto err;
                                 }
                         }
                 else
                         {
@@ skipping 21 matching lines @@
 
         /* num_val will be the total number of temporarily precomputed points */
         num_val = 0;
 
         for (i = 0; i < num + num_scalar; i++)
                 {
                 size_t bits;
 
                 bits = i < num ? BN_num_bits(scalars[i]) : BN_num_bits(scalar);
                 wsize[i] = EC_window_bits_for_scalar_size(bits);
-                num_val += 1u << (wsize[i] - 1);
+                num_val += (size_t)1 << (wsize[i] - 1);
                 wNAF[i + 1] = NULL; /* make sure we always have a pivot */
                 wNAF[i] = compute_wNAF((i < num ? scalars[i] : scalar), wsize[i], &wNAF_len[i]);
                 if (wNAF[i] == NULL)
                         goto err;
                 if (wNAF_len[i] > max_len)
                         max_len = wNAF_len[i];
                 }
 
         if (numblocks)
                 {
@@ skipping 118 matching lines @@
                 ECerr(EC_F_EC_WNAF_MUL, ERR_R_MALLOC_FAILURE);
                 goto err;
                 }
         val[num_val] = NULL; /* pivot element */
 
         /* allocate points for precomputation */
         v = val;
         for (i = 0; i < num + num_scalar; i++)
                 {
                 val_sub[i] = v;
-                for (j = 0; j < (1u << (wsize[i] - 1)); j++)
+                for (j = 0; j < ((size_t)1 << (wsize[i] - 1)); j++)
                         {
                         *v = EC_POINT_new(group);
                         if (*v == NULL) goto err;
                         v++;
                         }
                 }
         if (!(v == val + num_val))
                 {
                 ECerr(EC_F_EC_WNAF_MUL, ERR_R_INTERNAL_ERROR);
                 goto err;
@@ skipping 15 matching lines @@
                         if (!EC_POINT_copy(val_sub[i][0], points[i])) goto err;
                         }
                 else
                         {
                         if (!EC_POINT_copy(val_sub[i][0], generator)) goto err;
                         }
 
                 if (wsize[i] > 1)
                         {
                         if (!EC_POINT_dbl(group, tmp, val_sub[i][0], ctx)) goto err;
-                        for (j = 1; j < (1u << (wsize[i] - 1)); j++)
+                        for (j = 1; j < ((size_t)1 << (wsize[i] - 1)); j++)
                                 {
                                 if (!EC_POINT_add(group, val_sub[i][j], val_sub[i][j - 1], tmp, ctx)) goto err;
                                 }
                         }
                 }
 
 #if 1 /* optional; EC_window_bits_for_scalar_size assumes we do this step */
         if (!EC_POINTs_make_affine(group, num_val, val, ctx))
                 goto err;
 #endif
@@ skipping 163 matching lines @@
         blocksize = 8;
         w = 4;
         if (EC_window_bits_for_scalar_size(bits) > w)
                 {
                 /* let's not make the window too small ... */
                 w = EC_window_bits_for_scalar_size(bits);
                 }
 
         numblocks = (bits + blocksize - 1) / blocksize; /* max. number of blocks to use for wNAF splitting */
         
-        pre_points_per_block = 1u << (w - 1);
+        pre_points_per_block = (size_t)1 << (w - 1);
         num = pre_points_per_block * numblocks; /* number of points to compute and store */
 
         points = OPENSSL_malloc(sizeof (EC_POINT*)*(num + 1));
         if (!points)
                 {
                 ECerr(EC_F_EC_WNAF_PRECOMPUTE_MULT, ERR_R_MALLOC_FAILURE);
                 goto err;
                 }
 
         var = points;
@@ skipping 95 matching lines @@
         }
 
 
 int ec_wNAF_have_precompute_mult(const EC_GROUP *group)
         {
         if (EC_EX_DATA_get_data(group->extra_data, ec_pre_comp_dup, ec_pre_comp_free, ec_pre_comp_clear_free) != NULL)
                 return 1;
         else
                 return 0;
         }