Check ASN1_TYPE structure type is a SEQUENCE in PKCS7_get_smimecap().
[openssl.git] / crypto / pkcs7 / bio_ber.c
1 /* crypto/evp/bio_ber.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 <errno.h>
61 #include "cryptlib.h"
62 #include <openssl/buffer.h>
63 #include <openssl/evp.h>
64
65 static int ber_write(BIO *h,char *buf,int num);
66 static int ber_read(BIO *h,char *buf,int size);
67 /*static int ber_puts(BIO *h,char *str); */
68 /*static int ber_gets(BIO *h,char *str,int size); */
69 static long ber_ctrl(BIO *h,int cmd,long arg1,char *arg2);
70 static int ber_new(BIO *h);
71 static int ber_free(BIO *data);
72 static long ber_callback_ctrl(BIO *h,int cmd,void *(*fp)());
73 #define BER_BUF_SIZE    (32)
74
75 /* This is used to hold the state of the BER objects being read. */
76 typedef struct ber_struct
77         {
78         int tag;
79         int class;
80         long length;
81         int inf;
82         int num_left;
83         int depth;
84         } BER_CTX;
85
86 typedef struct bio_ber_struct
87         {
88         int tag;
89         int class;
90         long length;
91         int inf;
92
93         /* most of the following are used when doing non-blocking IO */
94         /* reading */
95         long num_left;  /* number of bytes still to read/write in block */
96         int depth;      /* used with indefinite encoding. */
97         int finished;   /* No more read data */
98
99         /* writting */ 
100         char *w_addr;
101         int w_offset;
102         int w_left;
103
104         int buf_len;
105         int buf_off;
106         unsigned char buf[BER_BUF_SIZE];
107         } BIO_BER_CTX;
108
109 static BIO_METHOD methods_ber=
110         {
111         BIO_TYPE_CIPHER,"cipher",
112         ber_write,
113         ber_read,
114         NULL, /* ber_puts, */
115         NULL, /* ber_gets, */
116         ber_ctrl,
117         ber_new,
118         ber_free,
119         ber_callback_ctrl,
120         };
121
122 BIO_METHOD *BIO_f_ber(void)
123         {
124         return(&methods_ber);
125         }
126
127 static int ber_new(BIO *bi)
128         {
129         BIO_BER_CTX *ctx;
130
131         ctx=(BIO_BER_CTX *)OPENSSL_malloc(sizeof(BIO_BER_CTX));
132         if (ctx == NULL) return(0);
133
134         memset((char *)ctx,0,sizeof(BIO_BER_CTX));
135
136         bi->init=0;
137         bi->ptr=(char *)ctx;
138         bi->flags=0;
139         return(1);
140         }
141
142 static int ber_free(BIO *a)
143         {
144         BIO_BER_CTX *b;
145
146         if (a == NULL) return(0);
147         b=(BIO_BER_CTX *)a->ptr;
148         OPENSSL_cleanse(a->ptr,sizeof(BIO_BER_CTX));
149         OPENSSL_free(a->ptr);
150         a->ptr=NULL;
151         a->init=0;
152         a->flags=0;
153         return(1);
154         }
155
156 int bio_ber_get_header(BIO *bio, BIO_BER_CTX *ctx)
157         {
158         char buf[64];
159         int i,j,n;
160         int ret;
161         unsigned char *p;
162         unsigned long length
163         int tag;
164         int class;
165         long max;
166
167         BIO_clear_retry_flags(b);
168
169         /* Pack the buffer down if there is a hole at the front */
170         if (ctx->buf_off != 0)
171                 {
172                 p=ctx->buf;
173                 j=ctx->buf_off;
174                 n=ctx->buf_len-j;
175                 for (i=0; i<n; i++)
176                         {
177                         p[0]=p[j];
178                         p++;
179                         }
180                 ctx->buf_len-j;
181                 ctx->buf_off=0;
182                 }
183
184         /* If there is more room, read some more data */
185         i=BER_BUF_SIZE-ctx->buf_len;
186         if (i)
187                 {
188                 i=BIO_read(bio->next_bio,&(ctx->buf[ctx->buf_len]),i);
189                 if (i <= 0)
190                         {
191                         BIO_copy_next_retry(b);
192                         return(i);
193                         }
194                 else
195                         ctx->buf_len+=i;
196                 }
197
198         max=ctx->buf_len;
199         p=ctx->buf;
200         ret=ASN1_get_object(&p,&length,&tag,&class,max);
201
202         if (ret & 0x80)
203                 {
204                 if ((ctx->buf_len < BER_BUF_SIZE) &&
205                         (ERR_GET_REASON(ERR_peek_error()) == ASN1_R_TOO_LONG))
206                         {
207                         ERR_get_error(); /* clear the error */
208                         BIO_set_retry_read(b);
209                         }
210                 return(-1);
211                 }
212
213         /* We have no error, we have a header, so make use of it */
214
215         if ((ctx->tag  >= 0) && (ctx->tag != tag))
216                 {
217                 BIOerr(BIO_F_BIO_BER_GET_HEADER,BIO_R_TAG_MISMATCH);
218                 sprintf(buf,"tag=%d, got %d",ctx->tag,tag);
219                 ERR_add_error_data(1,buf);
220                 return(-1);
221                 }
222         if (ret & 0x01)
223         if (ret & V_ASN1_CONSTRUCTED)
224         }
225         
226 static int ber_read(BIO *b, char *out, int outl)
227         {
228         int ret=0,i,n;
229         BIO_BER_CTX *ctx;
230
231         BIO_clear_retry_flags(b);
232
233         if (out == NULL) return(0);
234         ctx=(BIO_BER_CTX *)b->ptr;
235
236         if ((ctx == NULL) || (b->next_bio == NULL)) return(0);
237
238         if (ctx->finished) return(0);
239
240 again:
241         /* First see if we are half way through reading a block */
242         if (ctx->num_left > 0)
243                 {
244                 if (ctx->num_left < outl)
245                         n=ctx->num_left;
246                 else
247                         n=outl;
248                 i=BIO_read(b->next_bio,out,n);
249                 if (i <= 0)
250                         {
251                         BIO_copy_next_retry(b);
252                         return(i);
253                         }
254                 ctx->num_left-=i;
255                 outl-=i;
256                 ret+=i;
257                 if (ctx->num_left <= 0)
258                         {
259                         ctx->depth--;
260                         if (ctx->depth <= 0)
261                                 ctx->finished=1;
262                         }
263                 if (outl <= 0)
264                         return(ret);
265                 else
266                         goto again;
267                 }
268         else    /* we need to read another BER header */
269                 {
270                 }
271         }
272
273 static int ber_write(BIO *b, char *in, int inl)
274         {
275         int ret=0,n,i;
276         BIO_ENC_CTX *ctx;
277
278         ctx=(BIO_ENC_CTX *)b->ptr;
279         ret=inl;
280
281         BIO_clear_retry_flags(b);
282         n=ctx->buf_len-ctx->buf_off;
283         while (n > 0)
284                 {
285                 i=BIO_write(b->next_bio,&(ctx->buf[ctx->buf_off]),n);
286                 if (i <= 0)
287                         {
288                         BIO_copy_next_retry(b);
289                         return(i);
290                         }
291                 ctx->buf_off+=i;
292                 n-=i;
293                 }
294         /* at this point all pending data has been written */
295
296         if ((in == NULL) || (inl <= 0)) return(0);
297
298         ctx->buf_off=0;
299         while (inl > 0)
300                 {
301                 n=(inl > ENC_BLOCK_SIZE)?ENC_BLOCK_SIZE:inl;
302                 EVP_CipherUpdate(&(ctx->cipher),
303                         (unsigned char *)ctx->buf,&ctx->buf_len,
304                         (unsigned char *)in,n);
305                 inl-=n;
306                 in+=n;
307
308                 ctx->buf_off=0;
309                 n=ctx->buf_len;
310                 while (n > 0)
311                         {
312                         i=BIO_write(b->next_bio,&(ctx->buf[ctx->buf_off]),n);
313                         if (i <= 0)
314                                 {
315                                 BIO_copy_next_retry(b);
316                                 return(i);
317                                 }
318                         n-=i;
319                         ctx->buf_off+=i;
320                         }
321                 ctx->buf_len=0;
322                 ctx->buf_off=0;
323                 }
324         BIO_copy_next_retry(b);
325         return(ret);
326         }
327
328 static long ber_ctrl(BIO *b, int cmd, long num, char *ptr)
329         {
330         BIO *dbio;
331         BIO_ENC_CTX *ctx,*dctx;
332         long ret=1;
333         int i;
334
335         ctx=(BIO_ENC_CTX *)b->ptr;
336
337         switch (cmd)
338                 {
339         case BIO_CTRL_RESET:
340                 ctx->ok=1;
341                 ctx->finished=0;
342                 EVP_CipherInit_ex(&(ctx->cipher),NULL,NULL,NULL,NULL,
343                         ctx->cipher.berrypt);
344                 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
345                 break;
346         case BIO_CTRL_EOF:      /* More to read */
347                 if (ctx->cont <= 0)
348                         ret=1;
349                 else
350                         ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
351                 break;
352         case BIO_CTRL_WPENDING:
353                 ret=ctx->buf_len-ctx->buf_off;
354                 if (ret <= 0)
355                         ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
356                 break;
357         case BIO_CTRL_PENDING: /* More to read in buffer */
358                 ret=ctx->buf_len-ctx->buf_off;
359                 if (ret <= 0)
360                         ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
361                 break;
362         case BIO_CTRL_FLUSH:
363                 /* do a final write */
364 again:
365                 while (ctx->buf_len != ctx->buf_off)
366                         {
367                         i=ber_write(b,NULL,0);
368                         if (i < 0)
369                                 {
370                                 ret=i;
371                                 break;
372                                 }
373                         }
374
375                 if (!ctx->finished)
376                         {
377                         ctx->finished=1;
378                         ctx->buf_off=0;
379                         ret=EVP_CipherFinal_ex(&(ctx->cipher),
380                                 (unsigned char *)ctx->buf,
381                                 &(ctx->buf_len));
382                         ctx->ok=(int)ret;
383                         if (ret <= 0) break;
384
385                         /* push out the bytes */
386                         goto again;
387                         }
388                 
389                 /* Finally flush the underlying BIO */
390                 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
391                 break;
392         case BIO_C_GET_CIPHER_STATUS:
393                 ret=(long)ctx->ok;
394                 break;
395         case BIO_C_DO_STATE_MACHINE:
396                 BIO_clear_retry_flags(b);
397                 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
398                 BIO_copy_next_retry(b);
399                 break;
400
401         case BIO_CTRL_DUP:
402                 dbio=(BIO *)ptr;
403                 dctx=(BIO_ENC_CTX *)dbio->ptr;
404                 memcpy(&(dctx->cipher),&(ctx->cipher),sizeof(ctx->cipher));
405                 dbio->init=1;
406                 break;
407         default:
408                 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
409                 break;
410                 }
411         return(ret);
412         }
413
414 static long ber_callback_ctrl(BIO *b, int cmd, void *(*fp)())
415         {
416         long ret=1;
417
418         if (b->next_bio == NULL) return(0);
419         switch (cmd)
420                 {
421         default:
422                 ret=BIO_callback_ctrl(b->next_bio,cmd,fp);
423                 break;
424                 }
425         return(ret);
426         }
427
428 /*
429 void BIO_set_cipher_ctx(b,c)
430 BIO *b;
431 EVP_CIPHER_ctx *c;
432         {
433         if (b == NULL) return;
434
435         if ((b->callback != NULL) &&
436                 (b->callback(b,BIO_CB_CTRL,(char *)c,BIO_CTRL_SET,e,0L) <= 0))
437                 return;
438
439         b->init=1;
440         ctx=(BIO_ENC_CTX *)b->ptr;
441         memcpy(ctx->cipher,c,sizeof(EVP_CIPHER_CTX));
442         
443         if (b->callback != NULL)
444                 b->callback(b,BIO_CB_CTRL,(char *)c,BIO_CTRL_SET,e,1L);
445         }
446 */
447
448 void BIO_set_cipher(BIO *b, EVP_CIPHER *c, unsigned char *k, unsigned char *i,
449              int e)
450         {
451         BIO_ENC_CTX *ctx;
452
453         if (b == NULL) return;
454
455         if ((b->callback != NULL) &&
456                 (b->callback(b,BIO_CB_CTRL,(char *)c,BIO_CTRL_SET,e,0L) <= 0))
457                 return;
458
459         b->init=1;
460         ctx=(BIO_ENC_CTX *)b->ptr;
461         EVP_CipherInit_ex(&(ctx->cipher),c,NULL,k,i,e);
462         
463         if (b->callback != NULL)
464                 b->callback(b,BIO_CB_CTRL,(char *)c,BIO_CTRL_SET,e,1L);
465         }
466