1 // SPDX-License-Identifier: GPL-2.0 2 3 #define _GNU_SOURCE 4 5 #include <arpa/inet.h> 6 #include <errno.h> 7 #include <error.h> 8 #include <fcntl.h> 9 #include <poll.h> 10 #include <stdio.h> 11 #include <stdlib.h> 12 #include <unistd.h> 13 14 #include <linux/tls.h> 15 #include <linux/tcp.h> 16 #include <linux/socket.h> 17 18 #include <sys/epoll.h> 19 #include <sys/types.h> 20 #include <sys/sendfile.h> 21 #include <sys/socket.h> 22 #include <sys/stat.h> 23 24 #include "kselftest_harness.h" 25 26 #define TLS_PAYLOAD_MAX_LEN 16384 27 #define SOL_TLS 282 28 29 static int fips_enabled; 30 31 struct tls_crypto_info_keys { 32 union { 33 struct tls_crypto_info crypto_info; 34 struct tls12_crypto_info_aes_gcm_128 aes128; 35 struct tls12_crypto_info_chacha20_poly1305 chacha20; 36 struct tls12_crypto_info_sm4_gcm sm4gcm; 37 struct tls12_crypto_info_sm4_ccm sm4ccm; 38 struct tls12_crypto_info_aes_ccm_128 aesccm128; 39 struct tls12_crypto_info_aes_gcm_256 aesgcm256; 40 struct tls12_crypto_info_aria_gcm_128 ariagcm128; 41 struct tls12_crypto_info_aria_gcm_256 ariagcm256; 42 }; 43 size_t len; 44 }; 45 46 static void tls_crypto_info_init(uint16_t tls_version, uint16_t cipher_type, 47 struct tls_crypto_info_keys *tls12, 48 char key_generation) 49 { 50 memset(tls12, key_generation, sizeof(*tls12)); 51 memset(tls12, 0, sizeof(struct tls_crypto_info)); 52 53 switch (cipher_type) { 54 case TLS_CIPHER_CHACHA20_POLY1305: 55 tls12->len = sizeof(struct tls12_crypto_info_chacha20_poly1305); 56 tls12->chacha20.info.version = tls_version; 57 tls12->chacha20.info.cipher_type = cipher_type; 58 break; 59 case TLS_CIPHER_AES_GCM_128: 60 tls12->len = sizeof(struct tls12_crypto_info_aes_gcm_128); 61 tls12->aes128.info.version = tls_version; 62 tls12->aes128.info.cipher_type = cipher_type; 63 break; 64 case TLS_CIPHER_SM4_GCM: 65 tls12->len = sizeof(struct tls12_crypto_info_sm4_gcm); 66 tls12->sm4gcm.info.version = tls_version; 67 tls12->sm4gcm.info.cipher_type = cipher_type; 68 break; 69 case TLS_CIPHER_SM4_CCM: 70 tls12->len = sizeof(struct tls12_crypto_info_sm4_ccm); 71 tls12->sm4ccm.info.version = tls_version; 72 tls12->sm4ccm.info.cipher_type = cipher_type; 73 break; 74 case TLS_CIPHER_AES_CCM_128: 75 tls12->len = sizeof(struct tls12_crypto_info_aes_ccm_128); 76 tls12->aesccm128.info.version = tls_version; 77 tls12->aesccm128.info.cipher_type = cipher_type; 78 break; 79 case TLS_CIPHER_AES_GCM_256: 80 tls12->len = sizeof(struct tls12_crypto_info_aes_gcm_256); 81 tls12->aesgcm256.info.version = tls_version; 82 tls12->aesgcm256.info.cipher_type = cipher_type; 83 break; 84 case TLS_CIPHER_ARIA_GCM_128: 85 tls12->len = sizeof(struct tls12_crypto_info_aria_gcm_128); 86 tls12->ariagcm128.info.version = tls_version; 87 tls12->ariagcm128.info.cipher_type = cipher_type; 88 break; 89 case TLS_CIPHER_ARIA_GCM_256: 90 tls12->len = sizeof(struct tls12_crypto_info_aria_gcm_256); 91 tls12->ariagcm256.info.version = tls_version; 92 tls12->ariagcm256.info.cipher_type = cipher_type; 93 break; 94 default: 95 break; 96 } 97 } 98 99 static void memrnd(void *s, size_t n) 100 { 101 int *dword = s; 102 char *byte; 103 104 for (; n >= 4; n -= 4) 105 *dword++ = rand(); 106 byte = (void *)dword; 107 while (n--) 108 *byte++ = rand(); 109 } 110 111 static void ulp_sock_pair(struct __test_metadata *_metadata, 112 int *fd, int *cfd, bool *notls) 113 { 114 struct sockaddr_in addr; 115 socklen_t len; 116 int sfd, ret; 117 118 *notls = false; 119 len = sizeof(addr); 120 121 addr.sin_family = AF_INET; 122 addr.sin_addr.s_addr = htonl(INADDR_ANY); 123 addr.sin_port = 0; 124 125 *fd = socket(AF_INET, SOCK_STREAM, 0); 126 sfd = socket(AF_INET, SOCK_STREAM, 0); 127 128 ret = bind(sfd, &addr, sizeof(addr)); 129 ASSERT_EQ(ret, 0); 130 ret = listen(sfd, 10); 131 ASSERT_EQ(ret, 0); 132 133 ret = getsockname(sfd, &addr, &len); 134 ASSERT_EQ(ret, 0); 135 136 ret = connect(*fd, &addr, sizeof(addr)); 137 ASSERT_EQ(ret, 0); 138 139 *cfd = accept(sfd, &addr, &len); 140 ASSERT_GE(*cfd, 0); 141 142 close(sfd); 143 144 ret = setsockopt(*fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 145 if (ret != 0) { 146 ASSERT_EQ(errno, ENOENT); 147 *notls = true; 148 printf("Failure setting TCP_ULP, testing without tls\n"); 149 return; 150 } 151 152 ret = setsockopt(*cfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 153 ASSERT_EQ(ret, 0); 154 } 155 156 /* Produce a basic cmsg */ 157 static int tls_send_cmsg(int fd, unsigned char record_type, 158 void *data, size_t len, int flags) 159 { 160 char cbuf[CMSG_SPACE(sizeof(char))]; 161 int cmsg_len = sizeof(char); 162 struct cmsghdr *cmsg; 163 struct msghdr msg; 164 struct iovec vec; 165 166 vec.iov_base = data; 167 vec.iov_len = len; 168 memset(&msg, 0, sizeof(struct msghdr)); 169 msg.msg_iov = &vec; 170 msg.msg_iovlen = 1; 171 msg.msg_control = cbuf; 172 msg.msg_controllen = sizeof(cbuf); 173 cmsg = CMSG_FIRSTHDR(&msg); 174 cmsg->cmsg_level = SOL_TLS; 175 /* test sending non-record types. */ 176 cmsg->cmsg_type = TLS_SET_RECORD_TYPE; 177 cmsg->cmsg_len = CMSG_LEN(cmsg_len); 178 *CMSG_DATA(cmsg) = record_type; 179 msg.msg_controllen = cmsg->cmsg_len; 180 181 return sendmsg(fd, &msg, flags); 182 } 183 184 static int __tls_recv_cmsg(struct __test_metadata *_metadata, 185 int fd, unsigned char *ctype, 186 void *data, size_t len, int flags) 187 { 188 char cbuf[CMSG_SPACE(sizeof(char))]; 189 struct cmsghdr *cmsg; 190 struct msghdr msg; 191 struct iovec vec; 192 int n; 193 194 vec.iov_base = data; 195 vec.iov_len = len; 196 memset(&msg, 0, sizeof(struct msghdr)); 197 msg.msg_iov = &vec; 198 msg.msg_iovlen = 1; 199 msg.msg_control = cbuf; 200 msg.msg_controllen = sizeof(cbuf); 201 202 n = recvmsg(fd, &msg, flags); 203 204 cmsg = CMSG_FIRSTHDR(&msg); 205 EXPECT_NE(cmsg, NULL); 206 EXPECT_EQ(cmsg->cmsg_level, SOL_TLS); 207 EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE); 208 if (ctype) 209 *ctype = *((unsigned char *)CMSG_DATA(cmsg)); 210 211 return n; 212 } 213 214 static int tls_recv_cmsg(struct __test_metadata *_metadata, 215 int fd, unsigned char record_type, 216 void *data, size_t len, int flags) 217 { 218 unsigned char ctype; 219 int n; 220 221 n = __tls_recv_cmsg(_metadata, fd, &ctype, data, len, flags); 222 EXPECT_EQ(ctype, record_type); 223 224 return n; 225 } 226 227 FIXTURE(tls_basic) 228 { 229 int fd, cfd; 230 bool notls; 231 }; 232 233 FIXTURE_SETUP(tls_basic) 234 { 235 ulp_sock_pair(_metadata, &self->fd, &self->cfd, &self->notls); 236 } 237 238 FIXTURE_TEARDOWN(tls_basic) 239 { 240 close(self->fd); 241 close(self->cfd); 242 } 243 244 /* Send some data through with ULP but no keys */ 245 TEST_F(tls_basic, base_base) 246 { 247 char const *test_str = "test_read"; 248 int send_len = 10; 249 char buf[10]; 250 251 ASSERT_EQ(strlen(test_str) + 1, send_len); 252 253 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 254 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1); 255 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 256 }; 257 258 TEST_F(tls_basic, bad_cipher) 259 { 260 struct tls_crypto_info_keys tls12; 261 262 tls12.crypto_info.version = 200; 263 tls12.crypto_info.cipher_type = TLS_CIPHER_AES_GCM_128; 264 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, sizeof(struct tls12_crypto_info_aes_gcm_128)), -1); 265 266 tls12.crypto_info.version = TLS_1_2_VERSION; 267 tls12.crypto_info.cipher_type = 50; 268 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, sizeof(struct tls12_crypto_info_aes_gcm_128)), -1); 269 270 tls12.crypto_info.version = TLS_1_2_VERSION; 271 tls12.crypto_info.cipher_type = 59; 272 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, sizeof(struct tls12_crypto_info_aes_gcm_128)), -1); 273 274 tls12.crypto_info.version = TLS_1_2_VERSION; 275 tls12.crypto_info.cipher_type = 10; 276 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, sizeof(struct tls12_crypto_info_aes_gcm_128)), -1); 277 278 tls12.crypto_info.version = TLS_1_2_VERSION; 279 tls12.crypto_info.cipher_type = 70; 280 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, sizeof(struct tls12_crypto_info_aes_gcm_128)), -1); 281 } 282 283 TEST_F(tls_basic, recseq_wrap) 284 { 285 struct tls_crypto_info_keys tls12; 286 char const *test_str = "test_read"; 287 int send_len = 10; 288 289 if (self->notls) 290 SKIP(return, "no TLS support"); 291 292 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_GCM_128, &tls12, 0); 293 memset(&tls12.aes128.rec_seq, 0xff, sizeof(tls12.aes128.rec_seq)); 294 295 ASSERT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 296 ASSERT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 297 298 EXPECT_EQ(send(self->fd, test_str, send_len, 0), -1); 299 EXPECT_EQ(errno, EBADMSG); 300 } 301 302 FIXTURE(tls) 303 { 304 int fd, cfd; 305 bool notls; 306 }; 307 308 FIXTURE_VARIANT(tls) 309 { 310 uint16_t tls_version; 311 uint16_t cipher_type; 312 bool nopad, fips_non_compliant; 313 }; 314 315 FIXTURE_VARIANT_ADD(tls, 12_aes_gcm) 316 { 317 .tls_version = TLS_1_2_VERSION, 318 .cipher_type = TLS_CIPHER_AES_GCM_128, 319 }; 320 321 FIXTURE_VARIANT_ADD(tls, 13_aes_gcm) 322 { 323 .tls_version = TLS_1_3_VERSION, 324 .cipher_type = TLS_CIPHER_AES_GCM_128, 325 }; 326 327 FIXTURE_VARIANT_ADD(tls, 12_chacha) 328 { 329 .tls_version = TLS_1_2_VERSION, 330 .cipher_type = TLS_CIPHER_CHACHA20_POLY1305, 331 .fips_non_compliant = true, 332 }; 333 334 FIXTURE_VARIANT_ADD(tls, 13_chacha) 335 { 336 .tls_version = TLS_1_3_VERSION, 337 .cipher_type = TLS_CIPHER_CHACHA20_POLY1305, 338 .fips_non_compliant = true, 339 }; 340 341 FIXTURE_VARIANT_ADD(tls, 13_sm4_gcm) 342 { 343 .tls_version = TLS_1_3_VERSION, 344 .cipher_type = TLS_CIPHER_SM4_GCM, 345 .fips_non_compliant = true, 346 }; 347 348 FIXTURE_VARIANT_ADD(tls, 13_sm4_ccm) 349 { 350 .tls_version = TLS_1_3_VERSION, 351 .cipher_type = TLS_CIPHER_SM4_CCM, 352 .fips_non_compliant = true, 353 }; 354 355 FIXTURE_VARIANT_ADD(tls, 12_aes_ccm) 356 { 357 .tls_version = TLS_1_2_VERSION, 358 .cipher_type = TLS_CIPHER_AES_CCM_128, 359 }; 360 361 FIXTURE_VARIANT_ADD(tls, 13_aes_ccm) 362 { 363 .tls_version = TLS_1_3_VERSION, 364 .cipher_type = TLS_CIPHER_AES_CCM_128, 365 }; 366 367 FIXTURE_VARIANT_ADD(tls, 12_aes_gcm_256) 368 { 369 .tls_version = TLS_1_2_VERSION, 370 .cipher_type = TLS_CIPHER_AES_GCM_256, 371 }; 372 373 FIXTURE_VARIANT_ADD(tls, 13_aes_gcm_256) 374 { 375 .tls_version = TLS_1_3_VERSION, 376 .cipher_type = TLS_CIPHER_AES_GCM_256, 377 }; 378 379 FIXTURE_VARIANT_ADD(tls, 13_nopad) 380 { 381 .tls_version = TLS_1_3_VERSION, 382 .cipher_type = TLS_CIPHER_AES_GCM_128, 383 .nopad = true, 384 }; 385 386 FIXTURE_VARIANT_ADD(tls, 12_aria_gcm) 387 { 388 .tls_version = TLS_1_2_VERSION, 389 .cipher_type = TLS_CIPHER_ARIA_GCM_128, 390 }; 391 392 FIXTURE_VARIANT_ADD(tls, 12_aria_gcm_256) 393 { 394 .tls_version = TLS_1_2_VERSION, 395 .cipher_type = TLS_CIPHER_ARIA_GCM_256, 396 }; 397 398 FIXTURE_SETUP(tls) 399 { 400 struct tls_crypto_info_keys tls12; 401 int one = 1; 402 int ret; 403 404 if (fips_enabled && variant->fips_non_compliant) 405 SKIP(return, "Unsupported cipher in FIPS mode"); 406 407 tls_crypto_info_init(variant->tls_version, variant->cipher_type, 408 &tls12, 0); 409 410 ulp_sock_pair(_metadata, &self->fd, &self->cfd, &self->notls); 411 412 if (self->notls) 413 return; 414 415 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len); 416 ASSERT_EQ(ret, 0); 417 418 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len); 419 ASSERT_EQ(ret, 0); 420 421 if (variant->nopad) { 422 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD, 423 (void *)&one, sizeof(one)); 424 ASSERT_EQ(ret, 0); 425 } 426 } 427 428 FIXTURE_TEARDOWN(tls) 429 { 430 close(self->fd); 431 close(self->cfd); 432 } 433 434 TEST_F(tls, sendfile) 435 { 436 int filefd = open("/proc/self/exe", O_RDONLY); 437 struct stat st; 438 439 EXPECT_GE(filefd, 0); 440 fstat(filefd, &st); 441 EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0); 442 443 close(filefd); 444 } 445 446 TEST_F(tls, send_then_sendfile) 447 { 448 int filefd = open("/proc/self/exe", O_RDONLY); 449 char const *test_str = "test_send"; 450 int to_send = strlen(test_str) + 1; 451 char recv_buf[10]; 452 struct stat st; 453 char *buf; 454 455 EXPECT_GE(filefd, 0); 456 fstat(filefd, &st); 457 buf = (char *)malloc(st.st_size); 458 459 EXPECT_EQ(send(self->fd, test_str, to_send, 0), to_send); 460 EXPECT_EQ(recv(self->cfd, recv_buf, to_send, MSG_WAITALL), to_send); 461 EXPECT_EQ(memcmp(test_str, recv_buf, to_send), 0); 462 463 EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0); 464 EXPECT_EQ(recv(self->cfd, buf, st.st_size, MSG_WAITALL), st.st_size); 465 466 free(buf); 467 close(filefd); 468 } 469 470 static void chunked_sendfile(struct __test_metadata *_metadata, 471 struct _test_data_tls *self, 472 uint16_t chunk_size, 473 uint16_t extra_payload_size) 474 { 475 char buf[TLS_PAYLOAD_MAX_LEN]; 476 uint16_t test_payload_size; 477 int size = 0; 478 int ret; 479 char filename[] = "/tmp/mytemp.XXXXXX"; 480 int fd = mkstemp(filename); 481 off_t offset = 0; 482 483 unlink(filename); 484 ASSERT_GE(fd, 0); 485 EXPECT_GE(chunk_size, 1); 486 test_payload_size = chunk_size + extra_payload_size; 487 ASSERT_GE(TLS_PAYLOAD_MAX_LEN, test_payload_size); 488 memset(buf, 1, test_payload_size); 489 size = write(fd, buf, test_payload_size); 490 EXPECT_EQ(size, test_payload_size); 491 fsync(fd); 492 493 while (size > 0) { 494 ret = sendfile(self->fd, fd, &offset, chunk_size); 495 EXPECT_GE(ret, 0); 496 size -= ret; 497 } 498 499 EXPECT_EQ(recv(self->cfd, buf, test_payload_size, MSG_WAITALL), 500 test_payload_size); 501 502 close(fd); 503 } 504 505 TEST_F(tls, multi_chunk_sendfile) 506 { 507 chunked_sendfile(_metadata, self, 4096, 4096); 508 chunked_sendfile(_metadata, self, 4096, 0); 509 chunked_sendfile(_metadata, self, 4096, 1); 510 chunked_sendfile(_metadata, self, 4096, 2048); 511 chunked_sendfile(_metadata, self, 8192, 2048); 512 chunked_sendfile(_metadata, self, 4096, 8192); 513 chunked_sendfile(_metadata, self, 8192, 4096); 514 chunked_sendfile(_metadata, self, 12288, 1024); 515 chunked_sendfile(_metadata, self, 12288, 2000); 516 chunked_sendfile(_metadata, self, 15360, 100); 517 chunked_sendfile(_metadata, self, 15360, 300); 518 chunked_sendfile(_metadata, self, 1, 4096); 519 chunked_sendfile(_metadata, self, 2048, 4096); 520 chunked_sendfile(_metadata, self, 2048, 8192); 521 chunked_sendfile(_metadata, self, 4096, 8192); 522 chunked_sendfile(_metadata, self, 1024, 12288); 523 chunked_sendfile(_metadata, self, 2000, 12288); 524 chunked_sendfile(_metadata, self, 100, 15360); 525 chunked_sendfile(_metadata, self, 300, 15360); 526 } 527 528 TEST_F(tls, recv_max) 529 { 530 unsigned int send_len = TLS_PAYLOAD_MAX_LEN; 531 char recv_mem[TLS_PAYLOAD_MAX_LEN]; 532 char buf[TLS_PAYLOAD_MAX_LEN]; 533 534 memrnd(buf, sizeof(buf)); 535 536 EXPECT_GE(send(self->fd, buf, send_len, 0), 0); 537 EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1); 538 EXPECT_EQ(memcmp(buf, recv_mem, send_len), 0); 539 } 540 541 TEST_F(tls, recv_small) 542 { 543 char const *test_str = "test_read"; 544 int send_len = 10; 545 char buf[10]; 546 547 send_len = strlen(test_str) + 1; 548 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 549 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1); 550 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 551 } 552 553 TEST_F(tls, msg_more) 554 { 555 char const *test_str = "test_read"; 556 int send_len = 10; 557 char buf[10 * 2]; 558 559 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len); 560 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1); 561 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 562 EXPECT_EQ(recv(self->cfd, buf, send_len * 2, MSG_WAITALL), 563 send_len * 2); 564 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 565 } 566 567 TEST_F(tls, cmsg_msg_more) 568 { 569 char *test_str = "test_read"; 570 char record_type = 100; 571 int send_len = 10; 572 573 /* we don't allow MSG_MORE with non-DATA records */ 574 EXPECT_EQ(tls_send_cmsg(self->fd, record_type, test_str, send_len, 575 MSG_MORE), -1); 576 EXPECT_EQ(errno, EINVAL); 577 } 578 579 TEST_F(tls, msg_more_then_cmsg) 580 { 581 char *test_str = "test_read"; 582 char record_type = 100; 583 int send_len = 10; 584 char buf[10 * 2]; 585 int ret; 586 587 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len); 588 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1); 589 590 ret = tls_send_cmsg(self->fd, record_type, test_str, send_len, 0); 591 EXPECT_EQ(ret, send_len); 592 593 /* initial DATA record didn't get merged with the non-DATA record */ 594 EXPECT_EQ(recv(self->cfd, buf, send_len * 2, 0), send_len); 595 596 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type, 597 buf, sizeof(buf), MSG_WAITALL), 598 send_len); 599 } 600 601 TEST_F(tls, msg_more_unsent) 602 { 603 char const *test_str = "test_read"; 604 int send_len = 10; 605 char buf[10]; 606 607 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len); 608 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1); 609 } 610 611 TEST_F(tls, msg_eor) 612 { 613 char const *test_str = "test_read"; 614 int send_len = 10; 615 char buf[10]; 616 617 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_EOR), send_len); 618 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len); 619 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 620 } 621 622 TEST_F(tls, sendmsg_single) 623 { 624 struct msghdr msg; 625 626 char const *test_str = "test_sendmsg"; 627 size_t send_len = 13; 628 struct iovec vec; 629 char buf[13]; 630 631 vec.iov_base = (char *)test_str; 632 vec.iov_len = send_len; 633 memset(&msg, 0, sizeof(struct msghdr)); 634 msg.msg_iov = &vec; 635 msg.msg_iovlen = 1; 636 EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len); 637 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len); 638 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 639 } 640 641 #define MAX_FRAGS 64 642 #define SEND_LEN 13 643 TEST_F(tls, sendmsg_fragmented) 644 { 645 char const *test_str = "test_sendmsg"; 646 char buf[SEND_LEN * MAX_FRAGS]; 647 struct iovec vec[MAX_FRAGS]; 648 struct msghdr msg; 649 int i, frags; 650 651 for (frags = 1; frags <= MAX_FRAGS; frags++) { 652 for (i = 0; i < frags; i++) { 653 vec[i].iov_base = (char *)test_str; 654 vec[i].iov_len = SEND_LEN; 655 } 656 657 memset(&msg, 0, sizeof(struct msghdr)); 658 msg.msg_iov = vec; 659 msg.msg_iovlen = frags; 660 661 EXPECT_EQ(sendmsg(self->fd, &msg, 0), SEND_LEN * frags); 662 EXPECT_EQ(recv(self->cfd, buf, SEND_LEN * frags, MSG_WAITALL), 663 SEND_LEN * frags); 664 665 for (i = 0; i < frags; i++) 666 EXPECT_EQ(memcmp(buf + SEND_LEN * i, 667 test_str, SEND_LEN), 0); 668 } 669 } 670 #undef MAX_FRAGS 671 #undef SEND_LEN 672 673 TEST_F(tls, sendmsg_large) 674 { 675 void *mem = malloc(16384); 676 size_t send_len = 16384; 677 size_t sends = 128; 678 struct msghdr msg; 679 size_t recvs = 0; 680 size_t sent = 0; 681 682 memset(&msg, 0, sizeof(struct msghdr)); 683 while (sent++ < sends) { 684 struct iovec vec = { (void *)mem, send_len }; 685 686 msg.msg_iov = &vec; 687 msg.msg_iovlen = 1; 688 EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len); 689 } 690 691 while (recvs++ < sends) { 692 EXPECT_NE(recv(self->cfd, mem, send_len, 0), -1); 693 } 694 695 free(mem); 696 } 697 698 TEST_F(tls, sendmsg_multiple) 699 { 700 char const *test_str = "test_sendmsg_multiple"; 701 struct iovec vec[5]; 702 char *test_strs[5]; 703 struct msghdr msg; 704 int total_len = 0; 705 int len_cmp = 0; 706 int iov_len = 5; 707 char *buf; 708 int i; 709 710 memset(&msg, 0, sizeof(struct msghdr)); 711 for (i = 0; i < iov_len; i++) { 712 test_strs[i] = (char *)malloc(strlen(test_str) + 1); 713 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str); 714 vec[i].iov_base = (void *)test_strs[i]; 715 vec[i].iov_len = strlen(test_strs[i]) + 1; 716 total_len += vec[i].iov_len; 717 } 718 msg.msg_iov = vec; 719 msg.msg_iovlen = iov_len; 720 721 EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len); 722 buf = malloc(total_len); 723 EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1); 724 for (i = 0; i < iov_len; i++) { 725 EXPECT_EQ(memcmp(test_strs[i], buf + len_cmp, 726 strlen(test_strs[i])), 727 0); 728 len_cmp += strlen(buf + len_cmp) + 1; 729 } 730 for (i = 0; i < iov_len; i++) 731 free(test_strs[i]); 732 free(buf); 733 } 734 735 TEST_F(tls, sendmsg_multiple_stress) 736 { 737 char const *test_str = "abcdefghijklmno"; 738 struct iovec vec[1024]; 739 char *test_strs[1024]; 740 int iov_len = 1024; 741 int total_len = 0; 742 char buf[1 << 14]; 743 struct msghdr msg; 744 int len_cmp = 0; 745 int i; 746 747 memset(&msg, 0, sizeof(struct msghdr)); 748 for (i = 0; i < iov_len; i++) { 749 test_strs[i] = (char *)malloc(strlen(test_str) + 1); 750 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str); 751 vec[i].iov_base = (void *)test_strs[i]; 752 vec[i].iov_len = strlen(test_strs[i]) + 1; 753 total_len += vec[i].iov_len; 754 } 755 msg.msg_iov = vec; 756 msg.msg_iovlen = iov_len; 757 758 EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len); 759 EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1); 760 761 for (i = 0; i < iov_len; i++) 762 len_cmp += strlen(buf + len_cmp) + 1; 763 764 for (i = 0; i < iov_len; i++) 765 free(test_strs[i]); 766 } 767 768 TEST_F(tls, splice_from_pipe) 769 { 770 int send_len = TLS_PAYLOAD_MAX_LEN; 771 char mem_send[TLS_PAYLOAD_MAX_LEN]; 772 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 773 int p[2]; 774 775 ASSERT_GE(pipe(p), 0); 776 EXPECT_GE(write(p[1], mem_send, send_len), 0); 777 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), 0); 778 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len); 779 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 780 } 781 782 TEST_F(tls, splice_more) 783 { 784 unsigned int f = SPLICE_F_NONBLOCK | SPLICE_F_MORE | SPLICE_F_GIFT; 785 int send_len = TLS_PAYLOAD_MAX_LEN; 786 char mem_send[TLS_PAYLOAD_MAX_LEN]; 787 int i, send_pipe = 1; 788 int p[2]; 789 790 ASSERT_GE(pipe(p), 0); 791 EXPECT_GE(write(p[1], mem_send, send_len), 0); 792 for (i = 0; i < 32; i++) 793 EXPECT_EQ(splice(p[0], NULL, self->fd, NULL, send_pipe, f), 1); 794 } 795 796 TEST_F(tls, splice_from_pipe2) 797 { 798 int send_len = 16000; 799 char mem_send[16000]; 800 char mem_recv[16000]; 801 int p2[2]; 802 int p[2]; 803 804 memrnd(mem_send, sizeof(mem_send)); 805 806 ASSERT_GE(pipe(p), 0); 807 ASSERT_GE(pipe(p2), 0); 808 EXPECT_EQ(write(p[1], mem_send, 8000), 8000); 809 EXPECT_EQ(splice(p[0], NULL, self->fd, NULL, 8000, 0), 8000); 810 EXPECT_EQ(write(p2[1], mem_send + 8000, 8000), 8000); 811 EXPECT_EQ(splice(p2[0], NULL, self->fd, NULL, 8000, 0), 8000); 812 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len); 813 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 814 } 815 816 TEST_F(tls, send_and_splice) 817 { 818 int send_len = TLS_PAYLOAD_MAX_LEN; 819 char mem_send[TLS_PAYLOAD_MAX_LEN]; 820 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 821 char const *test_str = "test_read"; 822 int send_len2 = 10; 823 char buf[10]; 824 int p[2]; 825 826 ASSERT_GE(pipe(p), 0); 827 EXPECT_EQ(send(self->fd, test_str, send_len2, 0), send_len2); 828 EXPECT_EQ(recv(self->cfd, buf, send_len2, MSG_WAITALL), send_len2); 829 EXPECT_EQ(memcmp(test_str, buf, send_len2), 0); 830 831 EXPECT_GE(write(p[1], mem_send, send_len), send_len); 832 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), send_len); 833 834 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len); 835 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 836 } 837 838 TEST_F(tls, splice_to_pipe) 839 { 840 int send_len = TLS_PAYLOAD_MAX_LEN; 841 char mem_send[TLS_PAYLOAD_MAX_LEN]; 842 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 843 int p[2]; 844 845 memrnd(mem_send, sizeof(mem_send)); 846 847 ASSERT_GE(pipe(p), 0); 848 EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len); 849 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, send_len, 0), send_len); 850 EXPECT_EQ(read(p[0], mem_recv, send_len), send_len); 851 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 852 } 853 854 TEST_F(tls, splice_cmsg_to_pipe) 855 { 856 char *test_str = "test_read"; 857 char record_type = 100; 858 int send_len = 10; 859 char buf[10]; 860 int p[2]; 861 862 if (self->notls) 863 SKIP(return, "no TLS support"); 864 865 ASSERT_GE(pipe(p), 0); 866 EXPECT_EQ(tls_send_cmsg(self->fd, 100, test_str, send_len, 0), 10); 867 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, send_len, 0), -1); 868 EXPECT_EQ(errno, EINVAL); 869 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1); 870 EXPECT_EQ(errno, EIO); 871 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type, 872 buf, sizeof(buf), MSG_WAITALL), 873 send_len); 874 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 875 } 876 877 TEST_F(tls, splice_dec_cmsg_to_pipe) 878 { 879 char *test_str = "test_read"; 880 char record_type = 100; 881 int send_len = 10; 882 char buf[10]; 883 int p[2]; 884 885 if (self->notls) 886 SKIP(return, "no TLS support"); 887 888 ASSERT_GE(pipe(p), 0); 889 EXPECT_EQ(tls_send_cmsg(self->fd, 100, test_str, send_len, 0), 10); 890 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1); 891 EXPECT_EQ(errno, EIO); 892 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, send_len, 0), -1); 893 EXPECT_EQ(errno, EINVAL); 894 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type, 895 buf, sizeof(buf), MSG_WAITALL), 896 send_len); 897 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 898 } 899 900 TEST_F(tls, recv_and_splice) 901 { 902 int send_len = TLS_PAYLOAD_MAX_LEN; 903 char mem_send[TLS_PAYLOAD_MAX_LEN]; 904 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 905 int half = send_len / 2; 906 int p[2]; 907 908 ASSERT_GE(pipe(p), 0); 909 EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len); 910 /* Recv hald of the record, splice the other half */ 911 EXPECT_EQ(recv(self->cfd, mem_recv, half, MSG_WAITALL), half); 912 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, half, SPLICE_F_NONBLOCK), 913 half); 914 EXPECT_EQ(read(p[0], &mem_recv[half], half), half); 915 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 916 } 917 918 TEST_F(tls, peek_and_splice) 919 { 920 int send_len = TLS_PAYLOAD_MAX_LEN; 921 char mem_send[TLS_PAYLOAD_MAX_LEN]; 922 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 923 int chunk = TLS_PAYLOAD_MAX_LEN / 4; 924 int n, i, p[2]; 925 926 memrnd(mem_send, sizeof(mem_send)); 927 928 ASSERT_GE(pipe(p), 0); 929 for (i = 0; i < 4; i++) 930 EXPECT_EQ(send(self->fd, &mem_send[chunk * i], chunk, 0), 931 chunk); 932 933 EXPECT_EQ(recv(self->cfd, mem_recv, chunk * 5 / 2, 934 MSG_WAITALL | MSG_PEEK), 935 chunk * 5 / 2); 936 EXPECT_EQ(memcmp(mem_send, mem_recv, chunk * 5 / 2), 0); 937 938 n = 0; 939 while (n < send_len) { 940 i = splice(self->cfd, NULL, p[1], NULL, send_len - n, 0); 941 EXPECT_GT(i, 0); 942 n += i; 943 } 944 EXPECT_EQ(n, send_len); 945 EXPECT_EQ(read(p[0], mem_recv, send_len), send_len); 946 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 947 } 948 949 TEST_F(tls, splice_to_pipe_small) 950 { 951 int send_len = TLS_PAYLOAD_MAX_LEN; 952 char mem_send[TLS_PAYLOAD_MAX_LEN]; 953 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 954 size_t total = 0; 955 int p[2]; 956 957 memrnd(mem_send, sizeof(mem_send)); 958 959 ASSERT_GE(pipe(p), 0); 960 961 /* Shrink pipe to 1 page (typically 4096 bytes) to force multiple 962 * splice iterations for a 16384-byte TLS record. 963 */ 964 EXPECT_GE(fcntl(p[1], F_SETPIPE_SZ, 4096), 4096); 965 966 EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len); 967 968 while (total < (size_t)send_len) { 969 ssize_t spliced, drained; 970 971 spliced = splice(self->cfd, NULL, p[1], NULL, 972 send_len - total, 0); 973 EXPECT_GT(spliced, 0); 974 if (spliced <= 0) 975 break; 976 977 drained = read(p[0], mem_recv + total, spliced); 978 EXPECT_EQ(drained, spliced); 979 if (drained <= 0) 980 break; 981 982 total += drained; 983 } 984 985 EXPECT_EQ(total, (size_t)send_len); 986 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 987 988 close(p[0]); 989 close(p[1]); 990 } 991 992 #define MAX_FRAGS 48 993 TEST_F(tls, splice_short) 994 { 995 struct iovec sendchar_iov; 996 char read_buf[0x10000]; 997 char sendbuf[0x100]; 998 char sendchar = 'S'; 999 int pipefds[2]; 1000 int i; 1001 1002 sendchar_iov.iov_base = &sendchar; 1003 sendchar_iov.iov_len = 1; 1004 1005 memset(sendbuf, 's', sizeof(sendbuf)); 1006 1007 ASSERT_GE(pipe2(pipefds, O_NONBLOCK), 0); 1008 ASSERT_GE(fcntl(pipefds[0], F_SETPIPE_SZ, (MAX_FRAGS + 1) * 0x1000), 0); 1009 1010 for (i = 0; i < MAX_FRAGS; i++) 1011 ASSERT_GE(vmsplice(pipefds[1], &sendchar_iov, 1, 0), 0); 1012 1013 ASSERT_EQ(write(pipefds[1], sendbuf, sizeof(sendbuf)), sizeof(sendbuf)); 1014 1015 EXPECT_EQ(splice(pipefds[0], NULL, self->fd, NULL, MAX_FRAGS + 0x1000, 0), 1016 MAX_FRAGS + sizeof(sendbuf)); 1017 EXPECT_EQ(recv(self->cfd, read_buf, sizeof(read_buf), 0), MAX_FRAGS + sizeof(sendbuf)); 1018 EXPECT_EQ(recv(self->cfd, read_buf, sizeof(read_buf), MSG_DONTWAIT), -1); 1019 EXPECT_EQ(errno, EAGAIN); 1020 } 1021 #undef MAX_FRAGS 1022 1023 TEST_F(tls, recvmsg_single) 1024 { 1025 char const *test_str = "test_recvmsg_single"; 1026 int send_len = strlen(test_str) + 1; 1027 char buf[20]; 1028 struct msghdr hdr; 1029 struct iovec vec; 1030 1031 memset(&hdr, 0, sizeof(hdr)); 1032 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1033 vec.iov_base = (char *)buf; 1034 vec.iov_len = send_len; 1035 hdr.msg_iovlen = 1; 1036 hdr.msg_iov = &vec; 1037 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1); 1038 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 1039 } 1040 1041 TEST_F(tls, recvmsg_single_max) 1042 { 1043 int send_len = TLS_PAYLOAD_MAX_LEN; 1044 char send_mem[TLS_PAYLOAD_MAX_LEN]; 1045 char recv_mem[TLS_PAYLOAD_MAX_LEN]; 1046 struct iovec vec; 1047 struct msghdr hdr; 1048 1049 memrnd(send_mem, sizeof(send_mem)); 1050 1051 EXPECT_EQ(send(self->fd, send_mem, send_len, 0), send_len); 1052 vec.iov_base = (char *)recv_mem; 1053 vec.iov_len = TLS_PAYLOAD_MAX_LEN; 1054 1055 hdr.msg_iovlen = 1; 1056 hdr.msg_iov = &vec; 1057 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1); 1058 EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0); 1059 } 1060 1061 TEST_F(tls, recvmsg_multiple) 1062 { 1063 unsigned int msg_iovlen = 1024; 1064 struct iovec vec[1024]; 1065 char *iov_base[1024]; 1066 unsigned int iov_len = 16; 1067 int send_len = 1 << 14; 1068 char buf[1 << 14]; 1069 struct msghdr hdr; 1070 int i; 1071 1072 memrnd(buf, sizeof(buf)); 1073 1074 EXPECT_EQ(send(self->fd, buf, send_len, 0), send_len); 1075 for (i = 0; i < msg_iovlen; i++) { 1076 iov_base[i] = (char *)malloc(iov_len); 1077 vec[i].iov_base = iov_base[i]; 1078 vec[i].iov_len = iov_len; 1079 } 1080 1081 hdr.msg_iovlen = msg_iovlen; 1082 hdr.msg_iov = vec; 1083 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1); 1084 1085 for (i = 0; i < msg_iovlen; i++) 1086 free(iov_base[i]); 1087 } 1088 1089 TEST_F(tls, single_send_multiple_recv) 1090 { 1091 unsigned int total_len = TLS_PAYLOAD_MAX_LEN * 2; 1092 unsigned int send_len = TLS_PAYLOAD_MAX_LEN; 1093 char send_mem[TLS_PAYLOAD_MAX_LEN * 2]; 1094 char recv_mem[TLS_PAYLOAD_MAX_LEN * 2]; 1095 1096 memrnd(send_mem, sizeof(send_mem)); 1097 1098 EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0); 1099 memset(recv_mem, 0, total_len); 1100 1101 EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1); 1102 EXPECT_NE(recv(self->cfd, recv_mem + send_len, send_len, 0), -1); 1103 EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0); 1104 } 1105 1106 TEST_F(tls, multiple_send_single_recv) 1107 { 1108 unsigned int total_len = 2 * 10; 1109 unsigned int send_len = 10; 1110 char recv_mem[2 * 10]; 1111 char send_mem[10]; 1112 1113 memrnd(send_mem, sizeof(send_mem)); 1114 1115 EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0); 1116 EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0); 1117 memset(recv_mem, 0, total_len); 1118 EXPECT_EQ(recv(self->cfd, recv_mem, total_len, MSG_WAITALL), total_len); 1119 1120 EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0); 1121 EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0); 1122 } 1123 1124 TEST_F(tls, single_send_multiple_recv_non_align) 1125 { 1126 const unsigned int total_len = 15; 1127 const unsigned int recv_len = 10; 1128 char recv_mem[recv_len * 2]; 1129 char send_mem[total_len]; 1130 1131 memrnd(send_mem, sizeof(send_mem)); 1132 1133 EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0); 1134 memset(recv_mem, 0, total_len); 1135 1136 EXPECT_EQ(recv(self->cfd, recv_mem, recv_len, 0), recv_len); 1137 EXPECT_EQ(recv(self->cfd, recv_mem + recv_len, recv_len, 0), 5); 1138 EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0); 1139 } 1140 1141 TEST_F(tls, recv_partial) 1142 { 1143 char const *test_str = "test_read_partial"; 1144 char const *test_str_first = "test_read"; 1145 char const *test_str_second = "_partial"; 1146 int send_len = strlen(test_str) + 1; 1147 char recv_mem[18]; 1148 1149 memset(recv_mem, 0, sizeof(recv_mem)); 1150 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1151 EXPECT_EQ(recv(self->cfd, recv_mem, strlen(test_str_first), 1152 MSG_WAITALL), strlen(test_str_first)); 1153 EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0); 1154 memset(recv_mem, 0, sizeof(recv_mem)); 1155 EXPECT_EQ(recv(self->cfd, recv_mem, strlen(test_str_second), 1156 MSG_WAITALL), strlen(test_str_second)); 1157 EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)), 1158 0); 1159 } 1160 1161 TEST_F(tls, recv_nonblock) 1162 { 1163 char buf[4096]; 1164 bool err; 1165 1166 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1); 1167 err = (errno == EAGAIN || errno == EWOULDBLOCK); 1168 EXPECT_EQ(err, true); 1169 } 1170 1171 TEST_F(tls, recv_peek) 1172 { 1173 char const *test_str = "test_read_peek"; 1174 int send_len = strlen(test_str) + 1; 1175 char buf[15]; 1176 1177 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1178 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_PEEK), send_len); 1179 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 1180 memset(buf, 0, sizeof(buf)); 1181 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 1182 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 1183 } 1184 1185 TEST_F(tls, recv_peek_multiple) 1186 { 1187 char const *test_str = "test_read_peek"; 1188 int send_len = strlen(test_str) + 1; 1189 unsigned int num_peeks = 100; 1190 char buf[15]; 1191 int i; 1192 1193 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1194 for (i = 0; i < num_peeks; i++) { 1195 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1); 1196 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 1197 memset(buf, 0, sizeof(buf)); 1198 } 1199 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1); 1200 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 1201 } 1202 1203 TEST_F(tls, recv_peek_multiple_records) 1204 { 1205 char const *test_str = "test_read_peek_mult_recs"; 1206 char const *test_str_first = "test_read_peek"; 1207 char const *test_str_second = "_mult_recs"; 1208 int len; 1209 char buf[64]; 1210 1211 len = strlen(test_str_first); 1212 EXPECT_EQ(send(self->fd, test_str_first, len, 0), len); 1213 1214 len = strlen(test_str_second) + 1; 1215 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len); 1216 1217 len = strlen(test_str_first); 1218 memset(buf, 0, len); 1219 EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len); 1220 1221 /* MSG_PEEK can only peek into the current record. */ 1222 len = strlen(test_str_first); 1223 EXPECT_EQ(memcmp(test_str_first, buf, len), 0); 1224 1225 len = strlen(test_str) + 1; 1226 memset(buf, 0, len); 1227 EXPECT_EQ(recv(self->cfd, buf, len, MSG_WAITALL), len); 1228 1229 /* Non-MSG_PEEK will advance strparser (and therefore record) 1230 * however. 1231 */ 1232 len = strlen(test_str) + 1; 1233 EXPECT_EQ(memcmp(test_str, buf, len), 0); 1234 1235 /* MSG_MORE will hold current record open, so later MSG_PEEK 1236 * will see everything. 1237 */ 1238 len = strlen(test_str_first); 1239 EXPECT_EQ(send(self->fd, test_str_first, len, MSG_MORE), len); 1240 1241 len = strlen(test_str_second) + 1; 1242 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len); 1243 1244 len = strlen(test_str) + 1; 1245 memset(buf, 0, len); 1246 EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len); 1247 1248 len = strlen(test_str) + 1; 1249 EXPECT_EQ(memcmp(test_str, buf, len), 0); 1250 } 1251 1252 TEST_F(tls, recv_peek_large_buf_mult_recs) 1253 { 1254 char const *test_str = "test_read_peek_mult_recs"; 1255 char const *test_str_first = "test_read_peek"; 1256 char const *test_str_second = "_mult_recs"; 1257 int len; 1258 char buf[64]; 1259 1260 len = strlen(test_str_first); 1261 EXPECT_EQ(send(self->fd, test_str_first, len, 0), len); 1262 1263 len = strlen(test_str_second) + 1; 1264 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len); 1265 1266 len = strlen(test_str) + 1; 1267 memset(buf, 0, len); 1268 EXPECT_NE((len = recv(self->cfd, buf, len, 1269 MSG_PEEK | MSG_WAITALL)), -1); 1270 len = strlen(test_str) + 1; 1271 EXPECT_EQ(memcmp(test_str, buf, len), 0); 1272 } 1273 1274 TEST_F(tls, recv_lowat) 1275 { 1276 char send_mem[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 1277 char recv_mem[20]; 1278 int lowat = 8; 1279 1280 EXPECT_EQ(send(self->fd, send_mem, 10, 0), 10); 1281 EXPECT_EQ(send(self->fd, send_mem, 5, 0), 5); 1282 1283 memset(recv_mem, 0, 20); 1284 EXPECT_EQ(setsockopt(self->cfd, SOL_SOCKET, SO_RCVLOWAT, 1285 &lowat, sizeof(lowat)), 0); 1286 EXPECT_EQ(recv(self->cfd, recv_mem, 1, MSG_WAITALL), 1); 1287 EXPECT_EQ(recv(self->cfd, recv_mem + 1, 6, MSG_WAITALL), 6); 1288 EXPECT_EQ(recv(self->cfd, recv_mem + 7, 10, 0), 8); 1289 1290 EXPECT_EQ(memcmp(send_mem, recv_mem, 10), 0); 1291 EXPECT_EQ(memcmp(send_mem, recv_mem + 10, 5), 0); 1292 } 1293 1294 TEST_F(tls, bidir) 1295 { 1296 char const *test_str = "test_read"; 1297 int send_len = 10; 1298 char buf[10]; 1299 int ret; 1300 1301 if (!self->notls) { 1302 struct tls_crypto_info_keys tls12; 1303 1304 tls_crypto_info_init(variant->tls_version, variant->cipher_type, 1305 &tls12, 0); 1306 1307 ret = setsockopt(self->fd, SOL_TLS, TLS_RX, &tls12, 1308 tls12.len); 1309 ASSERT_EQ(ret, 0); 1310 1311 ret = setsockopt(self->cfd, SOL_TLS, TLS_TX, &tls12, 1312 tls12.len); 1313 ASSERT_EQ(ret, 0); 1314 } 1315 1316 ASSERT_EQ(strlen(test_str) + 1, send_len); 1317 1318 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1319 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1); 1320 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1321 1322 memset(buf, 0, sizeof(buf)); 1323 1324 EXPECT_EQ(send(self->cfd, test_str, send_len, 0), send_len); 1325 EXPECT_NE(recv(self->fd, buf, send_len, 0), -1); 1326 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1327 }; 1328 1329 TEST_F(tls, pollin) 1330 { 1331 char const *test_str = "test_poll"; 1332 struct pollfd fd = { 0, 0, 0 }; 1333 char buf[10]; 1334 int send_len = 10; 1335 1336 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1337 fd.fd = self->cfd; 1338 fd.events = POLLIN; 1339 1340 EXPECT_EQ(poll(&fd, 1, 20), 1); 1341 EXPECT_EQ(fd.revents & POLLIN, 1); 1342 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len); 1343 /* Test timing out */ 1344 EXPECT_EQ(poll(&fd, 1, 20), 0); 1345 } 1346 1347 TEST_F(tls, poll_wait) 1348 { 1349 char const *test_str = "test_poll_wait"; 1350 int send_len = strlen(test_str) + 1; 1351 struct pollfd fd = { 0, 0, 0 }; 1352 char recv_mem[15]; 1353 1354 fd.fd = self->cfd; 1355 fd.events = POLLIN; 1356 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1357 /* Set timeout to inf. secs */ 1358 EXPECT_EQ(poll(&fd, 1, -1), 1); 1359 EXPECT_EQ(fd.revents & POLLIN, 1); 1360 EXPECT_EQ(recv(self->cfd, recv_mem, send_len, MSG_WAITALL), send_len); 1361 } 1362 1363 TEST_F(tls, poll_wait_split) 1364 { 1365 struct pollfd fd = { 0, 0, 0 }; 1366 char send_mem[20] = {}; 1367 char recv_mem[15]; 1368 1369 fd.fd = self->cfd; 1370 fd.events = POLLIN; 1371 /* Send 20 bytes */ 1372 EXPECT_EQ(send(self->fd, send_mem, sizeof(send_mem), 0), 1373 sizeof(send_mem)); 1374 /* Poll with inf. timeout */ 1375 EXPECT_EQ(poll(&fd, 1, -1), 1); 1376 EXPECT_EQ(fd.revents & POLLIN, 1); 1377 EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), MSG_WAITALL), 1378 sizeof(recv_mem)); 1379 1380 /* Now the remaining 5 bytes of record data are in TLS ULP */ 1381 fd.fd = self->cfd; 1382 fd.events = POLLIN; 1383 EXPECT_EQ(poll(&fd, 1, -1), 1); 1384 EXPECT_EQ(fd.revents & POLLIN, 1); 1385 EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), 0), 1386 sizeof(send_mem) - sizeof(recv_mem)); 1387 } 1388 1389 TEST_F(tls, blocking) 1390 { 1391 size_t data = 100000; 1392 int res = fork(); 1393 1394 EXPECT_NE(res, -1); 1395 1396 if (res) { 1397 /* parent */ 1398 size_t left = data; 1399 char buf[16384]; 1400 int status; 1401 int pid2; 1402 1403 while (left) { 1404 int res = send(self->fd, buf, 1405 left > 16384 ? 16384 : left, 0); 1406 1407 EXPECT_GE(res, 0); 1408 left -= res; 1409 } 1410 1411 pid2 = wait(&status); 1412 EXPECT_EQ(status, 0); 1413 EXPECT_EQ(res, pid2); 1414 } else { 1415 /* child */ 1416 size_t left = data; 1417 char buf[16384]; 1418 1419 while (left) { 1420 int res = recv(self->cfd, buf, 1421 left > 16384 ? 16384 : left, 0); 1422 1423 EXPECT_GE(res, 0); 1424 left -= res; 1425 } 1426 } 1427 } 1428 1429 TEST_F(tls, nonblocking) 1430 { 1431 size_t data = 100000; 1432 int sendbuf = 100; 1433 int flags; 1434 int res; 1435 1436 flags = fcntl(self->fd, F_GETFL, 0); 1437 fcntl(self->fd, F_SETFL, flags | O_NONBLOCK); 1438 fcntl(self->cfd, F_SETFL, flags | O_NONBLOCK); 1439 1440 /* Ensure nonblocking behavior by imposing a small send 1441 * buffer. 1442 */ 1443 EXPECT_EQ(setsockopt(self->fd, SOL_SOCKET, SO_SNDBUF, 1444 &sendbuf, sizeof(sendbuf)), 0); 1445 1446 res = fork(); 1447 EXPECT_NE(res, -1); 1448 1449 if (res) { 1450 /* parent */ 1451 bool eagain = false; 1452 size_t left = data; 1453 char buf[16384]; 1454 int status; 1455 int pid2; 1456 1457 while (left) { 1458 int res = send(self->fd, buf, 1459 left > 16384 ? 16384 : left, 0); 1460 1461 if (res == -1 && errno == EAGAIN) { 1462 eagain = true; 1463 usleep(10000); 1464 continue; 1465 } 1466 EXPECT_GE(res, 0); 1467 left -= res; 1468 } 1469 1470 EXPECT_TRUE(eagain); 1471 pid2 = wait(&status); 1472 1473 EXPECT_EQ(status, 0); 1474 EXPECT_EQ(res, pid2); 1475 } else { 1476 /* child */ 1477 bool eagain = false; 1478 size_t left = data; 1479 char buf[16384]; 1480 1481 while (left) { 1482 int res = recv(self->cfd, buf, 1483 left > 16384 ? 16384 : left, 0); 1484 1485 if (res == -1 && errno == EAGAIN) { 1486 eagain = true; 1487 usleep(10000); 1488 continue; 1489 } 1490 EXPECT_GE(res, 0); 1491 left -= res; 1492 } 1493 EXPECT_TRUE(eagain); 1494 } 1495 } 1496 1497 static void 1498 test_mutliproc(struct __test_metadata *_metadata, struct _test_data_tls *self, 1499 bool sendpg, unsigned int n_readers, unsigned int n_writers) 1500 { 1501 const unsigned int n_children = n_readers + n_writers; 1502 const size_t data = 6 * 1000 * 1000; 1503 const size_t file_sz = data / 100; 1504 size_t read_bias, write_bias; 1505 int i, fd, child_id; 1506 char buf[file_sz]; 1507 pid_t pid; 1508 1509 /* Only allow multiples for simplicity */ 1510 ASSERT_EQ(!(n_readers % n_writers) || !(n_writers % n_readers), true); 1511 read_bias = n_writers / n_readers ?: 1; 1512 write_bias = n_readers / n_writers ?: 1; 1513 1514 /* prep a file to send */ 1515 fd = open("/tmp/", O_TMPFILE | O_RDWR, 0600); 1516 ASSERT_GE(fd, 0); 1517 1518 memset(buf, 0xac, file_sz); 1519 ASSERT_EQ(write(fd, buf, file_sz), file_sz); 1520 1521 /* spawn children */ 1522 for (child_id = 0; child_id < n_children; child_id++) { 1523 pid = fork(); 1524 ASSERT_NE(pid, -1); 1525 if (!pid) 1526 break; 1527 } 1528 1529 /* parent waits for all children */ 1530 if (pid) { 1531 for (i = 0; i < n_children; i++) { 1532 int status; 1533 1534 wait(&status); 1535 EXPECT_EQ(status, 0); 1536 } 1537 1538 return; 1539 } 1540 1541 /* Split threads for reading and writing */ 1542 if (child_id < n_readers) { 1543 size_t left = data * read_bias; 1544 char rb[8001]; 1545 1546 while (left) { 1547 int res; 1548 1549 res = recv(self->cfd, rb, 1550 left > sizeof(rb) ? sizeof(rb) : left, 0); 1551 1552 EXPECT_GE(res, 0); 1553 left -= res; 1554 } 1555 } else { 1556 size_t left = data * write_bias; 1557 1558 while (left) { 1559 int res; 1560 1561 ASSERT_EQ(lseek(fd, 0, SEEK_SET), 0); 1562 if (sendpg) 1563 res = sendfile(self->fd, fd, NULL, 1564 left > file_sz ? file_sz : left); 1565 else 1566 res = send(self->fd, buf, 1567 left > file_sz ? file_sz : left, 0); 1568 1569 EXPECT_GE(res, 0); 1570 left -= res; 1571 } 1572 } 1573 } 1574 1575 TEST_F(tls, mutliproc_even) 1576 { 1577 test_mutliproc(_metadata, self, false, 6, 6); 1578 } 1579 1580 TEST_F(tls, mutliproc_readers) 1581 { 1582 test_mutliproc(_metadata, self, false, 4, 12); 1583 } 1584 1585 TEST_F(tls, mutliproc_writers) 1586 { 1587 test_mutliproc(_metadata, self, false, 10, 2); 1588 } 1589 1590 TEST_F(tls, mutliproc_sendpage_even) 1591 { 1592 test_mutliproc(_metadata, self, true, 6, 6); 1593 } 1594 1595 TEST_F(tls, mutliproc_sendpage_readers) 1596 { 1597 test_mutliproc(_metadata, self, true, 4, 12); 1598 } 1599 1600 TEST_F(tls, mutliproc_sendpage_writers) 1601 { 1602 test_mutliproc(_metadata, self, true, 10, 2); 1603 } 1604 1605 TEST_F(tls, control_msg) 1606 { 1607 char *test_str = "test_read"; 1608 char record_type = 100; 1609 int send_len = 10; 1610 char buf[10]; 1611 1612 if (self->notls) 1613 SKIP(return, "no TLS support"); 1614 1615 EXPECT_EQ(tls_send_cmsg(self->fd, record_type, test_str, send_len, 0), 1616 send_len); 1617 /* Should fail because we didn't provide a control message */ 1618 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1); 1619 1620 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type, 1621 buf, sizeof(buf), MSG_WAITALL | MSG_PEEK), 1622 send_len); 1623 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1624 1625 /* Recv the message again without MSG_PEEK */ 1626 memset(buf, 0, sizeof(buf)); 1627 1628 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type, 1629 buf, sizeof(buf), MSG_WAITALL), 1630 send_len); 1631 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1632 } 1633 1634 TEST_F(tls, control_msg_nomerge) 1635 { 1636 char *rec1 = "1111"; 1637 char *rec2 = "2222"; 1638 int send_len = 5; 1639 char buf[15]; 1640 1641 if (self->notls) 1642 SKIP(return, "no TLS support"); 1643 1644 EXPECT_EQ(tls_send_cmsg(self->fd, 100, rec1, send_len, 0), send_len); 1645 EXPECT_EQ(tls_send_cmsg(self->fd, 100, rec2, send_len, 0), send_len); 1646 1647 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, 100, buf, sizeof(buf), MSG_PEEK), send_len); 1648 EXPECT_EQ(memcmp(buf, rec1, send_len), 0); 1649 1650 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, 100, buf, sizeof(buf), MSG_PEEK), send_len); 1651 EXPECT_EQ(memcmp(buf, rec1, send_len), 0); 1652 1653 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, 100, buf, sizeof(buf), 0), send_len); 1654 EXPECT_EQ(memcmp(buf, rec1, send_len), 0); 1655 1656 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, 100, buf, sizeof(buf), 0), send_len); 1657 EXPECT_EQ(memcmp(buf, rec2, send_len), 0); 1658 } 1659 1660 TEST_F(tls, data_control_data) 1661 { 1662 char *rec1 = "1111"; 1663 char *rec2 = "2222"; 1664 char *rec3 = "3333"; 1665 int send_len = 5; 1666 char buf[15]; 1667 1668 if (self->notls) 1669 SKIP(return, "no TLS support"); 1670 1671 EXPECT_EQ(send(self->fd, rec1, send_len, 0), send_len); 1672 EXPECT_EQ(tls_send_cmsg(self->fd, 100, rec2, send_len, 0), send_len); 1673 EXPECT_EQ(send(self->fd, rec3, send_len, 0), send_len); 1674 1675 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_PEEK), send_len); 1676 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_PEEK), send_len); 1677 } 1678 1679 TEST_F(tls, shutdown) 1680 { 1681 char const *test_str = "test_read"; 1682 int send_len = 10; 1683 char buf[10]; 1684 1685 ASSERT_EQ(strlen(test_str) + 1, send_len); 1686 1687 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1688 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1); 1689 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1690 1691 shutdown(self->fd, SHUT_RDWR); 1692 shutdown(self->cfd, SHUT_RDWR); 1693 } 1694 1695 TEST_F(tls, shutdown_unsent) 1696 { 1697 char const *test_str = "test_read"; 1698 int send_len = 10; 1699 1700 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len); 1701 1702 shutdown(self->fd, SHUT_RDWR); 1703 shutdown(self->cfd, SHUT_RDWR); 1704 } 1705 1706 TEST_F(tls, shutdown_reuse) 1707 { 1708 struct sockaddr_in addr; 1709 int ret; 1710 1711 shutdown(self->fd, SHUT_RDWR); 1712 shutdown(self->cfd, SHUT_RDWR); 1713 close(self->cfd); 1714 1715 addr.sin_family = AF_INET; 1716 addr.sin_addr.s_addr = htonl(INADDR_ANY); 1717 addr.sin_port = 0; 1718 1719 ret = bind(self->fd, &addr, sizeof(addr)); 1720 EXPECT_EQ(ret, 0); 1721 ret = listen(self->fd, 10); 1722 EXPECT_EQ(ret, -1); 1723 EXPECT_EQ(errno, EINVAL); 1724 1725 ret = connect(self->fd, &addr, sizeof(addr)); 1726 EXPECT_EQ(ret, -1); 1727 EXPECT_EQ(errno, EISCONN); 1728 } 1729 1730 TEST_F(tls, getsockopt) 1731 { 1732 struct tls_crypto_info_keys expect, get; 1733 socklen_t len; 1734 1735 /* get only the version/cipher */ 1736 len = sizeof(struct tls_crypto_info); 1737 memrnd(&get, sizeof(get)); 1738 EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &get, &len), 0); 1739 EXPECT_EQ(len, sizeof(struct tls_crypto_info)); 1740 EXPECT_EQ(get.crypto_info.version, variant->tls_version); 1741 EXPECT_EQ(get.crypto_info.cipher_type, variant->cipher_type); 1742 1743 /* get the full crypto_info */ 1744 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &expect, 0); 1745 len = expect.len; 1746 memrnd(&get, sizeof(get)); 1747 EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &get, &len), 0); 1748 EXPECT_EQ(len, expect.len); 1749 EXPECT_EQ(get.crypto_info.version, variant->tls_version); 1750 EXPECT_EQ(get.crypto_info.cipher_type, variant->cipher_type); 1751 EXPECT_EQ(memcmp(&get, &expect, expect.len), 0); 1752 1753 /* short get should fail */ 1754 len = sizeof(struct tls_crypto_info) - 1; 1755 EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &get, &len), -1); 1756 EXPECT_EQ(errno, EINVAL); 1757 1758 /* partial get of the cipher data should fail */ 1759 len = expect.len - 1; 1760 EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &get, &len), -1); 1761 EXPECT_EQ(errno, EINVAL); 1762 } 1763 1764 TEST_F(tls, recv_efault) 1765 { 1766 char *rec1 = "1111111111"; 1767 char *rec2 = "2222222222"; 1768 struct msghdr hdr = {}; 1769 struct iovec iov[2]; 1770 char recv_mem[12]; 1771 int ret; 1772 1773 if (self->notls) 1774 SKIP(return, "no TLS support"); 1775 1776 EXPECT_EQ(send(self->fd, rec1, 10, 0), 10); 1777 EXPECT_EQ(send(self->fd, rec2, 10, 0), 10); 1778 1779 iov[0].iov_base = recv_mem; 1780 iov[0].iov_len = sizeof(recv_mem); 1781 iov[1].iov_base = NULL; /* broken iov to make process_rx_list fail */ 1782 iov[1].iov_len = 1; 1783 1784 hdr.msg_iovlen = 2; 1785 hdr.msg_iov = iov; 1786 1787 EXPECT_EQ(recv(self->cfd, recv_mem, 1, 0), 1); 1788 EXPECT_EQ(recv_mem[0], rec1[0]); 1789 1790 ret = recvmsg(self->cfd, &hdr, 0); 1791 EXPECT_LE(ret, sizeof(recv_mem)); 1792 EXPECT_GE(ret, 9); 1793 EXPECT_EQ(memcmp(rec1, recv_mem, 9), 0); 1794 if (ret > 9) 1795 EXPECT_EQ(memcmp(rec2, recv_mem + 9, ret - 9), 0); 1796 } 1797 1798 #define TLS_RECORD_TYPE_HANDSHAKE 0x16 1799 /* key_update, length 1, update_not_requested */ 1800 static const char key_update_msg[] = "\x18\x00\x00\x01\x00"; 1801 static void tls_send_keyupdate(struct __test_metadata *_metadata, int fd) 1802 { 1803 size_t len = sizeof(key_update_msg); 1804 1805 EXPECT_EQ(tls_send_cmsg(fd, TLS_RECORD_TYPE_HANDSHAKE, 1806 (char *)key_update_msg, len, 0), 1807 len); 1808 } 1809 1810 static void tls_recv_keyupdate(struct __test_metadata *_metadata, int fd, int flags) 1811 { 1812 char buf[100]; 1813 1814 EXPECT_EQ(tls_recv_cmsg(_metadata, fd, TLS_RECORD_TYPE_HANDSHAKE, buf, sizeof(buf), flags), 1815 sizeof(key_update_msg)); 1816 EXPECT_EQ(memcmp(buf, key_update_msg, sizeof(key_update_msg)), 0); 1817 } 1818 1819 /* set the key to 0 then 1 for RX, immediately to 1 for TX */ 1820 TEST_F(tls_basic, rekey_rx) 1821 { 1822 struct tls_crypto_info_keys tls12_0, tls12_1; 1823 char const *test_str = "test_message"; 1824 int send_len = strlen(test_str) + 1; 1825 char buf[20]; 1826 int ret; 1827 1828 if (self->notls) 1829 return; 1830 1831 tls_crypto_info_init(TLS_1_3_VERSION, TLS_CIPHER_AES_GCM_128, 1832 &tls12_0, 0); 1833 tls_crypto_info_init(TLS_1_3_VERSION, TLS_CIPHER_AES_GCM_128, 1834 &tls12_1, 1); 1835 1836 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12_1, tls12_1.len); 1837 ASSERT_EQ(ret, 0); 1838 1839 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12_0, tls12_0.len); 1840 ASSERT_EQ(ret, 0); 1841 1842 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12_1, tls12_1.len); 1843 EXPECT_EQ(ret, 0); 1844 1845 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1846 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 1847 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1848 } 1849 1850 /* set the key to 0 then 1 for TX, immediately to 1 for RX */ 1851 TEST_F(tls_basic, rekey_tx) 1852 { 1853 struct tls_crypto_info_keys tls12_0, tls12_1; 1854 char const *test_str = "test_message"; 1855 int send_len = strlen(test_str) + 1; 1856 char buf[20]; 1857 int ret; 1858 1859 if (self->notls) 1860 return; 1861 1862 tls_crypto_info_init(TLS_1_3_VERSION, TLS_CIPHER_AES_GCM_128, 1863 &tls12_0, 0); 1864 tls_crypto_info_init(TLS_1_3_VERSION, TLS_CIPHER_AES_GCM_128, 1865 &tls12_1, 1); 1866 1867 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12_0, tls12_0.len); 1868 ASSERT_EQ(ret, 0); 1869 1870 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12_1, tls12_1.len); 1871 ASSERT_EQ(ret, 0); 1872 1873 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12_1, tls12_1.len); 1874 EXPECT_EQ(ret, 0); 1875 1876 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1877 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 1878 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1879 } 1880 1881 TEST_F(tls_basic, disconnect) 1882 { 1883 char const *test_str = "test_message"; 1884 int send_len = strlen(test_str) + 1; 1885 struct tls_crypto_info_keys key; 1886 struct sockaddr_in addr; 1887 char buf[20]; 1888 int ret; 1889 1890 if (self->notls) 1891 return; 1892 1893 tls_crypto_info_init(TLS_1_3_VERSION, TLS_CIPHER_AES_GCM_128, 1894 &key, 0); 1895 1896 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &key, key.len); 1897 ASSERT_EQ(ret, 0); 1898 1899 /* Pre-queue the data so that setsockopt parses it but doesn't 1900 * dequeue it from the TCP socket. recvmsg would dequeue. 1901 */ 1902 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1903 1904 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &key, key.len); 1905 ASSERT_EQ(ret, 0); 1906 1907 addr.sin_family = AF_UNSPEC; 1908 addr.sin_addr.s_addr = htonl(INADDR_ANY); 1909 addr.sin_port = 0; 1910 ret = connect(self->cfd, &addr, sizeof(addr)); 1911 EXPECT_EQ(ret, -1); 1912 EXPECT_EQ(errno, EOPNOTSUPP); 1913 1914 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 1915 } 1916 1917 TEST_F(tls, rekey) 1918 { 1919 char const *test_str_1 = "test_message_before_rekey"; 1920 char const *test_str_2 = "test_message_after_rekey"; 1921 struct tls_crypto_info_keys tls12; 1922 int send_len; 1923 char buf[100]; 1924 1925 if (variant->tls_version != TLS_1_3_VERSION) 1926 return; 1927 1928 /* initial send/recv */ 1929 send_len = strlen(test_str_1) + 1; 1930 EXPECT_EQ(send(self->fd, test_str_1, send_len, 0), send_len); 1931 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 1932 EXPECT_EQ(memcmp(buf, test_str_1, send_len), 0); 1933 1934 /* update TX key */ 1935 tls_send_keyupdate(_metadata, self->fd); 1936 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 1937 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 1938 1939 /* send after rekey */ 1940 send_len = strlen(test_str_2) + 1; 1941 EXPECT_EQ(send(self->fd, test_str_2, send_len, 0), send_len); 1942 1943 /* can't receive the KeyUpdate without a control message */ 1944 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1); 1945 1946 /* get KeyUpdate */ 1947 tls_recv_keyupdate(_metadata, self->cfd, 0); 1948 1949 /* recv blocking -> -EKEYEXPIRED */ 1950 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), 0), -1); 1951 EXPECT_EQ(errno, EKEYEXPIRED); 1952 1953 /* recv non-blocking -> -EKEYEXPIRED */ 1954 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1); 1955 EXPECT_EQ(errno, EKEYEXPIRED); 1956 1957 /* update RX key */ 1958 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 1959 1960 /* recv after rekey */ 1961 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1); 1962 EXPECT_EQ(memcmp(buf, test_str_2, send_len), 0); 1963 } 1964 1965 TEST_F(tls, rekey_fail) 1966 { 1967 char const *test_str_1 = "test_message_before_rekey"; 1968 char const *test_str_2 = "test_message_after_rekey"; 1969 struct tls_crypto_info_keys tls12; 1970 int send_len; 1971 char buf[100]; 1972 1973 /* initial send/recv */ 1974 send_len = strlen(test_str_1) + 1; 1975 EXPECT_EQ(send(self->fd, test_str_1, send_len, 0), send_len); 1976 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 1977 EXPECT_EQ(memcmp(buf, test_str_1, send_len), 0); 1978 1979 /* update TX key */ 1980 tls_send_keyupdate(_metadata, self->fd); 1981 1982 if (variant->tls_version != TLS_1_3_VERSION) { 1983 /* just check that rekey is not supported and return */ 1984 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 1985 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), -1); 1986 EXPECT_EQ(errno, EBUSY); 1987 return; 1988 } 1989 1990 /* successful update */ 1991 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 1992 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 1993 1994 /* invalid update: change of version */ 1995 tls_crypto_info_init(TLS_1_2_VERSION, variant->cipher_type, &tls12, 1); 1996 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), -1); 1997 EXPECT_EQ(errno, EINVAL); 1998 1999 /* invalid update (RX socket): change of version */ 2000 tls_crypto_info_init(TLS_1_2_VERSION, variant->cipher_type, &tls12, 1); 2001 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), -1); 2002 EXPECT_EQ(errno, EINVAL); 2003 2004 /* invalid update: change of cipher */ 2005 if (variant->cipher_type == TLS_CIPHER_AES_GCM_256) 2006 tls_crypto_info_init(variant->tls_version, TLS_CIPHER_CHACHA20_POLY1305, &tls12, 1); 2007 else 2008 tls_crypto_info_init(variant->tls_version, TLS_CIPHER_AES_GCM_256, &tls12, 1); 2009 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), -1); 2010 EXPECT_EQ(errno, EINVAL); 2011 2012 /* send after rekey, the invalid updates shouldn't have an effect */ 2013 send_len = strlen(test_str_2) + 1; 2014 EXPECT_EQ(send(self->fd, test_str_2, send_len, 0), send_len); 2015 2016 /* can't receive the KeyUpdate without a control message */ 2017 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1); 2018 2019 /* get KeyUpdate */ 2020 tls_recv_keyupdate(_metadata, self->cfd, 0); 2021 2022 /* recv blocking -> -EKEYEXPIRED */ 2023 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), 0), -1); 2024 EXPECT_EQ(errno, EKEYEXPIRED); 2025 2026 /* recv non-blocking -> -EKEYEXPIRED */ 2027 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1); 2028 EXPECT_EQ(errno, EKEYEXPIRED); 2029 2030 /* update RX key */ 2031 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2032 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2033 2034 /* recv after rekey */ 2035 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1); 2036 EXPECT_EQ(memcmp(buf, test_str_2, send_len), 0); 2037 } 2038 2039 TEST_F(tls, rekey_peek) 2040 { 2041 char const *test_str_1 = "test_message_before_rekey"; 2042 struct tls_crypto_info_keys tls12; 2043 int send_len; 2044 char buf[100]; 2045 2046 if (variant->tls_version != TLS_1_3_VERSION) 2047 return; 2048 2049 send_len = strlen(test_str_1) + 1; 2050 EXPECT_EQ(send(self->fd, test_str_1, send_len, 0), send_len); 2051 2052 /* update TX key */ 2053 tls_send_keyupdate(_metadata, self->fd); 2054 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2055 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2056 2057 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_PEEK), send_len); 2058 EXPECT_EQ(memcmp(buf, test_str_1, send_len), 0); 2059 2060 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 2061 EXPECT_EQ(memcmp(buf, test_str_1, send_len), 0); 2062 2063 /* can't receive the KeyUpdate without a control message */ 2064 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_PEEK), -1); 2065 2066 /* peek KeyUpdate */ 2067 tls_recv_keyupdate(_metadata, self->cfd, MSG_PEEK); 2068 2069 /* get KeyUpdate */ 2070 tls_recv_keyupdate(_metadata, self->cfd, 0); 2071 2072 /* update RX key */ 2073 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2074 } 2075 2076 TEST_F(tls, splice_rekey) 2077 { 2078 int send_len = TLS_PAYLOAD_MAX_LEN / 2; 2079 char mem_send[TLS_PAYLOAD_MAX_LEN]; 2080 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 2081 struct tls_crypto_info_keys tls12; 2082 int p[2]; 2083 2084 if (variant->tls_version != TLS_1_3_VERSION) 2085 return; 2086 2087 memrnd(mem_send, sizeof(mem_send)); 2088 2089 ASSERT_GE(pipe(p), 0); 2090 EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len); 2091 2092 /* update TX key */ 2093 tls_send_keyupdate(_metadata, self->fd); 2094 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2095 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2096 2097 EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len); 2098 2099 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, TLS_PAYLOAD_MAX_LEN, 0), send_len); 2100 EXPECT_EQ(read(p[0], mem_recv, send_len), send_len); 2101 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 2102 2103 /* can't splice the KeyUpdate */ 2104 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, TLS_PAYLOAD_MAX_LEN, 0), -1); 2105 EXPECT_EQ(errno, EINVAL); 2106 2107 /* peek KeyUpdate */ 2108 tls_recv_keyupdate(_metadata, self->cfd, MSG_PEEK); 2109 2110 /* get KeyUpdate */ 2111 tls_recv_keyupdate(_metadata, self->cfd, 0); 2112 2113 /* can't splice before updating the key */ 2114 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, TLS_PAYLOAD_MAX_LEN, 0), -1); 2115 EXPECT_EQ(errno, EKEYEXPIRED); 2116 2117 /* update RX key */ 2118 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2119 2120 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, TLS_PAYLOAD_MAX_LEN, 0), send_len); 2121 EXPECT_EQ(read(p[0], mem_recv, send_len), send_len); 2122 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 2123 } 2124 2125 TEST_F(tls, rekey_peek_splice) 2126 { 2127 char const *test_str_1 = "test_message_before_rekey"; 2128 struct tls_crypto_info_keys tls12; 2129 int send_len; 2130 char buf[100]; 2131 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 2132 int p[2]; 2133 2134 if (variant->tls_version != TLS_1_3_VERSION) 2135 return; 2136 2137 ASSERT_GE(pipe(p), 0); 2138 2139 send_len = strlen(test_str_1) + 1; 2140 EXPECT_EQ(send(self->fd, test_str_1, send_len, 0), send_len); 2141 2142 /* update TX key */ 2143 tls_send_keyupdate(_metadata, self->fd); 2144 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2145 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2146 2147 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_PEEK), send_len); 2148 EXPECT_EQ(memcmp(buf, test_str_1, send_len), 0); 2149 2150 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, TLS_PAYLOAD_MAX_LEN, 0), send_len); 2151 EXPECT_EQ(read(p[0], mem_recv, send_len), send_len); 2152 EXPECT_EQ(memcmp(mem_recv, test_str_1, send_len), 0); 2153 } 2154 2155 TEST_F(tls, rekey_getsockopt) 2156 { 2157 struct tls_crypto_info_keys tls12; 2158 struct tls_crypto_info_keys tls12_get; 2159 socklen_t len; 2160 2161 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 0); 2162 2163 len = tls12.len; 2164 EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &tls12_get, &len), 0); 2165 EXPECT_EQ(len, tls12.len); 2166 EXPECT_EQ(memcmp(&tls12_get, &tls12, tls12.len), 0); 2167 2168 len = tls12.len; 2169 EXPECT_EQ(getsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12_get, &len), 0); 2170 EXPECT_EQ(len, tls12.len); 2171 EXPECT_EQ(memcmp(&tls12_get, &tls12, tls12.len), 0); 2172 2173 if (variant->tls_version != TLS_1_3_VERSION) 2174 return; 2175 2176 tls_send_keyupdate(_metadata, self->fd); 2177 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2178 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2179 2180 tls_recv_keyupdate(_metadata, self->cfd, 0); 2181 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2182 2183 len = tls12.len; 2184 EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &tls12_get, &len), 0); 2185 EXPECT_EQ(len, tls12.len); 2186 EXPECT_EQ(memcmp(&tls12_get, &tls12, tls12.len), 0); 2187 2188 len = tls12.len; 2189 EXPECT_EQ(getsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12_get, &len), 0); 2190 EXPECT_EQ(len, tls12.len); 2191 EXPECT_EQ(memcmp(&tls12_get, &tls12, tls12.len), 0); 2192 } 2193 2194 TEST_F(tls, rekey_poll_pending) 2195 { 2196 char const *test_str = "test_message_after_rekey"; 2197 struct tls_crypto_info_keys tls12; 2198 struct pollfd pfd = { }; 2199 int send_len; 2200 int ret; 2201 2202 if (variant->tls_version != TLS_1_3_VERSION) 2203 return; 2204 2205 /* update TX key */ 2206 tls_send_keyupdate(_metadata, self->fd); 2207 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2208 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2209 2210 /* get KeyUpdate */ 2211 tls_recv_keyupdate(_metadata, self->cfd, 0); 2212 2213 /* send immediately after rekey */ 2214 send_len = strlen(test_str) + 1; 2215 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 2216 2217 /* key hasn't been updated, expect cfd to be non-readable */ 2218 pfd.fd = self->cfd; 2219 pfd.events = POLLIN; 2220 EXPECT_EQ(poll(&pfd, 1, 0), 0); 2221 2222 ret = fork(); 2223 ASSERT_GE(ret, 0); 2224 2225 if (ret) { 2226 int pid2, status; 2227 2228 /* wait before installing the new key */ 2229 sleep(1); 2230 2231 /* update RX key while poll() is sleeping */ 2232 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2233 2234 pid2 = wait(&status); 2235 EXPECT_EQ(pid2, ret); 2236 EXPECT_EQ(status, 0); 2237 } else { 2238 pfd.fd = self->cfd; 2239 pfd.events = POLLIN; 2240 EXPECT_EQ(poll(&pfd, 1, 5000), 1); 2241 2242 exit(!__test_passed(_metadata)); 2243 } 2244 } 2245 2246 TEST_F(tls, rekey_poll_delay) 2247 { 2248 char const *test_str = "test_message_after_rekey"; 2249 struct tls_crypto_info_keys tls12; 2250 struct pollfd pfd = { }; 2251 int send_len; 2252 int ret; 2253 2254 if (variant->tls_version != TLS_1_3_VERSION) 2255 return; 2256 2257 /* update TX key */ 2258 tls_send_keyupdate(_metadata, self->fd); 2259 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2260 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2261 2262 /* get KeyUpdate */ 2263 tls_recv_keyupdate(_metadata, self->cfd, 0); 2264 2265 ret = fork(); 2266 ASSERT_GE(ret, 0); 2267 2268 if (ret) { 2269 int pid2, status; 2270 2271 /* wait before installing the new key */ 2272 sleep(1); 2273 2274 /* update RX key while poll() is sleeping */ 2275 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2276 2277 sleep(1); 2278 send_len = strlen(test_str) + 1; 2279 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 2280 2281 pid2 = wait(&status); 2282 EXPECT_EQ(pid2, ret); 2283 EXPECT_EQ(status, 0); 2284 } else { 2285 pfd.fd = self->cfd; 2286 pfd.events = POLLIN; 2287 EXPECT_EQ(poll(&pfd, 1, 5000), 1); 2288 exit(!__test_passed(_metadata)); 2289 } 2290 } 2291 2292 struct raw_rec { 2293 unsigned int plain_len; 2294 unsigned char plain_data[100]; 2295 unsigned int cipher_len; 2296 unsigned char cipher_data[128]; 2297 }; 2298 2299 /* TLS 1.2, AES_CCM, data, seqno:0, plaintext: 'Hello world' */ 2300 static const struct raw_rec id0_data_l11 = { 2301 .plain_len = 11, 2302 .plain_data = { 2303 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 2304 0x72, 0x6c, 0x64, 2305 }, 2306 .cipher_len = 40, 2307 .cipher_data = { 2308 0x17, 0x03, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 2309 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0xa2, 0x33, 2310 0xde, 0x8d, 0x94, 0xf0, 0x29, 0x6c, 0xb1, 0xaf, 2311 0x6a, 0x75, 0xb2, 0x93, 0xad, 0x45, 0xd5, 0xfd, 2312 0x03, 0x51, 0x57, 0x8f, 0xf9, 0xcc, 0x3b, 0x42, 2313 }, 2314 }; 2315 2316 /* TLS 1.2, AES_CCM, ctrl, seqno:0, plaintext: '' */ 2317 static const struct raw_rec id0_ctrl_l0 = { 2318 .plain_len = 0, 2319 .plain_data = { 2320 }, 2321 .cipher_len = 29, 2322 .cipher_data = { 2323 0x16, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 2324 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x38, 0x7b, 2325 0xa6, 0x1c, 0xdd, 0xa7, 0x19, 0x33, 0xab, 0xae, 2326 0x88, 0xe1, 0xd2, 0x08, 0x4f, 2327 }, 2328 }; 2329 2330 /* TLS 1.2, AES_CCM, data, seqno:0, plaintext: '' */ 2331 static const struct raw_rec id0_data_l0 = { 2332 .plain_len = 0, 2333 .plain_data = { 2334 }, 2335 .cipher_len = 29, 2336 .cipher_data = { 2337 0x17, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 2338 0x00, 0x00, 0x00, 0x00, 0x00, 0xc5, 0x37, 0x90, 2339 0x70, 0x45, 0x89, 0xfb, 0x5c, 0xc7, 0x89, 0x03, 2340 0x68, 0x80, 0xd3, 0xd8, 0xcc, 2341 }, 2342 }; 2343 2344 /* TLS 1.2, AES_CCM, data, seqno:1, plaintext: 'Hello world' */ 2345 static const struct raw_rec id1_data_l11 = { 2346 .plain_len = 11, 2347 .plain_data = { 2348 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 2349 0x72, 0x6c, 0x64, 2350 }, 2351 .cipher_len = 40, 2352 .cipher_data = { 2353 0x17, 0x03, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 2354 0x00, 0x00, 0x00, 0x00, 0x01, 0x3a, 0x1a, 0x9c, 2355 0xd0, 0xa8, 0x9a, 0xd6, 0x69, 0xd6, 0x1a, 0xe3, 2356 0xb5, 0x1f, 0x0d, 0x2c, 0xe2, 0x97, 0x46, 0xff, 2357 0x2b, 0xcc, 0x5a, 0xc4, 0xa3, 0xb9, 0xef, 0xba, 2358 }, 2359 }; 2360 2361 /* TLS 1.2, AES_CCM, ctrl, seqno:1, plaintext: '' */ 2362 static const struct raw_rec id1_ctrl_l0 = { 2363 .plain_len = 0, 2364 .plain_data = { 2365 }, 2366 .cipher_len = 29, 2367 .cipher_data = { 2368 0x16, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 2369 0x00, 0x00, 0x00, 0x00, 0x01, 0x3e, 0xf0, 0xfe, 2370 0xee, 0xd9, 0xe2, 0x5d, 0xc7, 0x11, 0x4c, 0xe6, 2371 0xb4, 0x7e, 0xef, 0x40, 0x2b, 2372 }, 2373 }; 2374 2375 /* TLS 1.2, AES_CCM, data, seqno:1, plaintext: '' */ 2376 static const struct raw_rec id1_data_l0 = { 2377 .plain_len = 0, 2378 .plain_data = { 2379 }, 2380 .cipher_len = 29, 2381 .cipher_data = { 2382 0x17, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 2383 0x00, 0x00, 0x00, 0x00, 0x01, 0xce, 0xfc, 0x86, 2384 0xc8, 0xf0, 0x55, 0xf9, 0x47, 0x3f, 0x74, 0xdc, 2385 0xc9, 0xbf, 0xfe, 0x5b, 0xb1, 2386 }, 2387 }; 2388 2389 /* TLS 1.2, AES_CCM, ctrl, seqno:2, plaintext: 'Hello world' */ 2390 static const struct raw_rec id2_ctrl_l11 = { 2391 .plain_len = 11, 2392 .plain_data = { 2393 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 2394 0x72, 0x6c, 0x64, 2395 }, 2396 .cipher_len = 40, 2397 .cipher_data = { 2398 0x16, 0x03, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 2399 0x00, 0x00, 0x00, 0x00, 0x02, 0xe5, 0x3d, 0x19, 2400 0x3d, 0xca, 0xb8, 0x16, 0xb6, 0xff, 0x79, 0x87, 2401 0x2a, 0x04, 0x11, 0x3d, 0xf8, 0x64, 0x5f, 0x36, 2402 0x8b, 0xa8, 0xee, 0x4c, 0x6d, 0x62, 0xa5, 0x00, 2403 }, 2404 }; 2405 2406 /* TLS 1.2, AES_CCM, data, seqno:2, plaintext: 'Hello world' */ 2407 static const struct raw_rec id2_data_l11 = { 2408 .plain_len = 11, 2409 .plain_data = { 2410 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 2411 0x72, 0x6c, 0x64, 2412 }, 2413 .cipher_len = 40, 2414 .cipher_data = { 2415 0x17, 0x03, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 2416 0x00, 0x00, 0x00, 0x00, 0x02, 0xe5, 0x3d, 0x19, 2417 0x3d, 0xca, 0xb8, 0x16, 0xb6, 0xff, 0x79, 0x87, 2418 0x8e, 0xa1, 0xd0, 0xcd, 0x33, 0xb5, 0x86, 0x2b, 2419 0x17, 0xf1, 0x52, 0x2a, 0x55, 0x62, 0x65, 0x11, 2420 }, 2421 }; 2422 2423 /* TLS 1.2, AES_CCM, ctrl, seqno:2, plaintext: '' */ 2424 static const struct raw_rec id2_ctrl_l0 = { 2425 .plain_len = 0, 2426 .plain_data = { 2427 }, 2428 .cipher_len = 29, 2429 .cipher_data = { 2430 0x16, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 2431 0x00, 0x00, 0x00, 0x00, 0x02, 0xdc, 0x5c, 0x0e, 2432 0x41, 0xdd, 0xba, 0xd3, 0xcc, 0xcf, 0x6d, 0xd9, 2433 0x06, 0xdb, 0x79, 0xe5, 0x5d, 2434 }, 2435 }; 2436 2437 /* TLS 1.2, AES_CCM, data, seqno:2, plaintext: '' */ 2438 static const struct raw_rec id2_data_l0 = { 2439 .plain_len = 0, 2440 .plain_data = { 2441 }, 2442 .cipher_len = 29, 2443 .cipher_data = { 2444 0x17, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 2445 0x00, 0x00, 0x00, 0x00, 0x02, 0xc3, 0xca, 0x26, 2446 0x22, 0xe4, 0x25, 0xfb, 0x5f, 0x6d, 0xbf, 0x83, 2447 0x30, 0x48, 0x69, 0x1a, 0x47, 2448 }, 2449 }; 2450 2451 FIXTURE(zero_len) 2452 { 2453 int fd, cfd; 2454 bool notls; 2455 }; 2456 2457 FIXTURE_VARIANT(zero_len) 2458 { 2459 const struct raw_rec *recs[4]; 2460 ssize_t recv_ret[4]; 2461 }; 2462 2463 FIXTURE_VARIANT_ADD(zero_len, data_data_data) 2464 { 2465 .recs = { &id0_data_l11, &id1_data_l11, &id2_data_l11, }, 2466 .recv_ret = { 33, -EAGAIN, }, 2467 }; 2468 2469 FIXTURE_VARIANT_ADD(zero_len, data_0ctrl_data) 2470 { 2471 .recs = { &id0_data_l11, &id1_ctrl_l0, &id2_data_l11, }, 2472 .recv_ret = { 11, 0, 11, -EAGAIN, }, 2473 }; 2474 2475 FIXTURE_VARIANT_ADD(zero_len, 0data_0data_0data) 2476 { 2477 .recs = { &id0_data_l0, &id1_data_l0, &id2_data_l0, }, 2478 .recv_ret = { -EAGAIN, }, 2479 }; 2480 2481 FIXTURE_VARIANT_ADD(zero_len, 0data_0data_ctrl) 2482 { 2483 .recs = { &id0_data_l0, &id1_data_l0, &id2_ctrl_l11, }, 2484 .recv_ret = { 0, 11, -EAGAIN, }, 2485 }; 2486 2487 FIXTURE_VARIANT_ADD(zero_len, 0data_0data_0ctrl) 2488 { 2489 .recs = { &id0_data_l0, &id1_data_l0, &id2_ctrl_l0, }, 2490 .recv_ret = { 0, 0, -EAGAIN, }, 2491 }; 2492 2493 FIXTURE_VARIANT_ADD(zero_len, 0ctrl_0ctrl_0ctrl) 2494 { 2495 .recs = { &id0_ctrl_l0, &id1_ctrl_l0, &id2_ctrl_l0, }, 2496 .recv_ret = { 0, 0, 0, -EAGAIN, }, 2497 }; 2498 2499 FIXTURE_VARIANT_ADD(zero_len, 0data_0data_data) 2500 { 2501 .recs = { &id0_data_l0, &id1_data_l0, &id2_data_l11, }, 2502 .recv_ret = { 11, -EAGAIN, }, 2503 }; 2504 2505 FIXTURE_VARIANT_ADD(zero_len, data_0data_0data) 2506 { 2507 .recs = { &id0_data_l11, &id1_data_l0, &id2_data_l0, }, 2508 .recv_ret = { 11, -EAGAIN, }, 2509 }; 2510 2511 FIXTURE_SETUP(zero_len) 2512 { 2513 struct tls_crypto_info_keys tls12; 2514 int ret; 2515 2516 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_CCM_128, 2517 &tls12, 0); 2518 2519 ulp_sock_pair(_metadata, &self->fd, &self->cfd, &self->notls); 2520 if (self->notls) 2521 return; 2522 2523 /* Don't install keys on fd, we'll send raw records */ 2524 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len); 2525 ASSERT_EQ(ret, 0); 2526 } 2527 2528 FIXTURE_TEARDOWN(zero_len) 2529 { 2530 close(self->fd); 2531 close(self->cfd); 2532 } 2533 2534 TEST_F(zero_len, test) 2535 { 2536 const struct raw_rec *const *rec; 2537 unsigned char buf[128]; 2538 int rec_off; 2539 int i; 2540 2541 for (i = 0; i < 4 && variant->recs[i]; i++) 2542 EXPECT_EQ(send(self->fd, variant->recs[i]->cipher_data, 2543 variant->recs[i]->cipher_len, 0), 2544 variant->recs[i]->cipher_len); 2545 2546 rec = &variant->recs[0]; 2547 rec_off = 0; 2548 for (i = 0; i < 4; i++) { 2549 int j, ret; 2550 2551 ret = variant->recv_ret[i] >= 0 ? variant->recv_ret[i] : -1; 2552 EXPECT_EQ(__tls_recv_cmsg(_metadata, self->cfd, NULL, 2553 buf, sizeof(buf), MSG_DONTWAIT), ret); 2554 if (ret == -1) 2555 EXPECT_EQ(errno, -variant->recv_ret[i]); 2556 if (variant->recv_ret[i] == -EAGAIN) 2557 break; 2558 2559 for (j = 0; j < ret; j++) { 2560 while (rec_off == (*rec)->plain_len) { 2561 rec++; 2562 rec_off = 0; 2563 } 2564 EXPECT_EQ(buf[j], (*rec)->plain_data[rec_off]); 2565 rec_off++; 2566 } 2567 } 2568 }; 2569 2570 FIXTURE(tls_err) 2571 { 2572 int fd, cfd; 2573 int fd2, cfd2; 2574 bool notls; 2575 }; 2576 2577 FIXTURE_VARIANT(tls_err) 2578 { 2579 uint16_t tls_version; 2580 }; 2581 2582 FIXTURE_VARIANT_ADD(tls_err, 12_aes_gcm) 2583 { 2584 .tls_version = TLS_1_2_VERSION, 2585 }; 2586 2587 FIXTURE_VARIANT_ADD(tls_err, 13_aes_gcm) 2588 { 2589 .tls_version = TLS_1_3_VERSION, 2590 }; 2591 2592 FIXTURE_SETUP(tls_err) 2593 { 2594 struct tls_crypto_info_keys tls12; 2595 int ret; 2596 2597 tls_crypto_info_init(variant->tls_version, TLS_CIPHER_AES_GCM_128, 2598 &tls12, 0); 2599 2600 ulp_sock_pair(_metadata, &self->fd, &self->cfd, &self->notls); 2601 ulp_sock_pair(_metadata, &self->fd2, &self->cfd2, &self->notls); 2602 if (self->notls) 2603 return; 2604 2605 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len); 2606 ASSERT_EQ(ret, 0); 2607 2608 ret = setsockopt(self->cfd2, SOL_TLS, TLS_RX, &tls12, tls12.len); 2609 ASSERT_EQ(ret, 0); 2610 } 2611 2612 FIXTURE_TEARDOWN(tls_err) 2613 { 2614 close(self->fd); 2615 close(self->cfd); 2616 close(self->fd2); 2617 close(self->cfd2); 2618 } 2619 2620 TEST_F(tls_err, bad_rec) 2621 { 2622 char buf[64]; 2623 2624 if (self->notls) 2625 SKIP(return, "no TLS support"); 2626 2627 memset(buf, 0x55, sizeof(buf)); 2628 EXPECT_EQ(send(self->fd2, buf, sizeof(buf), 0), sizeof(buf)); 2629 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2630 EXPECT_EQ(errno, EMSGSIZE); 2631 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), MSG_DONTWAIT), -1); 2632 EXPECT_EQ(errno, EAGAIN); 2633 } 2634 2635 TEST_F(tls_err, bad_auth) 2636 { 2637 char buf[128]; 2638 int n; 2639 2640 if (self->notls) 2641 SKIP(return, "no TLS support"); 2642 2643 memrnd(buf, sizeof(buf) / 2); 2644 EXPECT_EQ(send(self->fd, buf, sizeof(buf) / 2, 0), sizeof(buf) / 2); 2645 n = recv(self->cfd, buf, sizeof(buf), 0); 2646 EXPECT_GT(n, sizeof(buf) / 2); 2647 2648 buf[n - 1]++; 2649 2650 EXPECT_EQ(send(self->fd2, buf, n, 0), n); 2651 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2652 EXPECT_EQ(errno, EBADMSG); 2653 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2654 EXPECT_EQ(errno, EBADMSG); 2655 } 2656 2657 TEST_F(tls_err, bad_in_large_read) 2658 { 2659 char txt[3][64]; 2660 char cip[3][128]; 2661 char buf[3 * 128]; 2662 int i, n; 2663 2664 if (self->notls) 2665 SKIP(return, "no TLS support"); 2666 2667 /* Put 3 records in the sockets */ 2668 for (i = 0; i < 3; i++) { 2669 memrnd(txt[i], sizeof(txt[i])); 2670 EXPECT_EQ(send(self->fd, txt[i], sizeof(txt[i]), 0), 2671 sizeof(txt[i])); 2672 n = recv(self->cfd, cip[i], sizeof(cip[i]), 0); 2673 EXPECT_GT(n, sizeof(txt[i])); 2674 /* Break the third message */ 2675 if (i == 2) 2676 cip[2][n - 1]++; 2677 EXPECT_EQ(send(self->fd2, cip[i], n, 0), n); 2678 } 2679 2680 /* We should be able to receive the first two messages */ 2681 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), sizeof(txt[0]) * 2); 2682 EXPECT_EQ(memcmp(buf, txt[0], sizeof(txt[0])), 0); 2683 EXPECT_EQ(memcmp(buf + sizeof(txt[0]), txt[1], sizeof(txt[1])), 0); 2684 /* Third mesasge is bad */ 2685 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2686 EXPECT_EQ(errno, EBADMSG); 2687 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2688 EXPECT_EQ(errno, EBADMSG); 2689 } 2690 2691 TEST_F(tls_err, bad_cmsg) 2692 { 2693 char *test_str = "test_read"; 2694 int send_len = 10; 2695 char cip[128]; 2696 char buf[128]; 2697 char txt[64]; 2698 int n; 2699 2700 if (self->notls) 2701 SKIP(return, "no TLS support"); 2702 2703 /* Queue up one data record */ 2704 memrnd(txt, sizeof(txt)); 2705 EXPECT_EQ(send(self->fd, txt, sizeof(txt), 0), sizeof(txt)); 2706 n = recv(self->cfd, cip, sizeof(cip), 0); 2707 EXPECT_GT(n, sizeof(txt)); 2708 EXPECT_EQ(send(self->fd2, cip, n, 0), n); 2709 2710 EXPECT_EQ(tls_send_cmsg(self->fd, 100, test_str, send_len, 0), 10); 2711 n = recv(self->cfd, cip, sizeof(cip), 0); 2712 cip[n - 1]++; /* Break it */ 2713 EXPECT_GT(n, send_len); 2714 EXPECT_EQ(send(self->fd2, cip, n, 0), n); 2715 2716 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), sizeof(txt)); 2717 EXPECT_EQ(memcmp(buf, txt, sizeof(txt)), 0); 2718 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2719 EXPECT_EQ(errno, EBADMSG); 2720 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2721 EXPECT_EQ(errno, EBADMSG); 2722 } 2723 2724 TEST_F(tls_err, timeo) 2725 { 2726 struct timeval tv = { .tv_usec = 10000, }; 2727 char buf[128]; 2728 int ret; 2729 2730 if (self->notls) 2731 SKIP(return, "no TLS support"); 2732 2733 ret = setsockopt(self->cfd2, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); 2734 ASSERT_EQ(ret, 0); 2735 2736 ret = fork(); 2737 ASSERT_GE(ret, 0); 2738 2739 if (ret) { 2740 usleep(1000); /* Give child a head start */ 2741 2742 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2743 EXPECT_EQ(errno, EAGAIN); 2744 2745 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2746 EXPECT_EQ(errno, EAGAIN); 2747 2748 wait(&ret); 2749 } else { 2750 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2751 EXPECT_EQ(errno, EAGAIN); 2752 exit(0); 2753 } 2754 } 2755 2756 TEST_F(tls_err, poll_partial_rec) 2757 { 2758 struct pollfd pfd = { }; 2759 ssize_t rec_len; 2760 char rec[256]; 2761 char buf[128]; 2762 2763 if (self->notls) 2764 SKIP(return, "no TLS support"); 2765 2766 pfd.fd = self->cfd2; 2767 pfd.events = POLLIN; 2768 EXPECT_EQ(poll(&pfd, 1, 1), 0); 2769 2770 memrnd(buf, sizeof(buf)); 2771 EXPECT_EQ(send(self->fd, buf, sizeof(buf), 0), sizeof(buf)); 2772 rec_len = recv(self->cfd, rec, sizeof(rec), 0); 2773 EXPECT_GT(rec_len, sizeof(buf)); 2774 2775 /* Write 100B, not the full record ... */ 2776 EXPECT_EQ(send(self->fd2, rec, 100, 0), 100); 2777 /* ... no full record should mean no POLLIN */ 2778 pfd.fd = self->cfd2; 2779 pfd.events = POLLIN; 2780 EXPECT_EQ(poll(&pfd, 1, 1), 0); 2781 /* Now write the rest, and it should all pop out of the other end. */ 2782 EXPECT_EQ(send(self->fd2, rec + 100, rec_len - 100, 0), rec_len - 100); 2783 pfd.fd = self->cfd2; 2784 pfd.events = POLLIN; 2785 EXPECT_EQ(poll(&pfd, 1, 1), 1); 2786 EXPECT_EQ(recv(self->cfd2, rec, sizeof(rec), 0), sizeof(buf)); 2787 EXPECT_EQ(memcmp(buf, rec, sizeof(buf)), 0); 2788 } 2789 2790 TEST_F(tls_err, epoll_partial_rec) 2791 { 2792 struct epoll_event ev, events[10]; 2793 ssize_t rec_len; 2794 char rec[256]; 2795 char buf[128]; 2796 int epollfd; 2797 2798 if (self->notls) 2799 SKIP(return, "no TLS support"); 2800 2801 epollfd = epoll_create1(0); 2802 ASSERT_GE(epollfd, 0); 2803 2804 memset(&ev, 0, sizeof(ev)); 2805 ev.events = EPOLLIN; 2806 ev.data.fd = self->cfd2; 2807 ASSERT_GE(epoll_ctl(epollfd, EPOLL_CTL_ADD, self->cfd2, &ev), 0); 2808 2809 EXPECT_EQ(epoll_wait(epollfd, events, 10, 0), 0); 2810 2811 memrnd(buf, sizeof(buf)); 2812 EXPECT_EQ(send(self->fd, buf, sizeof(buf), 0), sizeof(buf)); 2813 rec_len = recv(self->cfd, rec, sizeof(rec), 0); 2814 EXPECT_GT(rec_len, sizeof(buf)); 2815 2816 /* Write 100B, not the full record ... */ 2817 EXPECT_EQ(send(self->fd2, rec, 100, 0), 100); 2818 /* ... no full record should mean no POLLIN */ 2819 EXPECT_EQ(epoll_wait(epollfd, events, 10, 0), 0); 2820 /* Now write the rest, and it should all pop out of the other end. */ 2821 EXPECT_EQ(send(self->fd2, rec + 100, rec_len - 100, 0), rec_len - 100); 2822 EXPECT_EQ(epoll_wait(epollfd, events, 10, 0), 1); 2823 EXPECT_EQ(recv(self->cfd2, rec, sizeof(rec), 0), sizeof(buf)); 2824 EXPECT_EQ(memcmp(buf, rec, sizeof(buf)), 0); 2825 2826 close(epollfd); 2827 } 2828 2829 TEST_F(tls_err, poll_partial_rec_async) 2830 { 2831 struct pollfd pfd = { }; 2832 char token = '\0'; 2833 ssize_t rec_len; 2834 char rec[256]; 2835 char buf[128]; 2836 int p[2]; 2837 int ret; 2838 2839 if (self->notls) 2840 SKIP(return, "no TLS support"); 2841 2842 ASSERT_GE(pipe(p), 0); 2843 2844 memrnd(buf, sizeof(buf)); 2845 EXPECT_EQ(send(self->fd, buf, sizeof(buf), 0), sizeof(buf)); 2846 rec_len = recv(self->cfd, rec, sizeof(rec), 0); 2847 EXPECT_GT(rec_len, sizeof(buf)); 2848 2849 ret = fork(); 2850 ASSERT_GE(ret, 0); 2851 2852 if (ret) { 2853 int status, pid2; 2854 2855 close(p[1]); 2856 usleep(1000); /* Give child a head start */ 2857 2858 EXPECT_EQ(send(self->fd2, rec, 100, 0), 100); 2859 2860 EXPECT_EQ(read(p[0], &token, 1), 1); /* Barrier #1 */ 2861 2862 EXPECT_EQ(send(self->fd2, rec + 100, rec_len - 100, 0), 2863 rec_len - 100); 2864 2865 pid2 = wait(&status); 2866 EXPECT_EQ(pid2, ret); 2867 EXPECT_EQ(status, 0); 2868 } else { 2869 close(p[0]); 2870 2871 /* Child should sleep in poll(), never get a wake */ 2872 pfd.fd = self->cfd2; 2873 pfd.events = POLLIN; 2874 EXPECT_EQ(poll(&pfd, 1, 20), 0); 2875 2876 EXPECT_EQ(write(p[1], &token, 1), 1); /* Barrier #1 */ 2877 2878 pfd.fd = self->cfd2; 2879 pfd.events = POLLIN; 2880 EXPECT_EQ(poll(&pfd, 1, 20), 1); 2881 2882 exit(!__test_passed(_metadata)); 2883 } 2884 } 2885 2886 /* Use OOB+large send to trigger copy mode due to memory pressure. 2887 * OOB causes a short read. 2888 */ 2889 TEST_F(tls_err, oob_pressure) 2890 { 2891 char buf[1<<16]; 2892 int i; 2893 2894 memrnd(buf, sizeof(buf)); 2895 2896 EXPECT_EQ(send(self->fd2, buf, 5, MSG_OOB), 5); 2897 EXPECT_EQ(send(self->fd2, buf, sizeof(buf), 0), sizeof(buf)); 2898 for (i = 0; i < 64; i++) 2899 EXPECT_EQ(send(self->fd2, buf, 5, MSG_OOB), 5); 2900 } 2901 2902 /* 2903 * Parse a stream of TLS records and ensure that each record respects 2904 * the specified @max_payload_len. 2905 */ 2906 static size_t parse_tls_records(struct __test_metadata *_metadata, 2907 const __u8 *rx_buf, int rx_len, int overhead, 2908 __u16 max_payload_len) 2909 { 2910 const __u8 *rec = rx_buf; 2911 size_t total_plaintext_rx = 0; 2912 const __u8 rec_header_len = 5; 2913 2914 while (rec < rx_buf + rx_len) { 2915 __u16 record_payload_len; 2916 __u16 plaintext_len; 2917 2918 /* Sanity check that it's a TLS header for application data */ 2919 ASSERT_EQ(rec[0], 23); 2920 ASSERT_EQ(rec[1], 0x3); 2921 ASSERT_EQ(rec[2], 0x3); 2922 2923 memcpy(&record_payload_len, rec + 3, 2); 2924 record_payload_len = ntohs(record_payload_len); 2925 ASSERT_GE(record_payload_len, overhead); 2926 2927 plaintext_len = record_payload_len - overhead; 2928 total_plaintext_rx += plaintext_len; 2929 2930 /* Plaintext must not exceed the specified limit */ 2931 ASSERT_LE(plaintext_len, max_payload_len); 2932 rec += rec_header_len + record_payload_len; 2933 } 2934 2935 return total_plaintext_rx; 2936 } 2937 2938 TEST(tls_12_tx_max_payload_len) 2939 { 2940 struct tls_crypto_info_keys tls12; 2941 int cfd, ret, fd, overhead; 2942 size_t total_plaintext_rx = 0; 2943 __u8 tx[1024], rx[2000]; 2944 __u16 limit = 128; 2945 __u16 opt = 0; 2946 unsigned int optlen = sizeof(opt); 2947 bool notls; 2948 2949 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_CCM_128, 2950 &tls12, 0); 2951 2952 ulp_sock_pair(_metadata, &fd, &cfd, ¬ls); 2953 2954 if (notls) 2955 exit(KSFT_SKIP); 2956 2957 /* Don't install keys on fd, we'll parse raw records */ 2958 ret = setsockopt(cfd, SOL_TLS, TLS_TX, &tls12, tls12.len); 2959 ASSERT_EQ(ret, 0); 2960 2961 ret = setsockopt(cfd, SOL_TLS, TLS_TX_MAX_PAYLOAD_LEN, &limit, 2962 sizeof(limit)); 2963 ASSERT_EQ(ret, 0); 2964 2965 ret = getsockopt(cfd, SOL_TLS, TLS_TX_MAX_PAYLOAD_LEN, &opt, &optlen); 2966 EXPECT_EQ(ret, 0); 2967 EXPECT_EQ(limit, opt); 2968 EXPECT_EQ(optlen, sizeof(limit)); 2969 2970 memset(tx, 0, sizeof(tx)); 2971 ASSERT_EQ(send(cfd, tx, sizeof(tx), 0), sizeof(tx)); 2972 close(cfd); 2973 2974 ret = recv(fd, rx, sizeof(rx), 0); 2975 2976 /* 2977 * 16B tag + 8B IV -- record header (5B) is not counted but we'll 2978 * need it to walk the record stream 2979 */ 2980 overhead = 16 + 8; 2981 total_plaintext_rx = parse_tls_records(_metadata, rx, ret, overhead, 2982 limit); 2983 2984 ASSERT_EQ(total_plaintext_rx, sizeof(tx)); 2985 close(fd); 2986 } 2987 2988 TEST(tls_12_tx_max_payload_len_open_rec) 2989 { 2990 struct tls_crypto_info_keys tls12; 2991 int cfd, ret, fd, overhead; 2992 size_t total_plaintext_rx = 0; 2993 __u8 tx[1024], rx[2000]; 2994 __u16 tx_partial = 256; 2995 __u16 og_limit = 512, limit = 128; 2996 bool notls; 2997 2998 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_CCM_128, 2999 &tls12, 0); 3000 3001 ulp_sock_pair(_metadata, &fd, &cfd, ¬ls); 3002 3003 if (notls) 3004 exit(KSFT_SKIP); 3005 3006 /* Don't install keys on fd, we'll parse raw records */ 3007 ret = setsockopt(cfd, SOL_TLS, TLS_TX, &tls12, tls12.len); 3008 ASSERT_EQ(ret, 0); 3009 3010 ret = setsockopt(cfd, SOL_TLS, TLS_TX_MAX_PAYLOAD_LEN, &og_limit, 3011 sizeof(og_limit)); 3012 ASSERT_EQ(ret, 0); 3013 3014 memset(tx, 0, sizeof(tx)); 3015 ASSERT_EQ(send(cfd, tx, tx_partial, MSG_MORE), tx_partial); 3016 3017 /* 3018 * Changing the payload limit with a pending open record should 3019 * not be allowed. 3020 */ 3021 ret = setsockopt(cfd, SOL_TLS, TLS_TX_MAX_PAYLOAD_LEN, &limit, 3022 sizeof(limit)); 3023 ASSERT_EQ(ret, -1); 3024 ASSERT_EQ(errno, EBUSY); 3025 3026 ASSERT_EQ(send(cfd, tx + tx_partial, sizeof(tx) - tx_partial, MSG_EOR), 3027 sizeof(tx) - tx_partial); 3028 close(cfd); 3029 3030 ret = recv(fd, rx, sizeof(rx), 0); 3031 3032 /* 3033 * 16B tag + 8B IV -- record header (5B) is not counted but we'll 3034 * need it to walk the record stream 3035 */ 3036 overhead = 16 + 8; 3037 total_plaintext_rx = parse_tls_records(_metadata, rx, ret, overhead, 3038 og_limit); 3039 ASSERT_EQ(total_plaintext_rx, sizeof(tx)); 3040 close(fd); 3041 } 3042 3043 TEST(non_established) { 3044 struct tls12_crypto_info_aes_gcm_256 tls12; 3045 struct sockaddr_in addr; 3046 int sfd, ret, fd; 3047 socklen_t len; 3048 3049 len = sizeof(addr); 3050 3051 memset(&tls12, 0, sizeof(tls12)); 3052 tls12.info.version = TLS_1_2_VERSION; 3053 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256; 3054 3055 addr.sin_family = AF_INET; 3056 addr.sin_addr.s_addr = htonl(INADDR_ANY); 3057 addr.sin_port = 0; 3058 3059 fd = socket(AF_INET, SOCK_STREAM, 0); 3060 sfd = socket(AF_INET, SOCK_STREAM, 0); 3061 3062 ret = bind(sfd, &addr, sizeof(addr)); 3063 ASSERT_EQ(ret, 0); 3064 ret = listen(sfd, 10); 3065 ASSERT_EQ(ret, 0); 3066 3067 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3068 EXPECT_EQ(ret, -1); 3069 /* TLS ULP not supported */ 3070 if (errno == ENOENT) 3071 return; 3072 EXPECT_EQ(errno, ENOTCONN); 3073 3074 ret = setsockopt(sfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3075 EXPECT_EQ(ret, -1); 3076 EXPECT_EQ(errno, ENOTCONN); 3077 3078 ret = getsockname(sfd, &addr, &len); 3079 ASSERT_EQ(ret, 0); 3080 3081 ret = connect(fd, &addr, sizeof(addr)); 3082 ASSERT_EQ(ret, 0); 3083 3084 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3085 ASSERT_EQ(ret, 0); 3086 3087 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3088 EXPECT_EQ(ret, -1); 3089 EXPECT_EQ(errno, EEXIST); 3090 3091 close(fd); 3092 close(sfd); 3093 } 3094 3095 TEST(keysizes) { 3096 struct tls12_crypto_info_aes_gcm_256 tls12; 3097 int ret, fd, cfd; 3098 bool notls; 3099 3100 memset(&tls12, 0, sizeof(tls12)); 3101 tls12.info.version = TLS_1_2_VERSION; 3102 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256; 3103 3104 ulp_sock_pair(_metadata, &fd, &cfd, ¬ls); 3105 3106 if (!notls) { 3107 ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12, 3108 sizeof(tls12)); 3109 EXPECT_EQ(ret, 0); 3110 3111 ret = setsockopt(cfd, SOL_TLS, TLS_RX, &tls12, 3112 sizeof(tls12)); 3113 EXPECT_EQ(ret, 0); 3114 } 3115 3116 close(fd); 3117 close(cfd); 3118 } 3119 3120 TEST(no_pad) { 3121 struct tls12_crypto_info_aes_gcm_256 tls12; 3122 int ret, fd, cfd, val; 3123 socklen_t len; 3124 bool notls; 3125 3126 memset(&tls12, 0, sizeof(tls12)); 3127 tls12.info.version = TLS_1_3_VERSION; 3128 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256; 3129 3130 ulp_sock_pair(_metadata, &fd, &cfd, ¬ls); 3131 3132 if (notls) 3133 exit(KSFT_SKIP); 3134 3135 ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12, sizeof(tls12)); 3136 EXPECT_EQ(ret, 0); 3137 3138 ret = setsockopt(cfd, SOL_TLS, TLS_RX, &tls12, sizeof(tls12)); 3139 EXPECT_EQ(ret, 0); 3140 3141 val = 1; 3142 ret = setsockopt(cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD, 3143 (void *)&val, sizeof(val)); 3144 EXPECT_EQ(ret, 0); 3145 3146 len = sizeof(val); 3147 val = 2; 3148 ret = getsockopt(cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD, 3149 (void *)&val, &len); 3150 EXPECT_EQ(ret, 0); 3151 EXPECT_EQ(val, 1); 3152 EXPECT_EQ(len, 4); 3153 3154 val = 0; 3155 ret = setsockopt(cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD, 3156 (void *)&val, sizeof(val)); 3157 EXPECT_EQ(ret, 0); 3158 3159 len = sizeof(val); 3160 val = 2; 3161 ret = getsockopt(cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD, 3162 (void *)&val, &len); 3163 EXPECT_EQ(ret, 0); 3164 EXPECT_EQ(val, 0); 3165 EXPECT_EQ(len, 4); 3166 3167 close(fd); 3168 close(cfd); 3169 } 3170 3171 TEST(tls_v6ops) { 3172 struct tls_crypto_info_keys tls12; 3173 struct sockaddr_in6 addr, addr2; 3174 int sfd, ret, fd; 3175 socklen_t len, len2; 3176 3177 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_GCM_128, &tls12, 0); 3178 3179 addr.sin6_family = AF_INET6; 3180 addr.sin6_addr = in6addr_any; 3181 addr.sin6_port = 0; 3182 3183 fd = socket(AF_INET6, SOCK_STREAM, 0); 3184 sfd = socket(AF_INET6, SOCK_STREAM, 0); 3185 3186 ret = bind(sfd, &addr, sizeof(addr)); 3187 ASSERT_EQ(ret, 0); 3188 ret = listen(sfd, 10); 3189 ASSERT_EQ(ret, 0); 3190 3191 len = sizeof(addr); 3192 ret = getsockname(sfd, &addr, &len); 3193 ASSERT_EQ(ret, 0); 3194 3195 ret = connect(fd, &addr, sizeof(addr)); 3196 ASSERT_EQ(ret, 0); 3197 3198 len = sizeof(addr); 3199 ret = getsockname(fd, &addr, &len); 3200 ASSERT_EQ(ret, 0); 3201 3202 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3203 if (ret) { 3204 ASSERT_EQ(errno, ENOENT); 3205 SKIP(return, "no TLS support"); 3206 } 3207 ASSERT_EQ(ret, 0); 3208 3209 ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12, tls12.len); 3210 ASSERT_EQ(ret, 0); 3211 3212 ret = setsockopt(fd, SOL_TLS, TLS_RX, &tls12, tls12.len); 3213 ASSERT_EQ(ret, 0); 3214 3215 len2 = sizeof(addr2); 3216 ret = getsockname(fd, &addr2, &len2); 3217 ASSERT_EQ(ret, 0); 3218 3219 EXPECT_EQ(len2, len); 3220 EXPECT_EQ(memcmp(&addr, &addr2, len), 0); 3221 3222 close(fd); 3223 close(sfd); 3224 } 3225 3226 TEST(prequeue) { 3227 struct tls_crypto_info_keys tls12; 3228 char buf[20000], buf2[20000]; 3229 struct sockaddr_in addr; 3230 int sfd, cfd, ret, fd; 3231 socklen_t len; 3232 3233 len = sizeof(addr); 3234 memrnd(buf, sizeof(buf)); 3235 3236 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_GCM_256, &tls12, 0); 3237 3238 addr.sin_family = AF_INET; 3239 addr.sin_addr.s_addr = htonl(INADDR_ANY); 3240 addr.sin_port = 0; 3241 3242 fd = socket(AF_INET, SOCK_STREAM, 0); 3243 sfd = socket(AF_INET, SOCK_STREAM, 0); 3244 3245 ASSERT_EQ(bind(sfd, &addr, sizeof(addr)), 0); 3246 ASSERT_EQ(listen(sfd, 10), 0); 3247 ASSERT_EQ(getsockname(sfd, &addr, &len), 0); 3248 ASSERT_EQ(connect(fd, &addr, sizeof(addr)), 0); 3249 ASSERT_GE(cfd = accept(sfd, &addr, &len), 0); 3250 close(sfd); 3251 3252 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3253 if (ret) { 3254 ASSERT_EQ(errno, ENOENT); 3255 SKIP(return, "no TLS support"); 3256 } 3257 3258 ASSERT_EQ(setsockopt(fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 3259 EXPECT_EQ(send(fd, buf, sizeof(buf), MSG_DONTWAIT), sizeof(buf)); 3260 3261 ASSERT_EQ(setsockopt(cfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")), 0); 3262 ASSERT_EQ(setsockopt(cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 3263 EXPECT_EQ(recv(cfd, buf2, sizeof(buf2), MSG_WAITALL), sizeof(buf2)); 3264 3265 EXPECT_EQ(memcmp(buf, buf2, sizeof(buf)), 0); 3266 3267 close(fd); 3268 close(cfd); 3269 } 3270 3271 TEST(data_steal) { 3272 struct tls_crypto_info_keys tls; 3273 char buf[20000], buf2[20000]; 3274 struct sockaddr_in addr; 3275 int sfd, cfd, ret, fd; 3276 int pid, status; 3277 socklen_t len; 3278 3279 len = sizeof(addr); 3280 memrnd(buf, sizeof(buf)); 3281 3282 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_GCM_256, &tls, 0); 3283 3284 addr.sin_family = AF_INET; 3285 addr.sin_addr.s_addr = htonl(INADDR_ANY); 3286 addr.sin_port = 0; 3287 3288 fd = socket(AF_INET, SOCK_STREAM, 0); 3289 sfd = socket(AF_INET, SOCK_STREAM, 0); 3290 3291 ASSERT_EQ(bind(sfd, &addr, sizeof(addr)), 0); 3292 ASSERT_EQ(listen(sfd, 10), 0); 3293 ASSERT_EQ(getsockname(sfd, &addr, &len), 0); 3294 ASSERT_EQ(connect(fd, &addr, sizeof(addr)), 0); 3295 ASSERT_GE(cfd = accept(sfd, &addr, &len), 0); 3296 close(sfd); 3297 3298 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3299 if (ret) { 3300 ASSERT_EQ(errno, ENOENT); 3301 SKIP(return, "no TLS support"); 3302 } 3303 ASSERT_EQ(setsockopt(cfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")), 0); 3304 3305 /* Spawn a child and get it into the read wait path of the underlying 3306 * TCP socket (before kernel .recvmsg is replaced with the TLS one). 3307 */ 3308 pid = fork(); 3309 ASSERT_GE(pid, 0); 3310 if (!pid) { 3311 EXPECT_EQ(recv(cfd, buf, sizeof(buf) / 2 + 1, MSG_WAITALL), 3312 sizeof(buf) / 2 + 1); 3313 exit(!__test_passed(_metadata)); 3314 } 3315 3316 /* Send a sync byte and poll until it's consumed to ensure 3317 * the child is in recv() before we proceed to install TLS. 3318 */ 3319 ASSERT_EQ(send(fd, buf, 1, 0), 1); 3320 do { 3321 usleep(500); 3322 } while (recv(cfd, buf, 1, MSG_PEEK | MSG_DONTWAIT) == 1); 3323 EXPECT_EQ(errno, EAGAIN); 3324 3325 ASSERT_EQ(setsockopt(fd, SOL_TLS, TLS_TX, &tls, tls.len), 0); 3326 ASSERT_EQ(setsockopt(cfd, SOL_TLS, TLS_RX, &tls, tls.len), 0); 3327 3328 EXPECT_EQ(send(fd, buf, sizeof(buf), 0), sizeof(buf)); 3329 EXPECT_EQ(wait(&status), pid); 3330 EXPECT_EQ(status, 0); 3331 EXPECT_EQ(recv(cfd, buf2, sizeof(buf2), MSG_DONTWAIT), -1); 3332 /* Don't check errno, the error will be different depending 3333 * on what random bytes TLS interpreted as the record length. 3334 */ 3335 3336 close(fd); 3337 close(cfd); 3338 } 3339 3340 static void __attribute__((constructor)) fips_check(void) { 3341 int res; 3342 FILE *f; 3343 3344 f = fopen("/proc/sys/crypto/fips_enabled", "r"); 3345 if (f) { 3346 res = fscanf(f, "%d", &fips_enabled); 3347 if (res != 1) 3348 ksft_print_msg("ERROR: Couldn't read /proc/sys/crypto/fips_enabled\n"); 3349 fclose(f); 3350 } 3351 } 3352 3353 TEST_HARNESS_MAIN 3354