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->len != len) { 115 OPENSSL_free(thiswb->buf); 116 thiswb->buf = NULL; /* force reallocation */ 117 } 118 119 if (thiswb->buf == NULL) { 120 if (s->wbio == NULL || !BIO_get_ktls_send(s->wbio)) { 121 p = OPENSSL_malloc(len); 122 if (p == NULL) { 123 s->rlayer.numwpipes = currpipe; 124 /* 125 * We've got a malloc failure, and we're still initialising 126 * buffers. We assume we're so doomed that we won't even be able 127 * to send an alert. 128 */ 129 SSLfatal(s, SSL_AD_NO_ALERT, 130 SSL_F_SSL3_SETUP_WRITE_BUFFER, ERR_R_MALLOC_FAILURE); 131 return 0; 132 } 133 } else { 134 p = NULL; 135 } 136 memset(thiswb, 0, sizeof(SSL3_BUFFER)); 137 thiswb->buf = p; 138 thiswb->len = len; 139 } 140 } 141 142 return 1; 143 } 144 145 int ssl3_setup_buffers(SSL *s) 146 { 147 if (!ssl3_setup_read_buffer(s)) { 148 /* SSLfatal() already called */ 149 return 0; 150 } 151 if (!ssl3_setup_write_buffer(s, 1, 0)) { 152 /* SSLfatal() already called */ 153 return 0; 154 } 155 return 1; 156 } 157 158 int ssl3_release_write_buffer(SSL *s) 159 { 160 SSL3_BUFFER *wb; 161 size_t pipes; 162 163 pipes = s->rlayer.numwpipes; 164 while (pipes > 0) { 165 wb = &RECORD_LAYER_get_wbuf(&s->rlayer)[pipes - 1]; 166 167 if (SSL3_BUFFER_is_app_buffer(wb)) 168 SSL3_BUFFER_set_app_buffer(wb, 0); 169 else 170 OPENSSL_free(wb->buf); 171 wb->buf = NULL; 172 pipes--; 173 } 174 s->rlayer.numwpipes = 0; 175 return 1; 176 } 177 178 int ssl3_release_read_buffer(SSL *s) 179 { 180 SSL3_BUFFER *b; 181 182 b = RECORD_LAYER_get_rbuf(&s->rlayer); 183 OPENSSL_free(b->buf); 184 b->buf = NULL; 185 return 1; 186 } 187