[thirdparty/openssl.git] / crypto / param_build.c

/*
 * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
 * Copyright (c) 2019, Oracle and/or its affiliates.  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 <string.h>
#include <openssl/err.h>
#include <openssl/cryptoerr.h>
#include <openssl/params.h>
#include "internal/cryptlib.h"
#include "internal/param_build.h"

#define OSSL_PARAM_ALLOCATED_END    127

typedef union {
    OSSL_UNION_ALIGN;
} OSSL_PARAM_BLD_BLOCK;

#define ALIGN_SIZE  sizeof(OSSL_PARAM_BLD_BLOCK)

static size_t bytes_to_blocks(size_t bytes)
{
    return (bytes + ALIGN_SIZE - 1) / ALIGN_SIZE;
}

static OSSL_PARAM_BLD_DEF *param_push(OSSL_PARAM_BLD *bld, const char *key,
                                      int size, size_t alloc, int type,
                                      int secure)
{
    OSSL_PARAM_BLD_DEF *pd;

    if (bld->curr >= OSSL_PARAM_BLD_MAX) {
        CRYPTOerr(CRYPTO_F_PARAM_PUSH, CRYPTO_R_TOO_MANY_RECORDS);
        return NULL;
    }
    pd = bld->params + bld->curr++;
    memset(pd, 0, sizeof(*pd));
    pd->key = key;
    pd->type = type;
    pd->size = size;
    pd->alloc_blocks = bytes_to_blocks(size);
    if ((pd->secure = secure) != 0)
        bld->secure_blocks += pd->alloc_blocks;
    else
        bld->total_blocks += pd->alloc_blocks;
    return pd;
}

static int param_push_num(OSSL_PARAM_BLD *bld, const char *key,
                          void *num, size_t size, int type)
{
    OSSL_PARAM_BLD_DEF *pd = param_push(bld, key, size, size, type, 0);

    if (pd == NULL)
        return 0;
    if (size > sizeof(pd->num)) {
        CRYPTOerr(CRYPTO_F_PARAM_PUSH_NUM, CRYPTO_R_TOO_MANY_BYTES);
        return 0;
    }
    memcpy(&pd->num, num, size);
    return 1;
}

void ossl_param_bld_init(OSSL_PARAM_BLD *bld)
{
    memset(bld, 0, sizeof(*bld));
}

int ossl_param_bld_push_int(OSSL_PARAM_BLD *bld, const char *key, int num)
{
    return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_INTEGER);
}

int ossl_param_bld_push_uint(OSSL_PARAM_BLD *bld, const char *key,
                             unsigned int num)
{
    return param_push_num(bld, key, &num, sizeof(num),
                          OSSL_PARAM_UNSIGNED_INTEGER);
}

int ossl_param_bld_push_long(OSSL_PARAM_BLD *bld, const char *key,
                             long int num)
{
    return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_INTEGER);
}

int ossl_param_bld_push_ulong(OSSL_PARAM_BLD *bld, const char *key,
                              unsigned long int num)
{
    return param_push_num(bld, key, &num, sizeof(num),
                          OSSL_PARAM_UNSIGNED_INTEGER);
}

int ossl_param_bld_push_int32(OSSL_PARAM_BLD *bld, const char *key,
                              int32_t num)
{
    return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_INTEGER);
}

int ossl_param_bld_push_uint32(OSSL_PARAM_BLD *bld, const char *key,
                               uint32_t num)
{
    return param_push_num(bld, key, &num, sizeof(num),
                          OSSL_PARAM_UNSIGNED_INTEGER);
}

int ossl_param_bld_push_int64(OSSL_PARAM_BLD *bld, const char *key,
                              int64_t num)
{
    return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_INTEGER);
}

int ossl_param_bld_push_uint64(OSSL_PARAM_BLD *bld, const char *key,
                               uint64_t num)
{
    return param_push_num(bld, key, &num, sizeof(num),
                          OSSL_PARAM_UNSIGNED_INTEGER);
}

int ossl_param_bld_push_size_t(OSSL_PARAM_BLD *bld, const char *key,
                               size_t num)
{
    return param_push_num(bld, key, &num, sizeof(num),
                          OSSL_PARAM_UNSIGNED_INTEGER);
}

int ossl_param_bld_push_double(OSSL_PARAM_BLD *bld, const char *key,
                               double num)
{
    return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_REAL);
}

int ossl_param_bld_push_BN(OSSL_PARAM_BLD *bld, const char *key,
                           const BIGNUM *bn)
{
    int sz = -1, secure = 0;
    OSSL_PARAM_BLD_DEF *pd;

    if (bn != NULL) {
        sz = BN_num_bytes(bn);
        if (sz < 0) {
            CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_PUSH_BN,
                      CRYPTO_R_ZERO_LENGTH_NUMBER);
            return 0;
        }
        if (BN_get_flags(bn, BN_FLG_SECURE) == BN_FLG_SECURE)
            secure = 1;
    }
    pd = param_push(bld, key, sz, sz >= 0 ? sz : 0,
                    OSSL_PARAM_UNSIGNED_INTEGER, secure);
    if (pd == NULL)
        return 0;
    pd->bn = bn;
    return 1;
}

int ossl_param_bld_push_utf8_string(OSSL_PARAM_BLD *bld, const char *key,
                                    const char *buf, size_t bsize)
{
    OSSL_PARAM_BLD_DEF *pd;

    if (bsize == 0) {
        bsize = strlen(buf) + 1;
    } else if (bsize > INT_MAX) {
        CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_PUSH_UTF8_STRING,
                  CRYPTO_R_STRING_TOO_LONG);
        return 0;
    }
    pd = param_push(bld, key, bsize, bsize, OSSL_PARAM_UTF8_STRING, 0);
    if (pd == NULL)
        return 0;
    pd->string = buf;
    return 1;
}

int ossl_param_bld_push_utf8_ptr(OSSL_PARAM_BLD *bld, const char *key,
                                 char *buf, size_t bsize)
{
    OSSL_PARAM_BLD_DEF *pd;

    if (bsize == 0) {
        bsize = strlen(buf) + 1;
    } else if (bsize > INT_MAX) {
        CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_PUSH_UTF8_PTR,
                  CRYPTO_R_STRING_TOO_LONG);
        return 0;
    }
    pd = param_push(bld, key, bsize, sizeof(buf), OSSL_PARAM_UTF8_PTR, 0);
    if (pd == NULL)
        return 0;
    pd->string = buf;
    return 1;
}

int ossl_param_bld_push_octet_string(OSSL_PARAM_BLD *bld, const char *key,
                                     const void *buf, size_t bsize)
{
    OSSL_PARAM_BLD_DEF *pd;

    if (bsize > INT_MAX) {
        CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_PUSH_OCTET_STRING,
                  CRYPTO_R_STRING_TOO_LONG);
        return 0;
    }
    pd = param_push(bld, key, bsize, bsize, OSSL_PARAM_OCTET_STRING, 0);
    if (pd == NULL)
        return 0;
    pd->string = buf;
    return 1;
}

int ossl_param_bld_push_octet_ptr(OSSL_PARAM_BLD *bld, const char *key,
                                  void *buf, size_t bsize)
{
    OSSL_PARAM_BLD_DEF *pd;

    if (bsize > INT_MAX) {
        CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_PUSH_OCTET_PTR,
                  CRYPTO_R_STRING_TOO_LONG);
        return 0;
    }
    pd = param_push(bld, key, bsize, sizeof(buf), OSSL_PARAM_OCTET_PTR, 0);
    if (pd == NULL)
        return 0;
    pd->string = buf;
    return 1;
}

static OSSL_PARAM *param_bld_convert(OSSL_PARAM_BLD *bld, OSSL_PARAM *param,
                                     OSSL_PARAM_BLD_BLOCK *blk,
                                     OSSL_PARAM_BLD_BLOCK *secure)
{
    size_t i;
    OSSL_PARAM_BLD_DEF *pd;
    void *p;

    for (i = 0; i < bld->curr; i++) {
        pd = bld->params + i;
        param[i].key = pd->key;
        param[i].data_type = pd->type;
        param[i].data_size = pd->size;
        param[i].return_size = 0;

        if (pd->secure) {
            p = secure;
            secure += pd->alloc_blocks;
        } else {
            p = blk;
            blk += pd->alloc_blocks;
        }
        param[i].data = p;
        if (pd->bn != NULL) {
            /* BIGNUM */
            BN_bn2nativepad(pd->bn, (unsigned char *)p, pd->size);
        } else if (pd->type == OSSL_PARAM_OCTET_PTR
                   || pd->type == OSSL_PARAM_UTF8_PTR) {
            /* PTR */
            *(const void **)p = pd->string;
        } else if (pd->type == OSSL_PARAM_OCTET_STRING
                   || pd->type == OSSL_PARAM_UTF8_STRING) {
            if (pd->string != NULL)
                memcpy(p, pd->string, pd->size);
            else
                memset(p, 0, pd->size);
        } else {
            /* Number, but could also be a NULL BIGNUM */
            if (pd->size > sizeof(pd->num))
                memset(p, 0, pd->size);
            else if (pd->size > 0)
                memcpy(p, &pd->num, pd->size);
        }
    }
    param[i] = OSSL_PARAM_construct_end();
    return param + i;
}

