ssl/*: remove SSL3_RECORD->orig_len to restore binary compatibility.

Kludge alert. This is arranged by passing padding length in unused
bits of SSL3_RECORD->type, so that orig_len can be reconstructed.
(cherry picked from commit 8bfd4c659f180a6ce34f21c0e62956b362067fba)

diff --git a/ssl/d1_pkt.c b/ssl/d1_pkt.c
index 02c881ab3176c849c800b013f73a1f061aa641d9..0ad8b5f5590e4936134e28135d4dede948ac8238 100644 (file)
--- a/ssl/d1_pkt.c
+++ b/ssl/d1_pkt.c
@@ -379,7 +379,7 @@ dtls1_process_record(SSL *s)
        int enc_err;
        SSL_SESSION *sess;
        SSL3_RECORD *rr;
-       unsigned int mac_size;
+       unsigned int mac_size, orig_len;
        unsigned char md[EVP_MAX_MD_SIZE];
 
        rr= &(s->s3->rrec);
@@ -410,7 +410,7 @@ dtls1_process_record(SSL *s)
 
        /* decrypt in place in 'rr->input' */
        rr->data=rr->input;
-       rr->orig_len=rr->length;
+       orig_len=rr->length;
 
        enc_err = s->method->ssl3_enc->enc(s,0);
        /* enc_err is:
@@ -447,10 +447,10 @@ printf("\n");
                 * therefore we can safely process the record in a different
                 * amount of time if it's too short to possibly contain a MAC.
                 */
-               if (rr->orig_len < mac_size ||
+               if (orig_len < mac_size ||
                    /* CBC records must have a padding length byte too. */
                    (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
-                    rr->orig_len < mac_size+1))
+                    orig_len < mac_size+1))
                        {
                        al=SSL_AD_DECODE_ERROR;
                        SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_LENGTH_TOO_SHORT);
@@ -465,12 +465,12 @@ printf("\n");
                         * without leaking the contents of the padding bytes.
                         * */
                        mac = mac_tmp;
