83bdcf492f1ee99de7808c44a857fb2d0ed3f1a5
[openssl.git] / crypto / pem / pem_info.c
1 /* crypto/pem/pem_info.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 "cryptlib.h"
61 #include <openssl/buffer.h>
62 #include <openssl/objects.h>
63 #include <openssl/evp.h>
64 #include <openssl/x509.h>
65 #include <openssl/pem.h>
66
67 #ifndef NO_FP_API
68 STACK *PEM_X509_INFO_read(FILE *fp, STACK *sk, int (*cb)())
69         {
70         BIO *b;
71         STACK *ret;
72
73         if ((b=BIO_new(BIO_s_file())) == NULL)
74                 {
75                 PEMerr(PEM_F_PEM_X509_INFO_READ,ERR_R_BUF_LIB);
76                 return(0);
77                 }
78         BIO_set_fp(b,fp,BIO_NOCLOSE);
79         ret=PEM_X509_INFO_read_bio(b,sk,cb);
80         BIO_free(b);
81         return(ret);
82         }
83 #endif
84
85 STACK *PEM_X509_INFO_read_bio(BIO *bp, STACK *sk, int (*cb)())
86         {
87         X509_INFO *xi=NULL;
88         char *name=NULL,*header=NULL,**pp;
89         unsigned char *data=NULL,*p;
90         long len,error=0;
91         int ok=0;
92         STACK *ret=NULL;
93         unsigned int i,raw;
94         char *(*d2i)();
95
96         if (sk == NULL)
97                 {
98                 if ((ret=sk_new_null()) == NULL)
99                         {
100                         PEMerr(PEM_F_PEM_X509_INFO_READ_BIO,ERR_R_MALLOC_FAILURE);
101                         goto err;
102                         }
103                 }
104         else
105                 ret=sk;
106
107         if ((xi=X509_INFO_new()) == NULL) goto err;
108         for (;;)
109                 {
110                 raw=0;
111                 i=PEM_read_bio(bp,&name,&header,&data,&len);
112                 if (i == 0)
113                         {
114                         error=ERR_GET_REASON(ERR_peek_error());
115                         if (error == PEM_R_NO_START_LINE)
116                                 {
117                                 ERR_clear_error();
118                                 break;
119                                 }
120                         goto err;
121                         }
122 start:
123                 if (    (strcmp(name,PEM_STRING_X509) == 0) ||
124                         (strcmp(name,PEM_STRING_X509_OLD) == 0))
125                         {
126                         d2i=(char *(*)())d2i_X509;
127                         if (xi->x509 != NULL)
128                                 {
129                                 if (!sk_push(ret,(char *)xi)) goto err;
130                                 if ((xi=X509_INFO_new()) == NULL) goto err;
131                                 goto start;
132                                 }
133                         pp=(char **)&(xi->x509);
134                         }
135                 else if (strcmp(name,PEM_STRING_X509_CRL) == 0)
136                         {
137                         d2i=(char *(*)())d2i_X509_CRL;
138                         if (xi->crl != NULL)
139                                 {
140                                 if (!sk_push(ret,(char *)xi)) goto err;
141                                 if ((xi=X509_INFO_new()) == NULL) goto err;
142                                 goto start;
143                                 }
144                         pp=(char **)&(xi->crl);
145                         }
146                 else
147 #ifndef NO_RSA
148                         if (strcmp(name,PEM_STRING_RSA) == 0)
149                         {
150                         d2i=(char *(*)())d2i_RSAPrivateKey;
151                         if (xi->x_pkey != NULL) 
152                                 {
153                                 if (!sk_push(ret,(char *)xi)) goto err;
154                                 if ((xi=X509_INFO_new()) == NULL) goto err;
155                                 goto start;
156                                 }
157
158                         xi->enc_data=NULL;
159                         xi->enc_len=0;
160
161                         xi->x_pkey=X509_PKEY_new();
162                         if ((xi->x_pkey->dec_pkey=EVP_PKEY_new()) == NULL)
163                                 goto err;
164                         xi->x_pkey->dec_pkey->type=EVP_PKEY_RSA;
165                         pp=(char **)&(xi->x_pkey->dec_pkey->pkey.rsa);
166                         if ((int)strlen(header) > 10) /* assume encrypted */
167                                 raw=1;
168                         }
169                 else
170 #endif
171 #ifndef NO_DSA
172                         if (strcmp(name,PEM_STRING_DSA) == 0)
173                         {
174                         d2i=(char *(*)())d2i_DSAPrivateKey;
175                         if (xi->x_pkey != NULL) 
176                                 {
177                                 if (!sk_push(ret,(char *)xi)) goto err;
178                                 if ((xi=X509_INFO_new()) == NULL) goto err;
179                                 goto start;
180                                 }
181
182                         xi->enc_data=NULL;
183                         xi->enc_len=0;
184
185                         xi->x_pkey=X509_PKEY_new();
186                         if ((xi->x_pkey->dec_pkey=EVP_PKEY_new()) == NULL)
187                                 goto err;
188                         xi->x_pkey->dec_pkey->type=EVP_PKEY_DSA;
189                         pp=(char **)&(xi->x_pkey->dec_pkey->pkey.dsa);
190                         if ((int)strlen(header) > 10) /* assume encrypted */
191                                 raw=1;
192                         }
193                 else
194 #endif
195                         {
196                         d2i=NULL;
197                         pp=NULL;
198                         }
199
200                 if (d2i != NULL)
201                         {
202                         if (!raw)
203                                 {
204                                 EVP_CIPHER_INFO cipher;
205
206                                 if (!PEM_get_EVP_CIPHER_INFO(header,&cipher))
207                                         goto err;
208                                 if (!PEM_do_header(&cipher,data,&len,cb))
209                                         goto err;
210                                 p=data;
211                                 if (d2i(pp,&p,len) == NULL)
212                                         {
213                                         PEMerr(PEM_F_PEM_X509_INFO_READ_BIO,ERR_R_ASN1_LIB);
214                                         goto err;
215                                         }
216                                 }
217                         else
218                                 { /* encrypted RSA data */
219                                 if (!PEM_get_EVP_CIPHER_INFO(header,
220                                         &xi->enc_cipher)) goto err;
221                                 xi->enc_data=(char *)data;
222                                 xi->enc_len=(int)len;
223                                 data=NULL;
224                                 }
225                         }
226                 else    {
227                         /* unknown */
228                         }
229                 if (name != NULL) Free(name);
230                 if (header != NULL) Free(header);
231                 if (data != NULL) Free(data);
232                 name=NULL;
233                 header=NULL;
234                 data=NULL;
235                 }
236
237         /* if the last one hasn't been pushed yet and there is anything
238          * in it then add it to the stack ... 
239          */
240         if ((xi->x509 != NULL) || (xi->crl != NULL) ||
241                 (xi->x_pkey != NULL) || (xi->enc_data != NULL))
242                 {
243                 if (!sk_push(ret,(char *)xi)) goto err;
244                 xi=NULL;
245                 }
246         ok=1;
247 err:
248         if (xi != NULL) X509_INFO_free(xi);
249         if (!ok)
250                 {
251                 for (i=0; ((int)i)<sk_num(ret); i++)
252                         {
253                         xi=(X509_INFO *)sk_value(ret,i);
254                         X509_INFO_free(xi);
255                         }
256                 if (ret != sk) sk_free(ret);
257                 ret=NULL;
258                 }
259                 
260         if (name != NULL) Free(name);
261         if (header != NULL) Free(header);
262         if (data != NULL) Free(data);
263         return(ret);
264         }
265
266
267 /* A TJH addition */
268 int PEM_X509_INFO_write_bio(BIO *bp, X509_INFO *xi, EVP_CIPHER *enc,
269              unsigned char *kstr, int klen, int (*cb)())
270         {
271         EVP_CIPHER_CTX ctx;
272         int i,ret=0;
273         unsigned char *data=NULL;
274         const char *objstr=NULL;
275 #define PEM_BUFSIZE     1024
276         char buf[PEM_BUFSIZE];
277         unsigned char *iv=NULL;
278         
279         if (enc != NULL)
280                 {
281                 objstr=OBJ_nid2sn(EVP_CIPHER_nid(enc));
282                 if (objstr == NULL)
283                         {
284                         PEMerr(PEM_F_PEM_X509_INFO_WRITE_BIO,PEM_R_UNSUPPORTED_CIPHER);
285                         goto err;
286                         }
287                 }
288
289         /* now for the fun part ... if we have a private key then 
290          * we have to be able to handle a not-yet-decrypted key
291          * being written out correctly ... if it is decrypted or
292          * it is non-encrypted then we use the base code
293          */
294         if (xi->x_pkey!=NULL)
295                 {
296                 if ( (xi->enc_data!=NULL) && (xi->enc_len>0) )
297                         {
298                         /* copy from wierdo names into more normal things */
299                         iv=xi->enc_cipher.iv;
300                         data=(unsigned char *)xi->enc_data;
301                         i=xi->enc_len;
302
303                         /* we take the encryption data from the
304                          * internal stuff rather than what the
305                          * user has passed us ... as we have to 
306                          * match exactly for some strange reason
307                          */
308                         objstr=OBJ_nid2sn(
309                                 EVP_CIPHER_nid(xi->enc_cipher.cipher));
310                         if (objstr == NULL)
311                                 {
312                                 PEMerr(PEM_F_PEM_X509_INFO_WRITE_BIO,PEM_R_UNSUPPORTED_CIPHER);
313                                 goto err;
314                                 }
315
316                         /* create the right magic header stuff */
317                         buf[0]='\0';
318                         PEM_proc_type(buf,PEM_TYPE_ENCRYPTED);
319                         PEM_dek_info(buf,objstr,8,(char *)iv);
320
321                         /* use the normal code to write things out */
322                         i=PEM_write_bio(bp,PEM_STRING_RSA,buf,data,i);
323                         if (i <= 0) goto err;
324                         }
325                 else
326                         {
327                         /* Add DSA/DH */
328 #ifndef NO_RSA
329                         /* normal optionally encrypted stuff */
330                         if (PEM_write_bio_RSAPrivateKey(bp,
331                                 xi->x_pkey->dec_pkey->pkey.rsa,
332                                 enc,kstr,klen,cb)<=0)
333                                 goto err;
334 #endif
335                         }
336                 }
337
338         /* if we have a certificate then write it out now */
339         if ((xi->x509 != NULL) || (PEM_write_bio_X509(bp,xi->x509) <= 0))
340                 goto err;
341
342         /* we are ignoring anything else that is loaded into the X509_INFO
343          * structure for the moment ... as I don't need it so I'm not
344          * coding it here and Eric can do it when this makes it into the
345          * base library --tjh
346          */
347
348         ret=1;
349
350 err:
351         memset((char *)&ctx,0,sizeof(ctx));
352         memset(buf,0,PEM_BUFSIZE);
353         return(ret);
354         }