OSSL_PARAM *ossl_param_bld_to_param(OSSL_PARAM_BLD *bld)
{
    OSSL_PARAM_BLD_BLOCK *blk, *s = NULL;
    OSSL_PARAM *params, *last;
    const size_t p_blks = bytes_to_blocks((1 + bld->curr) * sizeof(*params));
    const size_t total = ALIGN_SIZE * (p_blks + bld->total_blocks);
    const size_t ss = ALIGN_SIZE * bld->secure_blocks;

    if (ss > 0) {
        s = OPENSSL_secure_malloc(ss);
        if (s == NULL) {
            CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM,
                      CRYPTO_R_SECURE_MALLOC_FAILURE);
            return NULL;
        }
    }
    params = OPENSSL_malloc(total);
    if (params == NULL) {
        CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM, ERR_R_MALLOC_FAILURE);
        OPENSSL_secure_free(s);
        return NULL;
    }
    blk = p_blks + (OSSL_PARAM_BLD_BLOCK *)(params);
    last = param_bld_convert(bld, params, blk, s);
    last->data_size = ss;
    last->data = s;
    last->data_type = OSSL_PARAM_ALLOCATED_END;
    return params;
}

void ossl_param_bld_free(OSSL_PARAM *params)
{
    if (params != NULL) {
        OSSL_PARAM *p;

        for (p = params; p->key != NULL; p++)
            ;
        if (p->data_type == OSSL_PARAM_ALLOCATED_END)
            OPENSSL_secure_clear_free(p->data, p->data_size);
        OPENSSL_free(params);
    }
}

