CoCalc -- decode

GitHub Repository: freebsd/freebsd-src
Path: blob/main/crypto/openssl/providers/implementations/encode_decode/decode_der2key.c
⁴⁸³⁸³ views
1
/*
2
 * Copyright 2020-2025 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
/*
11
 * low level APIs are deprecated for public use, but still ok for
12
 * internal use.
13
 */
14
#include "internal/deprecated.h"
15

16
#include <openssl/byteorder.h>
17
#include <openssl/core_dispatch.h>
18
#include <openssl/core_names.h>
19
#include <openssl/core_object.h>
20
#include <openssl/crypto.h>
21
#include <openssl/err.h>
22
#include <openssl/params.h>
23
#include <openssl/pem.h>         /* PEM_BUFSIZE and public PEM functions */
24
#include <openssl/pkcs12.h>
25
#include <openssl/provider.h>
26
#include <openssl/x509.h>
27
#include <openssl/proverr.h>
28
#include <openssl/asn1t.h>
29
#include "internal/cryptlib.h"   /* ossl_assert() */
30
#include "crypto/dh.h"
31
#include "crypto/dsa.h"
32
#include "crypto/ec.h"
33
#include "crypto/evp.h"
34
#include "crypto/ecx.h"
35
#include "crypto/rsa.h"
36
#include "crypto/ml_dsa.h"
37
#include "crypto/slh_dsa.h"
38
#include "crypto/x509.h"
39
#include "crypto/ml_kem.h"
40
#include "openssl/obj_mac.h"
41
#include "prov/bio.h"
42
#include "prov/implementations.h"
43
#include "endecoder_local.h"
44
#include "internal/nelem.h"
45
#include "ml_dsa_codecs.h"
46
#include "ml_kem_codecs.h"
47

48
#ifndef OPENSSL_NO_SLH_DSA
49
typedef struct {
50
    ASN1_OBJECT *oid;
51
} BARE_ALGOR;
52

53
typedef struct {
54
    BARE_ALGOR algor;
55
    ASN1_BIT_STRING *pubkey;
56
} BARE_PUBKEY;
57

58
ASN1_SEQUENCE(BARE_ALGOR) = {
59
    ASN1_SIMPLE(BARE_ALGOR, oid, ASN1_OBJECT),
60
} static_ASN1_SEQUENCE_END(BARE_ALGOR)
61

62
ASN1_SEQUENCE(BARE_PUBKEY) = {
63
    ASN1_EMBED(BARE_PUBKEY, algor, BARE_ALGOR),
64
    ASN1_SIMPLE(BARE_PUBKEY, pubkey, ASN1_BIT_STRING)
65
} static_ASN1_SEQUENCE_END(BARE_PUBKEY)
66
#endif /* OPENSSL_NO_SLH_DSA */
67

68
struct der2key_ctx_st;           /* Forward declaration */
69
typedef int check_key_fn(void *, struct der2key_ctx_st *ctx);
70
typedef void adjust_key_fn(void *, struct der2key_ctx_st *ctx);
71
typedef void free_key_fn(void *);
72
typedef void *d2i_PKCS8_fn(const unsigned char **, long,
73
                           struct der2key_ctx_st *);
74
typedef void *d2i_PUBKEY_fn(const unsigned char **, long,
75
                            struct der2key_ctx_st *);
76
struct keytype_desc_st {
77
    const char *keytype_name;
78
    const OSSL_DISPATCH *fns; /* Keymgmt (to pilfer functions from) */
79

80
    /* The input structure name */
81
    const char *structure_name;
82

83
    /*
84
     * The EVP_PKEY_xxx type macro.  Should be zero for type specific
85
     * structures, non-zero when the outermost structure is PKCS#8 or
86
     * SubjectPublicKeyInfo.  This determines which of the function
87
     * pointers below will be used.
88
     */
89
    int evp_type;
90

91
    /* The selection mask for OSSL_FUNC_decoder_does_selection() */
92
    int selection_mask;
93

94
    /* For type specific decoders, we use the corresponding d2i */
95
    d2i_of_void *d2i_private_key; /* From type-specific DER */
96
    d2i_of_void *d2i_public_key;  /* From type-specific DER */
97
    d2i_of_void *d2i_key_params;  /* From type-specific DER */
98
    d2i_PKCS8_fn *d2i_PKCS8;      /* Wrapped in a PrivateKeyInfo */
99
    d2i_PUBKEY_fn *d2i_PUBKEY;    /* Wrapped in a SubjectPublicKeyInfo */
100

101
    /*
102
     * For any key, we may need to check that the key meets expectations.
103
     * This is useful when the same functions can decode several variants
104
     * of a key.
105
     */
106
    check_key_fn *check_key;
107

108
    /*
109
     * For any key, we may need to make provider specific adjustments, such
110
     * as ensure the key carries the correct library context.
111
     */
112
    adjust_key_fn *adjust_key;
113
    /* {type}_free() */
114
    free_key_fn *free_key;
115
};
116

117
/*
118
 * Context used for DER to key decoding.
119
 */
120
struct der2key_ctx_st {
121
    PROV_CTX *provctx;
122
    char propq[OSSL_MAX_PROPQUERY_SIZE];
123
    const struct keytype_desc_st *desc;
124
    /* The selection that is passed to der2key_decode() */
125
    int selection;
126
    /* Flag used to signal that a failure is fatal */
127
    unsigned int flag_fatal : 1;
128
};
129

130
typedef void *key_from_pkcs8_t(const PKCS8_PRIV_KEY_INFO *p8inf,
131
                               OSSL_LIB_CTX *libctx, const char *propq);
132
static void *der2key_decode_p8(const unsigned char **input_der,
133
                               long input_der_len, struct der2key_ctx_st *ctx,
134
                               key_from_pkcs8_t *key_from_pkcs8)
135
{
136
    PKCS8_PRIV_KEY_INFO *p8inf = NULL;
137
    const X509_ALGOR *alg = NULL;
138
    void *key = NULL;
139

140
    if ((p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, input_der, input_der_len)) != NULL
141
        && PKCS8_pkey_get0(NULL, NULL, NULL, &alg, p8inf)
142
        && (OBJ_obj2nid(alg->algorithm) == ctx->desc->evp_type
143
            /* Allow decoding sm2 private key with id_ecPublicKey */
144
            || (OBJ_obj2nid(alg->algorithm) == NID_X9_62_id_ecPublicKey
145
                && ctx->desc->evp_type == NID_sm2)))
146
        key = key_from_pkcs8(p8inf, PROV_LIBCTX_OF(ctx->provctx), ctx->propq);
147
    PKCS8_PRIV_KEY_INFO_free(p8inf);
148

149
    return key;
150
}
151

152
/* ---------------------------------------------------------------------- */
153

154
static OSSL_FUNC_decoder_freectx_fn der2key_freectx;
155
static OSSL_FUNC_decoder_decode_fn der2key_decode;
156
static OSSL_FUNC_decoder_export_object_fn der2key_export_object;
157
static OSSL_FUNC_decoder_settable_ctx_params_fn der2key_settable_ctx_params;
158
static OSSL_FUNC_decoder_set_ctx_params_fn der2key_set_ctx_params;
159

160
static struct der2key_ctx_st *
161
der2key_newctx(void *provctx, const struct keytype_desc_st *desc)
162
{
163
    struct der2key_ctx_st *ctx = OPENSSL_zalloc(sizeof(*ctx));
164

165
    if (ctx != NULL) {
166
        ctx->provctx = provctx;
167
        ctx->desc = desc;
168
    }
169
    return ctx;
170
}
171

172
static const OSSL_PARAM *der2key_settable_ctx_params(ossl_unused void *provctx)
173
{
174
    static const OSSL_PARAM settables[] = {
175
        OSSL_PARAM_utf8_string(OSSL_DECODER_PARAM_PROPERTIES, NULL, 0),
176
        OSSL_PARAM_END
177
    };
178
    return settables;
179
}
180

181
static int der2key_set_ctx_params(void *vctx, const OSSL_PARAM params[])
182
{
183
    struct der2key_ctx_st *ctx = vctx;
184
    const OSSL_PARAM *p;
185
    char *str = ctx->propq;
186

187
    p = OSSL_PARAM_locate_const(params, OSSL_DECODER_PARAM_PROPERTIES);
188
    if (p != NULL && !OSSL_PARAM_get_utf8_string(p, &str, sizeof(ctx->propq)))
189
        return 0;
190

191
    return 1;
192
}
193

194
static void der2key_freectx(void *vctx)
195
{
196
    struct der2key_ctx_st *ctx = vctx;
197

198
    OPENSSL_free(ctx);
199
}
200

