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

openssl/crypto/ecdsa/ecdsatest.c

 /* crypto/ecdsa/ecdsatest.c */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
 /* ====================================================================
  * Copyright (c) 2000-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 150 matching lines @@
                 return 0;
         tmp = BN_new();
         if (!tmp)
                 return 0;
         if (!BN_dec2bn(&tmp, numbers[fbytes_counter]))
                 {
                 BN_free(tmp);
                 return 0;
                 }
         fbytes_counter ++;
-        ret = BN_bn2bin(tmp, buf);      
-        if (ret == 0 || ret != num)
+        if (num != BN_num_bytes(tmp) || !BN_bn2bin(tmp, buf))
                 ret = 0;
-        else
+        else 
                 ret = 1;
         if (tmp)
                 BN_free(tmp);
         return ret;
         }
 
 /* some tests from the X9.62 draft */
 int x9_62_test_internal(BIO *out, int nid, const char *r_in, const char *s_in)
         {
         int     ret = 0;
@@ skipping 95 matching lines @@
                 ret = 0;
         return ret;
         }
 
 int test_builtin(BIO *out)
         {
         EC_builtin_curve *curves = NULL;
         size_t          crv_len = 0, n = 0;
         EC_KEY          *eckey = NULL, *wrong_eckey = NULL;
         EC_GROUP        *group;
+        ECDSA_SIG       *ecdsa_sig = NULL;
         unsigned char   digest[20], wrong_digest[20];
-        unsigned char   *signature = NULL; 
-        unsigned int    sig_len;
+        unsigned char   *signature = NULL;
+        unsigned char   *sig_ptr;
+        unsigned char   *raw_buf = NULL;
+        unsigned int    sig_len, degree, r_len, s_len, bn_len, buf_len;
         int             nid, ret =  0;
         
         /* fill digest values with some random data */
         if (!RAND_pseudo_bytes(digest, 20) ||
             !RAND_pseudo_bytes(wrong_digest, 20))
                 {
                 BIO_printf(out, "ERROR: unable to get random data\n");
                 goto builtin_err;
                 }
 
@@ skipping 29 matching lines @@
                         continue;
                 /* create new ecdsa key (== EC_KEY) */
                 if ((eckey = EC_KEY_new()) == NULL)
                         goto builtin_err;
                 group = EC_GROUP_new_by_curve_name(nid);
                 if (group == NULL)
                         goto builtin_err;
                 if (EC_KEY_set_group(eckey, group) == 0)
                         goto builtin_err;
                 EC_GROUP_free(group);
-                if (EC_GROUP_get_degree(EC_KEY_get0_group(eckey)) < 160)
+                degree = EC_GROUP_get_degree(EC_KEY_get0_group(eckey));
+                if (degree < 160)
                         /* drop the curve */ 
                         {
                         EC_KEY_free(eckey);
                         eckey = NULL;
                         continue;
                         }
                 BIO_printf(out, "%s: ", OBJ_nid2sn(nid));
                 /* create key */
                 if (!EC_KEY_generate_key(eckey))
                         {
@@ skipping 55 matching lines @@
                 (void)BIO_flush(out);
                 /* wrong digest */
                 if (ECDSA_verify(0, wrong_digest, 20, signature, sig_len,
                         eckey) == 1)
                         {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
                         }
                 BIO_printf(out, ".");
                 (void)BIO_flush(out);
-                /* modify a single byte of the signature */
-                offset = signature[10] % sig_len;
-                dirt   = signature[11];
-                signature[offset] ^= dirt ? dirt : 1; 
+                /* wrong length */
+                if (ECDSA_verify(0, digest, 20, signature, sig_len - 1,
+                        eckey) == 1)
+                        {
+                        BIO_printf(out, " failed\n");
+                        goto builtin_err;
+                        }
+                BIO_printf(out, ".");
+                (void)BIO_flush(out);
+
+                /* Modify a single byte of the signature: to ensure we don't
+                 * garble the ASN1 structure, we read the raw signature and
+                 * modify a byte in one of the bignums directly. */
+                sig_ptr = signature;
+                if ((ecdsa_sig = d2i_ECDSA_SIG(NULL, &sig_ptr, sig_len)) == NULL)
+                        {
+                        BIO_printf(out, " failed\n");
+                        goto builtin_err;
+                        }
+
+                /* Store the two BIGNUMs in raw_buf. */
+                r_len = BN_num_bytes(ecdsa_sig->r);
+                s_len = BN_num_bytes(ecdsa_sig->s);
+                bn_len = (degree + 7) / 8;
+                if ((r_len > bn_len) || (s_len > bn_len))
+                        {
+                        BIO_printf(out, " failed\n");
+                        goto builtin_err;
+                        }
+                buf_len = 2 * bn_len;
+                if ((raw_buf = OPENSSL_malloc(buf_len)) == NULL)
+                        goto builtin_err;
+                /* Pad the bignums with leading zeroes. */
+                memset(raw_buf, 0, buf_len);
+                BN_bn2bin(ecdsa_sig->r, raw_buf + bn_len - r_len);
+                BN_bn2bin(ecdsa_sig->s, raw_buf + buf_len - s_len);
+
+                /* Modify a single byte in the buffer. */
+                offset = raw_buf[10] % buf_len;
+                dirt   = raw_buf[11] ? raw_buf[11] : 1;
+                raw_buf[offset] ^= dirt;
+                /* Now read the BIGNUMs back in from raw_buf. */
+                if ((BN_bin2bn(raw_buf, bn_len, ecdsa_sig->r) == NULL) ||
+                        (BN_bin2bn(raw_buf + bn_len, bn_len, ecdsa_sig->s) == NULL))
+                        goto builtin_err;
+
+                sig_ptr = signature;
+                sig_len = i2d_ECDSA_SIG(ecdsa_sig, &sig_ptr);
                 if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) == 1)
                         {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
                         }