OSSL_PARAM *ossl_param_bld_to_param_ex(OSSL_PARAM_BLD *bld, OSSL_PARAM *params,
                                       size_t param_n, void *data,
                                       size_t data_n, void *secure,
                                       size_t secure_n)
{
    if (params == NULL || data == NULL) {
        CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM_EX,
                  CRYPTO_R_INVALID_NULL_ARGUMENT);
        return NULL;
    }
    if (param_n < bld->curr + 1) {
        CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM_EX,
                  CRYPTO_R_INSUFFICIENT_PARAM_SIZE);
        return NULL;
    }
    if (data_n < ALIGN_SIZE * bld->total_blocks) {
        CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM_EX,
                  CRYPTO_R_INSUFFICIENT_DATA_SPACE);
        return NULL;
    }
    if (bld->secure_blocks > 0 && secure_n < ALIGN_SIZE * bld->secure_blocks) {
        CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM_EX,
                  CRYPTO_R_INSUFFICIENT_SECURE_DATA_SPACE);
        return NULL;
    }
    param_bld_convert(bld, params, (OSSL_PARAM_BLD_BLOCK *)data,
                      (OSSL_PARAM_BLD_BLOCK *)secure);
    return params;
}
Commit	Line	Data
3c93fbac P	1	/*
	2	* Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
	3	* Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
	4	*
	5	* Licensed under the Apache License 2.0 (the "License"). You may not use
	6	* this file except in compliance with the License. You can obtain a copy
	7	* in the file LICENSE in the source distribution or at
	8	* https://www.openssl.org/source/license.html
	9	*/
	10
	11	#include <string.h>
	12	#include <openssl/err.h>
	13	#include <openssl/cryptoerr.h>
	14	#include <openssl/params.h>
	15	#include "internal/cryptlib.h"
	16	#include "internal/param_build.h"
	17
