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