2ba8f53e5a687802d50f9a5f0ae9f4d03010fec3
[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 <openssl/err.h>
15 #include <openssl/evp.h>
16 #include <openssl/rand.h>
17 #include "internal/param_build_set.h"
18 #include "openssl/param_build.h"
19 #include "crypto/ecx.h"
20 #include "prov/implementations.h"
21 #include "prov/providercommon.h"
22 #include "prov/provider_ctx.h"
23 #ifdef S390X_EC_ASM
24 # include "s390x_arch.h"
25 # include <openssl/sha.h>   /* For SHA512_DIGEST_LENGTH */
26 #endif
27
28 static OSSL_OP_keymgmt_new_fn x25519_new_key;
29 static OSSL_OP_keymgmt_new_fn x448_new_key;
30 static OSSL_OP_keymgmt_new_fn ed25519_new_key;
31 static OSSL_OP_keymgmt_new_fn ed448_new_key;
32 static OSSL_OP_keymgmt_gen_init_fn x25519_gen_init;
33 static OSSL_OP_keymgmt_gen_init_fn x448_gen_init;
34 static OSSL_OP_keymgmt_gen_init_fn ed25519_gen_init;
35 static OSSL_OP_keymgmt_gen_init_fn ed448_gen_init;
36 static OSSL_OP_keymgmt_gen_fn x25519_gen;
37 static OSSL_OP_keymgmt_gen_fn x448_gen;
38 static OSSL_OP_keymgmt_gen_fn ed25519_gen;
39 static OSSL_OP_keymgmt_gen_fn ed448_gen;
40 static OSSL_OP_keymgmt_gen_cleanup_fn ecx_gen_cleanup;
41 static OSSL_OP_keymgmt_get_params_fn x25519_get_params;
42 static OSSL_OP_keymgmt_get_params_fn x448_get_params;
43 static OSSL_OP_keymgmt_get_params_fn ed25519_get_params;
44 static OSSL_OP_keymgmt_get_params_fn ed448_get_params;
45 static OSSL_OP_keymgmt_gettable_params_fn x25519_gettable_params;
46 static OSSL_OP_keymgmt_gettable_params_fn x448_gettable_params;
47 static OSSL_OP_keymgmt_gettable_params_fn ed25519_gettable_params;
48 static OSSL_OP_keymgmt_gettable_params_fn ed448_gettable_params;
49 static OSSL_OP_keymgmt_has_fn ecx_has;
50 static OSSL_OP_keymgmt_import_fn ecx_import;
51 static OSSL_OP_keymgmt_import_types_fn ecx_imexport_types;
52 static OSSL_OP_keymgmt_export_fn ecx_export;
53 static OSSL_OP_keymgmt_export_types_fn ecx_imexport_types;
54
55 #define ECX_POSSIBLE_SELECTIONS (OSSL_KEYMGMT_SELECT_KEYPAIR)
56
57 struct ecx_gen_ctx {
58     OPENSSL_CTX *libctx;
59     ECX_KEY_TYPE type;
60 };
61
62 #ifdef S390X_EC_ASM
63 static void *s390x_ecx_keygen25519(struct ecx_gen_ctx *gctx);
64 static void *s390x_ecx_keygen448(struct ecx_gen_ctx *gctx);
65 static void *s390x_ecd_keygen25519(struct ecx_gen_ctx *gctx);
66 static void *s390x_ecd_keygen448(struct ecx_gen_ctx *gctx);
67 #endif
68
69 static void *x25519_new_key(void *provctx)
70 {
71     return ecx_key_new(ECX_KEY_TYPE_X25519, 0);
72 }
73
74 static void *x448_new_key(void *provctx)
75 {
76     return ecx_key_new(ECX_KEY_TYPE_X448, 0);
77 }
78
79 static void *ed25519_new_key(void *provctx)
80 {
81     return ecx_key_new(ECX_KEY_TYPE_ED25519, 0);
82 }
83
84 static void *ed448_new_key(void *provctx)
85 {
86     return ecx_key_new(ECX_KEY_TYPE_ED448, 0);
87 }
88
89 static int ecx_has(void *keydata, int selection)
90 {
91     ECX_KEY *key = keydata;
92     int ok = 0;
93
94     if (key != NULL) {
95         if ((selection & ECX_POSSIBLE_SELECTIONS) != 0)
96             ok = 1;
97
98         if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
99             ok = ok && key->haspubkey;
100
101         if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
102             ok = ok && key->privkey != NULL;
103     }
104     return ok;
105 }
106
107 static int ecx_import(void *keydata, int selection, const OSSL_PARAM params[])
108 {
109     ECX_KEY *key = keydata;
110     int ok = 1;
111     int include_private = 0;
112
113     if (key == NULL)
114         return 0;
115
116     if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) == 0)
117         return 0;
118
119     include_private = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0);
120     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
121         ok = ok && ecx_key_fromdata(key, params, include_private);
122
123     return ok;
124 }
125
126 static int key_to_params(ECX_KEY *key, OSSL_PARAM_BLD *tmpl,
127                          OSSL_PARAM params[])
128 {
129     if (key == NULL)
130         return 0;
131
132     if (!ossl_param_build_set_octet_string(tmpl, params,
133                                            OSSL_PKEY_PARAM_PUB_KEY,
134                                            key->pubkey, key->keylen))
135         return 0;
136
137     if (key->privkey != NULL
138         && !ossl_param_build_set_octet_string(tmpl, params,
139                                               OSSL_PKEY_PARAM_PRIV_KEY,
140                                               key->privkey, key->keylen))
141         return 0;
142
143     return 1;
144 }
145
146 static int ecx_export(void *keydata, int selection, OSSL_CALLBACK *param_cb,
147                       void *cbarg)
148 {
149     ECX_KEY *key = keydata;
150     OSSL_PARAM_BLD *tmpl;
151     OSSL_PARAM *params = NULL;
152     int ret = 0;
153
154     if (key == NULL)
155         return 0;
156
157     tmpl = OSSL_PARAM_BLD_new();
158     if (tmpl == NULL)
159         return 0;
160
161     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0
162          && !key_to_params(key, tmpl, NULL))
163         goto err;
164
165     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0
166          && !key_to_params(key, tmpl, NULL))
167         goto err;
168
169     params = OSSL_PARAM_BLD_to_param(tmpl);
170     if (params == NULL)
171         goto err;
172
173     ret = param_cb(params, cbarg);
174     OSSL_PARAM_BLD_free_params(params);
175 err:
176     OSSL_PARAM_BLD_free(tmpl);
177     return ret;
178 }
179
180 #define ECX_KEY_TYPES()                                                        \
181 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),                     \
182 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0)
183
184 static const OSSL_PARAM ecx_key_types[] = {
185     ECX_KEY_TYPES(),
186     OSSL_PARAM_END
187 };
188 static const OSSL_PARAM *ecx_imexport_types(int selection)
189 {
190     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
191         return ecx_key_types;
192     return NULL;
193 }
194
195 static int ecx_get_params(void *key, OSSL_PARAM params[], int bits, int secbits,
196                           int size)
197 {
198     ECX_KEY *ecx = key;
199     OSSL_PARAM *p;
200
201     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
202         && !OSSL_PARAM_set_int(p, bits))
203         return 0;
204     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
205         && !OSSL_PARAM_set_int(p, secbits))
206         return 0;
207     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL
208         && !OSSL_PARAM_set_int(p, size))
209         return 0;
210     return key_to_params(ecx, NULL, params);
211 }
212
213 static int ed_get_params(void *key, OSSL_PARAM params[])
214 {
215     OSSL_PARAM *p;
216
217     if ((p = OSSL_PARAM_locate(params,
218                                OSSL_PKEY_PARAM_MANDATORY_DIGEST)) != NULL
219         && !OSSL_PARAM_set_utf8_string(p, ""))
220         return 0;
221     return 1;
222 }
223
224 static int x25519_get_params(void *key, OSSL_PARAM params[])
225 {
226     return ecx_get_params(key, params, X25519_BITS, X25519_SECURITY_BITS,
227                           X25519_KEYLEN);
228 }
229
230 static int x448_get_params(void *key, OSSL_PARAM params[])
231 {
232     return ecx_get_params(key, params, X448_BITS, X448_SECURITY_BITS,
233                           X448_KEYLEN);
234 }
235
236 static int ed25519_get_params(void *key, OSSL_PARAM params[])
237 {
238     return ecx_get_params(key, params, ED25519_BITS, ED25519_SECURITY_BITS,
239                           ED25519_KEYLEN)
240         && ed_get_params(key, params);
241 }
242
243 static int ed448_get_params(void *key, OSSL_PARAM params[])
244 {
245     return ecx_get_params(key, params, ED448_BITS, ED448_SECURITY_BITS,
246                           ED448_KEYLEN)
247         && ed_get_params(key, params);
248 }
249
250 static const OSSL_PARAM ecx_params[] = {
251     OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
252     OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
253     OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
254     OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST, NULL, 0),
255     ECX_KEY_TYPES(),
256     OSSL_PARAM_END
257 };
258
259 static const OSSL_PARAM ed_params[] = {
260     OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
261     OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
262     OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
263     ECX_KEY_TYPES(),
264     OSSL_PARAM_END
265 };
266
267 static const OSSL_PARAM *x25519_gettable_params(void)
268 {
269     return ecx_params;
270 }
271
272 static const OSSL_PARAM *x448_gettable_params(void)
273 {
274     return ecx_params;
275 }
276
277 static const OSSL_PARAM *ed25519_gettable_params(void)
278 {
279     return ed_params;
280 }
281
282 static const OSSL_PARAM *ed448_gettable_params(void)
283 {
284     return ed_params;
285 }
286
287 static void *ecx_gen_init(void *provctx, int selection, ECX_KEY_TYPE type)
288 {
289     OPENSSL_CTX *libctx = PROV_LIBRARY_CONTEXT_OF(provctx);
290     struct ecx_gen_ctx *gctx = NULL;
291
292     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
293         return NULL;
294
295     if ((gctx = OPENSSL_malloc(sizeof(*gctx))) != NULL) {
296         gctx->libctx = libctx;
297         gctx->type = type;
298     }
299     return gctx;
300 }
301
302 static void *x25519_gen_init(void *provctx, int selection)
303 {
304     return ecx_gen_init(provctx, selection, ECX_KEY_TYPE_X25519);
305 }
306
307 static void *x448_gen_init(void *provctx, int selection)
308 {
309     return ecx_gen_init(provctx, selection, ECX_KEY_TYPE_X448);
310 }
311
312 static void *ed25519_gen_init(void *provctx, int selection)
313 {
314     return ecx_gen_init(provctx, selection, ECX_KEY_TYPE_ED25519);
315 }
316
317 static void *ed448_gen_init(void *provctx, int selection)
318 {
319     return ecx_gen_init(provctx, selection, ECX_KEY_TYPE_ED448);
320 }
321
322 static void *ecx_gen(struct ecx_gen_ctx *gctx)
323 {
324     ECX_KEY *key;
325     unsigned char *privkey;
326
327     if (gctx == NULL)
328         return NULL;
329     if ((key = ecx_key_new(gctx->type, 0)) == NULL) {
330         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
331         return NULL;
332     }
333     if ((privkey = ecx_key_allocate_privkey(key)) == NULL) {
334         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
335         goto err;
336     }
337     if (RAND_priv_bytes_ex(gctx->libctx, privkey, key->keylen) <= 0)
338         goto err;
339     switch (gctx->type) {
340     case ECX_KEY_TYPE_X25519:
341         privkey[0] &= 248;
342         privkey[X25519_KEYLEN - 1] &= 127;
343         privkey[X25519_KEYLEN - 1] |= 64;
344         X25519_public_from_private(key->pubkey, privkey);
345         break;
346     case ECX_KEY_TYPE_X448:
347         privkey[0] &= 252;
348         privkey[X448_KEYLEN - 1] |= 128;
349         X448_public_from_private(key->pubkey, privkey);
350         break;
351     case ECX_KEY_TYPE_ED25519:
352         if (!ED25519_public_from_private(gctx->libctx, key->pubkey, privkey))
353             goto err;
354         break;
355     case ECX_KEY_TYPE_ED448:
356         if (!ED448_public_from_private(gctx->libctx, key->pubkey, privkey))
357             goto err;
358         break;
359     }
360     return key;
361 err:
362     ecx_key_free(key);
363     return NULL;
364 }
365
366 static void *x25519_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
367 {
368     struct ecx_gen_ctx *gctx = genctx;
369
370 #ifdef S390X_EC_ASM
371     if (OPENSSL_s390xcap_P.pcc[1] & S390X_CAPBIT(S390X_SCALAR_MULTIPLY_X25519))
372         return s390x_ecx_keygen25519(gctx);
373 #endif
374     return ecx_gen(gctx);
375 }
376
377 static void *x448_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
378 {
379     struct ecx_gen_ctx *gctx = genctx;
380
381 #ifdef S390X_EC_ASM
382     if (OPENSSL_s390xcap_P.pcc[1] & S390X_CAPBIT(S390X_SCALAR_MULTIPLY_X448))
383         return s390x_ecx_keygen448(gctx);
384 #endif
385     return ecx_gen(gctx);
386 }
387
388 static void *ed25519_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
389 {
390     struct ecx_gen_ctx *gctx = genctx;
391 #ifdef S390X_EC_ASM
392     if (OPENSSL_s390xcap_P.pcc[1] & S390X_CAPBIT(S390X_SCALAR_MULTIPLY_ED25519)
393         && OPENSSL_s390xcap_P.kdsa[0] & S390X_CAPBIT(S390X_EDDSA_SIGN_ED25519)
394         && OPENSSL_s390xcap_P.kdsa[0]
395             & S390X_CAPBIT(S390X_EDDSA_VERIFY_ED25519))
396         return s390x_ecd_keygen25519(gctx);
397 #endif
398     return ecx_gen(gctx);
399 }
400
401 static void *ed448_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
402 {
403     struct ecx_gen_ctx *gctx = genctx;
404
405 #ifdef S390X_EC_ASM
406     if (OPENSSL_s390xcap_P.pcc[1] & S390X_CAPBIT(S390X_SCALAR_MULTIPLY_ED448)
407         && OPENSSL_s390xcap_P.kdsa[0] & S390X_CAPBIT(S390X_EDDSA_SIGN_ED448)
408         && OPENSSL_s390xcap_P.kdsa[0] & S390X_CAPBIT(S390X_EDDSA_VERIFY_ED448))
409         return s390x_ecd_keygen448(gctx);
410 #endif
411     return ecx_gen(gctx);
412 }
413
414 static void ecx_gen_cleanup(void *genctx)
415 {
416     struct ecx_gen_ctx *gctx = genctx;
417
418     OPENSSL_free(gctx);
419 }
420
421 #define MAKE_KEYMGMT_FUNCTIONS(alg) \
422     const OSSL_DISPATCH alg##_keymgmt_functions[] = { \
423         { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))alg##_new_key }, \
424         { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))ecx_key_free }, \
425         { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))alg##_get_params }, \
426         { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))alg##_gettable_params }, \
427         { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))ecx_has }, \
428         { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))ecx_import }, \
429         { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))ecx_imexport_types }, \
430         { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))ecx_export }, \
431         { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))ecx_imexport_types }, \
432         { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))alg##_gen_init }, \
433         { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))alg##_gen }, \
434         { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))ecx_gen_cleanup }, \
435         { 0, NULL } \
436     };
437
438 MAKE_KEYMGMT_FUNCTIONS(x25519)
439 MAKE_KEYMGMT_FUNCTIONS(x448)
440 MAKE_KEYMGMT_FUNCTIONS(ed25519)
441 MAKE_KEYMGMT_FUNCTIONS(ed448)
442
443 #ifdef S390X_EC_ASM
444 # include "s390x_arch.h"
445
446 static void *s390x_ecx_keygen25519(struct ecx_gen_ctx *gctx)
447 {
448     static const unsigned char generator[] = {
449         0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
450         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
451         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
452     };
453     ECX_KEY *key = ecx_key_new(ECX_KEY_TYPE_X25519, 1);
454     unsigned char *privkey = NULL, *pubkey;
455
456     if (key == NULL) {
457         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
458         goto err;
459     }
460
461     pubkey = key->pubkey;
462
463     privkey = ecx_key_allocate_privkey(key);
464     if (privkey == NULL) {
465         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
466         goto err;
467     }
468
469     if (RAND_priv_bytes_ex(gctx->libctx, privkey, X25519_KEYLEN) <= 0)
470         goto err;
471
472     privkey[0] &= 248;
473     privkey[31] &= 127;
474     privkey[31] |= 64;
475
476     if (s390x_x25519_mul(pubkey, generator, privkey) != 1)
477         goto err;
478     return key;
479  err:
480     ecx_key_free(key);
481     return NULL;
482 }
483
484 static void *s390x_ecx_keygen448(struct ecx_gen_ctx *gctx)
485 {
486     static const unsigned char generator[] = {
487         0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
488         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
489         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
490         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
491         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
492     };
493     ECX_KEY *key = ecx_key_new(ECX_KEY_TYPE_X448, 1);
494     unsigned char *privkey = NULL, *pubkey;
495
496     if (key == NULL) {
497         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
498         goto err;
499     }
500
501     pubkey = key->pubkey;
502
503     privkey = ecx_key_allocate_privkey(key);
504     if (privkey == NULL) {
505         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
506         goto err;
507     }
508
509     if (RAND_priv_bytes_ex(gctx->libctx, privkey, X448_KEYLEN) <= 0)
510         goto err;
511
512     privkey[0] &= 252;
513     privkey[55] |= 128;
514
515     if (s390x_x448_mul(pubkey, generator, privkey) != 1)
516         goto err;
517     return key;
518  err:
519     ecx_key_free(key);
520     return NULL;
521 }
522
523 static void *s390x_ecd_keygen25519(struct ecx_gen_ctx *gctx)
524 {
525     static const unsigned char generator_x[] = {
526         0x1a, 0xd5, 0x25, 0x8f, 0x60, 0x2d, 0x56, 0xc9, 0xb2, 0xa7, 0x25, 0x95,
527         0x60, 0xc7, 0x2c, 0x69, 0x5c, 0xdc, 0xd6, 0xfd, 0x31, 0xe2, 0xa4, 0xc0,
528         0xfe, 0x53, 0x6e, 0xcd, 0xd3, 0x36, 0x69, 0x21
529     };
530     static const unsigned char generator_y[] = {
531         0x58, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
532         0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
533         0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
534     };
535     unsigned char x_dst[32], buff[SHA512_DIGEST_LENGTH];
536     ECX_KEY *key = ecx_key_new(ECX_KEY_TYPE_ED25519, 1);
537     unsigned char *privkey = NULL, *pubkey;
538     unsigned int sz;
539     EVP_MD *sha = NULL;
540     int j;
541
542     if (key == NULL) {
543         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
544         goto err;
545     }
546
547     pubkey = key->pubkey;
548
549     privkey = ecx_key_allocate_privkey(key);
550     if (privkey == NULL) {
551         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
552         goto err;
553     }
554
555     if (RAND_priv_bytes_ex(gctx->libctx, privkey, ED25519_KEYLEN) <= 0)
556         goto err;
557
558     sha = EVP_MD_fetch(gctx->libctx, "SHA512", NULL);
559     if (sha == NULL)
560         goto err;
561     j = EVP_Digest(privkey, 32, buff, &sz, sha, NULL);
562     EVP_MD_free(sha);
563     if (!j)
564         goto err;
565
566     buff[0] &= 248;
567     buff[31] &= 63;
568     buff[31] |= 64;
569
570     if (s390x_ed25519_mul(x_dst, pubkey,
571                           generator_x, generator_y, buff) != 1)
572         goto err;
573
574     pubkey[31] |= ((x_dst[0] & 0x01) << 7);
575     return key;
576  err:
577     ecx_key_free(key);
578     return NULL;
579 }
580
581 static void *s390x_ecd_keygen448(struct ecx_gen_ctx *gctx)
582 {
583     static const unsigned char generator_x[] = {
584         0x5e, 0xc0, 0x0c, 0xc7, 0x2b, 0xa8, 0x26, 0x26, 0x8e, 0x93, 0x00, 0x8b,
585         0xe1, 0x80, 0x3b, 0x43, 0x11, 0x65, 0xb6, 0x2a, 0xf7, 0x1a, 0xae, 0x12,
586         0x64, 0xa4, 0xd3, 0xa3, 0x24, 0xe3, 0x6d, 0xea, 0x67, 0x17, 0x0f, 0x47,
587         0x70, 0x65, 0x14, 0x9e, 0xda, 0x36, 0xbf, 0x22, 0xa6, 0x15, 0x1d, 0x22,
588         0xed, 0x0d, 0xed, 0x6b, 0xc6, 0x70, 0x19, 0x4f, 0x00
589     };
590     static const unsigned char generator_y[] = {
591         0x14, 0xfa, 0x30, 0xf2, 0x5b, 0x79, 0x08, 0x98, 0xad, 0xc8, 0xd7, 0x4e,
592         0x2c, 0x13, 0xbd, 0xfd, 0xc4, 0x39, 0x7c, 0xe6, 0x1c, 0xff, 0xd3, 0x3a,
593         0xd7, 0xc2, 0xa0, 0x05, 0x1e, 0x9c, 0x78, 0x87, 0x40, 0x98, 0xa3, 0x6c,
594         0x73, 0x73, 0xea, 0x4b, 0x62, 0xc7, 0xc9, 0x56, 0x37, 0x20, 0x76, 0x88,
595         0x24, 0xbc, 0xb6, 0x6e, 0x71, 0x46, 0x3f, 0x69, 0x00
596     };
597     unsigned char x_dst[57], buff[114];
598     ECX_KEY *key = ecx_key_new(ECX_KEY_TYPE_ED448, 1);
599     unsigned char *privkey = NULL, *pubkey;
600     EVP_MD_CTX *hashctx = NULL;
601     EVP_MD *shake = NULL;
602
603     if (key == NULL) {
604         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
605         goto err;
606     }
607
608     pubkey = key->pubkey;
609
610     privkey = ecx_key_allocate_privkey(key);
611     if (privkey == NULL) {
612         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
613         goto err;
614     }
615
616     shake = EVP_MD_fetch(gctx->libctx, "SHAKE256", NULL);
617     if (shake == NULL)
618         goto err;
619     if (RAND_priv_bytes_ex(gctx->libctx, privkey, ED448_KEYLEN) <= 0)
620         goto err;
621
622     hashctx = EVP_MD_CTX_new();
623     if (hashctx == NULL)
624         goto err;
625     if (EVP_DigestInit_ex(hashctx, shake, NULL) != 1)
626         goto err;
627     if (EVP_DigestUpdate(hashctx, privkey, 57) != 1)
628         goto err;
629     if (EVP_DigestFinalXOF(hashctx, buff, sizeof(buff)) != 1)
630         goto err;
631
632     buff[0] &= -4;
633     buff[55] |= 0x80;
634     buff[56] = 0;
635
636     if (s390x_ed448_mul(x_dst, pubkey,
637                         generator_x, generator_y, buff) != 1)
638         goto err;
639
640     pubkey[56] |= ((x_dst[0] & 0x01) << 7);
641     EVP_MD_CTX_free(hashctx);
642     EVP_MD_free(shake);
643     return key;
644  err:
645     ecx_key_free(key);
646     EVP_MD_CTX_free(hashctx);
647     EVP_MD_free(shake);
648     return NULL;
649 }
650 #endif