1 /*
2 * Copyright 2019-2022 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/crypto.h>
13 #include <openssl/lhash.h>
14 #include "crypto/lhash.h"
15 #include "property_local.h"
16 #include "crypto/context.h"
17
18 /*
19 * Property strings are a consolidation of all strings seen by the property
20 * subsystem. There are two name spaces to keep property names separate from
21 * property values (numeric values are not expected to be cached however).
22 * They allow a rapid conversion from a string to a unique index and any
23 * subsequent string comparison can be done via an integer compare.
24 *
25 * This implementation uses OpenSSL's standard hash table. There are more
26 * space and time efficient algorithms if this becomes a bottleneck.
27 */
28
29 typedef struct {
30 const char *s;
31 OSSL_PROPERTY_IDX idx;
32 char body[1];
33 } PROPERTY_STRING;
34
35 DEFINE_LHASH_OF_EX(PROPERTY_STRING);
36 typedef LHASH_OF(PROPERTY_STRING) PROP_TABLE;
37
38 typedef struct {
39 CRYPTO_RWLOCK *lock;
40 PROP_TABLE *prop_names;
41 PROP_TABLE *prop_values;
42 OSSL_PROPERTY_IDX prop_name_idx;
43 OSSL_PROPERTY_IDX prop_value_idx;
44 #ifndef OPENSSL_SMALL_FOOTPRINT
45 STACK_OF(OPENSSL_CSTRING) *prop_namelist;
46 STACK_OF(OPENSSL_CSTRING) *prop_valuelist;
47 #endif
48 } PROPERTY_STRING_DATA;
49
property_hash(const PROPERTY_STRING * a)50 static unsigned long property_hash(const PROPERTY_STRING *a)
51 {
52 return OPENSSL_LH_strhash(a->s);
53 }
54
property_cmp(const PROPERTY_STRING * a,const PROPERTY_STRING * b)55 static int property_cmp(const PROPERTY_STRING *a, const PROPERTY_STRING *b)
56 {
57 return strcmp(a->s, b->s);
58 }
59
property_free(PROPERTY_STRING * ps)60 static void property_free(PROPERTY_STRING *ps)
61 {
62 OPENSSL_free(ps);
63 }
64
property_table_free(PROP_TABLE ** pt)65 static void property_table_free(PROP_TABLE **pt)
66 {
67 PROP_TABLE *t = *pt;
68
69 if (t != NULL) {
70 lh_PROPERTY_STRING_doall(t, &property_free);
71 lh_PROPERTY_STRING_free(t);
72 *pt = NULL;
73 }
74 }
75
ossl_property_string_data_free(void * vpropdata)76 void ossl_property_string_data_free(void *vpropdata)
77 {
78 PROPERTY_STRING_DATA *propdata = vpropdata;
79
80 if (propdata == NULL)
81 return;
82
83 CRYPTO_THREAD_lock_free(propdata->lock);
84 property_table_free(&propdata->prop_names);
85 property_table_free(&propdata->prop_values);
86 #ifndef OPENSSL_SMALL_FOOTPRINT
87 sk_OPENSSL_CSTRING_free(propdata->prop_namelist);
88 sk_OPENSSL_CSTRING_free(propdata->prop_valuelist);
89 propdata->prop_namelist = propdata->prop_valuelist = NULL;
90 #endif
91 propdata->prop_name_idx = propdata->prop_value_idx = 0;
92
93 OPENSSL_free(propdata);
94 }
95
ossl_property_string_data_new(OSSL_LIB_CTX * ctx)96 void *ossl_property_string_data_new(OSSL_LIB_CTX *ctx) {
97 PROPERTY_STRING_DATA *propdata = OPENSSL_zalloc(sizeof(*propdata));
98
99 if (propdata == NULL)
100 return NULL;
101
102 propdata->lock = CRYPTO_THREAD_lock_new();
103 propdata->prop_names = lh_PROPERTY_STRING_new(&property_hash,
104 &property_cmp);
105 propdata->prop_values = lh_PROPERTY_STRING_new(&property_hash,
106 &property_cmp);
107 #ifndef OPENSSL_SMALL_FOOTPRINT
108 propdata->prop_namelist = sk_OPENSSL_CSTRING_new_null();
109 propdata->prop_valuelist = sk_OPENSSL_CSTRING_new_null();
110 #endif
111 if (propdata->lock == NULL
112 #ifndef OPENSSL_SMALL_FOOTPRINT
113 || propdata->prop_namelist == NULL
114 || propdata->prop_valuelist == NULL
115 #endif
116 || propdata->prop_names == NULL
117 || propdata->prop_values == NULL) {
118 ossl_property_string_data_free(propdata);
119 return NULL;
120 }
121 return propdata;
122 }
123
new_property_string(const char * s,OSSL_PROPERTY_IDX * pidx)124 static PROPERTY_STRING *new_property_string(const char *s,
125 OSSL_PROPERTY_IDX *pidx)
126 {
127 const size_t l = strlen(s);
128 PROPERTY_STRING *ps = OPENSSL_malloc(sizeof(*ps) + l);
129
130 if (ps != NULL) {
131 memcpy(ps->body, s, l + 1);
132 ps->s = ps->body;
133 ps->idx = ++*pidx;
134 if (ps->idx == 0) {
135 OPENSSL_free(ps);
136 return NULL;
137 }
138 }
139 return ps;
140 }
141
ossl_property_string(OSSL_LIB_CTX * ctx,int name,int create,const char * s)142 static OSSL_PROPERTY_IDX ossl_property_string(OSSL_LIB_CTX *ctx, int name,
143 int create, const char *s)
144 {
145 PROPERTY_STRING p, *ps, *ps_new;
146 PROP_TABLE *t;
147 OSSL_PROPERTY_IDX *pidx;
148 PROPERTY_STRING_DATA *propdata
149 = ossl_lib_ctx_get_data(ctx, OSSL_LIB_CTX_PROPERTY_STRING_INDEX);
150
151 if (propdata == NULL)
152 return 0;
153
154 t = name ? propdata->prop_names : propdata->prop_values;
155 p.s = s;
156 if (!CRYPTO_THREAD_read_lock(propdata->lock)) {
157 ERR_raise(ERR_LIB_CRYPTO, ERR_R_UNABLE_TO_GET_READ_LOCK);
158 return 0;
159 }
160 ps = lh_PROPERTY_STRING_retrieve(t, &p);
161 if (ps == NULL && create) {
162 CRYPTO_THREAD_unlock(propdata->lock);
163 if (!CRYPTO_THREAD_write_lock(propdata->lock)) {
164 ERR_raise(ERR_LIB_CRYPTO, ERR_R_UNABLE_TO_GET_WRITE_LOCK);
165 return 0;
166 }
167 pidx = name ? &propdata->prop_name_idx : &propdata->prop_value_idx;
168 ps = lh_PROPERTY_STRING_retrieve(t, &p);
169 if (ps == NULL && (ps_new = new_property_string(s, pidx)) != NULL) {
170 #ifndef OPENSSL_SMALL_FOOTPRINT
171 STACK_OF(OPENSSL_CSTRING) *slist;
172
173 slist = name ? propdata->prop_namelist : propdata->prop_valuelist;
174 if (sk_OPENSSL_CSTRING_push(slist, ps_new->s) <= 0) {
175 property_free(ps_new);
176 CRYPTO_THREAD_unlock(propdata->lock);
177 return 0;
178 }
179 #endif
180 lh_PROPERTY_STRING_insert(t, ps_new);
181 if (lh_PROPERTY_STRING_error(t)) {
182 /*-
183 * Undo the previous push which means also decrementing the
184 * index and freeing the allocated storage.
185 */
186 #ifndef OPENSSL_SMALL_FOOTPRINT
187 sk_OPENSSL_CSTRING_pop(slist);
188 #endif
189 property_free(ps_new);
190 --*pidx;
191 CRYPTO_THREAD_unlock(propdata->lock);
192 return 0;
193 }
194 ps = ps_new;
195 }
196 }
197 CRYPTO_THREAD_unlock(propdata->lock);
198 return ps != NULL ? ps->idx : 0;
199 }
200
201 #ifdef OPENSSL_SMALL_FOOTPRINT
202 struct find_str_st {
203 const char *str;
204 OSSL_PROPERTY_IDX idx;
205 };
206
find_str_fn(PROPERTY_STRING * prop,void * vfindstr)207 static void find_str_fn(PROPERTY_STRING *prop, void *vfindstr)
208 {
209 struct find_str_st *findstr = vfindstr;
210
211 if (prop->idx == findstr->idx)
212 findstr->str = prop->s;
213 }
214 #endif
215
ossl_property_str(int name,OSSL_LIB_CTX * ctx,OSSL_PROPERTY_IDX idx)216 static const char *ossl_property_str(int name, OSSL_LIB_CTX *ctx,
217 OSSL_PROPERTY_IDX idx)
218 {
219 const char *r;
220 PROPERTY_STRING_DATA *propdata
221 = ossl_lib_ctx_get_data(ctx, OSSL_LIB_CTX_PROPERTY_STRING_INDEX);
222
223 if (propdata == NULL)
224 return NULL;
225
226 if (!CRYPTO_THREAD_read_lock(propdata->lock)) {
227 ERR_raise(ERR_LIB_CRYPTO, ERR_R_UNABLE_TO_GET_READ_LOCK);
228 return NULL;
229 }
230 #ifdef OPENSSL_SMALL_FOOTPRINT
231 {
232 struct find_str_st findstr;
233
234 findstr.str = NULL;
235 findstr.idx = idx;
236
237 lh_PROPERTY_STRING_doall_arg(name ? propdata->prop_names
238 : propdata->prop_values,
239 find_str_fn, &findstr);
240 r = findstr.str;
241 }
242 #else
243 r = sk_OPENSSL_CSTRING_value(name ? propdata->prop_namelist
244 : propdata->prop_valuelist, idx - 1);
245 #endif
246 CRYPTO_THREAD_unlock(propdata->lock);
247
248 return r;
249 }
250
ossl_property_name(OSSL_LIB_CTX * ctx,const char * s,int create)251 OSSL_PROPERTY_IDX ossl_property_name(OSSL_LIB_CTX *ctx, const char *s,
252 int create)
253 {
254 return ossl_property_string(ctx, 1, create, s);
255 }
256
ossl_property_name_str(OSSL_LIB_CTX * ctx,OSSL_PROPERTY_IDX idx)257 const char *ossl_property_name_str(OSSL_LIB_CTX *ctx, OSSL_PROPERTY_IDX idx)
258 {
259 return ossl_property_str(1, ctx, idx);
260 }
261
ossl_property_value(OSSL_LIB_CTX * ctx,const char * s,int create)262 OSSL_PROPERTY_IDX ossl_property_value(OSSL_LIB_CTX *ctx, const char *s,
263 int create)
264 {
265 return ossl_property_string(ctx, 0, create, s);
266 }
267
ossl_property_value_str(OSSL_LIB_CTX * ctx,OSSL_PROPERTY_IDX idx)268 const char *ossl_property_value_str(OSSL_LIB_CTX *ctx, OSSL_PROPERTY_IDX idx)
269 {
270 return ossl_property_str(0, ctx, idx);
271 }
272
