[thirdparty/openssl.git] / providers / implementations / serializers / serializer_dsa_priv.c

/*
 * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

/*
 * DSA low level APIs are deprecated for public use, but still ok for
 * internal use.
 */
#include "internal/deprecated.h"

#include <openssl/core_dispatch.h>
#include <openssl/core_names.h>
#include <openssl/err.h>
#include <openssl/pem.h>
#include <openssl/dsa.h>
#include <openssl/types.h>
#include <openssl/params.h>
#include "prov/bio.h"
#include "prov/implementations.h"
#include "prov/provider_ctx.h"
#include "serializer_local.h"

static OSSL_FUNC_serializer_newctx_fn dsa_priv_newctx;
static OSSL_FUNC_serializer_freectx_fn dsa_priv_freectx;
static OSSL_FUNC_serializer_set_ctx_params_fn dsa_priv_set_ctx_params;
static OSSL_FUNC_serializer_settable_ctx_params_fn dsa_priv_settable_ctx_params;
static OSSL_FUNC_serializer_serialize_data_fn dsa_priv_der_data;
static OSSL_FUNC_serializer_serialize_object_fn dsa_priv_der;
static OSSL_FUNC_serializer_serialize_data_fn dsa_pem_priv_data;
static OSSL_FUNC_serializer_serialize_object_fn dsa_pem_priv;

static OSSL_FUNC_serializer_newctx_fn dsa_print_newctx;
static OSSL_FUNC_serializer_freectx_fn dsa_print_freectx;
static OSSL_FUNC_serializer_serialize_data_fn dsa_priv_print_data;
static OSSL_FUNC_serializer_serialize_object_fn dsa_priv_print;

 /*
 * Context used for private key serialization.
 */
struct dsa_priv_ctx_st {
    void *provctx;

    struct pkcs8_encrypt_ctx_st sc;
};

/* Private key : context */
static void *dsa_priv_newctx(void *provctx)
{
    struct dsa_priv_ctx_st *ctx = OPENSSL_zalloc(sizeof(*ctx));

    if (ctx != NULL) {
        ctx->provctx = provctx;

        /* -1 is the "whatever" indicator, i.e. the PKCS8 library default PBE */
        ctx->sc.pbe_nid = -1;
    }
    return ctx;
}

static void dsa_priv_freectx(void *vctx)
{
    struct dsa_priv_ctx_st *ctx = vctx;

    EVP_CIPHER_free(ctx->sc.cipher);
    OPENSSL_free(ctx->sc.cipher_pass);
    OPENSSL_free(ctx);
}

static const OSSL_PARAM *dsa_priv_settable_ctx_params(void)
{
    static const OSSL_PARAM settables[] = {
        OSSL_PARAM_utf8_string(OSSL_SERIALIZER_PARAM_CIPHER, NULL, 0),
        OSSL_PARAM_octet_string(OSSL_SERIALIZER_PARAM_PASS, NULL, 0),
        OSSL_PARAM_END,
    };

    return settables;
}

static int dsa_priv_set_ctx_params(void *vctx, const OSSL_PARAM params[])
{
    struct dsa_priv_ctx_st *ctx = vctx;
    const OSSL_PARAM *p;

    if ((p = OSSL_PARAM_locate_const(params, OSSL_SERIALIZER_PARAM_CIPHER))
        != NULL) {
        const OSSL_PARAM *propsp =
            OSSL_PARAM_locate_const(params, OSSL_SERIALIZER_PARAM_PROPERTIES);
        const char *props = NULL;

        if (p->data_type != OSSL_PARAM_UTF8_STRING)
            return 0;
        if (propsp != NULL && propsp->data_type != OSSL_PARAM_UTF8_STRING)
            return 0;
        props = (propsp != NULL ? propsp->data : NULL);

        EVP_CIPHER_free(ctx->sc.cipher);
        ctx->sc.cipher_intent = p->data != NULL;
        if (p->data != NULL
            && ((ctx->sc.cipher = EVP_CIPHER_fetch(NULL, p->data, props))
                == NULL))
            return 0;
    }
    if ((p = OSSL_PARAM_locate_const(params, OSSL_SERIALIZER_PARAM_PASS))
        != NULL) {
        OPENSSL_free(ctx->sc.cipher_pass);
        ctx->sc.cipher_pass = NULL;
        if (!OSSL_PARAM_get_octet_string(p, &ctx->sc.cipher_pass, 0,
                                         &ctx->sc.cipher_pass_length))
            return 0;
    }
    return 1;
}

