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

openssl/crypto/evp/m_sha1.c

 /* crypto/evp/m_sha1.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
  * This package is an SSL implementation written
  * by Eric Young (eay@cryptsoft.com).
  * The implementation was written so as to conform with Netscapes SSL.
  * 
  * This library is free for commercial and non-commercial use as long as
  * the following conditions are aheared to.  The following conditions
@@ skipping 50 matching lines @@
 
 #ifndef OPENSSL_NO_SHA
 
 #include <openssl/evp.h>
 #include <openssl/objects.h>
 #include <openssl/x509.h>
 #ifndef OPENSSL_NO_RSA
 #include <openssl/rsa.h>
 #endif
 
-#ifndef OPENSSL_FIPS
-
 static int init(EVP_MD_CTX *ctx)
         { return SHA1_Init(ctx->md_data); }
 
 static int update(EVP_MD_CTX *ctx,const void *data,size_t count)
         { return SHA1_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
         { return SHA1_Final(md,ctx->md_data); }
 
 static const EVP_MD sha1_md=
         {
         NID_sha1,
         NID_sha1WithRSAEncryption,
         SHA_DIGEST_LENGTH,
-        0,
+        EVP_MD_FLAG_PKEY_METHOD_SIGNATURE|EVP_MD_FLAG_DIGALGID_ABSENT,
         init,
         update,
         final,
         NULL,
         NULL,
         EVP_PKEY_RSA_method,
         SHA_CBLOCK,
         sizeof(EVP_MD *)+sizeof(SHA_CTX),
         };
 
 const EVP_MD *EVP_sha1(void)
         {
         return(&sha1_md);
         }
+#endif
 
 #ifndef OPENSSL_NO_SHA256
 static int init224(EVP_MD_CTX *ctx)
         { return SHA224_Init(ctx->md_data); }
 static int init256(EVP_MD_CTX *ctx)
         { return SHA256_Init(ctx->md_data); }
 /*
  * Even though there're separate SHA224_[Update|Final], we call
  * SHA256 functions even in SHA224 context. This is what happens
  * there anyway, so we can spare few CPU cycles:-)
  */
 static int update256(EVP_MD_CTX *ctx,const void *data,size_t count)
         { return SHA256_Update(ctx->md_data,data,count); }
 static int final256(EVP_MD_CTX *ctx,unsigned char *md)
         { return SHA256_Final(md,ctx->md_data); }
 
 static const EVP_MD sha224_md=
         {
         NID_sha224,
         NID_sha224WithRSAEncryption,
         SHA224_DIGEST_LENGTH,
-        0,
+        EVP_MD_FLAG_PKEY_METHOD_SIGNATURE|EVP_MD_FLAG_DIGALGID_ABSENT,
         init224,
         update256,
         final256,
         NULL,
         NULL,
         EVP_PKEY_RSA_method,
         SHA256_CBLOCK,
         sizeof(EVP_MD *)+sizeof(SHA256_CTX),
         };
 
 const EVP_MD *EVP_sha224(void)
         { return(&sha224_md); }
 
 static const EVP_MD sha256_md=
         {
         NID_sha256,
         NID_sha256WithRSAEncryption,
         SHA256_DIGEST_LENGTH,
-        0,
+        EVP_MD_FLAG_PKEY_METHOD_SIGNATURE|EVP_MD_FLAG_DIGALGID_ABSENT,
         init256,
         update256,
         final256,
         NULL,
         NULL,
         EVP_PKEY_RSA_method,
         SHA256_CBLOCK,
         sizeof(EVP_MD *)+sizeof(SHA256_CTX),
         };
 
@@ skipping 10 matching lines @@
 static int update512(EVP_MD_CTX *ctx,const void *data,size_t count)
         { return SHA512_Update(ctx->md_data,data,count); }
 static int final512(EVP_MD_CTX *ctx,unsigned char *md)
         { return SHA512_Final(md,ctx->md_data); }
 
 static const EVP_MD sha384_md=
         {
         NID_sha384,
         NID_sha384WithRSAEncryption,
         SHA384_DIGEST_LENGTH,
-        0,
+        EVP_MD_FLAG_PKEY_METHOD_SIGNATURE|EVP_MD_FLAG_DIGALGID_ABSENT,
         init384,
         update512,
         final512,
         NULL,
         NULL,
         EVP_PKEY_RSA_method,
         SHA512_CBLOCK,
         sizeof(EVP_MD *)+sizeof(SHA512_CTX),
         };
 
 const EVP_MD *EVP_sha384(void)
         { return(&sha384_md); }
 
 static const EVP_MD sha512_md=
         {
         NID_sha512,
         NID_sha512WithRSAEncryption,
         SHA512_DIGEST_LENGTH,
-        0,
+        EVP_MD_FLAG_PKEY_METHOD_SIGNATURE|EVP_MD_FLAG_DIGALGID_ABSENT,
         init512,
         update512,
         final512,
         NULL,
         NULL,
         EVP_PKEY_RSA_method,
         SHA512_CBLOCK,
         sizeof(EVP_MD *)+sizeof(SHA512_CTX),
         };
 
 const EVP_MD *EVP_sha512(void)
         { return(&sha512_md); }
 #endif  /* ifndef OPENSSL_NO_SHA512 */
-
-#endif
-
-#endif