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

/*
 * Copyright 2019 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
 */

#include <openssl/opensslconf.h> /* SIXTY_FOUR_BIT_LONG, ... */
#include <openssl/err.h>
#include <openssl/pem.h>         /* PEM_BUFSIZE */
#include <openssl/pkcs12.h>      /* PKCS8_encrypt() */
#include <openssl/types.h>
#include <openssl/x509.h>        /* i2d_X509_PUBKEY_bio() */
#include "crypto/bn.h"           /* bn_get_words() */
#include "prov/bio.h"            /* ossl_prov_bio_printf() */
#include "prov/implementations.h"
#include "prov/providercommonerr.h" /* PROV_R_READ_KEY */
#include "serializer_local.h"

static PKCS8_PRIV_KEY_INFO *
ossl_prov_p8info_from_obj(const void *obj, int obj_nid,
                          ASN1_STRING *params,
                          int params_type,
                          int (*k2d)(const void *obj,
                                     unsigned char **pder))
{
    /* der, derlen store the key DER output and its length */
    unsigned char *der = NULL;
    int derlen;
    /* The final PKCS#8 info */
    PKCS8_PRIV_KEY_INFO *p8info = NULL;


    if ((p8info = PKCS8_PRIV_KEY_INFO_new()) == NULL
        || (derlen = k2d(obj, &der)) <= 0
        || !PKCS8_pkey_set0(p8info, OBJ_nid2obj(obj_nid), 0,
                            params_type, params, der, derlen)) {
        ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
        PKCS8_PRIV_KEY_INFO_free(p8info);
        OPENSSL_free(der);
        p8info = NULL;
    }

    return p8info;
}

static X509_SIG *ossl_prov_encp8_from_p8info(PKCS8_PRIV_KEY_INFO *p8info,
                                             struct pkcs8_encrypt_ctx_st *ctx)
{
    X509_SIG *p8 = NULL;
    char buf[PEM_BUFSIZE];
    const void *kstr = ctx->cipher_pass;
    size_t klen = ctx->cipher_pass_length;

    if (ctx->cipher == NULL)
        return NULL;

    if (kstr == NULL) {
        if (!ctx->cb(buf, sizeof(buf), &klen, NULL, ctx->cbarg)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_READ_KEY);
            return NULL;
        }
        kstr = buf;
    }
    /* NID == -1 means "standard" */
    p8 = PKCS8_encrypt(-1, ctx->cipher, kstr, klen, NULL, 0, 0, p8info);
    if (kstr == buf)
        OPENSSL_cleanse(buf, klen);
    return p8;
}

static X509_SIG *ossl_prov_encp8_from_obj(const void *obj, int obj_nid,
                                          ASN1_STRING *params,
                                          int params_type,
                                          int (*k2d)(const void *obj,
                                                     unsigned char **pder),
                                          struct pkcs8_encrypt_ctx_st *ctx)
{
    PKCS8_PRIV_KEY_INFO *p8info =
        ossl_prov_p8info_from_obj(obj, obj_nid, params, params_type, k2d);
    X509_SIG *p8 = ossl_prov_encp8_from_p8info(p8info, ctx);

    PKCS8_PRIV_KEY_INFO_free(p8info);
    return p8;
}

static X509_PUBKEY *ossl_prov_pubkey_from_obj(const void *obj, int obj_nid,
                                              ASN1_STRING *params,
                                              int params_type,
                                              int (*k2d)(const void *obj,
                                                         unsigned char **pder))
{
    /* der, derlen store the key DER output and its length */
    unsigned char *der = NULL;
    int derlen;
    /* The final X509_PUBKEY */
    X509_PUBKEY *xpk = NULL;


    if ((xpk = X509_PUBKEY_new()) == NULL
        || (derlen = k2d(obj, &der)) <= 0
        || !X509_PUBKEY_set0_param(xpk, OBJ_nid2obj(obj_nid),
                                   params_type, params, der, derlen)) {
        ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
        X509_PUBKEY_free(xpk);
        OPENSSL_free(der);
        xpk = NULL;
    }

    return xpk;
}

