From 30f92658fa4e1357cfcee9c077a21e928970d290 Mon Sep 17 00:00:00 2001 From: jsing <> Date: Mon, 14 Apr 2014 15:15:33 +0000 Subject: First pass at applying KNF to the OpenSSL code, which almost makes it readable. This pass is whitespace only and can readily be verified using tr and md5. --- src/lib/libssl/s23_clnt.c | 620 ++++++++++++++++++-------------------- src/lib/libssl/s23_lib.c | 158 +++++----- src/lib/libssl/s23_pkt.c | 74 +++-- src/lib/libssl/s23_srvr.c | 564 ++++++++++++++++------------------ src/lib/libssl/src/ssl/s23_clnt.c | 620 ++++++++++++++++++-------------------- src/lib/libssl/src/ssl/s23_lib.c | 158 +++++----- src/lib/libssl/src/ssl/s23_meth.c | 23 +- src/lib/libssl/src/ssl/s23_pkt.c | 74 +++-- src/lib/libssl/src/ssl/s23_srvr.c | 564 ++++++++++++++++------------------ 9 files changed, 1339 insertions(+), 1516 deletions(-) diff --git a/src/lib/libssl/s23_clnt.c b/src/lib/libssl/s23_clnt.c index 6315e9d876..0fd388a05a 100644 --- a/src/lib/libssl/s23_clnt.c +++ b/src/lib/libssl/s23_clnt.c @@ -119,160 +119,163 @@ static const SSL_METHOD *ssl23_get_client_method(int ver); static int ssl23_client_hello(SSL *s); static int ssl23_get_server_hello(SSL *s); -static const SSL_METHOD *ssl23_get_client_method(int ver) - { +static const SSL_METHOD +*ssl23_get_client_method(int ver) +{ #ifndef OPENSSL_NO_SSL2 if (ver == SSL2_VERSION) - return(SSLv2_client_method()); + return (SSLv2_client_method()); #endif if (ver == SSL3_VERSION) - return(SSLv3_client_method()); + return (SSLv3_client_method()); else if (ver == TLS1_VERSION) - return(TLSv1_client_method()); + return (TLSv1_client_method()); else if (ver == TLS1_1_VERSION) - return(TLSv1_1_client_method()); + return (TLSv1_1_client_method()); else if (ver == TLS1_2_VERSION) - return(TLSv1_2_client_method()); + return (TLSv1_2_client_method()); else - return(NULL); - } + return (NULL); +} IMPLEMENT_ssl23_meth_func(SSLv23_client_method, - ssl_undefined_function, - ssl23_connect, - ssl23_get_client_method) - -int ssl23_connect(SSL *s) - { - BUF_MEM *buf=NULL; - unsigned long Time=(unsigned long)time(NULL); - void (*cb)(const SSL *ssl,int type,int val)=NULL; - int ret= -1; - int new_state,state; - - RAND_add(&Time,sizeof(Time),0); + ssl_undefined_function, ssl23_connect, ssl23_get_client_method) + +int +ssl23_connect(SSL *s) +{ + BUF_MEM *buf = NULL; + unsigned long Time = (unsigned long)time(NULL); + void (*cb)(const SSL *ssl, int type, int val) = NULL; + int ret = -1; + int new_state, state; + + RAND_add(&Time, sizeof(Time), 0); ERR_clear_error(); errno = 0; if (s->info_callback != NULL) - cb=s->info_callback; + cb = s->info_callback; else if (s->ctx->info_callback != NULL) - cb=s->ctx->info_callback; - + cb = s->ctx->info_callback; + s->in_handshake++; - if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); + if (!SSL_in_init(s) || SSL_in_before(s)) + SSL_clear(s); - for (;;) - { - state=s->state; + for (;;) { + state = s->state; - switch(s->state) - { + switch (s->state) { case SSL_ST_BEFORE: case SSL_ST_CONNECT: case SSL_ST_BEFORE|SSL_ST_CONNECT: case SSL_ST_OK|SSL_ST_CONNECT: - if (s->session != NULL) - { - SSLerr(SSL_F_SSL23_CONNECT,SSL_R_SSL23_DOING_SESSION_ID_REUSE); - ret= -1; + if (s->session != NULL) { + SSLerr(SSL_F_SSL23_CONNECT, SSL_R_SSL23_DOING_SESSION_ID_REUSE); + ret = -1; goto end; - } - s->server=0; - if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1); + } + s->server = 0; + if (cb != NULL) + cb(s, SSL_CB_HANDSHAKE_START, 1); /* s->version=TLS1_VERSION; */ - s->type=SSL_ST_CONNECT; + s->type = SSL_ST_CONNECT; - if (s->init_buf == NULL) - { - if ((buf=BUF_MEM_new()) == NULL) - { - ret= -1; + if (s->init_buf == NULL) { + if ((buf = BUF_MEM_new()) == NULL) { + ret = -1; goto end; - } - if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH)) - { - ret= -1; + } + if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) { + ret = -1; goto end; - } - s->init_buf=buf; - buf=NULL; } + s->init_buf = buf; + buf = NULL; + } - if (!ssl3_setup_buffers(s)) { ret= -1; goto end; } + if (!ssl3_setup_buffers(s)) { + ret = -1; + goto end; + } ssl3_init_finished_mac(s); - s->state=SSL23_ST_CW_CLNT_HELLO_A; + s->state = SSL23_ST_CW_CLNT_HELLO_A; s->ctx->stats.sess_connect++; - s->init_num=0; + s->init_num = 0; break; case SSL23_ST_CW_CLNT_HELLO_A: case SSL23_ST_CW_CLNT_HELLO_B: - s->shutdown=0; - ret=ssl23_client_hello(s); - if (ret <= 0) goto end; - s->state=SSL23_ST_CR_SRVR_HELLO_A; - s->init_num=0; + s->shutdown = 0; + ret = ssl23_client_hello(s); + if (ret <= 0) + goto end; + s->state = SSL23_ST_CR_SRVR_HELLO_A; + s->init_num = 0; break; case SSL23_ST_CR_SRVR_HELLO_A: case SSL23_ST_CR_SRVR_HELLO_B: - ret=ssl23_get_server_hello(s); - if (ret >= 0) cb=NULL; + ret = ssl23_get_server_hello(s); + if (ret >= 0) + cb = NULL; goto end; /* break; */ default: - SSLerr(SSL_F_SSL23_CONNECT,SSL_R_UNKNOWN_STATE); - ret= -1; + SSLerr(SSL_F_SSL23_CONNECT, SSL_R_UNKNOWN_STATE); + ret = -1; goto end; /* break; */ - } + } - if (s->debug) { (void)BIO_flush(s->wbio); } + if (s->debug) { + (void)BIO_flush(s->wbio); + } - if ((cb != NULL) && (s->state != state)) - { - new_state=s->state; - s->state=state; - cb(s,SSL_CB_CONNECT_LOOP,1); - s->state=new_state; - } + if ((cb != NULL) && (s->state != state)) { + new_state = s->state; + s->state = state; + cb(s, SSL_CB_CONNECT_LOOP, 1); + s->state = new_state; } + } end: s->in_handshake--; if (buf != NULL) BUF_MEM_free(buf); if (cb != NULL) - cb(s,SSL_CB_CONNECT_EXIT,ret); - return(ret); - } + cb(s, SSL_CB_CONNECT_EXIT, ret); + return (ret); +} -static int ssl23_no_ssl2_ciphers(SSL *s) - { +static int +ssl23_no_ssl2_ciphers(SSL *s) +{ SSL_CIPHER *cipher; STACK_OF(SSL_CIPHER) *ciphers; int i; ciphers = SSL_get_ciphers(s); - for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) - { + for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) { cipher = sk_SSL_CIPHER_value(ciphers, i); if (cipher->algorithm_ssl == SSL_SSLV2) return 0; - } - return 1; } + return 1; +} /* Fill a ClientRandom or ServerRandom field of length len. Returns <= 0 * on failure, 1 on success. */ -int ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len) - { +int +ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len) +{ int send_time = 0; if (len < 4) @@ -281,22 +284,21 @@ int ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len) send_time = (s->mode & SSL_MODE_SEND_SERVERHELLO_TIME) != 0; else send_time = (s->mode & SSL_MODE_SEND_CLIENTHELLO_TIME) != 0; - if (send_time) - { + if (send_time) { unsigned long Time = (unsigned long)time(NULL); unsigned char *p = result; l2n(Time, p); - return RAND_pseudo_bytes(p, len-4); - } - else + return RAND_pseudo_bytes(p, len - 4); + } else return RAND_pseudo_bytes(result, len); - } +} -static int ssl23_client_hello(SSL *s) - { +static int +ssl23_client_hello(SSL *s) +{ unsigned char *buf; - unsigned char *p,*d; - int i,ch_len; + unsigned char *p, *d; + int i, ch_len; unsigned long l; int ssl2_compat; int version = 0, version_major, version_minor; @@ -320,14 +322,14 @@ static int ssl23_client_hello(SSL *s) * TLS1>=1, it would be insufficient to pass SSL_NO_TLSv1, the * answer is SSL_OP_NO_TLSv1|SSL_OP_NO_SSLv3|SSL_OP_NO_SSLv2. */ - mask = SSL_OP_NO_TLSv1_1|SSL_OP_NO_TLSv1 + mask = SSL_OP_NO_TLSv1_1|SSL_OP_NO_TLSv1 #if !defined(OPENSSL_NO_SSL3) - |SSL_OP_NO_SSLv3 + |SSL_OP_NO_SSLv3 #endif #if !defined(OPENSSL_NO_SSL2) - |(ssl2_compat?SSL_OP_NO_SSLv2:0) + |(ssl2_compat ? SSL_OP_NO_SSLv2 : 0) #endif - ; + ; #if !defined(OPENSSL_NO_TLS1_2_CLIENT) version = TLS1_2_VERSION; @@ -351,8 +353,7 @@ static int ssl23_client_hello(SSL *s) #endif #ifndef OPENSSL_NO_TLSEXT - if (version != SSL2_VERSION) - { + if (version != SSL2_VERSION) { /* have to disable SSL 2.0 compatibility if we need TLS extensions */ if (s->tlsext_hostname != NULL) @@ -363,67 +364,53 @@ static int ssl23_client_hello(SSL *s) if (s->ctx->tlsext_opaque_prf_input_callback != 0 || s->tlsext_opaque_prf_input != NULL) ssl2_compat = 0; #endif - } + } #endif - buf=(unsigned char *)s->init_buf->data; - if (s->state == SSL23_ST_CW_CLNT_HELLO_A) - { + buf = (unsigned char *)s->init_buf->data; + if (s->state == SSL23_ST_CW_CLNT_HELLO_A) { #if 0 /* don't reuse session-id's */ - if (!ssl_get_new_session(s,0)) - { - return(-1); - } + if (!ssl_get_new_session(s, 0)) { + return (-1); + } #endif - p=s->s3->client_random; + p = s->s3->client_random; if (ssl_fill_hello_random(s, 0, p, SSL3_RANDOM_SIZE) <= 0) return -1; - if (version == TLS1_2_VERSION) - { + if (version == TLS1_2_VERSION) { version_major = TLS1_2_VERSION_MAJOR; version_minor = TLS1_2_VERSION_MINOR; - } - else if (version == TLS1_1_VERSION) - { + } else if (version == TLS1_1_VERSION) { version_major = TLS1_1_VERSION_MAJOR; version_minor = TLS1_1_VERSION_MINOR; - } - else if (version == TLS1_VERSION) - { + } else if (version == TLS1_VERSION) { version_major = TLS1_VERSION_MAJOR; version_minor = TLS1_VERSION_MINOR; - } + } #ifdef OPENSSL_FIPS - else if(FIPS_mode()) - { + else if (FIPS_mode()) { SSLerr(SSL_F_SSL23_CLIENT_HELLO, - SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE); + SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE); return -1; - } + } #endif - else if (version == SSL3_VERSION) - { + else if (version == SSL3_VERSION) { version_major = SSL3_VERSION_MAJOR; version_minor = SSL3_VERSION_MINOR; - } - else if (version == SSL2_VERSION) - { + } else if (version == SSL2_VERSION) { version_major = SSL2_VERSION_MAJOR; version_minor = SSL2_VERSION_MINOR; - } - else - { - SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_PROTOCOLS_AVAILABLE); - return(-1); - } + } else { + SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_NO_PROTOCOLS_AVAILABLE); + return (-1); + } s->client_version = version; - if (ssl2_compat) - { + if (ssl2_compat) { /* create SSL 2.0 compatible Client Hello */ /* two byte record header will be written last */ @@ -433,28 +420,27 @@ static int ssl23_client_hello(SSL *s) *(d++) = SSL2_MT_CLIENT_HELLO; *(d++) = version_major; *(d++) = version_minor; - + /* Ciphers supported */ - i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),p,0); - if (i == 0) - { + i = ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), p, 0); + if (i == 0) { /* no ciphers */ - SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE); + SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_NO_CIPHERS_AVAILABLE); return -1; - } - s2n(i,d); - p+=i; - + } + s2n(i, d); + p += i; + /* put in the session-id length (zero since there is no reuse) */ #if 0 - s->session->session_id_length=0; + s->session->session_id_length = 0; #endif - s2n(0,d); + s2n(0, d); if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG) - ch_len=SSL2_CHALLENGE_LENGTH; + ch_len = SSL2_CHALLENGE_LENGTH; else - ch_len=SSL2_MAX_CHALLENGE_LENGTH; + ch_len = SSL2_MAX_CHALLENGE_LENGTH; /* write out sslv2 challenge */ /* Note that ch_len must be <= SSL3_RANDOM_SIZE (32), @@ -462,34 +448,32 @@ static int ssl23_client_hello(SSL *s) or SSL2_MAX_CHALLENGE_LENGTH (16), but leave the check in for futurproofing */ if (SSL3_RANDOM_SIZE < ch_len) - i=SSL3_RANDOM_SIZE; + i = SSL3_RANDOM_SIZE; else - i=ch_len; - s2n(i,d); - memset(&(s->s3->client_random[0]),0,SSL3_RANDOM_SIZE); - if (RAND_pseudo_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i) <= 0) + i = ch_len; + s2n(i, d); + memset(&(s->s3->client_random[0]), 0, SSL3_RANDOM_SIZE); + if (RAND_pseudo_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE - i]), i) <= 0) return -1; - memcpy(p,&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i); - p+=i; + memcpy(p, &(s->s3->client_random[SSL3_RANDOM_SIZE - i]), i); + p += i; - i= p- &(buf[2]); - buf[0]=((i>>8)&0xff)|0x80; - buf[1]=(i&0xff); + i = p- &(buf[2]); + buf[0] = ((i >> 8)&0xff)|0x80; + buf[1] = (i&0xff); /* number of bytes to write */ - s->init_num=i+2; - s->init_off=0; + s->init_num = i + 2; + s->init_off = 0; - ssl3_finish_mac(s,&(buf[2]),i); - } - else - { + ssl3_finish_mac(s, &(buf[2]), i); + } else { /* create Client Hello in SSL 3.0/TLS 1.0 format */ /* do the record header (5 bytes) and handshake message header (4 bytes) last */ d = p = &(buf[9]); - + *(p++) = version_major; *(p++) = version_minor; @@ -501,73 +485,68 @@ static int ssl23_client_hello(SSL *s) *(p++) = 0; /* Ciphers supported (using SSL 3.0/TLS 1.0 format) */ - i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),&(p[2]),ssl3_put_cipher_by_char); - if (i == 0) - { - SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE); + i = ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), &(p[2]), ssl3_put_cipher_by_char); + if (i == 0) { + SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_NO_CIPHERS_AVAILABLE); return -1; - } + } #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH /* Some servers hang if client hello > 256 bytes * as hack workaround chop number of supported ciphers * to keep it well below this if we use TLS v1.2 */ - if (TLS1_get_version(s) >= TLS1_2_VERSION - && i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH) + if (TLS1_get_version(s) >= TLS1_2_VERSION && + i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH) i = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1; #endif - s2n(i,p); - p+=i; + s2n(i, p); + p += i; /* COMPRESSION */ #ifdef OPENSSL_NO_COMP - *(p++)=1; + *(p++) = 1; #else - if ((s->options & SSL_OP_NO_COMPRESSION) - || !s->ctx->comp_methods) - j=0; + if ((s->options & SSL_OP_NO_COMPRESSION) || + !s->ctx->comp_methods) + j = 0; else - j=sk_SSL_COMP_num(s->ctx->comp_methods); - *(p++)=1+j; - for (i=0; ictx->comp_methods,i); - *(p++)=comp->id; - } + j = sk_SSL_COMP_num(s->ctx->comp_methods); + *(p++) = 1 + j; + for (i = 0; i < j; i++) { + comp = sk_SSL_COMP_value(s->ctx->comp_methods, i); + *(p++) = comp->id; + } #endif *(p++)=0; /* Add the NULL method */ #ifndef OPENSSL_NO_TLSEXT /* TLS extensions*/ - if (ssl_prepare_clienthello_tlsext(s) <= 0) - { - SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_CLIENTHELLO_TLSEXT); + if (ssl_prepare_clienthello_tlsext(s) <= 0) { + SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT); return -1; - } - if ((p = ssl_add_clienthello_tlsext(s, p, buf+SSL3_RT_MAX_PLAIN_LENGTH)) == NULL) - { - SSLerr(SSL_F_SSL23_CLIENT_HELLO,ERR_R_INTERNAL_ERROR); + } + if ((p = ssl_add_clienthello_tlsext(s, p, buf + SSL3_RT_MAX_PLAIN_LENGTH)) == NULL) { + SSLerr(SSL_F_SSL23_CLIENT_HELLO, ERR_R_INTERNAL_ERROR); return -1; - } + } #endif - - l = p-d; + + l = p - d; /* fill in 4-byte handshake header */ - d=&(buf[5]); - *(d++)=SSL3_MT_CLIENT_HELLO; - l2n3(l,d); + d = &(buf[5]); + *(d++) = SSL3_MT_CLIENT_HELLO; + l2n3(l, d); l += 4; - if (l > SSL3_RT_MAX_PLAIN_LENGTH) - { - SSLerr(SSL_F_SSL23_CLIENT_HELLO,ERR_R_INTERNAL_ERROR); + if (l > SSL3_RT_MAX_PLAIN_LENGTH) { + SSLerr(SSL_F_SSL23_CLIENT_HELLO, ERR_R_INTERNAL_ERROR); return -1; - } - + } + /* fill in 5-byte record header */ - d=buf; + d = buf; *(d++) = SSL3_RT_HANDSHAKE; *(d++) = version_major; /* Some servers hang if we use long client hellos @@ -577,54 +556,54 @@ static int ssl23_client_hello(SSL *s) *(d++) = 1; else *(d++) = version_minor; - s2n((int)l,d); + s2n((int)l, d); /* number of bytes to write */ - s->init_num=p-buf; - s->init_off=0; - - ssl3_finish_mac(s,&(buf[5]), s->init_num - 5); - } + s->init_num = p - buf; + s->init_off = 0; - s->state=SSL23_ST_CW_CLNT_HELLO_B; - s->init_off=0; + ssl3_finish_mac(s, &(buf[5]), s->init_num - 5); } + s->state = SSL23_ST_CW_CLNT_HELLO_B; + s->init_off = 0; + } + /* SSL3_ST_CW_CLNT_HELLO_B */ ret = ssl23_write_bytes(s); - if ((ret >= 2) && s->msg_callback) - { + if ((ret >= 2) && s->msg_callback) { /* Client Hello has been sent; tell msg_callback */ if (ssl2_compat) - s->msg_callback(1, SSL2_VERSION, 0, s->init_buf->data+2, ret-2, s, s->msg_callback_arg); + s->msg_callback(1, SSL2_VERSION, 0, s->init_buf->data + 2, ret - 2, s, s->msg_callback_arg); else - s->msg_callback(1, version, SSL3_RT_HANDSHAKE, s->init_buf->data+5, ret-5, s, s->msg_callback_arg); - } + s->msg_callback(1, version, SSL3_RT_HANDSHAKE, s->init_buf->data + 5, ret - 5, s, s->msg_callback_arg); + } return ret; - } +} -static int ssl23_get_server_hello(SSL *s) - { +static int +ssl23_get_server_hello(SSL *s) +{ char buf[8]; unsigned char *p; int i; int n; - n=ssl23_read_bytes(s,7); + n = ssl23_read_bytes(s, 7); - if (n != 7) return(n); - p=s->packet; + if (n != 7) + return (n); + p = s->packet; - memcpy(buf,p,n); + memcpy(buf, p, n); if ((p[0] & 0x80) && (p[2] == SSL2_MT_SERVER_HELLO) && - (p[5] == 0x00) && (p[6] == 0x02)) - { + (p[5] == 0x00) && (p[6] == 0x02)) { #ifdef OPENSSL_NO_SSL2 - SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL); + SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL); goto err; #else /* we are talking sslv2 */ @@ -632,169 +611,150 @@ static int ssl23_get_server_hello(SSL *s) * sslv2 stuff. */ int ch_len; - if (s->options & SSL_OP_NO_SSLv2) - { - SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL); + if (s->options & SSL_OP_NO_SSLv2) { + SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL); goto err; - } - if (s->s2 == NULL) - { + } + if (s->s2 == NULL) { if (!ssl2_new(s)) goto err; - } - else + } else ssl2_clear(s); if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG) - ch_len=SSL2_CHALLENGE_LENGTH; + ch_len = SSL2_CHALLENGE_LENGTH; else - ch_len=SSL2_MAX_CHALLENGE_LENGTH; + ch_len = SSL2_MAX_CHALLENGE_LENGTH; /* write out sslv2 challenge */ /* Note that ch_len must be <= SSL3_RANDOM_SIZE (32), because it is one of SSL2_MAX_CHALLENGE_LENGTH (32) or SSL2_MAX_CHALLENGE_LENGTH (16), but leave the check in for futurproofing */ - i=(SSL3_RANDOM_SIZE < ch_len) - ?SSL3_RANDOM_SIZE:ch_len; - s->s2->challenge_length=i; + i = (SSL3_RANDOM_SIZE < ch_len) ? SSL3_RANDOM_SIZE : ch_len; + s->s2->challenge_length = i; memcpy(s->s2->challenge, - &(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i); + &(s->s3->client_random[SSL3_RANDOM_SIZE - i]), i); - if (s->s3 != NULL) ssl3_free(s); + if (s->s3 != NULL) + ssl3_free(s); if (!BUF_MEM_grow_clean(s->init_buf, - SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) - { - SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,ERR_R_BUF_LIB); + SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) { + SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, ERR_R_BUF_LIB); goto err; - } + } - s->state=SSL2_ST_GET_SERVER_HELLO_A; + s->state = SSL2_ST_GET_SERVER_HELLO_A; if (!(s->client_version == SSL2_VERSION)) /* use special padding (SSL 3.0 draft/RFC 2246, App. E.2) */ - s->s2->ssl2_rollback=1; + s->s2->ssl2_rollback = 1; /* setup the 7 bytes we have read so we get them from * the sslv2 buffer */ - s->rstate=SSL_ST_READ_HEADER; - s->packet_length=n; - s->packet= &(s->s2->rbuf[0]); - memcpy(s->packet,buf,n); - s->s2->rbuf_left=n; - s->s2->rbuf_offs=0; + s->rstate = SSL_ST_READ_HEADER; + s->packet_length = n; + s->packet = &(s->s2->rbuf[0]); + memcpy(s->packet, buf, n); + s->s2->rbuf_left = n; + s->s2->rbuf_offs = 0; /* we have already written one */ - s->s2->write_sequence=1; + s->s2->write_sequence = 1; - s->method=SSLv2_client_method(); - s->handshake_func=s->method->ssl_connect; + s->method = SSLv2_client_method(); + s->handshake_func = s->method->ssl_connect; #endif - } - else if (p[1] == SSL3_VERSION_MAJOR && - p[2] <= TLS1_2_VERSION_MINOR && - ((p[0] == SSL3_RT_HANDSHAKE && p[5] == SSL3_MT_SERVER_HELLO) || - (p[0] == SSL3_RT_ALERT && p[3] == 0 && p[4] == 2))) - { + } else if (p[1] == SSL3_VERSION_MAJOR && + p[2] <= TLS1_2_VERSION_MINOR && + ((p[0] == SSL3_RT_HANDSHAKE && p[5] == SSL3_MT_SERVER_HELLO) || + (p[0] == SSL3_RT_ALERT && p[3] == 0 && p[4] == 2))) { /* we have sslv3 or tls1 (server hello or alert) */ if ((p[2] == SSL3_VERSION_MINOR) && - !(s->options & SSL_OP_NO_SSLv3)) - { + !(s->options & SSL_OP_NO_SSLv3)) { #ifdef OPENSSL_FIPS - if(FIPS_mode()) - { + if (FIPS_mode()) { SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, - SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE); + SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE); goto err; - } -#endif - s->version=SSL3_VERSION; - s->method=SSLv3_client_method(); - } - else if ((p[2] == TLS1_VERSION_MINOR) && - !(s->options & SSL_OP_NO_TLSv1)) - { - s->version=TLS1_VERSION; - s->method=TLSv1_client_method(); } - else if ((p[2] == TLS1_1_VERSION_MINOR) && - !(s->options & SSL_OP_NO_TLSv1_1)) - { - s->version=TLS1_1_VERSION; - s->method=TLSv1_1_client_method(); - } - else if ((p[2] == TLS1_2_VERSION_MINOR) && - !(s->options & SSL_OP_NO_TLSv1_2)) - { - s->version=TLS1_2_VERSION; - s->method=TLSv1_2_client_method(); - } - else - { - SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL); +#endif + s->version = SSL3_VERSION; + s->method = SSLv3_client_method(); + } else if ((p[2] == TLS1_VERSION_MINOR) && + !(s->options & SSL_OP_NO_TLSv1)) { + s->version = TLS1_VERSION; + s->method = TLSv1_client_method(); + } else if ((p[2] == TLS1_1_VERSION_MINOR) && + !(s->options & SSL_OP_NO_TLSv1_1)) { + s->version = TLS1_1_VERSION; + s->method = TLSv1_1_client_method(); + } else if ((p[2] == TLS1_2_VERSION_MINOR) && + !(s->options & SSL_OP_NO_TLSv1_2)) { + s->version = TLS1_2_VERSION; + s->method = TLSv1_2_client_method(); + } else { + SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL); goto err; - } + } - if (p[0] == SSL3_RT_ALERT && p[5] != SSL3_AL_WARNING) - { + if (p[0] == SSL3_RT_ALERT && p[5] != SSL3_AL_WARNING) { /* fatal alert */ - void (*cb)(const SSL *ssl,int type,int val)=NULL; + void (*cb)(const SSL *ssl, int type, int val) = NULL; int j; if (s->info_callback != NULL) - cb=s->info_callback; + cb = s->info_callback; else if (s->ctx->info_callback != NULL) - cb=s->ctx->info_callback; - - i=p[5]; - if (cb != NULL) - { - j=(i<<8)|p[6]; - cb(s,SSL_CB_READ_ALERT,j); - } - + cb = s->ctx->info_callback; + + i = p[5]; + if (cb != NULL) { + j = (i << 8) | p[6]; + cb(s, SSL_CB_READ_ALERT, j); + } + if (s->msg_callback) - s->msg_callback(0, s->version, SSL3_RT_ALERT, p+5, 2, s, s->msg_callback_arg); + s->msg_callback(0, s->version, SSL3_RT_ALERT, p + 5, 2, s, s->msg_callback_arg); - s->rwstate=SSL_NOTHING; - SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_AD_REASON_OFFSET+p[6]); + s->rwstate = SSL_NOTHING; + SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_AD_REASON_OFFSET + p[6]); goto err; - } + } - if (!ssl_init_wbio_buffer(s,1)) goto err; + if (!ssl_init_wbio_buffer(s, 1)) + goto err; /* we are in this state */ - s->state=SSL3_ST_CR_SRVR_HELLO_A; + s->state = SSL3_ST_CR_SRVR_HELLO_A; /* put the 7 bytes we have read into the input buffer * for SSLv3 */ - s->rstate=SSL_ST_READ_HEADER; - s->packet_length=n; + 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; - - s->handshake_func=s->method->ssl_connect; - } - else - { - SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNKNOWN_PROTOCOL); + s->packet = &(s->s3->rbuf.buf[0]); + memcpy(s->packet, buf, n); + s->s3->rbuf.left = n; + s->s3->rbuf.offset = 0; + + s->handshake_func = s->method->ssl_connect; + } else { + SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNKNOWN_PROTOCOL); goto err; - } - s->init_num=0; + } + s->init_num = 0; /* Since, if we are sending a ssl23 client hello, we are not * reusing a session-id */ - if (!ssl_get_new_session(s,0)) + if (!ssl_get_new_session(s, 0)) goto err; - return(SSL_connect(s)); + return (SSL_connect(s)); err: - return(-1); - } + return (-1); +} diff --git a/src/lib/libssl/s23_lib.c b/src/lib/libssl/s23_lib.c index a6285b767f..3a4d5a6ecb 100644 --- a/src/lib/libssl/s23_lib.c +++ b/src/lib/libssl/s23_lib.c @@ -60,128 +60,126 @@ #include #include "ssl_locl.h" -long ssl23_default_timeout(void) - { - return(300); - } +long +ssl23_default_timeout(void) +{ + return (300); +} -int ssl23_num_ciphers(void) - { +int +ssl23_num_ciphers(void) +{ return(ssl3_num_ciphers() #ifndef OPENSSL_NO_SSL2 - + ssl2_num_ciphers() + + ssl2_num_ciphers() #endif - ); - } + ); +} -const SSL_CIPHER *ssl23_get_cipher(unsigned int u) - { - unsigned int uu=ssl3_num_ciphers(); +const SSL_CIPHER +*ssl23_get_cipher(unsigned int u) +{ + unsigned int uu = ssl3_num_ciphers(); if (u < uu) - return(ssl3_get_cipher(u)); + return (ssl3_get_cipher(u)); else #ifndef OPENSSL_NO_SSL2 - return(ssl2_get_cipher(u-uu)); + return (ssl2_get_cipher(u - uu)); #else - return(NULL); + return (NULL); #endif - } +} /* This function needs to check if the ciphers required are actually * available */ -const SSL_CIPHER *ssl23_get_cipher_by_char(const unsigned char *p) - { +const SSL_CIPHER +*ssl23_get_cipher_by_char(const unsigned char *p) +{ const SSL_CIPHER *cp; - cp=ssl3_get_cipher_by_char(p); + cp = ssl3_get_cipher_by_char(p); #ifndef OPENSSL_NO_SSL2 if (cp == NULL) - cp=ssl2_get_cipher_by_char(p); + cp = ssl2_get_cipher_by_char(p); #endif - return(cp); - } + return (cp); +} -int ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p) - { +int +ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p) +{ long l; /* We can write SSLv2 and SSLv3 ciphers */ - if (p != NULL) - { - l=c->id; - p[0]=((unsigned char)(l>>16L))&0xFF; - p[1]=((unsigned char)(l>> 8L))&0xFF; - p[2]=((unsigned char)(l ))&0xFF; - } - return(3); + if (p != NULL) { + l = c->id; + p[0] = ((unsigned char)(l >> 16L))&0xFF; + p[1] = ((unsigned char)(l >> 8L))&0xFF; + p[2] = ((unsigned char)(l ))&0xFF; } + return (3); +} -int ssl23_read(SSL *s, void *buf, int len) - { +int +ssl23_read(SSL *s, void *buf, int len) +{ int n; errno = 0; - if (SSL_in_init(s) && (!s->in_handshake)) - { - n=s->handshake_func(s); - if (n < 0) return(n); - if (n == 0) - { - SSLerr(SSL_F_SSL23_READ,SSL_R_SSL_HANDSHAKE_FAILURE); - return(-1); - } - return(SSL_read(s,buf,len)); + if (SSL_in_init(s) && (!s->in_handshake)) { + n = s->handshake_func(s); + if (n < 0) + return (n); + if (n == 0) { + SSLerr(SSL_F_SSL23_READ, SSL_R_SSL_HANDSHAKE_FAILURE); + return (-1); } - else - { + return (SSL_read(s, buf, len)); + } else { ssl_undefined_function(s); - return(-1); - } + return (-1); } +} -int ssl23_peek(SSL *s, void *buf, int len) - { +int +ssl23_peek(SSL *s, void *buf, int len) +{ int n; errno = 0; - if (SSL_in_init(s) && (!s->in_handshake)) - { - n=s->handshake_func(s); - if (n < 0) return(n); - if (n == 0) - { - SSLerr(SSL_F_SSL23_PEEK,SSL_R_SSL_HANDSHAKE_FAILURE); - return(-1); - } - return(SSL_peek(s,buf,len)); + if (SSL_in_init(s) && (!s->in_handshake)) { + n = s->handshake_func(s); + if (n < 0) + return (n); + if (n == 0) { + SSLerr(SSL_F_SSL23_PEEK, SSL_R_SSL_HANDSHAKE_FAILURE); + return (-1); } - else - { + return (SSL_peek(s, buf, len)); + } else { ssl_undefined_function(s); - return(-1); - } + return (-1); } +} -int ssl23_write(SSL *s, const void *buf, int len) - { +int +ssl23_write(SSL *s, const void *buf, int len) +{ int n; errno = 0; - if (SSL_in_init(s) && (!s->in_handshake)) - { - n=s->handshake_func(s); - if (n < 0) return(n); - if (n == 0) - { - SSLerr(SSL_F_SSL23_WRITE,SSL_R_SSL_HANDSHAKE_FAILURE); - return(-1); - } - return(SSL_write(s,buf,len)); + if (SSL_in_init(s) && (!s->in_handshake)) { + n = s->handshake_func(s); + if (n < 0) + return (n); + if (n == 0) { + SSLerr(SSL_F_SSL23_WRITE, SSL_R_SSL_HANDSHAKE_FAILURE); + return (-1); } - else - { + return (SSL_write(s, buf, len)); + } else { ssl_undefined_function(s); - return(-1); - } + return (-1); } +} diff --git a/src/lib/libssl/s23_pkt.c b/src/lib/libssl/s23_pkt.c index eba8d9d8fc..28d07a2212 100644 --- a/src/lib/libssl/s23_pkt.c +++ b/src/lib/libssl/s23_pkt.c @@ -62,55 +62,53 @@ #include #include -int ssl23_write_bytes(SSL *s) - { - int i,num,tot; +int +ssl23_write_bytes(SSL *s) +{ + int i, num, tot; char *buf; - buf=s->init_buf->data; - tot=s->init_off; - num=s->init_num; - for (;;) - { - s->rwstate=SSL_WRITING; - i=BIO_write(s->wbio,&(buf[tot]),num); - if (i <= 0) - { - s->init_off=tot; - s->init_num=num; - return(i); - } - s->rwstate=SSL_NOTHING; - if (i == num) return(tot+i); - - num-=i; - tot+=i; + buf = s->init_buf->data; + tot = s->init_off; + num = s->init_num; + for (;;) { + s->rwstate = SSL_WRITING; + i = BIO_write(s->wbio, &(buf[tot]), num); + if (i <= 0) { + s->init_off = tot; + s->init_num = num; + return (i); } + s->rwstate = SSL_NOTHING; + if (i == num) + return (tot + i); + + num -= i; + tot += i; } +} /* return regularly only when we have read (at least) 'n' bytes */ -int ssl23_read_bytes(SSL *s, int n) - { +int +ssl23_read_bytes(SSL *s, int n) +{ unsigned char *p; int j; - if (s->packet_length < (unsigned int)n) - { - p=s->packet; + if (s->packet_length < (unsigned int)n) { + p = s->packet; - for (;;) - { - s->rwstate=SSL_READING; - j=BIO_read(s->rbio,(char *)&(p[s->packet_length]), - n-s->packet_length); + for (;;) { + s->rwstate = SSL_READING; + j = BIO_read(s->rbio,(char *)&(p[s->packet_length]), + n - s->packet_length); if (j <= 0) - return(j); - s->rwstate=SSL_NOTHING; - s->packet_length+=j; + return (j); + s->rwstate = SSL_NOTHING; + s->packet_length += j; if (s->packet_length >= (unsigned int)n) - return(s->packet_length); - } + return (s->packet_length); } - return(n); } - + return (n); +} diff --git a/src/lib/libssl/s23_srvr.c b/src/lib/libssl/s23_srvr.c index 2ac8786c62..35db7b4992 100644 --- a/src/lib/libssl/s23_srvr.c +++ b/src/lib/libssl/s23_srvr.c @@ -121,227 +121,209 @@ static const SSL_METHOD *ssl23_get_server_method(int ver); int ssl23_get_client_hello(SSL *s); -static const 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()); + return (SSLv2_server_method()); #endif if (ver == SSL3_VERSION) - return(SSLv3_server_method()); + return (SSLv3_server_method()); else if (ver == TLS1_VERSION) - return(TLSv1_server_method()); + return (TLSv1_server_method()); else if (ver == TLS1_1_VERSION) - return(TLSv1_1_server_method()); + return (TLSv1_1_server_method()); else if (ver == TLS1_2_VERSION) - return(TLSv1_2_server_method()); + return (TLSv1_2_server_method()); else - return(NULL); - } + return (NULL); +} IMPLEMENT_ssl23_meth_func(SSLv23_server_method, - ssl23_accept, - ssl_undefined_function, - ssl23_get_server_method) + ssl23_accept, ssl_undefined_function, ssl23_get_server_method) -int ssl23_accept(SSL *s) - { +int +ssl23_accept(SSL *s) +{ BUF_MEM *buf; - unsigned long Time=(unsigned long)time(NULL); - void (*cb)(const SSL *ssl,int type,int val)=NULL; - int ret= -1; - int new_state,state; + unsigned long Time = (unsigned long)time(NULL); + void (*cb)(const SSL *ssl, int type, int val) = NULL; + int ret = -1; + int new_state, state; - RAND_add(&Time,sizeof(Time),0); + RAND_add(&Time, sizeof(Time), 0); ERR_clear_error(); errno = 0; if (s->info_callback != NULL) - cb=s->info_callback; + cb = s->info_callback; else if (s->ctx->info_callback != NULL) - cb=s->ctx->info_callback; - + cb = s->ctx->info_callback; + s->in_handshake++; - if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); + if (!SSL_in_init(s) || SSL_in_before(s)) + SSL_clear(s); - for (;;) - { - state=s->state; + for (;;) { + state = s->state; - switch(s->state) - { + switch (s->state) { case SSL_ST_BEFORE: case SSL_ST_ACCEPT: case SSL_ST_BEFORE|SSL_ST_ACCEPT: case SSL_ST_OK|SSL_ST_ACCEPT: - s->server=1; - if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1); + s->server = 1; + if (cb != NULL) + cb(s, SSL_CB_HANDSHAKE_START, 1); /* s->version=SSL3_VERSION; */ - s->type=SSL_ST_ACCEPT; + s->type = SSL_ST_ACCEPT; - if (s->init_buf == NULL) - { - if ((buf=BUF_MEM_new()) == NULL) - { - ret= -1; + if (s->init_buf == NULL) { + if ((buf = BUF_MEM_new()) == NULL) { + ret = -1; goto end; - } - if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH)) - { - ret= -1; + } + if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) { + ret = -1; goto end; - } - s->init_buf=buf; } + s->init_buf = buf; + } ssl3_init_finished_mac(s); - s->state=SSL23_ST_SR_CLNT_HELLO_A; + s->state = SSL23_ST_SR_CLNT_HELLO_A; s->ctx->stats.sess_accept++; - s->init_num=0; + s->init_num = 0; break; case SSL23_ST_SR_CLNT_HELLO_A: case SSL23_ST_SR_CLNT_HELLO_B: - s->shutdown=0; - ret=ssl23_get_client_hello(s); - if (ret >= 0) cb=NULL; + s->shutdown = 0; + ret = ssl23_get_client_hello(s); + if (ret >= 0) + cb = NULL; goto end; /* break; */ default: - SSLerr(SSL_F_SSL23_ACCEPT,SSL_R_UNKNOWN_STATE); - ret= -1; + SSLerr(SSL_F_SSL23_ACCEPT, SSL_R_UNKNOWN_STATE); + ret = -1; goto end; /* break; */ - } + } - if ((cb != NULL) && (s->state != state)) - { - new_state=s->state; - s->state=state; - cb(s,SSL_CB_ACCEPT_LOOP,1); - s->state=new_state; - } + if ((cb != NULL) && (s->state != state)) { + new_state = s->state; + s->state = state; + cb(s, SSL_CB_ACCEPT_LOOP, 1); + s->state = new_state; } + } end: s->in_handshake--; if (cb != NULL) - cb(s,SSL_CB_ACCEPT_EXIT,ret); - return(ret); - } + cb(s, SSL_CB_ACCEPT_EXIT, ret); + return (ret); +} -int ssl23_get_client_hello(SSL *s) - { +int +ssl23_get_client_hello(SSL *s) +{ char buf_space[11]; /* Request this many bytes in initial read. - * We can detect SSL 3.0/TLS 1.0 Client Hellos - * ('type == 3') correctly only when the following - * is in a single record, which is not guaranteed by - * the protocol specification: - * Byte Content - * 0 type \ + * We can detect SSL 3.0/TLS 1.0 Client Hellos + * ('type == 3') correctly only when the following + * is in a single record, which is not guaranteed by + * the protocol specification: + * Byte Content + * 0 type \ * 1/2 version > record header - * 3/4 length / - * 5 msg_type \ + * 3/4 length / + * 5 msg_type \ * 6-8 length > Client Hello message - * 9/10 client_version / + * 9/10 client_version / */ - char *buf= &(buf_space[0]); - unsigned char *p,*d,*d_len,*dd; + char *buf = &(buf_space[0]); + unsigned char *p, *d, *d_len, *dd; unsigned int i; - unsigned int csl,sil,cl; - int n=0,j; - int type=0; + unsigned int csl, sil, cl; + int n = 0, j; + int type = 0; int v[2]; - if (s->state == SSL23_ST_SR_CLNT_HELLO_A) - { + if (s->state == SSL23_ST_SR_CLNT_HELLO_A) { /* read the initial header */ - v[0]=v[1]=0; + v[0] = v[1] = 0; - if (!ssl3_setup_buffers(s)) goto err; + if (!ssl3_setup_buffers(s)) + goto err; - n=ssl23_read_bytes(s, sizeof buf_space); - if (n != sizeof buf_space) return(n); /* n == -1 || n == 0 */ + n = ssl23_read_bytes(s, sizeof buf_space); + if (n != sizeof buf_space) + return(n); /* n == -1 || n == 0 */ - p=s->packet; + p = s->packet; - memcpy(buf,p,n); + memcpy(buf, p, n); - if ((p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO)) - { + if ((p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO)) { /* * SSLv2 header */ - if ((p[3] == 0x00) && (p[4] == 0x02)) - { - v[0]=p[3]; v[1]=p[4]; + if ((p[3] == 0x00) && (p[4] == 0x02)) { + v[0] = p[3]; + v[1] = p[4]; /* SSLv2 */ if (!(s->options & SSL_OP_NO_SSLv2)) - type=1; - } - else if (p[3] == SSL3_VERSION_MAJOR) - { - v[0]=p[3]; v[1]=p[4]; + type = 1; + } else if (p[3] == SSL3_VERSION_MAJOR) { + v[0] = p[3]; + v[1] = p[4]; /* SSLv3/TLSv1 */ - if (p[4] >= TLS1_VERSION_MINOR) - { + if (p[4] >= TLS1_VERSION_MINOR) { if (p[4] >= TLS1_2_VERSION_MINOR && - !(s->options & SSL_OP_NO_TLSv1_2)) - { - s->version=TLS1_2_VERSION; - s->state=SSL23_ST_SR_CLNT_HELLO_B; - } - else if (p[4] >= TLS1_1_VERSION_MINOR && - !(s->options & SSL_OP_NO_TLSv1_1)) - { - s->version=TLS1_1_VERSION; + !(s->options & SSL_OP_NO_TLSv1_2)) { + s->version = TLS1_2_VERSION; + s->state = SSL23_ST_SR_CLNT_HELLO_B; + } else if (p[4] >= TLS1_1_VERSION_MINOR && + !(s->options & SSL_OP_NO_TLSv1_1)) { + s->version = TLS1_1_VERSION; /* type=2; */ /* done later to survive restarts */ - s->state=SSL23_ST_SR_CLNT_HELLO_B; - } - else if (!(s->options & SSL_OP_NO_TLSv1)) - { - s->version=TLS1_VERSION; + s->state = SSL23_ST_SR_CLNT_HELLO_B; + } else if (!(s->options & SSL_OP_NO_TLSv1)) { + s->version = TLS1_VERSION; /* type=2; */ /* done later to survive restarts */ - s->state=SSL23_ST_SR_CLNT_HELLO_B; - } - else if (!(s->options & SSL_OP_NO_SSLv3)) - { - s->version=SSL3_VERSION; + s->state = SSL23_ST_SR_CLNT_HELLO_B; + } else if (!(s->options & SSL_OP_NO_SSLv3)) { + s->version = SSL3_VERSION; /* type=2; */ - s->state=SSL23_ST_SR_CLNT_HELLO_B; - } - else if (!(s->options & SSL_OP_NO_SSLv2)) - { - type=1; - } + s->state = SSL23_ST_SR_CLNT_HELLO_B; + } else if (!(s->options & SSL_OP_NO_SSLv2)) { + type = 1; } - else if (!(s->options & SSL_OP_NO_SSLv3)) - { - s->version=SSL3_VERSION; + } else if (!(s->options & SSL_OP_NO_SSLv3)) { + s->version = SSL3_VERSION; /* type=2; */ - s->state=SSL23_ST_SR_CLNT_HELLO_B; - } - else if (!(s->options & SSL_OP_NO_SSLv2)) - type=1; + s->state = SSL23_ST_SR_CLNT_HELLO_B; + } else if (!(s->options & SSL_OP_NO_SSLv2)) + type = 1; - } } - else if ((p[0] == SSL3_RT_HANDSHAKE) && - (p[1] == SSL3_VERSION_MAJOR) && - (p[5] == SSL3_MT_CLIENT_HELLO) && - ((p[3] == 0 && p[4] < 5 /* silly record length? */) - || (p[9] >= p[1]))) - { + } else if ((p[0] == SSL3_RT_HANDSHAKE) && + (p[1] == SSL3_VERSION_MAJOR) && + (p[5] == SSL3_MT_CLIENT_HELLO) && + ((p[3] == 0 && p[4] < 5 /* silly record length? */) + || (p[9] >= p[1]))) { /* * SSLv3 or tls1 header */ - - v[0]=p[1]; /* major version (= SSL3_VERSION_MAJOR) */ + + v[0] = p[1]; /* major version (= SSL3_VERSION_MAJOR) */ /* We must look at client_version inside the Client Hello message * to get the correct minor version. * However if we have only a pathologically small fragment of the @@ -350,127 +332,108 @@ int ssl23_get_client_hello(SSL *s) * No known SSL 3.0 client fragments ClientHello like this, * so we simply assume TLS 1.0 to avoid protocol version downgrade * attacks. */ - if (p[3] == 0 && p[4] < 6) - { + if (p[3] == 0 && p[4] < 6) { #if 0 - SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_SMALL); + SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_RECORD_TOO_SMALL); goto err; #else v[1] = TLS1_VERSION_MINOR; #endif - } + } /* if major version number > 3 set minor to a value * which will use the highest version 3 we support. * If TLS 2.0 ever appears we will need to revise * this.... */ else if (p[9] > SSL3_VERSION_MAJOR) - v[1]=0xff; + v[1] = 0xff; else - v[1]=p[10]; /* minor version according to client_version */ - if (v[1] >= TLS1_VERSION_MINOR) - { + v[1] = p[10]; /* minor version according to client_version */ + if (v[1] >= TLS1_VERSION_MINOR) { if (v[1] >= TLS1_2_VERSION_MINOR && - !(s->options & SSL_OP_NO_TLSv1_2)) - { - s->version=TLS1_2_VERSION; - type=3; - } - else if (v[1] >= TLS1_1_VERSION_MINOR && - !(s->options & SSL_OP_NO_TLSv1_1)) - { - s->version=TLS1_1_VERSION; - type=3; - } - else if (!(s->options & SSL_OP_NO_TLSv1)) - { - s->version=TLS1_VERSION; - type=3; - } - else if (!(s->options & SSL_OP_NO_SSLv3)) - { - s->version=SSL3_VERSION; - type=3; - } + !(s->options & SSL_OP_NO_TLSv1_2)) { + s->version = TLS1_2_VERSION; + type = 3; + } else if (v[1] >= TLS1_1_VERSION_MINOR && + !(s->options & SSL_OP_NO_TLSv1_1)) { + s->version = TLS1_1_VERSION; + type = 3; + } else if (!(s->options & SSL_OP_NO_TLSv1)) { + s->version = TLS1_VERSION; + type = 3; + } else if (!(s->options & SSL_OP_NO_SSLv3)) { + s->version = SSL3_VERSION; + type = 3; } - else - { + } else { /* client requests SSL 3.0 */ - if (!(s->options & SSL_OP_NO_SSLv3)) - { - s->version=SSL3_VERSION; - type=3; - } - else if (!(s->options & SSL_OP_NO_TLSv1)) - { + if (!(s->options & SSL_OP_NO_SSLv3)) { + s->version = SSL3_VERSION; + type = 3; + } else if (!(s->options & SSL_OP_NO_TLSv1)) { /* we won't be able to use TLS of course, * but this will send an appropriate alert */ - s->version=TLS1_VERSION; - type=3; - } + s->version = TLS1_VERSION; + type = 3; } } - else if ((strncmp("GET ", (char *)p,4) == 0) || - (strncmp("POST ",(char *)p,5) == 0) || - (strncmp("HEAD ",(char *)p,5) == 0) || - (strncmp("PUT ", (char *)p,4) == 0)) - { - SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTP_REQUEST); + } + else if ((strncmp("GET ", (char *)p, 4) == 0) || + (strncmp("POST ",(char *)p, 5) == 0) || + (strncmp("HEAD ",(char *)p, 5) == 0) || + (strncmp("PUT ", (char *)p, 4) == 0)) { + 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); + } 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)) - { + if (FIPS_mode() && (s->version < TLS1_VERSION)) { SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, - SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE); + SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE); goto err; - } + } #endif - if (s->state == SSL23_ST_SR_CLNT_HELLO_B) - { + 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; + type = 2; + p = s->packet; v[0] = p[3]; /* == SSL3_VERSION_MAJOR */ v[1] = p[4]; - n=((p[0]&0x7f)<<8)|p[1]; - if (n > (1024*4)) - { - SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_LARGE); + n = ((p[0] & 0x7f) << 8) | p[1]; + if (n > (1024 * 4)) { + 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); + j = ssl23_read_bytes(s, n + 2); + if (j <= 0) + return (j); - ssl3_finish_mac(s, s->packet+2, s->packet_length-2); + 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) /* We can't have TLS extensions in SSL 2.0 format - * Client Hello, can we? Error condition should be + 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) /* 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); + { + SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_RECORD_LENGTH_MISMATCH); goto err; - } + } /* record header: msg_type ... */ *(d++) = SSL3_MT_CLIENT_HELLO; @@ -484,130 +447,122 @@ int ssl23_get_client_hello(SSL *s) /* lets populate the random area */ /* get the challenge_length */ - i=(cl > SSL3_RANDOM_SIZE)?SSL3_RANDOM_SIZE:cl; - memset(d,0,SSL3_RANDOM_SIZE); - memcpy(&(d[SSL3_RANDOM_SIZE-i]),&(p[csl+sil]),i); - d+=SSL3_RANDOM_SIZE; + i = (cl > SSL3_RANDOM_SIZE) ? SSL3_RANDOM_SIZE : cl; + memset(d, 0, SSL3_RANDOM_SIZE); + memcpy(&(d[SSL3_RANDOM_SIZE - i]), &(p[csl + sil]), i); + d += SSL3_RANDOM_SIZE; /* no session-id reuse */ - *(d++)=0; + *(d++) = 0; /* ciphers */ - j=0; - dd=d; - d+=2; - for (i=0; ipacket+s->packet_length) - { + /* 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; + 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; - } + 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): */ /* s->state = SSL23_SR_CLNT_HELLO_C */ - if (type == 1) - { + if (type == 1) { #ifdef OPENSSL_NO_SSL2 - SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNSUPPORTED_PROTOCOL); + SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_UNSUPPORTED_PROTOCOL); goto err; #else /* we are talking sslv2 */ /* we need to clean up the SSLv3/TLSv1 setup and put in the * sslv2 stuff. */ - if (s->s2 == NULL) - { + if (s->s2 == NULL) { if (!ssl2_new(s)) goto err; - } - else + } else ssl2_clear(s); - if (s->s3 != NULL) ssl3_free(s); + if (s->s3 != NULL) + ssl3_free(s); if (!BUF_MEM_grow_clean(s->init_buf, - SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) - { + SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) { goto err; - } + } - s->state=SSL2_ST_GET_CLIENT_HELLO_A; + s->state = SSL2_ST_GET_CLIENT_HELLO_A; if (s->options & SSL_OP_NO_TLSv1 && s->options & SSL_OP_NO_SSLv3) - s->s2->ssl2_rollback=0; + s->s2->ssl2_rollback = 0; else /* reject SSL 2.0 session if client supports SSL 3.0 or TLS 1.0 * (SSL 3.0 draft/RFC 2246, App. E.2) */ - s->s2->ssl2_rollback=1; + s->s2->ssl2_rollback = 1; /* setup the n bytes we have read so we get them from * the sslv2 buffer */ - s->rstate=SSL_ST_READ_HEADER; - s->packet_length=n; - s->packet= &(s->s2->rbuf[0]); - memcpy(s->packet,buf,n); - s->s2->rbuf_left=n; - s->s2->rbuf_offs=0; - - s->method=SSLv2_server_method(); - s->handshake_func=s->method->ssl_accept; + s->rstate = SSL_ST_READ_HEADER; + s->packet_length = n; + s->packet = &(s->s2->rbuf[0]); + memcpy(s->packet, buf, n); + s->s2->rbuf_left = n; + s->s2->rbuf_offs = 0; + + s->method = SSLv2_server_method(); + s->handshake_func = s->method->ssl_accept; #endif - } + } - if ((type == 2) || (type == 3)) - { + if ((type == 2) || (type == 3)) { /* we have SSLv3/TLSv1 (type 2: SSL2 style, type 3: SSL3/TLS style) */ - if (!ssl_init_wbio_buffer(s,1)) goto err; + if (!ssl_init_wbio_buffer(s, 1)) goto err; /* we are in this state */ - s->state=SSL3_ST_SR_CLNT_HELLO_A; + s->state = SSL3_ST_SR_CLNT_HELLO_A; - if (type == 3) - { + 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; + 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; - } + 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; + } if (s->version == TLS1_2_VERSION) s->method = TLSv1_2_server_method(); else if (s->version == TLS1_1_VERSION) @@ -617,22 +572,23 @@ int ssl23_get_client_hello(SSL *s) else s->method = SSLv3_server_method(); #if 0 /* ssl3_get_client_hello does this */ - s->client_version=(v[0]<<8)|v[1]; + s->client_version = (v[0]<<8)|v[1]; #endif - s->handshake_func=s->method->ssl_accept; - } - - if ((type < 1) || (type > 3)) - { + s->handshake_func = s->method->ssl_accept; + } + + if ((type < 1) || (type > 3)) { /* bad, very bad */ - SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNKNOWN_PROTOCOL); + SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_UNKNOWN_PROTOCOL); goto err; - } - s->init_num=0; + } + s->init_num = 0; - if (buf != buf_space) OPENSSL_free(buf); - return(SSL_accept(s)); + if (buf != buf_space) + OPENSSL_free(buf); + return (SSL_accept(s)); err: - if (buf != buf_space) OPENSSL_free(buf); - return(-1); - } + if (buf != buf_space) + OPENSSL_free(buf); + return (-1); +} diff --git a/src/lib/libssl/src/ssl/s23_clnt.c b/src/lib/libssl/src/ssl/s23_clnt.c index 6315e9d876..0fd388a05a 100644 --- a/src/lib/libssl/src/ssl/s23_clnt.c +++ b/src/lib/libssl/src/ssl/s23_clnt.c @@ -119,160 +119,163 @@ static const SSL_METHOD *ssl23_get_client_method(int ver); static int ssl23_client_hello(SSL *s); static int ssl23_get_server_hello(SSL *s); -static const SSL_METHOD *ssl23_get_client_method(int ver) - { +static const SSL_METHOD +*ssl23_get_client_method(int ver) +{ #ifndef OPENSSL_NO_SSL2 if (ver == SSL2_VERSION) - return(SSLv2_client_method()); + return (SSLv2_client_method()); #endif if (ver == SSL3_VERSION) - return(SSLv3_client_method()); + return (SSLv3_client_method()); else if (ver == TLS1_VERSION) - return(TLSv1_client_method()); + return (TLSv1_client_method()); else if (ver == TLS1_1_VERSION) - return(TLSv1_1_client_method()); + return (TLSv1_1_client_method()); else if (ver == TLS1_2_VERSION) - return(TLSv1_2_client_method()); + return (TLSv1_2_client_method()); else - return(NULL); - } + return (NULL); +} IMPLEMENT_ssl23_meth_func(SSLv23_client_method, - ssl_undefined_function, - ssl23_connect, - ssl23_get_client_method) - -int ssl23_connect(SSL *s) - { - BUF_MEM *buf=NULL; - unsigned long Time=(unsigned long)time(NULL); - void (*cb)(const SSL *ssl,int type,int val)=NULL; - int ret= -1; - int new_state,state; - - RAND_add(&Time,sizeof(Time),0); + ssl_undefined_function, ssl23_connect, ssl23_get_client_method) + +int +ssl23_connect(SSL *s) +{ + BUF_MEM *buf = NULL; + unsigned long Time = (unsigned long)time(NULL); + void (*cb)(const SSL *ssl, int type, int val) = NULL; + int ret = -1; + int new_state, state; + + RAND_add(&Time, sizeof(Time), 0); ERR_clear_error(); errno = 0; if (s->info_callback != NULL) - cb=s->info_callback; + cb = s->info_callback; else if (s->ctx->info_callback != NULL) - cb=s->ctx->info_callback; - + cb = s->ctx->info_callback; + s->in_handshake++; - if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); + if (!SSL_in_init(s) || SSL_in_before(s)) + SSL_clear(s); - for (;;) - { - state=s->state; + for (;;) { + state = s->state; - switch(s->state) - { + switch (s->state) { case SSL_ST_BEFORE: case SSL_ST_CONNECT: case SSL_ST_BEFORE|SSL_ST_CONNECT: case SSL_ST_OK|SSL_ST_CONNECT: - if (s->session != NULL) - { - SSLerr(SSL_F_SSL23_CONNECT,SSL_R_SSL23_DOING_SESSION_ID_REUSE); - ret= -1; + if (s->session != NULL) { + SSLerr(SSL_F_SSL23_CONNECT, SSL_R_SSL23_DOING_SESSION_ID_REUSE); + ret = -1; goto end; - } - s->server=0; - if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1); + } + s->server = 0; + if (cb != NULL) + cb(s, SSL_CB_HANDSHAKE_START, 1); /* s->version=TLS1_VERSION; */ - s->type=SSL_ST_CONNECT; + s->type = SSL_ST_CONNECT; - if (s->init_buf == NULL) - { - if ((buf=BUF_MEM_new()) == NULL) - { - ret= -1; + if (s->init_buf == NULL) { + if ((buf = BUF_MEM_new()) == NULL) { + ret = -1; goto end; - } - if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH)) - { - ret= -1; + } + if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) { + ret = -1; goto end; - } - s->init_buf=buf; - buf=NULL; } + s->init_buf = buf; + buf = NULL; + } - if (!ssl3_setup_buffers(s)) { ret= -1; goto end; } + if (!ssl3_setup_buffers(s)) { + ret = -1; + goto end; + } ssl3_init_finished_mac(s); - s->state=SSL23_ST_CW_CLNT_HELLO_A; + s->state = SSL23_ST_CW_CLNT_HELLO_A; s->ctx->stats.sess_connect++; - s->init_num=0; + s->init_num = 0; break; case SSL23_ST_CW_CLNT_HELLO_A: case SSL23_ST_CW_CLNT_HELLO_B: - s->shutdown=0; - ret=ssl23_client_hello(s); - if (ret <= 0) goto end; - s->state=SSL23_ST_CR_SRVR_HELLO_A; - s->init_num=0; + s->shutdown = 0; + ret = ssl23_client_hello(s); + if (ret <= 0) + goto end; + s->state = SSL23_ST_CR_SRVR_HELLO_A; + s->init_num = 0; break; case SSL23_ST_CR_SRVR_HELLO_A: case SSL23_ST_CR_SRVR_HELLO_B: - ret=ssl23_get_server_hello(s); - if (ret >= 0) cb=NULL; + ret = ssl23_get_server_hello(s); + if (ret >= 0) + cb = NULL; goto end; /* break; */ default: - SSLerr(SSL_F_SSL23_CONNECT,SSL_R_UNKNOWN_STATE); - ret= -1; + SSLerr(SSL_F_SSL23_CONNECT, SSL_R_UNKNOWN_STATE); + ret = -1; goto end; /* break; */ - } + } - if (s->debug) { (void)BIO_flush(s->wbio); } + if (s->debug) { + (void)BIO_flush(s->wbio); + } - if ((cb != NULL) && (s->state != state)) - { - new_state=s->state; - s->state=state; - cb(s,SSL_CB_CONNECT_LOOP,1); - s->state=new_state; - } + if ((cb != NULL) && (s->state != state)) { + new_state = s->state; + s->state = state; + cb(s, SSL_CB_CONNECT_LOOP, 1); + s->state = new_state; } + } end: s->in_handshake--; if (buf != NULL) BUF_MEM_free(buf); if (cb != NULL) - cb(s,SSL_CB_CONNECT_EXIT,ret); - return(ret); - } + cb(s, SSL_CB_CONNECT_EXIT, ret); + return (ret); +} -static int ssl23_no_ssl2_ciphers(SSL *s) - { +static int +ssl23_no_ssl2_ciphers(SSL *s) +{ SSL_CIPHER *cipher; STACK_OF(SSL_CIPHER) *ciphers; int i; ciphers = SSL_get_ciphers(s); - for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) - { + for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) { cipher = sk_SSL_CIPHER_value(ciphers, i); if (cipher->algorithm_ssl == SSL_SSLV2) return 0; - } - return 1; } + return 1; +} /* Fill a ClientRandom or ServerRandom field of length len. Returns <= 0 * on failure, 1 on success. */ -int ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len) - { +int +ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len) +{ int send_time = 0; if (len < 4) @@ -281,22 +284,21 @@ int ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len) send_time = (s->mode & SSL_MODE_SEND_SERVERHELLO_TIME) != 0; else send_time = (s->mode & SSL_MODE_SEND_CLIENTHELLO_TIME) != 0; - if (send_time) - { + if (send_time) { unsigned long Time = (unsigned long)time(NULL); unsigned char *p = result; l2n(Time, p); - return RAND_pseudo_bytes(p, len-4); - } - else + return RAND_pseudo_bytes(p, len - 4); + } else return RAND_pseudo_bytes(result, len); - } +} -static int ssl23_client_hello(SSL *s) - { +static int +ssl23_client_hello(SSL *s) +{ unsigned char *buf; - unsigned char *p,*d; - int i,ch_len; + unsigned char *p, *d; + int i, ch_len; unsigned long l; int ssl2_compat; int version = 0, version_major, version_minor; @@ -320,14 +322,14 @@ static int ssl23_client_hello(SSL *s) * TLS1>=1, it would be insufficient to pass SSL_NO_TLSv1, the * answer is SSL_OP_NO_TLSv1|SSL_OP_NO_SSLv3|SSL_OP_NO_SSLv2. */ - mask = SSL_OP_NO_TLSv1_1|SSL_OP_NO_TLSv1 + mask = SSL_OP_NO_TLSv1_1|SSL_OP_NO_TLSv1 #if !defined(OPENSSL_NO_SSL3) - |SSL_OP_NO_SSLv3 + |SSL_OP_NO_SSLv3 #endif #if !defined(OPENSSL_NO_SSL2) - |(ssl2_compat?SSL_OP_NO_SSLv2:0) + |(ssl2_compat ? SSL_OP_NO_SSLv2 : 0) #endif - ; + ; #if !defined(OPENSSL_NO_TLS1_2_CLIENT) version = TLS1_2_VERSION; @@ -351,8 +353,7 @@ static int ssl23_client_hello(SSL *s) #endif #ifndef OPENSSL_NO_TLSEXT - if (version != SSL2_VERSION) - { + if (version != SSL2_VERSION) { /* have to disable SSL 2.0 compatibility if we need TLS extensions */ if (s->tlsext_hostname != NULL) @@ -363,67 +364,53 @@ static int ssl23_client_hello(SSL *s) if (s->ctx->tlsext_opaque_prf_input_callback != 0 || s->tlsext_opaque_prf_input != NULL) ssl2_compat = 0; #endif - } + } #endif - buf=(unsigned char *)s->init_buf->data; - if (s->state == SSL23_ST_CW_CLNT_HELLO_A) - { + buf = (unsigned char *)s->init_buf->data; + if (s->state == SSL23_ST_CW_CLNT_HELLO_A) { #if 0 /* don't reuse session-id's */ - if (!ssl_get_new_session(s,0)) - { - return(-1); - } + if (!ssl_get_new_session(s, 0)) { + return (-1); + } #endif - p=s->s3->client_random; + p = s->s3->client_random; if (ssl_fill_hello_random(s, 0, p, SSL3_RANDOM_SIZE) <= 0) return -1; - if (version == TLS1_2_VERSION) - { + if (version == TLS1_2_VERSION) { version_major = TLS1_2_VERSION_MAJOR; version_minor = TLS1_2_VERSION_MINOR; - } - else if (version == TLS1_1_VERSION) - { + } else if (version == TLS1_1_VERSION) { version_major = TLS1_1_VERSION_MAJOR; version_minor = TLS1_1_VERSION_MINOR; - } - else if (version == TLS1_VERSION) - { + } else if (version == TLS1_VERSION) { version_major = TLS1_VERSION_MAJOR; version_minor = TLS1_VERSION_MINOR; - } + } #ifdef OPENSSL_FIPS - else if(FIPS_mode()) - { + else if (FIPS_mode()) { SSLerr(SSL_F_SSL23_CLIENT_HELLO, - SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE); + SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE); return -1; - } + } #endif - else if (version == SSL3_VERSION) - { + else if (version == SSL3_VERSION) { version_major = SSL3_VERSION_MAJOR; version_minor = SSL3_VERSION_MINOR; - } - else if (version == SSL2_VERSION) - { + } else if (version == SSL2_VERSION) { version_major = SSL2_VERSION_MAJOR; version_minor = SSL2_VERSION_MINOR; - } - else - { - SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_PROTOCOLS_AVAILABLE); - return(-1); - } + } else { + SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_NO_PROTOCOLS_AVAILABLE); + return (-1); + } s->client_version = version; - if (ssl2_compat) - { + if (ssl2_compat) { /* create SSL 2.0 compatible Client Hello */ /* two byte record header will be written last */ @@ -433,28 +420,27 @@ static int ssl23_client_hello(SSL *s) *(d++) = SSL2_MT_CLIENT_HELLO; *(d++) = version_major; *(d++) = version_minor; - + /* Ciphers supported */ - i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),p,0); - if (i == 0) - { + i = ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), p, 0); + if (i == 0) { /* no ciphers */ - SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE); + SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_NO_CIPHERS_AVAILABLE); return -1; - } - s2n(i,d); - p+=i; - + } + s2n(i, d); + p += i; + /* put in the session-id length (zero since there is no reuse) */ #if 0 - s->session->session_id_length=0; + s->session->session_id_length = 0; #endif - s2n(0,d); + s2n(0, d); if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG) - ch_len=SSL2_CHALLENGE_LENGTH; + ch_len = SSL2_CHALLENGE_LENGTH; else - ch_len=SSL2_MAX_CHALLENGE_LENGTH; + ch_len = SSL2_MAX_CHALLENGE_LENGTH; /* write out sslv2 challenge */ /* Note that ch_len must be <= SSL3_RANDOM_SIZE (32), @@ -462,34 +448,32 @@ static int ssl23_client_hello(SSL *s) or SSL2_MAX_CHALLENGE_LENGTH (16), but leave the check in for futurproofing */ if (SSL3_RANDOM_SIZE < ch_len) - i=SSL3_RANDOM_SIZE; + i = SSL3_RANDOM_SIZE; else - i=ch_len; - s2n(i,d); - memset(&(s->s3->client_random[0]),0,SSL3_RANDOM_SIZE); - if (RAND_pseudo_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i) <= 0) + i = ch_len; + s2n(i, d); + memset(&(s->s3->client_random[0]), 0, SSL3_RANDOM_SIZE); + if (RAND_pseudo_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE - i]), i) <= 0) return -1; - memcpy(p,&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i); - p+=i; + memcpy(p, &(s->s3->client_random[SSL3_RANDOM_SIZE - i]), i); + p += i; - i= p- &(buf[2]); - buf[0]=((i>>8)&0xff)|0x80; - buf[1]=(i&0xff); + i = p- &(buf[2]); + buf[0] = ((i >> 8)&0xff)|0x80; + buf[1] = (i&0xff); /* number of bytes to write */ - s->init_num=i+2; - s->init_off=0; + s->init_num = i + 2; + s->init_off = 0; - ssl3_finish_mac(s,&(buf[2]),i); - } - else - { + ssl3_finish_mac(s, &(buf[2]), i); + } else { /* create Client Hello in SSL 3.0/TLS 1.0 format */ /* do the record header (5 bytes) and handshake message header (4 bytes) last */ d = p = &(buf[9]); - + *(p++) = version_major; *(p++) = version_minor; @@ -501,73 +485,68 @@ static int ssl23_client_hello(SSL *s) *(p++) = 0; /* Ciphers supported (using SSL 3.0/TLS 1.0 format) */ - i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),&(p[2]),ssl3_put_cipher_by_char); - if (i == 0) - { - SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE); + i = ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), &(p[2]), ssl3_put_cipher_by_char); + if (i == 0) { + SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_NO_CIPHERS_AVAILABLE); return -1; - } + } #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH /* Some servers hang if client hello > 256 bytes * as hack workaround chop number of supported ciphers * to keep it well below this if we use TLS v1.2 */ - if (TLS1_get_version(s) >= TLS1_2_VERSION - && i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH) + if (TLS1_get_version(s) >= TLS1_2_VERSION && + i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH) i = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1; #endif - s2n(i,p); - p+=i; + s2n(i, p); + p += i; /* COMPRESSION */ #ifdef OPENSSL_NO_COMP - *(p++)=1; + *(p++) = 1; #else - if ((s->options & SSL_OP_NO_COMPRESSION) - || !s->ctx->comp_methods) - j=0; + if ((s->options & SSL_OP_NO_COMPRESSION) || + !s->ctx->comp_methods) + j = 0; else - j=sk_SSL_COMP_num(s->ctx->comp_methods); - *(p++)=1+j; - for (i=0; ictx->comp_methods,i); - *(p++)=comp->id; - } + j = sk_SSL_COMP_num(s->ctx->comp_methods); + *(p++) = 1 + j; + for (i = 0; i < j; i++) { + comp = sk_SSL_COMP_value(s->ctx->comp_methods, i); + *(p++) = comp->id; + } #endif *(p++)=0; /* Add the NULL method */ #ifndef OPENSSL_NO_TLSEXT /* TLS extensions*/ - if (ssl_prepare_clienthello_tlsext(s) <= 0) - { - SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_CLIENTHELLO_TLSEXT); + if (ssl_prepare_clienthello_tlsext(s) <= 0) { + SSLerr(SSL_F_SSL23_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT); return -1; - } - if ((p = ssl_add_clienthello_tlsext(s, p, buf+SSL3_RT_MAX_PLAIN_LENGTH)) == NULL) - { - SSLerr(SSL_F_SSL23_CLIENT_HELLO,ERR_R_INTERNAL_ERROR); + } + if ((p = ssl_add_clienthello_tlsext(s, p, buf + SSL3_RT_MAX_PLAIN_LENGTH)) == NULL) { + SSLerr(SSL_F_SSL23_CLIENT_HELLO, ERR_R_INTERNAL_ERROR); return -1; - } + } #endif - - l = p-d; + + l = p - d; /* fill in 4-byte handshake header */ - d=&(buf[5]); - *(d++)=SSL3_MT_CLIENT_HELLO; - l2n3(l,d); + d = &(buf[5]); + *(d++) = SSL3_MT_CLIENT_HELLO; + l2n3(l, d); l += 4; - if (l > SSL3_RT_MAX_PLAIN_LENGTH) - { - SSLerr(SSL_F_SSL23_CLIENT_HELLO,ERR_R_INTERNAL_ERROR); + if (l > SSL3_RT_MAX_PLAIN_LENGTH) { + SSLerr(SSL_F_SSL23_CLIENT_HELLO, ERR_R_INTERNAL_ERROR); return -1; - } - + } + /* fill in 5-byte record header */ - d=buf; + d = buf; *(d++) = SSL3_RT_HANDSHAKE; *(d++) = version_major; /* Some servers hang if we use long client hellos @@ -577,54 +556,54 @@ static int ssl23_client_hello(SSL *s) *(d++) = 1; else *(d++) = version_minor; - s2n((int)l,d); + s2n((int)l, d); /* number of bytes to write */ - s->init_num=p-buf; - s->init_off=0; - - ssl3_finish_mac(s,&(buf[5]), s->init_num - 5); - } + s->init_num = p - buf; + s->init_off = 0; - s->state=SSL23_ST_CW_CLNT_HELLO_B; - s->init_off=0; + ssl3_finish_mac(s, &(buf[5]), s->init_num - 5); } + s->state = SSL23_ST_CW_CLNT_HELLO_B; + s->init_off = 0; + } + /* SSL3_ST_CW_CLNT_HELLO_B */ ret = ssl23_write_bytes(s); - if ((ret >= 2) && s->msg_callback) - { + if ((ret >= 2) && s->msg_callback) { /* Client Hello has been sent; tell msg_callback */ if (ssl2_compat) - s->msg_callback(1, SSL2_VERSION, 0, s->init_buf->data+2, ret-2, s, s->msg_callback_arg); + s->msg_callback(1, SSL2_VERSION, 0, s->init_buf->data + 2, ret - 2, s, s->msg_callback_arg); else - s->msg_callback(1, version, SSL3_RT_HANDSHAKE, s->init_buf->data+5, ret-5, s, s->msg_callback_arg); - } + s->msg_callback(1, version, SSL3_RT_HANDSHAKE, s->init_buf->data + 5, ret - 5, s, s->msg_callback_arg); + } return ret; - } +} -static int ssl23_get_server_hello(SSL *s) - { +static int +ssl23_get_server_hello(SSL *s) +{ char buf[8]; unsigned char *p; int i; int n; - n=ssl23_read_bytes(s,7); + n = ssl23_read_bytes(s, 7); - if (n != 7) return(n); - p=s->packet; + if (n != 7) + return (n); + p = s->packet; - memcpy(buf,p,n); + memcpy(buf, p, n); if ((p[0] & 0x80) && (p[2] == SSL2_MT_SERVER_HELLO) && - (p[5] == 0x00) && (p[6] == 0x02)) - { + (p[5] == 0x00) && (p[6] == 0x02)) { #ifdef OPENSSL_NO_SSL2 - SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL); + SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL); goto err; #else /* we are talking sslv2 */ @@ -632,169 +611,150 @@ static int ssl23_get_server_hello(SSL *s) * sslv2 stuff. */ int ch_len; - if (s->options & SSL_OP_NO_SSLv2) - { - SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL); + if (s->options & SSL_OP_NO_SSLv2) { + SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL); goto err; - } - if (s->s2 == NULL) - { + } + if (s->s2 == NULL) { if (!ssl2_new(s)) goto err; - } - else + } else ssl2_clear(s); if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG) - ch_len=SSL2_CHALLENGE_LENGTH; + ch_len = SSL2_CHALLENGE_LENGTH; else - ch_len=SSL2_MAX_CHALLENGE_LENGTH; + ch_len = SSL2_MAX_CHALLENGE_LENGTH; /* write out sslv2 challenge */ /* Note that ch_len must be <= SSL3_RANDOM_SIZE (32), because it is one of SSL2_MAX_CHALLENGE_LENGTH (32) or SSL2_MAX_CHALLENGE_LENGTH (16), but leave the check in for futurproofing */ - i=(SSL3_RANDOM_SIZE < ch_len) - ?SSL3_RANDOM_SIZE:ch_len; - s->s2->challenge_length=i; + i = (SSL3_RANDOM_SIZE < ch_len) ? SSL3_RANDOM_SIZE : ch_len; + s->s2->challenge_length = i; memcpy(s->s2->challenge, - &(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i); + &(s->s3->client_random[SSL3_RANDOM_SIZE - i]), i); - if (s->s3 != NULL) ssl3_free(s); + if (s->s3 != NULL) + ssl3_free(s); if (!BUF_MEM_grow_clean(s->init_buf, - SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) - { - SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,ERR_R_BUF_LIB); + SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) { + SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, ERR_R_BUF_LIB); goto err; - } + } - s->state=SSL2_ST_GET_SERVER_HELLO_A; + s->state = SSL2_ST_GET_SERVER_HELLO_A; if (!(s->client_version == SSL2_VERSION)) /* use special padding (SSL 3.0 draft/RFC 2246, App. E.2) */ - s->s2->ssl2_rollback=1; + s->s2->ssl2_rollback = 1; /* setup the 7 bytes we have read so we get them from * the sslv2 buffer */ - s->rstate=SSL_ST_READ_HEADER; - s->packet_length=n; - s->packet= &(s->s2->rbuf[0]); - memcpy(s->packet,buf,n); - s->s2->rbuf_left=n; - s->s2->rbuf_offs=0; + s->rstate = SSL_ST_READ_HEADER; + s->packet_length = n; + s->packet = &(s->s2->rbuf[0]); + memcpy(s->packet, buf, n); + s->s2->rbuf_left = n; + s->s2->rbuf_offs = 0; /* we have already written one */ - s->s2->write_sequence=1; + s->s2->write_sequence = 1; - s->method=SSLv2_client_method(); - s->handshake_func=s->method->ssl_connect; + s->method = SSLv2_client_method(); + s->handshake_func = s->method->ssl_connect; #endif - } - else if (p[1] == SSL3_VERSION_MAJOR && - p[2] <= TLS1_2_VERSION_MINOR && - ((p[0] == SSL3_RT_HANDSHAKE && p[5] == SSL3_MT_SERVER_HELLO) || - (p[0] == SSL3_RT_ALERT && p[3] == 0 && p[4] == 2))) - { + } else if (p[1] == SSL3_VERSION_MAJOR && + p[2] <= TLS1_2_VERSION_MINOR && + ((p[0] == SSL3_RT_HANDSHAKE && p[5] == SSL3_MT_SERVER_HELLO) || + (p[0] == SSL3_RT_ALERT && p[3] == 0 && p[4] == 2))) { /* we have sslv3 or tls1 (server hello or alert) */ if ((p[2] == SSL3_VERSION_MINOR) && - !(s->options & SSL_OP_NO_SSLv3)) - { + !(s->options & SSL_OP_NO_SSLv3)) { #ifdef OPENSSL_FIPS - if(FIPS_mode()) - { + if (FIPS_mode()) { SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, - SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE); + SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE); goto err; - } -#endif - s->version=SSL3_VERSION; - s->method=SSLv3_client_method(); - } - else if ((p[2] == TLS1_VERSION_MINOR) && - !(s->options & SSL_OP_NO_TLSv1)) - { - s->version=TLS1_VERSION; - s->method=TLSv1_client_method(); } - else if ((p[2] == TLS1_1_VERSION_MINOR) && - !(s->options & SSL_OP_NO_TLSv1_1)) - { - s->version=TLS1_1_VERSION; - s->method=TLSv1_1_client_method(); - } - else if ((p[2] == TLS1_2_VERSION_MINOR) && - !(s->options & SSL_OP_NO_TLSv1_2)) - { - s->version=TLS1_2_VERSION; - s->method=TLSv1_2_client_method(); - } - else - { - SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL); +#endif + s->version = SSL3_VERSION; + s->method = SSLv3_client_method(); + } else if ((p[2] == TLS1_VERSION_MINOR) && + !(s->options & SSL_OP_NO_TLSv1)) { + s->version = TLS1_VERSION; + s->method = TLSv1_client_method(); + } else if ((p[2] == TLS1_1_VERSION_MINOR) && + !(s->options & SSL_OP_NO_TLSv1_1)) { + s->version = TLS1_1_VERSION; + s->method = TLSv1_1_client_method(); + } else if ((p[2] == TLS1_2_VERSION_MINOR) && + !(s->options & SSL_OP_NO_TLSv1_2)) { + s->version = TLS1_2_VERSION; + s->method = TLSv1_2_client_method(); + } else { + SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL); goto err; - } + } - if (p[0] == SSL3_RT_ALERT && p[5] != SSL3_AL_WARNING) - { + if (p[0] == SSL3_RT_ALERT && p[5] != SSL3_AL_WARNING) { /* fatal alert */ - void (*cb)(const SSL *ssl,int type,int val)=NULL; + void (*cb)(const SSL *ssl, int type, int val) = NULL; int j; if (s->info_callback != NULL) - cb=s->info_callback; + cb = s->info_callback; else if (s->ctx->info_callback != NULL) - cb=s->ctx->info_callback; - - i=p[5]; - if (cb != NULL) - { - j=(i<<8)|p[6]; - cb(s,SSL_CB_READ_ALERT,j); - } - + cb = s->ctx->info_callback; + + i = p[5]; + if (cb != NULL) { + j = (i << 8) | p[6]; + cb(s, SSL_CB_READ_ALERT, j); + } + if (s->msg_callback) - s->msg_callback(0, s->version, SSL3_RT_ALERT, p+5, 2, s, s->msg_callback_arg); + s->msg_callback(0, s->version, SSL3_RT_ALERT, p + 5, 2, s, s->msg_callback_arg); - s->rwstate=SSL_NOTHING; - SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_AD_REASON_OFFSET+p[6]); + s->rwstate = SSL_NOTHING; + SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_AD_REASON_OFFSET + p[6]); goto err; - } + } - if (!ssl_init_wbio_buffer(s,1)) goto err; + if (!ssl_init_wbio_buffer(s, 1)) + goto err; /* we are in this state */ - s->state=SSL3_ST_CR_SRVR_HELLO_A; + s->state = SSL3_ST_CR_SRVR_HELLO_A; /* put the 7 bytes we have read into the input buffer * for SSLv3 */ - s->rstate=SSL_ST_READ_HEADER; - s->packet_length=n; + 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; - - s->handshake_func=s->method->ssl_connect; - } - else - { - SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNKNOWN_PROTOCOL); + s->packet = &(s->s3->rbuf.buf[0]); + memcpy(s->packet, buf, n); + s->s3->rbuf.left = n; + s->s3->rbuf.offset = 0; + + s->handshake_func = s->method->ssl_connect; + } else { + SSLerr(SSL_F_SSL23_GET_SERVER_HELLO, SSL_R_UNKNOWN_PROTOCOL); goto err; - } - s->init_num=0; + } + s->init_num = 0; /* Since, if we are sending a ssl23 client hello, we are not * reusing a session-id */ - if (!ssl_get_new_session(s,0)) + if (!ssl_get_new_session(s, 0)) goto err; - return(SSL_connect(s)); + return (SSL_connect(s)); err: - return(-1); - } + return (-1); +} diff --git a/src/lib/libssl/src/ssl/s23_lib.c b/src/lib/libssl/src/ssl/s23_lib.c index a6285b767f..3a4d5a6ecb 100644 --- a/src/lib/libssl/src/ssl/s23_lib.c +++ b/src/lib/libssl/src/ssl/s23_lib.c @@ -60,128 +60,126 @@ #include #include "ssl_locl.h" -long ssl23_default_timeout(void) - { - return(300); - } +long +ssl23_default_timeout(void) +{ + return (300); +} -int ssl23_num_ciphers(void) - { +int +ssl23_num_ciphers(void) +{ return(ssl3_num_ciphers() #ifndef OPENSSL_NO_SSL2 - + ssl2_num_ciphers() + + ssl2_num_ciphers() #endif - ); - } + ); +} -const SSL_CIPHER *ssl23_get_cipher(unsigned int u) - { - unsigned int uu=ssl3_num_ciphers(); +const SSL_CIPHER +*ssl23_get_cipher(unsigned int u) +{ + unsigned int uu = ssl3_num_ciphers(); if (u < uu) - return(ssl3_get_cipher(u)); + return (ssl3_get_cipher(u)); else #ifndef OPENSSL_NO_SSL2 - return(ssl2_get_cipher(u-uu)); + return (ssl2_get_cipher(u - uu)); #else - return(NULL); + return (NULL); #endif - } +} /* This function needs to check if the ciphers required are actually * available */ -const SSL_CIPHER *ssl23_get_cipher_by_char(const unsigned char *p) - { +const SSL_CIPHER +*ssl23_get_cipher_by_char(const unsigned char *p) +{ const SSL_CIPHER *cp; - cp=ssl3_get_cipher_by_char(p); + cp = ssl3_get_cipher_by_char(p); #ifndef OPENSSL_NO_SSL2 if (cp == NULL) - cp=ssl2_get_cipher_by_char(p); + cp = ssl2_get_cipher_by_char(p); #endif - return(cp); - } + return (cp); +} -int ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p) - { +int +ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p) +{ long l; /* We can write SSLv2 and SSLv3 ciphers */ - if (p != NULL) - { - l=c->id; - p[0]=((unsigned char)(l>>16L))&0xFF; - p[1]=((unsigned char)(l>> 8L))&0xFF; - p[2]=((unsigned char)(l ))&0xFF; - } - return(3); + if (p != NULL) { + l = c->id; + p[0] = ((unsigned char)(l >> 16L))&0xFF; + p[1] = ((unsigned char)(l >> 8L))&0xFF; + p[2] = ((unsigned char)(l ))&0xFF; } + return (3); +} -int ssl23_read(SSL *s, void *buf, int len) - { +int +ssl23_read(SSL *s, void *buf, int len) +{ int n; errno = 0; - if (SSL_in_init(s) && (!s->in_handshake)) - { - n=s->handshake_func(s); - if (n < 0) return(n); - if (n == 0) - { - SSLerr(SSL_F_SSL23_READ,SSL_R_SSL_HANDSHAKE_FAILURE); - return(-1); - } - return(SSL_read(s,buf,len)); + if (SSL_in_init(s) && (!s->in_handshake)) { + n = s->handshake_func(s); + if (n < 0) + return (n); + if (n == 0) { + SSLerr(SSL_F_SSL23_READ, SSL_R_SSL_HANDSHAKE_FAILURE); + return (-1); } - else - { + return (SSL_read(s, buf, len)); + } else { ssl_undefined_function(s); - return(-1); - } + return (-1); } +} -int ssl23_peek(SSL *s, void *buf, int len) - { +int +ssl23_peek(SSL *s, void *buf, int len) +{ int n; errno = 0; - if (SSL_in_init(s) && (!s->in_handshake)) - { - n=s->handshake_func(s); - if (n < 0) return(n); - if (n == 0) - { - SSLerr(SSL_F_SSL23_PEEK,SSL_R_SSL_HANDSHAKE_FAILURE); - return(-1); - } - return(SSL_peek(s,buf,len)); + if (SSL_in_init(s) && (!s->in_handshake)) { + n = s->handshake_func(s); + if (n < 0) + return (n); + if (n == 0) { + SSLerr(SSL_F_SSL23_PEEK, SSL_R_SSL_HANDSHAKE_FAILURE); + return (-1); } - else - { + return (SSL_peek(s, buf, len)); + } else { ssl_undefined_function(s); - return(-1); - } + return (-1); } +} -int ssl23_write(SSL *s, const void *buf, int len) - { +int +ssl23_write(SSL *s, const void *buf, int len) +{ int n; errno = 0; - if (SSL_in_init(s) && (!s->in_handshake)) - { - n=s->handshake_func(s); - if (n < 0) return(n); - if (n == 0) - { - SSLerr(SSL_F_SSL23_WRITE,SSL_R_SSL_HANDSHAKE_FAILURE); - return(-1); - } - return(SSL_write(s,buf,len)); + if (SSL_in_init(s) && (!s->in_handshake)) { + n = s->handshake_func(s); + if (n < 0) + return (n); + if (n == 0) { + SSLerr(SSL_F_SSL23_WRITE, SSL_R_SSL_HANDSHAKE_FAILURE); + return (-1); } - else - { + return (SSL_write(s, buf, len)); + } else { ssl_undefined_function(s); - return(-1); - } + return (-1); } +} diff --git a/src/lib/libssl/src/ssl/s23_meth.c b/src/lib/libssl/src/ssl/s23_meth.c index 40eae0f0be..ca1bb6819f 100644 --- a/src/lib/libssl/src/ssl/s23_meth.c +++ b/src/lib/libssl/src/ssl/s23_meth.c @@ -61,32 +61,31 @@ #include "ssl_locl.h" static const SSL_METHOD *ssl23_get_method(int ver); -static const SSL_METHOD *ssl23_get_method(int ver) - { +static const SSL_METHOD +*ssl23_get_method(int ver) +{ #ifndef OPENSSL_NO_SSL2 if (ver == SSL2_VERSION) - return(SSLv2_method()); + return (SSLv2_method()); else #endif #ifndef OPENSSL_NO_SSL3 if (ver == SSL3_VERSION) - return(SSLv3_method()); + return (SSLv3_method()); else #endif #ifndef OPENSSL_NO_TLS1 if (ver == TLS1_VERSION) - return(TLSv1_method()); + return (TLSv1_method()); else if (ver == TLS1_1_VERSION) - return(TLSv1_1_method()); + return (TLSv1_1_method()); else if (ver == TLS1_2_VERSION) - return(TLSv1_2_method()); + return (TLSv1_2_method()); else #endif - return(NULL); - } + return (NULL); +} IMPLEMENT_ssl23_meth_func(SSLv23_method, - ssl23_accept, - ssl23_connect, - ssl23_get_method) + ssl23_accept, ssl23_connect, ssl23_get_method) diff --git a/src/lib/libssl/src/ssl/s23_pkt.c b/src/lib/libssl/src/ssl/s23_pkt.c index eba8d9d8fc..28d07a2212 100644 --- a/src/lib/libssl/src/ssl/s23_pkt.c +++ b/src/lib/libssl/src/ssl/s23_pkt.c @@ -62,55 +62,53 @@ #include #include -int ssl23_write_bytes(SSL *s) - { - int i,num,tot; +int +ssl23_write_bytes(SSL *s) +{ + int i, num, tot; char *buf; - buf=s->init_buf->data; - tot=s->init_off; - num=s->init_num; - for (;;) - { - s->rwstate=SSL_WRITING; - i=BIO_write(s->wbio,&(buf[tot]),num); - if (i <= 0) - { - s->init_off=tot; - s->init_num=num; - return(i); - } - s->rwstate=SSL_NOTHING; - if (i == num) return(tot+i); - - num-=i; - tot+=i; + buf = s->init_buf->data; + tot = s->init_off; + num = s->init_num; + for (;;) { + s->rwstate = SSL_WRITING; + i = BIO_write(s->wbio, &(buf[tot]), num); + if (i <= 0) { + s->init_off = tot; + s->init_num = num; + return (i); } + s->rwstate = SSL_NOTHING; + if (i == num) + return (tot + i); + + num -= i; + tot += i; } +} /* return regularly only when we have read (at least) 'n' bytes */ -int ssl23_read_bytes(SSL *s, int n) - { +int +ssl23_read_bytes(SSL *s, int n) +{ unsigned char *p; int j; - if (s->packet_length < (unsigned int)n) - { - p=s->packet; + if (s->packet_length < (unsigned int)n) { + p = s->packet; - for (;;) - { - s->rwstate=SSL_READING; - j=BIO_read(s->rbio,(char *)&(p[s->packet_length]), - n-s->packet_length); + for (;;) { + s->rwstate = SSL_READING; + j = BIO_read(s->rbio,(char *)&(p[s->packet_length]), + n - s->packet_length); if (j <= 0) - return(j); - s->rwstate=SSL_NOTHING; - s->packet_length+=j; + return (j); + s->rwstate = SSL_NOTHING; + s->packet_length += j; if (s->packet_length >= (unsigned int)n) - return(s->packet_length); - } + return (s->packet_length); } - return(n); } - + return (n); +} diff --git a/src/lib/libssl/src/ssl/s23_srvr.c b/src/lib/libssl/src/ssl/s23_srvr.c index 2ac8786c62..35db7b4992 100644 --- a/src/lib/libssl/src/ssl/s23_srvr.c +++ b/src/lib/libssl/src/ssl/s23_srvr.c @@ -121,227 +121,209 @@ static const SSL_METHOD *ssl23_get_server_method(int ver); int ssl23_get_client_hello(SSL *s); -static const 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()); + return (SSLv2_server_method()); #endif if (ver == SSL3_VERSION) - return(SSLv3_server_method()); + return (SSLv3_server_method()); else if (ver == TLS1_VERSION) - return(TLSv1_server_method()); + return (TLSv1_server_method()); else if (ver == TLS1_1_VERSION) - return(TLSv1_1_server_method()); + return (TLSv1_1_server_method()); else if (ver == TLS1_2_VERSION) - return(TLSv1_2_server_method()); + return (TLSv1_2_server_method()); else - return(NULL); - } + return (NULL); +} IMPLEMENT_ssl23_meth_func(SSLv23_server_method, - ssl23_accept, - ssl_undefined_function, - ssl23_get_server_method) + ssl23_accept, ssl_undefined_function, ssl23_get_server_method) -int ssl23_accept(SSL *s) - { +int +ssl23_accept(SSL *s) +{ BUF_MEM *buf; - unsigned long Time=(unsigned long)time(NULL); - void (*cb)(const SSL *ssl,int type,int val)=NULL; - int ret= -1; - int new_state,state; + unsigned long Time = (unsigned long)time(NULL); + void (*cb)(const SSL *ssl, int type, int val) = NULL; + int ret = -1; + int new_state, state; - RAND_add(&Time,sizeof(Time),0); + RAND_add(&Time, sizeof(Time), 0); ERR_clear_error(); errno = 0; if (s->info_callback != NULL) - cb=s->info_callback; + cb = s->info_callback; else if (s->ctx->info_callback != NULL) - cb=s->ctx->info_callback; - + cb = s->ctx->info_callback; + s->in_handshake++; - if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); + if (!SSL_in_init(s) || SSL_in_before(s)) + SSL_clear(s); - for (;;) - { - state=s->state; + for (;;) { + state = s->state; - switch(s->state) - { + switch (s->state) { case SSL_ST_BEFORE: case SSL_ST_ACCEPT: case SSL_ST_BEFORE|SSL_ST_ACCEPT: case SSL_ST_OK|SSL_ST_ACCEPT: - s->server=1; - if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1); + s->server = 1; + if (cb != NULL) + cb(s, SSL_CB_HANDSHAKE_START, 1); /* s->version=SSL3_VERSION; */ - s->type=SSL_ST_ACCEPT; + s->type = SSL_ST_ACCEPT; - if (s->init_buf == NULL) - { - if ((buf=BUF_MEM_new()) == NULL) - { - ret= -1; + if (s->init_buf == NULL) { + if ((buf = BUF_MEM_new()) == NULL) { + ret = -1; goto end; - } - if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH)) - { - ret= -1; + } + if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) { + ret = -1; goto end; - } - s->init_buf=buf; } + s->init_buf = buf; + } ssl3_init_finished_mac(s); - s->state=SSL23_ST_SR_CLNT_HELLO_A; + s->state = SSL23_ST_SR_CLNT_HELLO_A; s->ctx->stats.sess_accept++; - s->init_num=0; + s->init_num = 0; break; case SSL23_ST_SR_CLNT_HELLO_A: case SSL23_ST_SR_CLNT_HELLO_B: - s->shutdown=0; - ret=ssl23_get_client_hello(s); - if (ret >= 0) cb=NULL; + s->shutdown = 0; + ret = ssl23_get_client_hello(s); + if (ret >= 0) + cb = NULL; goto end; /* break; */ default: - SSLerr(SSL_F_SSL23_ACCEPT,SSL_R_UNKNOWN_STATE); - ret= -1; + SSLerr(SSL_F_SSL23_ACCEPT, SSL_R_UNKNOWN_STATE); + ret = -1; goto end; /* break; */ - } + } - if ((cb != NULL) && (s->state != state)) - { - new_state=s->state; - s->state=state; - cb(s,SSL_CB_ACCEPT_LOOP,1); - s->state=new_state; - } + if ((cb != NULL) && (s->state != state)) { + new_state = s->state; + s->state = state; + cb(s, SSL_CB_ACCEPT_LOOP, 1); + s->state = new_state; } + } end: s->in_handshake--; if (cb != NULL) - cb(s,SSL_CB_ACCEPT_EXIT,ret); - return(ret); - } + cb(s, SSL_CB_ACCEPT_EXIT, ret); + return (ret); +} -int ssl23_get_client_hello(SSL *s) - { +int +ssl23_get_client_hello(SSL *s) +{ char buf_space[11]; /* Request this many bytes in initial read. - * We can detect SSL 3.0/TLS 1.0 Client Hellos - * ('type == 3') correctly only when the following - * is in a single record, which is not guaranteed by - * the protocol specification: - * Byte Content - * 0 type \ + * We can detect SSL 3.0/TLS 1.0 Client Hellos + * ('type == 3') correctly only when the following + * is in a single record, which is not guaranteed by + * the protocol specification: + * Byte Content + * 0 type \ * 1/2 version > record header - * 3/4 length / - * 5 msg_type \ + * 3/4 length / + * 5 msg_type \ * 6-8 length > Client Hello message - * 9/10 client_version / + * 9/10 client_version / */ - char *buf= &(buf_space[0]); - unsigned char *p,*d,*d_len,*dd; + char *buf = &(buf_space[0]); + unsigned char *p, *d, *d_len, *dd; unsigned int i; - unsigned int csl,sil,cl; - int n=0,j; - int type=0; + unsigned int csl, sil, cl; + int n = 0, j; + int type = 0; int v[2]; - if (s->state == SSL23_ST_SR_CLNT_HELLO_A) - { + if (s->state == SSL23_ST_SR_CLNT_HELLO_A) { /* read the initial header */ - v[0]=v[1]=0; + v[0] = v[1] = 0; - if (!ssl3_setup_buffers(s)) goto err; + if (!ssl3_setup_buffers(s)) + goto err; - n=ssl23_read_bytes(s, sizeof buf_space); - if (n != sizeof buf_space) return(n); /* n == -1 || n == 0 */ + n = ssl23_read_bytes(s, sizeof buf_space); + if (n != sizeof buf_space) + return(n); /* n == -1 || n == 0 */ - p=s->packet; + p = s->packet; - memcpy(buf,p,n); + memcpy(buf, p, n); - if ((p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO)) - { + if ((p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO)) { /* * SSLv2 header */ - if ((p[3] == 0x00) && (p[4] == 0x02)) - { - v[0]=p[3]; v[1]=p[4]; + if ((p[3] == 0x00) && (p[4] == 0x02)) { + v[0] = p[3]; + v[1] = p[4]; /* SSLv2 */ if (!(s->options & SSL_OP_NO_SSLv2)) - type=1; - } - else if (p[3] == SSL3_VERSION_MAJOR) - { - v[0]=p[3]; v[1]=p[4]; + type = 1; + } else if (p[3] == SSL3_VERSION_MAJOR) { + v[0] = p[3]; + v[1] = p[4]; /* SSLv3/TLSv1 */ - if (p[4] >= TLS1_VERSION_MINOR) - { + if (p[4] >= TLS1_VERSION_MINOR) { if (p[4] >= TLS1_2_VERSION_MINOR && - !(s->options & SSL_OP_NO_TLSv1_2)) - { - s->version=TLS1_2_VERSION; - s->state=SSL23_ST_SR_CLNT_HELLO_B; - } - else if (p[4] >= TLS1_1_VERSION_MINOR && - !(s->options & SSL_OP_NO_TLSv1_1)) - { - s->version=TLS1_1_VERSION; + !(s->options & SSL_OP_NO_TLSv1_2)) { + s->version = TLS1_2_VERSION; + s->state = SSL23_ST_SR_CLNT_HELLO_B; + } else if (p[4] >= TLS1_1_VERSION_MINOR && + !(s->options & SSL_OP_NO_TLSv1_1)) { + s->version = TLS1_1_VERSION; /* type=2; */ /* done later to survive restarts */ - s->state=SSL23_ST_SR_CLNT_HELLO_B; - } - else if (!(s->options & SSL_OP_NO_TLSv1)) - { - s->version=TLS1_VERSION; + s->state = SSL23_ST_SR_CLNT_HELLO_B; + } else if (!(s->options & SSL_OP_NO_TLSv1)) { + s->version = TLS1_VERSION; /* type=2; */ /* done later to survive restarts */ - s->state=SSL23_ST_SR_CLNT_HELLO_B; - } - else if (!(s->options & SSL_OP_NO_SSLv3)) - { - s->version=SSL3_VERSION; + s->state = SSL23_ST_SR_CLNT_HELLO_B; + } else if (!(s->options & SSL_OP_NO_SSLv3)) { + s->version = SSL3_VERSION; /* type=2; */ - s->state=SSL23_ST_SR_CLNT_HELLO_B; - } - else if (!(s->options & SSL_OP_NO_SSLv2)) - { - type=1; - } + s->state = SSL23_ST_SR_CLNT_HELLO_B; + } else if (!(s->options & SSL_OP_NO_SSLv2)) { + type = 1; } - else if (!(s->options & SSL_OP_NO_SSLv3)) - { - s->version=SSL3_VERSION; + } else if (!(s->options & SSL_OP_NO_SSLv3)) { + s->version = SSL3_VERSION; /* type=2; */ - s->state=SSL23_ST_SR_CLNT_HELLO_B; - } - else if (!(s->options & SSL_OP_NO_SSLv2)) - type=1; + s->state = SSL23_ST_SR_CLNT_HELLO_B; + } else if (!(s->options & SSL_OP_NO_SSLv2)) + type = 1; - } } - else if ((p[0] == SSL3_RT_HANDSHAKE) && - (p[1] == SSL3_VERSION_MAJOR) && - (p[5] == SSL3_MT_CLIENT_HELLO) && - ((p[3] == 0 && p[4] < 5 /* silly record length? */) - || (p[9] >= p[1]))) - { + } else if ((p[0] == SSL3_RT_HANDSHAKE) && + (p[1] == SSL3_VERSION_MAJOR) && + (p[5] == SSL3_MT_CLIENT_HELLO) && + ((p[3] == 0 && p[4] < 5 /* silly record length? */) + || (p[9] >= p[1]))) { /* * SSLv3 or tls1 header */ - - v[0]=p[1]; /* major version (= SSL3_VERSION_MAJOR) */ + + v[0] = p[1]; /* major version (= SSL3_VERSION_MAJOR) */ /* We must look at client_version inside the Client Hello message * to get the correct minor version. * However if we have only a pathologically small fragment of the @@ -350,127 +332,108 @@ int ssl23_get_client_hello(SSL *s) * No known SSL 3.0 client fragments ClientHello like this, * so we simply assume TLS 1.0 to avoid protocol version downgrade * attacks. */ - if (p[3] == 0 && p[4] < 6) - { + if (p[3] == 0 && p[4] < 6) { #if 0 - SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_SMALL); + SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_RECORD_TOO_SMALL); goto err; #else v[1] = TLS1_VERSION_MINOR; #endif - } + } /* if major version number > 3 set minor to a value * which will use the highest version 3 we support. * If TLS 2.0 ever appears we will need to revise * this.... */ else if (p[9] > SSL3_VERSION_MAJOR) - v[1]=0xff; + v[1] = 0xff; else - v[1]=p[10]; /* minor version according to client_version */ - if (v[1] >= TLS1_VERSION_MINOR) - { + v[1] = p[10]; /* minor version according to client_version */ + if (v[1] >= TLS1_VERSION_MINOR) { if (v[1] >= TLS1_2_VERSION_MINOR && - !(s->options & SSL_OP_NO_TLSv1_2)) - { - s->version=TLS1_2_VERSION; - type=3; - } - else if (v[1] >= TLS1_1_VERSION_MINOR && - !(s->options & SSL_OP_NO_TLSv1_1)) - { - s->version=TLS1_1_VERSION; - type=3; - } - else if (!(s->options & SSL_OP_NO_TLSv1)) - { - s->version=TLS1_VERSION; - type=3; - } - else if (!(s->options & SSL_OP_NO_SSLv3)) - { - s->version=SSL3_VERSION; - type=3; - } + !(s->options & SSL_OP_NO_TLSv1_2)) { + s->version = TLS1_2_VERSION; + type = 3; + } else if (v[1] >= TLS1_1_VERSION_MINOR && + !(s->options & SSL_OP_NO_TLSv1_1)) { + s->version = TLS1_1_VERSION; + type = 3; + } else if (!(s->options & SSL_OP_NO_TLSv1)) { + s->version = TLS1_VERSION; + type = 3; + } else if (!(s->options & SSL_OP_NO_SSLv3)) { + s->version = SSL3_VERSION; + type = 3; } - else - { + } else { /* client requests SSL 3.0 */ - if (!(s->options & SSL_OP_NO_SSLv3)) - { - s->version=SSL3_VERSION; - type=3; - } - else if (!(s->options & SSL_OP_NO_TLSv1)) - { + if (!(s->options & SSL_OP_NO_SSLv3)) { + s->version = SSL3_VERSION; + type = 3; + } else if (!(s->options & SSL_OP_NO_TLSv1)) { /* we won't be able to use TLS of course, * but this will send an appropriate alert */ - s->version=TLS1_VERSION; - type=3; - } + s->version = TLS1_VERSION; + type = 3; } } - else if ((strncmp("GET ", (char *)p,4) == 0) || - (strncmp("POST ",(char *)p,5) == 0) || - (strncmp("HEAD ",(char *)p,5) == 0) || - (strncmp("PUT ", (char *)p,4) == 0)) - { - SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTP_REQUEST); + } + else if ((strncmp("GET ", (char *)p, 4) == 0) || + (strncmp("POST ",(char *)p, 5) == 0) || + (strncmp("HEAD ",(char *)p, 5) == 0) || + (strncmp("PUT ", (char *)p, 4) == 0)) { + 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); + } 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)) - { + if (FIPS_mode() && (s->version < TLS1_VERSION)) { SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, - SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE); + SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE); goto err; - } + } #endif - if (s->state == SSL23_ST_SR_CLNT_HELLO_B) - { + 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; + type = 2; + p = s->packet; v[0] = p[3]; /* == SSL3_VERSION_MAJOR */ v[1] = p[4]; - n=((p[0]&0x7f)<<8)|p[1]; - if (n > (1024*4)) - { - SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_LARGE); + n = ((p[0] & 0x7f) << 8) | p[1]; + if (n > (1024 * 4)) { + 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); + j = ssl23_read_bytes(s, n + 2); + if (j <= 0) + return (j); - ssl3_finish_mac(s, s->packet+2, s->packet_length-2); + 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) /* We can't have TLS extensions in SSL 2.0 format - * Client Hello, can we? Error condition should be + 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) /* 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); + { + SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_RECORD_LENGTH_MISMATCH); goto err; - } + } /* record header: msg_type ... */ *(d++) = SSL3_MT_CLIENT_HELLO; @@ -484,130 +447,122 @@ int ssl23_get_client_hello(SSL *s) /* lets populate the random area */ /* get the challenge_length */ - i=(cl > SSL3_RANDOM_SIZE)?SSL3_RANDOM_SIZE:cl; - memset(d,0,SSL3_RANDOM_SIZE); - memcpy(&(d[SSL3_RANDOM_SIZE-i]),&(p[csl+sil]),i); - d+=SSL3_RANDOM_SIZE; + i = (cl > SSL3_RANDOM_SIZE) ? SSL3_RANDOM_SIZE : cl; + memset(d, 0, SSL3_RANDOM_SIZE); + memcpy(&(d[SSL3_RANDOM_SIZE - i]), &(p[csl + sil]), i); + d += SSL3_RANDOM_SIZE; /* no session-id reuse */ - *(d++)=0; + *(d++) = 0; /* ciphers */ - j=0; - dd=d; - d+=2; - for (i=0; ipacket+s->packet_length) - { + /* 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; + 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; - } + 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): */ /* s->state = SSL23_SR_CLNT_HELLO_C */ - if (type == 1) - { + if (type == 1) { #ifdef OPENSSL_NO_SSL2 - SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNSUPPORTED_PROTOCOL); + SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_UNSUPPORTED_PROTOCOL); goto err; #else /* we are talking sslv2 */ /* we need to clean up the SSLv3/TLSv1 setup and put in the * sslv2 stuff. */ - if (s->s2 == NULL) - { + if (s->s2 == NULL) { if (!ssl2_new(s)) goto err; - } - else + } else ssl2_clear(s); - if (s->s3 != NULL) ssl3_free(s); + if (s->s3 != NULL) + ssl3_free(s); if (!BUF_MEM_grow_clean(s->init_buf, - SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) - { + SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) { goto err; - } + } - s->state=SSL2_ST_GET_CLIENT_HELLO_A; + s->state = SSL2_ST_GET_CLIENT_HELLO_A; if (s->options & SSL_OP_NO_TLSv1 && s->options & SSL_OP_NO_SSLv3) - s->s2->ssl2_rollback=0; + s->s2->ssl2_rollback = 0; else /* reject SSL 2.0 session if client supports SSL 3.0 or TLS 1.0 * (SSL 3.0 draft/RFC 2246, App. E.2) */ - s->s2->ssl2_rollback=1; + s->s2->ssl2_rollback = 1; /* setup the n bytes we have read so we get them from * the sslv2 buffer */ - s->rstate=SSL_ST_READ_HEADER; - s->packet_length=n; - s->packet= &(s->s2->rbuf[0]); - memcpy(s->packet,buf,n); - s->s2->rbuf_left=n; - s->s2->rbuf_offs=0; - - s->method=SSLv2_server_method(); - s->handshake_func=s->method->ssl_accept; + s->rstate = SSL_ST_READ_HEADER; + s->packet_length = n; + s->packet = &(s->s2->rbuf[0]); + memcpy(s->packet, buf, n); + s->s2->rbuf_left = n; + s->s2->rbuf_offs = 0; + + s->method = SSLv2_server_method(); + s->handshake_func = s->method->ssl_accept; #endif - } + } - if ((type == 2) || (type == 3)) - { + if ((type == 2) || (type == 3)) { /* we have SSLv3/TLSv1 (type 2: SSL2 style, type 3: SSL3/TLS style) */ - if (!ssl_init_wbio_buffer(s,1)) goto err; + if (!ssl_init_wbio_buffer(s, 1)) goto err; /* we are in this state */ - s->state=SSL3_ST_SR_CLNT_HELLO_A; + s->state = SSL3_ST_SR_CLNT_HELLO_A; - if (type == 3) - { + 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; + 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; - } + 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; + } if (s->version == TLS1_2_VERSION) s->method = TLSv1_2_server_method(); else if (s->version == TLS1_1_VERSION) @@ -617,22 +572,23 @@ int ssl23_get_client_hello(SSL *s) else s->method = SSLv3_server_method(); #if 0 /* ssl3_get_client_hello does this */ - s->client_version=(v[0]<<8)|v[1]; + s->client_version = (v[0]<<8)|v[1]; #endif - s->handshake_func=s->method->ssl_accept; - } - - if ((type < 1) || (type > 3)) - { + s->handshake_func = s->method->ssl_accept; + } + + if ((type < 1) || (type > 3)) { /* bad, very bad */ - SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNKNOWN_PROTOCOL); + SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO, SSL_R_UNKNOWN_PROTOCOL); goto err; - } - s->init_num=0; + } + s->init_num = 0; - if (buf != buf_space) OPENSSL_free(buf); - return(SSL_accept(s)); + if (buf != buf_space) + OPENSSL_free(buf); + return (SSL_accept(s)); err: - if (buf != buf_space) OPENSSL_free(buf); - return(-1); - } + if (buf != buf_space) + OPENSSL_free(buf); + return (-1); +} -- cgit v1.2.3-55-g6feb