tools/testing/selftests/sgx/test_encl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*  Copyright(c) 2016-20 Intel Corporation. */
   3
   4 #include <stddef.h>
   5 #include "defines.h"
   6
   7 /*
   8  * Data buffer spanning two pages that will be placed first in the .data
   9  * segment via the linker script. Even if not used internally the second page
  10  * is needed by external test manipulating page permissions, so mark
  11  * encl_buffer as "used" to make sure it is entirely preserved by the compiler.
  12  */
  13 static uint8_t __used __section(".data.encl_buffer") encl_buffer[8192] = { 1 };
  14
  15 enum sgx_enclu_function {
  16         EACCEPT = 0x5,
  17         EMODPE = 0x6,
  18 };
  19
  20 static void do_encl_emodpe(void *_op)
  21 {
  22         struct sgx_secinfo secinfo __aligned(sizeof(struct sgx_secinfo)) = {0};
  23         struct encl_op_emodpe *op = _op;
  24
  25         secinfo.flags = op->flags;
  26
  27         asm volatile(".byte 0x0f, 0x01, 0xd7"
  28                                 : /* no outputs */
  29                                 : "a" (EMODPE),
  30                                   "b" (&secinfo),
  31                                   "c" (op->epc_addr)
  32                                 : "memory" /* read from secinfo pointer */);
  33 }
  34
  35 static void do_encl_eaccept(void *_op)
  36 {
  37         struct sgx_secinfo secinfo __aligned(sizeof(struct sgx_secinfo)) = {0};
  38         struct encl_op_eaccept *op = _op;
  39         int rax;
  40
  41         secinfo.flags = op->flags;
  42
  43         asm volatile(".byte 0x0f, 0x01, 0xd7"
  44                                 : "=a" (rax)
  45                                 : "a" (EACCEPT),
  46                                   "b" (&secinfo),
  47                                   "c" (op->epc_addr)
  48                                 : "memory" /* read from secinfo pointer */);
  49
  50         op->ret = rax;
  51 }
  52
  53 static void *memcpy(void *dest, const void *src, size_t n)
  54 {
  55         size_t i;
  56
  57         for (i = 0; i < n; i++)
  58                 ((char *)dest)[i] = ((char *)src)[i];
  59
  60         return dest;
  61 }
  62
  63 static void *memset(void *dest, int c, size_t n)
  64 {
  65         size_t i;
  66
  67         for (i = 0; i < n; i++)
  68                 ((char *)dest)[i] = c;
  69
  70         return dest;
  71 }
  72
  73 static void do_encl_init_tcs_page(void *_op)
  74 {
  75         struct encl_op_init_tcs_page *op = _op;
  76         void *tcs = (void *)op->tcs_page;
  77         uint32_t val_32;
  78
  79         memset(tcs, 0, 16);                     /* STATE and FLAGS */
  80         memcpy(tcs + 16, &op->ssa, 8);          /* OSSA */
  81         memset(tcs + 24, 0, 4);                 /* CSSA */
  82         val_32 = 1;
  83         memcpy(tcs + 28, &val_32, 4);           /* NSSA */
  84         memcpy(tcs + 32, &op->entry, 8);        /* OENTRY */
  85         memset(tcs + 40, 0, 24);                /* AEP, OFSBASE, OGSBASE */
  86         val_32 = 0xFFFFFFFF;
  87         memcpy(tcs + 64, &val_32, 4);           /* FSLIMIT */
  88         memcpy(tcs + 68, &val_32, 4);           /* GSLIMIT */
  89         memset(tcs + 72, 0, 4024);              /* Reserved */
  90 }
  91
  92 static void do_encl_op_put_to_buf(void *op)
  93 {
  94         struct encl_op_put_to_buf *op2 = op;
  95
  96         memcpy(&encl_buffer[0], &op2->value, 8);
  97 }
  98
  99 static void do_encl_op_get_from_buf(void *op)
 100 {
 101         struct encl_op_get_from_buf *op2 = op;
 102
 103         memcpy(&op2->value, &encl_buffer[0], 8);
 104 }
 105
 106 static void do_encl_op_put_to_addr(void *_op)
 107 {
 108         struct encl_op_put_to_addr *op = _op;
 109
 110         memcpy((void *)op->addr, &op->value, 8);
 111 }
 112
 113 static void do_encl_op_get_from_addr(void *_op)
 114 {
 115         struct encl_op_get_from_addr *op = _op;
 116
 117         memcpy(&op->value, (void *)op->addr, 8);
 118 }
 119
 120 static void do_encl_op_nop(void *_op)
 121 {
 122
 123 }
 124
 125 /*
 126  * Symbol placed at the start of the enclave image by the linker script.
 127  * Declare this extern symbol with visibility "hidden" to ensure the compiler
 128  * does not access it through the GOT and generates position-independent
 129  * addressing as __encl_base(%rip), so we can get the actual enclave base
 130  * during runtime.
 131  */
 132 extern const uint8_t __attribute__((visibility("hidden"))) __encl_base;
 133
 134 typedef void (*encl_op_t)(void *);
 135 static const encl_op_t encl_op_array[ENCL_OP_MAX] = {
 136         do_encl_op_put_to_buf,
 137         do_encl_op_get_from_buf,
 138         do_encl_op_put_to_addr,
 139         do_encl_op_get_from_addr,
 140         do_encl_op_nop,
 141         do_encl_eaccept,
 142         do_encl_emodpe,
 143         do_encl_init_tcs_page,
 144 };
 145
 146 void encl_body(void *rdi,  void *rsi)
 147 {
 148         struct encl_op_header *header = (struct encl_op_header *)rdi;
 149         encl_op_t op;
 150
 151         if (header->type >= ENCL_OP_MAX)
 152                 return;
 153
 154         /*
 155          * The enclave base address needs to be added, as this call site
 156          * *cannot be* made rip-relative by the compiler, or fixed up by
 157          * any other possible means.
 158          */
 159         op = ((uint64_t)&__encl_base) + encl_op_array[header->type];
 160
 161         (*op)(header);
 162 }