/* Private key : DER */
static int dsa_priv_der_data(void *vctx, const OSSL_PARAM params[],
                             OSSL_CORE_BIO *out,
                             OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
    struct dsa_priv_ctx_st *ctx = vctx;
    OSSL_FUNC_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
    OSSL_FUNC_keymgmt_free_fn *dsa_free = ossl_prov_get_keymgmt_dsa_free();
    OSSL_FUNC_keymgmt_import_fn *dsa_import = ossl_prov_get_keymgmt_dsa_import();
    int ok = 0;

    if (dsa_import != NULL) {
        DSA *dsa;

        if ((dsa = dsa_new(ctx->provctx)) != NULL
            && dsa_import(dsa, OSSL_KEYMGMT_SELECT_KEYPAIR, params)
            && dsa_priv_der(ctx, dsa, out, cb, cbarg))
            ok = 1;
        dsa_free(dsa);
    }
    return ok;
}

static int dsa_priv_der(void *vctx, void *dsa, OSSL_CORE_BIO *cout,
                        OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
    struct dsa_priv_ctx_st *ctx = vctx;
    BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
    int ret;

    if (out == NULL)
        return 0;

    ctx->sc.cb = cb;
    ctx->sc.cbarg = cbarg;

    ret = ossl_prov_write_priv_der_from_obj(out, dsa, EVP_PKEY_DSA,
                                            ossl_prov_prepare_dsa_params,
                                            ossl_prov_dsa_priv_to_der,
                                            &ctx->sc);
    BIO_free(out);

    return ret;
}

/* Private key : PEM */
static int dsa_pem_priv_data(void *vctx, const OSSL_PARAM params[],
                             OSSL_CORE_BIO *out,
                             OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
    struct dsa_priv_ctx_st *ctx = vctx;
    OSSL_FUNC_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
    OSSL_FUNC_keymgmt_free_fn *dsa_free = ossl_prov_get_keymgmt_dsa_free();
    OSSL_FUNC_keymgmt_import_fn *dsa_import = ossl_prov_get_keymgmt_dsa_import();
    int ok = 0;

    if (dsa_import != NULL) {
        DSA *dsa;

        if ((dsa = dsa_new(ctx->provctx)) != NULL
            && dsa_import(dsa, OSSL_KEYMGMT_SELECT_KEYPAIR, params)
            && dsa_pem_priv(ctx, dsa, out, cb, cbarg))
            ok = 1;
        dsa_free(dsa);
    }
    return ok;
}

static int dsa_pem_priv(void *vctx, void *dsa, OSSL_CORE_BIO *cout,
                        OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
    struct dsa_priv_ctx_st *ctx = vctx;
    BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
    int ret;

    if (out == NULL)
        return 0;

    ctx->sc.cb = cb;
    ctx->sc.cbarg = cbarg;

    ret = ossl_prov_write_priv_pem_from_obj(out, dsa, EVP_PKEY_DSA,
                                            ossl_prov_prepare_dsa_params,
                                            ossl_prov_dsa_priv_to_der,
                                            &ctx->sc);
    BIO_free(out);

    return ret;
}

/*
 * There's no specific print context, so we use the provider context
 */
static void *dsa_print_newctx(void *provctx)
{
    return provctx;
}

static void dsa_print_freectx(void *ctx)
{
}

static int dsa_priv_print_data(void *vctx, const OSSL_PARAM params[],
                               OSSL_CORE_BIO *out,
                               OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
    struct dsa_priv_ctx_st *ctx = vctx;
    OSSL_FUNC_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
    OSSL_FUNC_keymgmt_free_fn *dsa_free = ossl_prov_get_keymgmt_dsa_free();
    OSSL_FUNC_keymgmt_import_fn *dsa_import = ossl_prov_get_keymgmt_dsa_import();
    int ok = 0;

    if (dsa_import != NULL) {
        DSA *dsa;

        if ((dsa = dsa_new(ctx->provctx)) != NULL
            && dsa_import(dsa, OSSL_KEYMGMT_SELECT_KEYPAIR, params)
            && dsa_priv_print(ctx, dsa, out, cb, cbarg))
            ok = 1;
        dsa_free(dsa);
    }
    return ok;
}

static int dsa_priv_print(void *ctx, void *dsa, OSSL_CORE_BIO *cout,
                          OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
    BIO *out = bio_new_from_core_bio(ctx, cout);
    int ret;

    if (out == NULL)
        return 0;

    ret = ossl_prov_print_dsa(out, dsa, dsa_print_priv);
    BIO_free(out);

    return ret;
}

const OSSL_DISPATCH dsa_priv_der_serializer_functions[] = {
    { OSSL_FUNC_SERIALIZER_NEWCTX, (void (*)(void))dsa_priv_newctx },
    { OSSL_FUNC_SERIALIZER_FREECTX, (void (*)(void))dsa_priv_freectx },
    { OSSL_FUNC_SERIALIZER_SET_CTX_PARAMS,
      (void (*)(void))dsa_priv_set_ctx_params },
    { OSSL_FUNC_SERIALIZER_SETTABLE_CTX_PARAMS,
      (void (*)(void))dsa_priv_settable_ctx_params },
    { OSSL_FUNC_SERIALIZER_SERIALIZE_DATA, (void (*)(void))dsa_priv_der_data },
    { OSSL_FUNC_SERIALIZER_SERIALIZE_OBJECT, (void (*)(void))dsa_priv_der },
    { 0, NULL }
};

const OSSL_DISPATCH dsa_priv_pem_serializer_functions[] = {
    { OSSL_FUNC_SERIALIZER_NEWCTX, (void (*)(void))dsa_priv_newctx },
    { OSSL_FUNC_SERIALIZER_FREECTX, (void (*)(void))dsa_priv_freectx },
    { OSSL_FUNC_SERIALIZER_SET_CTX_PARAMS,
      (void (*)(void))dsa_priv_set_ctx_params },
    { OSSL_FUNC_SERIALIZER_SETTABLE_CTX_PARAMS,
      (void (*)(void))dsa_priv_settable_ctx_params },
    { OSSL_FUNC_SERIALIZER_SERIALIZE_DATA, (void (*)(void))dsa_pem_priv_data },
    { OSSL_FUNC_SERIALIZER_SERIALIZE_OBJECT, (void (*)(void))dsa_pem_priv },
    { 0, NULL }
};

const OSSL_DISPATCH dsa_priv_text_serializer_functions[] = {
    { OSSL_FUNC_SERIALIZER_NEWCTX, (void (*)(void))dsa_print_newctx },
    { OSSL_FUNC_SERIALIZER_FREECTX, (void (*)(void))dsa_print_freectx },
    { OSSL_FUNC_SERIALIZER_SERIALIZE_OBJECT, (void (*)(void))dsa_priv_print },
    { OSSL_FUNC_SERIALIZER_SERIALIZE_DATA,
      (void (*)(void))dsa_priv_print_data },
    { 0, NULL }
};
Commit	Line	Data
264b789b	1	/*
33388b44	2	* Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
264b789b RL	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
f41ac0ee P	10	/*
	11	* DSA low level APIs are deprecated for public use, but still ok for
	12	* internal use.
	13	*/
	14	#include "internal/deprecated.h"
	15
23c48d94	16	#include <openssl/core_dispatch.h>
264b789b RL	17	#include <openssl/core_names.h>
	18	#include <openssl/err.h>
	19	#include <openssl/pem.h>
	20	#include <openssl/dsa.h>
	21	#include <openssl/types.h>
	22	#include <openssl/params.h>
	23	#include "prov/bio.h"
	24	#include "prov/implementations.h"
d40b42ab	25	#include "prov/provider_ctx.h"
264b789b RL	26	#include "serializer_local.h"
264b789b RL	27
363b1e5d DMSP	28	static OSSL_FUNC_serializer_newctx_fn dsa_priv_newctx;
	29	static OSSL_FUNC_serializer_freectx_fn dsa_priv_freectx;
	30	static OSSL_FUNC_serializer_set_ctx_params_fn dsa_priv_set_ctx_params;
	31	static OSSL_FUNC_serializer_settable_ctx_params_fn dsa_priv_settable_ctx_params;
	32	static OSSL_FUNC_serializer_serialize_data_fn dsa_priv_der_data;
	33	static OSSL_FUNC_serializer_serialize_object_fn dsa_priv_der;
	34	static OSSL_FUNC_serializer_serialize_data_fn dsa_pem_priv_data;
	35	static OSSL_FUNC_serializer_serialize_object_fn dsa_pem_priv;
	36
	37	static OSSL_FUNC_serializer_newctx_fn dsa_print_newctx;
	38	static OSSL_FUNC_serializer_freectx_fn dsa_print_freectx;
	39	static OSSL_FUNC_serializer_serialize_data_fn dsa_priv_print_data;
	40	static OSSL_FUNC_serializer_serialize_object_fn dsa_priv_print;
264b789b RL	41
	42	/*
	43	* Context used for private key serialization.
	44	*/
	45	struct dsa_priv_ctx_st {
	46	void *provctx;
	47
	48	struct pkcs8_encrypt_ctx_st sc;
	49	};
	50
	51	/* Private key : context */
	52	static void dsa_priv_newctx(void provctx)
	53	{
	54	struct dsa_priv_ctx_st ctx = OPENSSL_zalloc(sizeof(ctx));
	55
	56	if (ctx != NULL) {
	57	ctx->provctx = provctx;
264b789b	58
75e571b5 P	59	/* -1 is the "whatever" indicator, i.e. the PKCS8 library default PBE */
	60	ctx->sc.pbe_nid = -1;
	61	}
264b789b RL	62	return ctx;
	63	}
	64
	65	static void dsa_priv_freectx(void *vctx)
	66	{
	67	struct dsa_priv_ctx_st *ctx = vctx;
	68
	69	EVP_CIPHER_free(ctx->sc.cipher);
	70	OPENSSL_free(ctx->sc.cipher_pass);
	71	OPENSSL_free(ctx);
	72	}
	73
	74	static const OSSL_PARAM *dsa_priv_settable_ctx_params(void)
	75	{
	76	static const OSSL_PARAM settables[] = {
	77	OSSL_PARAM_utf8_string(OSSL_SERIALIZER_PARAM_CIPHER, NULL, 0),
	78	OSSL_PARAM_octet_string(OSSL_SERIALIZER_PARAM_PASS, NULL, 0),
	79	OSSL_PARAM_END,
	80	};
	81
	82	return settables;
	83	}
	84
	85	static int dsa_priv_set_ctx_params(void *vctx, const OSSL_PARAM params[])
	86	{
	87	struct dsa_priv_ctx_st *ctx = vctx;
	88	const OSSL_PARAM *p;
	89
	90	if ((p = OSSL_PARAM_locate_const(params, OSSL_SERIALIZER_PARAM_CIPHER))
	91	!= NULL) {
	92	const OSSL_PARAM *propsp =
	93	OSSL_PARAM_locate_const(params, OSSL_SERIALIZER_PARAM_PROPERTIES);
	94	const char *props = NULL;
	95
	96	if (p->data_type != OSSL_PARAM_UTF8_STRING)
	97	return 0;
	98	if (propsp != NULL && propsp->data_type != OSSL_PARAM_UTF8_STRING)
	99	return 0;
	100	props = (propsp != NULL ? propsp->data : NULL);
	101
	102	EVP_CIPHER_free(ctx->sc.cipher);
	103	ctx->sc.cipher_intent = p->data != NULL;
	104	if (p->data != NULL
	105	&& ((ctx->sc.cipher = EVP_CIPHER_fetch(NULL, p->data, props))
	106	== NULL))
	107	return 0;
	108	}
	109	if ((p = OSSL_PARAM_locate_const(params, OSSL_SERIALIZER_PARAM_PASS))
	110	!= NULL) {
	111	OPENSSL_free(ctx->sc.cipher_pass);
	112	ctx->sc.cipher_pass = NULL;
	113	if (!OSSL_PARAM_get_octet_string(p, &ctx->sc.cipher_pass, 0,
	114	&ctx->sc.cipher_pass_length))
	115	return 0;
	116	}
	117	return 1;
	118	}
	119
	120	/* Private key : DER */
d40b42ab MC	121	static int dsa_priv_der_data(void *vctx, const OSSL_PARAM params[],
d40b42ab MC	122	OSSL_CORE_BIO *out,
264b789b RL	123	OSSL_PASSPHRASE_CALLBACK cb, void cbarg)
	124	{
	125	struct dsa_priv_ctx_st *ctx = vctx;
363b1e5d DMSP	126	OSSL_FUNC_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
	127	OSSL_FUNC_keymgmt_free_fn *dsa_free = ossl_prov_get_keymgmt_dsa_free();
	128	OSSL_FUNC_keymgmt_import_fn *dsa_import = ossl_prov_get_keymgmt_dsa_import();
264b789b RL	129	int ok = 0;
264b789b RL	130
32b0645c RL	131	if (dsa_import != NULL) {
32b0645c RL	132	DSA *dsa;
264b789b	133
32b0645c RL	134	if ((dsa = dsa_new(ctx->provctx)) != NULL
	135	&& dsa_import(dsa, OSSL_KEYMGMT_SELECT_KEYPAIR, params)
	136	&& dsa_priv_der(ctx, dsa, out, cb, cbarg))
	137	ok = 1;
	138	dsa_free(dsa);
264b789b RL	139	}
	140	return ok;
	141	}
	142
d40b42ab	143	static int dsa_priv_der(void vctx, void dsa, OSSL_CORE_BIO *cout,
264b789b RL	144	OSSL_PASSPHRASE_CALLBACK cb, void cbarg)
	145	{
	146	struct dsa_priv_ctx_st *ctx = vctx;
d40b42ab MC	147	BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
	148	int ret;
	149
	150	if (out == NULL)
	151	return 0;
264b789b RL	152
	153	ctx->sc.cb = cb;
	154	ctx->sc.cbarg = cbarg;
	155
d40b42ab MC	156	ret = ossl_prov_write_priv_der_from_obj(out, dsa, EVP_PKEY_DSA,
	157	ossl_prov_prepare_dsa_params,
	158	ossl_prov_dsa_priv_to_der,
	159	&ctx->sc);
	160	BIO_free(out);
	161
	162	return ret;
264b789b RL	163	}
	164
	165	/* Private key : PEM */
d40b42ab MC	166	static int dsa_pem_priv_data(void *vctx, const OSSL_PARAM params[],
d40b42ab MC	167	OSSL_CORE_BIO *out,
264b789b RL	168	OSSL_PASSPHRASE_CALLBACK cb, void cbarg)
	169	{
	170	struct dsa_priv_ctx_st *ctx = vctx;
363b1e5d DMSP	171	OSSL_FUNC_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
	172	OSSL_FUNC_keymgmt_free_fn *dsa_free = ossl_prov_get_keymgmt_dsa_free();
	173	OSSL_FUNC_keymgmt_import_fn *dsa_import = ossl_prov_get_keymgmt_dsa_import();
264b789b RL	174	int ok = 0;
264b789b RL	175
32b0645c RL	176	if (dsa_import != NULL) {
32b0645c RL	177	DSA *dsa;
264b789b	178
32b0645c RL	179	if ((dsa = dsa_new(ctx->provctx)) != NULL
	180	&& dsa_import(dsa, OSSL_KEYMGMT_SELECT_KEYPAIR, params)
	181	&& dsa_pem_priv(ctx, dsa, out, cb, cbarg))
	182	ok = 1;
	183	dsa_free(dsa);
264b789b RL	184	}
	185	return ok;
	186	}
	187
d40b42ab	188	static int dsa_pem_priv(void vctx, void dsa, OSSL_CORE_BIO *cout,
264b789b RL	189	OSSL_PASSPHRASE_CALLBACK cb, void cbarg)
	190	{
	191	struct dsa_priv_ctx_st *ctx = vctx;
d40b42ab MC	192	BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
	193	int ret;
	194
	195	if (out == NULL)
	196	return 0;
264b789b RL	197
	198	ctx->sc.cb = cb;
	199	ctx->sc.cbarg = cbarg;
	200
d40b42ab MC	201	ret = ossl_prov_write_priv_pem_from_obj(out, dsa, EVP_PKEY_DSA,
	202	ossl_prov_prepare_dsa_params,
	203	ossl_prov_dsa_priv_to_der,
	204	&ctx->sc);
	205	BIO_free(out);
	206
	207	return ret;
264b789b RL	208	}
	209
	210	/*
	211	* There's no specific print context, so we use the provider context
	212	*/
	213	static void dsa_print_newctx(void provctx)
	214	{
	215	return provctx;
	216	}
	217
	218	static void dsa_print_freectx(void *ctx)
	219	{
	220	}
	221
32b0645c	222	static int dsa_priv_print_data(void *vctx, const OSSL_PARAM params[],
d40b42ab	223	OSSL_CORE_BIO *out,
264b789b RL	224	OSSL_PASSPHRASE_CALLBACK cb, void cbarg)
264b789b RL	225	{
32b0645c	226	struct dsa_priv_ctx_st *ctx = vctx;
363b1e5d DMSP	227	OSSL_FUNC_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
	228	OSSL_FUNC_keymgmt_free_fn *dsa_free = ossl_prov_get_keymgmt_dsa_free();
	229	OSSL_FUNC_keymgmt_import_fn *dsa_import = ossl_prov_get_keymgmt_dsa_import();
264b789b RL	230	int ok = 0;
264b789b RL	231
32b0645c RL	232	if (dsa_import != NULL) {
32b0645c RL	233	DSA *dsa;
264b789b	234
32b0645c RL	235	if ((dsa = dsa_new(ctx->provctx)) != NULL
	236	&& dsa_import(dsa, OSSL_KEYMGMT_SELECT_KEYPAIR, params)
	237	&& dsa_priv_print(ctx, dsa, out, cb, cbarg))
	238	ok = 1;
	239	dsa_free(dsa);
264b789b RL	240	}
	241	return ok;
	242	}
	243
d40b42ab	244	static int dsa_priv_print(void ctx, void dsa, OSSL_CORE_BIO *cout,
264b789b RL	245	OSSL_PASSPHRASE_CALLBACK cb, void cbarg)
264b789b RL	246	{
d40b42ab MC	247	BIO *out = bio_new_from_core_bio(ctx, cout);
	248	int ret;
	249
	250	if (out == NULL)
	251	return 0;
	252
	253	ret = ossl_prov_print_dsa(out, dsa, dsa_print_priv);
	254	BIO_free(out);
	255
	256	return ret;
264b789b RL	257	}
	258
	259	const OSSL_DISPATCH dsa_priv_der_serializer_functions[] = {
	260	{ OSSL_FUNC_SERIALIZER_NEWCTX, (void (*)(void))dsa_priv_newctx },
	261	{ OSSL_FUNC_SERIALIZER_FREECTX, (void (*)(void))dsa_priv_freectx },
	262	{ OSSL_FUNC_SERIALIZER_SET_CTX_PARAMS,
	263	(void (*)(void))dsa_priv_set_ctx_params },
	264	{ OSSL_FUNC_SERIALIZER_SETTABLE_CTX_PARAMS,
	265	(void (*)(void))dsa_priv_settable_ctx_params },
	266	{ OSSL_FUNC_SERIALIZER_SERIALIZE_DATA, (void (*)(void))dsa_priv_der_data },
	267	{ OSSL_FUNC_SERIALIZER_SERIALIZE_OBJECT, (void (*)(void))dsa_priv_der },
	268	{ 0, NULL }
	269	};
	270
	271	const OSSL_DISPATCH dsa_priv_pem_serializer_functions[] = {
	272	{ OSSL_FUNC_SERIALIZER_NEWCTX, (void (*)(void))dsa_priv_newctx },
	273	{ OSSL_FUNC_SERIALIZER_FREECTX, (void (*)(void))dsa_priv_freectx },
	274	{ OSSL_FUNC_SERIALIZER_SET_CTX_PARAMS,
	275	(void (*)(void))dsa_priv_set_ctx_params },
	276	{ OSSL_FUNC_SERIALIZER_SETTABLE_CTX_PARAMS,
	277	(void (*)(void))dsa_priv_settable_ctx_params },
	278	{ OSSL_FUNC_SERIALIZER_SERIALIZE_DATA, (void (*)(void))dsa_pem_priv_data },
	279	{ OSSL_FUNC_SERIALIZER_SERIALIZE_OBJECT, (void (*)(void))dsa_pem_priv },
	280	{ 0, NULL }
	281	};
	282
	283	const OSSL_DISPATCH dsa_priv_text_serializer_functions[] = {
	284	{ OSSL_FUNC_SERIALIZER_NEWCTX, (void (*)(void))dsa_print_newctx },
	285	{ OSSL_FUNC_SERIALIZER_FREECTX, (void (*)(void))dsa_print_freectx },
	286	{ OSSL_FUNC_SERIALIZER_SERIALIZE_OBJECT, (void (*)(void))dsa_priv_print },
	287	{ OSSL_FUNC_SERIALIZER_SERIALIZE_DATA,
	288	(void (*)(void))dsa_priv_print_data },
	289	{ 0, NULL }
	290	};