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_onto_full_record) 839 { 840 char mem_send[4608]; 841 char mem_recv[4608]; 842 int frag_len = 100; 843 int nfrags, i, off; 844 int p[2]; 845 846 memrnd(mem_send, sizeof(mem_send)); 847 ASSERT_GE(pipe(p), 0); 848 849 for (nfrags = 16; nfrags <= 44; nfrags++) { 850 for (i = 0, off = 0; i < nfrags; i++, off += frag_len) { 851 EXPECT_EQ(write(p[1], mem_send + off, frag_len), frag_len); 852 EXPECT_EQ(splice(p[0], NULL, self->fd, NULL, frag_len, 853 SPLICE_F_MORE), frag_len); 854 } 855 856 EXPECT_EQ(send(self->fd, mem_send + off, 1, MSG_MORE), 1); 857 off++; 858 859 EXPECT_EQ(write(p[1], mem_send + off, frag_len), frag_len); 860 EXPECT_EQ(splice(p[0], NULL, self->fd, NULL, frag_len, 861 SPLICE_F_MORE), frag_len); 862 off += frag_len; 863 864 EXPECT_EQ(send(self->fd, mem_send + off, 1, 0), 1); 865 off++; 866 867 EXPECT_EQ(recv(self->cfd, mem_recv, off, MSG_WAITALL), off); 868 EXPECT_EQ(memcmp(mem_send, mem_recv, off), 0); 869 } 870 871 close(p[0]); 872 close(p[1]); 873 } 874 875 TEST_F(tls, splice_to_pipe) 876 { 877 int send_len = TLS_PAYLOAD_MAX_LEN; 878 char mem_send[TLS_PAYLOAD_MAX_LEN]; 879 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 880 int p[2]; 881 882 memrnd(mem_send, sizeof(mem_send)); 883 884 ASSERT_GE(pipe(p), 0); 885 EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len); 886 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, send_len, 0), send_len); 887 EXPECT_EQ(read(p[0], mem_recv, send_len), send_len); 888 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 889 } 890 891 TEST_F(tls, splice_cmsg_to_pipe) 892 { 893 char *test_str = "test_read"; 894 char record_type = 100; 895 int send_len = 10; 896 char buf[10]; 897 int p[2]; 898 899 if (self->notls) 900 SKIP(return, "no TLS support"); 901 902 ASSERT_GE(pipe(p), 0); 903 EXPECT_EQ(tls_send_cmsg(self->fd, 100, test_str, send_len, 0), 10); 904 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, send_len, 0), -1); 905 EXPECT_EQ(errno, EINVAL); 906 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1); 907 EXPECT_EQ(errno, EIO); 908 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type, 909 buf, sizeof(buf), MSG_WAITALL), 910 send_len); 911 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 912 } 913 914 TEST_F(tls, splice_dec_cmsg_to_pipe) 915 { 916 char *test_str = "test_read"; 917 char record_type = 100; 918 int send_len = 10; 919 char buf[10]; 920 int p[2]; 921 922 if (self->notls) 923 SKIP(return, "no TLS support"); 924 925 ASSERT_GE(pipe(p), 0); 926 EXPECT_EQ(tls_send_cmsg(self->fd, 100, test_str, send_len, 0), 10); 927 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1); 928 EXPECT_EQ(errno, EIO); 929 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, send_len, 0), -1); 930 EXPECT_EQ(errno, EINVAL); 931 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type, 932 buf, sizeof(buf), MSG_WAITALL), 933 send_len); 934 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 935 } 936 937 TEST_F(tls, recv_and_splice) 938 { 939 int send_len = TLS_PAYLOAD_MAX_LEN; 940 char mem_send[TLS_PAYLOAD_MAX_LEN]; 941 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 942 int half = send_len / 2; 943 int p[2]; 944 945 ASSERT_GE(pipe(p), 0); 946 EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len); 947 /* Recv hald of the record, splice the other half */ 948 EXPECT_EQ(recv(self->cfd, mem_recv, half, MSG_WAITALL), half); 949 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, half, SPLICE_F_NONBLOCK), 950 half); 951 EXPECT_EQ(read(p[0], &mem_recv[half], half), half); 952 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 953 } 954 955 TEST_F(tls, peek_and_splice) 956 { 957 int send_len = TLS_PAYLOAD_MAX_LEN; 958 char mem_send[TLS_PAYLOAD_MAX_LEN]; 959 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 960 int chunk = TLS_PAYLOAD_MAX_LEN / 4; 961 int n, i, p[2]; 962 963 memrnd(mem_send, sizeof(mem_send)); 964 965 ASSERT_GE(pipe(p), 0); 966 for (i = 0; i < 4; i++) 967 EXPECT_EQ(send(self->fd, &mem_send[chunk * i], chunk, 0), 968 chunk); 969 970 EXPECT_EQ(recv(self->cfd, mem_recv, chunk * 5 / 2, 971 MSG_WAITALL | MSG_PEEK), 972 chunk * 5 / 2); 973 EXPECT_EQ(memcmp(mem_send, mem_recv, chunk * 5 / 2), 0); 974 975 n = 0; 976 while (n < send_len) { 977 i = splice(self->cfd, NULL, p[1], NULL, send_len - n, 0); 978 EXPECT_GT(i, 0); 979 n += i; 980 } 981 EXPECT_EQ(n, send_len); 982 EXPECT_EQ(read(p[0], mem_recv, send_len), send_len); 983 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 984 } 985 986 TEST_F(tls, splice_to_pipe_small) 987 { 988 int send_len = TLS_PAYLOAD_MAX_LEN; 989 char mem_send[TLS_PAYLOAD_MAX_LEN]; 990 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 991 size_t total = 0; 992 int p[2]; 993 994 memrnd(mem_send, sizeof(mem_send)); 995 996 ASSERT_GE(pipe(p), 0); 997 998 /* Shrink pipe to 1 page (typically 4096 bytes) to force multiple 999 * splice iterations for a 16384-byte TLS record. 1000 */ 1001 EXPECT_GE(fcntl(p[1], F_SETPIPE_SZ, 4096), 4096); 1002 1003 EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len); 1004 1005 while (total < (size_t)send_len) { 1006 ssize_t spliced, drained; 1007 1008 spliced = splice(self->cfd, NULL, p[1], NULL, 1009 send_len - total, 0); 1010 EXPECT_GT(spliced, 0); 1011 if (spliced <= 0) 1012 break; 1013 1014 drained = read(p[0], mem_recv + total, spliced); 1015 EXPECT_EQ(drained, spliced); 1016 if (drained <= 0) 1017 break; 1018 1019 total += drained; 1020 } 1021 1022 EXPECT_EQ(total, (size_t)send_len); 1023 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 1024 1025 close(p[0]); 1026 close(p[1]); 1027 } 1028 1029 #define MAX_FRAGS 48 1030 TEST_F(tls, splice_short) 1031 { 1032 struct iovec sendchar_iov; 1033 char read_buf[0x10000]; 1034 char sendbuf[0x100]; 1035 char sendchar = 'S'; 1036 int pipefds[2]; 1037 int pipe_sz; 1038 int ret; 1039 int i; 1040 1041 sendchar_iov.iov_base = &sendchar; 1042 sendchar_iov.iov_len = 1; 1043 1044 memset(sendbuf, 's', sizeof(sendbuf)); 1045 1046 ASSERT_GE(pipe2(pipefds, O_NONBLOCK), 0); 1047 pipe_sz = (MAX_FRAGS + 1) * getpagesize(); 1048 ret = fcntl(pipefds[0], F_SETPIPE_SZ, pipe_sz); 1049 if (ret < 0 && errno == EPERM) 1050 SKIP(return, "insufficient pipe capacity"); 1051 ASSERT_GE(ret, pipe_sz); 1052 1053 for (i = 0; i < MAX_FRAGS; i++) 1054 ASSERT_GE(vmsplice(pipefds[1], &sendchar_iov, 1, 0), 0); 1055 1056 ASSERT_EQ(write(pipefds[1], sendbuf, sizeof(sendbuf)), sizeof(sendbuf)); 1057 1058 EXPECT_EQ(splice(pipefds[0], NULL, self->fd, NULL, MAX_FRAGS + 0x1000, 0), 1059 MAX_FRAGS + sizeof(sendbuf)); 1060 EXPECT_EQ(recv(self->cfd, read_buf, sizeof(read_buf), 0), MAX_FRAGS + sizeof(sendbuf)); 1061 EXPECT_EQ(recv(self->cfd, read_buf, sizeof(read_buf), MSG_DONTWAIT), -1); 1062 EXPECT_EQ(errno, EAGAIN); 1063 } 1064 #undef MAX_FRAGS 1065 1066 TEST_F(tls, recvmsg_single) 1067 { 1068 char const *test_str = "test_recvmsg_single"; 1069 int send_len = strlen(test_str) + 1; 1070 char buf[20]; 1071 struct msghdr hdr; 1072 struct iovec vec; 1073 1074 memset(&hdr, 0, sizeof(hdr)); 1075 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1076 vec.iov_base = (char *)buf; 1077 vec.iov_len = send_len; 1078 hdr.msg_iovlen = 1; 1079 hdr.msg_iov = &vec; 1080 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1); 1081 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 1082 } 1083 1084 TEST_F(tls, recvmsg_single_max) 1085 { 1086 int send_len = TLS_PAYLOAD_MAX_LEN; 1087 char send_mem[TLS_PAYLOAD_MAX_LEN]; 1088 char recv_mem[TLS_PAYLOAD_MAX_LEN]; 1089 struct iovec vec; 1090 struct msghdr hdr; 1091 1092 memrnd(send_mem, sizeof(send_mem)); 1093 1094 EXPECT_EQ(send(self->fd, send_mem, send_len, 0), send_len); 1095 vec.iov_base = (char *)recv_mem; 1096 vec.iov_len = TLS_PAYLOAD_MAX_LEN; 1097 1098 hdr.msg_iovlen = 1; 1099 hdr.msg_iov = &vec; 1100 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1); 1101 EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0); 1102 } 1103 1104 TEST_F(tls, recvmsg_multiple) 1105 { 1106 unsigned int msg_iovlen = 1024; 1107 struct iovec vec[1024]; 1108 char *iov_base[1024]; 1109 unsigned int iov_len = 16; 1110 int send_len = 1 << 14; 1111 char buf[1 << 14]; 1112 struct msghdr hdr; 1113 int i; 1114 1115 memrnd(buf, sizeof(buf)); 1116 1117 EXPECT_EQ(send(self->fd, buf, send_len, 0), send_len); 1118 for (i = 0; i < msg_iovlen; i++) { 1119 iov_base[i] = (char *)malloc(iov_len); 1120 vec[i].iov_base = iov_base[i]; 1121 vec[i].iov_len = iov_len; 1122 } 1123 1124 hdr.msg_iovlen = msg_iovlen; 1125 hdr.msg_iov = vec; 1126 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1); 1127 1128 for (i = 0; i < msg_iovlen; i++) 1129 free(iov_base[i]); 1130 } 1131 1132 TEST_F(tls, single_send_multiple_recv) 1133 { 1134 unsigned int total_len = TLS_PAYLOAD_MAX_LEN * 2; 1135 unsigned int send_len = TLS_PAYLOAD_MAX_LEN; 1136 char send_mem[TLS_PAYLOAD_MAX_LEN * 2]; 1137 char recv_mem[TLS_PAYLOAD_MAX_LEN * 2]; 1138 1139 memrnd(send_mem, sizeof(send_mem)); 1140 1141 EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0); 1142 memset(recv_mem, 0, total_len); 1143 1144 EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1); 1145 EXPECT_NE(recv(self->cfd, recv_mem + send_len, send_len, 0), -1); 1146 EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0); 1147 } 1148 1149 TEST_F(tls, multiple_send_single_recv) 1150 { 1151 unsigned int total_len = 2 * 10; 1152 unsigned int send_len = 10; 1153 char recv_mem[2 * 10]; 1154 char send_mem[10]; 1155 1156 memrnd(send_mem, sizeof(send_mem)); 1157 1158 EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0); 1159 EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0); 1160 memset(recv_mem, 0, total_len); 1161 EXPECT_EQ(recv(self->cfd, recv_mem, total_len, MSG_WAITALL), total_len); 1162 1163 EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0); 1164 EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0); 1165 } 1166 1167 TEST_F(tls, single_send_multiple_recv_non_align) 1168 { 1169 const unsigned int total_len = 15; 1170 const unsigned int recv_len = 10; 1171 char recv_mem[recv_len * 2]; 1172 char send_mem[total_len]; 1173 1174 memrnd(send_mem, sizeof(send_mem)); 1175 1176 EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0); 1177 memset(recv_mem, 0, total_len); 1178 1179 EXPECT_EQ(recv(self->cfd, recv_mem, recv_len, 0), recv_len); 1180 EXPECT_EQ(recv(self->cfd, recv_mem + recv_len, recv_len, 0), 5); 1181 EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0); 1182 } 1183 1184 TEST_F(tls, recv_partial) 1185 { 1186 char const *test_str = "test_read_partial"; 1187 char const *test_str_first = "test_read"; 1188 char const *test_str_second = "_partial"; 1189 int send_len = strlen(test_str) + 1; 1190 char recv_mem[18]; 1191 1192 memset(recv_mem, 0, sizeof(recv_mem)); 1193 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1194 EXPECT_EQ(recv(self->cfd, recv_mem, strlen(test_str_first), 1195 MSG_WAITALL), strlen(test_str_first)); 1196 EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0); 1197 memset(recv_mem, 0, sizeof(recv_mem)); 1198 EXPECT_EQ(recv(self->cfd, recv_mem, strlen(test_str_second), 1199 MSG_WAITALL), strlen(test_str_second)); 1200 EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)), 1201 0); 1202 } 1203 1204 TEST_F(tls, recv_nonblock) 1205 { 1206 char buf[4096]; 1207 bool err; 1208 1209 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1); 1210 err = (errno == EAGAIN || errno == EWOULDBLOCK); 1211 EXPECT_EQ(err, true); 1212 } 1213 1214 TEST_F(tls, recv_peek) 1215 { 1216 char const *test_str = "test_read_peek"; 1217 int send_len = strlen(test_str) + 1; 1218 char buf[15]; 1219 1220 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1221 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_PEEK), send_len); 1222 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 1223 memset(buf, 0, sizeof(buf)); 1224 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 1225 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 1226 } 1227 1228 TEST_F(tls, recv_peek_multiple) 1229 { 1230 char const *test_str = "test_read_peek"; 1231 int send_len = strlen(test_str) + 1; 1232 unsigned int num_peeks = 100; 1233 char buf[15]; 1234 int i; 1235 1236 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1237 for (i = 0; i < num_peeks; i++) { 1238 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1); 1239 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 1240 memset(buf, 0, sizeof(buf)); 1241 } 1242 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1); 1243 EXPECT_EQ(memcmp(test_str, buf, send_len), 0); 1244 } 1245 1246 TEST_F(tls, recv_peek_multiple_records) 1247 { 1248 char const *test_str = "test_read_peek_mult_recs"; 1249 char const *test_str_first = "test_read_peek"; 1250 char const *test_str_second = "_mult_recs"; 1251 int len; 1252 char buf[64]; 1253 1254 len = strlen(test_str_first); 1255 EXPECT_EQ(send(self->fd, test_str_first, len, 0), len); 1256 1257 len = strlen(test_str_second) + 1; 1258 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len); 1259 1260 len = strlen(test_str_first); 1261 memset(buf, 0, len); 1262 EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len); 1263 1264 /* MSG_PEEK can only peek into the current record. */ 1265 len = strlen(test_str_first); 1266 EXPECT_EQ(memcmp(test_str_first, buf, len), 0); 1267 1268 len = strlen(test_str) + 1; 1269 memset(buf, 0, len); 1270 EXPECT_EQ(recv(self->cfd, buf, len, MSG_WAITALL), len); 1271 1272 /* Non-MSG_PEEK will advance strparser (and therefore record) 1273 * however. 1274 */ 1275 len = strlen(test_str) + 1; 1276 EXPECT_EQ(memcmp(test_str, buf, len), 0); 1277 1278 /* MSG_MORE will hold current record open, so later MSG_PEEK 1279 * will see everything. 1280 */ 1281 len = strlen(test_str_first); 1282 EXPECT_EQ(send(self->fd, test_str_first, len, MSG_MORE), len); 1283 1284 len = strlen(test_str_second) + 1; 1285 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len); 1286 1287 len = strlen(test_str) + 1; 1288 memset(buf, 0, len); 1289 EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len); 1290 1291 len = strlen(test_str) + 1; 1292 EXPECT_EQ(memcmp(test_str, buf, len), 0); 1293 } 1294 1295 TEST_F(tls, recv_peek_large_buf_mult_recs) 1296 { 1297 char const *test_str = "test_read_peek_mult_recs"; 1298 char const *test_str_first = "test_read_peek"; 1299 char const *test_str_second = "_mult_recs"; 1300 int len; 1301 char buf[64]; 1302 1303 len = strlen(test_str_first); 1304 EXPECT_EQ(send(self->fd, test_str_first, len, 0), len); 1305 1306 len = strlen(test_str_second) + 1; 1307 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len); 1308 1309 len = strlen(test_str) + 1; 1310 memset(buf, 0, len); 1311 EXPECT_NE((len = recv(self->cfd, buf, len, 1312 MSG_PEEK | MSG_WAITALL)), -1); 1313 len = strlen(test_str) + 1; 1314 EXPECT_EQ(memcmp(test_str, buf, len), 0); 1315 } 1316 1317 TEST_F(tls, recv_lowat) 1318 { 1319 char send_mem[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 1320 char recv_mem[20]; 1321 int lowat = 8; 1322 1323 EXPECT_EQ(send(self->fd, send_mem, 10, 0), 10); 1324 EXPECT_EQ(send(self->fd, send_mem, 5, 0), 5); 1325 1326 memset(recv_mem, 0, 20); 1327 EXPECT_EQ(setsockopt(self->cfd, SOL_SOCKET, SO_RCVLOWAT, 1328 &lowat, sizeof(lowat)), 0); 1329 EXPECT_EQ(recv(self->cfd, recv_mem, 1, MSG_WAITALL), 1); 1330 EXPECT_EQ(recv(self->cfd, recv_mem + 1, 6, MSG_WAITALL), 6); 1331 EXPECT_EQ(recv(self->cfd, recv_mem + 7, 10, 0), 8); 1332 1333 EXPECT_EQ(memcmp(send_mem, recv_mem, 10), 0); 1334 EXPECT_EQ(memcmp(send_mem, recv_mem + 10, 5), 0); 1335 } 1336 1337 TEST_F(tls, bidir) 1338 { 1339 char const *test_str = "test_read"; 1340 int send_len = 10; 1341 char buf[10]; 1342 int ret; 1343 1344 if (!self->notls) { 1345 struct tls_crypto_info_keys tls12; 1346 1347 tls_crypto_info_init(variant->tls_version, variant->cipher_type, 1348 &tls12, 0); 1349 1350 ret = setsockopt(self->fd, SOL_TLS, TLS_RX, &tls12, 1351 tls12.len); 1352 ASSERT_EQ(ret, 0); 1353 1354 ret = setsockopt(self->cfd, SOL_TLS, TLS_TX, &tls12, 1355 tls12.len); 1356 ASSERT_EQ(ret, 0); 1357 } 1358 1359 ASSERT_EQ(strlen(test_str) + 1, send_len); 1360 1361 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1362 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1); 1363 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1364 1365 memset(buf, 0, sizeof(buf)); 1366 1367 EXPECT_EQ(send(self->cfd, test_str, send_len, 0), send_len); 1368 EXPECT_NE(recv(self->fd, buf, send_len, 0), -1); 1369 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1370 }; 1371 1372 TEST_F(tls, pollin) 1373 { 1374 char const *test_str = "test_poll"; 1375 struct pollfd fd = { 0, 0, 0 }; 1376 char buf[10]; 1377 int send_len = 10; 1378 1379 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1380 fd.fd = self->cfd; 1381 fd.events = POLLIN; 1382 1383 EXPECT_EQ(poll(&fd, 1, 20), 1); 1384 EXPECT_EQ(fd.revents & POLLIN, 1); 1385 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len); 1386 /* Test timing out */ 1387 EXPECT_EQ(poll(&fd, 1, 20), 0); 1388 } 1389 1390 TEST_F(tls, poll_wait) 1391 { 1392 char const *test_str = "test_poll_wait"; 1393 int send_len = strlen(test_str) + 1; 1394 struct pollfd fd = { 0, 0, 0 }; 1395 char recv_mem[15]; 1396 1397 fd.fd = self->cfd; 1398 fd.events = POLLIN; 1399 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1400 /* Set timeout to inf. secs */ 1401 EXPECT_EQ(poll(&fd, 1, -1), 1); 1402 EXPECT_EQ(fd.revents & POLLIN, 1); 1403 EXPECT_EQ(recv(self->cfd, recv_mem, send_len, MSG_WAITALL), send_len); 1404 } 1405 1406 TEST_F(tls, poll_wait_split) 1407 { 1408 struct pollfd fd = { 0, 0, 0 }; 1409 char send_mem[20] = {}; 1410 char recv_mem[15]; 1411 1412 fd.fd = self->cfd; 1413 fd.events = POLLIN; 1414 /* Send 20 bytes */ 1415 EXPECT_EQ(send(self->fd, send_mem, sizeof(send_mem), 0), 1416 sizeof(send_mem)); 1417 /* Poll with inf. timeout */ 1418 EXPECT_EQ(poll(&fd, 1, -1), 1); 1419 EXPECT_EQ(fd.revents & POLLIN, 1); 1420 EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), MSG_WAITALL), 1421 sizeof(recv_mem)); 1422 1423 /* Now the remaining 5 bytes of record data are in TLS ULP */ 1424 fd.fd = self->cfd; 1425 fd.events = POLLIN; 1426 EXPECT_EQ(poll(&fd, 1, -1), 1); 1427 EXPECT_EQ(fd.revents & POLLIN, 1); 1428 EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), 0), 1429 sizeof(send_mem) - sizeof(recv_mem)); 1430 } 1431 1432 TEST_F(tls, blocking) 1433 { 1434 size_t data = 100000; 1435 int res = fork(); 1436 1437 EXPECT_NE(res, -1); 1438 1439 if (res) { 1440 /* parent */ 1441 size_t left = data; 1442 char buf[16384]; 1443 int status; 1444 int pid2; 1445 1446 while (left) { 1447 int res = send(self->fd, buf, 1448 left > 16384 ? 16384 : left, 0); 1449 1450 EXPECT_GE(res, 0); 1451 left -= res; 1452 } 1453 1454 pid2 = wait(&status); 1455 EXPECT_EQ(status, 0); 1456 EXPECT_EQ(res, pid2); 1457 } else { 1458 /* child */ 1459 size_t left = data; 1460 char buf[16384]; 1461 1462 while (left) { 1463 int res = recv(self->cfd, buf, 1464 left > 16384 ? 16384 : left, 0); 1465 1466 EXPECT_GE(res, 0); 1467 left -= res; 1468 } 1469 } 1470 } 1471 1472 TEST_F(tls, nonblocking) 1473 { 1474 size_t data = 100000; 1475 int sendbuf = 100; 1476 int flags; 1477 int res; 1478 1479 flags = fcntl(self->fd, F_GETFL, 0); 1480 fcntl(self->fd, F_SETFL, flags | O_NONBLOCK); 1481 fcntl(self->cfd, F_SETFL, flags | O_NONBLOCK); 1482 1483 /* Ensure nonblocking behavior by imposing a small send 1484 * buffer. 1485 */ 1486 EXPECT_EQ(setsockopt(self->fd, SOL_SOCKET, SO_SNDBUF, 1487 &sendbuf, sizeof(sendbuf)), 0); 1488 1489 res = fork(); 1490 EXPECT_NE(res, -1); 1491 1492 if (res) { 1493 /* parent */ 1494 bool eagain = false; 1495 size_t left = data; 1496 char buf[16384]; 1497 int status; 1498 int pid2; 1499 1500 while (left) { 1501 int res = send(self->fd, buf, 1502 left > 16384 ? 16384 : left, 0); 1503 1504 if (res == -1 && errno == EAGAIN) { 1505 eagain = true; 1506 usleep(10000); 1507 continue; 1508 } 1509 EXPECT_GE(res, 0); 1510 left -= res; 1511 } 1512 1513 EXPECT_TRUE(eagain); 1514 pid2 = wait(&status); 1515 1516 EXPECT_EQ(status, 0); 1517 EXPECT_EQ(res, pid2); 1518 } else { 1519 /* child */ 1520 bool eagain = false; 1521 size_t left = data; 1522 char buf[16384]; 1523 1524 while (left) { 1525 int res = recv(self->cfd, buf, 1526 left > 16384 ? 16384 : left, 0); 1527 1528 if (res == -1 && errno == EAGAIN) { 1529 eagain = true; 1530 usleep(10000); 1531 continue; 1532 } 1533 EXPECT_GE(res, 0); 1534 left -= res; 1535 } 1536 EXPECT_TRUE(eagain); 1537 } 1538 } 1539 1540 static void 1541 test_mutliproc(struct __test_metadata *_metadata, struct _test_data_tls *self, 1542 bool sendpg, unsigned int n_readers, unsigned int n_writers) 1543 { 1544 const unsigned int n_children = n_readers + n_writers; 1545 const size_t data = 6 * 1000 * 1000; 1546 const size_t file_sz = data / 100; 1547 size_t read_bias, write_bias; 1548 int i, fd, child_id; 1549 char buf[file_sz]; 1550 pid_t pid; 1551 1552 /* Only allow multiples for simplicity */ 1553 ASSERT_EQ(!(n_readers % n_writers) || !(n_writers % n_readers), true); 1554 read_bias = n_writers / n_readers ?: 1; 1555 write_bias = n_readers / n_writers ?: 1; 1556 1557 /* prep a file to send */ 1558 fd = open("/tmp/", O_TMPFILE | O_RDWR, 0600); 1559 ASSERT_GE(fd, 0); 1560 1561 memset(buf, 0xac, file_sz); 1562 ASSERT_EQ(write(fd, buf, file_sz), file_sz); 1563 1564 /* spawn children */ 1565 for (child_id = 0; child_id < n_children; child_id++) { 1566 pid = fork(); 1567 ASSERT_NE(pid, -1); 1568 if (!pid) 1569 break; 1570 } 1571 1572 /* parent waits for all children */ 1573 if (pid) { 1574 for (i = 0; i < n_children; i++) { 1575 int status; 1576 1577 wait(&status); 1578 EXPECT_EQ(status, 0); 1579 } 1580 1581 return; 1582 } 1583 1584 /* Split threads for reading and writing */ 1585 if (child_id < n_readers) { 1586 size_t left = data * read_bias; 1587 char rb[8001]; 1588 1589 while (left) { 1590 int res; 1591 1592 res = recv(self->cfd, rb, 1593 left > sizeof(rb) ? sizeof(rb) : left, 0); 1594 1595 ASSERT_GE(res, 0); 1596 left -= res; 1597 } 1598 } else { 1599 size_t left = data * write_bias; 1600 1601 while (left) { 1602 int res; 1603 1604 ASSERT_EQ(lseek(fd, 0, SEEK_SET), 0); 1605 if (sendpg) 1606 res = sendfile(self->fd, fd, NULL, 1607 left > file_sz ? file_sz : left); 1608 else 1609 res = send(self->fd, buf, 1610 left > file_sz ? file_sz : left, 0); 1611 1612 ASSERT_GE(res, 0); 1613 left -= res; 1614 } 1615 } 1616 } 1617 1618 TEST_F(tls, mutliproc_even) 1619 { 1620 test_mutliproc(_metadata, self, false, 6, 6); 1621 } 1622 1623 TEST_F(tls, mutliproc_readers) 1624 { 1625 test_mutliproc(_metadata, self, false, 4, 12); 1626 } 1627 1628 TEST_F(tls, mutliproc_writers) 1629 { 1630 test_mutliproc(_metadata, self, false, 10, 2); 1631 } 1632 1633 TEST_F(tls, mutliproc_sendpage_even) 1634 { 1635 test_mutliproc(_metadata, self, true, 6, 6); 1636 } 1637 1638 TEST_F(tls, mutliproc_sendpage_readers) 1639 { 1640 test_mutliproc(_metadata, self, true, 4, 12); 1641 } 1642 1643 TEST_F(tls, mutliproc_sendpage_writers) 1644 { 1645 test_mutliproc(_metadata, self, true, 10, 2); 1646 } 1647 1648 TEST_F(tls, control_msg) 1649 { 1650 char *test_str = "test_read"; 1651 char record_type = 100; 1652 int send_len = 10; 1653 char buf[10]; 1654 1655 if (self->notls) 1656 SKIP(return, "no TLS support"); 1657 1658 EXPECT_EQ(tls_send_cmsg(self->fd, record_type, test_str, send_len, 0), 1659 send_len); 1660 /* Should fail because we didn't provide a control message */ 1661 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1); 1662 1663 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type, 1664 buf, sizeof(buf), MSG_WAITALL | MSG_PEEK), 1665 send_len); 1666 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1667 1668 /* Recv the message again without MSG_PEEK */ 1669 memset(buf, 0, sizeof(buf)); 1670 1671 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type, 1672 buf, sizeof(buf), MSG_WAITALL), 1673 send_len); 1674 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1675 } 1676 1677 TEST_F(tls, control_msg_nomerge) 1678 { 1679 char *rec1 = "1111"; 1680 char *rec2 = "2222"; 1681 int send_len = 5; 1682 char buf[15]; 1683 1684 if (self->notls) 1685 SKIP(return, "no TLS support"); 1686 1687 EXPECT_EQ(tls_send_cmsg(self->fd, 100, rec1, send_len, 0), send_len); 1688 EXPECT_EQ(tls_send_cmsg(self->fd, 100, rec2, send_len, 0), send_len); 1689 1690 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, 100, buf, sizeof(buf), MSG_PEEK), send_len); 1691 EXPECT_EQ(memcmp(buf, rec1, send_len), 0); 1692 1693 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, 100, buf, sizeof(buf), MSG_PEEK), send_len); 1694 EXPECT_EQ(memcmp(buf, rec1, send_len), 0); 1695 1696 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, 100, buf, sizeof(buf), 0), send_len); 1697 EXPECT_EQ(memcmp(buf, rec1, send_len), 0); 1698 1699 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, 100, buf, sizeof(buf), 0), send_len); 1700 EXPECT_EQ(memcmp(buf, rec2, send_len), 0); 1701 } 1702 1703 TEST_F(tls, data_control_data) 1704 { 1705 char *rec1 = "1111"; 1706 char *rec2 = "2222"; 1707 char *rec3 = "3333"; 1708 int send_len = 5; 1709 char buf[15]; 1710 1711 if (self->notls) 1712 SKIP(return, "no TLS support"); 1713 1714 EXPECT_EQ(send(self->fd, rec1, send_len, 0), send_len); 1715 EXPECT_EQ(tls_send_cmsg(self->fd, 100, rec2, send_len, 0), send_len); 1716 EXPECT_EQ(send(self->fd, rec3, send_len, 0), send_len); 1717 1718 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_PEEK), send_len); 1719 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_PEEK), send_len); 1720 } 1721 1722 TEST_F(tls, shutdown) 1723 { 1724 char const *test_str = "test_read"; 1725 int send_len = 10; 1726 char buf[10]; 1727 1728 ASSERT_EQ(strlen(test_str) + 1, send_len); 1729 1730 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1731 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1); 1732 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1733 1734 shutdown(self->fd, SHUT_RDWR); 1735 shutdown(self->cfd, SHUT_RDWR); 1736 } 1737 1738 TEST_F(tls, shutdown_unsent) 1739 { 1740 char const *test_str = "test_read"; 1741 int send_len = 10; 1742 1743 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len); 1744 1745 shutdown(self->fd, SHUT_RDWR); 1746 shutdown(self->cfd, SHUT_RDWR); 1747 } 1748 1749 TEST_F(tls, shutdown_reuse) 1750 { 1751 struct sockaddr_in addr; 1752 int ret; 1753 1754 shutdown(self->fd, SHUT_RDWR); 1755 shutdown(self->cfd, SHUT_RDWR); 1756 close(self->cfd); 1757 1758 addr.sin_family = AF_INET; 1759 addr.sin_addr.s_addr = htonl(INADDR_ANY); 1760 addr.sin_port = 0; 1761 1762 ret = bind(self->fd, &addr, sizeof(addr)); 1763 EXPECT_EQ(ret, 0); 1764 ret = listen(self->fd, 10); 1765 EXPECT_EQ(ret, -1); 1766 EXPECT_EQ(errno, EINVAL); 1767 1768 ret = connect(self->fd, &addr, sizeof(addr)); 1769 EXPECT_EQ(ret, -1); 1770 EXPECT_EQ(errno, EISCONN); 1771 } 1772 1773 TEST_F(tls, getsockopt) 1774 { 1775 struct tls_crypto_info_keys expect, get; 1776 socklen_t len; 1777 1778 /* get only the version/cipher */ 1779 len = sizeof(struct tls_crypto_info); 1780 memrnd(&get, sizeof(get)); 1781 EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &get, &len), 0); 1782 EXPECT_EQ(len, sizeof(struct tls_crypto_info)); 1783 EXPECT_EQ(get.crypto_info.version, variant->tls_version); 1784 EXPECT_EQ(get.crypto_info.cipher_type, variant->cipher_type); 1785 1786 /* get the full crypto_info */ 1787 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &expect, 0); 1788 len = expect.len; 1789 memrnd(&get, sizeof(get)); 1790 EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &get, &len), 0); 1791 EXPECT_EQ(len, expect.len); 1792 EXPECT_EQ(get.crypto_info.version, variant->tls_version); 1793 EXPECT_EQ(get.crypto_info.cipher_type, variant->cipher_type); 1794 EXPECT_EQ(memcmp(&get, &expect, expect.len), 0); 1795 1796 /* short get should fail */ 1797 len = sizeof(struct tls_crypto_info) - 1; 1798 EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &get, &len), -1); 1799 EXPECT_EQ(errno, EINVAL); 1800 1801 /* partial get of the cipher data should fail */ 1802 len = expect.len - 1; 1803 EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &get, &len), -1); 1804 EXPECT_EQ(errno, EINVAL); 1805 } 1806 1807 TEST_F(tls, recv_efault) 1808 { 1809 char *rec1 = "1111111111"; 1810 char *rec2 = "2222222222"; 1811 struct msghdr hdr = {}; 1812 struct iovec iov[2]; 1813 char recv_mem[12]; 1814 int ret; 1815 1816 if (self->notls) 1817 SKIP(return, "no TLS support"); 1818 1819 EXPECT_EQ(send(self->fd, rec1, 10, 0), 10); 1820 EXPECT_EQ(send(self->fd, rec2, 10, 0), 10); 1821 1822 iov[0].iov_base = recv_mem; 1823 iov[0].iov_len = sizeof(recv_mem); 1824 iov[1].iov_base = NULL; /* broken iov to make process_rx_list fail */ 1825 iov[1].iov_len = 1; 1826 1827 hdr.msg_iovlen = 2; 1828 hdr.msg_iov = iov; 1829 1830 EXPECT_EQ(recv(self->cfd, recv_mem, 1, 0), 1); 1831 EXPECT_EQ(recv_mem[0], rec1[0]); 1832 1833 ret = recvmsg(self->cfd, &hdr, 0); 1834 EXPECT_LE(ret, sizeof(recv_mem)); 1835 EXPECT_GE(ret, 9); 1836 EXPECT_EQ(memcmp(rec1, recv_mem, 9), 0); 1837 if (ret > 9) 1838 EXPECT_EQ(memcmp(rec2, recv_mem + 9, ret - 9), 0); 1839 } 1840 1841 #define TLS_RECORD_TYPE_HANDSHAKE 0x16 1842 1843 TEST_F(tls_basic, recvmsg_nopad_retry_iov) 1844 { 1845 char payload[32]; 1846 char first_iov[sizeof(payload)]; 1847 char later_iov[sizeof(payload) * 2]; 1848 char expected_later_iov[sizeof(later_iov)]; 1849 char cbuf[CMSG_SPACE(sizeof(char))]; 1850 struct tls_crypto_info_keys tls13; 1851 struct iovec iov[] = { 1852 { .iov_base = first_iov, .iov_len = sizeof(first_iov) }, 1853 { .iov_base = later_iov, .iov_len = sizeof(later_iov) }, 1854 }; 1855 struct msghdr msg = { 1856 .msg_iov = iov, 1857 .msg_iovlen = ARRAY_SIZE(iov), 1858 .msg_control = cbuf, 1859 .msg_controllen = sizeof(cbuf), 1860 }; 1861 int one = 1; 1862 int ret; 1863 int i; 1864 1865 if (self->notls) 1866 SKIP(return, "no TLS support"); 1867 1868 tls_crypto_info_init(TLS_1_3_VERSION, TLS_CIPHER_AES_GCM_128, 1869 &tls13, 0); 1870 1871 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls13, tls13.len); 1872 ASSERT_EQ(ret, 0); 1873 1874 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls13, tls13.len); 1875 ASSERT_EQ(ret, 0); 1876 1877 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD, 1878 &one, sizeof(one)); 1879 ASSERT_EQ(ret, 0); 1880 1881 for (i = 0; i < sizeof(payload); i++) 1882 payload[i] = 0x40 + i; 1883 memset(first_iov, 0xa5, sizeof(first_iov)); 1884 memset(later_iov, 0x5a, sizeof(later_iov)); 1885 memset(expected_later_iov, 0x5a, sizeof(expected_later_iov)); 1886 1887 /* A control record forces optimistic TLS 1.3 RX to retry. */ 1888 ret = tls_send_cmsg(self->fd, TLS_RECORD_TYPE_HANDSHAKE, 1889 payload, sizeof(payload), 0); 1890 ASSERT_EQ(ret, sizeof(payload)); 1891 1892 ret = recvmsg(self->cfd, &msg, 0); 1893 ASSERT_EQ(ret, sizeof(payload)); 1894 EXPECT_EQ(memcmp(first_iov, payload, sizeof(payload)), 0); 1895 EXPECT_EQ(memcmp(later_iov, expected_later_iov, 1896 sizeof(later_iov)), 0); 1897 } 1898 1899 /* key_update, length 1, update_not_requested */ 1900 static const char key_update_msg[] = "\x18\x00\x00\x01\x00"; 1901 static void tls_send_keyupdate(struct __test_metadata *_metadata, int fd) 1902 { 1903 size_t len = sizeof(key_update_msg); 1904 1905 EXPECT_EQ(tls_send_cmsg(fd, TLS_RECORD_TYPE_HANDSHAKE, 1906 (char *)key_update_msg, len, 0), 1907 len); 1908 } 1909 1910 static void tls_recv_keyupdate(struct __test_metadata *_metadata, int fd, int flags) 1911 { 1912 char buf[100]; 1913 1914 EXPECT_EQ(tls_recv_cmsg(_metadata, fd, TLS_RECORD_TYPE_HANDSHAKE, buf, sizeof(buf), flags), 1915 sizeof(key_update_msg)); 1916 EXPECT_EQ(memcmp(buf, key_update_msg, sizeof(key_update_msg)), 0); 1917 } 1918 1919 /* set the key to 0 then 1 for RX, immediately to 1 for TX */ 1920 TEST_F(tls_basic, rekey_rx) 1921 { 1922 struct tls_crypto_info_keys tls12_0, tls12_1; 1923 char const *test_str = "test_message"; 1924 int send_len = strlen(test_str) + 1; 1925 char buf[20]; 1926 int ret; 1927 1928 if (self->notls) 1929 return; 1930 1931 tls_crypto_info_init(TLS_1_3_VERSION, TLS_CIPHER_AES_GCM_128, 1932 &tls12_0, 0); 1933 tls_crypto_info_init(TLS_1_3_VERSION, TLS_CIPHER_AES_GCM_128, 1934 &tls12_1, 1); 1935 1936 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12_1, tls12_1.len); 1937 ASSERT_EQ(ret, 0); 1938 1939 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12_0, tls12_0.len); 1940 ASSERT_EQ(ret, 0); 1941 1942 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12_1, tls12_1.len); 1943 EXPECT_EQ(ret, 0); 1944 1945 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1946 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 1947 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1948 } 1949 1950 /* set the key to 0 then 1 for TX, immediately to 1 for RX */ 1951 TEST_F(tls_basic, rekey_tx) 1952 { 1953 struct tls_crypto_info_keys tls12_0, tls12_1; 1954 char const *test_str = "test_message"; 1955 int send_len = strlen(test_str) + 1; 1956 char buf[20]; 1957 int ret; 1958 1959 if (self->notls) 1960 return; 1961 1962 tls_crypto_info_init(TLS_1_3_VERSION, TLS_CIPHER_AES_GCM_128, 1963 &tls12_0, 0); 1964 tls_crypto_info_init(TLS_1_3_VERSION, TLS_CIPHER_AES_GCM_128, 1965 &tls12_1, 1); 1966 1967 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12_0, tls12_0.len); 1968 ASSERT_EQ(ret, 0); 1969 1970 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12_1, tls12_1.len); 1971 ASSERT_EQ(ret, 0); 1972 1973 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12_1, tls12_1.len); 1974 EXPECT_EQ(ret, 0); 1975 1976 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 1977 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 1978 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 1979 } 1980 1981 TEST_F(tls_basic, disconnect) 1982 { 1983 char const *test_str = "test_message"; 1984 int send_len = strlen(test_str) + 1; 1985 struct tls_crypto_info_keys key; 1986 struct sockaddr_in addr; 1987 char buf[20]; 1988 int ret; 1989 1990 if (self->notls) 1991 return; 1992 1993 tls_crypto_info_init(TLS_1_3_VERSION, TLS_CIPHER_AES_GCM_128, 1994 &key, 0); 1995 1996 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &key, key.len); 1997 ASSERT_EQ(ret, 0); 1998 1999 /* Pre-queue the data so that setsockopt parses it but doesn't 2000 * dequeue it from the TCP socket. recvmsg would dequeue. 2001 */ 2002 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 2003 2004 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &key, key.len); 2005 ASSERT_EQ(ret, 0); 2006 2007 addr.sin_family = AF_UNSPEC; 2008 addr.sin_addr.s_addr = htonl(INADDR_ANY); 2009 addr.sin_port = 0; 2010 ret = connect(self->cfd, &addr, sizeof(addr)); 2011 EXPECT_EQ(ret, -1); 2012 EXPECT_EQ(errno, EOPNOTSUPP); 2013 2014 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 2015 } 2016 2017 TEST_F(tls, rekey) 2018 { 2019 char const *test_str_1 = "test_message_before_rekey"; 2020 char const *test_str_2 = "test_message_after_rekey"; 2021 struct tls_crypto_info_keys tls12; 2022 int send_len; 2023 char buf[100]; 2024 2025 if (variant->tls_version != TLS_1_3_VERSION) 2026 return; 2027 2028 /* initial send/recv */ 2029 send_len = strlen(test_str_1) + 1; 2030 EXPECT_EQ(send(self->fd, test_str_1, send_len, 0), send_len); 2031 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 2032 EXPECT_EQ(memcmp(buf, test_str_1, send_len), 0); 2033 2034 /* update TX key */ 2035 tls_send_keyupdate(_metadata, self->fd); 2036 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2037 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2038 2039 /* send after rekey */ 2040 send_len = strlen(test_str_2) + 1; 2041 EXPECT_EQ(send(self->fd, test_str_2, send_len, 0), send_len); 2042 2043 /* can't receive the KeyUpdate without a control message */ 2044 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1); 2045 2046 /* get KeyUpdate */ 2047 tls_recv_keyupdate(_metadata, self->cfd, 0); 2048 2049 /* recv blocking -> -EKEYEXPIRED */ 2050 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), 0), -1); 2051 EXPECT_EQ(errno, EKEYEXPIRED); 2052 2053 /* recv non-blocking -> -EKEYEXPIRED */ 2054 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1); 2055 EXPECT_EQ(errno, EKEYEXPIRED); 2056 2057 /* update RX key */ 2058 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2059 2060 /* recv after rekey */ 2061 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1); 2062 EXPECT_EQ(memcmp(buf, test_str_2, send_len), 0); 2063 } 2064 2065 TEST_F(tls, rekey_fail) 2066 { 2067 char const *test_str_1 = "test_message_before_rekey"; 2068 char const *test_str_2 = "test_message_after_rekey"; 2069 struct tls_crypto_info_keys tls12; 2070 int send_len; 2071 char buf[100]; 2072 2073 /* initial send/recv */ 2074 send_len = strlen(test_str_1) + 1; 2075 EXPECT_EQ(send(self->fd, test_str_1, send_len, 0), send_len); 2076 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 2077 EXPECT_EQ(memcmp(buf, test_str_1, send_len), 0); 2078 2079 /* update TX key */ 2080 tls_send_keyupdate(_metadata, self->fd); 2081 2082 if (variant->tls_version != TLS_1_3_VERSION) { 2083 /* just check that rekey is not supported and return */ 2084 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2085 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), -1); 2086 EXPECT_EQ(errno, EBUSY); 2087 return; 2088 } 2089 2090 /* successful update */ 2091 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2092 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2093 2094 /* invalid update: change of version */ 2095 tls_crypto_info_init(TLS_1_2_VERSION, variant->cipher_type, &tls12, 1); 2096 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), -1); 2097 EXPECT_EQ(errno, EINVAL); 2098 2099 /* invalid update (RX socket): change of version */ 2100 tls_crypto_info_init(TLS_1_2_VERSION, variant->cipher_type, &tls12, 1); 2101 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), -1); 2102 EXPECT_EQ(errno, EINVAL); 2103 2104 /* invalid update: change of cipher */ 2105 if (variant->cipher_type == TLS_CIPHER_AES_GCM_256) 2106 tls_crypto_info_init(variant->tls_version, TLS_CIPHER_CHACHA20_POLY1305, &tls12, 1); 2107 else 2108 tls_crypto_info_init(variant->tls_version, TLS_CIPHER_AES_GCM_256, &tls12, 1); 2109 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), -1); 2110 EXPECT_EQ(errno, EINVAL); 2111 2112 /* send after rekey, the invalid updates shouldn't have an effect */ 2113 send_len = strlen(test_str_2) + 1; 2114 EXPECT_EQ(send(self->fd, test_str_2, send_len, 0), send_len); 2115 2116 /* can't receive the KeyUpdate without a control message */ 2117 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1); 2118 2119 /* get KeyUpdate */ 2120 tls_recv_keyupdate(_metadata, self->cfd, 0); 2121 2122 /* recv blocking -> -EKEYEXPIRED */ 2123 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), 0), -1); 2124 EXPECT_EQ(errno, EKEYEXPIRED); 2125 2126 /* recv non-blocking -> -EKEYEXPIRED */ 2127 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1); 2128 EXPECT_EQ(errno, EKEYEXPIRED); 2129 2130 /* update RX key */ 2131 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2132 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2133 2134 /* recv after rekey */ 2135 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1); 2136 EXPECT_EQ(memcmp(buf, test_str_2, send_len), 0); 2137 } 2138 2139 TEST_F(tls, rekey_peek) 2140 { 2141 char const *test_str_1 = "test_message_before_rekey"; 2142 struct tls_crypto_info_keys tls12; 2143 int send_len; 2144 char buf[100]; 2145 2146 if (variant->tls_version != TLS_1_3_VERSION) 2147 return; 2148 2149 send_len = strlen(test_str_1) + 1; 2150 EXPECT_EQ(send(self->fd, test_str_1, send_len, 0), send_len); 2151 2152 /* update TX key */ 2153 tls_send_keyupdate(_metadata, self->fd); 2154 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2155 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2156 2157 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_PEEK), send_len); 2158 EXPECT_EQ(memcmp(buf, test_str_1, send_len), 0); 2159 2160 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 2161 EXPECT_EQ(memcmp(buf, test_str_1, send_len), 0); 2162 2163 /* can't receive the KeyUpdate without a control message */ 2164 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_PEEK), -1); 2165 2166 /* peek KeyUpdate */ 2167 tls_recv_keyupdate(_metadata, self->cfd, MSG_PEEK); 2168 2169 /* get KeyUpdate */ 2170 tls_recv_keyupdate(_metadata, self->cfd, 0); 2171 2172 /* update RX key */ 2173 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2174 } 2175 2176 TEST_F(tls, splice_rekey) 2177 { 2178 int send_len = TLS_PAYLOAD_MAX_LEN / 2; 2179 char mem_send[TLS_PAYLOAD_MAX_LEN]; 2180 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 2181 struct tls_crypto_info_keys tls12; 2182 int p[2]; 2183 2184 if (variant->tls_version != TLS_1_3_VERSION) 2185 return; 2186 2187 memrnd(mem_send, sizeof(mem_send)); 2188 2189 ASSERT_GE(pipe(p), 0); 2190 EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len); 2191 2192 /* update TX key */ 2193 tls_send_keyupdate(_metadata, self->fd); 2194 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2195 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2196 2197 EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len); 2198 2199 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, TLS_PAYLOAD_MAX_LEN, 0), send_len); 2200 EXPECT_EQ(read(p[0], mem_recv, send_len), send_len); 2201 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 2202 2203 /* can't splice the KeyUpdate */ 2204 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, TLS_PAYLOAD_MAX_LEN, 0), -1); 2205 EXPECT_EQ(errno, EINVAL); 2206 2207 /* peek KeyUpdate */ 2208 tls_recv_keyupdate(_metadata, self->cfd, MSG_PEEK); 2209 2210 /* get KeyUpdate */ 2211 tls_recv_keyupdate(_metadata, self->cfd, 0); 2212 2213 /* can't splice before updating the key */ 2214 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, TLS_PAYLOAD_MAX_LEN, 0), -1); 2215 EXPECT_EQ(errno, EKEYEXPIRED); 2216 2217 /* update RX key */ 2218 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2219 2220 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, TLS_PAYLOAD_MAX_LEN, 0), send_len); 2221 EXPECT_EQ(read(p[0], mem_recv, send_len), send_len); 2222 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0); 2223 } 2224 2225 TEST_F(tls, rekey_peek_splice) 2226 { 2227 char const *test_str_1 = "test_message_before_rekey"; 2228 struct tls_crypto_info_keys tls12; 2229 int send_len; 2230 char buf[100]; 2231 char mem_recv[TLS_PAYLOAD_MAX_LEN]; 2232 int p[2]; 2233 2234 if (variant->tls_version != TLS_1_3_VERSION) 2235 return; 2236 2237 ASSERT_GE(pipe(p), 0); 2238 2239 send_len = strlen(test_str_1) + 1; 2240 EXPECT_EQ(send(self->fd, test_str_1, send_len, 0), send_len); 2241 2242 /* update TX key */ 2243 tls_send_keyupdate(_metadata, self->fd); 2244 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2245 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2246 2247 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_PEEK), send_len); 2248 EXPECT_EQ(memcmp(buf, test_str_1, send_len), 0); 2249 2250 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, TLS_PAYLOAD_MAX_LEN, 0), send_len); 2251 EXPECT_EQ(read(p[0], mem_recv, send_len), send_len); 2252 EXPECT_EQ(memcmp(mem_recv, test_str_1, send_len), 0); 2253 } 2254 2255 TEST_F(tls, rekey_getsockopt) 2256 { 2257 struct tls_crypto_info_keys tls12; 2258 struct tls_crypto_info_keys tls12_get; 2259 socklen_t len; 2260 2261 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 0); 2262 2263 len = tls12.len; 2264 EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &tls12_get, &len), 0); 2265 EXPECT_EQ(len, tls12.len); 2266 EXPECT_EQ(memcmp(&tls12_get, &tls12, tls12.len), 0); 2267 2268 len = tls12.len; 2269 EXPECT_EQ(getsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12_get, &len), 0); 2270 EXPECT_EQ(len, tls12.len); 2271 EXPECT_EQ(memcmp(&tls12_get, &tls12, tls12.len), 0); 2272 2273 if (variant->tls_version != TLS_1_3_VERSION) 2274 return; 2275 2276 tls_send_keyupdate(_metadata, self->fd); 2277 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2278 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2279 2280 tls_recv_keyupdate(_metadata, self->cfd, 0); 2281 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2282 2283 len = tls12.len; 2284 EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &tls12_get, &len), 0); 2285 EXPECT_EQ(len, tls12.len); 2286 EXPECT_EQ(memcmp(&tls12_get, &tls12, tls12.len), 0); 2287 2288 len = tls12.len; 2289 EXPECT_EQ(getsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12_get, &len), 0); 2290 EXPECT_EQ(len, tls12.len); 2291 EXPECT_EQ(memcmp(&tls12_get, &tls12, tls12.len), 0); 2292 } 2293 2294 TEST_F(tls, rekey_poll_pending) 2295 { 2296 char const *test_str = "test_message_after_rekey"; 2297 struct tls_crypto_info_keys tls12; 2298 struct pollfd pfd = { }; 2299 int send_len; 2300 int ret; 2301 2302 if (variant->tls_version != TLS_1_3_VERSION) 2303 return; 2304 2305 /* update TX key */ 2306 tls_send_keyupdate(_metadata, self->fd); 2307 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2308 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2309 2310 /* get KeyUpdate */ 2311 tls_recv_keyupdate(_metadata, self->cfd, 0); 2312 2313 /* send immediately after rekey */ 2314 send_len = strlen(test_str) + 1; 2315 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 2316 2317 /* key hasn't been updated, expect cfd to be non-readable */ 2318 pfd.fd = self->cfd; 2319 pfd.events = POLLIN; 2320 EXPECT_EQ(poll(&pfd, 1, 0), 0); 2321 2322 ret = fork(); 2323 ASSERT_GE(ret, 0); 2324 2325 if (ret) { 2326 int pid2, status; 2327 2328 /* wait before installing the new key */ 2329 sleep(1); 2330 2331 /* update RX key while poll() is sleeping */ 2332 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2333 2334 pid2 = wait(&status); 2335 EXPECT_EQ(pid2, ret); 2336 EXPECT_EQ(status, 0); 2337 } else { 2338 pfd.fd = self->cfd; 2339 pfd.events = POLLIN; 2340 EXPECT_EQ(poll(&pfd, 1, 5000), 1); 2341 2342 exit(!__test_passed(_metadata)); 2343 } 2344 } 2345 2346 TEST_F(tls, rekey_poll_delay) 2347 { 2348 char const *test_str = "test_message_after_rekey"; 2349 struct tls_crypto_info_keys tls12; 2350 struct pollfd pfd = { }; 2351 int send_len; 2352 int ret; 2353 2354 if (variant->tls_version != TLS_1_3_VERSION) 2355 return; 2356 2357 /* update TX key */ 2358 tls_send_keyupdate(_metadata, self->fd); 2359 tls_crypto_info_init(variant->tls_version, variant->cipher_type, &tls12, 1); 2360 EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 2361 2362 /* get KeyUpdate */ 2363 tls_recv_keyupdate(_metadata, self->cfd, 0); 2364 2365 ret = fork(); 2366 ASSERT_GE(ret, 0); 2367 2368 if (ret) { 2369 int pid2, status; 2370 2371 /* wait before installing the new key */ 2372 sleep(1); 2373 2374 /* update RX key while poll() is sleeping */ 2375 EXPECT_EQ(setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 2376 2377 sleep(1); 2378 send_len = strlen(test_str) + 1; 2379 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 2380 2381 pid2 = wait(&status); 2382 EXPECT_EQ(pid2, ret); 2383 EXPECT_EQ(status, 0); 2384 } else { 2385 pfd.fd = self->cfd; 2386 pfd.events = POLLIN; 2387 EXPECT_EQ(poll(&pfd, 1, 5000), 1); 2388 exit(!__test_passed(_metadata)); 2389 } 2390 } 2391 2392 struct raw_rec { 2393 unsigned int plain_len; 2394 unsigned char plain_data[100]; 2395 unsigned int cipher_len; 2396 unsigned char cipher_data[128]; 2397 }; 2398 2399 /* TLS 1.2, AES_CCM, data, seqno:0, plaintext: 'Hello world' */ 2400 static const struct raw_rec id0_data_l11 = { 2401 .plain_len = 11, 2402 .plain_data = { 2403 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 2404 0x72, 0x6c, 0x64, 2405 }, 2406 .cipher_len = 40, 2407 .cipher_data = { 2408 0x17, 0x03, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 2409 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0xa2, 0x33, 2410 0xde, 0x8d, 0x94, 0xf0, 0x29, 0x6c, 0xb1, 0xaf, 2411 0x6a, 0x75, 0xb2, 0x93, 0xad, 0x45, 0xd5, 0xfd, 2412 0x03, 0x51, 0x57, 0x8f, 0xf9, 0xcc, 0x3b, 0x42, 2413 }, 2414 }; 2415 2416 /* TLS 1.2, AES_CCM, ctrl, seqno:0, plaintext: '' */ 2417 static const struct raw_rec id0_ctrl_l0 = { 2418 .plain_len = 0, 2419 .plain_data = { 2420 }, 2421 .cipher_len = 29, 2422 .cipher_data = { 2423 0x16, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 2424 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x38, 0x7b, 2425 0xa6, 0x1c, 0xdd, 0xa7, 0x19, 0x33, 0xab, 0xae, 2426 0x88, 0xe1, 0xd2, 0x08, 0x4f, 2427 }, 2428 }; 2429 2430 /* TLS 1.2, AES_CCM, data, seqno:0, plaintext: '' */ 2431 static const struct raw_rec id0_data_l0 = { 2432 .plain_len = 0, 2433 .plain_data = { 2434 }, 2435 .cipher_len = 29, 2436 .cipher_data = { 2437 0x17, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 2438 0x00, 0x00, 0x00, 0x00, 0x00, 0xc5, 0x37, 0x90, 2439 0x70, 0x45, 0x89, 0xfb, 0x5c, 0xc7, 0x89, 0x03, 2440 0x68, 0x80, 0xd3, 0xd8, 0xcc, 2441 }, 2442 }; 2443 2444 /* TLS 1.2, AES_CCM, data, seqno:1, plaintext: 'Hello world' */ 2445 static const struct raw_rec id1_data_l11 = { 2446 .plain_len = 11, 2447 .plain_data = { 2448 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 2449 0x72, 0x6c, 0x64, 2450 }, 2451 .cipher_len = 40, 2452 .cipher_data = { 2453 0x17, 0x03, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 2454 0x00, 0x00, 0x00, 0x00, 0x01, 0x3a, 0x1a, 0x9c, 2455 0xd0, 0xa8, 0x9a, 0xd6, 0x69, 0xd6, 0x1a, 0xe3, 2456 0xb5, 0x1f, 0x0d, 0x2c, 0xe2, 0x97, 0x46, 0xff, 2457 0x2b, 0xcc, 0x5a, 0xc4, 0xa3, 0xb9, 0xef, 0xba, 2458 }, 2459 }; 2460 2461 /* TLS 1.2, AES_CCM, ctrl, seqno:1, plaintext: '' */ 2462 static const struct raw_rec id1_ctrl_l0 = { 2463 .plain_len = 0, 2464 .plain_data = { 2465 }, 2466 .cipher_len = 29, 2467 .cipher_data = { 2468 0x16, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 2469 0x00, 0x00, 0x00, 0x00, 0x01, 0x3e, 0xf0, 0xfe, 2470 0xee, 0xd9, 0xe2, 0x5d, 0xc7, 0x11, 0x4c, 0xe6, 2471 0xb4, 0x7e, 0xef, 0x40, 0x2b, 2472 }, 2473 }; 2474 2475 /* TLS 1.2, AES_CCM, data, seqno:1, plaintext: '' */ 2476 static const struct raw_rec id1_data_l0 = { 2477 .plain_len = 0, 2478 .plain_data = { 2479 }, 2480 .cipher_len = 29, 2481 .cipher_data = { 2482 0x17, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 2483 0x00, 0x00, 0x00, 0x00, 0x01, 0xce, 0xfc, 0x86, 2484 0xc8, 0xf0, 0x55, 0xf9, 0x47, 0x3f, 0x74, 0xdc, 2485 0xc9, 0xbf, 0xfe, 0x5b, 0xb1, 2486 }, 2487 }; 2488 2489 /* TLS 1.2, AES_CCM, ctrl, seqno:2, plaintext: 'Hello world' */ 2490 static const struct raw_rec id2_ctrl_l11 = { 2491 .plain_len = 11, 2492 .plain_data = { 2493 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 2494 0x72, 0x6c, 0x64, 2495 }, 2496 .cipher_len = 40, 2497 .cipher_data = { 2498 0x16, 0x03, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 2499 0x00, 0x00, 0x00, 0x00, 0x02, 0xe5, 0x3d, 0x19, 2500 0x3d, 0xca, 0xb8, 0x16, 0xb6, 0xff, 0x79, 0x87, 2501 0x2a, 0x04, 0x11, 0x3d, 0xf8, 0x64, 0x5f, 0x36, 2502 0x8b, 0xa8, 0xee, 0x4c, 0x6d, 0x62, 0xa5, 0x00, 2503 }, 2504 }; 2505 2506 /* TLS 1.2, AES_CCM, data, seqno:2, plaintext: 'Hello world' */ 2507 static const struct raw_rec id2_data_l11 = { 2508 .plain_len = 11, 2509 .plain_data = { 2510 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 2511 0x72, 0x6c, 0x64, 2512 }, 2513 .cipher_len = 40, 2514 .cipher_data = { 2515 0x17, 0x03, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 2516 0x00, 0x00, 0x00, 0x00, 0x02, 0xe5, 0x3d, 0x19, 2517 0x3d, 0xca, 0xb8, 0x16, 0xb6, 0xff, 0x79, 0x87, 2518 0x8e, 0xa1, 0xd0, 0xcd, 0x33, 0xb5, 0x86, 0x2b, 2519 0x17, 0xf1, 0x52, 0x2a, 0x55, 0x62, 0x65, 0x11, 2520 }, 2521 }; 2522 2523 /* TLS 1.2, AES_CCM, ctrl, seqno:2, plaintext: '' */ 2524 static const struct raw_rec id2_ctrl_l0 = { 2525 .plain_len = 0, 2526 .plain_data = { 2527 }, 2528 .cipher_len = 29, 2529 .cipher_data = { 2530 0x16, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 2531 0x00, 0x00, 0x00, 0x00, 0x02, 0xdc, 0x5c, 0x0e, 2532 0x41, 0xdd, 0xba, 0xd3, 0xcc, 0xcf, 0x6d, 0xd9, 2533 0x06, 0xdb, 0x79, 0xe5, 0x5d, 2534 }, 2535 }; 2536 2537 /* TLS 1.2, AES_CCM, data, seqno:2, plaintext: '' */ 2538 static const struct raw_rec id2_data_l0 = { 2539 .plain_len = 0, 2540 .plain_data = { 2541 }, 2542 .cipher_len = 29, 2543 .cipher_data = { 2544 0x17, 0x03, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 2545 0x00, 0x00, 0x00, 0x00, 0x02, 0xc3, 0xca, 0x26, 2546 0x22, 0xe4, 0x25, 0xfb, 0x5f, 0x6d, 0xbf, 0x83, 2547 0x30, 0x48, 0x69, 0x1a, 0x47, 2548 }, 2549 }; 2550 2551 FIXTURE(zero_len) 2552 { 2553 int fd, cfd; 2554 bool notls; 2555 }; 2556 2557 FIXTURE_VARIANT(zero_len) 2558 { 2559 const struct raw_rec *recs[4]; 2560 ssize_t recv_ret[4]; 2561 }; 2562 2563 FIXTURE_VARIANT_ADD(zero_len, data_data_data) 2564 { 2565 .recs = { &id0_data_l11, &id1_data_l11, &id2_data_l11, }, 2566 .recv_ret = { 33, -EAGAIN, }, 2567 }; 2568 2569 FIXTURE_VARIANT_ADD(zero_len, data_0ctrl_data) 2570 { 2571 .recs = { &id0_data_l11, &id1_ctrl_l0, &id2_data_l11, }, 2572 .recv_ret = { 11, 0, 11, -EAGAIN, }, 2573 }; 2574 2575 FIXTURE_VARIANT_ADD(zero_len, 0data_0data_0data) 2576 { 2577 .recs = { &id0_data_l0, &id1_data_l0, &id2_data_l0, }, 2578 .recv_ret = { -EAGAIN, }, 2579 }; 2580 2581 FIXTURE_VARIANT_ADD(zero_len, 0data_0data_ctrl) 2582 { 2583 .recs = { &id0_data_l0, &id1_data_l0, &id2_ctrl_l11, }, 2584 .recv_ret = { 0, 11, -EAGAIN, }, 2585 }; 2586 2587 FIXTURE_VARIANT_ADD(zero_len, 0data_0data_0ctrl) 2588 { 2589 .recs = { &id0_data_l0, &id1_data_l0, &id2_ctrl_l0, }, 2590 .recv_ret = { 0, 0, -EAGAIN, }, 2591 }; 2592 2593 FIXTURE_VARIANT_ADD(zero_len, 0ctrl_0ctrl_0ctrl) 2594 { 2595 .recs = { &id0_ctrl_l0, &id1_ctrl_l0, &id2_ctrl_l0, }, 2596 .recv_ret = { 0, 0, 0, -EAGAIN, }, 2597 }; 2598 2599 FIXTURE_VARIANT_ADD(zero_len, 0data_0data_data) 2600 { 2601 .recs = { &id0_data_l0, &id1_data_l0, &id2_data_l11, }, 2602 .recv_ret = { 11, -EAGAIN, }, 2603 }; 2604 2605 FIXTURE_VARIANT_ADD(zero_len, data_0data_0data) 2606 { 2607 .recs = { &id0_data_l11, &id1_data_l0, &id2_data_l0, }, 2608 .recv_ret = { 11, -EAGAIN, }, 2609 }; 2610 2611 FIXTURE_SETUP(zero_len) 2612 { 2613 struct tls_crypto_info_keys tls12; 2614 int ret; 2615 2616 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_CCM_128, 2617 &tls12, 0); 2618 2619 ulp_sock_pair(_metadata, &self->fd, &self->cfd, &self->notls); 2620 if (self->notls) 2621 return; 2622 2623 /* Don't install keys on fd, we'll send raw records */ 2624 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len); 2625 ASSERT_EQ(ret, 0); 2626 } 2627 2628 FIXTURE_TEARDOWN(zero_len) 2629 { 2630 close(self->fd); 2631 close(self->cfd); 2632 } 2633 2634 TEST_F(zero_len, test) 2635 { 2636 const struct raw_rec *const *rec; 2637 unsigned char buf[128]; 2638 int rec_off; 2639 int i; 2640 2641 for (i = 0; i < 4 && variant->recs[i]; i++) 2642 EXPECT_EQ(send(self->fd, variant->recs[i]->cipher_data, 2643 variant->recs[i]->cipher_len, 0), 2644 variant->recs[i]->cipher_len); 2645 2646 rec = &variant->recs[0]; 2647 rec_off = 0; 2648 for (i = 0; i < 4; i++) { 2649 int j, ret; 2650 2651 ret = variant->recv_ret[i] >= 0 ? variant->recv_ret[i] : -1; 2652 EXPECT_EQ(__tls_recv_cmsg(_metadata, self->cfd, NULL, 2653 buf, sizeof(buf), MSG_DONTWAIT), ret); 2654 if (ret == -1) 2655 EXPECT_EQ(errno, -variant->recv_ret[i]); 2656 if (variant->recv_ret[i] == -EAGAIN) 2657 break; 2658 2659 for (j = 0; j < ret; j++) { 2660 while (rec_off == (*rec)->plain_len) { 2661 rec++; 2662 rec_off = 0; 2663 } 2664 EXPECT_EQ(buf[j], (*rec)->plain_data[rec_off]); 2665 rec_off++; 2666 } 2667 } 2668 }; 2669 2670 FIXTURE(tls_err) 2671 { 2672 int fd, cfd; 2673 int fd2, cfd2; 2674 bool notls; 2675 }; 2676 2677 FIXTURE_VARIANT(tls_err) 2678 { 2679 uint16_t tls_version; 2680 }; 2681 2682 FIXTURE_VARIANT_ADD(tls_err, 12_aes_gcm) 2683 { 2684 .tls_version = TLS_1_2_VERSION, 2685 }; 2686 2687 FIXTURE_VARIANT_ADD(tls_err, 13_aes_gcm) 2688 { 2689 .tls_version = TLS_1_3_VERSION, 2690 }; 2691 2692 FIXTURE_SETUP(tls_err) 2693 { 2694 struct tls_crypto_info_keys tls12; 2695 int ret; 2696 2697 tls_crypto_info_init(variant->tls_version, TLS_CIPHER_AES_GCM_128, 2698 &tls12, 0); 2699 2700 ulp_sock_pair(_metadata, &self->fd, &self->cfd, &self->notls); 2701 ulp_sock_pair(_metadata, &self->fd2, &self->cfd2, &self->notls); 2702 if (self->notls) 2703 return; 2704 2705 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len); 2706 ASSERT_EQ(ret, 0); 2707 2708 ret = setsockopt(self->cfd2, SOL_TLS, TLS_RX, &tls12, tls12.len); 2709 ASSERT_EQ(ret, 0); 2710 } 2711 2712 FIXTURE_TEARDOWN(tls_err) 2713 { 2714 close(self->fd); 2715 close(self->cfd); 2716 close(self->fd2); 2717 close(self->cfd2); 2718 } 2719 2720 TEST_F(tls_err, bad_rec) 2721 { 2722 char buf[64]; 2723 2724 if (self->notls) 2725 SKIP(return, "no TLS support"); 2726 2727 memset(buf, 0x55, sizeof(buf)); 2728 EXPECT_EQ(send(self->fd2, buf, sizeof(buf), 0), sizeof(buf)); 2729 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2730 EXPECT_EQ(errno, EMSGSIZE); 2731 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), MSG_DONTWAIT), -1); 2732 EXPECT_EQ(errno, EAGAIN); 2733 } 2734 2735 TEST_F(tls_err, bad_auth) 2736 { 2737 char buf[128]; 2738 int n; 2739 2740 if (self->notls) 2741 SKIP(return, "no TLS support"); 2742 2743 memrnd(buf, sizeof(buf) / 2); 2744 EXPECT_EQ(send(self->fd, buf, sizeof(buf) / 2, 0), sizeof(buf) / 2); 2745 n = recv(self->cfd, buf, sizeof(buf), 0); 2746 EXPECT_GT(n, sizeof(buf) / 2); 2747 2748 buf[n - 1]++; 2749 2750 EXPECT_EQ(send(self->fd2, buf, n, 0), n); 2751 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2752 EXPECT_EQ(errno, EBADMSG); 2753 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2754 EXPECT_EQ(errno, EBADMSG); 2755 } 2756 2757 TEST_F(tls_err, bad_in_large_read) 2758 { 2759 char txt[3][64]; 2760 char cip[3][128]; 2761 char buf[3 * 128]; 2762 int i, n; 2763 2764 if (self->notls) 2765 SKIP(return, "no TLS support"); 2766 2767 /* Put 3 records in the sockets */ 2768 for (i = 0; i < 3; i++) { 2769 memrnd(txt[i], sizeof(txt[i])); 2770 EXPECT_EQ(send(self->fd, txt[i], sizeof(txt[i]), 0), 2771 sizeof(txt[i])); 2772 n = recv(self->cfd, cip[i], sizeof(cip[i]), 0); 2773 EXPECT_GT(n, sizeof(txt[i])); 2774 /* Break the third message */ 2775 if (i == 2) 2776 cip[2][n - 1]++; 2777 EXPECT_EQ(send(self->fd2, cip[i], n, 0), n); 2778 } 2779 2780 /* We should be able to receive the first two messages */ 2781 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), sizeof(txt[0]) * 2); 2782 EXPECT_EQ(memcmp(buf, txt[0], sizeof(txt[0])), 0); 2783 EXPECT_EQ(memcmp(buf + sizeof(txt[0]), txt[1], sizeof(txt[1])), 0); 2784 /* Third mesasge is bad */ 2785 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2786 EXPECT_EQ(errno, EBADMSG); 2787 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2788 EXPECT_EQ(errno, EBADMSG); 2789 } 2790 2791 TEST_F(tls_err, bad_cmsg) 2792 { 2793 char *test_str = "test_read"; 2794 int send_len = 10; 2795 char cip[128]; 2796 char buf[128]; 2797 char txt[64]; 2798 int n; 2799 2800 if (self->notls) 2801 SKIP(return, "no TLS support"); 2802 2803 /* Queue up one data record */ 2804 memrnd(txt, sizeof(txt)); 2805 EXPECT_EQ(send(self->fd, txt, sizeof(txt), 0), sizeof(txt)); 2806 n = recv(self->cfd, cip, sizeof(cip), 0); 2807 EXPECT_GT(n, sizeof(txt)); 2808 EXPECT_EQ(send(self->fd2, cip, n, 0), n); 2809 2810 EXPECT_EQ(tls_send_cmsg(self->fd, 100, test_str, send_len, 0), 10); 2811 n = recv(self->cfd, cip, sizeof(cip), 0); 2812 cip[n - 1]++; /* Break it */ 2813 EXPECT_GT(n, send_len); 2814 EXPECT_EQ(send(self->fd2, cip, n, 0), n); 2815 2816 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), sizeof(txt)); 2817 EXPECT_EQ(memcmp(buf, txt, sizeof(txt)), 0); 2818 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2819 EXPECT_EQ(errno, EBADMSG); 2820 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2821 EXPECT_EQ(errno, EBADMSG); 2822 } 2823 2824 TEST_F(tls_err, timeo) 2825 { 2826 struct timeval tv = { .tv_usec = 10000, }; 2827 char buf[128]; 2828 int ret; 2829 2830 if (self->notls) 2831 SKIP(return, "no TLS support"); 2832 2833 ret = setsockopt(self->cfd2, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); 2834 ASSERT_EQ(ret, 0); 2835 2836 ret = fork(); 2837 ASSERT_GE(ret, 0); 2838 2839 if (ret) { 2840 usleep(1000); /* Give child a head start */ 2841 2842 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2843 EXPECT_EQ(errno, EAGAIN); 2844 2845 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2846 EXPECT_EQ(errno, EAGAIN); 2847 2848 wait(&ret); 2849 } else { 2850 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1); 2851 EXPECT_EQ(errno, EAGAIN); 2852 exit(0); 2853 } 2854 } 2855 2856 TEST_F(tls_err, poll_partial_rec) 2857 { 2858 struct pollfd pfd = { }; 2859 ssize_t rec_len; 2860 char rec[256]; 2861 char buf[128]; 2862 2863 if (self->notls) 2864 SKIP(return, "no TLS support"); 2865 2866 pfd.fd = self->cfd2; 2867 pfd.events = POLLIN; 2868 EXPECT_EQ(poll(&pfd, 1, 1), 0); 2869 2870 memrnd(buf, sizeof(buf)); 2871 EXPECT_EQ(send(self->fd, buf, sizeof(buf), 0), sizeof(buf)); 2872 rec_len = recv(self->cfd, rec, sizeof(rec), 0); 2873 EXPECT_GT(rec_len, sizeof(buf)); 2874 2875 /* Write 100B, not the full record ... */ 2876 EXPECT_EQ(send(self->fd2, rec, 100, 0), 100); 2877 /* ... no full record should mean no POLLIN */ 2878 pfd.fd = self->cfd2; 2879 pfd.events = POLLIN; 2880 EXPECT_EQ(poll(&pfd, 1, 1), 0); 2881 /* Now write the rest, and it should all pop out of the other end. */ 2882 EXPECT_EQ(send(self->fd2, rec + 100, rec_len - 100, 0), rec_len - 100); 2883 pfd.fd = self->cfd2; 2884 pfd.events = POLLIN; 2885 EXPECT_EQ(poll(&pfd, 1, 1), 1); 2886 EXPECT_EQ(recv(self->cfd2, rec, sizeof(rec), 0), sizeof(buf)); 2887 EXPECT_EQ(memcmp(buf, rec, sizeof(buf)), 0); 2888 } 2889 2890 TEST_F(tls_err, epoll_partial_rec) 2891 { 2892 struct epoll_event ev, events[10]; 2893 ssize_t rec_len; 2894 char rec[256]; 2895 char buf[128]; 2896 int epollfd; 2897 2898 if (self->notls) 2899 SKIP(return, "no TLS support"); 2900 2901 epollfd = epoll_create1(0); 2902 ASSERT_GE(epollfd, 0); 2903 2904 memset(&ev, 0, sizeof(ev)); 2905 ev.events = EPOLLIN; 2906 ev.data.fd = self->cfd2; 2907 ASSERT_GE(epoll_ctl(epollfd, EPOLL_CTL_ADD, self->cfd2, &ev), 0); 2908 2909 EXPECT_EQ(epoll_wait(epollfd, events, 10, 0), 0); 2910 2911 memrnd(buf, sizeof(buf)); 2912 EXPECT_EQ(send(self->fd, buf, sizeof(buf), 0), sizeof(buf)); 2913 rec_len = recv(self->cfd, rec, sizeof(rec), 0); 2914 EXPECT_GT(rec_len, sizeof(buf)); 2915 2916 /* Write 100B, not the full record ... */ 2917 EXPECT_EQ(send(self->fd2, rec, 100, 0), 100); 2918 /* ... no full record should mean no POLLIN */ 2919 EXPECT_EQ(epoll_wait(epollfd, events, 10, 0), 0); 2920 /* Now write the rest, and it should all pop out of the other end. */ 2921 EXPECT_EQ(send(self->fd2, rec + 100, rec_len - 100, 0), rec_len - 100); 2922 EXPECT_EQ(epoll_wait(epollfd, events, 10, 0), 1); 2923 EXPECT_EQ(recv(self->cfd2, rec, sizeof(rec), 0), sizeof(buf)); 2924 EXPECT_EQ(memcmp(buf, rec, sizeof(buf)), 0); 2925 2926 close(epollfd); 2927 } 2928 2929 TEST_F(tls_err, poll_partial_rec_async) 2930 { 2931 struct pollfd pfd = { }; 2932 char token = '\0'; 2933 ssize_t rec_len; 2934 char rec[256]; 2935 char buf[128]; 2936 int p[2]; 2937 int ret; 2938 2939 if (self->notls) 2940 SKIP(return, "no TLS support"); 2941 2942 ASSERT_GE(pipe(p), 0); 2943 2944 memrnd(buf, sizeof(buf)); 2945 EXPECT_EQ(send(self->fd, buf, sizeof(buf), 0), sizeof(buf)); 2946 rec_len = recv(self->cfd, rec, sizeof(rec), 0); 2947 EXPECT_GT(rec_len, sizeof(buf)); 2948 2949 ret = fork(); 2950 ASSERT_GE(ret, 0); 2951 2952 if (ret) { 2953 int status, pid2; 2954 2955 close(p[1]); 2956 usleep(1000); /* Give child a head start */ 2957 2958 EXPECT_EQ(send(self->fd2, rec, 100, 0), 100); 2959 2960 EXPECT_EQ(read(p[0], &token, 1), 1); /* Barrier #1 */ 2961 2962 EXPECT_EQ(send(self->fd2, rec + 100, rec_len - 100, 0), 2963 rec_len - 100); 2964 2965 pid2 = wait(&status); 2966 EXPECT_EQ(pid2, ret); 2967 EXPECT_EQ(status, 0); 2968 } else { 2969 close(p[0]); 2970 2971 /* Child should sleep in poll(), never get a wake */ 2972 pfd.fd = self->cfd2; 2973 pfd.events = POLLIN; 2974 EXPECT_EQ(poll(&pfd, 1, 20), 0); 2975 2976 EXPECT_EQ(write(p[1], &token, 1), 1); /* Barrier #1 */ 2977 2978 pfd.fd = self->cfd2; 2979 pfd.events = POLLIN; 2980 EXPECT_EQ(poll(&pfd, 1, 20), 1); 2981 2982 exit(!__test_passed(_metadata)); 2983 } 2984 } 2985 2986 /* Use OOB+large send to trigger copy mode due to memory pressure. 2987 * OOB causes a short read. 2988 */ 2989 TEST_F(tls_err, oob_pressure) 2990 { 2991 char buf[1<<16]; 2992 int i; 2993 2994 memrnd(buf, sizeof(buf)); 2995 2996 EXPECT_EQ(send(self->fd2, buf, 5, MSG_OOB), 5); 2997 EXPECT_EQ(send(self->fd2, buf, sizeof(buf), 0), sizeof(buf)); 2998 for (i = 0; i < 64; i++) 2999 EXPECT_EQ(send(self->fd2, buf, 5, MSG_OOB), 5); 3000 } 3001 3002 /* 3003 * Parse a stream of TLS records and ensure that each record respects 3004 * the specified @max_payload_len. 3005 */ 3006 static size_t parse_tls_records(struct __test_metadata *_metadata, 3007 const __u8 *rx_buf, int rx_len, int overhead, 3008 __u16 max_payload_len) 3009 { 3010 const __u8 *rec = rx_buf; 3011 size_t total_plaintext_rx = 0; 3012 const __u8 rec_header_len = 5; 3013 3014 while (rec < rx_buf + rx_len) { 3015 __u16 record_payload_len; 3016 __u16 plaintext_len; 3017 3018 /* Sanity check that it's a TLS header for application data */ 3019 ASSERT_EQ(rec[0], 23); 3020 ASSERT_EQ(rec[1], 0x3); 3021 ASSERT_EQ(rec[2], 0x3); 3022 3023 memcpy(&record_payload_len, rec + 3, 2); 3024 record_payload_len = ntohs(record_payload_len); 3025 ASSERT_GE(record_payload_len, overhead); 3026 3027 plaintext_len = record_payload_len - overhead; 3028 total_plaintext_rx += plaintext_len; 3029 3030 /* Plaintext must not exceed the specified limit */ 3031 ASSERT_LE(plaintext_len, max_payload_len); 3032 rec += rec_header_len + record_payload_len; 3033 } 3034 3035 return total_plaintext_rx; 3036 } 3037 3038 TEST(tls_12_tx_max_payload_len) 3039 { 3040 struct tls_crypto_info_keys tls12; 3041 int cfd, ret, fd, overhead; 3042 size_t total_plaintext_rx = 0; 3043 __u8 tx[1024], rx[2000]; 3044 __u16 limit = 128; 3045 __u16 opt = 0; 3046 unsigned int optlen = sizeof(opt); 3047 bool notls; 3048 3049 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_CCM_128, 3050 &tls12, 0); 3051 3052 ulp_sock_pair(_metadata, &fd, &cfd, ¬ls); 3053 3054 if (notls) 3055 exit(KSFT_SKIP); 3056 3057 /* Don't install keys on fd, we'll parse raw records */ 3058 ret = setsockopt(cfd, SOL_TLS, TLS_TX, &tls12, tls12.len); 3059 ASSERT_EQ(ret, 0); 3060 3061 ret = setsockopt(cfd, SOL_TLS, TLS_TX_MAX_PAYLOAD_LEN, &limit, 3062 sizeof(limit)); 3063 ASSERT_EQ(ret, 0); 3064 3065 ret = getsockopt(cfd, SOL_TLS, TLS_TX_MAX_PAYLOAD_LEN, &opt, &optlen); 3066 EXPECT_EQ(ret, 0); 3067 EXPECT_EQ(limit, opt); 3068 EXPECT_EQ(optlen, sizeof(limit)); 3069 3070 memset(tx, 0, sizeof(tx)); 3071 ASSERT_EQ(send(cfd, tx, sizeof(tx), 0), sizeof(tx)); 3072 close(cfd); 3073 3074 ret = recv(fd, rx, sizeof(rx), 0); 3075 3076 /* 3077 * 16B tag + 8B IV -- record header (5B) is not counted but we'll 3078 * need it to walk the record stream 3079 */ 3080 overhead = 16 + 8; 3081 total_plaintext_rx = parse_tls_records(_metadata, rx, ret, overhead, 3082 limit); 3083 3084 ASSERT_EQ(total_plaintext_rx, sizeof(tx)); 3085 close(fd); 3086 } 3087 3088 TEST(tls_12_tx_max_payload_len_open_rec) 3089 { 3090 struct tls_crypto_info_keys tls12; 3091 int cfd, ret, fd, overhead; 3092 size_t total_plaintext_rx = 0; 3093 __u8 tx[1024], rx[2000]; 3094 __u16 tx_partial = 256; 3095 __u16 og_limit = 512, limit = 128; 3096 bool notls; 3097 3098 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_CCM_128, 3099 &tls12, 0); 3100 3101 ulp_sock_pair(_metadata, &fd, &cfd, ¬ls); 3102 3103 if (notls) 3104 exit(KSFT_SKIP); 3105 3106 /* Don't install keys on fd, we'll parse raw records */ 3107 ret = setsockopt(cfd, SOL_TLS, TLS_TX, &tls12, tls12.len); 3108 ASSERT_EQ(ret, 0); 3109 3110 ret = setsockopt(cfd, SOL_TLS, TLS_TX_MAX_PAYLOAD_LEN, &og_limit, 3111 sizeof(og_limit)); 3112 ASSERT_EQ(ret, 0); 3113 3114 memset(tx, 0, sizeof(tx)); 3115 ASSERT_EQ(send(cfd, tx, tx_partial, MSG_MORE), tx_partial); 3116 3117 /* 3118 * Changing the payload limit with a pending open record should 3119 * not be allowed. 3120 */ 3121 ret = setsockopt(cfd, SOL_TLS, TLS_TX_MAX_PAYLOAD_LEN, &limit, 3122 sizeof(limit)); 3123 ASSERT_EQ(ret, -1); 3124 ASSERT_EQ(errno, EBUSY); 3125 3126 ASSERT_EQ(send(cfd, tx + tx_partial, sizeof(tx) - tx_partial, MSG_EOR), 3127 sizeof(tx) - tx_partial); 3128 close(cfd); 3129 3130 ret = recv(fd, rx, sizeof(rx), 0); 3131 3132 /* 3133 * 16B tag + 8B IV -- record header (5B) is not counted but we'll 3134 * need it to walk the record stream 3135 */ 3136 overhead = 16 + 8; 3137 total_plaintext_rx = parse_tls_records(_metadata, rx, ret, overhead, 3138 og_limit); 3139 ASSERT_EQ(total_plaintext_rx, sizeof(tx)); 3140 close(fd); 3141 } 3142 3143 TEST(non_established) { 3144 struct tls12_crypto_info_aes_gcm_256 tls12; 3145 struct sockaddr_in addr; 3146 int sfd, ret, fd; 3147 socklen_t len; 3148 3149 len = sizeof(addr); 3150 3151 memset(&tls12, 0, sizeof(tls12)); 3152 tls12.info.version = TLS_1_2_VERSION; 3153 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256; 3154 3155 addr.sin_family = AF_INET; 3156 addr.sin_addr.s_addr = htonl(INADDR_ANY); 3157 addr.sin_port = 0; 3158 3159 fd = socket(AF_INET, SOCK_STREAM, 0); 3160 sfd = socket(AF_INET, SOCK_STREAM, 0); 3161 3162 ret = bind(sfd, &addr, sizeof(addr)); 3163 ASSERT_EQ(ret, 0); 3164 ret = listen(sfd, 10); 3165 ASSERT_EQ(ret, 0); 3166 3167 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3168 EXPECT_EQ(ret, -1); 3169 /* TLS ULP not supported */ 3170 if (errno == ENOENT) 3171 return; 3172 EXPECT_EQ(errno, ENOTCONN); 3173 3174 ret = setsockopt(sfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3175 EXPECT_EQ(ret, -1); 3176 EXPECT_EQ(errno, ENOTCONN); 3177 3178 ret = getsockname(sfd, &addr, &len); 3179 ASSERT_EQ(ret, 0); 3180 3181 ret = connect(fd, &addr, sizeof(addr)); 3182 ASSERT_EQ(ret, 0); 3183 3184 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3185 ASSERT_EQ(ret, 0); 3186 3187 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3188 EXPECT_EQ(ret, -1); 3189 EXPECT_EQ(errno, EEXIST); 3190 3191 close(fd); 3192 close(sfd); 3193 } 3194 3195 TEST(keysizes) { 3196 struct tls12_crypto_info_aes_gcm_256 tls12; 3197 int ret, fd, cfd; 3198 bool notls; 3199 3200 memset(&tls12, 0, sizeof(tls12)); 3201 tls12.info.version = TLS_1_2_VERSION; 3202 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256; 3203 3204 ulp_sock_pair(_metadata, &fd, &cfd, ¬ls); 3205 3206 if (!notls) { 3207 ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12, 3208 sizeof(tls12)); 3209 EXPECT_EQ(ret, 0); 3210 3211 ret = setsockopt(cfd, SOL_TLS, TLS_RX, &tls12, 3212 sizeof(tls12)); 3213 EXPECT_EQ(ret, 0); 3214 } 3215 3216 close(fd); 3217 close(cfd); 3218 } 3219 3220 TEST(no_pad) { 3221 struct tls12_crypto_info_aes_gcm_256 tls12; 3222 int ret, fd, cfd, val; 3223 socklen_t len; 3224 bool notls; 3225 3226 memset(&tls12, 0, sizeof(tls12)); 3227 tls12.info.version = TLS_1_3_VERSION; 3228 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256; 3229 3230 ulp_sock_pair(_metadata, &fd, &cfd, ¬ls); 3231 3232 if (notls) 3233 exit(KSFT_SKIP); 3234 3235 ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12, sizeof(tls12)); 3236 EXPECT_EQ(ret, 0); 3237 3238 ret = setsockopt(cfd, SOL_TLS, TLS_RX, &tls12, sizeof(tls12)); 3239 EXPECT_EQ(ret, 0); 3240 3241 val = 1; 3242 ret = setsockopt(cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD, 3243 (void *)&val, sizeof(val)); 3244 EXPECT_EQ(ret, 0); 3245 3246 len = sizeof(val); 3247 val = 2; 3248 ret = getsockopt(cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD, 3249 (void *)&val, &len); 3250 EXPECT_EQ(ret, 0); 3251 EXPECT_EQ(val, 1); 3252 EXPECT_EQ(len, 4); 3253 3254 val = 0; 3255 ret = setsockopt(cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD, 3256 (void *)&val, sizeof(val)); 3257 EXPECT_EQ(ret, 0); 3258 3259 len = sizeof(val); 3260 val = 2; 3261 ret = getsockopt(cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD, 3262 (void *)&val, &len); 3263 EXPECT_EQ(ret, 0); 3264 EXPECT_EQ(val, 0); 3265 EXPECT_EQ(len, 4); 3266 3267 close(fd); 3268 close(cfd); 3269 } 3270 3271 TEST(tls_v6ops) { 3272 struct tls_crypto_info_keys tls12; 3273 struct sockaddr_in6 addr, addr2; 3274 int sfd, ret, fd; 3275 socklen_t len, len2; 3276 3277 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_GCM_128, &tls12, 0); 3278 3279 addr.sin6_family = AF_INET6; 3280 addr.sin6_addr = in6addr_any; 3281 addr.sin6_port = 0; 3282 3283 fd = socket(AF_INET6, SOCK_STREAM, 0); 3284 sfd = socket(AF_INET6, SOCK_STREAM, 0); 3285 3286 ret = bind(sfd, &addr, sizeof(addr)); 3287 ASSERT_EQ(ret, 0); 3288 ret = listen(sfd, 10); 3289 ASSERT_EQ(ret, 0); 3290 3291 len = sizeof(addr); 3292 ret = getsockname(sfd, &addr, &len); 3293 ASSERT_EQ(ret, 0); 3294 3295 ret = connect(fd, &addr, sizeof(addr)); 3296 ASSERT_EQ(ret, 0); 3297 3298 len = sizeof(addr); 3299 ret = getsockname(fd, &addr, &len); 3300 ASSERT_EQ(ret, 0); 3301 3302 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3303 if (ret) { 3304 ASSERT_EQ(errno, ENOENT); 3305 SKIP(return, "no TLS support"); 3306 } 3307 ASSERT_EQ(ret, 0); 3308 3309 ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12, tls12.len); 3310 ASSERT_EQ(ret, 0); 3311 3312 ret = setsockopt(fd, SOL_TLS, TLS_RX, &tls12, tls12.len); 3313 ASSERT_EQ(ret, 0); 3314 3315 len2 = sizeof(addr2); 3316 ret = getsockname(fd, &addr2, &len2); 3317 ASSERT_EQ(ret, 0); 3318 3319 EXPECT_EQ(len2, len); 3320 EXPECT_EQ(memcmp(&addr, &addr2, len), 0); 3321 3322 close(fd); 3323 close(sfd); 3324 } 3325 3326 TEST(prequeue) { 3327 struct tls_crypto_info_keys tls12; 3328 char buf[20000], buf2[20000]; 3329 struct sockaddr_in addr; 3330 int sfd, cfd, ret, fd; 3331 socklen_t len; 3332 3333 len = sizeof(addr); 3334 memrnd(buf, sizeof(buf)); 3335 3336 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_GCM_256, &tls12, 0); 3337 3338 addr.sin_family = AF_INET; 3339 addr.sin_addr.s_addr = htonl(INADDR_ANY); 3340 addr.sin_port = 0; 3341 3342 fd = socket(AF_INET, SOCK_STREAM, 0); 3343 sfd = socket(AF_INET, SOCK_STREAM, 0); 3344 3345 ASSERT_EQ(bind(sfd, &addr, sizeof(addr)), 0); 3346 ASSERT_EQ(listen(sfd, 10), 0); 3347 ASSERT_EQ(getsockname(sfd, &addr, &len), 0); 3348 ASSERT_EQ(connect(fd, &addr, sizeof(addr)), 0); 3349 ASSERT_GE(cfd = accept(sfd, &addr, &len), 0); 3350 close(sfd); 3351 3352 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3353 if (ret) { 3354 ASSERT_EQ(errno, ENOENT); 3355 SKIP(return, "no TLS support"); 3356 } 3357 3358 ASSERT_EQ(setsockopt(fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0); 3359 EXPECT_EQ(send(fd, buf, sizeof(buf), MSG_DONTWAIT), sizeof(buf)); 3360 3361 ASSERT_EQ(setsockopt(cfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")), 0); 3362 ASSERT_EQ(setsockopt(cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0); 3363 EXPECT_EQ(recv(cfd, buf2, sizeof(buf2), MSG_WAITALL), sizeof(buf2)); 3364 3365 EXPECT_EQ(memcmp(buf, buf2, sizeof(buf)), 0); 3366 3367 close(fd); 3368 close(cfd); 3369 } 3370 3371 TEST(data_steal) { 3372 struct tls_crypto_info_keys tls; 3373 char buf[20000], buf2[20000]; 3374 struct sockaddr_in addr; 3375 int sfd, cfd, ret, fd; 3376 int pid, status; 3377 socklen_t len; 3378 3379 len = sizeof(addr); 3380 memrnd(buf, sizeof(buf)); 3381 3382 tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_GCM_256, &tls, 0); 3383 3384 addr.sin_family = AF_INET; 3385 addr.sin_addr.s_addr = htonl(INADDR_ANY); 3386 addr.sin_port = 0; 3387 3388 fd = socket(AF_INET, SOCK_STREAM, 0); 3389 sfd = socket(AF_INET, SOCK_STREAM, 0); 3390 3391 ASSERT_EQ(bind(sfd, &addr, sizeof(addr)), 0); 3392 ASSERT_EQ(listen(sfd, 10), 0); 3393 ASSERT_EQ(getsockname(sfd, &addr, &len), 0); 3394 ASSERT_EQ(connect(fd, &addr, sizeof(addr)), 0); 3395 ASSERT_GE(cfd = accept(sfd, &addr, &len), 0); 3396 close(sfd); 3397 3398 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")); 3399 if (ret) { 3400 ASSERT_EQ(errno, ENOENT); 3401 SKIP(return, "no TLS support"); 3402 } 3403 ASSERT_EQ(setsockopt(cfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")), 0); 3404 3405 /* Spawn a child and get it into the read wait path of the underlying 3406 * TCP socket (before kernel .recvmsg is replaced with the TLS one). 3407 */ 3408 pid = fork(); 3409 ASSERT_GE(pid, 0); 3410 if (!pid) { 3411 EXPECT_EQ(recv(cfd, buf, sizeof(buf) / 2 + 1, MSG_WAITALL), 3412 sizeof(buf) / 2 + 1); 3413 exit(!__test_passed(_metadata)); 3414 } 3415 3416 /* Send a sync byte and poll until it's consumed to ensure 3417 * the child is in recv() before we proceed to install TLS. 3418 */ 3419 ASSERT_EQ(send(fd, buf, 1, 0), 1); 3420 do { 3421 usleep(500); 3422 } while (recv(cfd, buf, 1, MSG_PEEK | MSG_DONTWAIT) == 1); 3423 EXPECT_EQ(errno, EAGAIN); 3424 3425 ASSERT_EQ(setsockopt(fd, SOL_TLS, TLS_TX, &tls, tls.len), 0); 3426 ASSERT_EQ(setsockopt(cfd, SOL_TLS, TLS_RX, &tls, tls.len), 0); 3427 3428 EXPECT_EQ(send(fd, buf, sizeof(buf), 0), sizeof(buf)); 3429 EXPECT_EQ(wait(&status), pid); 3430 EXPECT_EQ(status, 0); 3431 EXPECT_EQ(recv(cfd, buf2, sizeof(buf2), MSG_DONTWAIT), -1); 3432 /* Don't check errno, the error will be different depending 3433 * on what random bytes TLS interpreted as the record length. 3434 */ 3435 3436 close(fd); 3437 close(cfd); 3438 } 3439 3440 static void __attribute__((constructor)) fips_check(void) { 3441 int res; 3442 FILE *f; 3443 3444 f = fopen("/proc/sys/crypto/fips_enabled", "r"); 3445 if (f) { 3446 res = fscanf(f, "%d", &fips_enabled); 3447 if (res != 1) 3448 ksft_print_msg("ERROR: Couldn't read /proc/sys/crypto/fips_enabled\n"); 3449 fclose(f); 3450 } 3451 } 3452 3453 TEST_HARNESS_MAIN 3454