7312ef3f P	18	#define OSSL_PARAM_ALLOCATED_END 127
7312ef3f P	19
3c93fbac P	20	typedef union {
	21	OSSL_UNION_ALIGN;
	22	} OSSL_PARAM_BLD_BLOCK;
	23
	24	#define ALIGN_SIZE sizeof(OSSL_PARAM_BLD_BLOCK)
	25
	26	static size_t bytes_to_blocks(size_t bytes)
	27	{
	28	return (bytes + ALIGN_SIZE - 1) / ALIGN_SIZE;
	29	}
	30
	31	static OSSL_PARAM_BLD_DEF param_push(OSSL_PARAM_BLD bld, const char *key,
	32	int size, size_t alloc, int type,
	33	int secure)
	34	{
	35	OSSL_PARAM_BLD_DEF *pd;
	36
	37	if (bld->curr >= OSSL_PARAM_BLD_MAX) {
	38	CRYPTOerr(CRYPTO_F_PARAM_PUSH, CRYPTO_R_TOO_MANY_RECORDS);
	39	return NULL;
	40	}
	41	pd = bld->params + bld->curr++;
	42	memset(pd, 0, sizeof(*pd));
	43	pd->key = key;
	44	pd->type = type;
	45	pd->size = size;
	46	pd->alloc_blocks = bytes_to_blocks(size);
	47	if ((pd->secure = secure) != 0)
	48	bld->secure_blocks += pd->alloc_blocks;
	49	else
	50	bld->total_blocks += pd->alloc_blocks;
	51	return pd;
	52	}
	53
	54	static int param_push_num(OSSL_PARAM_BLD bld, const char key,
	55	void *num, size_t size, int type)
	56	{
	57	OSSL_PARAM_BLD_DEF *pd = param_push(bld, key, size, size, type, 0);
	58
	59	if (pd == NULL)
	60	return 0;
	61	if (size > sizeof(pd->num)) {
	62	CRYPTOerr(CRYPTO_F_PARAM_PUSH_NUM, CRYPTO_R_TOO_MANY_BYTES);
	63	return 0;
	64	}
	65	memcpy(&pd->num, num, size);
	66	return 1;
	67	}
	68
	69	void ossl_param_bld_init(OSSL_PARAM_BLD *bld)
	70	{
	71	memset(bld, 0, sizeof(*bld));
	72	}
	73
	74	int ossl_param_bld_push_int(OSSL_PARAM_BLD bld, const char key, int num)
	75	{
	76	return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_INTEGER);
	77	}
	78
	79	int ossl_param_bld_push_uint(OSSL_PARAM_BLD bld, const char key,
	80	unsigned int num)
	81	{
	82	return param_push_num(bld, key, &num, sizeof(num),
	83	OSSL_PARAM_UNSIGNED_INTEGER);
84	}
85
86	int ossl_param_bld_push_long(OSSL_PARAM_BLD bld, const char key,
87	long int num)
88	{
89	return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_INTEGER);
90	}
91
92	int ossl_param_bld_push_ulong(OSSL_PARAM_BLD bld, const char key,
93	unsigned long int num)
94	{
95	return param_push_num(bld, key, &num, sizeof(num),
96	OSSL_PARAM_UNSIGNED_INTEGER);
97	}
98
99	int ossl_param_bld_push_int32(OSSL_PARAM_BLD bld, const char key,
100	int32_t num)
101	{
102	return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_INTEGER);
103	}
104
105	int ossl_param_bld_push_uint32(OSSL_PARAM_BLD bld, const char key,
106	uint32_t num)
107	{
108	return param_push_num(bld, key, &num, sizeof(num),
109	OSSL_PARAM_UNSIGNED_INTEGER);
110	}
111
112	int ossl_param_bld_push_int64(OSSL_PARAM_BLD bld, const char key,
113	int64_t num)
114	{
115	return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_INTEGER);
116	}
117
118	int ossl_param_bld_push_uint64(OSSL_PARAM_BLD bld, const char key,
119	uint64_t num)
120	{
121	return param_push_num(bld, key, &num, sizeof(num),
122	OSSL_PARAM_UNSIGNED_INTEGER);
123	}
124
125	int ossl_param_bld_push_size_t(OSSL_PARAM_BLD bld, const char key,
126	size_t num)
127	{
128	return param_push_num(bld, key, &num, sizeof(num),
129	OSSL_PARAM_UNSIGNED_INTEGER);
130	}
131
132	int ossl_param_bld_push_double(OSSL_PARAM_BLD bld, const char key,
133	double num)
134	{
135	return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_REAL);
136	}
137
138	int ossl_param_bld_push_BN(OSSL_PARAM_BLD bld, const char key,
139	const BIGNUM *bn)
140	{
141	int sz = -1, secure = 0;
142	OSSL_PARAM_BLD_DEF *pd;
143
144	if (bn != NULL) {
145	sz = BN_num_bytes(bn);
146	if (sz < 0) {
147	CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_PUSH_BN,
148	CRYPTO_R_ZERO_LENGTH_NUMBER);
149	return 0;
150	}
151	if (BN_get_flags(bn, BN_FLG_SECURE) == BN_FLG_SECURE)
152	secure = 1;
153	}
154	pd = param_push(bld, key, sz, sz >= 0 ? sz : 0,
155	OSSL_PARAM_UNSIGNED_INTEGER, secure);
156	if (pd == NULL)
157	return 0;
158	pd->bn = bn;
159	return 1;
160	}
161
162	int ossl_param_bld_push_utf8_string(OSSL_PARAM_BLD bld, const char key,
5fa7789f	163	const char *buf, size_t bsize)
3c93fbac P	164	{
	165	OSSL_PARAM_BLD_DEF *pd;
	166
	167	if (bsize == 0) {
	168	bsize = strlen(buf) + 1;
	169	} else if (bsize > INT_MAX) {
	170	CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_PUSH_UTF8_STRING,
	171	CRYPTO_R_STRING_TOO_LONG);
	172	return 0;
	173	}
	174	pd = param_push(bld, key, bsize, bsize, OSSL_PARAM_UTF8_STRING, 0);
	175	if (pd == NULL)
	176	return 0;
	177	pd->string = buf;
	178	return 1;
	179	}
	180
	181	int ossl_param_bld_push_utf8_ptr(OSSL_PARAM_BLD bld, const char key,
	182	char *buf, size_t bsize)
	183	{
	184	OSSL_PARAM_BLD_DEF *pd;
	185
	186	if (bsize == 0) {
	187	bsize = strlen(buf) + 1;
	188	} else if (bsize > INT_MAX) {
	189	CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_PUSH_UTF8_PTR,
	190	CRYPTO_R_STRING_TOO_LONG);
	191	return 0;
	192	}
	193	pd = param_push(bld, key, bsize, sizeof(buf), OSSL_PARAM_UTF8_PTR, 0);
	194	if (pd == NULL)
	195	return 0;
	196	pd->string = buf;
	197	return 1;
	198	}
	199
	200	int ossl_param_bld_push_octet_string(OSSL_PARAM_BLD bld, const char key,
5fa7789f	201	const void *buf, size_t bsize)
3c93fbac P	202	{
	203	OSSL_PARAM_BLD_DEF *pd;
	204
	205	if (bsize > INT_MAX) {
	206	CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_PUSH_OCTET_STRING,
	207	CRYPTO_R_STRING_TOO_LONG);
	208	return 0;
	209	}
	210	pd = param_push(bld, key, bsize, bsize, OSSL_PARAM_OCTET_STRING, 0);
	211	if (pd == NULL)
	212	return 0;
	213	pd->string = buf;
	214	return 1;
	215	}
	216
	217	int ossl_param_bld_push_octet_ptr(OSSL_PARAM_BLD bld, const char key,
	218	void *buf, size_t bsize)
	219	{
	220	OSSL_PARAM_BLD_DEF *pd;
	221
	222	if (bsize > INT_MAX) {
	223	CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_PUSH_OCTET_PTR,
	224	CRYPTO_R_STRING_TOO_LONG);
	225	return 0;
	226	}
	227	pd = param_push(bld, key, bsize, sizeof(buf), OSSL_PARAM_OCTET_PTR, 0);
	228	if (pd == NULL)
	229	return 0;
	230	pd->string = buf;
	231	return 1;
	232	}
	233
	234	static OSSL_PARAM param_bld_convert(OSSL_PARAM_BLD bld, OSSL_PARAM *param,
	235	OSSL_PARAM_BLD_BLOCK *blk,
	236	OSSL_PARAM_BLD_BLOCK *secure)
	237	{
	238	size_t i;
	239	OSSL_PARAM_BLD_DEF *pd;
	240	void *p;
	241
	242	for (i = 0; i < bld->curr; i++) {
	243	pd = bld->params + i;
	244	param[i].key = pd->key;
	245	param[i].data_type = pd->type;
	246	param[i].data_size = pd->size;
	247	param[i].return_size = 0;
	248
	249	if (pd->secure) {
	250	p = secure;
	251	secure += pd->alloc_blocks;
	252	} else {
	253	p = blk;
	254	blk += pd->alloc_blocks;
	255	}
	256	param[i].data = p;
	257	if (pd->bn != NULL) {
	258	/* BIGNUM */
	259	BN_bn2nativepad(pd->bn, (unsigned char *)p, pd->size);
	260	} else if (pd->type == OSSL_PARAM_OCTET_PTR
	261	\|\| pd->type == OSSL_PARAM_UTF8_PTR) {
	262	/* PTR */
d32d3048	263	(const void *)p = pd->string;
3c93fbac P	264	} else if (pd->type == OSSL_PARAM_OCTET_STRING
	265	\|\| pd->type == OSSL_PARAM_UTF8_STRING) {
	266	if (pd->string != NULL)
	267	memcpy(p, pd->string, pd->size);
	268	else
	269	memset(p, 0, pd->size);
	270	} else {
	271	/* Number, but could also be a NULL BIGNUM */
	272	if (pd->size > sizeof(pd->num))
	273	memset(p, 0, pd->size);
	274	else if (pd->size > 0)
	275	memcpy(p, &pd->num, pd->size);
	276	}
	277	}
	278	param[i] = OSSL_PARAM_construct_end();
7312ef3f	279	return param + i;
3c93fbac P	280	}
3c93fbac P	281
7312ef3f	282	OSSL_PARAM ossl_param_bld_to_param(OSSL_PARAM_BLD bld)
3c93fbac P	283	{
3c93fbac P	284	OSSL_PARAM_BLD_BLOCK blk, s = NULL;
7312ef3f P	285	OSSL_PARAM params, last;
7312ef3f P	286	const size_t p_blks = bytes_to_blocks((1 + bld->curr) * sizeof(*params));
3c93fbac	287	const size_t total = ALIGN_SIZE * (p_blks + bld->total_blocks);
7312ef3f	288	const size_t ss = ALIGN_SIZE * bld->secure_blocks;
3c93fbac	289
7312ef3f P	290	if (ss > 0) {
7312ef3f P	291	s = OPENSSL_secure_malloc(ss);
3c93fbac P	292	if (s == NULL) {
	293	CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM,
	294	CRYPTO_R_SECURE_MALLOC_FAILURE);
	295	return NULL;
	296	}
	297	}
