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

openssl/ssl/s2_pkt.c

 /* ssl/s2_pkt.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 98 matching lines @@
  *
  */
 
 #include "ssl_locl.h"
 #ifndef OPENSSL_NO_SSL2
 #include <stdio.h>
 #include <errno.h>
 #define USE_SOCKETS
 
 static int read_n(SSL *s,unsigned int n,unsigned int max,unsigned int extend);
-static int do_ssl_write(SSL *s, const unsigned char *buf, unsigned int len);
+static int n_do_ssl_write(SSL *s, const unsigned char *buf, unsigned int len);
 static int write_pending(SSL *s, const unsigned char *buf, unsigned int len);
 static int ssl_mt_error(int n);
 
 
 /* SSL 2.0 imlementation for SSL_read/SSL_peek -
  * This routine will return 0 to len bytes, decrypted etc if required.
  */
 static int ssl2_read_internal(SSL *s, void *buf, int len, int peek)
         {
         int n;
         unsigned char mac[MAX_MAC_SIZE];
         unsigned char *p;
         int i;
-        unsigned int mac_size;
+        int mac_size;
 
  ssl2_read_again:
         if (SSL_in_init(s) && !s->in_handshake)
                 {
                 n=s->handshake_func(s);
                 if (n < 0) return(n);
                 if (n == 0)
                         {
                         SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_SSL_HANDSHAKE_FAILURE);
                         return(-1);
@@ skipping 95 matching lines @@
                         s->s2->mac_data=p;
                         s->s2->ract_data=p;
                         if (s->s2->padding)
                                 {
                                 SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_ILLEGAL_PADDING);
                                 return(-1);
                                 }
                         }
                 else
                         {
-                        mac_size=EVP_MD_size(s->read_hash);
+                        mac_size=EVP_MD_CTX_size(s->read_hash);
+                        if (mac_size < 0)
+                                return -1;
                         OPENSSL_assert(mac_size <= MAX_MAC_SIZE);
                         s->s2->mac_data=p;
                         s->s2->ract_data= &p[mac_size];
                         if (s->s2->padding + mac_size > s->s2->rlength)
                                 {
                                 SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_ILLEGAL_PADDING);
                                 return(-1);
                                 }
                         }
 
                 s->s2->ract_data_length=s->s2->rlength;
                 /* added a check for length > max_size in case
                  * encryption was not turned on yet due to an error */
                 if ((!s->s2->clear_text) &&
-                        (s->s2->rlength >= mac_size))
+                        (s->s2->rlength >= (unsigned int)mac_size))
                         {
                         ssl2_enc(s,0);
                         s->s2->ract_data_length-=mac_size;
                         ssl2_mac(s,mac,0);
                         s->s2->ract_data_length-=s->s2->padding;
                         if (    (memcmp(mac,s->s2->mac_data,
                                 (unsigned int)mac_size) != 0) ||
                                 (s->s2->rlength%EVP_CIPHER_CTX_block_size(s->enc_read_ctx) != 0))
                                 {
                                 SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_BAD_MAC_DECODE);
@@ skipping 165 matching lines @@
         clear_sys_error();
         s->rwstate=SSL_NOTHING;
         if (len <= 0) return(len);
 
         tot=s->s2->wnum;
         s->s2->wnum=0;
 
         n=(len-tot);
         for (;;)
                 {
-                i=do_ssl_write(s,&(buf[tot]),n);
+                i=n_do_ssl_write(s,&(buf[tot]),n);
                 if (i <= 0)
                         {
                         s->s2->wnum=tot;
                         return(i);
                         }
                 if ((i == (int)n) ||
                         (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE))
                         {
                         return(tot+i);
                         }
@@ skipping 43 matching lines @@
                         s->rwstate=SSL_NOTHING;
                         return(s->s2->wpend_ret);
                         }
                 else if (i <= 0)
                         return(i);
                 s->s2->wpend_off+=i;
                 s->s2->wpend_len-=i;
                 }
         }
 
-static int do_ssl_write(SSL *s, const unsigned char *buf, unsigned int len)
+static int n_do_ssl_write(SSL *s, const unsigned char *buf, unsigned int len)
         {
-        unsigned int j,k,olen,p,mac_size,bs;
+        unsigned int j,k,olen,p,bs;
+        int mac_size;
         register unsigned char *pp;
 
         olen=len;
 
         /* first check if there is data from an encryption waiting to
          * be sent - it must be sent because the other end is waiting.
          * This will happen with non-blocking IO.  We print it and then
          * return.
          */
         if (s->s2->wpend_len != 0) return(write_pending(s,buf,len));
 
         /* set mac_size to mac size */
         if (s->s2->clear_text)
                 mac_size=0;
         else
-                mac_size=EVP_MD_size(s->write_hash);
+                {
+                mac_size=EVP_MD_CTX_size(s->write_hash);
+                if (mac_size < 0)
+                        return -1;
+                }
 
         /* lets set the pad p */
         if (s->s2->clear_text)
                 {
                 if (len > SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER)
                         len=SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER;
                 p=0;
                 s->s2->three_byte_header=0;
                 /* len=len; */
                 }
@@ skipping 185 matching lines @@
                 }
         return(ret);
         }
 #else /* !OPENSSL_NO_SSL2 */
 
 # if PEDANTIC
 static void *dummy=&dummy;
 # endif
 
 #endif