OSSL_OP_keymgmt_importkey_fn *ossl_prov_get_importkey(const OSSL_DISPATCH *fns)
{
    /* Pilfer the keymgmt dispatch table */
    for (; fns->function_id != 0; fns++)
        if (fns->function_id == OSSL_FUNC_KEYMGMT_IMPORTKEY)
            return OSSL_get_OP_keymgmt_importkey(fns);

    return NULL;
}

# ifdef SIXTY_FOUR_BIT_LONG
#  define BN_FMTu "%lu"
#  define BN_FMTx "%lx"
# endif

# ifdef SIXTY_FOUR_BIT
#  define BN_FMTu "%llu"
#  define BN_FMTx "%llx"
# endif

# ifdef THIRTY_TWO_BIT
#  define BN_FMTu "%u"
#  define BN_FMTx "%x"
# endif

int ossl_prov_print_labeled_bignum(BIO *out, const char *label,
                                   const BIGNUM *bn)
{
    const char *neg;
    const char *post_label_spc = " ";
    int bytes;
    BN_ULONG *words;
    int n, i;

    if (bn == NULL)
        return 0;
    if (label == NULL) {
        label = "";
        post_label_spc = "";
    }

    bytes = BN_num_bytes(bn);
    words = bn_get_words(bn);
    neg = BN_is_negative(bn) ? "-" : "";

    if (BN_is_zero(bn))
        return ossl_prov_bio_printf(out, "%s%s0\n", label, post_label_spc);

    if (BN_num_bytes(bn) <= BN_BYTES)
        return ossl_prov_bio_printf(out,
                                    "%s%s%s" BN_FMTu " (%s0x" BN_FMTx ")\n",
                                    label, post_label_spc, neg, words[0],
                                    neg, words[0]);

    if (neg[0] == '-')
        neg = " (Negative)";

    if (ossl_prov_bio_printf(out, "%s%s\n", label, neg) <= 0)
        return 0;

    /* Keep track of how many bytes we have printed out so far */
    n = 0;

    /*
     * OpenSSL BIGNUMs are little endian limbs, so we print them last to
     * first limb.
     * i is used as limb index, j is used as the "byte index" in the limb
     */
    for (i = bytes / BN_BYTES - 1; i >= 0; i--) {
        BN_ULONG l = words[i];
        int  j;

        for (j = BN_BYTES - 1; j >= 0; j--) {
            int o = 8 * j;
            int b = ((l & (0xffLU << o)) >> o) & 0xff;

            /* Indent every new line with 4 spaces */
            if ((n % 15) == 0) {
                if (n > 0)
                    if (ossl_prov_bio_printf(out, "\n") <= 0)
                        return 0;
                if (ossl_prov_bio_printf(out, "    ") <= 0)
                    return 0;
            }

            /*
             * Upper bit set, then we print an extra zero and pretend the
             * BIGNUM was one byte longer
             */
            if (n == 0 && b > 127) {
                if (ossl_prov_bio_printf(out, "%02x:", 0) <= 0)
                    return 0;
                n++;
                bytes++;
            }

            if (++n < bytes) {
                if (ossl_prov_bio_printf(out, "%02x:", b) <= 0)
                    return 0;
            } else {
                if (ossl_prov_bio_printf(out, "%02x", b) <= 0)
                    return 0;
            }
        }
    }
    if (ossl_prov_bio_printf(out, "\n") <= 0)
        return 0;

    return 1;
}

/* p2s = param to asn1_string, k2d = key to der */
int ossl_prov_write_priv_der_from_obj(BIO *out, const void *obj, int obj_nid,
                                      int (*p2s)(const void *obj, int nid,
                                                 ASN1_STRING **str,
                                                 int *strtype),
                                      int (*k2d)(const void *obj,
                                                 unsigned char **pder),
                                      struct pkcs8_encrypt_ctx_st *ctx)
{
    int ret = 0;
    ASN1_STRING *str = NULL;
    int strtype = 0;

    if (p2s != NULL && !p2s(obj, obj_nid, &str, &strtype))
        return 0;

    if (ctx->cipher_intent) {
        X509_SIG *p8 =
            ossl_prov_encp8_from_obj(obj, obj_nid, str, strtype, k2d, ctx);

        if (p8 != NULL)
            ret = i2d_PKCS8_bio(out, p8);

        X509_SIG_free(p8);
    } else {
        PKCS8_PRIV_KEY_INFO *p8info =
            ossl_prov_p8info_from_obj(obj, obj_nid, str, strtype, k2d);

        if (p8info != NULL)
            ret = i2d_PKCS8_PRIV_KEY_INFO_bio(out, p8info);

        PKCS8_PRIV_KEY_INFO_free(p8info);
    }

