1// SPDX-License-Identifier: GPL-2.0 2/* Copyright(c) 2016-20 Intel Corporation. */ 3 4#include <cpuid.h> 5#include <elf.h> 6#include <errno.h> 7#include <fcntl.h> 8#include <stdbool.h> 9#include <stdio.h> 10#include <stdint.h> 11#include <stdlib.h> 12#include <string.h> 13#include <unistd.h> 14#include <sys/ioctl.h> 15#include <sys/mman.h> 16#include <sys/stat.h> 17#include <sys/time.h> 18#include <sys/types.h> 19#include <sys/auxv.h> 20#include "defines.h" 21#include "../kselftest_harness.h" 22#include "main.h" 23 24static const uint64_t MAGIC = 0x1122334455667788ULL; 25static const uint64_t MAGIC2 = 0x8877665544332211ULL; 26vdso_sgx_enter_enclave_t vdso_sgx_enter_enclave; 27 28/* 29 * Security Information (SECINFO) data structure needed by a few SGX 30 * instructions (eg. ENCLU[EACCEPT] and ENCLU[EMODPE]) holds meta-data 31 * about an enclave page. &enum sgx_secinfo_page_state specifies the 32 * secinfo flags used for page state. 33 */ 34enum sgx_secinfo_page_state { 35 SGX_SECINFO_PENDING = (1 << 3), 36 SGX_SECINFO_MODIFIED = (1 << 4), 37 SGX_SECINFO_PR = (1 << 5), 38}; 39 40struct vdso_symtab { 41 Elf64_Sym *elf_symtab; 42 const char *elf_symstrtab; 43 Elf64_Word *elf_hashtab; 44}; 45 46static Elf64_Dyn *vdso_get_dyntab(void *addr) 47{ 48 Elf64_Ehdr *ehdr = addr; 49 Elf64_Phdr *phdrtab = addr + ehdr->e_phoff; 50 int i; 51 52 for (i = 0; i < ehdr->e_phnum; i++) 53 if (phdrtab[i].p_type == PT_DYNAMIC) 54 return addr + phdrtab[i].p_offset; 55 56 return NULL; 57} 58 59static void *vdso_get_dyn(void *addr, Elf64_Dyn *dyntab, Elf64_Sxword tag) 60{ 61 int i; 62 63 for (i = 0; dyntab[i].d_tag != DT_NULL; i++) 64 if (dyntab[i].d_tag == tag) 65 return addr + dyntab[i].d_un.d_ptr; 66 67 return NULL; 68} 69 70static bool vdso_get_symtab(void *addr, struct vdso_symtab *symtab) 71{ 72 Elf64_Dyn *dyntab = vdso_get_dyntab(addr); 73 74 symtab->elf_symtab = vdso_get_dyn(addr, dyntab, DT_SYMTAB); 75 if (!symtab->elf_symtab) 76 return false; 77 78 symtab->elf_symstrtab = vdso_get_dyn(addr, dyntab, DT_STRTAB); 79 if (!symtab->elf_symstrtab) 80 return false; 81 82 symtab->elf_hashtab = vdso_get_dyn(addr, dyntab, DT_HASH); 83 if (!symtab->elf_hashtab) 84 return false; 85 86 return true; 87} 88 89static inline int sgx2_supported(void) 90{ 91 unsigned int eax, ebx, ecx, edx; 92 93 __cpuid_count(SGX_CPUID, 0x0, eax, ebx, ecx, edx); 94 95 return eax & 0x2; 96} 97 98static unsigned long elf_sym_hash(const char *name) 99{ 100 unsigned long h = 0, high; 101 102 while (*name) { 103 h = (h << 4) + *name++; 104 high = h & 0xf0000000; 105 106 if (high) 107 h ^= high >> 24; 108 109 h &= ~high; 110 } 111 112 return h; 113} 114 115static Elf64_Sym *vdso_symtab_get(struct vdso_symtab *symtab, const char *name) 116{ 117 Elf64_Word bucketnum = symtab->elf_hashtab[0]; 118 Elf64_Word *buckettab = &symtab->elf_hashtab[2]; 119 Elf64_Word *chaintab = &symtab->elf_hashtab[2 + bucketnum]; 120 Elf64_Sym *sym; 121 Elf64_Word i; 122 123 for (i = buckettab[elf_sym_hash(name) % bucketnum]; i != STN_UNDEF; 124 i = chaintab[i]) { 125 sym = &symtab->elf_symtab[i]; 126 if (!strcmp(name, &symtab->elf_symstrtab[sym->st_name])) 127 return sym; 128 } 129 130 return NULL; 131} 132 133/* 134 * Return the offset in the enclave where the TCS segment can be found. 135 * The first RW segment loaded is the TCS. 136 */ 137static off_t encl_get_tcs_offset(struct encl *encl) 138{ 139 int i; 140 141 for (i = 0; i < encl->nr_segments; i++) { 142 struct encl_segment *seg = &encl->segment_tbl[i]; 143 144 if (i == 0 && seg->prot == (PROT_READ | PROT_WRITE)) 145 return seg->offset; 146 } 147 148 return -1; 149} 150 151/* 152 * Return the offset in the enclave where the data segment can be found. 153 * The first RW segment loaded is the TCS, skip that to get info on the 154 * data segment. 155 */ 156static off_t encl_get_data_offset(struct encl *encl) 157{ 158 int i; 159 160 for (i = 1; i < encl->nr_segments; i++) { 161 struct encl_segment *seg = &encl->segment_tbl[i]; 162 163 if (seg->prot == (PROT_READ | PROT_WRITE)) 164 return seg->offset; 165 } 166 167 return -1; 168} 169 170FIXTURE(enclave) { 171 struct encl encl; 172 struct sgx_enclave_run run; 173}; 174 175static bool setup_test_encl(unsigned long heap_size, struct encl *encl, 176 struct __test_metadata *_metadata) 177{ 178 Elf64_Sym *sgx_enter_enclave_sym = NULL; 179 struct vdso_symtab symtab; 180 struct encl_segment *seg; 181 char maps_line[256]; 182 FILE *maps_file; 183 unsigned int i; 184 void *addr; 185 186 if (!encl_load("test_encl.elf", encl, heap_size)) { 187 encl_delete(encl); 188 TH_LOG("Failed to load the test enclave."); 189 return false; 190 } 191 192 if (!encl_measure(encl)) 193 goto err; 194 195 if (!encl_build(encl)) 196 goto err; 197 198 /* 199 * An enclave consumer only must do this. 200 */ 201 for (i = 0; i < encl->nr_segments; i++) { 202 struct encl_segment *seg = &encl->segment_tbl[i]; 203 204 addr = mmap((void *)encl->encl_base + seg->offset, seg->size, 205 seg->prot, MAP_SHARED | MAP_FIXED, encl->fd, 0); 206 EXPECT_NE(addr, MAP_FAILED); 207 if (addr == MAP_FAILED) 208 goto err; 209 } 210 211 /* Get vDSO base address */ 212 addr = (void *)getauxval(AT_SYSINFO_EHDR); 213 if (!addr) 214 goto err; 215 216 if (!vdso_get_symtab(addr, &symtab)) 217 goto err; 218 219 sgx_enter_enclave_sym = vdso_symtab_get(&symtab, "__vdso_sgx_enter_enclave"); 220 if (!sgx_enter_enclave_sym) 221 goto err; 222 223 vdso_sgx_enter_enclave = addr + sgx_enter_enclave_sym->st_value; 224 225 return true; 226 227err: 228 for (i = 0; i < encl->nr_segments; i++) { 229 seg = &encl->segment_tbl[i]; 230 231 TH_LOG("0x%016lx 0x%016lx 0x%02x", seg->offset, seg->size, seg->prot); 232 } 233 234 maps_file = fopen("/proc/self/maps", "r"); 235 if (maps_file != NULL) { 236 while (fgets(maps_line, sizeof(maps_line), maps_file) != NULL) { 237 maps_line[strlen(maps_line) - 1] = '\0'; 238 239 if (strstr(maps_line, "/dev/sgx_enclave")) 240 TH_LOG("%s", maps_line); 241 } 242 243 fclose(maps_file); 244 } 245 246 TH_LOG("Failed to initialize the test enclave."); 247 248 encl_delete(encl); 249 250 return false; 251} 252 253FIXTURE_SETUP(enclave) 254{ 255} 256 257FIXTURE_TEARDOWN(enclave) 258{ 259 encl_delete(&self->encl); 260} 261 262#define ENCL_CALL(op, run, clobbered) \ 263 ({ \ 264 int ret; \ 265 if ((clobbered)) \ 266 ret = vdso_sgx_enter_enclave((unsigned long)(op), 0, 0, \ 267 EENTER, 0, 0, (run)); \ 268 else \ 269 ret = sgx_enter_enclave((void *)(op), NULL, 0, EENTER, NULL, NULL, \ 270 (run)); \ 271 ret; \ 272 }) 273 274#define EXPECT_EEXIT(run) \ 275 do { \ 276 EXPECT_EQ((run)->function, EEXIT); \ 277 if ((run)->function != EEXIT) \ 278 TH_LOG("0x%02x 0x%02x 0x%016llx", (run)->exception_vector, \ 279 (run)->exception_error_code, (run)->exception_addr); \ 280 } while (0) 281 282TEST_F(enclave, unclobbered_vdso) 283{ 284 struct encl_op_get_from_buf get_op; 285 struct encl_op_put_to_buf put_op; 286 287 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 288 289 memset(&self->run, 0, sizeof(self->run)); 290 self->run.tcs = self->encl.encl_base; 291 292 put_op.header.type = ENCL_OP_PUT_TO_BUFFER; 293 put_op.value = MAGIC; 294 295 EXPECT_EQ(ENCL_CALL(&put_op, &self->run, false), 0); 296 297 EXPECT_EEXIT(&self->run); 298 EXPECT_EQ(self->run.user_data, 0); 299 300 get_op.header.type = ENCL_OP_GET_FROM_BUFFER; 301 get_op.value = 0; 302 303 EXPECT_EQ(ENCL_CALL(&get_op, &self->run, false), 0); 304 305 EXPECT_EQ(get_op.value, MAGIC); 306 EXPECT_EEXIT(&self->run); 307 EXPECT_EQ(self->run.user_data, 0); 308} 309 310/* 311 * A section metric is concatenated in a way that @low bits 12-31 define the 312 * bits 12-31 of the metric and @high bits 0-19 define the bits 32-51 of the 313 * metric. 314 */ 315static unsigned long sgx_calc_section_metric(unsigned int low, 316 unsigned int high) 317{ 318 return (low & GENMASK_ULL(31, 12)) + 319 ((high & GENMASK_ULL(19, 0)) << 32); 320} 321 322/* 323 * Sum total available physical SGX memory across all EPC sections 324 * 325 * Return: total available physical SGX memory available on system 326 */ 327static unsigned long get_total_epc_mem(void) 328{ 329 unsigned int eax, ebx, ecx, edx; 330 unsigned long total_size = 0; 331 unsigned int type; 332 int section = 0; 333 334 while (true) { 335 __cpuid_count(SGX_CPUID, section + SGX_CPUID_EPC, eax, ebx, ecx, edx); 336 337 type = eax & SGX_CPUID_EPC_MASK; 338 if (type == SGX_CPUID_EPC_INVALID) 339 break; 340 341 if (type != SGX_CPUID_EPC_SECTION) 342 break; 343 344 total_size += sgx_calc_section_metric(ecx, edx); 345 346 section++; 347 } 348 349 return total_size; 350} 351 352TEST_F(enclave, unclobbered_vdso_oversubscribed) 353{ 354 struct encl_op_get_from_buf get_op; 355 struct encl_op_put_to_buf put_op; 356 unsigned long total_mem; 357 358 total_mem = get_total_epc_mem(); 359 ASSERT_NE(total_mem, 0); 360 ASSERT_TRUE(setup_test_encl(total_mem, &self->encl, _metadata)); 361 362 memset(&self->run, 0, sizeof(self->run)); 363 self->run.tcs = self->encl.encl_base; 364 365 put_op.header.type = ENCL_OP_PUT_TO_BUFFER; 366 put_op.value = MAGIC; 367 368 EXPECT_EQ(ENCL_CALL(&put_op, &self->run, false), 0); 369 370 EXPECT_EEXIT(&self->run); 371 EXPECT_EQ(self->run.user_data, 0); 372 373 get_op.header.type = ENCL_OP_GET_FROM_BUFFER; 374 get_op.value = 0; 375 376 EXPECT_EQ(ENCL_CALL(&get_op, &self->run, false), 0); 377 378 EXPECT_EQ(get_op.value, MAGIC); 379 EXPECT_EEXIT(&self->run); 380 EXPECT_EQ(self->run.user_data, 0); 381} 382 383TEST_F_TIMEOUT(enclave, unclobbered_vdso_oversubscribed_remove, 900) 384{ 385 struct sgx_enclave_remove_pages remove_ioc; 386 struct sgx_enclave_modify_types modt_ioc; 387 struct encl_op_get_from_buf get_op; 388 struct encl_op_eaccept eaccept_op; 389 struct encl_op_put_to_buf put_op; 390 struct encl_segment *heap; 391 unsigned long total_mem; 392 int ret, errno_save; 393 unsigned long addr; 394 unsigned long i; 395 396 /* 397 * Create enclave with additional heap that is as big as all 398 * available physical SGX memory. 399 */ 400 total_mem = get_total_epc_mem(); 401 ASSERT_NE(total_mem, 0); 402 TH_LOG("Creating an enclave with %lu bytes heap may take a while ...", 403 total_mem); 404 ASSERT_TRUE(setup_test_encl(total_mem, &self->encl, _metadata)); 405 406 /* 407 * Hardware (SGX2) and kernel support is needed for this test. Start 408 * with check that test has a chance of succeeding. 409 */ 410 memset(&modt_ioc, 0, sizeof(modt_ioc)); 411 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &modt_ioc); 412 413 if (ret == -1) { 414 if (errno == ENOTTY) 415 SKIP(return, 416 "Kernel does not support SGX_IOC_ENCLAVE_MODIFY_TYPES ioctl()"); 417 else if (errno == ENODEV) 418 SKIP(return, "System does not support SGX2"); 419 } 420 421 /* 422 * Invalid parameters were provided during sanity check, 423 * expect command to fail. 424 */ 425 EXPECT_EQ(ret, -1); 426 427 /* SGX2 is supported by kernel and hardware, test can proceed. */ 428 memset(&self->run, 0, sizeof(self->run)); 429 self->run.tcs = self->encl.encl_base; 430 431 heap = &self->encl.segment_tbl[self->encl.nr_segments - 1]; 432 433 put_op.header.type = ENCL_OP_PUT_TO_BUFFER; 434 put_op.value = MAGIC; 435 436 EXPECT_EQ(ENCL_CALL(&put_op, &self->run, false), 0); 437 438 EXPECT_EEXIT(&self->run); 439 EXPECT_EQ(self->run.user_data, 0); 440 441 get_op.header.type = ENCL_OP_GET_FROM_BUFFER; 442 get_op.value = 0; 443 444 EXPECT_EQ(ENCL_CALL(&get_op, &self->run, false), 0); 445 446 EXPECT_EQ(get_op.value, MAGIC); 447 EXPECT_EEXIT(&self->run); 448 EXPECT_EQ(self->run.user_data, 0); 449 450 /* Trim entire heap. */ 451 memset(&modt_ioc, 0, sizeof(modt_ioc)); 452 453 modt_ioc.offset = heap->offset; 454 modt_ioc.length = heap->size; 455 modt_ioc.page_type = SGX_PAGE_TYPE_TRIM; 456 457 TH_LOG("Changing type of %zd bytes to trimmed may take a while ...", 458 heap->size); 459 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &modt_ioc); 460 errno_save = ret == -1 ? errno : 0; 461 462 EXPECT_EQ(ret, 0); 463 EXPECT_EQ(errno_save, 0); 464 EXPECT_EQ(modt_ioc.result, 0); 465 EXPECT_EQ(modt_ioc.count, heap->size); 466 467 /* EACCEPT all removed pages. */ 468 addr = self->encl.encl_base + heap->offset; 469 470 eaccept_op.flags = SGX_SECINFO_TRIM | SGX_SECINFO_MODIFIED; 471 eaccept_op.header.type = ENCL_OP_EACCEPT; 472 473 TH_LOG("Entering enclave to run EACCEPT for each page of %zd bytes may take a while ...", 474 heap->size); 475 for (i = 0; i < heap->size; i += 4096) { 476 eaccept_op.epc_addr = addr + i; 477 eaccept_op.ret = 0; 478 479 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 480 481 EXPECT_EQ(self->run.exception_vector, 0); 482 EXPECT_EQ(self->run.exception_error_code, 0); 483 EXPECT_EQ(self->run.exception_addr, 0); 484 ASSERT_EQ(eaccept_op.ret, 0); 485 ASSERT_EQ(self->run.function, EEXIT); 486 } 487 488 /* Complete page removal. */ 489 memset(&remove_ioc, 0, sizeof(remove_ioc)); 490 491 remove_ioc.offset = heap->offset; 492 remove_ioc.length = heap->size; 493 494 TH_LOG("Removing %zd bytes from enclave may take a while ...", 495 heap->size); 496 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_REMOVE_PAGES, &remove_ioc); 497 errno_save = ret == -1 ? errno : 0; 498 499 EXPECT_EQ(ret, 0); 500 EXPECT_EQ(errno_save, 0); 501 EXPECT_EQ(remove_ioc.count, heap->size); 502} 503 504TEST_F(enclave, clobbered_vdso) 505{ 506 struct encl_op_get_from_buf get_op; 507 struct encl_op_put_to_buf put_op; 508 509 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 510 511 memset(&self->run, 0, sizeof(self->run)); 512 self->run.tcs = self->encl.encl_base; 513 514 put_op.header.type = ENCL_OP_PUT_TO_BUFFER; 515 put_op.value = MAGIC; 516 517 EXPECT_EQ(ENCL_CALL(&put_op, &self->run, true), 0); 518 519 EXPECT_EEXIT(&self->run); 520 EXPECT_EQ(self->run.user_data, 0); 521 522 get_op.header.type = ENCL_OP_GET_FROM_BUFFER; 523 get_op.value = 0; 524 525 EXPECT_EQ(ENCL_CALL(&get_op, &self->run, true), 0); 526 527 EXPECT_EQ(get_op.value, MAGIC); 528 EXPECT_EEXIT(&self->run); 529 EXPECT_EQ(self->run.user_data, 0); 530} 531 532static int test_handler(long rdi, long rsi, long rdx, long ursp, long r8, long r9, 533 struct sgx_enclave_run *run) 534{ 535 run->user_data = 0; 536 537 return 0; 538} 539 540TEST_F(enclave, clobbered_vdso_and_user_function) 541{ 542 struct encl_op_get_from_buf get_op; 543 struct encl_op_put_to_buf put_op; 544 545 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 546 547 memset(&self->run, 0, sizeof(self->run)); 548 self->run.tcs = self->encl.encl_base; 549 550 self->run.user_handler = (__u64)test_handler; 551 self->run.user_data = 0xdeadbeef; 552 553 put_op.header.type = ENCL_OP_PUT_TO_BUFFER; 554 put_op.value = MAGIC; 555 556 EXPECT_EQ(ENCL_CALL(&put_op, &self->run, true), 0); 557 558 EXPECT_EEXIT(&self->run); 559 EXPECT_EQ(self->run.user_data, 0); 560 561 get_op.header.type = ENCL_OP_GET_FROM_BUFFER; 562 get_op.value = 0; 563 564 EXPECT_EQ(ENCL_CALL(&get_op, &self->run, true), 0); 565 566 EXPECT_EQ(get_op.value, MAGIC); 567 EXPECT_EEXIT(&self->run); 568 EXPECT_EQ(self->run.user_data, 0); 569} 570 571/* 572 * Sanity check that it is possible to enter either of the two hardcoded TCS 573 */ 574TEST_F(enclave, tcs_entry) 575{ 576 struct encl_op_header op; 577 578 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 579 580 memset(&self->run, 0, sizeof(self->run)); 581 self->run.tcs = self->encl.encl_base; 582 583 op.type = ENCL_OP_NOP; 584 585 EXPECT_EQ(ENCL_CALL(&op, &self->run, true), 0); 586 587 EXPECT_EEXIT(&self->run); 588 EXPECT_EQ(self->run.exception_vector, 0); 589 EXPECT_EQ(self->run.exception_error_code, 0); 590 EXPECT_EQ(self->run.exception_addr, 0); 591 592 /* Move to the next TCS. */ 593 self->run.tcs = self->encl.encl_base + PAGE_SIZE; 594 595 EXPECT_EQ(ENCL_CALL(&op, &self->run, true), 0); 596 597 EXPECT_EEXIT(&self->run); 598 EXPECT_EQ(self->run.exception_vector, 0); 599 EXPECT_EQ(self->run.exception_error_code, 0); 600 EXPECT_EQ(self->run.exception_addr, 0); 601} 602 603/* 604 * Second page of .data segment is used to test changing PTE permissions. 605 * This spans the local encl_buffer within the test enclave. 606 * 607 * 1) Start with a sanity check: a value is written to the target page within 608 * the enclave and read back to ensure target page can be written to. 609 * 2) Change PTE permissions (RW -> RO) of target page within enclave. 610 * 3) Repeat (1) - this time expecting a regular #PF communicated via the 611 * vDSO. 612 * 4) Change PTE permissions of target page within enclave back to be RW. 613 * 5) Repeat (1) by resuming enclave, now expected to be possible to write to 614 * and read from target page within enclave. 615 */ 616TEST_F(enclave, pte_permissions) 617{ 618 struct encl_op_get_from_addr get_addr_op; 619 struct encl_op_put_to_addr put_addr_op; 620 unsigned long data_start; 621 int ret; 622 623 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 624 625 memset(&self->run, 0, sizeof(self->run)); 626 self->run.tcs = self->encl.encl_base; 627 628 data_start = self->encl.encl_base + 629 encl_get_data_offset(&self->encl) + 630 PAGE_SIZE; 631 632 /* 633 * Sanity check to ensure it is possible to write to page that will 634 * have its permissions manipulated. 635 */ 636 637 /* Write MAGIC to page */ 638 put_addr_op.value = MAGIC; 639 put_addr_op.addr = data_start; 640 put_addr_op.header.type = ENCL_OP_PUT_TO_ADDRESS; 641 642 EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0); 643 644 EXPECT_EEXIT(&self->run); 645 EXPECT_EQ(self->run.exception_vector, 0); 646 EXPECT_EQ(self->run.exception_error_code, 0); 647 EXPECT_EQ(self->run.exception_addr, 0); 648 649 /* 650 * Read memory that was just written to, confirming that it is the 651 * value previously written (MAGIC). 652 */ 653 get_addr_op.value = 0; 654 get_addr_op.addr = data_start; 655 get_addr_op.header.type = ENCL_OP_GET_FROM_ADDRESS; 656 657 EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0); 658 659 EXPECT_EQ(get_addr_op.value, MAGIC); 660 EXPECT_EEXIT(&self->run); 661 EXPECT_EQ(self->run.exception_vector, 0); 662 EXPECT_EQ(self->run.exception_error_code, 0); 663 EXPECT_EQ(self->run.exception_addr, 0); 664 665 /* Change PTE permissions of target page within the enclave */ 666 ret = mprotect((void *)data_start, PAGE_SIZE, PROT_READ); 667 if (ret) 668 perror("mprotect"); 669 670 /* 671 * PTE permissions of target page changed to read-only, EPCM 672 * permissions unchanged (EPCM permissions are RW), attempt to 673 * write to the page, expecting a regular #PF. 674 */ 675 676 put_addr_op.value = MAGIC2; 677 678 EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0); 679 680 EXPECT_EQ(self->run.exception_vector, 14); 681 EXPECT_EQ(self->run.exception_error_code, 0x7); 682 EXPECT_EQ(self->run.exception_addr, data_start); 683 684 self->run.exception_vector = 0; 685 self->run.exception_error_code = 0; 686 self->run.exception_addr = 0; 687 688 /* 689 * Change PTE permissions back to enable enclave to write to the 690 * target page and resume enclave - do not expect any exceptions this 691 * time. 692 */ 693 ret = mprotect((void *)data_start, PAGE_SIZE, PROT_READ | PROT_WRITE); 694 if (ret) 695 perror("mprotect"); 696 697 EXPECT_EQ(vdso_sgx_enter_enclave((unsigned long)&put_addr_op, 0, 698 0, ERESUME, 0, 0, &self->run), 699 0); 700 701 EXPECT_EEXIT(&self->run); 702 EXPECT_EQ(self->run.exception_vector, 0); 703 EXPECT_EQ(self->run.exception_error_code, 0); 704 EXPECT_EQ(self->run.exception_addr, 0); 705 706 get_addr_op.value = 0; 707 708 EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0); 709 710 EXPECT_EQ(get_addr_op.value, MAGIC2); 711 EXPECT_EEXIT(&self->run); 712 EXPECT_EQ(self->run.exception_vector, 0); 713 EXPECT_EQ(self->run.exception_error_code, 0); 714 EXPECT_EQ(self->run.exception_addr, 0); 715} 716 717/* 718 * Modifying permissions of TCS page should not be possible. 719 */ 720TEST_F(enclave, tcs_permissions) 721{ 722 struct sgx_enclave_restrict_permissions ioc; 723 int ret, errno_save; 724 725 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 726 727 memset(&self->run, 0, sizeof(self->run)); 728 self->run.tcs = self->encl.encl_base; 729 730 memset(&ioc, 0, sizeof(ioc)); 731 732 /* 733 * Ensure kernel supports needed ioctl() and system supports needed 734 * commands. 735 */ 736 737 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_RESTRICT_PERMISSIONS, &ioc); 738 errno_save = ret == -1 ? errno : 0; 739 740 /* 741 * Invalid parameters were provided during sanity check, 742 * expect command to fail. 743 */ 744 ASSERT_EQ(ret, -1); 745 746 /* ret == -1 */ 747 if (errno_save == ENOTTY) 748 SKIP(return, 749 "Kernel does not support SGX_IOC_ENCLAVE_RESTRICT_PERMISSIONS ioctl()"); 750 else if (errno_save == ENODEV) 751 SKIP(return, "System does not support SGX2"); 752 753 /* 754 * Attempt to make TCS page read-only. This is not allowed and 755 * should be prevented by the kernel. 756 */ 757 ioc.offset = encl_get_tcs_offset(&self->encl); 758 ioc.length = PAGE_SIZE; 759 ioc.permissions = SGX_SECINFO_R; 760 761 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_RESTRICT_PERMISSIONS, &ioc); 762 errno_save = ret == -1 ? errno : 0; 763 764 EXPECT_EQ(ret, -1); 765 EXPECT_EQ(errno_save, EINVAL); 766 EXPECT_EQ(ioc.result, 0); 767 EXPECT_EQ(ioc.count, 0); 768} 769 770/* 771 * Enclave page permission test. 772 * 773 * Modify and restore enclave page's EPCM (enclave) permissions from 774 * outside enclave (ENCLS[EMODPR] via kernel) as well as from within 775 * enclave (via ENCLU[EMODPE]). Check for page fault if 776 * VMA allows access but EPCM permissions do not. 777 */ 778TEST_F(enclave, epcm_permissions) 779{ 780 struct sgx_enclave_restrict_permissions restrict_ioc; 781 struct encl_op_get_from_addr get_addr_op; 782 struct encl_op_put_to_addr put_addr_op; 783 struct encl_op_eaccept eaccept_op; 784 struct encl_op_emodpe emodpe_op; 785 unsigned long data_start; 786 int ret, errno_save; 787 788 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 789 790 memset(&self->run, 0, sizeof(self->run)); 791 self->run.tcs = self->encl.encl_base; 792 793 /* 794 * Ensure kernel supports needed ioctl() and system supports needed 795 * commands. 796 */ 797 memset(&restrict_ioc, 0, sizeof(restrict_ioc)); 798 799 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_RESTRICT_PERMISSIONS, 800 &restrict_ioc); 801 errno_save = ret == -1 ? errno : 0; 802 803 /* 804 * Invalid parameters were provided during sanity check, 805 * expect command to fail. 806 */ 807 ASSERT_EQ(ret, -1); 808 809 /* ret == -1 */ 810 if (errno_save == ENOTTY) 811 SKIP(return, 812 "Kernel does not support SGX_IOC_ENCLAVE_RESTRICT_PERMISSIONS ioctl()"); 813 else if (errno_save == ENODEV) 814 SKIP(return, "System does not support SGX2"); 815 816 /* 817 * Page that will have its permissions changed is the second data 818 * page in the .data segment. This forms part of the local encl_buffer 819 * within the enclave. 820 * 821 * At start of test @data_start should have EPCM as well as PTE and 822 * VMA permissions of RW. 823 */ 824 825 data_start = self->encl.encl_base + 826 encl_get_data_offset(&self->encl) + PAGE_SIZE; 827 828 /* 829 * Sanity check that page at @data_start is writable before making 830 * any changes to page permissions. 831 * 832 * Start by writing MAGIC to test page. 833 */ 834 put_addr_op.value = MAGIC; 835 put_addr_op.addr = data_start; 836 put_addr_op.header.type = ENCL_OP_PUT_TO_ADDRESS; 837 838 EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0); 839 840 EXPECT_EEXIT(&self->run); 841 EXPECT_EQ(self->run.exception_vector, 0); 842 EXPECT_EQ(self->run.exception_error_code, 0); 843 EXPECT_EQ(self->run.exception_addr, 0); 844 845 /* 846 * Read memory that was just written to, confirming that 847 * page is writable. 848 */ 849 get_addr_op.value = 0; 850 get_addr_op.addr = data_start; 851 get_addr_op.header.type = ENCL_OP_GET_FROM_ADDRESS; 852 853 EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0); 854 855 EXPECT_EQ(get_addr_op.value, MAGIC); 856 EXPECT_EEXIT(&self->run); 857 EXPECT_EQ(self->run.exception_vector, 0); 858 EXPECT_EQ(self->run.exception_error_code, 0); 859 EXPECT_EQ(self->run.exception_addr, 0); 860 861 /* 862 * Change EPCM permissions to read-only. Kernel still considers 863 * the page writable. 864 */ 865 memset(&restrict_ioc, 0, sizeof(restrict_ioc)); 866 867 restrict_ioc.offset = encl_get_data_offset(&self->encl) + PAGE_SIZE; 868 restrict_ioc.length = PAGE_SIZE; 869 restrict_ioc.permissions = SGX_SECINFO_R; 870 871 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_RESTRICT_PERMISSIONS, 872 &restrict_ioc); 873 errno_save = ret == -1 ? errno : 0; 874 875 EXPECT_EQ(ret, 0); 876 EXPECT_EQ(errno_save, 0); 877 EXPECT_EQ(restrict_ioc.result, 0); 878 EXPECT_EQ(restrict_ioc.count, 4096); 879 880 /* 881 * EPCM permissions changed from kernel, need to EACCEPT from enclave. 882 */ 883 eaccept_op.epc_addr = data_start; 884 eaccept_op.flags = SGX_SECINFO_R | SGX_SECINFO_REG | SGX_SECINFO_PR; 885 eaccept_op.ret = 0; 886 eaccept_op.header.type = ENCL_OP_EACCEPT; 887 888 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 889 890 EXPECT_EEXIT(&self->run); 891 EXPECT_EQ(self->run.exception_vector, 0); 892 EXPECT_EQ(self->run.exception_error_code, 0); 893 EXPECT_EQ(self->run.exception_addr, 0); 894 EXPECT_EQ(eaccept_op.ret, 0); 895 896 /* 897 * EPCM permissions of page is now read-only, expect #PF 898 * on EPCM when attempting to write to page from within enclave. 899 */ 900 put_addr_op.value = MAGIC2; 901 902 EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0); 903 904 EXPECT_EQ(self->run.function, ERESUME); 905 EXPECT_EQ(self->run.exception_vector, 14); 906 EXPECT_EQ(self->run.exception_error_code, 0x8007); 907 EXPECT_EQ(self->run.exception_addr, data_start); 908 909 self->run.exception_vector = 0; 910 self->run.exception_error_code = 0; 911 self->run.exception_addr = 0; 912 913 /* 914 * Received AEX but cannot return to enclave at same entrypoint, 915 * need different TCS from where EPCM permission can be made writable 916 * again. 917 */ 918 self->run.tcs = self->encl.encl_base + PAGE_SIZE; 919 920 /* 921 * Enter enclave at new TCS to change EPCM permissions to be 922 * writable again and thus fix the page fault that triggered the 923 * AEX. 924 */ 925 926 emodpe_op.epc_addr = data_start; 927 emodpe_op.flags = SGX_SECINFO_R | SGX_SECINFO_W; 928 emodpe_op.header.type = ENCL_OP_EMODPE; 929 930 EXPECT_EQ(ENCL_CALL(&emodpe_op, &self->run, true), 0); 931 932 EXPECT_EEXIT(&self->run); 933 EXPECT_EQ(self->run.exception_vector, 0); 934 EXPECT_EQ(self->run.exception_error_code, 0); 935 EXPECT_EQ(self->run.exception_addr, 0); 936 937 /* 938 * Attempt to return to main TCS to resume execution at faulting 939 * instruction, PTE should continue to allow writing to the page. 940 */ 941 self->run.tcs = self->encl.encl_base; 942 943 /* 944 * Wrong page permissions that caused original fault has 945 * now been fixed via EPCM permissions. 946 * Resume execution in main TCS to re-attempt the memory access. 947 */ 948 self->run.tcs = self->encl.encl_base; 949 950 EXPECT_EQ(vdso_sgx_enter_enclave((unsigned long)&put_addr_op, 0, 0, 951 ERESUME, 0, 0, 952 &self->run), 953 0); 954 955 EXPECT_EEXIT(&self->run); 956 EXPECT_EQ(self->run.exception_vector, 0); 957 EXPECT_EQ(self->run.exception_error_code, 0); 958 EXPECT_EQ(self->run.exception_addr, 0); 959 960 get_addr_op.value = 0; 961 962 EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0); 963 964 EXPECT_EQ(get_addr_op.value, MAGIC2); 965 EXPECT_EEXIT(&self->run); 966 EXPECT_EQ(self->run.user_data, 0); 967 EXPECT_EQ(self->run.exception_vector, 0); 968 EXPECT_EQ(self->run.exception_error_code, 0); 969 EXPECT_EQ(self->run.exception_addr, 0); 970} 971 972/* 973 * Test the addition of pages to an initialized enclave via writing to 974 * a page belonging to the enclave's address space but was not added 975 * during enclave creation. 976 */ 977TEST_F(enclave, augment) 978{ 979 struct encl_op_get_from_addr get_addr_op; 980 struct encl_op_put_to_addr put_addr_op; 981 struct encl_op_eaccept eaccept_op; 982 size_t total_size = 0; 983 void *addr; 984 int i; 985 986 if (!sgx2_supported()) 987 SKIP(return, "SGX2 not supported"); 988 989 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 990 991 memset(&self->run, 0, sizeof(self->run)); 992 self->run.tcs = self->encl.encl_base; 993 994 for (i = 0; i < self->encl.nr_segments; i++) { 995 struct encl_segment *seg = &self->encl.segment_tbl[i]; 996 997 total_size += seg->size; 998 } 999 1000 /* 1001 * Actual enclave size is expected to be larger than the loaded 1002 * test enclave since enclave size must be a power of 2 in bytes 1003 * and test_encl does not consume it all. 1004 */ 1005 EXPECT_LT(total_size + PAGE_SIZE, self->encl.encl_size); 1006 1007 /* 1008 * Create memory mapping for the page that will be added. New 1009 * memory mapping is for one page right after all existing 1010 * mappings. 1011 * Kernel will allow new mapping using any permissions if it 1012 * falls into the enclave's address range but not backed 1013 * by existing enclave pages. 1014 */ 1015 addr = mmap((void *)self->encl.encl_base + total_size, PAGE_SIZE, 1016 PROT_READ | PROT_WRITE | PROT_EXEC, 1017 MAP_SHARED | MAP_FIXED, self->encl.fd, 0); 1018 EXPECT_NE(addr, MAP_FAILED); 1019 1020 self->run.exception_vector = 0; 1021 self->run.exception_error_code = 0; 1022 self->run.exception_addr = 0; 1023 1024 /* 1025 * Attempt to write to the new page from within enclave. 1026 * Expected to fail since page is not (yet) part of the enclave. 1027 * The first #PF will trigger the addition of the page to the 1028 * enclave, but since the new page needs an EACCEPT from within the 1029 * enclave before it can be used it would not be possible 1030 * to successfully return to the failing instruction. This is the 1031 * cause of the second #PF captured here having the SGX bit set, 1032 * it is from hardware preventing the page from being used. 1033 */ 1034 put_addr_op.value = MAGIC; 1035 put_addr_op.addr = (unsigned long)addr; 1036 put_addr_op.header.type = ENCL_OP_PUT_TO_ADDRESS; 1037 1038 EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0); 1039 1040 EXPECT_EQ(self->run.function, ERESUME); 1041 EXPECT_EQ(self->run.exception_vector, 14); 1042 EXPECT_EQ(self->run.exception_addr, (unsigned long)addr); 1043 1044 if (self->run.exception_error_code == 0x6) { 1045 munmap(addr, PAGE_SIZE); 1046 SKIP(return, "Kernel does not support adding pages to initialized enclave"); 1047 } 1048 1049 EXPECT_EQ(self->run.exception_error_code, 0x8007); 1050 1051 self->run.exception_vector = 0; 1052 self->run.exception_error_code = 0; 1053 self->run.exception_addr = 0; 1054 1055 /* Handle AEX by running EACCEPT from new entry point. */ 1056 self->run.tcs = self->encl.encl_base + PAGE_SIZE; 1057 1058 eaccept_op.epc_addr = self->encl.encl_base + total_size; 1059 eaccept_op.flags = SGX_SECINFO_R | SGX_SECINFO_W | SGX_SECINFO_REG | SGX_SECINFO_PENDING; 1060 eaccept_op.ret = 0; 1061 eaccept_op.header.type = ENCL_OP_EACCEPT; 1062 1063 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 1064 1065 EXPECT_EEXIT(&self->run); 1066 EXPECT_EQ(self->run.exception_vector, 0); 1067 EXPECT_EQ(self->run.exception_error_code, 0); 1068 EXPECT_EQ(self->run.exception_addr, 0); 1069 EXPECT_EQ(eaccept_op.ret, 0); 1070 1071 /* Can now return to main TCS to resume execution. */ 1072 self->run.tcs = self->encl.encl_base; 1073 1074 EXPECT_EQ(vdso_sgx_enter_enclave((unsigned long)&put_addr_op, 0, 0, 1075 ERESUME, 0, 0, 1076 &self->run), 1077 0); 1078 1079 EXPECT_EEXIT(&self->run); 1080 EXPECT_EQ(self->run.exception_vector, 0); 1081 EXPECT_EQ(self->run.exception_error_code, 0); 1082 EXPECT_EQ(self->run.exception_addr, 0); 1083 1084 /* 1085 * Read memory from newly added page that was just written to, 1086 * confirming that data previously written (MAGIC) is present. 1087 */ 1088 get_addr_op.value = 0; 1089 get_addr_op.addr = (unsigned long)addr; 1090 get_addr_op.header.type = ENCL_OP_GET_FROM_ADDRESS; 1091 1092 EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0); 1093 1094 EXPECT_EQ(get_addr_op.value, MAGIC); 1095 EXPECT_EEXIT(&self->run); 1096 EXPECT_EQ(self->run.exception_vector, 0); 1097 EXPECT_EQ(self->run.exception_error_code, 0); 1098 EXPECT_EQ(self->run.exception_addr, 0); 1099 1100 munmap(addr, PAGE_SIZE); 1101} 1102 1103/* 1104 * Test for the addition of pages to an initialized enclave via a 1105 * pre-emptive run of EACCEPT on page to be added. 1106 */ 1107TEST_F(enclave, augment_via_eaccept) 1108{ 1109 struct encl_op_get_from_addr get_addr_op; 1110 struct encl_op_put_to_addr put_addr_op; 1111 struct encl_op_eaccept eaccept_op; 1112 size_t total_size = 0; 1113 void *addr; 1114 int i; 1115 1116 if (!sgx2_supported()) 1117 SKIP(return, "SGX2 not supported"); 1118 1119 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 1120 1121 memset(&self->run, 0, sizeof(self->run)); 1122 self->run.tcs = self->encl.encl_base; 1123 1124 for (i = 0; i < self->encl.nr_segments; i++) { 1125 struct encl_segment *seg = &self->encl.segment_tbl[i]; 1126 1127 total_size += seg->size; 1128 } 1129 1130 /* 1131 * Actual enclave size is expected to be larger than the loaded 1132 * test enclave since enclave size must be a power of 2 in bytes while 1133 * test_encl does not consume it all. 1134 */ 1135 EXPECT_LT(total_size + PAGE_SIZE, self->encl.encl_size); 1136 1137 /* 1138 * mmap() a page at end of existing enclave to be used for dynamic 1139 * EPC page. 1140 * 1141 * Kernel will allow new mapping using any permissions if it 1142 * falls into the enclave's address range but not backed 1143 * by existing enclave pages. 1144 */ 1145 1146 addr = mmap((void *)self->encl.encl_base + total_size, PAGE_SIZE, 1147 PROT_READ | PROT_WRITE | PROT_EXEC, MAP_SHARED | MAP_FIXED, 1148 self->encl.fd, 0); 1149 EXPECT_NE(addr, MAP_FAILED); 1150 1151 self->run.exception_vector = 0; 1152 self->run.exception_error_code = 0; 1153 self->run.exception_addr = 0; 1154 1155 /* 1156 * Run EACCEPT on new page to trigger the #PF->EAUG->EACCEPT(again 1157 * without a #PF). All should be transparent to userspace. 1158 */ 1159 eaccept_op.epc_addr = self->encl.encl_base + total_size; 1160 eaccept_op.flags = SGX_SECINFO_R | SGX_SECINFO_W | SGX_SECINFO_REG | SGX_SECINFO_PENDING; 1161 eaccept_op.ret = 0; 1162 eaccept_op.header.type = ENCL_OP_EACCEPT; 1163 1164 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 1165 1166 if (self->run.exception_vector == 14 && 1167 self->run.exception_error_code == 4 && 1168 self->run.exception_addr == self->encl.encl_base + total_size) { 1169 munmap(addr, PAGE_SIZE); 1170 SKIP(return, "Kernel does not support adding pages to initialized enclave"); 1171 } 1172 1173 EXPECT_EEXIT(&self->run); 1174 EXPECT_EQ(self->run.exception_vector, 0); 1175 EXPECT_EQ(self->run.exception_error_code, 0); 1176 EXPECT_EQ(self->run.exception_addr, 0); 1177 EXPECT_EQ(eaccept_op.ret, 0); 1178 1179 /* 1180 * New page should be accessible from within enclave - attempt to 1181 * write to it. 1182 */ 1183 put_addr_op.value = MAGIC; 1184 put_addr_op.addr = (unsigned long)addr; 1185 put_addr_op.header.type = ENCL_OP_PUT_TO_ADDRESS; 1186 1187 EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0); 1188 1189 EXPECT_EEXIT(&self->run); 1190 EXPECT_EQ(self->run.exception_vector, 0); 1191 EXPECT_EQ(self->run.exception_error_code, 0); 1192 EXPECT_EQ(self->run.exception_addr, 0); 1193 1194 /* 1195 * Read memory from newly added page that was just written to, 1196 * confirming that data previously written (MAGIC) is present. 1197 */ 1198 get_addr_op.value = 0; 1199 get_addr_op.addr = (unsigned long)addr; 1200 get_addr_op.header.type = ENCL_OP_GET_FROM_ADDRESS; 1201 1202 EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0); 1203 1204 EXPECT_EQ(get_addr_op.value, MAGIC); 1205 EXPECT_EEXIT(&self->run); 1206 EXPECT_EQ(self->run.exception_vector, 0); 1207 EXPECT_EQ(self->run.exception_error_code, 0); 1208 EXPECT_EQ(self->run.exception_addr, 0); 1209 1210 munmap(addr, PAGE_SIZE); 1211} 1212 1213/* 1214 * SGX2 page type modification test in two phases: 1215 * Phase 1: 1216 * Create a new TCS, consisting out of three new pages (stack page with regular 1217 * page type, SSA page with regular page type, and TCS page with TCS page 1218 * type) in an initialized enclave and run a simple workload within it. 1219 * Phase 2: 1220 * Remove the three pages added in phase 1, add a new regular page at the 1221 * same address that previously hosted the TCS page and verify that it can 1222 * be modified. 1223 */ 1224TEST_F(enclave, tcs_create) 1225{ 1226 struct encl_op_init_tcs_page init_tcs_page_op; 1227 struct sgx_enclave_remove_pages remove_ioc; 1228 struct encl_op_get_from_addr get_addr_op; 1229 struct sgx_enclave_modify_types modt_ioc; 1230 struct encl_op_put_to_addr put_addr_op; 1231 struct encl_op_get_from_buf get_buf_op; 1232 struct encl_op_put_to_buf put_buf_op; 1233 void *addr, *tcs, *stack_end, *ssa; 1234 struct encl_op_eaccept eaccept_op; 1235 size_t total_size = 0; 1236 uint64_t val_64; 1237 int errno_save; 1238 int ret, i; 1239 1240 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, 1241 _metadata)); 1242 1243 memset(&self->run, 0, sizeof(self->run)); 1244 self->run.tcs = self->encl.encl_base; 1245 1246 /* 1247 * Hardware (SGX2) and kernel support is needed for this test. Start 1248 * with check that test has a chance of succeeding. 1249 */ 1250 memset(&modt_ioc, 0, sizeof(modt_ioc)); 1251 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &modt_ioc); 1252 1253 if (ret == -1) { 1254 if (errno == ENOTTY) 1255 SKIP(return, 1256 "Kernel does not support SGX_IOC_ENCLAVE_MODIFY_TYPES ioctl()"); 1257 else if (errno == ENODEV) 1258 SKIP(return, "System does not support SGX2"); 1259 } 1260 1261 /* 1262 * Invalid parameters were provided during sanity check, 1263 * expect command to fail. 1264 */ 1265 EXPECT_EQ(ret, -1); 1266 1267 /* 1268 * Add three regular pages via EAUG: one will be the TCS stack, one 1269 * will be the TCS SSA, and one will be the new TCS. The stack and 1270 * SSA will remain as regular pages, the TCS page will need its 1271 * type changed after populated with needed data. 1272 */ 1273 for (i = 0; i < self->encl.nr_segments; i++) { 1274 struct encl_segment *seg = &self->encl.segment_tbl[i]; 1275 1276 total_size += seg->size; 1277 } 1278 1279 /* 1280 * Actual enclave size is expected to be larger than the loaded 1281 * test enclave since enclave size must be a power of 2 in bytes while 1282 * test_encl does not consume it all. 1283 */ 1284 EXPECT_LT(total_size + 3 * PAGE_SIZE, self->encl.encl_size); 1285 1286 /* 1287 * mmap() three pages at end of existing enclave to be used for the 1288 * three new pages. 1289 */ 1290 addr = mmap((void *)self->encl.encl_base + total_size, 3 * PAGE_SIZE, 1291 PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, 1292 self->encl.fd, 0); 1293 EXPECT_NE(addr, MAP_FAILED); 1294 1295 self->run.exception_vector = 0; 1296 self->run.exception_error_code = 0; 1297 self->run.exception_addr = 0; 1298 1299 stack_end = (void *)self->encl.encl_base + total_size; 1300 tcs = (void *)self->encl.encl_base + total_size + PAGE_SIZE; 1301 ssa = (void *)self->encl.encl_base + total_size + 2 * PAGE_SIZE; 1302 1303 /* 1304 * Run EACCEPT on each new page to trigger the 1305 * EACCEPT->(#PF)->EAUG->EACCEPT(again without a #PF) flow. 1306 */ 1307 1308 eaccept_op.epc_addr = (unsigned long)stack_end; 1309 eaccept_op.flags = SGX_SECINFO_R | SGX_SECINFO_W | SGX_SECINFO_REG | SGX_SECINFO_PENDING; 1310 eaccept_op.ret = 0; 1311 eaccept_op.header.type = ENCL_OP_EACCEPT; 1312 1313 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 1314 1315 if (self->run.exception_vector == 14 && 1316 self->run.exception_error_code == 4 && 1317 self->run.exception_addr == (unsigned long)stack_end) { 1318 munmap(addr, 3 * PAGE_SIZE); 1319 SKIP(return, "Kernel does not support adding pages to initialized enclave"); 1320 } 1321 1322 EXPECT_EEXIT(&self->run); 1323 EXPECT_EQ(self->run.exception_vector, 0); 1324 EXPECT_EQ(self->run.exception_error_code, 0); 1325 EXPECT_EQ(self->run.exception_addr, 0); 1326 EXPECT_EQ(eaccept_op.ret, 0); 1327 1328 eaccept_op.epc_addr = (unsigned long)ssa; 1329 1330 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 1331 1332 EXPECT_EEXIT(&self->run); 1333 EXPECT_EQ(self->run.exception_vector, 0); 1334 EXPECT_EQ(self->run.exception_error_code, 0); 1335 EXPECT_EQ(self->run.exception_addr, 0); 1336 EXPECT_EQ(eaccept_op.ret, 0); 1337 1338 eaccept_op.epc_addr = (unsigned long)tcs; 1339 1340 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 1341 1342 EXPECT_EEXIT(&self->run); 1343 EXPECT_EQ(self->run.exception_vector, 0); 1344 EXPECT_EQ(self->run.exception_error_code, 0); 1345 EXPECT_EQ(self->run.exception_addr, 0); 1346 EXPECT_EQ(eaccept_op.ret, 0); 1347 1348 /* 1349 * Three new pages added to enclave. Now populate the TCS page with 1350 * needed data. This should be done from within enclave. Provide 1351 * the function that will do the actual data population with needed 1352 * data. 1353 */ 1354 1355 /* 1356 * New TCS will use the "encl_dyn_entry" entrypoint that expects 1357 * stack to begin in page before TCS page. 1358 */ 1359 val_64 = encl_get_entry(&self->encl, "encl_dyn_entry"); 1360 EXPECT_NE(val_64, 0); 1361 1362 init_tcs_page_op.tcs_page = (unsigned long)tcs; 1363 init_tcs_page_op.ssa = (unsigned long)total_size + 2 * PAGE_SIZE; 1364 init_tcs_page_op.entry = val_64; 1365 init_tcs_page_op.header.type = ENCL_OP_INIT_TCS_PAGE; 1366 1367 EXPECT_EQ(ENCL_CALL(&init_tcs_page_op, &self->run, true), 0); 1368 1369 EXPECT_EEXIT(&self->run); 1370 EXPECT_EQ(self->run.exception_vector, 0); 1371 EXPECT_EQ(self->run.exception_error_code, 0); 1372 EXPECT_EQ(self->run.exception_addr, 0); 1373 1374 /* Change TCS page type to TCS. */ 1375 memset(&modt_ioc, 0, sizeof(modt_ioc)); 1376 1377 modt_ioc.offset = total_size + PAGE_SIZE; 1378 modt_ioc.length = PAGE_SIZE; 1379 modt_ioc.page_type = SGX_PAGE_TYPE_TCS; 1380 1381 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &modt_ioc); 1382 errno_save = ret == -1 ? errno : 0; 1383 1384 EXPECT_EQ(ret, 0); 1385 EXPECT_EQ(errno_save, 0); 1386 EXPECT_EQ(modt_ioc.result, 0); 1387 EXPECT_EQ(modt_ioc.count, 4096); 1388 1389 /* EACCEPT new TCS page from enclave. */ 1390 eaccept_op.epc_addr = (unsigned long)tcs; 1391 eaccept_op.flags = SGX_SECINFO_TCS | SGX_SECINFO_MODIFIED; 1392 eaccept_op.ret = 0; 1393 eaccept_op.header.type = ENCL_OP_EACCEPT; 1394 1395 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 1396 1397 EXPECT_EEXIT(&self->run); 1398 EXPECT_EQ(self->run.exception_vector, 0); 1399 EXPECT_EQ(self->run.exception_error_code, 0); 1400 EXPECT_EQ(self->run.exception_addr, 0); 1401 EXPECT_EQ(eaccept_op.ret, 0); 1402 1403 /* Run workload from new TCS. */ 1404 self->run.tcs = (unsigned long)tcs; 1405 1406 /* 1407 * Simple workload to write to data buffer and read value back. 1408 */ 1409 put_buf_op.header.type = ENCL_OP_PUT_TO_BUFFER; 1410 put_buf_op.value = MAGIC; 1411 1412 EXPECT_EQ(ENCL_CALL(&put_buf_op, &self->run, true), 0); 1413 1414 EXPECT_EEXIT(&self->run); 1415 EXPECT_EQ(self->run.exception_vector, 0); 1416 EXPECT_EQ(self->run.exception_error_code, 0); 1417 EXPECT_EQ(self->run.exception_addr, 0); 1418 1419 get_buf_op.header.type = ENCL_OP_GET_FROM_BUFFER; 1420 get_buf_op.value = 0; 1421 1422 EXPECT_EQ(ENCL_CALL(&get_buf_op, &self->run, true), 0); 1423 1424 EXPECT_EQ(get_buf_op.value, MAGIC); 1425 EXPECT_EEXIT(&self->run); 1426 EXPECT_EQ(self->run.exception_vector, 0); 1427 EXPECT_EQ(self->run.exception_error_code, 0); 1428 EXPECT_EQ(self->run.exception_addr, 0); 1429 1430 /* 1431 * Phase 2 of test: 1432 * Remove pages associated with new TCS, create a regular page 1433 * where TCS page used to be and verify it can be used as a regular 1434 * page. 1435 */ 1436 1437 /* Start page removal by requesting change of page type to PT_TRIM. */ 1438 memset(&modt_ioc, 0, sizeof(modt_ioc)); 1439 1440 modt_ioc.offset = total_size; 1441 modt_ioc.length = 3 * PAGE_SIZE; 1442 modt_ioc.page_type = SGX_PAGE_TYPE_TRIM; 1443 1444 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &modt_ioc); 1445 errno_save = ret == -1 ? errno : 0; 1446 1447 EXPECT_EQ(ret, 0); 1448 EXPECT_EQ(errno_save, 0); 1449 EXPECT_EQ(modt_ioc.result, 0); 1450 EXPECT_EQ(modt_ioc.count, 3 * PAGE_SIZE); 1451 1452 /* 1453 * Enter enclave via TCS #1 and approve page removal by sending 1454 * EACCEPT for each of three removed pages. 1455 */ 1456 self->run.tcs = self->encl.encl_base; 1457 1458 eaccept_op.epc_addr = (unsigned long)stack_end; 1459 eaccept_op.flags = SGX_SECINFO_TRIM | SGX_SECINFO_MODIFIED; 1460 eaccept_op.ret = 0; 1461 eaccept_op.header.type = ENCL_OP_EACCEPT; 1462 1463 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 1464 1465 EXPECT_EEXIT(&self->run); 1466 EXPECT_EQ(self->run.exception_vector, 0); 1467 EXPECT_EQ(self->run.exception_error_code, 0); 1468 EXPECT_EQ(self->run.exception_addr, 0); 1469 EXPECT_EQ(eaccept_op.ret, 0); 1470 1471 eaccept_op.epc_addr = (unsigned long)tcs; 1472 eaccept_op.ret = 0; 1473 1474 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 1475 1476 EXPECT_EEXIT(&self->run); 1477 EXPECT_EQ(self->run.exception_vector, 0); 1478 EXPECT_EQ(self->run.exception_error_code, 0); 1479 EXPECT_EQ(self->run.exception_addr, 0); 1480 EXPECT_EQ(eaccept_op.ret, 0); 1481 1482 eaccept_op.epc_addr = (unsigned long)ssa; 1483 eaccept_op.ret = 0; 1484 1485 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 1486 1487 EXPECT_EEXIT(&self->run); 1488 EXPECT_EQ(self->run.exception_vector, 0); 1489 EXPECT_EQ(self->run.exception_error_code, 0); 1490 EXPECT_EQ(self->run.exception_addr, 0); 1491 EXPECT_EQ(eaccept_op.ret, 0); 1492 1493 /* Send final ioctl() to complete page removal. */ 1494 memset(&remove_ioc, 0, sizeof(remove_ioc)); 1495 1496 remove_ioc.offset = total_size; 1497 remove_ioc.length = 3 * PAGE_SIZE; 1498 1499 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_REMOVE_PAGES, &remove_ioc); 1500 errno_save = ret == -1 ? errno : 0; 1501 1502 EXPECT_EQ(ret, 0); 1503 EXPECT_EQ(errno_save, 0); 1504 EXPECT_EQ(remove_ioc.count, 3 * PAGE_SIZE); 1505 1506 /* 1507 * Enter enclave via TCS #1 and access location where TCS #3 was to 1508 * trigger dynamic add of regular page at that location. 1509 */ 1510 eaccept_op.epc_addr = (unsigned long)tcs; 1511 eaccept_op.flags = SGX_SECINFO_R | SGX_SECINFO_W | SGX_SECINFO_REG | SGX_SECINFO_PENDING; 1512 eaccept_op.ret = 0; 1513 eaccept_op.header.type = ENCL_OP_EACCEPT; 1514 1515 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 1516 1517 EXPECT_EEXIT(&self->run); 1518 EXPECT_EQ(self->run.exception_vector, 0); 1519 EXPECT_EQ(self->run.exception_error_code, 0); 1520 EXPECT_EQ(self->run.exception_addr, 0); 1521 EXPECT_EQ(eaccept_op.ret, 0); 1522 1523 /* 1524 * New page should be accessible from within enclave - write to it. 1525 */ 1526 put_addr_op.value = MAGIC; 1527 put_addr_op.addr = (unsigned long)tcs; 1528 put_addr_op.header.type = ENCL_OP_PUT_TO_ADDRESS; 1529 1530 EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0); 1531 1532 EXPECT_EEXIT(&self->run); 1533 EXPECT_EQ(self->run.exception_vector, 0); 1534 EXPECT_EQ(self->run.exception_error_code, 0); 1535 EXPECT_EQ(self->run.exception_addr, 0); 1536 1537 /* 1538 * Read memory from newly added page that was just written to, 1539 * confirming that data previously written (MAGIC) is present. 1540 */ 1541 get_addr_op.value = 0; 1542 get_addr_op.addr = (unsigned long)tcs; 1543 get_addr_op.header.type = ENCL_OP_GET_FROM_ADDRESS; 1544 1545 EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0); 1546 1547 EXPECT_EQ(get_addr_op.value, MAGIC); 1548 EXPECT_EEXIT(&self->run); 1549 EXPECT_EQ(self->run.exception_vector, 0); 1550 EXPECT_EQ(self->run.exception_error_code, 0); 1551 EXPECT_EQ(self->run.exception_addr, 0); 1552 1553 munmap(addr, 3 * PAGE_SIZE); 1554} 1555 1556/* 1557 * Ensure sane behavior if user requests page removal, does not run 1558 * EACCEPT from within enclave but still attempts to finalize page removal 1559 * with the SGX_IOC_ENCLAVE_REMOVE_PAGES ioctl(). The latter should fail 1560 * because the removal was not EACCEPTed from within the enclave. 1561 */ 1562TEST_F(enclave, remove_added_page_no_eaccept) 1563{ 1564 struct sgx_enclave_remove_pages remove_ioc; 1565 struct encl_op_get_from_addr get_addr_op; 1566 struct sgx_enclave_modify_types modt_ioc; 1567 struct encl_op_put_to_addr put_addr_op; 1568 unsigned long data_start; 1569 int ret, errno_save; 1570 1571 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 1572 1573 memset(&self->run, 0, sizeof(self->run)); 1574 self->run.tcs = self->encl.encl_base; 1575 1576 /* 1577 * Hardware (SGX2) and kernel support is needed for this test. Start 1578 * with check that test has a chance of succeeding. 1579 */ 1580 memset(&modt_ioc, 0, sizeof(modt_ioc)); 1581 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &modt_ioc); 1582 1583 if (ret == -1) { 1584 if (errno == ENOTTY) 1585 SKIP(return, 1586 "Kernel does not support SGX_IOC_ENCLAVE_MODIFY_TYPES ioctl()"); 1587 else if (errno == ENODEV) 1588 SKIP(return, "System does not support SGX2"); 1589 } 1590 1591 /* 1592 * Invalid parameters were provided during sanity check, 1593 * expect command to fail. 1594 */ 1595 EXPECT_EQ(ret, -1); 1596 1597 /* 1598 * Page that will be removed is the second data page in the .data 1599 * segment. This forms part of the local encl_buffer within the 1600 * enclave. 1601 */ 1602 data_start = self->encl.encl_base + 1603 encl_get_data_offset(&self->encl) + PAGE_SIZE; 1604 1605 /* 1606 * Sanity check that page at @data_start is writable before 1607 * removing it. 1608 * 1609 * Start by writing MAGIC to test page. 1610 */ 1611 put_addr_op.value = MAGIC; 1612 put_addr_op.addr = data_start; 1613 put_addr_op.header.type = ENCL_OP_PUT_TO_ADDRESS; 1614 1615 EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0); 1616 1617 EXPECT_EEXIT(&self->run); 1618 EXPECT_EQ(self->run.exception_vector, 0); 1619 EXPECT_EQ(self->run.exception_error_code, 0); 1620 EXPECT_EQ(self->run.exception_addr, 0); 1621 1622 /* 1623 * Read memory that was just written to, confirming that data 1624 * previously written (MAGIC) is present. 1625 */ 1626 get_addr_op.value = 0; 1627 get_addr_op.addr = data_start; 1628 get_addr_op.header.type = ENCL_OP_GET_FROM_ADDRESS; 1629 1630 EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0); 1631 1632 EXPECT_EQ(get_addr_op.value, MAGIC); 1633 EXPECT_EEXIT(&self->run); 1634 EXPECT_EQ(self->run.exception_vector, 0); 1635 EXPECT_EQ(self->run.exception_error_code, 0); 1636 EXPECT_EQ(self->run.exception_addr, 0); 1637 1638 /* Start page removal by requesting change of page type to PT_TRIM */ 1639 memset(&modt_ioc, 0, sizeof(modt_ioc)); 1640 1641 modt_ioc.offset = encl_get_data_offset(&self->encl) + PAGE_SIZE; 1642 modt_ioc.length = PAGE_SIZE; 1643 modt_ioc.page_type = SGX_PAGE_TYPE_TRIM; 1644 1645 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &modt_ioc); 1646 errno_save = ret == -1 ? errno : 0; 1647 1648 EXPECT_EQ(ret, 0); 1649 EXPECT_EQ(errno_save, 0); 1650 EXPECT_EQ(modt_ioc.result, 0); 1651 EXPECT_EQ(modt_ioc.count, 4096); 1652 1653 /* Skip EACCEPT */ 1654 1655 /* Send final ioctl() to complete page removal */ 1656 memset(&remove_ioc, 0, sizeof(remove_ioc)); 1657 1658 remove_ioc.offset = encl_get_data_offset(&self->encl) + PAGE_SIZE; 1659 remove_ioc.length = PAGE_SIZE; 1660 1661 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_REMOVE_PAGES, &remove_ioc); 1662 errno_save = ret == -1 ? errno : 0; 1663 1664 /* Operation not permitted since EACCEPT was omitted. */ 1665 EXPECT_EQ(ret, -1); 1666 EXPECT_EQ(errno_save, EPERM); 1667 EXPECT_EQ(remove_ioc.count, 0); 1668} 1669 1670/* 1671 * Request enclave page removal but instead of correctly following with 1672 * EACCEPT a read attempt to page is made from within the enclave. 1673 */ 1674TEST_F(enclave, remove_added_page_invalid_access) 1675{ 1676 struct encl_op_get_from_addr get_addr_op; 1677 struct encl_op_put_to_addr put_addr_op; 1678 struct sgx_enclave_modify_types ioc; 1679 unsigned long data_start; 1680 int ret, errno_save; 1681 1682 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 1683 1684 memset(&self->run, 0, sizeof(self->run)); 1685 self->run.tcs = self->encl.encl_base; 1686 1687 /* 1688 * Hardware (SGX2) and kernel support is needed for this test. Start 1689 * with check that test has a chance of succeeding. 1690 */ 1691 memset(&ioc, 0, sizeof(ioc)); 1692 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &ioc); 1693 1694 if (ret == -1) { 1695 if (errno == ENOTTY) 1696 SKIP(return, 1697 "Kernel does not support SGX_IOC_ENCLAVE_MODIFY_TYPES ioctl()"); 1698 else if (errno == ENODEV) 1699 SKIP(return, "System does not support SGX2"); 1700 } 1701 1702 /* 1703 * Invalid parameters were provided during sanity check, 1704 * expect command to fail. 1705 */ 1706 EXPECT_EQ(ret, -1); 1707 1708 /* 1709 * Page that will be removed is the second data page in the .data 1710 * segment. This forms part of the local encl_buffer within the 1711 * enclave. 1712 */ 1713 data_start = self->encl.encl_base + 1714 encl_get_data_offset(&self->encl) + PAGE_SIZE; 1715 1716 /* 1717 * Sanity check that page at @data_start is writable before 1718 * removing it. 1719 * 1720 * Start by writing MAGIC to test page. 1721 */ 1722 put_addr_op.value = MAGIC; 1723 put_addr_op.addr = data_start; 1724 put_addr_op.header.type = ENCL_OP_PUT_TO_ADDRESS; 1725 1726 EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0); 1727 1728 EXPECT_EEXIT(&self->run); 1729 EXPECT_EQ(self->run.exception_vector, 0); 1730 EXPECT_EQ(self->run.exception_error_code, 0); 1731 EXPECT_EQ(self->run.exception_addr, 0); 1732 1733 /* 1734 * Read memory that was just written to, confirming that data 1735 * previously written (MAGIC) is present. 1736 */ 1737 get_addr_op.value = 0; 1738 get_addr_op.addr = data_start; 1739 get_addr_op.header.type = ENCL_OP_GET_FROM_ADDRESS; 1740 1741 EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0); 1742 1743 EXPECT_EQ(get_addr_op.value, MAGIC); 1744 EXPECT_EEXIT(&self->run); 1745 EXPECT_EQ(self->run.exception_vector, 0); 1746 EXPECT_EQ(self->run.exception_error_code, 0); 1747 EXPECT_EQ(self->run.exception_addr, 0); 1748 1749 /* Start page removal by requesting change of page type to PT_TRIM. */ 1750 memset(&ioc, 0, sizeof(ioc)); 1751 1752 ioc.offset = encl_get_data_offset(&self->encl) + PAGE_SIZE; 1753 ioc.length = PAGE_SIZE; 1754 ioc.page_type = SGX_PAGE_TYPE_TRIM; 1755 1756 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &ioc); 1757 errno_save = ret == -1 ? errno : 0; 1758 1759 EXPECT_EQ(ret, 0); 1760 EXPECT_EQ(errno_save, 0); 1761 EXPECT_EQ(ioc.result, 0); 1762 EXPECT_EQ(ioc.count, 4096); 1763 1764 /* 1765 * Read from page that was just removed. 1766 */ 1767 get_addr_op.value = 0; 1768 1769 EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0); 1770 1771 /* 1772 * From kernel perspective the page is present but according to SGX the 1773 * page should not be accessible so a #PF with SGX bit set is 1774 * expected. 1775 */ 1776 1777 EXPECT_EQ(self->run.function, ERESUME); 1778 EXPECT_EQ(self->run.exception_vector, 14); 1779 EXPECT_EQ(self->run.exception_error_code, 0x8005); 1780 EXPECT_EQ(self->run.exception_addr, data_start); 1781} 1782 1783/* 1784 * Request enclave page removal and correctly follow with 1785 * EACCEPT but do not follow with removal ioctl() but instead a read attempt 1786 * to removed page is made from within the enclave. 1787 */ 1788TEST_F(enclave, remove_added_page_invalid_access_after_eaccept) 1789{ 1790 struct encl_op_get_from_addr get_addr_op; 1791 struct encl_op_put_to_addr put_addr_op; 1792 struct sgx_enclave_modify_types ioc; 1793 struct encl_op_eaccept eaccept_op; 1794 unsigned long data_start; 1795 int ret, errno_save; 1796 1797 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 1798 1799 memset(&self->run, 0, sizeof(self->run)); 1800 self->run.tcs = self->encl.encl_base; 1801 1802 /* 1803 * Hardware (SGX2) and kernel support is needed for this test. Start 1804 * with check that test has a chance of succeeding. 1805 */ 1806 memset(&ioc, 0, sizeof(ioc)); 1807 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &ioc); 1808 1809 if (ret == -1) { 1810 if (errno == ENOTTY) 1811 SKIP(return, 1812 "Kernel does not support SGX_IOC_ENCLAVE_MODIFY_TYPES ioctl()"); 1813 else if (errno == ENODEV) 1814 SKIP(return, "System does not support SGX2"); 1815 } 1816 1817 /* 1818 * Invalid parameters were provided during sanity check, 1819 * expect command to fail. 1820 */ 1821 EXPECT_EQ(ret, -1); 1822 1823 /* 1824 * Page that will be removed is the second data page in the .data 1825 * segment. This forms part of the local encl_buffer within the 1826 * enclave. 1827 */ 1828 data_start = self->encl.encl_base + 1829 encl_get_data_offset(&self->encl) + PAGE_SIZE; 1830 1831 /* 1832 * Sanity check that page at @data_start is writable before 1833 * removing it. 1834 * 1835 * Start by writing MAGIC to test page. 1836 */ 1837 put_addr_op.value = MAGIC; 1838 put_addr_op.addr = data_start; 1839 put_addr_op.header.type = ENCL_OP_PUT_TO_ADDRESS; 1840 1841 EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0); 1842 1843 EXPECT_EEXIT(&self->run); 1844 EXPECT_EQ(self->run.exception_vector, 0); 1845 EXPECT_EQ(self->run.exception_error_code, 0); 1846 EXPECT_EQ(self->run.exception_addr, 0); 1847 1848 /* 1849 * Read memory that was just written to, confirming that data 1850 * previously written (MAGIC) is present. 1851 */ 1852 get_addr_op.value = 0; 1853 get_addr_op.addr = data_start; 1854 get_addr_op.header.type = ENCL_OP_GET_FROM_ADDRESS; 1855 1856 EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0); 1857 1858 EXPECT_EQ(get_addr_op.value, MAGIC); 1859 EXPECT_EEXIT(&self->run); 1860 EXPECT_EQ(self->run.exception_vector, 0); 1861 EXPECT_EQ(self->run.exception_error_code, 0); 1862 EXPECT_EQ(self->run.exception_addr, 0); 1863 1864 /* Start page removal by requesting change of page type to PT_TRIM. */ 1865 memset(&ioc, 0, sizeof(ioc)); 1866 1867 ioc.offset = encl_get_data_offset(&self->encl) + PAGE_SIZE; 1868 ioc.length = PAGE_SIZE; 1869 ioc.page_type = SGX_PAGE_TYPE_TRIM; 1870 1871 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &ioc); 1872 errno_save = ret == -1 ? errno : 0; 1873 1874 EXPECT_EQ(ret, 0); 1875 EXPECT_EQ(errno_save, 0); 1876 EXPECT_EQ(ioc.result, 0); 1877 EXPECT_EQ(ioc.count, 4096); 1878 1879 eaccept_op.epc_addr = (unsigned long)data_start; 1880 eaccept_op.ret = 0; 1881 eaccept_op.flags = SGX_SECINFO_TRIM | SGX_SECINFO_MODIFIED; 1882 eaccept_op.header.type = ENCL_OP_EACCEPT; 1883 1884 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 1885 1886 EXPECT_EEXIT(&self->run); 1887 EXPECT_EQ(self->run.exception_vector, 0); 1888 EXPECT_EQ(self->run.exception_error_code, 0); 1889 EXPECT_EQ(self->run.exception_addr, 0); 1890 EXPECT_EQ(eaccept_op.ret, 0); 1891 1892 /* Skip ioctl() to remove page. */ 1893 1894 /* 1895 * Read from page that was just removed. 1896 */ 1897 get_addr_op.value = 0; 1898 1899 EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0); 1900 1901 /* 1902 * From kernel perspective the page is present but according to SGX the 1903 * page should not be accessible so a #PF with SGX bit set is 1904 * expected. 1905 */ 1906 1907 EXPECT_EQ(self->run.function, ERESUME); 1908 EXPECT_EQ(self->run.exception_vector, 14); 1909 EXPECT_EQ(self->run.exception_error_code, 0x8005); 1910 EXPECT_EQ(self->run.exception_addr, data_start); 1911} 1912 1913TEST_F(enclave, remove_untouched_page) 1914{ 1915 struct sgx_enclave_remove_pages remove_ioc; 1916 struct sgx_enclave_modify_types modt_ioc; 1917 struct encl_op_eaccept eaccept_op; 1918 unsigned long data_start; 1919 int ret, errno_save; 1920 1921 ASSERT_TRUE(setup_test_encl(ENCL_HEAP_SIZE_DEFAULT, &self->encl, _metadata)); 1922 1923 /* 1924 * Hardware (SGX2) and kernel support is needed for this test. Start 1925 * with check that test has a chance of succeeding. 1926 */ 1927 memset(&modt_ioc, 0, sizeof(modt_ioc)); 1928 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &modt_ioc); 1929 1930 if (ret == -1) { 1931 if (errno == ENOTTY) 1932 SKIP(return, 1933 "Kernel does not support SGX_IOC_ENCLAVE_MODIFY_TYPES ioctl()"); 1934 else if (errno == ENODEV) 1935 SKIP(return, "System does not support SGX2"); 1936 } 1937 1938 /* 1939 * Invalid parameters were provided during sanity check, 1940 * expect command to fail. 1941 */ 1942 EXPECT_EQ(ret, -1); 1943 1944 /* SGX2 is supported by kernel and hardware, test can proceed. */ 1945 memset(&self->run, 0, sizeof(self->run)); 1946 self->run.tcs = self->encl.encl_base; 1947 1948 data_start = self->encl.encl_base + 1949 encl_get_data_offset(&self->encl) + PAGE_SIZE; 1950 1951 memset(&modt_ioc, 0, sizeof(modt_ioc)); 1952 1953 modt_ioc.offset = encl_get_data_offset(&self->encl) + PAGE_SIZE; 1954 modt_ioc.length = PAGE_SIZE; 1955 modt_ioc.page_type = SGX_PAGE_TYPE_TRIM; 1956 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_MODIFY_TYPES, &modt_ioc); 1957 errno_save = ret == -1 ? errno : 0; 1958 1959 EXPECT_EQ(ret, 0); 1960 EXPECT_EQ(errno_save, 0); 1961 EXPECT_EQ(modt_ioc.result, 0); 1962 EXPECT_EQ(modt_ioc.count, 4096); 1963 1964 /* 1965 * Enter enclave via TCS #1 and approve page removal by sending 1966 * EACCEPT for removed page. 1967 */ 1968 1969 eaccept_op.epc_addr = data_start; 1970 eaccept_op.flags = SGX_SECINFO_TRIM | SGX_SECINFO_MODIFIED; 1971 eaccept_op.ret = 0; 1972 eaccept_op.header.type = ENCL_OP_EACCEPT; 1973 1974 EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0); 1975 EXPECT_EEXIT(&self->run); 1976 EXPECT_EQ(self->run.exception_vector, 0); 1977 EXPECT_EQ(self->run.exception_error_code, 0); 1978 EXPECT_EQ(self->run.exception_addr, 0); 1979 EXPECT_EQ(eaccept_op.ret, 0); 1980 1981 memset(&remove_ioc, 0, sizeof(remove_ioc)); 1982 1983 remove_ioc.offset = encl_get_data_offset(&self->encl) + PAGE_SIZE; 1984 remove_ioc.length = PAGE_SIZE; 1985 ret = ioctl(self->encl.fd, SGX_IOC_ENCLAVE_REMOVE_PAGES, &remove_ioc); 1986 errno_save = ret == -1 ? errno : 0; 1987 1988 EXPECT_EQ(ret, 0); 1989 EXPECT_EQ(errno_save, 0); 1990 EXPECT_EQ(remove_ioc.count, 4096); 1991} 1992 1993TEST_HARNESS_MAIN 1994