1 /*
2  * Copyright 2021-2022 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 <string.h>
11 #include <openssl/params.h>
12 #include <openssl/param_build.h>
13 #include "internal/param_build_set.h"
14 
15 #define OSSL_PARAM_ALLOCATED_END    127
16 #define OSSL_PARAM_MERGE_LIST_MAX   128
17 
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)
21 
22 typedef struct {
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) */
27 } OSSL_PARAM_BUF;
28 
ossl_param_bytes_to_blocks(size_t bytes)29 size_t ossl_param_bytes_to_blocks(size_t bytes)
30 {
31     return (bytes + OSSL_PARAM_ALIGN_SIZE - 1) / OSSL_PARAM_ALIGN_SIZE;
32 }
33 
ossl_param_buf_alloc(OSSL_PARAM_BUF * out,size_t extra_blocks,int is_secure)34 static int ossl_param_buf_alloc(OSSL_PARAM_BUF *out, size_t extra_blocks,
35                                 int is_secure)
36 {
37     size_t sz = OSSL_PARAM_ALIGN_SIZE * (extra_blocks + out->blocks);
38 
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);
43         return 0;
44     }
45     out->alloc_sz = sz;
46     out->cur = out->alloc + extra_blocks;
47     return 1;
48 }
49 
ossl_param_set_secure_block(OSSL_PARAM * last,void * secure_buffer,size_t secure_buffer_sz)50 void ossl_param_set_secure_block(OSSL_PARAM *last, void *secure_buffer,
51                                  size_t secure_buffer_sz)
52 {
53     last->key = NULL;
54     last->data_size = secure_buffer_sz;
55     last->data = secure_buffer;
56     last->data_type = OSSL_PARAM_ALLOCATED_END;
57 }
58 
ossl_param_dup(const OSSL_PARAM * src,OSSL_PARAM * dst,OSSL_PARAM_BUF buf[OSSL_PARAM_BUF_MAX],int * param_count)59 static OSSL_PARAM *ossl_param_dup(const OSSL_PARAM *src, OSSL_PARAM *dst,
60                                   OSSL_PARAM_BUF buf[OSSL_PARAM_BUF_MAX],
61                                   int *param_count)
62 {
63     const OSSL_PARAM *in;
64     int has_dst = (dst != NULL);
65     int is_secure;
66     size_t param_sz, blks;
67 
68     for (in = src; in->key != NULL; in++) {
69         is_secure = CRYPTO_secure_allocated(in->data);
70         if (has_dst) {
71             *dst = *in;
72             dst->data = buf[is_secure].cur;
73         }
74 
75         if (in->data_type == OSSL_PARAM_OCTET_PTR
76             || in->data_type == OSSL_PARAM_UTF8_PTR) {
77             param_sz = sizeof(in->data);
78             if (has_dst)
79                 *((const void **)dst->data) = *(const void **)in->data;
80         } else {
81             param_sz = in->data_size;
82             if (has_dst)
83                 memcpy(dst->data, in->data, param_sz);
84         }
85         if (in->data_type == OSSL_PARAM_UTF8_STRING)
86             param_sz++; /* NULL terminator */
87         blks = ossl_param_bytes_to_blocks(param_sz);
88 
89         if (has_dst) {
90             dst++;
91             buf[is_secure].cur += blks;
92         } else {
93             buf[is_secure].blocks += blks;
94         }
95         if (param_count != NULL)
96             ++*param_count;
97     }
98     return dst;
99 }
100 
OSSL_PARAM_dup(const OSSL_PARAM * src)101 OSSL_PARAM *OSSL_PARAM_dup(const OSSL_PARAM *src)
102 {
103     size_t param_blocks;
104     OSSL_PARAM_BUF buf[OSSL_PARAM_BUF_MAX];
105     OSSL_PARAM *last, *dst;
106     int param_count = 1; /* Include terminator in the count */
107 
108     if (src == NULL)
109         return NULL;
110 
111     memset(buf, 0, sizeof(buf));
112 
113     /* First Pass: get the param_count and block sizes required */
114     (void)ossl_param_dup(src, NULL, buf, &param_count);
115 
116     param_blocks = ossl_param_bytes_to_blocks(param_count * sizeof(*src));
117     /*
118      * The allocated buffer consists of an array of OSSL_PARAM followed by
119      * aligned data bytes that the array elements will point to.
120      */
121     if (!ossl_param_buf_alloc(&buf[OSSL_PARAM_BUF_PUBLIC], param_blocks, 0))
122         return NULL;
123 
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);
128         return NULL;
129     }
130 
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);
136     return dst;
137 }
138 
compare_params(const void * left,const void * right)139 static int compare_params(const void *left, const void *right)
140 {
141     const OSSL_PARAM *l = *(const OSSL_PARAM **)left;
142     const OSSL_PARAM *r = *(const OSSL_PARAM **)right;
143 
144     return OPENSSL_strcasecmp(l->key, r->key);
145 }
146 
OSSL_PARAM_merge(const OSSL_PARAM * p1,const OSSL_PARAM * p2)147 OSSL_PARAM *OSSL_PARAM_merge(const OSSL_PARAM *p1, const OSSL_PARAM *p2)
148 {
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;
155     int diff;
156 
157     if (p1 == NULL && p2 == NULL)
158         return NULL;
159 
160     /* Copy p1 to list1 */
161     if (p1 != NULL) {
162         for (p = p1; p->key != NULL && list1_sz < OSSL_PARAM_MERGE_LIST_MAX; p++)
163             list1[list1_sz++] = p;
164     }
165     list1[list1_sz] = NULL;
166 
167     /* copy p2 to a list2 */
168     if (p2 != NULL) {
169         for (p = p2; p->key != NULL && list2_sz < OSSL_PARAM_MERGE_LIST_MAX; p++)
170             list2[list2_sz++] = p;
171     }
172     list2[list2_sz] = NULL;
173     if (list1_sz == 0 && list2_sz == 0)
174         return NULL;
175 
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);
179 
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);
184         return NULL;
185     }
186     dst = params;
187     p1cur = list1;
188     p2cur = list2;
189     while (1) {
190         /* If list1 is finished just tack list2 onto the end */
191         if (*p1cur == NULL) {
192             do {
193                 *dst++ = **p2cur;
194                 p2cur++;
195             } while (*p2cur != NULL);
196             break;
197         }
198         /* If list2 is finished just tack list1 onto the end */
199         if (*p2cur == NULL) {
200             do {
201                 *dst++ = **p1cur;
202                 p1cur++;
203             } while (*p1cur != NULL);
204             break;
205         }
206         /* consume the list element with the smaller key */
207         diff = OPENSSL_strcasecmp((*p1cur)->key, (*p2cur)->key);
208         if (diff == 0) {
209             /* If the keys are the same then throw away the list1 element */
210             *dst++ = **p2cur;
211             p2cur++;
212             p1cur++;
213         } else if (diff > 0) {
214             *dst++ = **p2cur;
215             p2cur++;
216         } else {
217             *dst++ = **p1cur;
218             p1cur++;
219         }
220     }
221     return params;
222 }
223 
OSSL_PARAM_free(OSSL_PARAM * params)224 void OSSL_PARAM_free(OSSL_PARAM *params)
225 {
226     if (params != NULL) {
227         OSSL_PARAM *p;
228 
229         for (p = params; p->key != NULL; p++)
230             ;
231         if (p->data_type == OSSL_PARAM_ALLOCATED_END)
232             OPENSSL_secure_clear_free(p->data, p->data_size);
233         OPENSSL_free(params);
234     }
235 }
236