    return ret;
}

int ossl_prov_write_priv_pem_from_obj(BIO *out, const void *obj, int obj_nid,
                                      int (*p2s)(const void *obj, int nid,
                                                 ASN1_STRING **str,
                                                 int *strtype),
                                      int (*k2d)(const void *obj,
                                                 unsigned char **pder),
                                      struct pkcs8_encrypt_ctx_st *ctx)
{
    int ret = 0;
    ASN1_STRING *str = NULL;
    int strtype = 0;

    if (p2s != NULL && !p2s(obj, obj_nid, &str, &strtype))
        return 0;

    if (ctx->cipher_intent) {
        X509_SIG *p8 = ossl_prov_encp8_from_obj(obj, obj_nid, str, strtype,
                                                k2d, ctx);

        if (p8 != NULL)
            ret = PEM_write_bio_PKCS8(out, p8);

        X509_SIG_free(p8);
    } else {
        PKCS8_PRIV_KEY_INFO *p8info =
            ossl_prov_p8info_from_obj(obj, obj_nid, str, strtype, k2d);

        if (p8info != NULL)
            ret = PEM_write_bio_PKCS8_PRIV_KEY_INFO(out, p8info);

        PKCS8_PRIV_KEY_INFO_free(p8info);
    }

    return ret;
}

int ossl_prov_write_pub_der_from_obj(BIO *out, const void *obj, int obj_nid,
                                     int (*p2s)(const void *obj, int nid,
                                                ASN1_STRING **str,
                                                int *strtype),
                                     int (*k2d)(const void *obj,
                                                unsigned char **pder))
{
    int ret = 0;
    ASN1_STRING *str = NULL;
    int strtype = 0;
    X509_PUBKEY *xpk = NULL;

    if (p2s != NULL && !p2s(obj, obj_nid, &str, &strtype))
        return 0;

    xpk = ossl_prov_pubkey_from_obj(obj, obj_nid, str, strtype, k2d);

    if (xpk != NULL)
        ret = i2d_X509_PUBKEY_bio(out, xpk);

    /* Also frees |str| */
    X509_PUBKEY_free(xpk);
    return ret;
}

