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