692a2037a0c95b64ceb03b77bc67dfe6cf54b493
[openssl.git] / crypto / x509 / by_file.c
1 /* crypto/x509/by_file.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  *
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  *
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 #include <stdio.h>
60 #include <time.h>
61 #include <errno.h>
62
63 #include "cryptlib.h"
64 #include <openssl/lhash.h>
65 #include <openssl/buffer.h>
66 #include <openssl/x509.h>
67 #include <openssl/pem.h>
68
69 #ifndef OPENSSL_NO_STDIO
70
71 static int by_file_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc,
72                         long argl, char **ret);
73 X509_LOOKUP_METHOD x509_file_lookup = {
74     "Load file into cache",
75     NULL,                       /* new */
76     NULL,                       /* free */
77     NULL,                       /* init */
78     NULL,                       /* shutdown */
79     by_file_ctrl,               /* ctrl */
80     NULL,                       /* get_by_subject */
81     NULL,                       /* get_by_issuer_serial */
82     NULL,                       /* get_by_fingerprint */
83     NULL,                       /* get_by_alias */
84 };
85
86 X509_LOOKUP_METHOD *X509_LOOKUP_file(void)
87 {
88     return (&x509_file_lookup);
89 }
90
91 static int by_file_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp,
92                         long argl, char **ret)
93 {
94     int ok = 0;
95     const char *file;
96
97     switch (cmd) {
98     case X509_L_FILE_LOAD:
99         if (argl == X509_FILETYPE_DEFAULT) {
100             file = getenv(X509_get_default_cert_file_env());
101             if (file)
102                 ok = (X509_load_cert_crl_file(ctx, file,
103                                               X509_FILETYPE_PEM) != 0);
104
105             else
106                 ok = (X509_load_cert_crl_file
107                       (ctx, X509_get_default_cert_file(),
108                        X509_FILETYPE_PEM) != 0);
109
110             if (!ok) {
111                 X509err(X509_F_BY_FILE_CTRL, X509_R_LOADING_DEFAULTS);
112             }
113         } else {
114             if (argl == X509_FILETYPE_PEM)
115                 ok = (X509_load_cert_crl_file(ctx, argp,
116                                               X509_FILETYPE_PEM) != 0);
117             else
118                 ok = (X509_load_cert_file(ctx, argp, (int)argl) != 0);
119         }
120         break;
121     }
122     return (ok);
123 }
124
125 int X509_load_cert_file(X509_LOOKUP *ctx, const char *file, int type)
126 {
127     int ret = 0;
128     BIO *in = NULL;
129     int i, count = 0;
130     X509 *x = NULL;
131
132     if (file == NULL)
133         return (1);
134     in = BIO_new(BIO_s_file_internal());
135
136     if ((in == NULL) || (BIO_read_filename(in, file) <= 0)) {
137         X509err(X509_F_X509_LOAD_CERT_FILE, ERR_R_SYS_LIB);
138         goto err;
139     }
140
141     if (type == X509_FILETYPE_PEM) {
142         for (;;) {
143             x = PEM_read_bio_X509_AUX(in, NULL, NULL, NULL);
144             if (x == NULL) {
145                 if ((ERR_GET_REASON(ERR_peek_last_error()) ==
146                      PEM_R_NO_START_LINE) && (count > 0)) {
147                     ERR_clear_error();
148                     break;
149                 } else {
150                     X509err(X509_F_X509_LOAD_CERT_FILE, ERR_R_PEM_LIB);
151                     goto err;
152                 }
153             }
154             i = X509_STORE_add_cert(ctx->store_ctx, x);
155             if (!i)
156                 goto err;
157             count++;
158             X509_free(x);
159             x = NULL;
160         }
161         ret = count;
162     } else if (type == X509_FILETYPE_ASN1) {
163         x = d2i_X509_bio(in, NULL);
164         if (x == NULL) {
165             X509err(X509_F_X509_LOAD_CERT_FILE, ERR_R_ASN1_LIB);
166             goto err;
167         }
168         i = X509_STORE_add_cert(ctx->store_ctx, x);
169         if (!i)
170             goto err;
171         ret = i;
172     } else {
173         X509err(X509_F_X509_LOAD_CERT_FILE, X509_R_BAD_X509_FILETYPE);
174         goto err;
175     }
176  err:
177     if (x != NULL)
178         X509_free(x);
179     if (in != NULL)
180         BIO_free(in);
181     return (ret);
182 }
183
184 int X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type)
185 {
186     int ret = 0;
187     BIO *in = NULL;
188     int i, count = 0;
189     X509_CRL *x = NULL;
190
191     if (file == NULL)
192         return (1);
193     in = BIO_new(BIO_s_file_internal());
194
195     if ((in == NULL) || (BIO_read_filename(in, file) <= 0)) {
196         X509err(X509_F_X509_LOAD_CRL_FILE, ERR_R_SYS_LIB);
197         goto err;
198     }
199
200     if (type == X509_FILETYPE_PEM) {
201         for (;;) {
202             x = PEM_read_bio_X509_CRL(in, NULL, NULL, NULL);
203             if (x == NULL) {
204                 if ((ERR_GET_REASON(ERR_peek_last_error()) ==
205                      PEM_R_NO_START_LINE) && (count > 0)) {
206                     ERR_clear_error();
207                     break;
208                 } else {
209                     X509err(X509_F_X509_LOAD_CRL_FILE, ERR_R_PEM_LIB);
210                     goto err;
211                 }
212             }
213             i = X509_STORE_add_crl(ctx->store_ctx, x);
214             if (!i)
215                 goto err;
216             count++;
217             X509_CRL_free(x);
218             x = NULL;
219         }
220         ret = count;
221     } else if (type == X509_FILETYPE_ASN1) {
222         x = d2i_X509_CRL_bio(in, NULL);
223         if (x == NULL) {
224             X509err(X509_F_X509_LOAD_CRL_FILE, ERR_R_ASN1_LIB);
225             goto err;
226         }
227         i = X509_STORE_add_crl(ctx->store_ctx, x);
228         if (!i)
229             goto err;
230         ret = i;
231     } else {
232         X509err(X509_F_X509_LOAD_CRL_FILE, X509_R_BAD_X509_FILETYPE);
233         goto err;
234     }
235  err:
236     if (x != NULL)
237         X509_CRL_free(x);
238     if (in != NULL)
239         BIO_free(in);
240     return (ret);
241 }
242
243 int X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type)
244 {
245     STACK_OF(X509_INFO) *inf;
246     X509_INFO *itmp;
247     BIO *in;
248     int i, count = 0;
249     if (type != X509_FILETYPE_PEM)
250         return X509_load_cert_file(ctx, file, type);
251     in = BIO_new_file(file, "r");
252     if (!in) {
253         X509err(X509_F_X509_LOAD_CERT_CRL_FILE, ERR_R_SYS_LIB);
254         return 0;
255     }
256     inf = PEM_X509_INFO_read_bio(in, NULL, NULL, NULL);
257     BIO_free(in);
258     if (!inf) {
259         X509err(X509_F_X509_LOAD_CERT_CRL_FILE, ERR_R_PEM_LIB);
260         return 0;
261     }
262     for (i = 0; i < sk_X509_INFO_num(inf); i++) {
263         itmp = sk_X509_INFO_value(inf, i);
264         if (itmp->x509) {
265             X509_STORE_add_cert(ctx->store_ctx, itmp->x509);
266             count++;
267         }
268         if (itmp->crl) {
269             X509_STORE_add_crl(ctx->store_ctx, itmp->crl);
270             count++;
271         }
272     }
273     sk_X509_INFO_pop_free(inf, X509_INFO_free);
274     return count;
275 }
276
277 #endif                          /* OPENSSL_NO_STDIO */