Implement Provider side Key Management for X25519 and X448
[openssl.git] / providers / implementations / keymgmt / ecx_kmgmt.c
1 /*
2  * Copyright 2020 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 <assert.h>
11 #include <openssl/core_numbers.h>
12 #include <openssl/core_names.h>
13 #include <openssl/params.h>
14 #include "internal/param_build.h"
15 #include "crypto/ecx.h"
16 #include "prov/implementations.h"
17 #include "prov/providercommon.h"
18
19 static OSSL_OP_keymgmt_new_fn x25519_new_key;
20 static OSSL_OP_keymgmt_new_fn x448_new_key;
21 static OSSL_OP_keymgmt_get_params_fn x25519_get_params;
22 static OSSL_OP_keymgmt_get_params_fn x448_get_params;
23 static OSSL_OP_keymgmt_gettable_params_fn ecx_gettable_params;
24 static OSSL_OP_keymgmt_has_fn ecx_has;
25 static OSSL_OP_keymgmt_import_fn ecx_import;
26 static OSSL_OP_keymgmt_import_types_fn ecx_imexport_types;
27 static OSSL_OP_keymgmt_export_fn ecx_export;
28 static OSSL_OP_keymgmt_export_types_fn ecx_imexport_types;
29
30 static void *x25519_new_key(void *provctx)
31 {
32     return ecx_key_new(X25519_KEYLEN, 0);
33 }
34
35 static void *x448_new_key(void *provctx)
36 {
37     return ecx_key_new(X448_KEYLEN, 0);
38 }
39
40 static int ecx_has(void *keydata, int selection)
41 {
42     ECX_KEY *key = keydata;
43     const int ecx_selections = OSSL_KEYMGMT_SELECT_PUBLIC_KEY
44                                | OSSL_KEYMGMT_SELECT_PRIVATE_KEY;
45     int ok = 1;
46
47     if ((selection & ~ecx_selections) != 0
48             || (selection & ecx_selections) == 0)
49         return 0;
50
51     if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
52         ok = ok && key->haspubkey;
53
54     if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
55         ok = ok && key->privkey != NULL;
56
57     return ok;
58 }
59
60 static int ecx_import(void *keydata, int selection, const OSSL_PARAM params[])
61 {
62     ECX_KEY *key = keydata;
63     size_t privkeylen = 0, pubkeylen;
64     const OSSL_PARAM *param_priv_key = NULL, *param_pub_key;
65     unsigned char *pubkey;
66     const int ecx_selections = OSSL_KEYMGMT_SELECT_PUBLIC_KEY
67                                | OSSL_KEYMGMT_SELECT_PRIVATE_KEY;
68
69     if (key == NULL)
70         return 0;
71
72     if ((selection & ~ecx_selections) != 0
73             || (selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) == 0)
74         return 0;
75
76     if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
77         param_priv_key =
78             OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY);
79     param_pub_key =
80         OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY);
81
82     /*
83      * If a private key is present then a public key must also be present.
84      * Alternatively we've just got a public key.
85      */
86     if (param_pub_key == NULL
87             || (param_priv_key == NULL
88                 && (selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0))
89         return 0;
90
91     if (param_priv_key != NULL
92              && !OSSL_PARAM_get_octet_string(param_priv_key,
93                                             (void **)&key->privkey, key->keylen,
94                                              &privkeylen))
95         return 0;
96
97     pubkey = key->pubkey;
98     if (!OSSL_PARAM_get_octet_string(param_pub_key,
99                                      (void **)&pubkey,
100                                      sizeof(key->pubkey), &pubkeylen))
101         return 0;
102
103     if (pubkeylen != key->keylen
104             || (param_priv_key != NULL && privkeylen != key->keylen))
105         return 0;
106
107     key->haspubkey = 1;
108
109     return 1;
110 }
111
112 static int key_to_params(ECX_KEY *key, OSSL_PARAM_BLD *tmpl)
113 {
114     if (key == NULL)
115         return 0;
116
117     if (!ossl_param_bld_push_octet_string(tmpl, OSSL_PKEY_PARAM_PUB_KEY,
118                                           key->pubkey, key->keylen))
119         return 0;
120
121     if (key->privkey != NULL
122         && !ossl_param_bld_push_octet_string(tmpl, OSSL_PKEY_PARAM_PRIV_KEY,
123                                              key->privkey, key->keylen))
124         return 0;
125
126     return 1;
127 }
128
129 static int ecx_export(void *keydata, int selection, OSSL_CALLBACK *param_cb,
130                       void *cbarg)
131 {
132     ECX_KEY *key = keydata;
133     OSSL_PARAM_BLD tmpl;
134     OSSL_PARAM *params = NULL;
135     int ret;
136
137     if (key == NULL)
138         return 0;
139
140     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0
141             && !key_to_params(key, &tmpl))
142         return 0;
143
144     ossl_param_bld_init(&tmpl);
145     params = ossl_param_bld_to_param(&tmpl);
146     if (params == NULL) {
147         ossl_param_bld_free(params);
148         return 0;
149     }
150
151     ret = param_cb(params, cbarg);
152     ossl_param_bld_free(params);
153     return ret;
154 }
155
156 static const OSSL_PARAM ecx_key_types[] = {
157     OSSL_PARAM_BN(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
158     OSSL_PARAM_BN(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
159     OSSL_PARAM_END
160 };
161 static const OSSL_PARAM *ecx_imexport_types(int selection)
162 {
163     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
164         return ecx_key_types;
165     return NULL;
166 }
167
168 static int ecx_get_params(OSSL_PARAM params[], int bits, int secbits,
169                           int size)
170 {
171     OSSL_PARAM *p;
172
173     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
174         && !OSSL_PARAM_set_int(p, bits))
175         return 0;
176     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
177         && !OSSL_PARAM_set_int(p, secbits))
178         return 0;
179     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL
180         && !OSSL_PARAM_set_int(p, size))
181         return 0;
182     return 1;
183 }
184
185 static int x25519_get_params(void *key, OSSL_PARAM params[])
186 {
187     return ecx_get_params(params, X25519_BITS, X25519_SECURITY_BITS, X25519_KEYLEN);
188 }
189
190 static int x448_get_params(void *key, OSSL_PARAM params[])
191 {
192     return ecx_get_params(params, X448_BITS, X448_SECURITY_BITS, X448_KEYLEN);
193 }
194
195 static const OSSL_PARAM ecx_params[] = {
196     OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
197     OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
198     OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
199     OSSL_PARAM_END
200 };
201
202 static const OSSL_PARAM *ecx_gettable_params(void)
203 {
204     return ecx_params;
205 }
206
207 const OSSL_DISPATCH x25519_keymgmt_functions[] = {
208     { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))x25519_new_key },
209     { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))ecx_key_free },
210     { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))x25519_get_params },
211     { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))ecx_gettable_params },
212     { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))ecx_has },
213     { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))ecx_import },
214     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))ecx_imexport_types },
215     { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))ecx_export },
216     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))ecx_imexport_types },
217     { 0, NULL }
218 };
219
220 const OSSL_DISPATCH x448_keymgmt_functions[] = {
221     { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))x448_new_key },
222     { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))ecx_key_free },
223     { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))x448_get_params },
224     { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))ecx_gettable_params },
225     { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))ecx_has },
226     { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))ecx_import },
227     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))ecx_imexport_types },
228     { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))ecx_export },
229     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))ecx_imexport_types },
230     { 0, NULL }
231 };