201
static int der2key_check_selection(int selection,
202
                                   const struct keytype_desc_st *desc)
203
{
204
    /*
205
     * The selections are kinda sorta "levels", i.e. each selection given
206
     * here is assumed to include those following.
207
     */
208
    int checks[] = {
209
        OSSL_KEYMGMT_SELECT_PRIVATE_KEY,
210
        OSSL_KEYMGMT_SELECT_PUBLIC_KEY,
211
        OSSL_KEYMGMT_SELECT_ALL_PARAMETERS
212
    };
213
    size_t i;
214

215
    /* The decoder implementations made here support guessing */
216
    if (selection == 0)
217
        return 1;
218

219
    for (i = 0; i < OSSL_NELEM(checks); i++) {
220
        int check1 = (selection & checks[i]) != 0;
221
        int check2 = (desc->selection_mask & checks[i]) != 0;
222

223
        /*
224
         * If the caller asked for the currently checked bit(s), return
225
         * whether the decoder description says it's supported.
226
         */
227
        if (check1)
228
            return check2;
229
    }
230

231
    /* This should be dead code, but just to be safe... */
232
    return 0;
233
}
234

235
static int der2key_decode(void *vctx, OSSL_CORE_BIO *cin, int selection,
236
                          OSSL_CALLBACK *data_cb, void *data_cbarg,
237
                          OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
238
{
239
    struct der2key_ctx_st *ctx = vctx;
240
    unsigned char *der = NULL;
241
    const unsigned char *derp;
242
    long der_len = 0;
243
    void *key = NULL;
244
    int ok = 0;
245

246
    ctx->selection = selection;
247
    /*
248
     * The caller is allowed to specify 0 as a selection mask, to have the
249
     * structure and key type guessed.  For type-specific structures, this
250
     * is not recommended, as some structures are very similar.
251
     * Note that 0 isn't the same as OSSL_KEYMGMT_SELECT_ALL, as the latter
252
     * signifies a private key structure, where everything else is assumed
253
     * to be present as well.
254
     */
255
    if (selection == 0)
256
        selection = ctx->desc->selection_mask;
257
    if ((selection & ctx->desc->selection_mask) == 0) {
258
        ERR_raise(ERR_LIB_PROV, ERR_R_PASSED_INVALID_ARGUMENT);
259
        return 0;
260
    }
261

262
    ok = ossl_read_der(ctx->provctx, cin, &der, &der_len);
263
    if (!ok)
264
        goto next;
265

266
    ok = 0; /* Assume that we fail */
267

268
    ERR_set_mark();
269
    if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) {
270
        derp = der;
271
        if (ctx->desc->d2i_PKCS8 != NULL) {
272
            key = ctx->desc->d2i_PKCS8(&derp, der_len, ctx);
273
            if (ctx->flag_fatal) {
274
                ERR_clear_last_mark();
275
                goto end;
276
            }
277
        } else if (ctx->desc->d2i_private_key != NULL) {
278
            key = ctx->desc->d2i_private_key(NULL, &derp, der_len);
279
        }
280
        if (key == NULL && ctx->selection != 0) {
281
            ERR_clear_last_mark();
282
            goto next;
283
        }
284
    }
285
    if (key == NULL && (selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) {
286
        derp = der;
287
        if (ctx->desc->d2i_PUBKEY != NULL)
288
            key = ctx->desc->d2i_PUBKEY(&derp, der_len, ctx);
289
        else if (ctx->desc->d2i_public_key != NULL)
290
            key = ctx->desc->d2i_public_key(NULL, &derp, der_len);
291
        if (key == NULL && ctx->selection != 0) {
292
            ERR_clear_last_mark();
293
            goto next;
294
        }
295
    }
296
    if (key == NULL && (selection & OSSL_KEYMGMT_SELECT_ALL_PARAMETERS) != 0) {
297
        derp = der;
298
        if (ctx->desc->d2i_key_params != NULL)
299
            key = ctx->desc->d2i_key_params(NULL, &derp, der_len);
300
        if (key == NULL && ctx->selection != 0) {
301
            ERR_clear_last_mark();
302
            goto next;
303
        }
304
    }
305
    if (key == NULL)
306
        ERR_clear_last_mark();
307
    else
308
        ERR_pop_to_mark();
309

310
    /*
311
     * Last minute check to see if this was the correct type of key.  This
312
     * should never lead to a fatal error, i.e. the decoding itself was
313
     * correct, it was just an unexpected key type.  This is generally for
314
     * classes of key types that have subtle variants, like RSA-PSS keys as
315
     * opposed to plain RSA keys.
316
     */
317
    if (key != NULL
318
        && ctx->desc->check_key != NULL
319
        && !ctx->desc->check_key(key, ctx)) {
320
        ctx->desc->free_key(key);
321
        key = NULL;
322
    }
323

324
    if (key != NULL && ctx->desc->adjust_key != NULL)
325
        ctx->desc->adjust_key(key, ctx);
326

327
 next:
328
    /*
329
     * Indicated that we successfully decoded something, or not at all.
330
     * Ending up "empty handed" is not an error.
331
     */
332
    ok = 1;
333

334
    /*
335
     * We free memory here so it's not held up during the callback, because
336
     * we know the process is recursive and the allocated chunks of memory
337
     * add up.
338
     */
339
    OPENSSL_free(der);
340
    der = NULL;
341

342
    if (key != NULL) {
343
        OSSL_PARAM params[4];
344
        int object_type = OSSL_OBJECT_PKEY;
345

346
        params[0] =
347
            OSSL_PARAM_construct_int(OSSL_OBJECT_PARAM_TYPE, &object_type);
348

349
#ifndef OPENSSL_NO_SM2
350
        if (strcmp(ctx->desc->keytype_name, "EC") == 0
351
            && (EC_KEY_get_flags(key) & EC_FLAG_SM2_RANGE) != 0)
352
            params[1] =
353
                OSSL_PARAM_construct_utf8_string(OSSL_OBJECT_PARAM_DATA_TYPE,
354
                                                 "SM2", 0);
355
        else
356
#endif
357
            params[1] =
358
                OSSL_PARAM_construct_utf8_string(OSSL_OBJECT_PARAM_DATA_TYPE,
359
                                                 (char *)ctx->desc->keytype_name,
360
                                                 0);
361
        /* The address of the key becomes the octet string */
362
        params[2] =
363
            OSSL_PARAM_construct_octet_string(OSSL_OBJECT_PARAM_REFERENCE,
364
                                              &key, sizeof(key));
365
        params[3] = OSSL_PARAM_construct_end();
366

367
        ok = data_cb(params, data_cbarg);
368
    }
369

370
 end:
371
    ctx->desc->free_key(key);
372
    OPENSSL_free(der);
373

374
    return ok;
375
}
376

377
static int der2key_export_object(void *vctx,
378
                                 const void *reference, size_t reference_sz,
379
                                 OSSL_CALLBACK *export_cb, void *export_cbarg)
380
{
381
    struct der2key_ctx_st *ctx = vctx;
382
    OSSL_FUNC_keymgmt_export_fn *export =
383
        ossl_prov_get_keymgmt_export(ctx->desc->fns);
384
    void *keydata;
385

386
    if (reference_sz == sizeof(keydata) && export != NULL) {
387
        int selection = ctx->selection;
388

389
        if (selection == 0)
390
            selection = OSSL_KEYMGMT_SELECT_ALL;
391
        /* The contents of the reference is the address to our object */
392
        keydata = *(void **)reference;
393

394
        return export(keydata, selection, export_cb, export_cbarg);
395
    }
396
    return 0;
397
}
398

399
#define D2I_PUBKEY_NOCTX(n, f)                              \
400
    static void *                                           \
401
    n##_d2i_PUBKEY(const unsigned char **der, long der_len, \
402
                   ossl_unused struct der2key_ctx_st *ctx)  \
403
    {                                                       \
404
        return f(NULL, der, der_len);                       \
405
    }
406

407
/* ---------------------------------------------------------------------- */
408

409
#ifndef OPENSSL_NO_DH
410
# define dh_evp_type                    EVP_PKEY_DH
411
# define dh_d2i_private_key             NULL
412
# define dh_d2i_public_key              NULL
413
# define dh_d2i_key_params              (d2i_of_void *)d2i_DHparams
414
# define dh_free                        (free_key_fn *)DH_free
415
# define dh_check                       NULL
416

417
static void *dh_d2i_PKCS8(const unsigned char **der, long der_len,
418
                          struct der2key_ctx_st *ctx)
