1 /* 2 * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the OpenSSL license (the "License"). You may not use 5 * this file except in compliance with the License. You can obtain a copy 6 * in the file LICENSE in the source distribution or at 7 * https://www.openssl.org/source/license.html 8 */ 9 10 #include "../ssl_local.h" 11 #include "record_local.h" 12 13 void SSL3_BUFFER_set_data(SSL3_BUFFER *b, const unsigned char *d, size_t n) 14 { 15 if (d != NULL) 16 memcpy(b->buf, d, n); 17 b->left = n; 18 b->offset = 0; 19 } 20 21 /* 22 * Clear the contents of an SSL3_BUFFER but retain any memory allocated. Also 23 * retains the default_len setting 24 */ 25 void SSL3_BUFFER_clear(SSL3_BUFFER *b) 26 { 27 b->offset = 0; 28 b->left = 0; 29 } 30 31 void SSL3_BUFFER_release(SSL3_BUFFER *b) 32 { 33 OPENSSL_free(b->buf); 34 b->buf = NULL; 35 } 36 37 int ssl3_setup_read_buffer(SSL *s) 38 { 39 unsigned char *p; 40 size_t len, align = 0, headerlen; 41 SSL3_BUFFER *b; 42 43 b = RECORD_LAYER_get_rbuf(&s->rlayer); 44 45 if (SSL_IS_DTLS(s)) 46 headerlen = DTLS1_RT_HEADER_LENGTH; 47 else 48 headerlen = SSL3_RT_HEADER_LENGTH; 49 50 #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0 51 align = (-SSL3_RT_HEADER_LENGTH) & (SSL3_ALIGN_PAYLOAD - 1); 52 #endif 53 54 if (b->buf == NULL) { 55 len = SSL3_RT_MAX_PLAIN_LENGTH 56 + SSL3_RT_MAX_ENCRYPTED_OVERHEAD + headerlen + align; 57 #ifndef OPENSSL_NO_COMP 58 if (ssl_allow_compression(s)) 59 len += SSL3_RT_MAX_COMPRESSED_OVERHEAD; 60 #endif 61 if (b->default_len > len) 62 len = b->default_len; 63 if ((p = OPENSSL_malloc(len)) == NULL) { 64 /* 65 * We've got a malloc failure, and we're still initialising buffers. 66 * We assume we're so doomed that we won't even be able to send an 67 * alert. 68 */ 69 SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_SSL3_SETUP_READ_BUFFER, 70 ERR_R_MALLOC_FAILURE); 71 return 0; 72 } 73 b->buf = p; 74 b->len = len; 75 } 76 77 RECORD_LAYER_set_packet(&s->rlayer, &(b->buf[0])); 78 return 1; 79 } 80 81 int ssl3_setup_write_buffer(SSL *s, size_t numwpipes, size_t len) 82 { 83 unsigned char *p; 84 size_t align = 0, headerlen; 85 SSL3_BUFFER *wb; 86 size_t currpipe; 87 88 s->rlayer.numwpipes = numwpipes; 89 90 if (len == 0) { 91 if (SSL_IS_DTLS(s)) 92 headerlen = DTLS1_RT_HEADER_LENGTH + 1; 93 else 94 headerlen = SSL3_RT_HEADER_LENGTH; 95 96 #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0 97 align = SSL3_ALIGN_PAYLOAD - 1; 98 #endif 99 100 len = ssl_get_max_send_fragment(s) 101 + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD + headerlen + align; 102 #ifndef OPENSSL_NO_COMP 103 if (ssl_allow_compression(s)) 104 len += SSL3_RT_MAX_COMPRESSED_OVERHEAD; 105 #endif 106 if (!(s->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS)) 107 len += headerlen + align + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD; 108 } 109 110 wb = RECORD_LAYER_get_wbuf(&s->rlayer); 111 for (currpipe = 0; currpipe < numwpipes; currpipe++) { 112 SSL3_BUFFER *thiswb = &wb[currpipe]; 113 114 if (thiswb->buf != NULL && thiswb->len != len) { 115 OPENSSL_free(thiswb->buf); 116 thiswb->buf = NULL; /* force reallocation */ 117 } 118 119 if (thiswb->buf == NULL) { 120 p = OPENSSL_malloc(len); 121 if (p == NULL) { 122 s->rlayer.numwpipes = currpipe; 123 /* 124 * We've got a malloc failure, and we're still initialising 125 * buffers. We assume we're so doomed that we won't even be able 126 * to send an alert. 127 */ 128 SSLfatal(s, SSL_AD_NO_ALERT, 129 SSL_F_SSL3_SETUP_WRITE_BUFFER, ERR_R_MALLOC_FAILURE); 130 return 0; 131 } 132 memset(thiswb, 0, sizeof(SSL3_BUFFER)); 133 thiswb->buf = p; 134 thiswb->len = len; 135 } 136 } 137 138 return 1; 139 } 140 141 int ssl3_setup_buffers(SSL *s) 142 { 143 if (!ssl3_setup_read_buffer(s)) { 144 /* SSLfatal() already called */ 145 return 0; 146 } 147 if (!ssl3_setup_write_buffer(s, 1, 0)) { 148 /* SSLfatal() already called */ 149 return 0; 150 } 151 return 1; 152 } 153 154 int ssl3_release_write_buffer(SSL *s) 155 { 156 SSL3_BUFFER *wb; 157 size_t pipes; 158 159 pipes = s->rlayer.numwpipes; 160 while (pipes > 0) { 161 wb = &RECORD_LAYER_get_wbuf(&s->rlayer)[pipes - 1]; 162 163 OPENSSL_free(wb->buf); 164 wb->buf = NULL; 165 pipes--; 166 } 167 s->rlayer.numwpipes = 0; 168 return 1; 169 } 170 171 int ssl3_release_read_buffer(SSL *s) 172 { 173 SSL3_BUFFER *b; 174 175 b = RECORD_LAYER_get_rbuf(&s->rlayer); 176 OPENSSL_free(b->buf); 177 b->buf = NULL; 178 return 1; 179 } 180