| 1 |
/* |
| 2 |
* TLSv1 Record Protocol |
| 3 |
* Copyright (c) 2006-2011, Jouni Malinen <[email protected]> |
| 4 |
* |
| 5 |
* This software may be distributed under the terms of the BSD license. |
| 6 |
* See README for more details. |
| 7 |
*/ |
| 8 |
|
| 9 |
#include "includes.h" |
| 10 |
|
| 11 |
#include "common.h" |
| 12 |
#include "crypto/md5.h" |
| 13 |
#include "crypto/sha1.h" |
| 14 |
#include "crypto/sha256.h" |
| 15 |
#include "tlsv1_common.h" |
| 16 |
#include "tlsv1_record.h" |
| 17 |
|
| 18 |
|
| 19 |
/** |
| 20 |
* tlsv1_record_set_cipher_suite - TLS record layer: Set cipher suite |
| 21 |
* @rl: Pointer to TLS record layer data |
| 22 |
* @cipher_suite: New cipher suite |
| 23 |
* Returns: 0 on success, -1 on failure |
| 24 |
* |
| 25 |
* This function is used to prepare TLS record layer for cipher suite change. |
| 26 |
* tlsv1_record_change_write_cipher() and |
| 27 |
* tlsv1_record_change_read_cipher() functions can then be used to change the |
| 28 |
* currently used ciphers. |
| 29 |
*/ |
| 30 |
int tlsv1_record_set_cipher_suite(struct tlsv1_record_layer *rl, |
| 31 |
u16 cipher_suite) |
| 32 |
{ |
| 33 |
const struct tls_cipher_suite *suite; |
| 34 |
const struct tls_cipher_data *data; |
| 35 |
|
| 36 |
wpa_printf(MSG_DEBUG, "TLSv1: Selected cipher suite: 0x%04x", |
| 37 |
cipher_suite); |
| 38 |
rl->cipher_suite = cipher_suite; |
| 39 |
|
| 40 |
suite = tls_get_cipher_suite(cipher_suite); |
| 41 |
if (suite == NULL) |
| 42 |
return -1; |
| 43 |
|
| 44 |
if (suite->hash == TLS_HASH_MD5) { |
| 45 |
rl->hash_alg = CRYPTO_HASH_ALG_HMAC_MD5; |
| 46 |
rl->hash_size = MD5_MAC_LEN; |
| 47 |
} else if (suite->hash == TLS_HASH_SHA) { |
| 48 |
rl->hash_alg = CRYPTO_HASH_ALG_HMAC_SHA1; |
| 49 |
rl->hash_size = SHA1_MAC_LEN; |
| 50 |
} else if (suite->hash == TLS_HASH_SHA256) { |
| 51 |
rl->hash_alg = CRYPTO_HASH_ALG_HMAC_SHA256; |
| 52 |
rl->hash_size = SHA256_MAC_LEN; |
| 53 |
} |
| 54 |
|
| 55 |
data = tls_get_cipher_data(suite->cipher); |
| 56 |
if (data == NULL) |
| 57 |
return -1; |
| 58 |
|
| 59 |
rl->key_material_len = data->key_material; |
| 60 |
rl->iv_size = data->block_size; |
| 61 |
rl->cipher_alg = data->alg; |
| 62 |
|
| 63 |
return 0; |
| 64 |
} |
| 65 |
|
| 66 |
|
| 67 |
/** |
| 68 |
* tlsv1_record_change_write_cipher - TLS record layer: Change write cipher |
| 69 |
* @rl: Pointer to TLS record layer data |
| 70 |
* Returns: 0 on success (cipher changed), -1 on failure |
| 71 |
* |
| 72 |
* This function changes TLS record layer to use the new cipher suite |
| 73 |
* configured with tlsv1_record_set_cipher_suite() for writing. |
| 74 |
*/ |
| 75 |
int tlsv1_record_change_write_cipher(struct tlsv1_record_layer *rl) |
| 76 |
{ |
| 77 |
wpa_printf(MSG_DEBUG, "TLSv1: Record Layer - New write cipher suite " |
| 78 |
"0x%04x", rl->cipher_suite); |
| 79 |
rl->write_cipher_suite = rl->cipher_suite; |
| 80 |
os_memset(rl->write_seq_num, 0, TLS_SEQ_NUM_LEN); |
| 81 |
|
| 82 |
if (rl->write_cbc) { |
| 83 |
crypto_cipher_deinit(rl->write_cbc); |
| 84 |
rl->write_cbc = NULL; |
| 85 |
} |
| 86 |
if (rl->cipher_alg != CRYPTO_CIPHER_NULL) { |
| 87 |
rl->write_cbc = crypto_cipher_init(rl->cipher_alg, |
| 88 |
rl->write_iv, rl->write_key, |
| 89 |
rl->key_material_len); |
| 90 |
if (rl->write_cbc == NULL) { |
| 91 |
wpa_printf(MSG_DEBUG, "TLSv1: Failed to initialize " |
| 92 |
"cipher"); |
| 93 |
return -1; |
| 94 |
} |
| 95 |
} |
| 96 |
|
| 97 |
return 0; |
| 98 |
} |
| 99 |
|
| 100 |
|
| 101 |
/** |
| 102 |
* tlsv1_record_change_read_cipher - TLS record layer: Change read cipher |
| 103 |
* @rl: Pointer to TLS record layer data |
| 104 |
* Returns: 0 on success (cipher changed), -1 on failure |
| 105 |
* |
| 106 |
* This function changes TLS record layer to use the new cipher suite |
| 107 |
* configured with tlsv1_record_set_cipher_suite() for reading. |
| 108 |
*/ |
| 109 |
int tlsv1_record_change_read_cipher(struct tlsv1_record_layer *rl) |
| 110 |
{ |
| 111 |
wpa_printf(MSG_DEBUG, "TLSv1: Record Layer - New read cipher suite " |
| 112 |
"0x%04x", rl->cipher_suite); |
| 113 |
rl->read_cipher_suite = rl->cipher_suite; |
| 114 |
os_memset(rl->read_seq_num, 0, TLS_SEQ_NUM_LEN); |
| 115 |
|
| 116 |
if (rl->read_cbc) { |
| 117 |
crypto_cipher_deinit(rl->read_cbc); |
| 118 |
rl->read_cbc = NULL; |
| 119 |
} |
| 120 |
if (rl->cipher_alg != CRYPTO_CIPHER_NULL) { |
| 121 |
rl->read_cbc = crypto_cipher_init(rl->cipher_alg, |
| 122 |
rl->read_iv, rl->read_key, |
| 123 |
rl->key_material_len); |
| 124 |
if (rl->read_cbc == NULL) { |
| 125 |
wpa_printf(MSG_DEBUG, "TLSv1: Failed to initialize " |
| 126 |
"cipher"); |
| 127 |
return -1; |
| 128 |
} |
| 129 |
} |
| 130 |
|
| 131 |
return 0; |
| 132 |
} |
| 133 |
|
| 134 |
|
| 135 |
/** |
| 136 |
* tlsv1_record_send - TLS record layer: Send a message |
| 137 |
* @rl: Pointer to TLS record layer data |
| 138 |
* @content_type: Content type (TLS_CONTENT_TYPE_*) |
| 139 |
* @buf: Buffer for the generated TLS message (needs to have extra space for |
| 140 |
* header, IV (TLS v1.1), and HMAC) |
| 141 |
* @buf_size: Maximum buf size |
| 142 |
* @payload: Payload to be sent |
| 143 |
* @payload_len: Length of the payload |
| 144 |
* @out_len: Buffer for returning the used buf length |
| 145 |
* Returns: 0 on success, -1 on failure |
| 146 |
* |
| 147 |
* This function fills in the TLS record layer header, adds HMAC, and encrypts |
| 148 |
* the data using the current write cipher. |
| 149 |
*/ |
| 150 |
int tlsv1_record_send(struct tlsv1_record_layer *rl, u8 content_type, u8 *buf, |
| 151 |
size_t buf_size, const u8 *payload, size_t payload_len, |
| 152 |
size_t *out_len) |
| 153 |
{ |
| 154 |
u8 *pos, *ct_start, *length, *cpayload; |
| 155 |
struct crypto_hash *hmac; |
| 156 |
size_t clen; |
| 157 |
int explicit_iv; |
| 158 |
|
| 159 |
pos = buf; |
| 160 |
if (pos + TLS_RECORD_HEADER_LEN > buf + buf_size) |
| 161 |
return -1; |
| 162 |
|
| 163 |
/* ContentType type */ |
| 164 |
ct_start = pos; |
| 165 |
*pos++ = content_type; |
| 166 |
/* ProtocolVersion version */ |
| 167 |
WPA_PUT_BE16(pos, rl->tls_version); |
| 168 |
pos += 2; |
| 169 |
/* uint16 length */ |
| 170 |
length = pos; |
| 171 |
WPA_PUT_BE16(length, payload_len); |
| 172 |
pos += 2; |
| 173 |
|
| 174 |
cpayload = pos; |
| 175 |
explicit_iv = rl->write_cipher_suite != TLS_NULL_WITH_NULL_NULL && |
| 176 |
rl->iv_size && rl->tls_version >= TLS_VERSION_1_1; |
| 177 |
if (explicit_iv) { |
| 178 |
/* opaque IV[Cipherspec.block_length] */ |
| 179 |
if (pos + rl->iv_size > buf + buf_size) |
| 180 |
return -1; |
| 181 |
|
| 182 |
/* |
| 183 |
* Use random number R per the RFC 4346, 6.2.3.2 CBC Block |
| 184 |
* Cipher option 2a. |
| 185 |
*/ |
| 186 |
|
| 187 |
if (os_get_random(pos, rl->iv_size)) |
| 188 |
return -1; |
| 189 |
pos += rl->iv_size; |
| 190 |
} |
| 191 |
|
| 192 |
/* |
| 193 |
* opaque fragment[TLSPlaintext.length] |
| 194 |
* (opaque content[TLSCompressed.length] in GenericBlockCipher) |
| 195 |
*/ |
| 196 |
if (pos + payload_len > buf + buf_size) |
| 197 |
return -1; |
| 198 |
os_memmove(pos, payload, payload_len); |
| 199 |
pos += payload_len; |
| 200 |
|
| 201 |
if (rl->write_cipher_suite != TLS_NULL_WITH_NULL_NULL) { |
| 202 |
/* |
| 203 |
* MAC calculated over seq_num + TLSCompressed.type + |
| 204 |
* TLSCompressed.version + TLSCompressed.length + |
| 205 |
* TLSCompressed.fragment |
| 206 |
*/ |
| 207 |
hmac = crypto_hash_init(rl->hash_alg, rl->write_mac_secret, |
| 208 |
rl->hash_size); |
| 209 |
if (hmac == NULL) { |
| 210 |
wpa_printf(MSG_DEBUG, "TLSv1: Record Layer - Failed " |
| 211 |
"to initialize HMAC"); |
| 212 |
return -1; |
| 213 |
} |
| 214 |
crypto_hash_update(hmac, rl->write_seq_num, TLS_SEQ_NUM_LEN); |
| 215 |
/* type + version + length + fragment */ |
| 216 |
crypto_hash_update(hmac, ct_start, TLS_RECORD_HEADER_LEN); |
| 217 |
crypto_hash_update(hmac, payload, payload_len); |
| 218 |
clen = buf + buf_size - pos; |
| 219 |
if (clen < rl->hash_size) { |
| 220 |
wpa_printf(MSG_DEBUG, "TLSv1: Record Layer - Not " |
| 221 |
"enough room for MAC"); |
| 222 |
crypto_hash_finish(hmac, NULL, NULL); |
| 223 |
return -1; |
| 224 |
} |
| 225 |
|
| 226 |
if (crypto_hash_finish(hmac, pos, &clen) < 0) { |
| 227 |
wpa_printf(MSG_DEBUG, "TLSv1: Record Layer - Failed " |
| 228 |
"to calculate HMAC"); |
| 229 |
return -1; |
| 230 |
} |
| 231 |
wpa_hexdump(MSG_MSGDUMP, "TLSv1: Record Layer - Write HMAC", |
| 232 |
pos, clen); |
| 233 |
pos += clen; |
| 234 |
if (rl->iv_size) { |
| 235 |
size_t len = pos - cpayload; |
| 236 |
size_t pad; |
| 237 |
pad = (len + 1) % rl->iv_size; |
| 238 |
if (pad) |
| 239 |
pad = rl->iv_size - pad; |
| 240 |
if (pos + pad + 1 > buf + buf_size) { |
| 241 |
wpa_printf(MSG_DEBUG, "TLSv1: No room for " |
| 242 |
"block cipher padding"); |
| 243 |
return -1; |
| 244 |
} |
| 245 |
os_memset(pos, pad, pad + 1); |
| 246 |
pos += pad + 1; |
| 247 |
} |
| 248 |
|
| 249 |
if (crypto_cipher_encrypt(rl->write_cbc, cpayload, |
| 250 |
cpayload, pos - cpayload) < 0) |
| 251 |
return -1; |
| 252 |
} |
| 253 |
|
| 254 |
WPA_PUT_BE16(length, pos - length - 2); |
| 255 |
inc_byte_array(rl->write_seq_num, TLS_SEQ_NUM_LEN); |
| 256 |
|
| 257 |
*out_len = pos - buf; |
| 258 |
|
| 259 |
return 0; |
| 260 |
} |
| 261 |
|
| 262 |
|
| 263 |
/** |
| 264 |
* tlsv1_record_receive - TLS record layer: Process a received message |
| 265 |
* @rl: Pointer to TLS record layer data |
| 266 |
* @in_data: Received data |
| 267 |
* @in_len: Length of the received data |
| 268 |
* @out_data: Buffer for output data (must be at least as long as in_data) |
| 269 |
* @out_len: Set to maximum out_data length by caller; used to return the |
| 270 |
* length of the used data |
| 271 |
* @alert: Buffer for returning an alert value on failure |
| 272 |
* Returns: Number of bytes used from in_data on success, 0 if record was not |
| 273 |
* complete (more data needed), or -1 on failure |
| 274 |
* |
| 275 |
* This function decrypts the received message, verifies HMAC and TLS record |
| 276 |
* layer header. |
| 277 |
*/ |
| 278 |
int tlsv1_record_receive(struct tlsv1_record_layer *rl, |
| 279 |
const u8 *in_data, size_t in_len, |
| 280 |
u8 *out_data, size_t *out_len, u8 *alert) |
| 281 |
{ |
| 282 |
size_t i, rlen, hlen; |
| 283 |
u8 padlen; |
| 284 |
struct crypto_hash *hmac; |
| 285 |
u8 len[2], hash[100]; |
| 286 |
int force_mac_error = 0; |
| 287 |
u8 ct; |
| 288 |
|
| 289 |
if (in_len < TLS_RECORD_HEADER_LEN) { |
| 290 |
wpa_printf(MSG_DEBUG, "TLSv1: Too short record (in_len=%lu) - " |
| 291 |
"need more data", |
| 292 |
(unsigned long) in_len); |
| 293 |
wpa_hexdump(MSG_MSGDUMP, "TLSv1: Record Layer - Received", |
| 294 |
in_data, in_len); |
| 295 |
return 0; |
| 296 |
} |
| 297 |
|
| 298 |
ct = in_data[0]; |
| 299 |
rlen = WPA_GET_BE16(in_data + 3); |
| 300 |
wpa_printf(MSG_DEBUG, "TLSv1: Received content type %d version %d.%d " |
| 301 |
"length %d", ct, in_data[1], in_data[2], (int) rlen); |
| 302 |
|
| 303 |
/* |
| 304 |
* TLS v1.0 and v1.1 RFCs were not exactly clear on the use of the |
| 305 |
* protocol version in record layer. As such, accept any {03,xx} value |
| 306 |
* to remain compatible with existing implementations. |
| 307 |
*/ |
| 308 |
if (in_data[1] != 0x03) { |
| 309 |
wpa_printf(MSG_DEBUG, "TLSv1: Unexpected protocol version " |
| 310 |
"%u.%u", in_data[1], in_data[2]); |
| 311 |
*alert = TLS_ALERT_PROTOCOL_VERSION; |
| 312 |
return -1; |
| 313 |
} |
| 314 |
|
| 315 |
/* TLSCiphertext must not be more than 2^14+2048 bytes */ |
| 316 |
if (TLS_RECORD_HEADER_LEN + rlen > 18432) { |
| 317 |
wpa_printf(MSG_DEBUG, "TLSv1: Record overflow (len=%lu)", |
| 318 |
(unsigned long) (TLS_RECORD_HEADER_LEN + rlen)); |
| 319 |
*alert = TLS_ALERT_RECORD_OVERFLOW; |
| 320 |
return -1; |
| 321 |
} |
| 322 |
|
| 323 |
in_data += TLS_RECORD_HEADER_LEN; |
| 324 |
in_len -= TLS_RECORD_HEADER_LEN; |
| 325 |
|
| 326 |
if (rlen > in_len) { |
| 327 |
wpa_printf(MSG_DEBUG, "TLSv1: Not all record data included " |
| 328 |
"(rlen=%lu > in_len=%lu)", |
| 329 |
(unsigned long) rlen, (unsigned long) in_len); |
| 330 |
return 0; |
| 331 |
} |
| 332 |
|
| 333 |
wpa_hexdump(MSG_MSGDUMP, "TLSv1: Record Layer - Received", |
| 334 |
in_data, rlen); |
| 335 |
|
| 336 |
if (ct != TLS_CONTENT_TYPE_HANDSHAKE && |
| 337 |
ct != TLS_CONTENT_TYPE_CHANGE_CIPHER_SPEC && |
| 338 |
ct != TLS_CONTENT_TYPE_ALERT && |
| 339 |
ct != TLS_CONTENT_TYPE_APPLICATION_DATA) { |
| 340 |
wpa_printf(MSG_DEBUG, "TLSv1: Ignore record with unknown " |
| 341 |
"content type 0x%x", ct); |
| 342 |
*alert = TLS_ALERT_UNEXPECTED_MESSAGE; |
| 343 |
return -1; |
| 344 |
} |
| 345 |
|
| 346 |
in_len = rlen; |
| 347 |
|
| 348 |
if (*out_len < in_len) { |
| 349 |
wpa_printf(MSG_DEBUG, "TLSv1: Not enough output buffer for " |
| 350 |
"processing received record"); |
| 351 |
*alert = TLS_ALERT_INTERNAL_ERROR; |
| 352 |
return -1; |
| 353 |
} |
| 354 |
|
| 355 |
if (rl->read_cipher_suite != TLS_NULL_WITH_NULL_NULL) { |
| 356 |
size_t plen; |
| 357 |
if (crypto_cipher_decrypt(rl->read_cbc, in_data, |
| 358 |
out_data, in_len) < 0) { |
| 359 |
*alert = TLS_ALERT_DECRYPTION_FAILED; |
| 360 |
return -1; |
| 361 |
} |
| 362 |
plen = in_len; |
| 363 |
wpa_hexdump_key(MSG_MSGDUMP, "TLSv1: Record Layer - Decrypted " |
| 364 |
"data", out_data, plen); |
| 365 |
|
| 366 |
if (rl->iv_size) { |
| 367 |
/* |
| 368 |
* TLS v1.0 defines different alert values for various |
| 369 |
* failures. That may information to aid in attacks, so |
| 370 |
* use the same bad_record_mac alert regardless of the |
| 371 |
* issues. |
| 372 |
* |
| 373 |
* In addition, instead of returning immediately on |
| 374 |
* error, run through the MAC check to make timing |
| 375 |
* attacks more difficult. |
| 376 |
*/ |
| 377 |
|
| 378 |
if (rl->tls_version >= TLS_VERSION_1_1) { |
| 379 |
/* Remove opaque IV[Cipherspec.block_length] */ |
| 380 |
if (plen < rl->iv_size) { |
| 381 |
wpa_printf(MSG_DEBUG, "TLSv1.1: Not " |
| 382 |
"enough room for IV"); |
| 383 |
force_mac_error = 1; |
| 384 |
goto check_mac; |
| 385 |
} |
| 386 |
os_memmove(out_data, out_data + rl->iv_size, |
| 387 |
plen - rl->iv_size); |
| 388 |
plen -= rl->iv_size; |
| 389 |
} |
| 390 |
|
| 391 |
/* Verify and remove padding */ |
| 392 |
if (plen == 0) { |
| 393 |
wpa_printf(MSG_DEBUG, "TLSv1: Too short record" |
| 394 |
" (no pad)"); |
| 395 |
force_mac_error = 1; |
| 396 |
goto check_mac; |
| 397 |
} |
| 398 |
padlen = out_data[plen - 1]; |
| 399 |
if (padlen >= plen) { |
| 400 |
wpa_printf(MSG_DEBUG, "TLSv1: Incorrect pad " |
| 401 |
"length (%u, plen=%lu) in " |
| 402 |
"received record", |
| 403 |
padlen, (unsigned long) plen); |
| 404 |
force_mac_error = 1; |
| 405 |
goto check_mac; |
| 406 |
} |
| 407 |
for (i = plen - padlen - 1; i < plen - 1; i++) { |
| 408 |
if (out_data[i] != padlen) { |
| 409 |
wpa_hexdump(MSG_DEBUG, |
| 410 |
"TLSv1: Invalid pad in " |
| 411 |
"received record", |
| 412 |
out_data + plen - padlen - |
| 413 |
1, padlen + 1); |
| 414 |
force_mac_error = 1; |
| 415 |
goto check_mac; |
| 416 |
} |
| 417 |
} |
| 418 |
|
| 419 |
plen -= padlen + 1; |
| 420 |
|
| 421 |
wpa_hexdump_key(MSG_MSGDUMP, "TLSv1: Record Layer - " |
| 422 |
"Decrypted data with IV and padding " |
| 423 |
"removed", out_data, plen); |
| 424 |
} |
| 425 |
|
| 426 |
check_mac: |
| 427 |
if (plen < rl->hash_size) { |
| 428 |
wpa_printf(MSG_DEBUG, "TLSv1: Too short record; no " |
| 429 |
"hash value"); |
| 430 |
*alert = TLS_ALERT_BAD_RECORD_MAC; |
| 431 |
return -1; |
| 432 |
} |
| 433 |
|
| 434 |
plen -= rl->hash_size; |
| 435 |
|
| 436 |
hmac = crypto_hash_init(rl->hash_alg, rl->read_mac_secret, |
| 437 |
rl->hash_size); |
| 438 |
if (hmac == NULL) { |
| 439 |
wpa_printf(MSG_DEBUG, "TLSv1: Record Layer - Failed " |
| 440 |
"to initialize HMAC"); |
| 441 |
*alert = TLS_ALERT_INTERNAL_ERROR; |
| 442 |
return -1; |
| 443 |
} |
| 444 |
|
| 445 |
crypto_hash_update(hmac, rl->read_seq_num, TLS_SEQ_NUM_LEN); |
| 446 |
/* type + version + length + fragment */ |
| 447 |
crypto_hash_update(hmac, in_data - TLS_RECORD_HEADER_LEN, 3); |
| 448 |
WPA_PUT_BE16(len, plen); |
| 449 |
crypto_hash_update(hmac, len, 2); |
| 450 |
crypto_hash_update(hmac, out_data, plen); |
| 451 |
hlen = sizeof(hash); |
| 452 |
if (crypto_hash_finish(hmac, hash, &hlen) < 0) { |
| 453 |
wpa_printf(MSG_DEBUG, "TLSv1: Record Layer - Failed " |
| 454 |
"to calculate HMAC"); |
| 455 |
*alert = TLS_ALERT_INTERNAL_ERROR; |
| 456 |
return -1; |
| 457 |
} |
| 458 |
if (hlen != rl->hash_size || |
| 459 |
os_memcmp_const(hash, out_data + plen, hlen) != 0 || |
| 460 |
force_mac_error) { |
| 461 |
wpa_printf(MSG_DEBUG, "TLSv1: Invalid HMAC value in " |
| 462 |
"received message (force_mac_error=%d)", |
| 463 |
force_mac_error); |
| 464 |
*alert = TLS_ALERT_BAD_RECORD_MAC; |
| 465 |
return -1; |
| 466 |
} |
| 467 |
|
| 468 |
*out_len = plen; |
| 469 |
} else { |
| 470 |
os_memcpy(out_data, in_data, in_len); |
| 471 |
*out_len = in_len; |
| 472 |
} |
| 473 |
|
| 474 |
/* TLSCompressed must not be more than 2^14+1024 bytes */ |
| 475 |
if (TLS_RECORD_HEADER_LEN + *out_len > 17408) { |
| 476 |
wpa_printf(MSG_DEBUG, "TLSv1: Record overflow (len=%lu)", |
| 477 |
(unsigned long) (TLS_RECORD_HEADER_LEN + *out_len)); |
| 478 |
*alert = TLS_ALERT_RECORD_OVERFLOW; |
| 479 |
return -1; |
| 480 |
} |
| 481 |
|
| 482 |
inc_byte_array(rl->read_seq_num, TLS_SEQ_NUM_LEN); |
| 483 |
|
| 484 |
return TLS_RECORD_HEADER_LEN + rlen; |
| 485 |
} |