419
{
420
    return der2key_decode_p8(der, der_len, ctx,
421
                             (key_from_pkcs8_t *)ossl_dh_key_from_pkcs8);
422
}
423

424
D2I_PUBKEY_NOCTX(dh, ossl_d2i_DH_PUBKEY)
425
D2I_PUBKEY_NOCTX(dhx, ossl_d2i_DHx_PUBKEY)
426

427
static void dh_adjust(void *key, struct der2key_ctx_st *ctx)
428
{
429
    ossl_dh_set0_libctx(key, PROV_LIBCTX_OF(ctx->provctx));
430
}
431

432
# define dhx_evp_type                   EVP_PKEY_DHX
433
# define dhx_d2i_private_key            NULL
434
# define dhx_d2i_public_key             NULL
435
# define dhx_d2i_key_params             (d2i_of_void *)d2i_DHxparams
436
# define dhx_d2i_PKCS8                  dh_d2i_PKCS8
437
# define dhx_free                       (free_key_fn *)DH_free
438
# define dhx_check                      NULL
439
# define dhx_adjust                     dh_adjust
440
#endif
441

442
/* ---------------------------------------------------------------------- */
443

444
#ifndef OPENSSL_NO_DSA
445
# define dsa_evp_type                   EVP_PKEY_DSA
446
# define dsa_d2i_private_key            (d2i_of_void *)d2i_DSAPrivateKey
447
# define dsa_d2i_public_key             (d2i_of_void *)d2i_DSAPublicKey
448
# define dsa_d2i_key_params             (d2i_of_void *)d2i_DSAparams
449
# define dsa_free                       (free_key_fn *)DSA_free
450
# define dsa_check                      NULL
451

452
static void *dsa_d2i_PKCS8(const unsigned char **der, long der_len,
453
                           struct der2key_ctx_st *ctx)
454
{
455
    return der2key_decode_p8(der, der_len, ctx,
456
                             (key_from_pkcs8_t *)ossl_dsa_key_from_pkcs8);
457
}
458

459
D2I_PUBKEY_NOCTX(dsa, ossl_d2i_DSA_PUBKEY)
460

461
static void dsa_adjust(void *key, struct der2key_ctx_st *ctx)
462
{
463
    ossl_dsa_set0_libctx(key, PROV_LIBCTX_OF(ctx->provctx));
464
}
465
#endif
466

467
/* ---------------------------------------------------------------------- */
468

469
#ifndef OPENSSL_NO_EC
470
# define ec_evp_type                    EVP_PKEY_EC
471
# define ec_d2i_private_key             (d2i_of_void *)d2i_ECPrivateKey
472
# define ec_d2i_public_key              NULL
473
# define ec_d2i_key_params              (d2i_of_void *)d2i_ECParameters
474
# define ec_free                        (free_key_fn *)EC_KEY_free
475

476
static void *ec_d2i_PKCS8(const unsigned char **der, long der_len,
477
                          struct der2key_ctx_st *ctx)
478
{
479
    return der2key_decode_p8(der, der_len, ctx,
480
                             (key_from_pkcs8_t *)ossl_ec_key_from_pkcs8);
481
}
482

483
D2I_PUBKEY_NOCTX(ec, d2i_EC_PUBKEY)
484

485
static int ec_check(void *key, struct der2key_ctx_st *ctx)
486
{
487
    /* We're trying to be clever by comparing two truths */
488
    int ret = 0;
489
    int sm2 = (EC_KEY_get_flags(key) & EC_FLAG_SM2_RANGE) != 0;
490

491
    if (sm2)
492
        ret = ctx->desc->evp_type == EVP_PKEY_SM2
493
            || ctx->desc->evp_type == NID_X9_62_id_ecPublicKey;
494
    else
495
        ret = ctx->desc->evp_type != EVP_PKEY_SM2;
496

497
    return ret;
498
}
499

500
static void ec_adjust(void *key, struct der2key_ctx_st *ctx)
501
{
502
    ossl_ec_key_set0_libctx(key, PROV_LIBCTX_OF(ctx->provctx));
503
}
504

505
# ifndef OPENSSL_NO_ECX
506
/*
507
 * ED25519, ED448, X25519, X448 only implement PKCS#8 and SubjectPublicKeyInfo,
508
 * so no d2i functions to be had.
509
 */
510

511
static void *ecx_d2i_PKCS8(const unsigned char **der, long der_len,
512
                           struct der2key_ctx_st *ctx)
513
{
514
    return der2key_decode_p8(der, der_len, ctx,
515
                             (key_from_pkcs8_t *)ossl_ecx_key_from_pkcs8);
516
}
517

518
D2I_PUBKEY_NOCTX(ed25519, ossl_d2i_ED25519_PUBKEY)
519
D2I_PUBKEY_NOCTX(ed448, ossl_d2i_ED448_PUBKEY)
520
D2I_PUBKEY_NOCTX(x25519, ossl_d2i_X25519_PUBKEY)
521
D2I_PUBKEY_NOCTX(x448, ossl_d2i_X448_PUBKEY)
522

523
static void ecx_key_adjust(void *key, struct der2key_ctx_st *ctx)
524
{
525
    ossl_ecx_key_set0_libctx(key, PROV_LIBCTX_OF(ctx->provctx));
526
}
527

528
#  define ed25519_evp_type               EVP_PKEY_ED25519
529
#  define ed25519_d2i_private_key        NULL
530
#  define ed25519_d2i_public_key         NULL
531
#  define ed25519_d2i_key_params         NULL
532
#  define ed25519_d2i_PKCS8              ecx_d2i_PKCS8
533
#  define ed25519_free                   (free_key_fn *)ossl_ecx_key_free
534
#  define ed25519_check                  NULL
535
#  define ed25519_adjust                 ecx_key_adjust
536

537
#  define ed448_evp_type                 EVP_PKEY_ED448
538
#  define ed448_d2i_private_key          NULL
539
#  define ed448_d2i_public_key           NULL
540
#  define ed448_d2i_key_params           NULL
541
#  define ed448_d2i_PKCS8                ecx_d2i_PKCS8
542
#  define ed448_free                     (free_key_fn *)ossl_ecx_key_free
543
#  define ed448_check                    NULL
544
#  define ed448_adjust                   ecx_key_adjust
545

546
#  define x25519_evp_type                EVP_PKEY_X25519
547
#  define x25519_d2i_private_key         NULL
548
#  define x25519_d2i_public_key          NULL
549
#  define x25519_d2i_key_params          NULL
550
#  define x25519_d2i_PKCS8               ecx_d2i_PKCS8
551
#  define x25519_free                    (free_key_fn *)ossl_ecx_key_free
552
#  define x25519_check                   NULL
553
#  define x25519_adjust                  ecx_key_adjust
554

555
#  define x448_evp_type                  EVP_PKEY_X448
556
#  define x448_d2i_private_key           NULL
557
#  define x448_d2i_public_key            NULL
558
#  define x448_d2i_key_params            NULL
559
#  define x448_d2i_PKCS8                 ecx_d2i_PKCS8
560
#  define x448_free                      (free_key_fn *)ossl_ecx_key_free
561
#  define x448_check                     NULL
562
#  define x448_adjust                    ecx_key_adjust
563
# endif /* OPENSSL_NO_ECX */
564

565
# ifndef OPENSSL_NO_SM2
566
#  define sm2_evp_type                  EVP_PKEY_SM2
567
#  define sm2_d2i_private_key           (d2i_of_void *)d2i_ECPrivateKey
568
#  define sm2_d2i_public_key            NULL
569
#  define sm2_d2i_key_params            (d2i_of_void *)d2i_ECParameters
570
#  define sm2_d2i_PUBKEY                ec_d2i_PUBKEY
571
#  define sm2_free                      (free_key_fn *)EC_KEY_free
572
#  define sm2_check                     ec_check
573
#  define sm2_adjust                    ec_adjust
574

575
static void *sm2_d2i_PKCS8(const unsigned char **der, long der_len,
576
                           struct der2key_ctx_st *ctx)
577
{
578
    return der2key_decode_p8(der, der_len, ctx,
579
                             (key_from_pkcs8_t *)ossl_ec_key_from_pkcs8);
580
}
581
# endif
582

583
#endif
584

585
/* ---------------------------------------------------------------------- */
586

587
#ifndef OPENSSL_NO_ML_KEM
588
static void *
589
ml_kem_d2i_PKCS8(const uint8_t **der, long der_len, struct der2key_ctx_st *ctx)
590
{
591
    ML_KEM_KEY *key;
592

593
    key = ossl_ml_kem_d2i_PKCS8(*der, der_len, ctx->desc->evp_type,
594
                                ctx->provctx, ctx->propq);
595
    if (key != NULL)
596
        *der += der_len;
597
    return key;
598
}
599

