tools/testing/selftests/sgx/sigstruct.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*  Copyright(c) 2016-20 Intel Corporation. */
   3
   4 #define _GNU_SOURCE
   5 #include <assert.h>
   6 #include <getopt.h>
   7 #include <stdbool.h>
   8 #include <stdint.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <sys/stat.h>
  13 #include <sys/types.h>
  14 #include <unistd.h>
  15 #include <openssl/err.h>
  16 #include <openssl/pem.h>
  17 #include "defines.h"
  18 #include "main.h"
  19
  20 struct q1q2_ctx {
  21         BN_CTX *bn_ctx;
  22         BIGNUM *m;
  23         BIGNUM *s;
  24         BIGNUM *q1;
  25         BIGNUM *qr;
  26         BIGNUM *q2;
  27 };
  28
  29 static void free_q1q2_ctx(struct q1q2_ctx *ctx)
  30 {
  31         BN_CTX_free(ctx->bn_ctx);
  32         BN_free(ctx->m);
  33         BN_free(ctx->s);
  34         BN_free(ctx->q1);
  35         BN_free(ctx->qr);
  36         BN_free(ctx->q2);
  37 }
  38
  39 static bool alloc_q1q2_ctx(const uint8_t *s, const uint8_t *m,
  40                            struct q1q2_ctx *ctx)
  41 {
  42         ctx->bn_ctx = BN_CTX_new();
  43         ctx->s = BN_bin2bn(s, SGX_MODULUS_SIZE, NULL);
  44         ctx->m = BN_bin2bn(m, SGX_MODULUS_SIZE, NULL);
  45         ctx->q1 = BN_new();
  46         ctx->qr = BN_new();
  47         ctx->q2 = BN_new();
  48
  49         if (!ctx->bn_ctx || !ctx->s || !ctx->m || !ctx->q1 || !ctx->qr ||
  50             !ctx->q2) {
  51                 free_q1q2_ctx(ctx);
  52                 return false;
  53         }
  54
  55         return true;
  56 }
  57
  58 static bool calc_q1q2(const uint8_t *s, const uint8_t *m, uint8_t *q1,
  59                       uint8_t *q2)
  60 {
  61         struct q1q2_ctx ctx;
  62
  63         if (!alloc_q1q2_ctx(s, m, &ctx)) {
  64                 fprintf(stderr, "Not enough memory for Q1Q2 calculation\n");
  65                 return false;
  66         }
  67
  68         if (!BN_mul(ctx.q1, ctx.s, ctx.s, ctx.bn_ctx))
  69                 goto out;
  70
  71         if (!BN_div(ctx.q1, ctx.qr, ctx.q1, ctx.m, ctx.bn_ctx))
  72                 goto out;
  73
  74         if (BN_num_bytes(ctx.q1) > SGX_MODULUS_SIZE) {
  75                 fprintf(stderr, "Too large Q1 %d bytes\n",
  76                         BN_num_bytes(ctx.q1));
  77                 goto out;
  78         }
  79
  80         if (!BN_mul(ctx.q2, ctx.s, ctx.qr, ctx.bn_ctx))
  81                 goto out;
  82
  83         if (!BN_div(ctx.q2, NULL, ctx.q2, ctx.m, ctx.bn_ctx))
  84                 goto out;
  85
  86         if (BN_num_bytes(ctx.q2) > SGX_MODULUS_SIZE) {
  87                 fprintf(stderr, "Too large Q2 %d bytes\n",
  88                         BN_num_bytes(ctx.q2));
  89                 goto out;
  90         }
  91
  92         BN_bn2bin(ctx.q1, q1);
  93         BN_bn2bin(ctx.q2, q2);
  94
  95         free_q1q2_ctx(&ctx);
  96         return true;
  97 out:
  98         free_q1q2_ctx(&ctx);
  99         return false;
 100 }
 101
 102 struct sgx_sigstruct_payload {
 103         struct sgx_sigstruct_header header;
 104         struct sgx_sigstruct_body body;
 105 };
 106
 107 static bool check_crypto_errors(void)
 108 {
 109         int err;
 110         bool had_errors = false;
 111         const char *filename;
 112         int line;
 113         char str[256];
 114
 115         for ( ; ; ) {
 116                 if (ERR_peek_error() == 0)
 117                         break;
 118
 119                 had_errors = true;
 120                 err = ERR_get_error_line(&filename, &line);
 121                 ERR_error_string_n(err, str, sizeof(str));
 122                 fprintf(stderr, "crypto: %s: %s:%d\n", str, filename, line);
 123         }
 124
 125         return had_errors;
 126 }
 127
 128 static inline const BIGNUM *get_modulus(RSA *key)
 129 {
 130         const BIGNUM *n;
 131
 132         RSA_get0_key(key, &n, NULL, NULL);
 133         return n;
 134 }
 135
 136 static RSA *gen_sign_key(void)
 137 {
 138         unsigned long sign_key_length;
 139         BIO *bio;
 140         RSA *key;
 141
 142         sign_key_length = (unsigned long)&sign_key_end -
 143                           (unsigned long)&sign_key;
 144
 145         bio = BIO_new_mem_buf(&sign_key, sign_key_length);
 146         if (!bio)
 147                 return NULL;
 148
 149         key = PEM_read_bio_RSAPrivateKey(bio, NULL, NULL, NULL);
 150         BIO_free(bio);
 151
 152         return key;
 153 }
 154
 155 static void reverse_bytes(void *data, int length)
 156 {
 157         int i = 0;
 158         int j = length - 1;
 159         uint8_t temp;
 160         uint8_t *ptr = data;
 161
 162         while (i < j) {
 163                 temp = ptr[i];
 164                 ptr[i] = ptr[j];
 165                 ptr[j] = temp;
 166                 i++;
 167                 j--;
 168         }
 169 }
 170
 171 enum mrtags {
 172         MRECREATE = 0x0045544145524345,
 173         MREADD = 0x0000000044444145,
 174         MREEXTEND = 0x00444E4554584545,
 175 };
 176
 177 static bool mrenclave_update(EVP_MD_CTX *ctx, const void *data)
 178 {
 179         if (!EVP_DigestUpdate(ctx, data, 64)) {
 180                 fprintf(stderr, "digest update failed\n");
 181                 return false;
 182         }
 183
 184         return true;
 185 }
 186
 187 static bool mrenclave_commit(EVP_MD_CTX *ctx, uint8_t *mrenclave)
 188 {
 189         unsigned int size;
 190
 191         if (!EVP_DigestFinal_ex(ctx, (unsigned char *)mrenclave, &size)) {
 192                 fprintf(stderr, "digest commit failed\n");
 193                 return false;
 194         }
 195
 196         if (size != 32) {
 197                 fprintf(stderr, "invalid digest size = %u\n", size);
 198                 return false;
 199         }
 200
 201         return true;
 202 }
 203
 204 struct mrecreate {
 205         uint64_t tag;
 206         uint32_t ssaframesize;
 207         uint64_t size;
 208         uint8_t reserved[44];
 209 } __attribute__((__packed__));
 210
 211
 212 static bool mrenclave_ecreate(EVP_MD_CTX *ctx, uint64_t blob_size)
 213 {
 214         struct mrecreate mrecreate;
 215         uint64_t encl_size;
 216
 217         for (encl_size = 0x1000; encl_size < blob_size; )
 218                 encl_size <<= 1;
 219
 220         memset(&mrecreate, 0, sizeof(mrecreate));
 221         mrecreate.tag = MRECREATE;
 222         mrecreate.ssaframesize = 1;
 223         mrecreate.size = encl_size;
 224
 225         if (!EVP_DigestInit_ex(ctx, EVP_sha256(), NULL))
 226                 return false;
 227
 228         return mrenclave_update(ctx, &mrecreate);
 229 }
 230
 231 struct mreadd {
 232         uint64_t tag;
 233         uint64_t offset;
 234         uint64_t flags; /* SECINFO flags */
 235         uint8_t reserved[40];
 236 } __attribute__((__packed__));
 237
 238 static bool mrenclave_eadd(EVP_MD_CTX *ctx, uint64_t offset, uint64_t flags)
 239 {
 240         struct mreadd mreadd;
 241
 242         memset(&mreadd, 0, sizeof(mreadd));
 243         mreadd.tag = MREADD;
 244         mreadd.offset = offset;
 245         mreadd.flags = flags;
 246
 247         return mrenclave_update(ctx, &mreadd);
 248 }
 249
 250 struct mreextend {
 251         uint64_t tag;
 252         uint64_t offset;
 253         uint8_t reserved[48];
 254 } __attribute__((__packed__));
 255
 256 static bool mrenclave_eextend(EVP_MD_CTX *ctx, uint64_t offset,
 257                               const uint8_t *data)
 258 {
 259         struct mreextend mreextend;
 260         int i;
 261
 262         for (i = 0; i < 0x1000; i += 0x100) {
 263                 memset(&mreextend, 0, sizeof(mreextend));
 264                 mreextend.tag = MREEXTEND;
 265                 mreextend.offset = offset + i;
 266
 267                 if (!mrenclave_update(ctx, &mreextend))
 268                         return false;
 269
 270                 if (!mrenclave_update(ctx, &data[i + 0x00]))
 271                         return false;
 272
 273                 if (!mrenclave_update(ctx, &data[i + 0x40]))
 274                         return false;
 275
 276                 if (!mrenclave_update(ctx, &data[i + 0x80]))
 277                         return false;
 278
 279                 if (!mrenclave_update(ctx, &data[i + 0xC0]))
 280                         return false;
 281         }
 282
 283         return true;
 284 }
 285
 286 static bool mrenclave_segment(EVP_MD_CTX *ctx, struct encl *encl,
 287                               struct encl_segment *seg)
 288 {
 289         uint64_t end = seg->offset + seg->size;
 290         uint64_t offset;
 291
 292         for (offset = seg->offset; offset < end; offset += PAGE_SIZE) {
 293                 if (!mrenclave_eadd(ctx, offset, seg->flags))
 294                         return false;
 295
 296                 if (!mrenclave_eextend(ctx, offset, encl->src + offset))
 297                         return false;
 298         }
 299
 300         return true;
 301 }
 302
 303 bool encl_measure(struct encl *encl)
 304 {
 305         uint64_t header1[2] = {0x000000E100000006, 0x0000000000010000};
 306         uint64_t header2[2] = {0x0000006000000101, 0x0000000100000060};
 307         struct sgx_sigstruct *sigstruct = &encl->sigstruct;
 308         struct sgx_sigstruct_payload payload;
 309         uint8_t digest[SHA256_DIGEST_LENGTH];
 310         unsigned int siglen;
 311         RSA *key = NULL;
 312         EVP_MD_CTX *ctx;
 313         int i;
 314
 315         memset(sigstruct, 0, sizeof(*sigstruct));
 316
 317         sigstruct->header.header1[0] = header1[0];
 318         sigstruct->header.header1[1] = header1[1];
 319         sigstruct->header.header2[0] = header2[0];
 320         sigstruct->header.header2[1] = header2[1];
 321         sigstruct->exponent = 3;
 322         sigstruct->body.attributes = SGX_ATTR_MODE64BIT;
 323         sigstruct->body.xfrm = 3;
 324
 325         /* sanity check */
 326         if (check_crypto_errors())
 327                 goto err;
 328
 329         key = gen_sign_key();
 330         if (!key) {
 331                 ERR_print_errors_fp(stdout);
 332                 goto err;
 333         }
 334
 335         BN_bn2bin(get_modulus(key), sigstruct->modulus);
 336
 337         ctx = EVP_MD_CTX_create();
 338         if (!ctx)
 339                 goto err;
 340
 341         if (!mrenclave_ecreate(ctx, encl->src_size))
 342                 goto err;
 343
 344         for (i = 0; i < encl->nr_segments; i++) {
 345                 struct encl_segment *seg = &encl->segment_tbl[i];
 346
 347                 if (!mrenclave_segment(ctx, encl, seg))
 348                         goto err;
 349         }
 350
 351         if (!mrenclave_commit(ctx, sigstruct->body.mrenclave))
 352                 goto err;
 353
 354         memcpy(&payload.header, &sigstruct->header, sizeof(sigstruct->header));
 355         memcpy(&payload.body, &sigstruct->body, sizeof(sigstruct->body));
 356
 357         SHA256((unsigned char *)&payload, sizeof(payload), digest);
 358
 359         if (!RSA_sign(NID_sha256, digest, SHA256_DIGEST_LENGTH,
 360                       sigstruct->signature, &siglen, key))
 361                 goto err;
 362
 363         if (!calc_q1q2(sigstruct->signature, sigstruct->modulus, sigstruct->q1,
 364                        sigstruct->q2))
 365                 goto err;
 366
 367         /* BE -> LE */
 368         reverse_bytes(sigstruct->signature, SGX_MODULUS_SIZE);
 369         reverse_bytes(sigstruct->modulus, SGX_MODULUS_SIZE);
 370         reverse_bytes(sigstruct->q1, SGX_MODULUS_SIZE);
 371         reverse_bytes(sigstruct->q2, SGX_MODULUS_SIZE);
 372
 373         EVP_MD_CTX_destroy(ctx);
 374         RSA_free(key);
 375         return true;
 376
 377 err:
 378         EVP_MD_CTX_destroy(ctx);
 379         RSA_free(key);
 380         return false;
 381 }