7312ef3f P	298	params = OPENSSL_malloc(total);
7312ef3f P	299	if (params == NULL) {
3c93fbac P	300	CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM, ERR_R_MALLOC_FAILURE);
	301	OPENSSL_secure_free(s);
	302	return NULL;
	303	}
7312ef3f P	304	blk = p_blks + (OSSL_PARAM_BLD_BLOCK *)(params);
	305	last = param_bld_convert(bld, params, blk, s);
	306	last->data_size = ss;
	307	last->data = s;
	308	last->data_type = OSSL_PARAM_ALLOCATED_END;
	309	return params;
	310	}
	311
	312	void ossl_param_bld_free(OSSL_PARAM *params)
	313	{
	314	if (params != NULL) {
	315	OSSL_PARAM *p;
	316
	317	for (p = params; p->key != NULL; p++)
	318	;
	319	if (p->data_type == OSSL_PARAM_ALLOCATED_END)
	320	OPENSSL_secure_clear_free(p->data, p->data_size);
	321	OPENSSL_free(params);
	322	}
3c93fbac P	323	}
	324
	325	OSSL_PARAM ossl_param_bld_to_param_ex(OSSL_PARAM_BLD bld, OSSL_PARAM *params,
	326	size_t param_n, void *data,
	327	size_t data_n, void *secure,
	328	size_t secure_n)
	329	{
	330	if (params == NULL \|\| data == NULL) {
	331	CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM_EX,
	332	CRYPTO_R_INVALID_NULL_ARGUMENT);
	333	return NULL;
	334	}
	335	if (param_n < bld->curr + 1) {
	336	CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM_EX,
	337	CRYPTO_R_INSUFFICIENT_PARAM_SIZE);
	338	return NULL;
	339	}
	340	if (data_n < ALIGN_SIZE * bld->total_blocks) {
	341	CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM_EX,
	342	CRYPTO_R_INSUFFICIENT_DATA_SPACE);
	343	return NULL;
	344	}
	345	if (bld->secure_blocks > 0 && secure_n < ALIGN_SIZE * bld->secure_blocks) {
	346	CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM_EX,
	347	CRYPTO_R_INSUFFICIENT_SECURE_DATA_SPACE);
	348	return NULL;
	349	}
	350	param_bld_convert(bld, params, (OSSL_PARAM_BLD_BLOCK *)data,
	351	(OSSL_PARAM_BLD_BLOCK *)secure);
	352	return params;
	353	}