600
static ossl_inline void *
601
ml_kem_d2i_PUBKEY(const uint8_t **der, long der_len,
602
                  struct der2key_ctx_st *ctx)
603
{
604
    ML_KEM_KEY *key;
605

606
    key = ossl_ml_kem_d2i_PUBKEY(*der, der_len, ctx->desc->evp_type,
607
                                 ctx->provctx, ctx->propq);
608
    if (key != NULL)
609
        *der += der_len;
610
    return key;
611
}
612

613
# define ml_kem_512_evp_type                EVP_PKEY_ML_KEM_512
614
# define ml_kem_512_d2i_private_key         NULL
615
# define ml_kem_512_d2i_public_key          NULL
616
# define ml_kem_512_d2i_key_params          NULL
617
# define ml_kem_512_d2i_PUBKEY              ml_kem_d2i_PUBKEY
618
# define ml_kem_512_d2i_PKCS8               ml_kem_d2i_PKCS8
619
# define ml_kem_512_free                    (free_key_fn *)ossl_ml_kem_key_free
620
# define ml_kem_512_check                   NULL
621
# define ml_kem_512_adjust                  NULL
622

623
# define ml_kem_768_evp_type                EVP_PKEY_ML_KEM_768
624
# define ml_kem_768_d2i_private_key         NULL
625
# define ml_kem_768_d2i_public_key          NULL
626
# define ml_kem_768_d2i_key_params          NULL
627
# define ml_kem_768_d2i_PUBKEY              ml_kem_d2i_PUBKEY
628
# define ml_kem_768_d2i_PKCS8               ml_kem_d2i_PKCS8
629
# define ml_kem_768_free                    (free_key_fn *)ossl_ml_kem_key_free
630
# define ml_kem_768_check                   NULL
631
# define ml_kem_768_adjust                  NULL
632

633
# define ml_kem_1024_evp_type               EVP_PKEY_ML_KEM_1024
634
# define ml_kem_1024_d2i_private_key        NULL
635
# define ml_kem_1024_d2i_public_key         NULL
636
# define ml_kem_1024_d2i_PUBKEY             ml_kem_d2i_PUBKEY
637
# define ml_kem_1024_d2i_PKCS8              ml_kem_d2i_PKCS8
638
# define ml_kem_1024_d2i_key_params         NULL
639
# define ml_kem_1024_free                   (free_key_fn *)ossl_ml_kem_key_free
640
# define ml_kem_1024_check                  NULL
641
# define ml_kem_1024_adjust                 NULL
642

643
#endif
644

645
#ifndef OPENSSL_NO_SLH_DSA
646
static void *
647
slh_dsa_d2i_PKCS8(const uint8_t **der, long der_len, struct der2key_ctx_st *ctx)
648
{
649
    SLH_DSA_KEY *key = NULL, *ret = NULL;
650
    OSSL_LIB_CTX *libctx = PROV_LIBCTX_OF(ctx->provctx);
651
    PKCS8_PRIV_KEY_INFO *p8inf = NULL;
652
    const unsigned char *p;
653
    const X509_ALGOR *alg = NULL;
654
    int plen, ptype;
655

656
    if ((p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, der, der_len)) == NULL
657
        || !PKCS8_pkey_get0(NULL, &p, &plen, &alg, p8inf))
658
        goto end;
659

660
    /* Algorithm parameters must be absent. */
661
    if ((X509_ALGOR_get0(NULL, &ptype, NULL, alg), ptype != V_ASN1_UNDEF)) {
662
        ERR_raise_data(ERR_LIB_PROV, PROV_R_UNEXPECTED_KEY_PARAMETERS,
663
                       "unexpected parameters with a PKCS#8 %s private key",
664
                       ctx->desc->keytype_name);
665
        goto end;
666
    }
667
    if (OBJ_obj2nid(alg->algorithm) != ctx->desc->evp_type)
668
        goto end;
669
    if ((key = ossl_slh_dsa_key_new(libctx, ctx->propq,
670
                                    ctx->desc->keytype_name)) == NULL)
671
        goto end;
672

673
    if (!ossl_slh_dsa_set_priv(key, p, plen))
674
        goto end;
675
    ret = key;
676
 end:
677
    PKCS8_PRIV_KEY_INFO_free(p8inf);
678
    if (ret == NULL)
679
        ossl_slh_dsa_key_free(key);
680
    return ret;
681
}
682

683
static ossl_inline void *slh_dsa_d2i_PUBKEY(const uint8_t **der, long der_len,
684
                                            struct der2key_ctx_st *ctx)
685
{
686
    int ok = 0;
687
    OSSL_LIB_CTX *libctx = PROV_LIBCTX_OF(ctx->provctx);
688
    SLH_DSA_KEY *ret = NULL;
689
    BARE_PUBKEY *spki = NULL;
690
    const uint8_t *end = *der;
691
    size_t len;
692

693
    ret = ossl_slh_dsa_key_new(libctx, ctx->propq, ctx->desc->keytype_name);
694
    if (ret == NULL)
695
        return NULL;
696
    len = ossl_slh_dsa_key_get_pub_len(ret);
697

698
    /*-
699
     * The DER ASN.1 encoding of SLH-DSA public keys prepends 18 bytes to the
700
     * encoded public key (since the largest public key size is 64 bytes):
701
     *
702
     * - 2 byte outer sequence tag and length
703
     * -  2 byte algorithm sequence tag and length
704
     * -    2 byte algorithm OID tag and length
705
     * -      9 byte algorithm OID
706
     * -  2 byte bit string tag and length
707
     * -    1 bitstring lead byte
708
     *
709
     * Check that we have the right OID, the bit string has no "bits left" and
710
     * that we consume all the input exactly.
711
     */
712
    if (der_len != 18 + (long)len) {
713
        ERR_raise_data(ERR_LIB_PROV, PROV_R_BAD_ENCODING,
714
                       "unexpected %s public key length: %ld != %ld",
715
                       ctx->desc->keytype_name, der_len,
716
                       18 + (long)len);
717
        goto err;
718
    }
719

720
    if ((spki = OPENSSL_zalloc(sizeof(*spki))) == NULL)
721
        goto err;
722

723
    /* The spki storage is freed on error */
724
    if (ASN1_item_d2i_ex((ASN1_VALUE **)&spki, &end, der_len,
725
                         ASN1_ITEM_rptr(BARE_PUBKEY), NULL, NULL) == NULL) {
726
        ERR_raise_data(ERR_LIB_PROV, PROV_R_BAD_ENCODING,
727
                       "malformed %s public key ASN.1 encoding",
728
                       ossl_slh_dsa_key_get_name(ret));
729
        goto err;
730
    }
731

732
    /* The spki structure now owns some memory */
733
    if ((spki->pubkey->flags & 0x7) != 0 || end != *der + der_len) {
734
        ERR_raise_data(ERR_LIB_PROV, PROV_R_BAD_ENCODING,
735
                       "malformed %s public key ASN.1 encoding",
736
                       ossl_slh_dsa_key_get_name(ret));
737
        goto err;
738
    }
739
    if (OBJ_cmp(OBJ_nid2obj(ctx->desc->evp_type), spki->algor.oid) != 0) {
740
        ERR_raise_data(ERR_LIB_PROV, PROV_R_BAD_ENCODING,
741
                       "unexpected algorithm OID for an %s public key",
742
                       ossl_slh_dsa_key_get_name(ret));
743
        goto err;
744
    }
745

746
    if (!ossl_slh_dsa_set_pub(ret, spki->pubkey->data, spki->pubkey->length)) {
747
        ERR_raise_data(ERR_LIB_PROV, PROV_R_BAD_ENCODING,
748
                       "failed to parse %s public key from the input data",
749
                       ossl_slh_dsa_key_get_name(ret));
750
        goto err;
751
    }
752
    ok = 1;
753
 err:
754
    if (spki != NULL) {
755
        ASN1_OBJECT_free(spki->algor.oid);
756
        ASN1_BIT_STRING_free(spki->pubkey);
757
        OPENSSL_free(spki);
758
    }
759
    if (!ok) {
760
        ossl_slh_dsa_key_free(ret);
761
        ret = NULL;
762
    }
763
    return ret;
764
}
765

