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

openssl/ssl/s23_srvr.c

 /* ssl/s23_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 38 matching lines @@
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
  * The licence and distribution terms for any publically available version or
  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
 /* ====================================================================
- * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 1998-2006 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:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer. 
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ skipping 39 matching lines @@
  *
  */
 
 #include <stdio.h>
 #include "ssl_locl.h"
 #include <openssl/buffer.h>
 #include <openssl/rand.h>
 #include <openssl/objects.h>
 #include <openssl/evp.h>
 
-static SSL_METHOD *ssl23_get_server_method(int ver);
+static const SSL_METHOD *ssl23_get_server_method(int ver);
 int ssl23_get_client_hello(SSL *s);
-static SSL_METHOD *ssl23_get_server_method(int ver)
+static const SSL_METHOD *ssl23_get_server_method(int ver)
         {
 #ifndef OPENSSL_NO_SSL2
         if (ver == SSL2_VERSION)
                 return(SSLv2_server_method());
 #endif
         if (ver == SSL3_VERSION)
                 return(SSLv3_server_method());
         else if (ver == TLS1_VERSION)
                 return(TLSv1_server_method());
         else
@@ skipping 254 matching lines @@
                         SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTP_REQUEST);
                         goto err;
                         }
                 else if (strncmp("CONNECT",(char *)p,7) == 0)
                         {
                         SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTPS_PROXY_REQUEST);
                         goto err;
                         }
                 }
 
-#ifdef OPENSSL_FIPS
-        if (FIPS_mode() && (s->version < TLS1_VERSION))
-                {
-                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,
-                                        SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
-                goto err;
-                }
-#endif
-
         if (s->state == SSL23_ST_SR_CLNT_HELLO_B)
                 {
                 /* we have SSLv3/TLSv1 in an SSLv2 header
                  * (other cases skip this state) */
 
                 type=2;
                 p=s->packet;
                 v[0] = p[3]; /* == SSL3_VERSION_MAJOR */
                 v[1] = p[4];
 
+/* The SSL2 protocol allows n to be larger, just pick
+ * a reasonable buffer size. */
+#if SSL3_RT_DEFAULT_PACKET_SIZE < 1024*4 - SSL3_RT_DEFAULT_WRITE_OVERHEAD
+#error "SSL3_RT_DEFAULT_PACKET_SIZE is too small."
+#endif
                 n=((p[0]&0x7f)<<8)|p[1];
-                if (n > (1024*4))
+                if (n > SSL3_RT_DEFAULT_PACKET_SIZE - 2)
                         {
                         SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_LARGE);
                         goto err;
                         }
 
                 j=ssl23_read_bytes(s,n+2);
                 if (j <= 0) return(j);
 
                 ssl3_finish_mac(s, s->packet+2, s->packet_length-2);
                 if (s->msg_callback)
                         s->msg_callback(0, SSL2_VERSION, 0, s->packet+2, s->packet_length-2, s, s->msg_callback_arg); /* CLIENT-HELLO */
 
                 p=s->packet;
                 p+=5;
                 n2s(p,csl);
                 n2s(p,sil);
                 n2s(p,cl);
                 d=(unsigned char *)s->init_buf->data;
-                if ((csl+sil+cl+11) != s->packet_length)
+                if ((csl+sil+cl+11) != s->packet_length) /* We can't have TLS extensions in SSL 2.0 format
+                                                          * Client Hello, can we? Error condition should be
+                                                          * '>' otherweise */
                         {
                         SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_LENGTH_MISMATCH);
                         goto err;
                         }
 
                 /* record header: msg_type ... */
                 *(d++) = SSL3_MT_CLIENT_HELLO;
                 /* ... and length (actual value will be written later) */
                 d_len = d;
                 d += 3;
@@ skipping 22 matching lines @@
                         *(d++)=p[i+1];
                         *(d++)=p[i+2];
                         j+=2;
                         }
                 s2n(j,dd);
 
                 /* COMPRESSION */
                 *(d++)=1;
                 *(d++)=0;
                 
+#if 0
+                /* copy any remaining data with may be extensions */
+                p = p+csl+sil+cl;
+                while (p <  s->packet+s->packet_length)
+                        {
+                        *(d++)=*(p++);
+                        }
+#endif
+
                 i = (d-(unsigned char *)s->init_buf->data) - 4;
                 l2n3((long)i, d_len);
 
                 /* get the data reused from the init_buf */
                 s->s3->tmp.reuse_message=1;
                 s->s3->tmp.message_type=SSL3_MT_CLIENT_HELLO;
                 s->s3->tmp.message_size=i;
                 }
 
         /* imaginary new state (for program structure): */
@@ skipping 55 matching lines @@
 
                 /* we are in this state */
                 s->state=SSL3_ST_SR_CLNT_HELLO_A;
 
                 if (type == 3)
                         {
                         /* put the 'n' bytes we have read into the input buffer
                          * for SSLv3 */
                         s->rstate=SSL_ST_READ_HEADER;
                         s->packet_length=n;
+                        if (s->s3->rbuf.buf == NULL)
+                                if (!ssl3_setup_read_buffer(s))
+                                        goto err;
+
                         s->packet= &(s->s3->rbuf.buf[0]);
                         memcpy(s->packet,buf,n);
                         s->s3->rbuf.left=n;
                         s->s3->rbuf.offset=0;
                         }
                 else
                         {
                         s->packet_length=0;
                         s->s3->rbuf.left=0;
                         s->s3->rbuf.offset=0;
@@ skipping 16 matching lines @@
                 goto err;
                 }
         s->init_num=0;
 
         if (buf != buf_space) OPENSSL_free(buf);
         return(SSL_accept(s));
 err:
         if (buf != buf_space) OPENSSL_free(buf);
         return(-1);
         }