-                       ssl3_cbc_copy_mac(mac_tmp, rr, mac_size);
+                       ssl3_cbc_copy_mac(mac_tmp, rr, mac_size, orig_len);
                        rr->length -= mac_size;
                        }
                else
                        {
-                       /* In this case there's no padding, so |rec->orig_len|
+                       /* In this case there's no padding, so |orig_len|
                         * equals |rec->length| and we checked that there's
                         * enough bytes for |mac_size| above. */
                        rr->length -= mac_size;

diff --git a/ssl/s3_cbc.c b/ssl/s3_cbc.c
index 52e294157eba276a8372faaf351d30a4497439a1..b91d84098d8c81fdac34dda7faaf761c23f4c6a7 100644 (file)
--- a/ssl/s3_cbc.c
+++ b/ssl/s3_cbc.c
@@ -116,7 +116,9 @@ int ssl3_cbc_remove_padding(const SSL* s,
        good = constant_time_ge(rec->length, padding_length+overhead);
        /* SSLv3 requires that the padding is minimal. */
        good &= constant_time_ge(block_size, padding_length+1);
-       rec->length -= good & (padding_length+1);
+       padding_length = good & (padding_length+1);
+       rec->length -= padding_length;
+       rec->type |= padding_length<<8; /* kludge: pass padding length */
        return (int)((good & 1) | (~good & -1));
 }
 
@@ -203,7 +205,9 @@ int tls1_cbc_remove_padding(const SSL* s,
        good <<= sizeof(good)*8-1;
        good = DUPLICATE_MSB_TO_ALL(good);
 
-       rec->length -= good & (padding_length+1);
+       padding_length = good & (padding_length+1);
+       rec->length -= padding_length;
+       rec->type |= padding_length<<8; /* kludge: pass padding length */
 
        /* We can always safely skip the explicit IV. We check at the beginning
         * of this function that the record has at least enough space for the
@@ -218,7 +222,6 @@ int tls1_cbc_remove_padding(const SSL* s,
                rec->data += block_size;
                rec->input += block_size;
                rec->length -= block_size;
-               rec->orig_len -= block_size;
                }
 
        return (int)((good & 1) | (~good & -1));
@@ -246,7 +249,7 @@ int tls1_cbc_remove_padding(const SSL* s,
  */
 void ssl3_cbc_copy_mac(unsigned char* out,
                       const SSL3_RECORD *rec,
-                      unsigned md_size)
+                      unsigned md_size,unsigned orig_len)
        {
 #if defined(CBC_MAC_ROTATE_IN_PLACE)
        unsigned char rotated_mac_buf[EVP_MAX_MD_SIZE*2];
@@ -265,7 +268,7 @@ void ssl3_cbc_copy_mac(unsigned char* out,
        unsigned div_spoiler;
        unsigned rotate_offset;
 
-       OPENSSL_assert(rec->orig_len >= md_size);
+       OPENSSL_assert(orig_len >= md_size);
        OPENSSL_assert(md_size <= EVP_MAX_MD_SIZE);
 
 #if defined(CBC_MAC_ROTATE_IN_PLACE)
@@ -273,8 +276,8 @@ void ssl3_cbc_copy_mac(unsigned char* out,
 #endif
 
        /* This information is public so it's safe to branch based on it. */
-       if (rec->orig_len > md_size + 255 + 1)
-               scan_start = rec->orig_len - (md_size + 255 + 1);
+       if (orig_len > md_size + 255 + 1)
+               scan_start = orig_len - (md_size + 255 + 1);
        /* div_spoiler contains a multiple of md_size that is used to cause the
         * modulo operation to be constant time. Without this, the time varies
         * based on the amount of padding when running on Intel chips at least.
@@ -287,9 +290,9 @@ void ssl3_cbc_copy_mac(unsigned char* out,
        rotate_offset = (div_spoiler + mac_start - scan_start) % md_size;
 
        memset(rotated_mac, 0, md_size);
-       for (i = scan_start; i < rec->orig_len;)
+       for (i = scan_start; i < orig_len;)
                {
-               for (j = 0; j < md_size && i < rec->orig_len; i++, j++)
+               for (j = 0; j < md_size && i < orig_len; i++, j++)
                        {
                        unsigned char mac_started = constant_time_ge(i, mac_start);
                        unsigned char mac_ended = constant_time_ge(i, mac_end);

diff --git a/ssl/s3_enc.c b/ssl/s3_enc.c
index 0282ef4620d0af01d09ff7307b276917b6e976fa..196f0739d5fea556fd024d1289fd75c7dbe92ae8 100644 (file)
--- a/ssl/s3_enc.c
+++ b/ssl/s3_enc.c
@@ -730,7 +730,7 @@ int n_ssl3_mac(SSL *ssl, unsigned char *md, int send)
        EVP_MD_CTX md_ctx;
        const EVP_MD_CTX *hash;
        unsigned char *p,rec_char;
-       size_t md_size;
+       size_t md_size, orig_len;
        int npad;
        int t;
 
@@ -755,6 +755,10 @@ int n_ssl3_mac(SSL *ssl, unsigned char *md, int send)
        md_size=t;
        npad=(48/md_size)*md_size;
 
+       /* kludge: ssl3_cbc_remove_padding passes padding length in rec->type */
+       orig_len = rec->length+md_size+((unsigned int)rec->type>>8);
+       rec->type &= 0xff;
+
        if (!send &&
            EVP_CIPHER_CTX_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
            ssl3_cbc_record_digest_supported(hash))
@@ -786,7 +790,7 @@ int n_ssl3_mac(SSL *ssl, unsigned char *md, int send)
                        hash,
                        md, &md_size,
                        header, rec->input,
-                       rec->length + md_size, rec->orig_len,
+                       rec->length + md_size, orig_len,
                        mac_sec, md_size,
                        1 /* is SSLv3 */);
                }

diff --git a/ssl/s3_pkt.c b/ssl/s3_pkt.c
index 032a8558ed1765c90363810eab8f4511739d7a87..64cef2abfae205e50d1bc55c280e20862d46ed7f 100644 (file)
--- a/ssl/s3_pkt.c
+++ b/ssl/s3_pkt.c
@@ -290,7 +290,7 @@ static int ssl3_get_record(SSL *s)
        unsigned char *p;
        unsigned char md[EVP_MAX_MD_SIZE];
        short version;
-       unsigned mac_size;
+       unsigned mac_size, orig_len;
        size_t extra;
 
        rr= &(s->s3->rrec);
@@ -400,7 +400,7 @@ fprintf(stderr, "Record type=%d, Length=%d\n", rr->type, rr->length);
 
        /* decrypt in place in 'rr->input' */
        rr->data=rr->input;
-       rr->orig_len=rr->length;
+       orig_len=rr->length;
 
        enc_err = s->method->ssl3_enc->enc(s,0);
        /* enc_err is:
@@ -436,10 +436,10 @@ printf("\n");
                 * therefore we can safely process the record in a different
                 * amount of time if it's too short to possibly contain a MAC.
                 */
-               if (rr->orig_len < mac_size ||
+               if (orig_len < mac_size ||
                    /* CBC records must have a padding length byte too. */
                    (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
-                    rr->orig_len < mac_size+1))
+                    orig_len < mac_size+1))
                        {
                        al=SSL_AD_DECODE_ERROR;
                        SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_LENGTH_TOO_SHORT);
@@ -454,12 +454,12 @@ printf("\n");
                         * without leaking the contents of the padding bytes.
                         * */
                        mac = mac_tmp;
-                       ssl3_cbc_copy_mac(mac_tmp, rr, mac_size);
+                       ssl3_cbc_copy_mac(mac_tmp, rr, mac_size, orig_len);
                        rr->length -= mac_size;
                        }
                else
                        {
-                       /* In this case there's no padding, so |rec->orig_len|
+                       /* In this case there's no padding, so |orig_len|
                         * equals |rec->length| and we checked that there's
                         * enough bytes for |mac_size| above. */
                        rr->length -= mac_size;

diff --git a/ssl/ssl3.h b/ssl/ssl3.h
index e41f2888713d865fa1606daca752e2df88ba3c3c..d2a5208824933baca05a0163809d017f6dc6cbcf 100644 (file)
--- a/ssl/ssl3.h
+++ b/ssl/ssl3.h
@@ -372,10 +372,6 @@ typedef struct ssl3_record_st
 /*r */ unsigned char *comp;    /* only used with decompression - malloc()ed */
 /*r */  unsigned long epoch;    /* epoch number, needed by DTLS1 */
 /*r */  unsigned char seq_num[8]; /* sequence number, needed by DTLS1 */
-/*rw*/ unsigned int orig_len;  /* How many bytes were available before padding
-                                  was removed? This is used to implement the
-                                  MAC check in constant time for CBC records.
-                                */
        } SSL3_RECORD;
 
 typedef struct ssl3_buffer_st