int ossl_prov_write_pub_pem_from_obj(BIO *out, const void *obj, int obj_nid,
                                     int (*p2s)(const void *obj, int nid,
                                                ASN1_STRING **str,
                                                int *strtype),
                                     int (*k2d)(const void *obj,
                                                unsigned char **pder))
{
    int ret = 0;
    ASN1_STRING *str = NULL;
    int strtype = 0;
    X509_PUBKEY *xpk = NULL;

    if (p2s != NULL && !p2s(obj, obj_nid, &str, &strtype))
        return 0;

    xpk = ossl_prov_pubkey_from_obj(obj, obj_nid, str, strtype, k2d);

    if (xpk != NULL)
        ret = PEM_write_bio_X509_PUBKEY(out, xpk);

    /* Also frees |str| */
    X509_PUBKEY_free(xpk);
    return ret;
}
Commit	Line	Data
cb58d81e RL	1	/*
	2	* Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
	3	*
	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
	8	*/
	9
	10	#include <openssl/opensslconf.h> /* SIXTY_FOUR_BIT_LONG, ... */
	11	#include <openssl/err.h>
	12	#include <openssl/pem.h> /* PEM_BUFSIZE */
	13	#include <openssl/pkcs12.h> /* PKCS8_encrypt() */
	14	#include <openssl/types.h>
	15	#include <openssl/x509.h> /* i2d_X509_PUBKEY_bio() */
	16	#include "crypto/bn.h" /* bn_get_words() */
	17	#include "prov/bio.h" /* ossl_prov_bio_printf() */
	18	#include "prov/implementations.h"
	19	#include "prov/providercommonerr.h" /* PROV_R_READ_KEY */
	20	#include "serializer_local.h"
	21
	22	static PKCS8_PRIV_KEY_INFO *
	23	ossl_prov_p8info_from_obj(const void *obj, int obj_nid,
	24	ASN1_STRING *params,
	25	int params_type,
	26	int (k2d)(const void obj,
	27	unsigned char **pder))
	28	{
	29	/* der, derlen store the key DER output and its length */
	30	unsigned char *der = NULL;
	31	int derlen;
	32	/* The final PKCS#8 info */
	33	PKCS8_PRIV_KEY_INFO *p8info = NULL;
	34
	35
	36	if ((p8info = PKCS8_PRIV_KEY_INFO_new()) == NULL
	37	\|\| (derlen = k2d(obj, &der)) <= 0
	38	\|\| !PKCS8_pkey_set0(p8info, OBJ_nid2obj(obj_nid), 0,
	39	params_type, params, der, derlen)) {
	40	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
	41	PKCS8_PRIV_KEY_INFO_free(p8info);
	42	OPENSSL_free(der);
	43	p8info = NULL;
	44	}
	45
	46	return p8info;
	47	}
	48
	49	static X509_SIG ossl_prov_encp8_from_p8info(PKCS8_PRIV_KEY_INFO p8info,
	50	struct pkcs8_encrypt_ctx_st *ctx)
	51	{
	52	X509_SIG *p8 = NULL;
	53	char buf[PEM_BUFSIZE];
	54	const void *kstr = ctx->cipher_pass;
	55	size_t klen = ctx->cipher_pass_length;
	56
	57	if (ctx->cipher == NULL)
	58	return NULL;
	59
	60	if (kstr == NULL) {
	61	if (!ctx->cb(buf, sizeof(buf), &klen, NULL, ctx->cbarg)) {
	62	ERR_raise(ERR_LIB_PROV, PROV_R_READ_KEY);
	63	return NULL;
	64	}
65	kstr = buf;
66	}
67	/* NID == -1 means "standard" */
68	p8 = PKCS8_encrypt(-1, ctx->cipher, kstr, klen, NULL, 0, 0, p8info);
69	if (kstr == buf)
70	OPENSSL_cleanse(buf, klen);
71	return p8;
72	}
73
74	static X509_SIG ossl_prov_encp8_from_obj(const void obj, int obj_nid,
75	ASN1_STRING *params,
76	int params_type,
77	int (k2d)(const void obj,
78	unsigned char **pder),
79	struct pkcs8_encrypt_ctx_st *ctx)
80	{
81	PKCS8_PRIV_KEY_INFO *p8info =
82	ossl_prov_p8info_from_obj(obj, obj_nid, params, params_type, k2d);
83	X509_SIG *p8 = ossl_prov_encp8_from_p8info(p8info, ctx);
84
85	PKCS8_PRIV_KEY_INFO_free(p8info);
86	return p8;
87	}
88
89	static X509_PUBKEY ossl_prov_pubkey_from_obj(const void obj, int obj_nid,
90	ASN1_STRING *params,
91	int params_type,
92	int (k2d)(const void obj,
93	unsigned char **pder))
94	{
95	/* der, derlen store the key DER output and its length */
96	unsigned char *der = NULL;
97	int derlen;
98	/* The final X509_PUBKEY */
99	X509_PUBKEY *xpk = NULL;
100
101
102	if ((xpk = X509_PUBKEY_new()) == NULL
103	\|\| (derlen = k2d(obj, &der)) <= 0
104	\|\| !X509_PUBKEY_set0_param(xpk, OBJ_nid2obj(obj_nid),
105	params_type, params, der, derlen)) {
106	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
107	X509_PUBKEY_free(xpk);
108	OPENSSL_free(der);
109	xpk = NULL;
110	}
111
112	return xpk;
113	}
114
115	OSSL_OP_keymgmt_importkey_fn ossl_prov_get_importkey(const OSSL_DISPATCH fns)
116	{
117	/* Pilfer the keymgmt dispatch table */
118	for (; fns->function_id != 0; fns++)
119	if (fns->function_id == OSSL_FUNC_KEYMGMT_IMPORTKEY)
120	return OSSL_get_OP_keymgmt_importkey(fns);
121
122	return NULL;
123	}
124
125	# ifdef SIXTY_FOUR_BIT_LONG
126	# define BN_FMTu "%lu"
127	# define BN_FMTx "%lx"
128	# endif
129
130	# ifdef SIXTY_FOUR_BIT
131	# define BN_FMTu "%llu"
132	# define BN_FMTx "%llx"
133	# endif
134
135	# ifdef THIRTY_TWO_BIT
136	# define BN_FMTu "%u"
137	# define BN_FMTx "%x"
138	# endif
139
140	int ossl_prov_print_labeled_bignum(BIO out, const char label,
a88aef32	141	const BIGNUM *bn)
cb58d81e RL	142	{
	143	const char *neg;
	144	const char *post_label_spc = " ";
	145	int bytes;
	146	BN_ULONG *words;
a88aef32	147	int n, i;
cb58d81e	148
a88aef32	149	if (bn == NULL)
cb58d81e RL	150	return 0;
	151	if (label == NULL) {
	152	label = "";
	153	post_label_spc = "";
	154	}
	155
a88aef32 RL	156	bytes = BN_num_bytes(bn);
	157	words = bn_get_words(bn);
	158	neg = BN_is_negative(bn) ? "-" : "";
cb58d81e	159
a88aef32	160	if (BN_is_zero(bn))
cb58d81e RL	161	return ossl_prov_bio_printf(out, "%s%s0\n", label, post_label_spc);
cb58d81e RL	162
a88aef32	163	if (BN_num_bytes(bn) <= BN_BYTES)
cb58d81e RL	164	return ossl_prov_bio_printf(out,
	165	"%s%s%s" BN_FMTu " (%s0x" BN_FMTx ")\n",
	166	label, post_label_spc, neg, words[0],
	167	neg, words[0]);
	168
	169	if (neg[0] == '-')
	170	neg = " (Negative)";
	171
	172	if (ossl_prov_bio_printf(out, "%s%s\n", label, neg) <= 0)
	173	return 0;
	174
a88aef32 RL	175	/* Keep track of how many bytes we have printed out so far */
	176	n = 0;
	177
	178	/*
	179	* OpenSSL BIGNUMs are little endian limbs, so we print them last to
	180	* first limb.
	181	* i is used as limb index, j is used as the "byte index" in the limb
	182	*/
	183	for (i = bytes / BN_BYTES - 1; i >= 0; i--) {
	184	BN_ULONG l = words[i];
	185	int j;
	186
	187	for (j = BN_BYTES - 1; j >= 0; j--) {
	188	int o = 8 * j;
	189	int b = ((l & (0xffLU << o)) >> o) & 0xff;
	190
	191	/* Indent every new line with 4 spaces */
	192	if ((n % 15) == 0) {
	193	if (n > 0)
	194	if (ossl_prov_bio_printf(out, "\n") <= 0)
	195	return 0;
	196	if (ossl_prov_bio_printf(out, " ") <= 0)
	197	return 0;
	198	}
cb58d81e	199
a88aef32 RL	200	/*
	201	* Upper bit set, then we print an extra zero and pretend the
	202	* BIGNUM was one byte longer
	203	*/
	204	if (n == 0 && b > 127) {
	205	if (ossl_prov_bio_printf(out, "%02x:", 0) <= 0)
	206	return 0;
	207	n++;
	208	bytes++;
	209	}
cb58d81e	210
a88aef32	211	if (++n < bytes) {
cb58d81e RL	212	if (ossl_prov_bio_printf(out, "%02x:", b) <= 0)
cb58d81e RL	213	return 0;
a88aef32 RL	214	} else {
	215	if (ossl_prov_bio_printf(out, "%02x", b) <= 0)
	216	return 0;
cb58d81e RL	217	}
cb58d81e RL	218	}
cb58d81e	219	}
a88aef32 RL	220	if (ossl_prov_bio_printf(out, "\n") <= 0)
a88aef32 RL	221	return 0;
cb58d81e RL	222
	223	return 1;
	224	}
	225
	226	/* p2s = param to asn1_string, k2d = key to der */
	227	int ossl_prov_write_priv_der_from_obj(BIO out, const void obj, int obj_nid,
	228	int (p2s)(const void obj, int nid,
	229	ASN1_STRING **str,
	230	int *strtype),
	231	int (k2d)(const void obj,
	232	unsigned char **pder),
	233	struct pkcs8_encrypt_ctx_st *ctx)
	234	{
	235	int ret = 0;
	236	ASN1_STRING *str = NULL;
	237	int strtype = 0;
	238
	239	if (p2s != NULL && !p2s(obj, obj_nid, &str, &strtype))
	240	return 0;
	241
	242	if (ctx->cipher_intent) {
	243	X509_SIG *p8 =
	244	ossl_prov_encp8_from_obj(obj, obj_nid, str, strtype, k2d, ctx);
	245
	246	if (p8 != NULL)
	247	ret = i2d_PKCS8_bio(out, p8);
	248
	249	X509_SIG_free(p8);
	250	} else {
	251	PKCS8_PRIV_KEY_INFO *p8info =
	252	ossl_prov_p8info_from_obj(obj, obj_nid, str, strtype, k2d);
	253
	254	if (p8info != NULL)
	255	ret = i2d_PKCS8_PRIV_KEY_INFO_bio(out, p8info);
	256
	257	PKCS8_PRIV_KEY_INFO_free(p8info);
	258	}
	259
	260	return ret;
	261	}
	262
	263	int ossl_prov_write_priv_pem_from_obj(BIO out, const void obj, int obj_nid,
	264	int (p2s)(const void obj, int nid,
	265	ASN1_STRING **str,
	266	int *strtype),
	267	int (k2d)(const void obj,
	268	unsigned char **pder),
	269	struct pkcs8_encrypt_ctx_st *ctx)
	270	{
	271	int ret = 0;
	272	ASN1_STRING *str = NULL;
	273	int strtype = 0;
	274
	275	if (p2s != NULL && !p2s(obj, obj_nid, &str, &strtype))
	276	return 0;
	277
	278	if (ctx->cipher_intent) {
	279	X509_SIG *p8 = ossl_prov_encp8_from_obj(obj, obj_nid, str, strtype,
	280	k2d, ctx);
	281
	282	if (p8 != NULL)
	283	ret = PEM_write_bio_PKCS8(out, p8);
	284
	285	X509_SIG_free(p8);
286	} else {
287	PKCS8_PRIV_KEY_INFO *p8info =
288	ossl_prov_p8info_from_obj(obj, obj_nid, str, strtype, k2d);
289
290	if (p8info != NULL)
291	ret = PEM_write_bio_PKCS8_PRIV_KEY_INFO(out, p8info);
292
293	PKCS8_PRIV_KEY_INFO_free(p8info);
294	}
295
296	return ret;
297	}
298
299	int ossl_prov_write_pub_der_from_obj(BIO out, const void obj, int obj_nid,
300	int (p2s)(const void obj, int nid,
301	ASN1_STRING **str,
302	int *strtype),
303	int (k2d)(const void obj,
304	unsigned char **pder))
305	{
306	int ret = 0;
307	ASN1_STRING *str = NULL;
308	int strtype = 0;
309	X509_PUBKEY *xpk = NULL;
310
311	if (p2s != NULL && !p2s(obj, obj_nid, &str, &strtype))
312	return 0;
313
314	xpk = ossl_prov_pubkey_from_obj(obj, obj_nid, str, strtype, k2d);
315
316	if (xpk != NULL)
317	ret = i2d_X509_PUBKEY_bio(out, xpk);
318
319	/* Also frees \|str\| */
320	X509_PUBKEY_free(xpk);
321	return ret;
322	}
323
324	int ossl_prov_write_pub_pem_from_obj(BIO out, const void obj, int obj_nid,
325	int (p2s)(const void obj, int nid,
326	ASN1_STRING **str,
327	int *strtype),
328	int (k2d)(const void obj,
329	unsigned char **pder))
330	{
331	int ret = 0;
332	ASN1_STRING *str = NULL;
333	int strtype = 0;
334	X509_PUBKEY *xpk = NULL;
335
336	if (p2s != NULL && !p2s(obj, obj_nid, &str, &strtype))
337	return 0;
338
339	xpk = ossl_prov_pubkey_from_obj(obj, obj_nid, str, strtype, k2d);
340
341	if (xpk != NULL)
342	ret = PEM_write_bio_X509_PUBKEY(out, xpk);
343
344	/* Also frees \|str\| */
345	X509_PUBKEY_free(xpk);
346	return ret;
347	}
348