~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/testing/selftests/sgx/sigstruct.c

Version: ~ [ linux-6.1-rc7 ] ~ [ linux-6.0.10 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.80 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.156 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.225 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.267 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.300 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.334 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp