[thirdparty/openssl.git] / providers / implementations / encode_decode / encoder_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 "encoder_local.h"

#define DSA_SELECT_PRIVATE_IMPORTABLE                                          \
    (OSSL_KEYMGMT_SELECT_KEYPAIR | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS)

static OSSL_FUNC_encoder_newctx_fn dsa_priv_newctx;
static OSSL_FUNC_encoder_freectx_fn dsa_priv_freectx;
static OSSL_FUNC_encoder_set_ctx_params_fn dsa_priv_set_ctx_params;
static OSSL_FUNC_encoder_settable_ctx_params_fn dsa_priv_settable_ctx_params;
static OSSL_FUNC_encoder_encode_data_fn dsa_priv_der_data;
static OSSL_FUNC_encoder_encode_object_fn dsa_priv_der;
static OSSL_FUNC_encoder_encode_data_fn dsa_pem_priv_data;
static OSSL_FUNC_encoder_encode_object_fn dsa_pem_priv;

static OSSL_FUNC_encoder_newctx_fn dsa_print_newctx;
static OSSL_FUNC_encoder_freectx_fn dsa_print_freectx;
static OSSL_FUNC_encoder_encode_data_fn dsa_priv_print_data;
static OSSL_FUNC_encoder_encode_object_fn dsa_priv_print;

/*
 * Context used for private key encoding.
 */
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(ossl_unused void *provctx)
{
    static const OSSL_PARAM settables[] = {
        OSSL_PARAM_utf8_string(OSSL_ENCODER_PARAM_CIPHER, NULL, 0),
        OSSL_PARAM_octet_string(OSSL_ENCODER_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_ENCODER_PARAM_CIPHER))
        != NULL) {
        const OSSL_PARAM *propsp =
            OSSL_PARAM_locate_const(params, OSSL_ENCODER_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_ENCODER_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, DSA_SELECT_PRIVATE_IMPORTABLE, 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, DSA_SELECT_PRIVATE_IMPORTABLE, 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, DSA_SELECT_PRIVATE_IMPORTABLE, 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_encoder_functions[] = {
    { OSSL_FUNC_ENCODER_NEWCTX, (void (*)(void))dsa_priv_newctx },
    { OSSL_FUNC_ENCODER_FREECTX, (void (*)(void))dsa_priv_freectx },
    { OSSL_FUNC_ENCODER_SET_CTX_PARAMS,
      (void (*)(void))dsa_priv_set_ctx_params },
    { OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS,
      (void (*)(void))dsa_priv_settable_ctx_params },
    { OSSL_FUNC_ENCODER_ENCODE_DATA, (void (*)(void))dsa_priv_der_data },
    { OSSL_FUNC_ENCODER_ENCODE_OBJECT, (void (*)(void))dsa_priv_der },
    { 0, NULL }
};

const OSSL_DISPATCH dsa_priv_pem_encoder_functions[] = {
    { OSSL_FUNC_ENCODER_NEWCTX, (void (*)(void))dsa_priv_newctx },
    { OSSL_FUNC_ENCODER_FREECTX, (void (*)(void))dsa_priv_freectx },
    { OSSL_FUNC_ENCODER_SET_CTX_PARAMS,
      (void (*)(void))dsa_priv_set_ctx_params },
    { OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS,
      (void (*)(void))dsa_priv_settable_ctx_params },
    { OSSL_FUNC_ENCODER_ENCODE_DATA, (void (*)(void))dsa_pem_priv_data },
    { OSSL_FUNC_ENCODER_ENCODE_OBJECT, (void (*)(void))dsa_pem_priv },
    { 0, NULL }
};

const OSSL_DISPATCH dsa_priv_text_encoder_functions[] = {
    { OSSL_FUNC_ENCODER_NEWCTX, (void (*)(void))dsa_print_newctx },
    { OSSL_FUNC_ENCODER_FREECTX, (void (*)(void))dsa_print_freectx },
    { OSSL_FUNC_ENCODER_ENCODE_OBJECT, (void (*)(void))dsa_priv_print },
    { OSSL_FUNC_ENCODER_ENCODE_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"
ece9304c RL	26	#include "encoder_local.h"
ece9304c RL	27
81fca0e7 SL	28	#define DSA_SELECT_PRIVATE_IMPORTABLE \
	29	(OSSL_KEYMGMT_SELECT_KEYPAIR \| OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS)
	30
ece9304c RL	31	static OSSL_FUNC_encoder_newctx_fn dsa_priv_newctx;
	32	static OSSL_FUNC_encoder_freectx_fn dsa_priv_freectx;
	33	static OSSL_FUNC_encoder_set_ctx_params_fn dsa_priv_set_ctx_params;
	34	static OSSL_FUNC_encoder_settable_ctx_params_fn dsa_priv_settable_ctx_params;
	35	static OSSL_FUNC_encoder_encode_data_fn dsa_priv_der_data;
	36	static OSSL_FUNC_encoder_encode_object_fn dsa_priv_der;
	37	static OSSL_FUNC_encoder_encode_data_fn dsa_pem_priv_data;
	38	static OSSL_FUNC_encoder_encode_object_fn dsa_pem_priv;
	39
	40	static OSSL_FUNC_encoder_newctx_fn dsa_print_newctx;
	41	static OSSL_FUNC_encoder_freectx_fn dsa_print_freectx;
	42	static OSSL_FUNC_encoder_encode_data_fn dsa_priv_print_data;
	43	static OSSL_FUNC_encoder_encode_object_fn dsa_priv_print;
	44
	45	/*
	46	* Context used for private key encoding.
264b789b RL	47	*/
	48	struct dsa_priv_ctx_st {
	49	void *provctx;
	50
	51	struct pkcs8_encrypt_ctx_st sc;
	52	};
	53
	54	/* Private key : context */
	55	static void dsa_priv_newctx(void provctx)
	56	{
	57	struct dsa_priv_ctx_st ctx = OPENSSL_zalloc(sizeof(ctx));
	58
	59	if (ctx != NULL) {
	60	ctx->provctx = provctx;
264b789b	61
75e571b5 P	62	/* -1 is the "whatever" indicator, i.e. the PKCS8 library default PBE */
	63	ctx->sc.pbe_nid = -1;
	64	}
264b789b RL	65	return ctx;
	66	}
	67
	68	static void dsa_priv_freectx(void *vctx)
	69	{
	70	struct dsa_priv_ctx_st *ctx = vctx;
	71
	72	EVP_CIPHER_free(ctx->sc.cipher);
	73	OPENSSL_free(ctx->sc.cipher_pass);
	74	OPENSSL_free(ctx);
	75	}
	76
1017ab21	77	static const OSSL_PARAM dsa_priv_settable_ctx_params(ossl_unused void provctx)
264b789b RL	78	{
264b789b RL	79	static const OSSL_PARAM settables[] = {
ece9304c RL	80	OSSL_PARAM_utf8_string(OSSL_ENCODER_PARAM_CIPHER, NULL, 0),
ece9304c RL	81	OSSL_PARAM_octet_string(OSSL_ENCODER_PARAM_PASS, NULL, 0),
264b789b RL	82	OSSL_PARAM_END,
	83	};
	84
	85	return settables;
	86	}
	87
	88	static int dsa_priv_set_ctx_params(void *vctx, const OSSL_PARAM params[])
	89	{
	90	struct dsa_priv_ctx_st *ctx = vctx;
	91	const OSSL_PARAM *p;
	92
ece9304c	93	if ((p = OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_CIPHER))
264b789b RL	94	!= NULL) {
264b789b RL	95	const OSSL_PARAM *propsp =
ece9304c	96	OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_PROPERTIES);
264b789b RL	97	const char *props = NULL;
	98
	99	if (p->data_type != OSSL_PARAM_UTF8_STRING)
	100	return 0;
	101	if (propsp != NULL && propsp->data_type != OSSL_PARAM_UTF8_STRING)
	102	return 0;
	103	props = (propsp != NULL ? propsp->data : NULL);
	104
	105	EVP_CIPHER_free(ctx->sc.cipher);
	106	ctx->sc.cipher_intent = p->data != NULL;
	107	if (p->data != NULL
	108	&& ((ctx->sc.cipher = EVP_CIPHER_fetch(NULL, p->data, props))
	109	== NULL))
	110	return 0;
	111	}
ece9304c	112	if ((p = OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_PASS))
264b789b RL	113	!= NULL) {
	114	OPENSSL_free(ctx->sc.cipher_pass);
	115	ctx->sc.cipher_pass = NULL;
	116	if (!OSSL_PARAM_get_octet_string(p, &ctx->sc.cipher_pass, 0,
	117	&ctx->sc.cipher_pass_length))
	118	return 0;
	119	}
	120	return 1;
	121	}
	122
	123	/* Private key : DER */
d40b42ab MC	124	static int dsa_priv_der_data(void *vctx, const OSSL_PARAM params[],
d40b42ab MC	125	OSSL_CORE_BIO *out,
264b789b RL	126	OSSL_PASSPHRASE_CALLBACK cb, void cbarg)
	127	{
	128	struct dsa_priv_ctx_st *ctx = vctx;
363b1e5d DMSP	129	OSSL_FUNC_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
	130	OSSL_FUNC_keymgmt_free_fn *dsa_free = ossl_prov_get_keymgmt_dsa_free();
	131	OSSL_FUNC_keymgmt_import_fn *dsa_import = ossl_prov_get_keymgmt_dsa_import();
264b789b RL	132	int ok = 0;
264b789b RL	133
32b0645c RL	134	if (dsa_import != NULL) {
32b0645c RL	135	DSA *dsa;
264b789b	136
32b0645c	137	if ((dsa = dsa_new(ctx->provctx)) != NULL
81fca0e7	138	&& dsa_import(dsa, DSA_SELECT_PRIVATE_IMPORTABLE, params)
32b0645c RL	139	&& dsa_priv_der(ctx, dsa, out, cb, cbarg))
	140	ok = 1;
	141	dsa_free(dsa);
264b789b RL	142	}
	143	return ok;
	144	}
	145
d40b42ab	146	static int dsa_priv_der(void vctx, void dsa, OSSL_CORE_BIO *cout,
264b789b RL	147	OSSL_PASSPHRASE_CALLBACK cb, void cbarg)
	148	{
	149	struct dsa_priv_ctx_st *ctx = vctx;
d40b42ab MC	150	BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
	151	int ret;
	152
	153	if (out == NULL)
	154	return 0;
264b789b RL	155
	156	ctx->sc.cb = cb;
	157	ctx->sc.cbarg = cbarg;
	158
d40b42ab MC	159	ret = ossl_prov_write_priv_der_from_obj(out, dsa, EVP_PKEY_DSA,
	160	ossl_prov_prepare_dsa_params,
	161	ossl_prov_dsa_priv_to_der,
	162	&ctx->sc);
	163	BIO_free(out);
	164
	165	return ret;
264b789b RL	166	}
	167
	168	/* Private key : PEM */
d40b42ab MC	169	static int dsa_pem_priv_data(void *vctx, const OSSL_PARAM params[],
d40b42ab MC	170	OSSL_CORE_BIO *out,
264b789b RL	171	OSSL_PASSPHRASE_CALLBACK cb, void cbarg)
	172	{
	173	struct dsa_priv_ctx_st *ctx = vctx;
363b1e5d DMSP	174	OSSL_FUNC_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
	175	OSSL_FUNC_keymgmt_free_fn *dsa_free = ossl_prov_get_keymgmt_dsa_free();
	176	OSSL_FUNC_keymgmt_import_fn *dsa_import = ossl_prov_get_keymgmt_dsa_import();
264b789b RL	177	int ok = 0;
264b789b RL	178
32b0645c RL	179	if (dsa_import != NULL) {
32b0645c RL	180	DSA *dsa;
264b789b	181
32b0645c	182	if ((dsa = dsa_new(ctx->provctx)) != NULL
81fca0e7	183	&& dsa_import(dsa, DSA_SELECT_PRIVATE_IMPORTABLE, params)
32b0645c RL	184	&& dsa_pem_priv(ctx, dsa, out, cb, cbarg))
	185	ok = 1;
	186	dsa_free(dsa);
264b789b RL	187	}
	188	return ok;
	189	}
	190
d40b42ab	191	static int dsa_pem_priv(void vctx, void dsa, OSSL_CORE_BIO *cout,
264b789b RL	192	OSSL_PASSPHRASE_CALLBACK cb, void cbarg)
	193	{
	194	struct dsa_priv_ctx_st *ctx = vctx;
d40b42ab MC	195	BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
	196	int ret;
	197
	198	if (out == NULL)
	199	return 0;
264b789b RL	200
	201	ctx->sc.cb = cb;
	202	ctx->sc.cbarg = cbarg;
	203
d40b42ab MC	204	ret = ossl_prov_write_priv_pem_from_obj(out, dsa, EVP_PKEY_DSA,
	205	ossl_prov_prepare_dsa_params,
	206	ossl_prov_dsa_priv_to_der,
	207	&ctx->sc);
	208	BIO_free(out);
	209
	210	return ret;
264b789b RL	211	}
	212
	213	/*
	214	* There's no specific print context, so we use the provider context
	215	*/
	216	static void dsa_print_newctx(void provctx)
	217	{
	218	return provctx;
	219	}
	220
	221	static void dsa_print_freectx(void *ctx)
	222	{
	223	}
	224
32b0645c	225	static int dsa_priv_print_data(void *vctx, const OSSL_PARAM params[],
d40b42ab	226	OSSL_CORE_BIO *out,
264b789b RL	227	OSSL_PASSPHRASE_CALLBACK cb, void cbarg)
264b789b RL	228	{
32b0645c	229	struct dsa_priv_ctx_st *ctx = vctx;
363b1e5d DMSP	230	OSSL_FUNC_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
	231	OSSL_FUNC_keymgmt_free_fn *dsa_free = ossl_prov_get_keymgmt_dsa_free();
	232	OSSL_FUNC_keymgmt_import_fn *dsa_import = ossl_prov_get_keymgmt_dsa_import();
264b789b RL	233	int ok = 0;
264b789b RL	234
32b0645c RL	235	if (dsa_import != NULL) {
32b0645c RL	236	DSA *dsa;
264b789b	237
32b0645c	238	if ((dsa = dsa_new(ctx->provctx)) != NULL
81fca0e7	239	&& dsa_import(dsa, DSA_SELECT_PRIVATE_IMPORTABLE, params)
32b0645c RL	240	&& dsa_priv_print(ctx, dsa, out, cb, cbarg))
	241	ok = 1;
	242	dsa_free(dsa);
264b789b RL	243	}
	244	return ok;
	245	}
	246
d40b42ab	247	static int dsa_priv_print(void ctx, void dsa, OSSL_CORE_BIO *cout,
264b789b RL	248	OSSL_PASSPHRASE_CALLBACK cb, void cbarg)
264b789b RL	249	{
d40b42ab MC	250	BIO *out = bio_new_from_core_bio(ctx, cout);
	251	int ret;
	252
	253	if (out == NULL)
	254	return 0;
	255
	256	ret = ossl_prov_print_dsa(out, dsa, dsa_print_priv);
	257	BIO_free(out);
	258
	259	return ret;
264b789b RL	260	}
264b789b RL	261
ece9304c RL	262	const OSSL_DISPATCH dsa_priv_der_encoder_functions[] = {
	263	{ OSSL_FUNC_ENCODER_NEWCTX, (void (*)(void))dsa_priv_newctx },
	264	{ OSSL_FUNC_ENCODER_FREECTX, (void (*)(void))dsa_priv_freectx },
	265	{ OSSL_FUNC_ENCODER_SET_CTX_PARAMS,
264b789b	266	(void (*)(void))dsa_priv_set_ctx_params },
ece9304c	267	{ OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS,
264b789b	268	(void (*)(void))dsa_priv_settable_ctx_params },
ece9304c RL	269	{ OSSL_FUNC_ENCODER_ENCODE_DATA, (void (*)(void))dsa_priv_der_data },
ece9304c RL	270	{ OSSL_FUNC_ENCODER_ENCODE_OBJECT, (void (*)(void))dsa_priv_der },
264b789b RL	271	{ 0, NULL }
	272	};
	273
ece9304c RL	274	const OSSL_DISPATCH dsa_priv_pem_encoder_functions[] = {
	275	{ OSSL_FUNC_ENCODER_NEWCTX, (void (*)(void))dsa_priv_newctx },
	276	{ OSSL_FUNC_ENCODER_FREECTX, (void (*)(void))dsa_priv_freectx },
	277	{ OSSL_FUNC_ENCODER_SET_CTX_PARAMS,
264b789b	278	(void (*)(void))dsa_priv_set_ctx_params },
ece9304c	279	{ OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS,
264b789b	280	(void (*)(void))dsa_priv_settable_ctx_params },
ece9304c RL	281	{ OSSL_FUNC_ENCODER_ENCODE_DATA, (void (*)(void))dsa_pem_priv_data },
ece9304c RL	282	{ OSSL_FUNC_ENCODER_ENCODE_OBJECT, (void (*)(void))dsa_pem_priv },
264b789b RL	283	{ 0, NULL }
	284	};
	285
ece9304c RL	286	const OSSL_DISPATCH dsa_priv_text_encoder_functions[] = {
	287	{ OSSL_FUNC_ENCODER_NEWCTX, (void (*)(void))dsa_print_newctx },
	288	{ OSSL_FUNC_ENCODER_FREECTX, (void (*)(void))dsa_print_freectx },
	289	{ OSSL_FUNC_ENCODER_ENCODE_OBJECT, (void (*)(void))dsa_priv_print },
	290	{ OSSL_FUNC_ENCODER_ENCODE_DATA,
264b789b RL	291	(void (*)(void))dsa_priv_print_data },
	292	{ 0, NULL }
	293	};