766
# define slh_dsa_sha2_128s_evp_type        EVP_PKEY_SLH_DSA_SHA2_128S
767
# define slh_dsa_sha2_128s_d2i_private_key NULL
768
# define slh_dsa_sha2_128s_d2i_public_key  NULL
769
# define slh_dsa_sha2_128s_d2i_key_params  NULL
770
# define slh_dsa_sha2_128s_d2i_PKCS8       slh_dsa_d2i_PKCS8
771
# define slh_dsa_sha2_128s_d2i_PUBKEY      slh_dsa_d2i_PUBKEY
772
# define slh_dsa_sha2_128s_free            (free_key_fn *)ossl_slh_dsa_key_free
773
# define slh_dsa_sha2_128s_check           NULL
774
# define slh_dsa_sha2_128s_adjust          NULL
775

776
# define slh_dsa_sha2_128f_evp_type        EVP_PKEY_SLH_DSA_SHA2_128F
777
# define slh_dsa_sha2_128f_d2i_private_key NULL
778
# define slh_dsa_sha2_128f_d2i_public_key  NULL
779
# define slh_dsa_sha2_128f_d2i_key_params  NULL
780
# define slh_dsa_sha2_128f_d2i_PKCS8       slh_dsa_d2i_PKCS8
781
# define slh_dsa_sha2_128f_d2i_PUBKEY      slh_dsa_d2i_PUBKEY
782
# define slh_dsa_sha2_128f_free            (free_key_fn *)ossl_slh_dsa_key_free
783
# define slh_dsa_sha2_128f_check           NULL
784
# define slh_dsa_sha2_128f_adjust          NULL
785

786
# define slh_dsa_sha2_192s_evp_type        EVP_PKEY_SLH_DSA_SHA2_192S
787
# define slh_dsa_sha2_192s_d2i_private_key NULL
788
# define slh_dsa_sha2_192s_d2i_public_key  NULL
789
# define slh_dsa_sha2_192s_d2i_key_params  NULL
790
# define slh_dsa_sha2_192s_d2i_PKCS8       slh_dsa_d2i_PKCS8
791
# define slh_dsa_sha2_192s_d2i_PUBKEY      slh_dsa_d2i_PUBKEY
792
# define slh_dsa_sha2_192s_free            (free_key_fn *)ossl_slh_dsa_key_free
793
# define slh_dsa_sha2_192s_check           NULL
794
# define slh_dsa_sha2_192s_adjust          NULL
795

796
# define slh_dsa_sha2_192f_evp_type        EVP_PKEY_SLH_DSA_SHA2_192F
797
# define slh_dsa_sha2_192f_d2i_private_key NULL
798
# define slh_dsa_sha2_192f_d2i_public_key  NULL
799
# define slh_dsa_sha2_192f_d2i_key_params  NULL
800
# define slh_dsa_sha2_192f_d2i_PKCS8       slh_dsa_d2i_PKCS8
801
# define slh_dsa_sha2_192f_d2i_PUBKEY      slh_dsa_d2i_PUBKEY
802
# define slh_dsa_sha2_192f_free            (free_key_fn *)ossl_slh_dsa_key_free
803
# define slh_dsa_sha2_192f_check           NULL
804
# define slh_dsa_sha2_192f_adjust          NULL
805

806
# define slh_dsa_sha2_256s_evp_type        EVP_PKEY_SLH_DSA_SHA2_256S
807
# define slh_dsa_sha2_256s_d2i_private_key NULL
808
# define slh_dsa_sha2_256s_d2i_public_key  NULL
809
# define slh_dsa_sha2_256s_d2i_key_params  NULL
810
# define slh_dsa_sha2_256s_d2i_PKCS8       slh_dsa_d2i_PKCS8
811
# define slh_dsa_sha2_256s_d2i_PUBKEY      slh_dsa_d2i_PUBKEY
812
# define slh_dsa_sha2_256s_free            (free_key_fn *)ossl_slh_dsa_key_free
813
# define slh_dsa_sha2_256s_check           NULL
814
# define slh_dsa_sha2_256s_adjust          NULL
815

816
# define slh_dsa_sha2_256f_evp_type        EVP_PKEY_SLH_DSA_SHA2_256F
817
# define slh_dsa_sha2_256f_d2i_private_key NULL
818
# define slh_dsa_sha2_256f_d2i_public_key  NULL
819
# define slh_dsa_sha2_256f_d2i_key_params  NULL
820
# define slh_dsa_sha2_256f_d2i_PKCS8       slh_dsa_d2i_PKCS8
821
# define slh_dsa_sha2_256f_d2i_PUBKEY      slh_dsa_d2i_PUBKEY
822
# define slh_dsa_sha2_256f_free            (free_key_fn *)ossl_slh_dsa_key_free
823
# define slh_dsa_sha2_256f_check           NULL
824
# define slh_dsa_sha2_256f_adjust          NULL
825

826
# define slh_dsa_shake_128s_evp_type        EVP_PKEY_SLH_DSA_SHAKE_128S
827
# define slh_dsa_shake_128s_d2i_private_key NULL
828
# define slh_dsa_shake_128s_d2i_public_key  NULL
829
# define slh_dsa_shake_128s_d2i_key_params  NULL
830
# define slh_dsa_shake_128s_d2i_PKCS8       slh_dsa_d2i_PKCS8
831
# define slh_dsa_shake_128s_d2i_PUBKEY      slh_dsa_d2i_PUBKEY
832
# define slh_dsa_shake_128s_free            (free_key_fn *)ossl_slh_dsa_key_free
833
# define slh_dsa_shake_128s_check           NULL
834
# define slh_dsa_shake_128s_adjust          NULL
835

836
# define slh_dsa_shake_128f_evp_type        EVP_PKEY_SLH_DSA_SHAKE_128F
837
# define slh_dsa_shake_128f_d2i_private_key NULL
838
# define slh_dsa_shake_128f_d2i_public_key  NULL
839
# define slh_dsa_shake_128f_d2i_key_params  NULL
840
# define slh_dsa_shake_128f_d2i_PKCS8       slh_dsa_d2i_PKCS8
841
# define slh_dsa_shake_128f_d2i_PUBKEY      slh_dsa_d2i_PUBKEY
842
# define slh_dsa_shake_128f_free            (free_key_fn *)ossl_slh_dsa_key_free
843
# define slh_dsa_shake_128f_check           NULL
844
# define slh_dsa_shake_128f_adjust          NULL
845

846
# define slh_dsa_shake_192s_evp_type        EVP_PKEY_SLH_DSA_SHAKE_192S
847
# define slh_dsa_shake_192s_d2i_private_key NULL
848
# define slh_dsa_shake_192s_d2i_public_key  NULL
849
# define slh_dsa_shake_192s_d2i_key_params  NULL
850
# define slh_dsa_shake_192s_d2i_PKCS8       slh_dsa_d2i_PKCS8
851
# define slh_dsa_shake_192s_d2i_PUBKEY      slh_dsa_d2i_PUBKEY
852
# define slh_dsa_shake_192s_free            (free_key_fn *)ossl_slh_dsa_key_free
853
# define slh_dsa_shake_192s_check           NULL
854
# define slh_dsa_shake_192s_adjust          NULL
855

856
# define slh_dsa_shake_192f_evp_type        EVP_PKEY_SLH_DSA_SHAKE_192F
857
# define slh_dsa_shake_192f_d2i_private_key NULL
858
# define slh_dsa_shake_192f_d2i_public_key  NULL
859
# define slh_dsa_shake_192f_d2i_key_params  NULL
860
# define slh_dsa_shake_192f_d2i_PKCS8       slh_dsa_d2i_PKCS8
861
# define slh_dsa_shake_192f_d2i_PUBKEY      slh_dsa_d2i_PUBKEY
862
# define slh_dsa_shake_192f_free            (free_key_fn *)ossl_slh_dsa_key_free
863
# define slh_dsa_shake_192f_check           NULL
864
# define slh_dsa_shake_192f_adjust          NULL
865

866
# define slh_dsa_shake_256s_evp_type        EVP_PKEY_SLH_DSA_SHAKE_256S
867
# define slh_dsa_shake_256s_d2i_private_key NULL
868
# define slh_dsa_shake_256s_d2i_public_key  NULL
869
# define slh_dsa_shake_256s_d2i_key_params  NULL
870
# define slh_dsa_shake_256s_d2i_PKCS8       slh_dsa_d2i_PKCS8
871
# define slh_dsa_shake_256s_d2i_PUBKEY      slh_dsa_d2i_PUBKEY
872
# define slh_dsa_shake_256s_free            (free_key_fn *)ossl_slh_dsa_key_free
873
# define slh_dsa_shake_256s_check           NULL
874
# define slh_dsa_shake_256s_adjust          NULL
875

876
# define slh_dsa_shake_256f_evp_type        EVP_PKEY_SLH_DSA_SHAKE_256F
877
# define slh_dsa_shake_256f_d2i_private_key NULL
878
# define slh_dsa_shake_256f_d2i_public_key  NULL
879
# define slh_dsa_shake_256f_d2i_key_params  NULL
880
# define slh_dsa_shake_256f_d2i_PKCS8       slh_dsa_d2i_PKCS8
881
# define slh_dsa_shake_256f_d2i_PUBKEY      slh_dsa_d2i_PUBKEY
882
# define slh_dsa_shake_256f_free            (free_key_fn *)ossl_slh_dsa_key_free
883
# define slh_dsa_shake_256f_check           NULL
884
# define slh_dsa_shake_256f_adjust          NULL
885
#endif /* OPENSSL_NO_SLH_DSA */
886

887
/* ---------------------------------------------------------------------- */
888

889
#define rsa_evp_type                    EVP_PKEY_RSA
890
#define rsa_d2i_private_key             (d2i_of_void *)d2i_RSAPrivateKey
891
#define rsa_d2i_public_key              (d2i_of_void *)d2i_RSAPublicKey
892
#define rsa_d2i_key_params              NULL
893
#define rsa_free                        (free_key_fn *)RSA_free
894

895
static void *rsa_d2i_PKCS8(const unsigned char **der, long der_len,
896
                           struct der2key_ctx_st *ctx)
897
{
898
    return der2key_decode_p8(der, der_len, ctx,
899
                             (key_from_pkcs8_t *)ossl_rsa_key_from_pkcs8);
900
}
901

902
static void *
903
rsa_d2i_PUBKEY(const unsigned char **der, long der_len,
904
               ossl_unused struct der2key_ctx_st *ctx)
905
{
906
    return d2i_RSA_PUBKEY(NULL, der, der_len);
907
}
908

909
static int rsa_check(void *key, struct der2key_ctx_st *ctx)
910
{
911
    int valid;
912

913
    switch (RSA_test_flags(key, RSA_FLAG_TYPE_MASK)) {
914
    case RSA_FLAG_TYPE_RSA:
915
        valid = (ctx->desc->evp_type == EVP_PKEY_RSA);
916
        break;
917
    case RSA_FLAG_TYPE_RSASSAPSS:
918
        valid = (ctx->desc->evp_type == EVP_PKEY_RSA_PSS);
919
        break;
920
    default:
921
        /* Currently unsupported RSA key type */
922
        valid = 0;
923
    }
924

925
    valid = (valid && ossl_rsa_check_factors(key));
926

927
    return valid;
928
}
929

930
static void rsa_adjust(void *key, struct der2key_ctx_st *ctx)
931
{
932
    ossl_rsa_set0_libctx(key, PROV_LIBCTX_OF(ctx->provctx));
933
}
934

935
#define rsapss_evp_type                 EVP_PKEY_RSA_PSS
936
#define rsapss_d2i_private_key          (d2i_of_void *)d2i_RSAPrivateKey
937
#define rsapss_d2i_public_key           (d2i_of_void *)d2i_RSAPublicKey
938
#define rsapss_d2i_key_params           NULL
939
#define rsapss_d2i_PKCS8                rsa_d2i_PKCS8
940
#define rsapss_d2i_PUBKEY               rsa_d2i_PUBKEY
941
#define rsapss_free                     (free_key_fn *)RSA_free
942
#define rsapss_check                    rsa_check
943
#define rsapss_adjust                   rsa_adjust
944

945
/* ---------------------------------------------------------------------- */
946

947
#ifndef OPENSSL_NO_ML_DSA
948
static void *
949
ml_dsa_d2i_PKCS8(const uint8_t **der, long der_len, struct der2key_ctx_st *ctx)
950
{
951
    ML_DSA_KEY *key;
952

953
    key = ossl_ml_dsa_d2i_PKCS8(*der, der_len, ctx->desc->evp_type,
954
                                ctx->provctx, ctx->propq);
955
    if (key != NULL)
956
        *der += der_len;
957
    return key;
958
}
959

960
static ossl_inline void * ml_dsa_d2i_PUBKEY(const uint8_t **der, long der_len,
961
                                            struct der2key_ctx_st *ctx)
962
{
963
    ML_DSA_KEY *key;
964

965
    key = ossl_ml_dsa_d2i_PUBKEY(*der, der_len, ctx->desc->evp_type,
966
                                 ctx->provctx, ctx->propq);
967
    if (key != NULL)
968
        *der += der_len;
969
    return key;
970
}
971

972
# define ml_dsa_44_evp_type                EVP_PKEY_ML_DSA_44
973
# define ml_dsa_44_d2i_private_key         NULL
974
# define ml_dsa_44_d2i_public_key          NULL
975
# define ml_dsa_44_d2i_key_params          NULL
976
# define ml_dsa_44_d2i_PUBKEY              ml_dsa_d2i_PUBKEY
977
# define ml_dsa_44_d2i_PKCS8               ml_dsa_d2i_PKCS8
978
# define ml_dsa_44_free                    (free_key_fn *)ossl_ml_dsa_key_free
979
# define ml_dsa_44_check                   NULL
980
# define ml_dsa_44_adjust                  NULL
981

982
# define ml_dsa_65_evp_type                EVP_PKEY_ML_DSA_65
983
# define ml_dsa_65_d2i_private_key         NULL
984
# define ml_dsa_65_d2i_public_key          NULL
985
# define ml_dsa_65_d2i_key_params          NULL
986
# define ml_dsa_65_d2i_PUBKEY              ml_dsa_d2i_PUBKEY
987
# define ml_dsa_65_d2i_PKCS8               ml_dsa_d2i_PKCS8
988
# define ml_dsa_65_free                    (free_key_fn *)ossl_ml_dsa_key_free
989
# define ml_dsa_65_check                   NULL
990
# define ml_dsa_65_adjust                  NULL
991

992
# define ml_dsa_87_evp_type               EVP_PKEY_ML_DSA_87
993
# define ml_dsa_87_d2i_private_key        NULL
994
# define ml_dsa_87_d2i_public_key         NULL
995
# define ml_dsa_87_d2i_PUBKEY             ml_dsa_d2i_PUBKEY
996
# define ml_dsa_87_d2i_PKCS8              ml_dsa_d2i_PKCS8
997
# define ml_dsa_87_d2i_key_params         NULL
998
# define ml_dsa_87_free                   (free_key_fn *)ossl_ml_dsa_key_free
999
# define ml_dsa_87_check                  NULL
1000
# define ml_dsa_87_adjust                 NULL
1001

1002
#endif
1003

1004
/* ---------------------------------------------------------------------- */
1005

1006
/*
1007
 * The DO_ macros help define the selection mask and the method functions
1008
 * for each kind of object we want to decode.
1009
 */
1010
#define DO_type_specific_keypair(keytype)               \
1011
    "type-specific", keytype##_evp_type,                \
1012
        ( OSSL_KEYMGMT_SELECT_KEYPAIR ),                \
1013
        keytype##_d2i_private_key,                      \
1014
        keytype##_d2i_public_key,                       \
1015
        NULL,                                           \
1016
        NULL,                                           \
1017
        NULL,                                           \
1018
        keytype##_check,                                \
1019
        keytype##_adjust,                               \
1020
        keytype##_free
1021

1022
#define DO_type_specific_pub(keytype)                   \
1023
    "type-specific", keytype##_evp_type,                \
1024
        ( OSSL_KEYMGMT_SELECT_PUBLIC_KEY ),             \
1025
        NULL,                                           \
1026
        keytype##_d2i_public_key,                       \
1027
        NULL,                                           \
1028
        NULL,                                           \
1029
        NULL,                                           \
1030
        keytype##_check,                                \
1031
        keytype##_adjust,                               \
1032
        keytype##_free
1033

1034
#define DO_type_specific_priv(keytype)                  \
1035
    "type-specific", keytype##_evp_type,                \
1036
        ( OSSL_KEYMGMT_SELECT_PRIVATE_KEY ),            \
1037
        keytype##_d2i_private_key,                      \
1038
        NULL,                                           \
1039
        NULL,                                           \
1040
        NULL,                                           \
1041
        NULL,                                           \
1042
        keytype##_check,                                \
1043
        keytype##_adjust,                               \
1044
        keytype##_free
1045

1046
#define DO_type_specific_params(keytype)                \
1047
    "type-specific", keytype##_evp_type,                \
1048
        ( OSSL_KEYMGMT_SELECT_ALL_PARAMETERS ),         \
1049
        NULL,                                           \
1050
        NULL,                                           \
1051
        keytype##_d2i_key_params,                       \
1052
        NULL,                                           \
1053
        NULL,                                           \
1054
        keytype##_check,                                \
1055
        keytype##_adjust,                               \
1056
        keytype##_free
1057

1058
#define DO_type_specific(keytype)                       \
1059
    "type-specific", keytype##_evp_type,                \
1060
        ( OSSL_KEYMGMT_SELECT_ALL ),                    \
1061
        keytype##_d2i_private_key,                      \
1062
        keytype##_d2i_public_key,                       \
1063
        keytype##_d2i_key_params,                       \
1064
        NULL,                                           \
1065
        NULL,                                           \
1066
        keytype##_check,                                \
1067
        keytype##_adjust,                               \
1068
        keytype##_free
1069

1070
#define DO_type_specific_no_pub(keytype)                \
1071
    "type-specific", keytype##_evp_type,                \
1072
        ( OSSL_KEYMGMT_SELECT_PRIVATE_KEY               \
1073
          | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS ),       \
1074
        keytype##_d2i_private_key,                      \
1075
        NULL,                                           \
1076
        keytype##_d2i_key_params,                       \
1077
        NULL,                                           \
1078
        NULL,                                           \
1079
        keytype##_check,                                \
1080
        keytype##_adjust,                               \
1081
        keytype##_free
1082

1083
#define DO_PrivateKeyInfo(keytype)                      \
1084
    "PrivateKeyInfo", keytype##_evp_type,               \
1085
        ( OSSL_KEYMGMT_SELECT_PRIVATE_KEY ),            \
1086
        NULL,                                           \
1087
        NULL,                                           \
1088
        NULL,                                           \
1089
        keytype##_d2i_PKCS8,                            \
1090
        NULL,                                           \
1091
        keytype##_check,                                \
1092
        keytype##_adjust,                               \
1093
        keytype##_free
1094

1095
#define DO_SubjectPublicKeyInfo(keytype)                \
1096
    "SubjectPublicKeyInfo", keytype##_evp_type,         \
1097
        ( OSSL_KEYMGMT_SELECT_PUBLIC_KEY ),             \
1098
        NULL,                                           \
1099
        NULL,                                           \
1100
        NULL,                                           \
1101
        NULL,                                           \
1102
        keytype##_d2i_PUBKEY,                           \
1103
        keytype##_check,                                \
1104
        keytype##_adjust,                               \
1105
        keytype##_free
1106

1107
#define DO_DH(keytype)                                  \
1108
    "DH", keytype##_evp_type,                           \
1109
        ( OSSL_KEYMGMT_SELECT_ALL_PARAMETERS ),         \
1110
        NULL,                                           \
1111
        NULL,                                           \
1112
        keytype##_d2i_key_params,                       \
1113
        NULL,                                           \
1114
        NULL,                                           \
1115
        keytype##_check,                                \
1116
        keytype##_adjust,                               \
1117
        keytype##_free
1118

1119
#define DO_DHX(keytype)                                 \
1120
    "DHX", keytype##_evp_type,                          \
1121
        ( OSSL_KEYMGMT_SELECT_ALL_PARAMETERS ),         \
1122
        NULL,                                           \
1123
        NULL,                                           \
1124
        keytype##_d2i_key_params,                       \
1125
        NULL,                                           \
1126
        NULL,                                           \
1127
        keytype##_check,                                \
1128
        keytype##_adjust,                               \
1129
        keytype##_free
1130

1131
#define DO_DSA(keytype)                                 \
1132
    "DSA", keytype##_evp_type,                          \
1133
        ( OSSL_KEYMGMT_SELECT_ALL ),                    \
1134
        keytype##_d2i_private_key,                      \
1135
        keytype##_d2i_public_key,                       \
1136
        keytype##_d2i_key_params,                       \
1137
        NULL,                                           \
1138
        NULL,                                           \
1139
        keytype##_check,                                \
1140
        keytype##_adjust,                               \
1141
        keytype##_free
1142

1143
#define DO_EC(keytype)                                  \
1144
    "EC", keytype##_evp_type,                           \
1145
        ( OSSL_KEYMGMT_SELECT_PRIVATE_KEY               \
1146
          | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS ),       \
1147
        keytype##_d2i_private_key,                      \
1148
        NULL,                                           \
1149
        keytype##_d2i_key_params,                       \
1150
        NULL,                                           \
1151
        NULL,                                           \
1152
        keytype##_check,                                \
1153
        keytype##_adjust,                               \
1154
        keytype##_free
1155

1156
#define DO_RSA(keytype)                                 \
1157
    "RSA", keytype##_evp_type,                          \
1158
        ( OSSL_KEYMGMT_SELECT_KEYPAIR ),                \
1159
        keytype##_d2i_private_key,                      \
1160
        keytype##_d2i_public_key,                       \
1161
        NULL,                                           \
1162
        NULL,                                           \
1163
        NULL,                                           \
1164
        keytype##_check,                                \
1165
        keytype##_adjust,                               \
1166
        keytype##_free
1167

1168
/*
1169
 * MAKE_DECODER is the single driver for creating OSSL_DISPATCH tables.
1170
 * It takes the following arguments:
1171
 *
1172
 * keytype_name The implementation key type as a string.
1173
 * keytype      The implementation key type.  This must correspond exactly
1174
 *              to our existing keymgmt keytype names...  in other words,
1175
 *              there must exist an ossl_##keytype##_keymgmt_functions.
1176
 * type         The type name for the set of functions that implement the
1177
 *              decoder for the key type.  This isn't necessarily the same
1178
 *              as keytype.  For example, the key types ed25519, ed448,
1179
 *              x25519 and x448 are all handled by the same functions with
1180
 *              the common type name ecx.
1181
 * kind         The kind of support to implement.  This translates into
1182
 *              the DO_##kind macros above, to populate the keytype_desc_st
1183
 *              structure.
1184
 */
1185
#define MAKE_DECODER(keytype_name, keytype, type, kind)                 \
1186
    static const struct keytype_desc_st kind##_##keytype##_desc =       \