+                /* Sanity check: undo the modification and verify signature. */
+                raw_buf[offset] ^= dirt;
+                if ((BN_bin2bn(raw_buf, bn_len, ecdsa_sig->r) == NULL) ||
+                        (BN_bin2bn(raw_buf + bn_len, bn_len, ecdsa_sig->s) == NULL))
+                        goto builtin_err;
+
+                sig_ptr = signature;
+                sig_len = i2d_ECDSA_SIG(ecdsa_sig, &sig_ptr);
+                if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) != 1)
+                        {
+                        BIO_printf(out, " failed\n");
+                        goto builtin_err;
+                        }
                 BIO_printf(out, ".");
                 (void)BIO_flush(out);
                 
                 BIO_printf(out, " ok\n");
                 /* cleanup */
+                /* clean bogus errors */
+                ERR_clear_error();
                 OPENSSL_free(signature);
                 signature = NULL;
                 EC_KEY_free(eckey);
                 eckey = NULL;
                 EC_KEY_free(wrong_eckey);
                 wrong_eckey = NULL;
+                ECDSA_SIG_free(ecdsa_sig);
+                ecdsa_sig = NULL;
+                OPENSSL_free(raw_buf);
+                raw_buf = NULL;
                 }
 
         ret = 1;        
 builtin_err:
         if (eckey)
                 EC_KEY_free(eckey);
         if (wrong_eckey)
                 EC_KEY_free(wrong_eckey);
+        if (ecdsa_sig)
+                ECDSA_SIG_free(ecdsa_sig);
         if (signature)
                 OPENSSL_free(signature);
+        if (raw_buf)
+                OPENSSL_free(raw_buf);
         if (curves)
                 OPENSSL_free(curves);
 
         return ret;
         }
 
 int main(void)
         {
         int     ret = 1;
         BIO     *out;
@@ skipping 25 matching lines @@
         
         ret = 0;
 err:    
         if (ret)        
                 BIO_printf(out, "\nECDSA test failed\n");
         else 
                 BIO_printf(out, "\nECDSA test passed\n");
         if (ret)
                 ERR_print_errors(out);
         CRYPTO_cleanup_all_ex_data();
-        ERR_remove_state(0);
+        ERR_remove_thread_state(NULL);
         ERR_free_strings();
         CRYPTO_mem_leaks(out);
         if (out != NULL)
                 BIO_free(out);
         return ret;
         }       
 #endif