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