c161698505c71620f8425e237b7cac9e30fbc305
[openssl.git] / test / evp_pkey_provided_test.c
1 /*
2  * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <openssl/evp.h>
11 #include <openssl/pem.h>
12 #include <openssl/serializer.h>
13 #include <openssl/provider.h>
14 #include <openssl/params.h>
15 #include <openssl/core_names.h>
16 #include "crypto/ecx.h"
17 #include "internal/nelem.h"
18 #include "crypto/evp.h"          /* For the internal API */
19 #include "testutil.h"
20
21 static char *datadir = NULL;
22
23 #define PRIV_TEXT    0
24 #define PRIV_PEM     1
25 #define PRIV_DER     2
26 #define PUB_TEXT     3
27 #define PUB_PEM      4
28 #define PUB_DER      5
29
30 static void stripcr(char *buf, size_t *len)
31 {
32     size_t i;
33     char *curr, *writ;
34
35     for (i = *len, curr = buf, writ = buf; i > 0; i--, curr++) {
36         if (*curr == '\r') {
37             (*len)--;
38             continue;
39         }
40         if (curr != writ)
41             *writ = *curr;
42         writ++;
43     }
44 }
45
46 static int compare_with_file(const char *alg, int type, BIO *membio)
47 {
48     char filename[80];
49     BIO *file = NULL;
50     char buf[1024];
51     char *memdata, *fullfile = NULL;
52     const char *suffix;
53     size_t readbytes;
54     int ret = 0;
55     int len;
56     size_t slen;
57
58     switch (type) {
59     case PRIV_TEXT:
60         suffix = "priv.txt";
61         break;
62
63     case PRIV_PEM:
64         suffix = "priv.pem";
65         break;
66
67     case PRIV_DER:
68         suffix = "priv.der";
69         break;
70
71     case PUB_TEXT:
72         suffix = "pub.txt";
73         break;
74
75     case PUB_PEM:
76         suffix = "pub.pem";
77         break;
78
79     case PUB_DER:
80         suffix = "pub.der";
81         break;
82
83     default:
84         TEST_error("Invalid file type");
85         goto err;
86     }
87
88     BIO_snprintf(filename, sizeof(filename), "%s.%s", alg, suffix);
89     fullfile = test_mk_file_path(datadir, filename);
90     if (!TEST_ptr(fullfile))
91         goto err;
92
93     file = BIO_new_file(fullfile, "rb");
94     if (!TEST_ptr(file))
95         goto err;
96
97     if (!TEST_true(BIO_read_ex(file, buf, sizeof(buf), &readbytes))
98             || !TEST_true(BIO_eof(file))
99             || !TEST_size_t_lt(readbytes, sizeof(buf)))
100         goto err;
101
102     len = BIO_get_mem_data(membio, &memdata);
103     if (!TEST_int_gt(len, 0))
104         goto err;
105
106     slen = len;
107     if (type != PRIV_DER && type != PUB_DER) {
108         stripcr(memdata, &slen);
109         stripcr(buf, &readbytes);
110     }
111
112     if (!TEST_mem_eq(memdata, slen, buf, readbytes))
113         goto err;
114
115     ret = 1;
116  err:
117     OPENSSL_free(fullfile);
118     (void)BIO_reset(membio);
119     BIO_free(file);
120     return ret;
121 }
122
123 static int test_print_key_using_pem(const char *alg, const EVP_PKEY *pk)
124 {
125     BIO *membio = BIO_new(BIO_s_mem());
126     int ret = 0;
127
128     if (!TEST_ptr(membio))
129         goto err;
130
131     if (!TEST_true(EVP_PKEY_print_private(membio, pk, 0, NULL))
132         || !TEST_true(compare_with_file(alg, PRIV_TEXT, membio))
133         /* Public key in PEM form */
134         || !TEST_true(PEM_write_bio_PUBKEY(membio, pk))
135         || !TEST_true(compare_with_file(alg, PUB_PEM, membio))
136         /* Unencrypted private key in PEM form */
137         || !TEST_true(PEM_write_bio_PrivateKey(membio, pk,
138                                                NULL, NULL, 0, NULL, NULL))
139         || !TEST_true(compare_with_file(alg, PRIV_PEM, membio))
140         /* Encrypted private key in PEM form */
141         || !TEST_true(PEM_write_bio_PrivateKey(bio_out, pk, EVP_aes_256_cbc(),
142                                                (unsigned char *)"pass", 4,
143                                                NULL, NULL)))
144         goto err;
145
146     ret = 1;
147  err:
148     BIO_free(membio);
149     return ret;
150 }
151
152 static int test_print_key_type_using_serializer(const char *alg, int type,
153                                                 const EVP_PKEY *pk)
154 {
155     const char *pq;
156     OSSL_SERIALIZER_CTX *ctx = NULL;
157     BIO *membio = BIO_new(BIO_s_mem());
158     int ret = 1;
159
160     switch (type) {
161     case PRIV_TEXT:
162         pq = OSSL_SERIALIZER_PrivateKey_TO_TEXT_PQ;
163         break;
164
165     case PRIV_PEM:
166         pq = OSSL_SERIALIZER_PrivateKey_TO_PEM_PQ;
167         break;
168
169     case PRIV_DER:
170         pq = OSSL_SERIALIZER_PrivateKey_TO_DER_PQ;
171         break;
172
173     case PUB_TEXT:
174         pq = OSSL_SERIALIZER_PUBKEY_TO_TEXT_PQ;
175         break;
176
177     case PUB_PEM:
178         pq = OSSL_SERIALIZER_PUBKEY_TO_PEM_PQ;
179         break;
180
181     case PUB_DER:
182         pq = OSSL_SERIALIZER_PUBKEY_TO_DER_PQ;
183         break;
184
185     default:
186         TEST_error("Invalid serialization type");
187         goto err;
188     }
189
190     if (!TEST_ptr(membio)) {
191         ret = 0;
192         goto err;
193     }
194
195     /* Make a context, it's valid for several prints */
196     TEST_note("Setting up a OSSL_SERIALIZER context with passphrase");
197     if (!TEST_ptr(ctx = OSSL_SERIALIZER_CTX_new_by_EVP_PKEY(pk, pq))
198         /* Check that this operation is supported */
199         || !TEST_ptr(OSSL_SERIALIZER_CTX_get_serializer(ctx)))
200         goto err;
201
202     /* Use no cipher.  This should give us an unencrypted PEM */
203     TEST_note("Testing with no encryption");
204     if (!TEST_true(OSSL_SERIALIZER_to_bio(ctx, membio))
205         || !TEST_true(compare_with_file(alg, type, membio)))
206         ret = 0;
207
208     if (type == PRIV_PEM) {
209         /* Set a passphrase to be used later */
210         if (!TEST_true(OSSL_SERIALIZER_CTX_set_passphrase(ctx,
211                                                           (unsigned char *)"pass",
212                                                           4)))
213             goto err;
214
215         /* Use a valid cipher name */
216         TEST_note("Displaying PEM encrypted with AES-256-CBC");
217         if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx, "AES-256-CBC", NULL))
218             || !TEST_true(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
219             ret = 0;
220
221         /* Use an invalid cipher name, which should generate no output */
222         TEST_note("NOT Displaying PEM encrypted with (invalid) FOO");
223         if (!TEST_false(OSSL_SERIALIZER_CTX_set_cipher(ctx, "FOO", NULL))
224             || !TEST_false(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
225             ret = 0;
226
227         /* Clear the cipher.  This should give us an unencrypted PEM again */
228         TEST_note("Testing with encryption cleared (no encryption)");
229         if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx, NULL, NULL))
230             || !TEST_true(OSSL_SERIALIZER_to_bio(ctx, membio))
231             || !TEST_true(compare_with_file(alg, type, membio)))
232             ret = 0;
233     }
234
235 err:
236     BIO_free(membio);
237     OSSL_SERIALIZER_CTX_free(ctx);
238     return ret;
239 }
240
241 static int test_print_key_using_serializer(const char *alg, const EVP_PKEY *pk)
242 {
243     int i;
244     int ret = 1;
245
246     for (i = 0; i < 6; i++)
247         ret = ret && test_print_key_type_using_serializer(alg, i, pk);
248
249     return ret;
250 }
251
252 /* Array indexes used in test_fromdata_rsa */
253 #define N       0
254 #define E       1
255 #define D       2
256 #define P       3
257 #define Q       4
258 #define DP      5
259 #define DQ      6
260 #define QINV    7
261
262 static int test_fromdata_rsa(void)
263 {
264     int ret = 0;
265     EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
266     EVP_PKEY *pk = NULL;
267     /*
268      * 32-bit RSA key, extracted from this command,
269      * executed with OpenSSL 1.0.2:
270      *
271      * openssl genrsa 32 | openssl rsa -text
272      */
273     static unsigned long key_numbers[] = {
274         0xbc747fc5,              /* N */
275         0x10001,                 /* E */
276         0x7b133399,              /* D */
277         0xe963,                  /* P */
278         0xceb7,                  /* Q */
279         0x8599,                  /* DP */
280         0xbd87,                  /* DQ */
281         0xcc3b,                  /* QINV */
282     };
283     OSSL_PARAM fromdata_params[] = {
284         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_N, &key_numbers[N]),
285         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_E, &key_numbers[E]),
286         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_D, &key_numbers[D]),
287         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR, &key_numbers[P]),
288         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR, &key_numbers[Q]),
289         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT, &key_numbers[DP]),
290         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT, &key_numbers[DQ]),
291         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_COEFFICIENT, &key_numbers[QINV]),
292         OSSL_PARAM_END
293     };
294
295     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL)))
296         goto err;
297
298     if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
299         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params))
300         || !TEST_int_eq(EVP_PKEY_bits(pk), 32)
301         || !TEST_int_eq(EVP_PKEY_security_bits(pk), 8)
302         || !TEST_int_eq(EVP_PKEY_size(pk), 4))
303         goto err;
304
305     if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
306         goto err;
307
308     if (!TEST_true(EVP_PKEY_check(key_ctx))
309         || !TEST_true(EVP_PKEY_public_check(key_ctx))
310         || !TEST_true(EVP_PKEY_private_check(key_ctx))
311         || !TEST_true(EVP_PKEY_pairwise_check(key_ctx)))
312         goto err;
313
314     ret = test_print_key_using_pem("RSA", pk)
315           && test_print_key_using_serializer("RSA", pk);
316
317  err:
318     EVP_PKEY_free(pk);
319     EVP_PKEY_CTX_free(key_ctx);
320     EVP_PKEY_CTX_free(ctx);
321
322     return ret;
323 }
324
325 #ifndef OPENSSL_NO_DH
326 /* Array indexes used in test_fromdata_dh */
327 #define PRIV_KEY        0
328 #define PUB_KEY         1
329 #define FFC_P           2
330 #define FFC_G           3
331
332 static int test_fromdata_dh(void)
333 {
334     int ret = 0;
335     EVP_PKEY_CTX *ctx = NULL;
336     EVP_PKEY *pk = NULL;
337     /*
338      * 32-bit DH key, extracted from this command,
339      * executed with OpenSSL 1.0.2:
340      *
341      * openssl dhparam -out dhp.pem 32
342      * openssl genpkey -paramfile dhp.pem | openssl pkey -text
343      */
344     static unsigned long key_numbers[] = {
345         0x666c2b06,              /* priv-key */
346         0x6fa6de50,              /* pub-key */
347         0x8bb45f53,              /* P */
348         0x2,                     /* G */
349     };
350     OSSL_PARAM fromdata_params[] = {
351         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_PRIV_KEY, &key_numbers[PRIV_KEY]),
352         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_PUB_KEY, &key_numbers[PUB_KEY]),
353         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_FFC_P, &key_numbers[FFC_P]),
354         OSSL_PARAM_ulong(OSSL_PKEY_PARAM_FFC_G, &key_numbers[FFC_G]),
355         OSSL_PARAM_END
356     };
357
358     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DH", NULL)))
359         goto err;
360
361     if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
362         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params))
363         || !TEST_int_eq(EVP_PKEY_bits(pk), 32)
364         || !TEST_int_eq(EVP_PKEY_security_bits(pk), 0) /* Missing Q */
365         || !TEST_int_eq(EVP_PKEY_size(pk), 4))
366         goto err;
367
368     ret = test_print_key_using_pem("DH", pk)
369           && test_print_key_using_serializer("DH", pk);
370
371  err:
372     EVP_PKEY_free(pk);
373     EVP_PKEY_CTX_free(ctx);
374
375     return ret;
376 }
377 #endif
378
379 #ifndef OPENSSL_NO_EC
380 /* Array indexes used in test_fromdata_ecx */
381 # define PRIV_KEY        0
382 # define PUB_KEY         1
383
384 # define X25519_IDX      0
385 # define X448_IDX        1
386
387 static int test_fromdata_ecx(int tst)
388 {
389     int ret = 0;
390     EVP_PKEY_CTX *ctx = NULL;
391     EVP_PKEY *pk = NULL;
392     const char *alg = (tst == X25519_IDX) ? "X25519" : "X448";
393
394     /* X448_KEYLEN > X25519_KEYLEN */
395     static unsigned char key_numbers[2][2][X448_KEYLEN] = {
396         /* X25519: Keys from RFC 7748 6.1 */
397         {
398             /* Private Key */
399             {
400                 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16,
401                 0xc1, 0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87,
402                 0xeb, 0xc0, 0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9,
403                 0x2c, 0x2a
404             },
405             /* Public Key */
406             {
407                 0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b,
408                 0x7d, 0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d,
409                 0x26, 0x38, 0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b,
410                 0x4e, 0x6a
411             }
412         },
413         /* X448: Keys from RFC 7748 6.2 */
414         {
415             /* Private Key */
416             {
417                 0x9a, 0x8f, 0x49, 0x25, 0xd1, 0x51, 0x9f, 0x57, 0x75, 0xcf,
418                 0x46, 0xb0, 0x4b, 0x58, 0x00, 0xd4, 0xee, 0x9e, 0xe8, 0xba,
419                 0xe8, 0xbc, 0x55, 0x65, 0xd4, 0x98, 0xc2, 0x8d, 0xd9, 0xc9,
420                 0xba, 0xf5, 0x74, 0xa9, 0x41, 0x97, 0x44, 0x89, 0x73, 0x91,
421                 0x00, 0x63, 0x82, 0xa6, 0xf1, 0x27, 0xab, 0x1d, 0x9a, 0xc2,
422                 0xd8, 0xc0, 0xa5, 0x98, 0x72, 0x6b
423             },
424             /* Public Key */
425             {
426                 0x9b, 0x08, 0xf7, 0xcc, 0x31, 0xb7, 0xe3, 0xe6, 0x7d, 0x22,
427                 0xd5, 0xae, 0xa1, 0x21, 0x07, 0x4a, 0x27, 0x3b, 0xd2, 0xb8,
428                 0x3d, 0xe0, 0x9c, 0x63, 0xfa, 0xa7, 0x3d, 0x2c, 0x22, 0xc5,
429                 0xd9, 0xbb, 0xc8, 0x36, 0x64, 0x72, 0x41, 0xd9, 0x53, 0xd4,
430                 0x0c, 0x5b, 0x12, 0xda, 0x88, 0x12, 0x0d, 0x53, 0x17, 0x7f,
431                 0x80, 0xe5, 0x32, 0xc4, 0x1f, 0xa0
432             }
433         }
434     };
435     OSSL_PARAM x25519_fromdata_params[] = {
436         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
437                                 key_numbers[X25519_IDX][PRIV_KEY],
438                                 X25519_KEYLEN),
439         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
440                                 key_numbers[X25519_IDX][PUB_KEY],
441                                 X25519_KEYLEN),
442         OSSL_PARAM_END
443     };
444     OSSL_PARAM x448_fromdata_params[] = {
445         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
446                                 key_numbers[X448_IDX][PRIV_KEY],
447                                 X448_KEYLEN),
448         OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
449                                 key_numbers[X448_IDX][PUB_KEY],
450                                 X448_KEYLEN),
451         OSSL_PARAM_END
452     };
453     OSSL_PARAM *fromdata_params;
454     int bits, security_bits, size;
455
456     if (tst == X25519_IDX) {
457         fromdata_params = x25519_fromdata_params;
458         bits = X25519_BITS;
459         security_bits = X25519_SECURITY_BITS;
460         size = X25519_KEYLEN;
461     } else {
462         fromdata_params = x448_fromdata_params;
463         bits = X448_BITS;
464         security_bits = X448_SECURITY_BITS;
465         size = X448_KEYLEN;
466     }
467
468     ctx = EVP_PKEY_CTX_new_from_name(NULL, alg, NULL);
469     if (!TEST_ptr(ctx))
470         goto err;
471
472     if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
473         || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params))
474         || !TEST_int_eq(EVP_PKEY_bits(pk), bits)
475         || !TEST_int_eq(EVP_PKEY_security_bits(pk), security_bits)
476         || !TEST_int_eq(EVP_PKEY_size(pk), size))
477         goto err;
478
479     ret = test_print_key_using_pem(alg, pk)
480           && test_print_key_using_serializer(alg, pk);
481
482  err:
483     EVP_PKEY_free(pk);
484     EVP_PKEY_CTX_free(ctx);
485
486     return ret;
487 }
488 #endif
489
490
491 int setup_tests(void)
492 {
493     if (!test_skip_common_options()) {
494         TEST_error("Error parsing test options\n");
495         return 0;
496     }
497
498     if (!TEST_ptr(datadir = test_get_argument(0)))
499         return 0;
500
501     ADD_TEST(test_fromdata_rsa);
502 #ifndef OPENSSL_NO_DH
503     ADD_TEST(test_fromdata_dh);
504 #endif
505 #ifndef OPENSSL_NO_EC
506     ADD_ALL_TESTS(test_fromdata_ecx, 2);
507 #endif
508     return 1;
509 }