Accept NULL in *_free.
[openssl.git] / ssl / ssl_cert.c
1 /* ssl/ssl_cert.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 "objects.h"
61 #include "bio.h"
62 #include "pem.h"
63 #include "ssl_locl.h"
64
65 int SSL_get_ex_data_X509_STORE_CTX_idx()
66         {
67         static int ssl_x509_store_ctx_idx= -1;
68
69         if (ssl_x509_store_ctx_idx < 0)
70                 {
71                 ssl_x509_store_ctx_idx=X509_STORE_CTX_get_ex_new_index(
72                         0,"SSL for verify callback",NULL,NULL,NULL);
73                 }
74         return(ssl_x509_store_ctx_idx);
75         }
76
77 CERT *ssl_cert_new()
78         {
79         CERT *ret;
80
81         ret=(CERT *)Malloc(sizeof(CERT));
82         if (ret == NULL)
83                 {
84                 SSLerr(SSL_F_SSL_CERT_NEW,ERR_R_MALLOC_FAILURE);
85                 return(NULL);
86                 }
87         memset(ret,0,sizeof(CERT));
88 /*
89         ret->valid=0;
90         ret->mask=0;
91         ret->export_mask=0;
92         ret->cert_type=0;
93         ret->key->x509=NULL;
94         ret->key->publickey=NULL;
95         ret->key->privatekey=NULL; */
96
97         ret->key= &(ret->pkeys[SSL_PKEY_RSA_ENC]);
98         ret->references=1;
99
100         return(ret);
101         }
102
103 void ssl_cert_free(c)
104 CERT *c;
105         {
106         int i;
107
108         if(c == NULL)
109             return;
110
111         i=CRYPTO_add(&c->references,-1,CRYPTO_LOCK_SSL_CERT);
112 #ifdef REF_PRINT
113         REF_PRINT("CERT",c);
114 #endif
115         if (i > 0) return;
116 #ifdef REF_CHECK
117         if (i < 0)
118                 {
119                 fprintf(stderr,"ssl_cert_free, bad reference count\n");
120                 abort(); /* ok */
121                 }
122 #endif
123
124 #ifndef NO_RSA
125         if (c->rsa_tmp) RSA_free(c->rsa_tmp);
126 #endif
127 #ifndef NO_DH
128         if (c->dh_tmp) DH_free(c->dh_tmp);
129 #endif
130
131         for (i=0; i<SSL_PKEY_NUM; i++)
132                 {
133                 if (c->pkeys[i].x509 != NULL)
134                         X509_free(c->pkeys[i].x509);
135                 if (c->pkeys[i].privatekey != NULL)
136                         EVP_PKEY_free(c->pkeys[i].privatekey);
137 #if 0
138                 if (c->pkeys[i].publickey != NULL)
139                         EVP_PKEY_free(c->pkeys[i].publickey);
140 #endif
141                 }
142         if (c->cert_chain != NULL)
143                 sk_pop_free(c->cert_chain,X509_free);
144         Free(c);
145         }
146
147 int ssl_set_cert_type(c, type)
148 CERT *c;
149 int type;
150         {
151         c->cert_type=type;
152         return(1);
153         }
154
155 int ssl_verify_cert_chain(s,sk)
156 SSL *s;
157 STACK *sk;
158         {
159         X509 *x;
160         int i;
161         X509_STORE_CTX ctx;
162
163         if ((sk == NULL) || (sk_num(sk) == 0))
164                 return(0);
165
166         x=(X509 *)sk_value(sk,0);
167         X509_STORE_CTX_init(&ctx,s->ctx->cert_store,x,sk);
168         X509_STORE_CTX_set_ex_data(&ctx,SSL_get_ex_data_X509_STORE_CTX_idx(),
169                 (char *)s);
170
171         if (s->ctx->app_verify_callback != NULL)
172                 i=s->ctx->app_verify_callback(&ctx);
173         else
174                 {
175 #ifndef NO_X509_VERIFY
176                 i=X509_verify_cert(&ctx);
177 #else
178                 i=0;
179                 ctx.error=X509_V_ERR_APPLICATION_VERIFICATION;
180                 SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN,SSL_R_NO_VERIFY_CALLBACK);
181 #endif
182                 }
183
184         s->verify_result=ctx.error;
185         X509_STORE_CTX_cleanup(&ctx);
186
187         return(i);
188         }
189
190 static void set_client_CA_list(ca_list,list)
191 STACK **ca_list;
192 STACK *list;
193         {
194         if (*ca_list != NULL)
195                 sk_pop_free(*ca_list,X509_NAME_free);
196
197         *ca_list=list;
198         }
199
200 STACK *SSL_dup_CA_list(sk)
201 STACK *sk;
202         {
203         int i;
204         STACK *ret;
205         X509_NAME *name;
206
207         ret=sk_new_null();
208         for (i=0; i<sk_num(sk); i++)
209                 {
210                 name=X509_NAME_dup((X509_NAME *)sk_value(sk,i));
211                 if ((name == NULL) || !sk_push(ret,(char *)name))
212                         {
213                         sk_pop_free(ret,X509_NAME_free);
214                         return(NULL);
215                         }
216                 }
217         return(ret);
218         }
219
220 void SSL_set_client_CA_list(s,list)
221 SSL *s;
222 STACK *list;
223         {
224         set_client_CA_list(&(s->client_CA),list);
225         }
226
227 void SSL_CTX_set_client_CA_list(ctx,list)
228 SSL_CTX *ctx;
229 STACK *list;
230         {
231         set_client_CA_list(&(ctx->client_CA),list);
232         }
233
234 STACK *SSL_CTX_get_client_CA_list(ctx)
235 SSL_CTX *ctx;
236         {
237         return(ctx->client_CA);
238         }
239
240 STACK *SSL_get_client_CA_list(s)
241 SSL *s;
242         {
243         if (s->type == SSL_ST_CONNECT)
244                 { /* we are in the client */
245                 if (((s->version>>8) == SSL3_VERSION_MAJOR) &&
246                         (s->s3 != NULL))
247                         return(s->s3->tmp.ca_names);
248                 else
249                         return(NULL);
250                 }
251         else
252                 {
253                 if (s->client_CA != NULL)
254                         return(s->client_CA);
255                 else
256                         return(s->ctx->client_CA);
257                 }
258         }
259
260 static int add_client_CA(sk,x)
261 STACK **sk;
262 X509 *x;
263         {
264         X509_NAME *name;
265
266         if (x == NULL) return(0);
267         if ((*sk == NULL) && ((*sk=sk_new_null()) == NULL))
268                 return(0);
269                 
270         if ((name=X509_NAME_dup(X509_get_subject_name(x))) == NULL)
271                 return(0);
272
273         if (!sk_push(*sk,(char *)name))
274                 {
275                 X509_NAME_free(name);
276                 return(0);
277                 }
278         return(1);
279         }
280
281 int SSL_add_client_CA(ssl,x)
282 SSL *ssl;
283 X509 *x;
284         {
285         return(add_client_CA(&(ssl->client_CA),x));
286         }
287
288 int SSL_CTX_add_client_CA(ctx,x)
289 SSL_CTX *ctx;
290 X509 *x;
291         {
292         return(add_client_CA(&(ctx->client_CA),x));
293         }
294
295 static int name_cmp(a,b)
296 X509_NAME **a,**b;
297         {
298         return(X509_NAME_cmp(*a,*b));
299         }
300
301 #ifndef NO_STDIO
302 STACK *SSL_load_client_CA_file(file)
303 char *file;
304         {
305         BIO *in;
306         X509 *x=NULL;
307         X509_NAME *xn=NULL;
308         STACK *ret,*sk;
309
310         ret=sk_new(NULL);
311         sk=sk_new(name_cmp);
312
313         in=BIO_new(BIO_s_file_internal());
314
315         if ((ret == NULL) || (sk == NULL) || (in == NULL))
316                 {
317                 SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE,ERR_R_MALLOC_FAILURE);
318                 goto err;
319                 }
320         
321         if (!BIO_read_filename(in,file))
322                 goto err;
323
324         for (;;)
325                 {
326                 if (PEM_read_bio_X509(in,&x,NULL) == NULL)
327                         break;
328                 if ((xn=X509_get_subject_name(x)) == NULL) goto err;
329                 /* check for duplicates */
330                 xn=X509_NAME_dup(xn);
331                 if (xn == NULL) goto err;
332                 if (sk_find(sk,(char *)xn) >= 0)
333                         X509_NAME_free(xn);
334                 else
335                         {
336                         sk_push(sk,(char *)xn);
337                         sk_push(ret,(char *)xn);
338                         }
339                 }
340
341         if (0)
342                 {
343 err:
344                 if (ret != NULL) sk_pop_free(ret,X509_NAME_free);
345                 ret=NULL;
346                 }
347         if (sk != NULL) sk_free(sk);
348         if (in != NULL) BIO_free(in);
349         if (x != NULL) X509_free(x);
350         return(ret);
351         }
352 #endif
353