2 * Copyright 2021 The OpenSSL Project Authors. All Rights Reserved.
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
11 #include <openssl/params.h>
12 #include <openssl/param_build.h>
13 #include "internal/param_build_set.h"
15 #define OSSL_PARAM_ALLOCATED_END 127
16 #define OSSL_PARAM_MERGE_LIST_MAX 128
18 #define OSSL_PARAM_BUF_PUBLIC 0
19 #define OSSL_PARAM_BUF_SECURE 1
20 #define OSSL_PARAM_BUF_MAX (OSSL_PARAM_BUF_SECURE + 1)
23 OSSL_PARAM_ALIGNED_BLOCK *alloc; /* The allocated buffer */
24 OSSL_PARAM_ALIGNED_BLOCK *cur; /* Current position in the allocated buf */
25 size_t blocks; /* Number of aligned blocks */
26 size_t alloc_sz; /* The size of the allocated buffer (in bytes) */
29 size_t ossl_param_bytes_to_blocks(size_t bytes)
31 return (bytes + OSSL_PARAM_ALIGN_SIZE - 1) / OSSL_PARAM_ALIGN_SIZE;
34 static int ossl_param_buf_alloc(OSSL_PARAM_BUF *out, size_t extra_blocks,
37 size_t sz = OSSL_PARAM_ALIGN_SIZE * (extra_blocks + out->blocks);
39 out->alloc = is_secure ? OPENSSL_secure_zalloc(sz) : OPENSSL_zalloc(sz);
40 if (out->alloc == NULL) {
41 ERR_raise(ERR_LIB_CRYPTO, is_secure ? CRYPTO_R_SECURE_MALLOC_FAILURE
42 : ERR_R_MALLOC_FAILURE);
46 out->cur = out->alloc + extra_blocks;
50 void ossl_param_set_secure_block(OSSL_PARAM *last, void *secure_buffer,
51 size_t secure_buffer_sz)
54 last->data_size = secure_buffer_sz;
55 last->data = secure_buffer;
56 last->data_type = OSSL_PARAM_ALLOCATED_END;
59 static OSSL_PARAM *ossl_param_dup(const OSSL_PARAM *src, OSSL_PARAM *dst,
60 OSSL_PARAM_BUF buf[OSSL_PARAM_BUF_MAX],
64 int has_dst = (dst != NULL);
66 size_t param_sz, blks;
68 for (in = src; in->key != NULL; in++) {
69 is_secure = CRYPTO_secure_allocated(in->data);
72 dst->data = buf[is_secure].cur;
75 if (in->data_type == OSSL_PARAM_OCTET_PTR
76 || in->data_type == OSSL_PARAM_UTF8_PTR) {
77 param_sz = sizeof(in->data);
79 *((const void **)dst->data) = *(const void **)in->data;
81 param_sz = in->data_size;
83 memcpy(dst->data, in->data, param_sz);
85 if (in->data_type == OSSL_PARAM_UTF8_STRING)
86 param_sz++; /* NULL terminator */
87 blks = ossl_param_bytes_to_blocks(param_sz);
91 buf[is_secure].cur += blks;
93 buf[is_secure].blocks += blks;
95 if (param_count != NULL)
101 OSSL_PARAM *OSSL_PARAM_dup(const OSSL_PARAM *src)
104 OSSL_PARAM_BUF buf[OSSL_PARAM_BUF_MAX];
105 OSSL_PARAM *last, *dst;
106 int param_count = 1; /* Include terminator in the count */
111 memset(buf, 0, sizeof(buf));
113 /* First Pass: get the param_count and block sizes required */
114 (void)ossl_param_dup(src, NULL, buf, ¶m_count);
116 param_blocks = ossl_param_bytes_to_blocks(param_count * sizeof(*src));
118 * The allocated buffer consists of an array of OSSL_PARAM followed by
119 * aligned data bytes that the array elements will point to.
121 if (!ossl_param_buf_alloc(&buf[OSSL_PARAM_BUF_PUBLIC], param_blocks, 0))
124 /* Allocate a secure memory buffer if required */
125 if (buf[OSSL_PARAM_BUF_SECURE].blocks > 0
126 && !ossl_param_buf_alloc(&buf[OSSL_PARAM_BUF_SECURE], 0, 1)) {
127 OPENSSL_free(buf[OSSL_PARAM_BUF_PUBLIC].alloc);
131 dst = (OSSL_PARAM *)buf[OSSL_PARAM_BUF_PUBLIC].alloc;
132 last = ossl_param_dup(src, dst, buf, NULL);
133 /* Store the allocated secure memory buffer in the last param block */
134 ossl_param_set_secure_block(last, buf[OSSL_PARAM_BUF_SECURE].alloc,
135 buf[OSSL_PARAM_BUF_SECURE].alloc_sz);
139 static int compare_params(const void *left, const void *right)
141 const OSSL_PARAM *l = *(const OSSL_PARAM **)left;
142 const OSSL_PARAM *r = *(const OSSL_PARAM **)right;
144 return OPENSSL_strcasecmp(l->key, r->key);
147 OSSL_PARAM *OSSL_PARAM_merge(const OSSL_PARAM *p1, const OSSL_PARAM *p2)
149 const OSSL_PARAM *list1[OSSL_PARAM_MERGE_LIST_MAX + 1];
150 const OSSL_PARAM *list2[OSSL_PARAM_MERGE_LIST_MAX + 1];
151 const OSSL_PARAM *p = NULL;
152 const OSSL_PARAM **p1cur, **p2cur;
153 OSSL_PARAM *params, *dst;
154 size_t list1_sz = 0, list2_sz = 0;
157 if (p1 == NULL && p2 == NULL)
160 /* Copy p1 to list1 */
162 for (p = p1; p->key != NULL && list1_sz < OSSL_PARAM_MERGE_LIST_MAX; p++)
163 list1[list1_sz++] = p;
165 list1[list1_sz] = NULL;
167 /* copy p2 to a list2 */
169 for (p = p2; p->key != NULL && list2_sz < OSSL_PARAM_MERGE_LIST_MAX; p++)
170 list2[list2_sz++] = p;
172 list2[list2_sz] = NULL;
173 if (list1_sz == 0 && list2_sz == 0)
176 /* Sort the 2 lists */
177 qsort(list1, list1_sz, sizeof(OSSL_PARAM *), compare_params);
178 qsort(list2, list2_sz, sizeof(OSSL_PARAM *), compare_params);
180 /* Allocate enough space to store the merged parameters */
181 params = OPENSSL_zalloc((list1_sz + list2_sz + 1) * sizeof(*p1));
182 if (params == NULL) {
183 ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
190 /* If list1 is finished just tack list2 onto the end */
191 if (*p1cur == NULL) {
195 } while (*p2cur != NULL);
198 /* If list2 is finished just tack list1 onto the end */
199 if (*p2cur == NULL) {
203 } while (*p1cur != NULL);
206 /* consume the list element with the smaller key */
207 diff = OPENSSL_strcasecmp((*p1cur)->key, (*p2cur)->key);
209 /* If the keys are the same then throw away the list1 element */
213 } else if (diff > 0) {
224 void OSSL_PARAM_free(OSSL_PARAM *params)
226 if (params != NULL) {
229 for (p = params; p->key != NULL; p++)
231 if (p->data_type == OSSL_PARAM_ALLOCATED_END)
232 OPENSSL_secure_clear_free(p->data, p->data_size);
233 OPENSSL_free(params);