1 /*
2 * Copyright 1995-2024 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 #if defined (__TANDEM) && defined (_SPT_MODEL_)
11 /*
12 * These definitions have to come first in SPT due to scoping of the
13 * declarations in c99 associated with SPT use of stat.
14 */
15 # include <sys/types.h>
16 # include <sys/stat.h>
17 #endif
18
19 #include "internal/e_os.h"
20 #include "internal/cryptlib.h"
21 #include <stdio.h>
22 #include <time.h>
23 #include <errno.h>
24 #include <sys/types.h>
25
26 #ifndef OPENSSL_NO_POSIX_IO
27 # include <sys/stat.h>
28 #endif
29
30 #include <openssl/x509.h>
31 #include "crypto/x509.h"
32 #include "x509_local.h"
33
34 struct lookup_dir_hashes_st {
35 unsigned long hash;
36 int suffix;
37 };
38
39 struct lookup_dir_entry_st {
40 char *dir;
41 int dir_type;
42 STACK_OF(BY_DIR_HASH) *hashes;
43 };
44
45 typedef struct lookup_dir_st {
46 BUF_MEM *buffer;
47 STACK_OF(BY_DIR_ENTRY) *dirs;
48 CRYPTO_RWLOCK *lock;
49 } BY_DIR;
50
51 static int dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,
52 char **retp);
53
54 static int new_dir(X509_LOOKUP *lu);
55 static void free_dir(X509_LOOKUP *lu);
56 static int add_cert_dir(BY_DIR *ctx, const char *dir, int type);
57 static int get_cert_by_subject(X509_LOOKUP *xl, X509_LOOKUP_TYPE type,
58 const X509_NAME *name, X509_OBJECT *ret);
59 static int get_cert_by_subject_ex(X509_LOOKUP *xl, X509_LOOKUP_TYPE type,
60 const X509_NAME *name, X509_OBJECT *ret,
61 OSSL_LIB_CTX *libctx, const char *propq);
62 static X509_LOOKUP_METHOD x509_dir_lookup = {
63 "Load certs from files in a directory",
64 new_dir, /* new_item */
65 free_dir, /* free */
66 NULL, /* init */
67 NULL, /* shutdown */
68 dir_ctrl, /* ctrl */
69 get_cert_by_subject, /* get_by_subject */
70 NULL, /* get_by_issuer_serial */
71 NULL, /* get_by_fingerprint */
72 NULL, /* get_by_alias */
73 get_cert_by_subject_ex, /* get_by_subject_ex */
74 NULL, /* ctrl_ex */
75 };
76
X509_LOOKUP_hash_dir(void)77 X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void)
78 {
79 return &x509_dir_lookup;
80 }
81
dir_ctrl(X509_LOOKUP * ctx,int cmd,const char * argp,long argl,char ** retp)82 static int dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,
83 char **retp)
84 {
85 int ret = 0;
86 BY_DIR *ld = (BY_DIR *)ctx->method_data;
87
88 switch (cmd) {
89 case X509_L_ADD_DIR:
90 if (argl == X509_FILETYPE_DEFAULT) {
91 const char *dir = ossl_safe_getenv(X509_get_default_cert_dir_env());
92
93 if (dir)
94 ret = add_cert_dir(ld, dir, X509_FILETYPE_PEM);
95 else
96 ret = add_cert_dir(ld, X509_get_default_cert_dir(),
97 X509_FILETYPE_PEM);
98 if (!ret) {
99 ERR_raise(ERR_LIB_X509, X509_R_LOADING_CERT_DIR);
100 }
101 } else
102 ret = add_cert_dir(ld, argp, (int)argl);
103 break;
104 }
105 return ret;
106 }
107
new_dir(X509_LOOKUP * lu)108 static int new_dir(X509_LOOKUP *lu)
109 {
110 BY_DIR *a = OPENSSL_malloc(sizeof(*a));
111
112 if (a == NULL)
113 return 0;
114
115 if ((a->buffer = BUF_MEM_new()) == NULL) {
116 ERR_raise(ERR_LIB_X509, ERR_R_BN_LIB);
117 goto err;
118 }
119 a->dirs = NULL;
120 a->lock = CRYPTO_THREAD_lock_new();
121 if (a->lock == NULL) {
122 BUF_MEM_free(a->buffer);
123 ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
124 goto err;
125 }
126 lu->method_data = a;
127 return 1;
128
129 err:
130 OPENSSL_free(a);
131 return 0;
132 }
133
by_dir_hash_free(BY_DIR_HASH * hash)134 static void by_dir_hash_free(BY_DIR_HASH *hash)
135 {
136 OPENSSL_free(hash);
137 }
138
by_dir_hash_cmp(const BY_DIR_HASH * const * a,const BY_DIR_HASH * const * b)139 static int by_dir_hash_cmp(const BY_DIR_HASH *const *a,
140 const BY_DIR_HASH *const *b)
141 {
142 if ((*a)->hash > (*b)->hash)
143 return 1;
144 if ((*a)->hash < (*b)->hash)
145 return -1;
146 return 0;
147 }
148
by_dir_entry_free(BY_DIR_ENTRY * ent)149 static void by_dir_entry_free(BY_DIR_ENTRY *ent)
150 {
151 OPENSSL_free(ent->dir);
152 sk_BY_DIR_HASH_pop_free(ent->hashes, by_dir_hash_free);
153 OPENSSL_free(ent);
154 }
155
free_dir(X509_LOOKUP * lu)156 static void free_dir(X509_LOOKUP *lu)
157 {
158 BY_DIR *a = (BY_DIR *)lu->method_data;
159
160 sk_BY_DIR_ENTRY_pop_free(a->dirs, by_dir_entry_free);
161 BUF_MEM_free(a->buffer);
162 CRYPTO_THREAD_lock_free(a->lock);
163 OPENSSL_free(a);
164 }
165
add_cert_dir(BY_DIR * ctx,const char * dir,int type)166 static int add_cert_dir(BY_DIR *ctx, const char *dir, int type)
167 {
168 int j;
169 size_t len;
170 const char *s, *ss, *p;
171
172 if (dir == NULL || *dir == '\0') {
173 ERR_raise(ERR_LIB_X509, X509_R_INVALID_DIRECTORY);
174 return 0;
175 }
176
177 s = dir;
178 p = s;
179 do {
180 if ((*p == LIST_SEPARATOR_CHAR) || (*p == '\0')) {
181 BY_DIR_ENTRY *ent;
182
183 ss = s;
184 s = p + 1;
185 len = p - ss;
186 if (len == 0)
187 continue;
188 for (j = 0; j < sk_BY_DIR_ENTRY_num(ctx->dirs); j++) {
189 ent = sk_BY_DIR_ENTRY_value(ctx->dirs, j);
190 if (strlen(ent->dir) == len && strncmp(ent->dir, ss, len) == 0)
191 break;
192 }
193 if (j < sk_BY_DIR_ENTRY_num(ctx->dirs))
194 continue;
195 if (ctx->dirs == NULL) {
196 ctx->dirs = sk_BY_DIR_ENTRY_new_null();
197 if (!ctx->dirs) {
198 ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
199 return 0;
200 }
201 }
202 ent = OPENSSL_malloc(sizeof(*ent));
203 if (ent == NULL)
204 return 0;
205 ent->dir_type = type;
206 ent->hashes = sk_BY_DIR_HASH_new(by_dir_hash_cmp);
207 ent->dir = OPENSSL_strndup(ss, len);
208 if (ent->dir == NULL || ent->hashes == NULL) {
209 by_dir_entry_free(ent);
210 return 0;
211 }
212 if (!sk_BY_DIR_ENTRY_push(ctx->dirs, ent)) {
213 by_dir_entry_free(ent);
214 ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
215 return 0;
216 }
217 }
218 } while (*p++ != '\0');
219 return 1;
220 }
221
get_cert_by_subject_ex(X509_LOOKUP * xl,X509_LOOKUP_TYPE type,const X509_NAME * name,X509_OBJECT * ret,OSSL_LIB_CTX * libctx,const char * propq)222 static int get_cert_by_subject_ex(X509_LOOKUP *xl, X509_LOOKUP_TYPE type,
223 const X509_NAME *name, X509_OBJECT *ret,
224 OSSL_LIB_CTX *libctx, const char *propq)
225 {
226 BY_DIR *ctx;
227 union {
228 X509 st_x509;
229 X509_CRL crl;
230 } data;
231 int ok = 0;
232 int i, j, k;
233 unsigned long h;
234 BUF_MEM *b = NULL;
235 X509_OBJECT stmp, *tmp;
236 const char *postfix = "";
237
238 if (name == NULL)
239 return 0;
240
241 stmp.type = type;
242 if (type == X509_LU_X509) {
243 data.st_x509.cert_info.subject = (X509_NAME *)name; /* won't modify it */
244 stmp.data.x509 = &data.st_x509;
245 } else if (type == X509_LU_CRL) {
246 data.crl.crl.issuer = (X509_NAME *)name; /* won't modify it */
247 stmp.data.crl = &data.crl;
248 postfix = "r";
249 } else {
250 ERR_raise(ERR_LIB_X509, X509_R_WRONG_LOOKUP_TYPE);
251 goto finish;
252 }
253
254 if ((b = BUF_MEM_new()) == NULL) {
255 ERR_raise(ERR_LIB_X509, ERR_R_BUF_LIB);
256 goto finish;
257 }
258
259 ctx = (BY_DIR *)xl->method_data;
260 h = X509_NAME_hash_ex(name, libctx, propq, &i);
261 if (i == 0)
262 goto finish;
263 for (i = 0; i < sk_BY_DIR_ENTRY_num(ctx->dirs); i++) {
264 BY_DIR_ENTRY *ent;
265 int idx;
266 BY_DIR_HASH htmp, *hent;
267
268 ent = sk_BY_DIR_ENTRY_value(ctx->dirs, i);
269 j = strlen(ent->dir) + 1 + 8 + 6 + 1 + 1;
270 if (!BUF_MEM_grow(b, j)) {
271 ERR_raise(ERR_LIB_X509, ERR_R_BUF_LIB);
272 goto finish;
273 }
274 if (type == X509_LU_CRL && ent->hashes) {
275 htmp.hash = h;
276 if (!CRYPTO_THREAD_read_lock(ctx->lock))
277 goto finish;
278 idx = sk_BY_DIR_HASH_find(ent->hashes, &htmp);
279 if (idx >= 0) {
280 hent = sk_BY_DIR_HASH_value(ent->hashes, idx);
281 k = hent->suffix;
282 } else {
283 hent = NULL;
284 k = 0;
285 }
286 CRYPTO_THREAD_unlock(ctx->lock);
287 } else {
288 k = 0;
289 hent = NULL;
290 }
291 for (;;) {
292 char c = '/';
293
294 #ifdef OPENSSL_SYS_VMS
295 c = ent->dir[strlen(ent->dir) - 1];
296 if (c != ':' && c != '>' && c != ']') {
297 /*
298 * If no separator is present, we assume the directory
299 * specifier is a logical name, and add a colon. We really
300 * should use better VMS routines for merging things like
301 * this, but this will do for now... -- Richard Levitte
302 */
303 c = ':';
304 } else {
305 c = '\0';
306 }
307
308 if (c == '\0') {
309 /*
310 * This is special. When c == '\0', no directory separator
311 * should be added.
312 */
313 BIO_snprintf(b->data, b->max,
314 "%s%08lx.%s%d", ent->dir, h, postfix, k);
315 } else
316 #endif
317 {
318 BIO_snprintf(b->data, b->max,
319 "%s%c%08lx.%s%d", ent->dir, c, h, postfix, k);
320 }
321 #ifndef OPENSSL_NO_POSIX_IO
322 # ifdef _WIN32
323 # define stat _stat
324 # endif
325 {
326 struct stat st;
327 if (stat(b->data, &st) < 0)
328 break;
329 }
330 #endif
331 /* found one. */
332 if (type == X509_LU_X509) {
333 if ((X509_load_cert_file_ex(xl, b->data, ent->dir_type, libctx,
334 propq)) == 0)
335 break;
336 } else if (type == X509_LU_CRL) {
337 if ((X509_load_crl_file(xl, b->data, ent->dir_type)) == 0)
338 break;
339 }
340 /* else case will caught higher up */
341 k++;
342 }
343
344 /*
345 * we have added it to the cache so now pull it out again
346 *
347 * Note: quadratic time find here since the objects won't generally be
348 * sorted and sorting the would result in O(n^2 log n) complexity.
349 */
350 if (k > 0) {
351 if (!X509_STORE_lock(xl->store_ctx))
352 goto finish;
353 j = sk_X509_OBJECT_find(xl->store_ctx->objs, &stmp);
354 tmp = sk_X509_OBJECT_value(xl->store_ctx->objs, j);
355 X509_STORE_unlock(xl->store_ctx);
356 } else {
357 tmp = NULL;
358 }
359 /*
360 * If a CRL, update the last file suffix added for this.
361 * We don't need to add an entry if k is 0 as this is the initial value.
362 * This avoids the need for a write lock and sort operation in the
363 * simple case where no CRL is present for a hash.
364 */
365 if (type == X509_LU_CRL && k > 0) {
366 if (!CRYPTO_THREAD_write_lock(ctx->lock))
367 goto finish;
368 /*
369 * Look for entry again in case another thread added an entry
370 * first.
371 */
372 if (hent == NULL) {
373 htmp.hash = h;
374 idx = sk_BY_DIR_HASH_find(ent->hashes, &htmp);
375 hent = sk_BY_DIR_HASH_value(ent->hashes, idx);
376 }
377 if (hent == NULL) {
378 hent = OPENSSL_malloc(sizeof(*hent));
379 if (hent == NULL) {
380 CRYPTO_THREAD_unlock(ctx->lock);
381 ok = 0;
382 goto finish;
383 }
384 hent->hash = h;
385 hent->suffix = k;
386 if (!sk_BY_DIR_HASH_push(ent->hashes, hent)) {
387 CRYPTO_THREAD_unlock(ctx->lock);
388 OPENSSL_free(hent);
389 ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
390 ok = 0;
391 goto finish;
392 }
393
394 /*
395 * Ensure stack is sorted so that subsequent sk_BY_DIR_HASH_find
396 * will not mutate the stack and therefore require a write lock.
397 */
398 sk_BY_DIR_HASH_sort(ent->hashes);
399 } else if (hent->suffix < k) {
400 hent->suffix = k;
401 }
402
403 CRYPTO_THREAD_unlock(ctx->lock);
404
405 }
406
407 if (tmp != NULL) {
408 ok = 1;
409 ret->type = tmp->type;
410 memcpy(&ret->data, &tmp->data, sizeof(ret->data));
411
412 /*
413 * Clear any errors that might have been raised processing empty
414 * or malformed files.
415 */
416 ERR_clear_error();
417
418 goto finish;
419 }
420 }
421 finish:
422 /* If we changed anything, resort the objects for faster lookup */
423 if (X509_STORE_lock(xl->store_ctx)) {
424 if (!sk_X509_OBJECT_is_sorted(xl->store_ctx->objs)) {
425 sk_X509_OBJECT_sort(xl->store_ctx->objs);
426 }
427 X509_STORE_unlock(xl->store_ctx);
428 }
429
430 BUF_MEM_free(b);
431 return ok;
432 }
433
get_cert_by_subject(X509_LOOKUP * xl,X509_LOOKUP_TYPE type,const X509_NAME * name,X509_OBJECT * ret)434 static int get_cert_by_subject(X509_LOOKUP *xl, X509_LOOKUP_TYPE type,
435 const X509_NAME *name, X509_OBJECT *ret)
436 {
437 return get_cert_by_subject_ex(xl, type, name, ret, NULL, NULL);
438 }
439
