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

[openssl.git] / ssl / s3_cbc.c

diff --git a/ssl/s3_cbc.c b/ssl/s3_cbc.c
index 2c87b27eb1d54fea189c8e86a331ad87e3383dd2..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);
@@ -339,7 +342,9 @@ static void tls1_sha1_final_raw(void* ctx, unsigned char *md_out)
        l2n(sha1->h3, md_out);
        l2n(sha1->h4, md_out);
        }
+#define LARGEST_DIGEST_CTX SHA_CTX
 
+#ifndef OPENSSL_NO_SHA256
 static void tls1_sha256_final_raw(void* ctx, unsigned char *md_out)
        {
        SHA256_CTX *sha256 = ctx;
@@ -350,7 +355,11 @@ static void tls1_sha256_final_raw(void* ctx, unsigned char *md_out)
                l2n(sha256->h[i], md_out);
                }
        }
+#undef  LARGEST_DIGEST_CTX
+#define LARGEST_DIGEST_CTX SHA256_CTX
+#endif
 
+#ifndef OPENSSL_NO_SHA512
 static void tls1_sha512_final_raw(void* ctx, unsigned char *md_out)
        {
        SHA512_CTX *sha512 = ctx;
@@ -361,6 +370,9 @@ static void tls1_sha512_final_raw(void* ctx, unsigned char *md_out)
                l2n8(sha512->h[i], md_out);
                }
        }
+#undef  LARGEST_DIGEST_CTX
+#define LARGEST_DIGEST_CTX SHA512_CTX
+#endif
 
 /* ssl3_cbc_record_digest_supported returns 1 iff |ctx| uses a hash function
  * which ssl3_cbc_digest_record supports. */
@@ -370,14 +382,18 @@ char ssl3_cbc_record_digest_supported(const EVP_MD_CTX *ctx)
        if (FIPS_mode())
                return 0;
 #endif
-       switch (ctx->digest->type)
+       switch (EVP_MD_CTX_type(ctx))
                {
                case NID_md5:
                case NID_sha1:
+#ifndef OPENSSL_NO_SHA256
                case NID_sha224:
                case NID_sha256:
+#endif
+#ifndef OPENSSL_NO_SHA512
                case NID_sha384:
                case NID_sha512:
+#endif
                        return 1;
                default:
                        return 0;
@@ -416,7 +432,7 @@ void ssl3_cbc_digest_record(
        char is_sslv3)
        {
        union { double align;
-               unsigned char c[sizeof(SHA512_CTX)]; } md_state;
+               unsigned char c[sizeof(LARGEST_DIGEST_CTX)]; } md_state;
        void (*md_final_raw)(void *ctx, unsigned char *md_out);
        void (*md_transform)(void *ctx, const unsigned char *block);
        unsigned md_size, md_block_size = 64;
@@ -439,7 +455,7 @@ void ssl3_cbc_digest_record(
         * many possible overflows later in this function. */
        OPENSSL_assert(data_plus_mac_plus_padding_size < 1024*1024);
 
-       switch (ctx->digest->type)
+       switch (EVP_MD_CTX_type(ctx))
                {
                case NID_md5:
                        MD5_Init((MD5_CTX*)md_state.c);
@@ -454,6 +470,7 @@ void ssl3_cbc_digest_record(
                        md_transform = (void(*)(void *ctx, const unsigned char *block)) SHA1_Transform;
                        md_size = 20;
                        break;
+#ifndef OPENSSL_NO_SHA256
                case NID_sha224:
                        SHA224_Init((SHA256_CTX*)md_state.c);
                        md_final_raw = tls1_sha256_final_raw;
@@ -466,6 +483,8 @@ void ssl3_cbc_digest_record(
                        md_transform = (void(*)(void *ctx, const unsigned char *block)) SHA256_Transform;
                        md_size = 32;
                        break;
+#endif
+#ifndef OPENSSL_NO_SHA512
                case NID_sha384:
                        SHA384_Init((SHA512_CTX*)md_state.c);
                        md_final_raw = tls1_sha512_final_raw;
@@ -482,6 +501,7 @@ void ssl3_cbc_digest_record(
                        md_block_size = 128;
                        md_length_size = 16;
                        break;
+#endif
                default:
                        /* ssl3_cbc_record_digest_supported should have been
                         * called first to check that the hash function is