diff --git a/ssl/ssl_locl.h b/ssl/ssl_locl.h
index 134198e91b52566ecfbc97574d69024463067cee..65c56bddc9126fd4858b7d465a6b4dd4bc666f03 100644 (file)
--- a/ssl/ssl_locl.h
+++ b/ssl/ssl_locl.h
@@ -1275,7 +1275,7 @@ int ssl_parse_serverhello_use_srtp_ext(SSL *s, unsigned char *d, int len,int *al
 /* s3_cbc.c */
 void ssl3_cbc_copy_mac(unsigned char* out,
                       const SSL3_RECORD *rec,
-                      unsigned md_size);
+                      unsigned md_size,unsigned orig_len);
 int ssl3_cbc_remove_padding(const SSL* s,
                            SSL3_RECORD *rec,
                            unsigned block_size,

diff --git a/ssl/t1_enc.c b/ssl/t1_enc.c
index e313355fa2f2a8d9952ed532c35a0a36c25b2dbb..4e23bbf77b4e26c56ccd3d3a14aad3817cc738bb 100644 (file)
--- a/ssl/t1_enc.c
+++ b/ssl/t1_enc.c
@@ -973,7 +973,7 @@ int tls1_mac(SSL *ssl, unsigned char *md, int send)
        SSL3_RECORD *rec;
        unsigned char *seq;
        EVP_MD_CTX *hash;
-       size_t md_size;
+       size_t md_size, orig_len;
        int i;
        EVP_MD_CTX hmac, *mac_ctx;
        unsigned char header[13];
@@ -1020,6 +1020,10 @@ int tls1_mac(SSL *ssl, unsigned char *md, int send)
        else
                memcpy(header, seq, 8);
 
+       /* kludge: tls1_cbc_remove_padding passes padding length in rec->type */
+       orig_len = rec->length+md_size+((unsigned int)rec->type>>8);
+       rec->type &= 0xff;
+
        header[8]=rec->type;
        header[9]=(unsigned char)(ssl->version>>8);
        header[10]=(unsigned char)(ssl->version);
@@ -1038,7 +1042,7 @@ int tls1_mac(SSL *ssl, unsigned char *md, int send)
                        mac_ctx,
                        md, &md_size,
                        header, rec->input,
-                       rec->length + md_size, rec->orig_len,
+                       rec->length + md_size, orig_len,
                        ssl->s3->read_mac_secret,
                        ssl->s3->read_mac_secret_size,
                        0 /* not SSLv3 */);
@@ -1054,7 +1058,7 @@ int tls1_mac(SSL *ssl, unsigned char *md, int send)
                        tls_fips_digest_extra(
                                        ssl->enc_read_ctx,
                                        mac_ctx, rec->input,
-                                       rec->length, rec->orig_len);
+                                       rec->length, orig_len);
 #endif
                }