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

openssl/ssl/s2_srvr.c

 /* ssl/s2_srvr.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 99 matching lines @@
  */
 
 #include "ssl_locl.h"
 #ifndef OPENSSL_NO_SSL2
 #include <stdio.h>
 #include <openssl/bio.h>
 #include <openssl/rand.h>
 #include <openssl/objects.h>
 #include <openssl/evp.h>
 
-static SSL_METHOD *ssl2_get_server_method(int ver);
+static const SSL_METHOD *ssl2_get_server_method(int ver);
 static int get_client_master_key(SSL *s);
 static int get_client_hello(SSL *s);
 static int server_hello(SSL *s); 
 static int get_client_finished(SSL *s);
 static int server_verify(SSL *s);
 static int server_finish(SSL *s);
 static int request_certificate(SSL *s);
 static int ssl_rsa_private_decrypt(CERT *c, int len, unsigned char *from,
         unsigned char *to,int padding);
 #define BREAK   break
 
-static SSL_METHOD *ssl2_get_server_method(int ver)
+static const SSL_METHOD *ssl2_get_server_method(int ver)
         {
         if (ver == SSL2_VERSION)
                 return(SSLv2_server_method());
         else
                 return(NULL);
         }
 
 IMPLEMENT_ssl2_meth_func(SSLv2_server_method,
                         ssl2_accept,
                         ssl_undefined_function,
@@ skipping 216 matching lines @@
         if (cb != NULL)
                 cb(s,SSL_CB_ACCEPT_EXIT,ret);
         return(ret);
         }
 
 static int get_client_master_key(SSL *s)
         {
         int is_export,i,n,keya,ek;
         unsigned long len;
         unsigned char *p;
-        SSL_CIPHER *cp;
+        const SSL_CIPHER *cp;
         const EVP_CIPHER *c;
         const EVP_MD *md;
 
         p=(unsigned char *)s->init_buf->data;
         if (s->state == SSL2_ST_GET_CLIENT_MASTER_KEY_A)
                 {
                 i=ssl2_read(s,(char *)&(p[s->init_num]),10-s->init_num);
 
                 if (i < (10-s->init_num))
                         return(ssl2_part_read(s,SSL_F_GET_CLIENT_MASTER_KEY,i));
@@ skipping 16 matching lines @@
                         {
                         ssl2_return_error(s,SSL2_PE_NO_CIPHER);
                         SSLerr(SSL_F_GET_CLIENT_MASTER_KEY, SSL_R_NO_CIPHER_MATCH);
                         return(-1);
                         }
                 s->session->cipher= cp;
 
                 p+=3;
                 n2s(p,i); s->s2->tmp.clear=i;
                 n2s(p,i); s->s2->tmp.enc=i;
-                n2s(p,i); s->session->key_arg_length=i;
-                if(s->session->key_arg_length > SSL_MAX_KEY_ARG_LENGTH)
+                n2s(p,i);
+                if(i > SSL_MAX_KEY_ARG_LENGTH)
                         {
                         ssl2_return_error(s,SSL2_PE_UNDEFINED_ERROR);
                         SSLerr(SSL_F_GET_CLIENT_MASTER_KEY, SSL_R_KEY_ARG_TOO_LONG);
                         return -1;
                         }
+                s->session->key_arg_length=i;
                 s->state=SSL2_ST_GET_CLIENT_MASTER_KEY_B;
                 }
 
         /* SSL2_ST_GET_CLIENT_MASTER_KEY_B */
         p=(unsigned char *)s->init_buf->data;
         if (s->init_buf->length < SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)
                 {
                 ssl2_return_error(s,SSL2_PE_UNDEFINED_ERROR);
                 SSLerr(SSL_F_GET_CLIENT_MASTER_KEY, ERR_R_INTERNAL_ERROR);
                 return -1;
@@ skipping 21 matching lines @@
                 ssl2_return_error(s,SSL2_PE_UNDEFINED_ERROR);
                 SSLerr(SSL_F_GET_CLIENT_MASTER_KEY,SSL_R_NO_PRIVATEKEY);
                 return(-1);
                 }
         i=ssl_rsa_private_decrypt(s->cert,s->s2->tmp.enc,
                 &(p[s->s2->tmp.clear]),&(p[s->s2->tmp.clear]),
                 (s->s2->ssl2_rollback)?RSA_SSLV23_PADDING:RSA_PKCS1_PADDING);
 
         is_export=SSL_C_IS_EXPORT(s->session->cipher);
         
-        if (!ssl_cipher_get_evp(s->session,&c,&md,NULL))
+        if (!ssl_cipher_get_evp(s->session,&c,&md,NULL,NULL,NULL))
                 {
                 ssl2_return_error(s,SSL2_PE_NO_CIPHER);
                 SSLerr(SSL_F_GET_CLIENT_MASTER_KEY,SSL_R_PROBLEMS_MAPPING_CIPHER_FUNCTIONS);
                 return(0);
                 }
 
         if (s->session->cipher->algorithm2 & SSL2_CF_8_BYTE_ENC)
                 {
                 is_export=1;
                 ek=8;
@@ skipping 225 matching lines @@
         return(1);
 mem_err:
         SSLerr(SSL_F_GET_CLIENT_HELLO,ERR_R_MALLOC_FAILURE);
         return(0);
         }
 
 static int server_hello(SSL *s)
         {
         unsigned char *p,*d;
         int n,hit;
-        STACK_OF(SSL_CIPHER) *sk;
 
         p=(unsigned char *)s->init_buf->data;
         if (s->state == SSL2_ST_SEND_SERVER_HELLO_A)
                 {
                 d=p+11;
                 *(p++)=SSL2_MT_SERVER_HELLO;            /* type */
                 hit=s->hit;
                 *(p++)=(unsigned char)hit;
 #if 1
                 if (!hit)
@@ skipping 60 matching lines @@
                         /* put certificate type */
                         *(p++)=SSL2_CT_X509_CERTIFICATE;
                         s2n(s->version,p);      /* version */
                         n=i2d_X509(s->cert->pkeys[SSL_PKEY_RSA_ENC].x509,NULL);
                         s2n(n,p);               /* certificate length */
                         i2d_X509(s->cert->pkeys[SSL_PKEY_RSA_ENC].x509,&d);
                         n=0;
                         
                         /* lets send out the ciphers we like in the
                          * prefered order */
-                        sk= s->session->ciphers;
                         n=ssl_cipher_list_to_bytes(s,s->session->ciphers,d,0);
                         d+=n;
                         s2n(n,p);               /* add cipher length */
                         }
 
                 /* make and send conn_id */
                 s2n(SSL2_CONNECTION_ID_LENGTH,p);       /* add conn_id length */
                 s->s2->conn_id_length=SSL2_CONNECTION_ID_LENGTH;
                 if (RAND_pseudo_bytes(s->s2->conn_id,(int)s->s2->conn_id_length) <= 0)
                         return -1;
@@ skipping 342 matching lines @@
                 SSLerr(SSL_F_SSL_RSA_PRIVATE_DECRYPT,ERR_R_RSA_LIB);
         return(i);
         }
 #else /* !OPENSSL_NO_SSL2 */
 
 # if PEDANTIC
 static void *dummy=&dummy;
 # endif
 
 #endif