[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"

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,
                                    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,
                                     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 */
            *(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;
}

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

    if (bld->secure_blocks > 0) {
        if (secure == NULL) {
            CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM,
                      CRYPTO_R_INVALID_NULL_ARGUMENT);
            return NULL;
        }
        s = OPENSSL_secure_malloc(bld->secure_blocks * ALIGN_SIZE);
        if (s == NULL) {
            CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM,
                      CRYPTO_R_SECURE_MALLOC_FAILURE);
            return NULL;
        }
    }
    param = OPENSSL_malloc(total);
    if (param == NULL) {
        CRYPTOerr(CRYPTO_F_OSSL_PARAM_BLD_TO_PARAM, ERR_R_MALLOC_FAILURE);
        OPENSSL_secure_free(s);
        return NULL;
    }
    if (secure != NULL)
        *secure = s;
    blk = p_blks + (OSSL_PARAM_BLD_BLOCK *)(param);
    param_bld_convert(bld, param, blk, s);
    return param;
}

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