1187
        { keytype_name, ossl_##keytype##_keymgmt_functions,             \
1188
          DO_##kind(keytype) };                                         \
1189
                                                                        \
1190
    static OSSL_FUNC_decoder_newctx_fn kind##_der2##keytype##_newctx;   \
1191
                                                                        \
1192
    static void *kind##_der2##keytype##_newctx(void *provctx)           \
1193
    {                                                                   \
1194
        return der2key_newctx(provctx, &kind##_##keytype##_desc);       \
1195
    }                                                                   \
1196
    static int kind##_der2##keytype##_does_selection(void *provctx,     \
1197
                                                     int selection)     \
1198
    {                                                                   \
1199
        return der2key_check_selection(selection,                       \
1200
                                       &kind##_##keytype##_desc);       \
1201
    }                                                                   \
1202
    const OSSL_DISPATCH                                                 \
1203
    ossl_##kind##_der_to_##keytype##_decoder_functions[] = {            \
1204
        { OSSL_FUNC_DECODER_NEWCTX,                                     \
1205
          (void (*)(void))kind##_der2##keytype##_newctx },              \
1206
        { OSSL_FUNC_DECODER_FREECTX,                                    \
1207
          (void (*)(void))der2key_freectx },                            \
1208
        { OSSL_FUNC_DECODER_DOES_SELECTION,                             \
1209
          (void (*)(void))kind##_der2##keytype##_does_selection },      \
1210
        { OSSL_FUNC_DECODER_DECODE,                                     \
1211
          (void (*)(void))der2key_decode },                             \
1212
        { OSSL_FUNC_DECODER_EXPORT_OBJECT,                              \
1213
          (void (*)(void))der2key_export_object },                      \
1214
        { OSSL_FUNC_DECODER_SETTABLE_CTX_PARAMS,                        \
1215
          (void (*)(void))der2key_settable_ctx_params },                \
1216
        { OSSL_FUNC_DECODER_SET_CTX_PARAMS,                             \
1217
          (void (*)(void))der2key_set_ctx_params },                     \
1218
        OSSL_DISPATCH_END                                               \
1219
    }
1220

1221
#ifndef OPENSSL_NO_DH
1222
MAKE_DECODER("DH", dh, dh, PrivateKeyInfo);
1223
MAKE_DECODER("DH", dh, dh, SubjectPublicKeyInfo);
1224
MAKE_DECODER("DH", dh, dh, type_specific_params);
1225
MAKE_DECODER("DH", dh, dh, DH);
1226
MAKE_DECODER("DHX", dhx, dhx, PrivateKeyInfo);
1227
MAKE_DECODER("DHX", dhx, dhx, SubjectPublicKeyInfo);
1228
MAKE_DECODER("DHX", dhx, dhx, type_specific_params);
1229
MAKE_DECODER("DHX", dhx, dhx, DHX);
1230
#endif
1231
#ifndef OPENSSL_NO_DSA
1232
MAKE_DECODER("DSA", dsa, dsa, PrivateKeyInfo);
1233
MAKE_DECODER("DSA", dsa, dsa, SubjectPublicKeyInfo);
1234
MAKE_DECODER("DSA", dsa, dsa, type_specific);
1235
MAKE_DECODER("DSA", dsa, dsa, DSA);
1236
#endif
1237
#ifndef OPENSSL_NO_EC
1238
MAKE_DECODER("EC", ec, ec, PrivateKeyInfo);
1239
MAKE_DECODER("EC", ec, ec, SubjectPublicKeyInfo);
1240
MAKE_DECODER("EC", ec, ec, type_specific_no_pub);
1241
MAKE_DECODER("EC", ec, ec, EC);
1242
# ifndef OPENSSL_NO_ECX
1243
MAKE_DECODER("X25519", x25519, ecx, PrivateKeyInfo);
1244
MAKE_DECODER("X25519", x25519, ecx, SubjectPublicKeyInfo);
1245
MAKE_DECODER("X448", x448, ecx, PrivateKeyInfo);
1246
MAKE_DECODER("X448", x448, ecx, SubjectPublicKeyInfo);
1247
MAKE_DECODER("ED25519", ed25519, ecx, PrivateKeyInfo);
1248
MAKE_DECODER("ED25519", ed25519, ecx, SubjectPublicKeyInfo);
1249
MAKE_DECODER("ED448", ed448, ecx, PrivateKeyInfo);
1250
MAKE_DECODER("ED448", ed448, ecx, SubjectPublicKeyInfo);
1251
# endif
1252
# ifndef OPENSSL_NO_SM2
1253
MAKE_DECODER("SM2", sm2, ec, PrivateKeyInfo);
1254
MAKE_DECODER("SM2", sm2, ec, SubjectPublicKeyInfo);
1255
MAKE_DECODER("SM2", sm2, sm2, type_specific_no_pub);
1256
# endif
1257
#endif
1258
#ifndef OPENSSL_NO_ML_KEM
1259
MAKE_DECODER("ML-KEM-512", ml_kem_512, ml_kem_512, PrivateKeyInfo);
1260
MAKE_DECODER("ML-KEM-512", ml_kem_512, ml_kem_512, SubjectPublicKeyInfo);
1261
MAKE_DECODER("ML-KEM-768", ml_kem_768, ml_kem_768, PrivateKeyInfo);
1262
MAKE_DECODER("ML-KEM-768", ml_kem_768, ml_kem_768, SubjectPublicKeyInfo);
1263
MAKE_DECODER("ML-KEM-1024", ml_kem_1024, ml_kem_1024, PrivateKeyInfo);
1264
MAKE_DECODER("ML-KEM-1024", ml_kem_1024, ml_kem_1024, SubjectPublicKeyInfo);
1265
#endif
1266
#ifndef OPENSSL_NO_SLH_DSA
1267
MAKE_DECODER("SLH-DSA-SHA2-128s", slh_dsa_sha2_128s, slh_dsa, PrivateKeyInfo);
1268
MAKE_DECODER("SLH-DSA-SHA2-128f", slh_dsa_sha2_128f, slh_dsa, PrivateKeyInfo);
1269
MAKE_DECODER("SLH-DSA-SHA2-192s", slh_dsa_sha2_192s, slh_dsa, PrivateKeyInfo);
1270
MAKE_DECODER("SLH-DSA-SHA2-192f", slh_dsa_sha2_192f, slh_dsa, PrivateKeyInfo);
1271
MAKE_DECODER("SLH-DSA-SHA2-256s", slh_dsa_sha2_256s, slh_dsa, PrivateKeyInfo);
1272
MAKE_DECODER("SLH-DSA-SHA2-256f", slh_dsa_sha2_256f, slh_dsa, PrivateKeyInfo);
1273
MAKE_DECODER("SLH-DSA-SHAKE-128s", slh_dsa_shake_128s, slh_dsa, PrivateKeyInfo);
1274
MAKE_DECODER("SLH-DSA-SHAKE-128f", slh_dsa_shake_128f, slh_dsa, PrivateKeyInfo);
1275
MAKE_DECODER("SLH-DSA-SHAKE-192s", slh_dsa_shake_192s, slh_dsa, PrivateKeyInfo);
1276
MAKE_DECODER("SLH-DSA-SHAKE-192f", slh_dsa_shake_192f, slh_dsa, PrivateKeyInfo);
1277
MAKE_DECODER("SLH-DSA-SHAKE-256s", slh_dsa_shake_256s, slh_dsa, PrivateKeyInfo);
1278
MAKE_DECODER("SLH-DSA-SHAKE-256f", slh_dsa_shake_256f, slh_dsa, PrivateKeyInfo);
1279

1280
MAKE_DECODER("SLH-DSA-SHA2-128s", slh_dsa_sha2_128s, slh_dsa, SubjectPublicKeyInfo);
1281
MAKE_DECODER("SLH-DSA-SHA2-128f", slh_dsa_sha2_128f, slh_dsa, SubjectPublicKeyInfo);
1282
MAKE_DECODER("SLH-DSA-SHA2-192s", slh_dsa_sha2_192s, slh_dsa, SubjectPublicKeyInfo);
1283
MAKE_DECODER("SLH-DSA-SHA2-192f", slh_dsa_sha2_192f, slh_dsa, SubjectPublicKeyInfo);
1284
MAKE_DECODER("SLH-DSA-SHA2-256s", slh_dsa_sha2_256s, slh_dsa, SubjectPublicKeyInfo);
1285
MAKE_DECODER("SLH-DSA-SHA2-256f", slh_dsa_sha2_256f, slh_dsa, SubjectPublicKeyInfo);
1286
MAKE_DECODER("SLH-DSA-SHAKE-128s", slh_dsa_shake_128s, slh_dsa, SubjectPublicKeyInfo);
1287
MAKE_DECODER("SLH-DSA-SHAKE-128f", slh_dsa_shake_128f, slh_dsa, SubjectPublicKeyInfo);
1288
MAKE_DECODER("SLH-DSA-SHAKE-192s", slh_dsa_shake_192s, slh_dsa, SubjectPublicKeyInfo);
1289
MAKE_DECODER("SLH-DSA-SHAKE-192f", slh_dsa_shake_192f, slh_dsa, SubjectPublicKeyInfo);
1290
MAKE_DECODER("SLH-DSA-SHAKE-256s", slh_dsa_shake_256s, slh_dsa, SubjectPublicKeyInfo);
1291
MAKE_DECODER("SLH-DSA-SHAKE-256f", slh_dsa_shake_256f, slh_dsa, SubjectPublicKeyInfo);
1292
#endif /* OPENSSL_NO_SLH_DSA */
1293
MAKE_DECODER("RSA", rsa, rsa, PrivateKeyInfo);
1294
MAKE_DECODER("RSA", rsa, rsa, SubjectPublicKeyInfo);
1295
MAKE_DECODER("RSA", rsa, rsa, type_specific_keypair);
1296
MAKE_DECODER("RSA", rsa, rsa, RSA);
1297
MAKE_DECODER("RSA-PSS", rsapss, rsapss, PrivateKeyInfo);
1298
MAKE_DECODER("RSA-PSS", rsapss, rsapss, SubjectPublicKeyInfo);
1299

1300
#ifndef OPENSSL_NO_ML_DSA
1301
MAKE_DECODER("ML-DSA-44", ml_dsa_44, ml_dsa_44, PrivateKeyInfo);
1302
MAKE_DECODER("ML-DSA-44", ml_dsa_44, ml_dsa_44, SubjectPublicKeyInfo);
1303
MAKE_DECODER("ML-DSA-65", ml_dsa_65, ml_dsa_65, PrivateKeyInfo);
1304
MAKE_DECODER("ML-DSA-65", ml_dsa_65, ml_dsa_65, SubjectPublicKeyInfo);
1305
MAKE_DECODER("ML-DSA-87", ml_dsa_87, ml_dsa_87, PrivateKeyInfo);
1306
MAKE_DECODER("ML-DSA-87", ml_dsa_87, ml_dsa_87, SubjectPublicKeyInfo);
1307
#endif
1308

1309
Product

Resources

Company
