diff options
Diffstat (limited to 'src/lib/libcrypto/pkcs7')
43 files changed, 6578 insertions, 0 deletions
diff --git a/src/lib/libcrypto/pkcs7/bio_ber.c b/src/lib/libcrypto/pkcs7/bio_ber.c new file mode 100644 index 0000000000..895a91177b --- /dev/null +++ b/src/lib/libcrypto/pkcs7/bio_ber.c | |||
@@ -0,0 +1,466 @@ | |||
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 | |||
diff --git a/src/lib/libcrypto/pkcs7/dec.c b/src/lib/libcrypto/pkcs7/dec.c new file mode 100644 index 0000000000..6752ec568a --- /dev/null +++ b/src/lib/libcrypto/pkcs7/dec.c | |||
@@ -0,0 +1,248 @@ | |||
1 | /* crypto/pkcs7/verify.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 | #include <stdio.h> | ||
59 | #include <stdlib.h> | ||
60 | #include <string.h> | ||
61 | #include <openssl/bio.h> | ||
62 | #include <openssl/x509.h> | ||
63 | #include <openssl/pem.h> | ||
64 | #include <openssl/err.h> | ||
65 | #include <openssl/asn1.h> | ||
66 | |||
67 | int verify_callback(int ok, X509_STORE_CTX *ctx); | ||
68 | |||
69 | BIO *bio_err=NULL; | ||
70 | |||
71 | int main(argc,argv) | ||
72 | int argc; | ||
73 | char *argv[]; | ||
74 | { | ||
75 | char *keyfile=NULL; | ||
76 | BIO *in; | ||
77 | EVP_PKEY *pkey; | ||
78 | X509 *x509; | ||
79 | PKCS7 *p7; | ||
80 | PKCS7_SIGNER_INFO *si; | ||
81 | X509_STORE_CTX cert_ctx; | ||
82 | X509_STORE *cert_store=NULL; | ||
83 | BIO *data,*detached=NULL,*p7bio=NULL; | ||
84 | char buf[1024*4]; | ||
85 | unsigned char *pp; | ||
86 | int i,printit=0; | ||
87 | STACK_OF(PKCS7_SIGNER_INFO) *sk; | ||
88 | |||
89 | OpenSSL_add_all_algorithms(); | ||
90 | bio_err=BIO_new_fp(stderr,BIO_NOCLOSE); | ||
91 | |||
92 | data=BIO_new(BIO_s_file()); | ||
93 | pp=NULL; | ||
94 | while (argc > 1) | ||
95 | { | ||
96 | argc--; | ||
97 | argv++; | ||
98 | if (strcmp(argv[0],"-p") == 0) | ||
99 | { | ||
100 | printit=1; | ||
101 | } | ||
102 | else if ((strcmp(argv[0],"-k") == 0) && (argc >= 2)) { | ||
103 | keyfile = argv[1]; | ||
104 | argc-=1; | ||
105 | argv+=1; | ||
106 | } else if ((strcmp(argv[0],"-d") == 0) && (argc >= 2)) | ||
107 | { | ||
108 | detached=BIO_new(BIO_s_file()); | ||
109 | if (!BIO_read_filename(detached,argv[1])) | ||
110 | goto err; | ||
111 | argc-=1; | ||
112 | argv+=1; | ||
113 | } | ||
114 | else break; | ||
115 | } | ||
116 | |||
117 | if (!BIO_read_filename(data,argv[0])) goto err; | ||
118 | |||
119 | if(!keyfile) { | ||
120 | fprintf(stderr, "No private key file specified\n"); | ||
121 | goto err; | ||
122 | } | ||
123 | |||
124 | if ((in=BIO_new_file(keyfile,"r")) == NULL) goto err; | ||
125 | if ((x509=PEM_read_bio_X509(in,NULL,NULL,NULL)) == NULL) goto err; | ||
126 | BIO_reset(in); | ||
127 | if ((pkey=PEM_read_bio_PrivateKey(in,NULL,NULL,NULL)) == NULL) | ||
128 | goto err; | ||
129 | BIO_free(in); | ||
130 | |||
131 | if (pp == NULL) | ||
132 | BIO_set_fp(data,stdin,BIO_NOCLOSE); | ||
133 | |||
134 | |||
135 | /* Load the PKCS7 object from a file */ | ||
136 | if ((p7=PEM_read_bio_PKCS7(data,NULL,NULL,NULL)) == NULL) goto err; | ||
137 | |||
138 | |||
139 | |||
140 | /* This stuff is being setup for certificate verification. | ||
141 | * When using SSL, it could be replaced with a | ||
142 | * cert_stre=SSL_CTX_get_cert_store(ssl_ctx); */ | ||
143 | cert_store=X509_STORE_new(); | ||
144 | X509_STORE_set_default_paths(cert_store); | ||
145 | X509_STORE_load_locations(cert_store,NULL,"../../certs"); | ||
146 | X509_STORE_set_verify_cb_func(cert_store,verify_callback); | ||
147 | |||
148 | ERR_clear_error(); | ||
149 | |||
150 | /* We need to process the data */ | ||
151 | /* We cannot support detached encryption */ | ||
152 | p7bio=PKCS7_dataDecode(p7,pkey,detached,x509); | ||
153 | |||
154 | if (p7bio == NULL) | ||
155 | { | ||
156 | printf("problems decoding\n"); | ||
157 | goto err; | ||
158 | } | ||
159 | |||
160 | /* We now have to 'read' from p7bio to calculate digests etc. */ | ||
161 | for (;;) | ||
162 | { | ||
163 | i=BIO_read(p7bio,buf,sizeof(buf)); | ||
164 | /* print it? */ | ||
165 | if (i <= 0) break; | ||
166 | fwrite(buf,1, i, stdout); | ||
167 | } | ||
168 | |||
169 | /* We can now verify signatures */ | ||
170 | sk=PKCS7_get_signer_info(p7); | ||
171 | if (sk == NULL) | ||
172 | { | ||
173 | fprintf(stderr, "there are no signatures on this data\n"); | ||
174 | } | ||
175 | else | ||
176 | { | ||
177 | /* Ok, first we need to, for each subject entry, | ||
178 | * see if we can verify */ | ||
179 | ERR_clear_error(); | ||
180 | for (i=0; i<sk_PKCS7_SIGNER_INFO_num(sk); i++) | ||
181 | { | ||
182 | si=sk_PKCS7_SIGNER_INFO_value(sk,i); | ||
183 | i=PKCS7_dataVerify(cert_store,&cert_ctx,p7bio,p7,si); | ||
184 | if (i <= 0) | ||
185 | goto err; | ||
186 | else | ||
187 | fprintf(stderr,"Signature verified\n"); | ||
188 | } | ||
189 | } | ||
190 | X509_STORE_free(cert_store); | ||
191 | |||
192 | exit(0); | ||
193 | err: | ||
194 | ERR_load_crypto_strings(); | ||
195 | ERR_print_errors_fp(stderr); | ||
196 | exit(1); | ||
197 | } | ||
198 | |||
199 | /* should be X509 * but we can just have them as char *. */ | ||
200 | int verify_callback(int ok, X509_STORE_CTX *ctx) | ||
201 | { | ||
202 | char buf[256]; | ||
203 | X509 *err_cert; | ||
204 | int err,depth; | ||
205 | |||
206 | err_cert=X509_STORE_CTX_get_current_cert(ctx); | ||
207 | err= X509_STORE_CTX_get_error(ctx); | ||
208 | depth= X509_STORE_CTX_get_error_depth(ctx); | ||
209 | |||
210 | X509_NAME_oneline(X509_get_subject_name(err_cert),buf,256); | ||
211 | BIO_printf(bio_err,"depth=%d %s\n",depth,buf); | ||
212 | if (!ok) | ||
213 | { | ||
214 | BIO_printf(bio_err,"verify error:num=%d:%s\n",err, | ||
215 | X509_verify_cert_error_string(err)); | ||
216 | if (depth < 6) | ||
217 | { | ||
218 | ok=1; | ||
219 | X509_STORE_CTX_set_error(ctx,X509_V_OK); | ||
220 | } | ||
221 | else | ||
222 | { | ||
223 | ok=0; | ||
224 | X509_STORE_CTX_set_error(ctx,X509_V_ERR_CERT_CHAIN_TOO_LONG); | ||
225 | } | ||
226 | } | ||
227 | switch (ctx->error) | ||
228 | { | ||
229 | case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT: | ||
230 | X509_NAME_oneline(X509_get_issuer_name(ctx->current_cert),buf,256); | ||
231 | BIO_printf(bio_err,"issuer= %s\n",buf); | ||
232 | break; | ||
233 | case X509_V_ERR_CERT_NOT_YET_VALID: | ||
234 | case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD: | ||
235 | BIO_printf(bio_err,"notBefore="); | ||
236 | ASN1_UTCTIME_print(bio_err,X509_get_notBefore(ctx->current_cert)); | ||
237 | BIO_printf(bio_err,"\n"); | ||
238 | break; | ||
239 | case X509_V_ERR_CERT_HAS_EXPIRED: | ||
240 | case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD: | ||
241 | BIO_printf(bio_err,"notAfter="); | ||
242 | ASN1_UTCTIME_print(bio_err,X509_get_notAfter(ctx->current_cert)); | ||
243 | BIO_printf(bio_err,"\n"); | ||
244 | break; | ||
245 | } | ||
246 | BIO_printf(bio_err,"verify return:%d\n",ok); | ||
247 | return(ok); | ||
248 | } | ||
diff --git a/src/lib/libcrypto/pkcs7/des.pem b/src/lib/libcrypto/pkcs7/des.pem new file mode 100644 index 0000000000..62d1657e3e --- /dev/null +++ b/src/lib/libcrypto/pkcs7/des.pem | |||
@@ -0,0 +1,15 @@ | |||
1 | |||
2 | MIAGCSqGSIb3DQEHA6CAMIACAQAxggHmMIHwAgEAMIGZMIGSMQswCQYDVQQGEwJBVTETMBEG | ||
3 | A1UECBMKUXVlZW5zbGFuZDERMA8GA1UEBxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29m | ||
4 | dCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNUUkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQD | ||
5 | ExJERU1PIFpFUk8gVkFMVUUgQ0ECAgR+MA0GCSqGSIb3DQEBAQUABEC2vXI1xQDW6lUHM3zQ | ||
6 | /9uBEBOO5A3TtkrklAXq7v01gsIC21t52qSk36REXY+slhNZ0OQ349tgkTsoETHFLoEwMIHw | ||
7 | AgEAMIGZMIGSMQswCQYDVQQGEwJBVTETMBEGA1UECBMKUXVlZW5zbGFuZDERMA8GA1UEBxMI | ||
8 | QnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29mdCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNU | ||
9 | UkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQDExJERU1PIFpFUk8gVkFMVUUgQ0ECAgR9MA0G | ||
10 | CSqGSIb3DQEBAQUABEB8ujxbabxXUYJhopuDm3oDq4JNqX6Io4p3ro+ShqfIndsXTZ1v5a2N | ||
11 | WtLLCWlHn/habjBwZ/DgQgcKASbZ7QxNMIAGCSqGSIb3DQEHATAaBggqhkiG9w0DAjAOAgIA | ||
12 | oAQIbsL5v1wX98KggAQoAaJ4WHm68fXY1WE5OIjfVBIDpO1K+i8dmKhjnAjrjoyZ9Bwc8rDL | ||
13 | lgQg4CXb805h5xl+GfvSwUaHJayte1m2mcOhs3J2YyqbQ+MEIMIiJQccmhO3oDKm36CFvYR8 | ||
14 | 5PjpclVcZyX2ngbwPFMnBAgy0clOAE6UKAAAAAAAAAAAAAA= | ||
15 | |||
diff --git a/src/lib/libcrypto/pkcs7/doc b/src/lib/libcrypto/pkcs7/doc new file mode 100644 index 0000000000..d2e8b7b2a3 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/doc | |||
@@ -0,0 +1,24 @@ | |||
1 | int PKCS7_set_content_type(PKCS7 *p7, int type); | ||
2 | Call to set the type of PKCS7 object we are working on | ||
3 | |||
4 | int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey, | ||
5 | EVP_MD *dgst); | ||
6 | Use this to setup a signer info | ||
7 | There will also be functions to add signed and unsigned attributes. | ||
8 | |||
9 | int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *p7i); | ||
10 | Add a signer info to the content. | ||
11 | |||
12 | int PKCS7_add_certificae(PKCS7 *p7, X509 *x509); | ||
13 | int PKCS7_add_crl(PKCS7 *p7, X509_CRL *x509); | ||
14 | |||
15 | ---- | ||
16 | |||
17 | p7=PKCS7_new(); | ||
18 | PKCS7_set_content_type(p7,NID_pkcs7_signed); | ||
19 | |||
20 | signer=PKCS7_SINGNER_INFO_new(); | ||
21 | PKCS7_SIGNER_INFO_set(signer,x509,pkey,EVP_md5()); | ||
22 | PKCS7_add_signer(py,signer); | ||
23 | |||
24 | we are now setup. | ||
diff --git a/src/lib/libcrypto/pkcs7/enc.c b/src/lib/libcrypto/pkcs7/enc.c new file mode 100644 index 0000000000..7417f8a4e0 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/enc.c | |||
@@ -0,0 +1,174 @@ | |||
1 | /* crypto/pkcs7/enc.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 | #include <stdio.h> | ||
59 | #include <string.h> | ||
60 | #include <openssl/bio.h> | ||
61 | #include <openssl/x509.h> | ||
62 | #include <openssl/pem.h> | ||
63 | #include <openssl/err.h> | ||
64 | |||
65 | int main(argc,argv) | ||
66 | int argc; | ||
67 | char *argv[]; | ||
68 | { | ||
69 | X509 *x509; | ||
70 | PKCS7 *p7; | ||
71 | BIO *in; | ||
72 | BIO *data,*p7bio; | ||
73 | char buf[1024*4]; | ||
74 | int i; | ||
75 | int nodetach=1; | ||
76 | char *keyfile = NULL; | ||
77 | const EVP_CIPHER *cipher=NULL; | ||
78 | STACK_OF(X509) *recips=NULL; | ||
79 | |||
80 | OpenSSL_add_all_algorithms(); | ||
81 | |||
82 | data=BIO_new(BIO_s_file()); | ||
83 | while(argc > 1) | ||
84 | { | ||
85 | if (strcmp(argv[1],"-nd") == 0) | ||
86 | { | ||
87 | nodetach=1; | ||
88 | argv++; argc--; | ||
89 | } | ||
90 | else if ((strcmp(argv[1],"-c") == 0) && (argc >= 2)) { | ||
91 | if(!(cipher = EVP_get_cipherbyname(argv[2]))) { | ||
92 | fprintf(stderr, "Unknown cipher %s\n", argv[2]); | ||
93 | goto err; | ||
94 | } | ||
95 | argc-=2; | ||
96 | argv+=2; | ||
97 | } else if ((strcmp(argv[1],"-k") == 0) && (argc >= 2)) { | ||
98 | keyfile = argv[2]; | ||
99 | argc-=2; | ||
100 | argv+=2; | ||
101 | if (!(in=BIO_new_file(keyfile,"r"))) goto err; | ||
102 | if (!(x509=PEM_read_bio_X509(in,NULL,NULL,NULL))) | ||
103 | goto err; | ||
104 | if(!recips) recips = sk_X509_new_null(); | ||
105 | sk_X509_push(recips, x509); | ||
106 | BIO_free(in); | ||
107 | } else break; | ||
108 | } | ||
109 | |||
110 | if(!recips) { | ||
111 | fprintf(stderr, "No recipients\n"); | ||
112 | goto err; | ||
113 | } | ||
114 | |||
115 | if (!BIO_read_filename(data,argv[1])) goto err; | ||
116 | |||
117 | p7=PKCS7_new(); | ||
118 | #if 0 | ||
119 | BIO_reset(in); | ||
120 | if ((pkey=PEM_read_bio_PrivateKey(in,NULL,NULL)) == NULL) goto err; | ||
121 | BIO_free(in); | ||
122 | PKCS7_set_type(p7,NID_pkcs7_signedAndEnveloped); | ||
123 | |||
124 | if (PKCS7_add_signature(p7,x509,pkey,EVP_sha1()) == NULL) goto err; | ||
125 | /* we may want to add more */ | ||
126 | PKCS7_add_certificate(p7,x509); | ||
127 | #else | ||
128 | PKCS7_set_type(p7,NID_pkcs7_enveloped); | ||
129 | #endif | ||
130 | if(!cipher) { | ||
131 | #ifndef OPENSSL_NO_DES | ||
132 | cipher = EVP_des_ede3_cbc(); | ||
133 | #else | ||
134 | fprintf(stderr, "No cipher selected\n"); | ||
135 | goto err; | ||
136 | #endif | ||
137 | } | ||
138 | |||
139 | if (!PKCS7_set_cipher(p7,cipher)) goto err; | ||
140 | for(i = 0; i < sk_X509_num(recips); i++) { | ||
141 | if (!PKCS7_add_recipient(p7,sk_X509_value(recips, i))) goto err; | ||
142 | } | ||
143 | sk_X509_pop_free(recips, X509_free); | ||
144 | |||
145 | /* Set the content of the signed to 'data' */ | ||
146 | /* PKCS7_content_new(p7,NID_pkcs7_data); not used in envelope */ | ||
147 | |||
148 | /* could be used, but not in this version :-) | ||
149 | if (!nodetach) PKCS7_set_detached(p7,1); | ||
150 | */ | ||
151 | |||
152 | if ((p7bio=PKCS7_dataInit(p7,NULL)) == NULL) goto err; | ||
153 | |||
154 | for (;;) | ||
155 | { | ||
156 | i=BIO_read(data,buf,sizeof(buf)); | ||
157 | if (i <= 0) break; | ||
158 | BIO_write(p7bio,buf,i); | ||
159 | } | ||
160 | BIO_flush(p7bio); | ||
161 | |||
162 | if (!PKCS7_dataFinal(p7,p7bio)) goto err; | ||
163 | BIO_free(p7bio); | ||
164 | |||
165 | PEM_write_PKCS7(stdout,p7); | ||
166 | PKCS7_free(p7); | ||
167 | |||
168 | exit(0); | ||
169 | err: | ||
170 | ERR_load_crypto_strings(); | ||
171 | ERR_print_errors_fp(stderr); | ||
172 | exit(1); | ||
173 | } | ||
174 | |||
diff --git a/src/lib/libcrypto/pkcs7/es1.pem b/src/lib/libcrypto/pkcs7/es1.pem new file mode 100644 index 0000000000..47112a238f --- /dev/null +++ b/src/lib/libcrypto/pkcs7/es1.pem | |||
@@ -0,0 +1,66 @@ | |||
1 | -----BEGIN PKCS7----- | ||
2 | MIAGCSqGSIb3DQEHA6CAMIACAQAxggHmMIHwAgEAMIGZMIGSMQswCQYDVQQGEwJBVTETMBEG | ||
3 | A1UECBMKUXVlZW5zbGFuZDERMA8GA1UEBxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29m | ||
4 | dCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNUUkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQD | ||
5 | ExJERU1PIFpFUk8gVkFMVUUgQ0ECAgRuMA0GCSqGSIb3DQEBAQUABEDWak0y/5XZJhQJeCLo | ||
6 | KECcHXkTEbjzYkYNHIinbiPmRK4QbNfs9z2mA3z/c2ykQ4eAqFR2jyNrUMN/+I5XEiv6MIHw | ||
7 | AgEAMIGZMIGSMQswCQYDVQQGEwJBVTETMBEGA1UECBMKUXVlZW5zbGFuZDERMA8GA1UEBxMI | ||
8 | QnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29mdCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNU | ||
9 | UkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQDExJERU1PIFpFUk8gVkFMVUUgQ0ECAgR9MA0G | ||
10 | CSqGSIb3DQEBAQUABEAWg9+KgtCjc77Jdj1Ve4wGgHjVHbbSYEA1ZqKFDoi15vSr9hfpHmC4 | ||
11 | ycZzcRo16JkTfolefiHZzmyjVz94vSN6MIAGCSqGSIb3DQEHATAaBggqhkiG9w0DAjAOAgIA | ||
12 | oAQI7X4Tk4mcbV6ggASBsHl1mCaJ3RhXWlNPCgCRU53d7M5x6TDZRkvwdtdvW96m1lupT03F | ||
13 | XtonkBqk7oMkH7kGfs5/REQOPjx0QE2Ixmgt1W3szum82EZwA7pZNppcraK7W/odw/7bYZO+ | ||
14 | II3HPmRklE2N9qiu1LPaPUsnYogkO6SennyeL5tZ382vBweL/8pnG0qsbT1OBb65v+llnsjT | ||
15 | pa1T/p+fIx/iJJGE6K9fYFokC6gXLQ6ozXRdOu5oBDB8mPCYYvAqKycidM/MrGGUkpEtS4f0 | ||
16 | lS31PwQi5YTim8Ig3/TOwVpPX32i46FTuEIEIMHkD/OvpfwCCzXUHHJnKnKUAUvIsSY3vGBs | ||
17 | 8ezpUDfBBBj9LHDy32hZ2tQilkDefP5VM2LLdrWgamYEgfiyITQvn08Ul5lQOQxbFKBheFq5 | ||
18 | otCCN4MR+w5eq12xQu6y+f9z0159ag2ru87D0lLtUtXXtCELbO1nUkT2sJ0k/iDs9TOXr6Cx | ||
19 | go1XKYho83hlkXYiCteVizdAbgVGNsNRD4wtIdajsorET/LuJECgp11YeL9w1dlDB0HLEZfi | ||
20 | XCsUphH4jGagba3hDeUSibnjSiJlN0ukfuQurBBbI2UkBAujiEAubKPn7C1FZJRSw6CPPX5t | ||
21 | KEpmcqT1JNk6LO8Js6/1sCmmBh1VGCy1+EuTI9J1p7Dagf4nQ8cHitoCRpHuKZlFHnZyv7tw | ||
22 | Rn/KOhHaYP2VzAh40gQIvKMAAWh9oFsEEIMwIoOmLwLH5wf+8QdbDhoECH8HwZt9a12dBAjL | ||
23 | r4j2zlvtfgQIt7nmEM3wz1EECKlc3EIy1irCBBCAKINcermK3A+jI6ISN2RzBFA3dsh/xwMu | ||
24 | l61aWMBBZzEz/SF92k6n35KZhCC0d6fIVC/1WMv0fnCwQ8oEDynSre216VEFiYKBaQLJe5o/ | ||
25 | mTAxC7Ht3goXnuc+i1FItOkLrgRI/wyvTICEn2WsNZiMADnGaee2bqPnUopo+VMGexJEtCPk | ||
26 | l0ZNlDJGquPDkpUwaEtecVZzCNyVPYyyF4J/l8rmGDhDdYUIC8IKBEg/ip/E0BuubBLWVbv+ | ||
27 | HRl4QrnGpyCyeXRXXK603QP3sT1Zbbm1v5pI/loOhVHi724LmtXHSyp5qv9MDcxE1PoX10LY | ||
28 | gBRtlwwESPeCF8bK5jk4xIQMhK5NMHj1Y1KQWTZ9NGITBL4hjRq2qp4Qk5GIpGgOVPopAuCo | ||
29 | TIyPikpqBRNtLSPRSsDs6QPUPzWBh6JgxwRQblnDKKUkxUcnJiD4i9QtGa/ZabMn4KxtNOBL | ||
30 | 5JSh1nJkaLXCZY070131WWPAByLcd5TiXq8x84pmzV5NNk4tiMpoXhJNsx8e4rskQQlKd6ME | ||
31 | SCe2eYDHKcKPX3WJbUzhrJSQ92/aWnI2iUY8WQ+kSNyiZ2QUjyuUg9Z66g/0d2STlvPOBHT/ | ||
32 | y5ODP2CwbcWX4QmCbUc9TT66fQRIrRVuwvtOfnUueyGgYhJ3HpAJfVaB/7kap5bj7Fi/azW4 | ||
33 | 9JDfd1bC/W9h0Kyk7RO2gxvE0hIHc26mZJHTm9MNP5D328MnM2MdBEjKjQBtgrp+lFIii7MP | ||
34 | nGHFTKUkG4WAIZJCf/CsT+p6/SW0qG71Me/YcSw5STB24j+a+HgMV8RVIeUlkP4z0IWWrSoB | ||
35 | Gh4d/Z0EUMCVHs/HZ/bWgiyhtHpvuVAzidm8D81p1LJ5BQX5/5f/m+q5+fS/npL27dTEbNqs | ||
36 | LSB6ij3MZAi7LwHWpTn9zWnDajCMEj9vlaV7mcKtHK5iBEg85agFi1h3MvicqLtoFe5hVv9T | ||
37 | tG0j6CRkjkixPzivltlrf44KHv14gLM0XJxCGyq7vd3l8QYr3+9at0zNnX/yqTiBnsnE5dUE | ||
38 | SIgrYuz87M2gi/ER9PcDoTtONH3+CkcqVy03q/Sj8cVWD/b1KgEhqnNOfc8Ak9PctyR/ItcR | ||
39 | 8Me5XVn1GJKkQJk4O29fxvgNoAQIrIESvUWGshAEQByXiFoFTDUByjTlgjcy77H1lrH+y3P/ | ||
40 | wAInJjJAut9kCNyGJV0PA4kdPB5USWltuO6t8gk4Pd2YBMl09zqUWkAEUCjFrtZ3mapjcGZI | ||
41 | uQTASKR5LSjXoWxTT5gae/+64MerF/oCEeO3ehRTpjnPrsiRDo0rWIQTaj9+Nro8Z2xtWstw | ||
42 | RnfoAHIxV1lEamPwjsceBEi2SD9hiifFeO5ECiVoaE1FdXUXhU+jwYAMx6jHWO9hMkYzS9pM | ||
43 | Y3IyWR5ybtOjiQgkUdvRJPUPGf5DVVMPnymGX25aDh5PYpIESPbsM9akCpOOVuscywcUswmU | ||
44 | o7dXvlB48WWCfg/al3BQKAZbn5ZXtWNwpUZkrEdHsrxAVv3rxRcdkT3Z1fzUbIuYkLJN200o | ||
45 | WgRIJvn6RO8KEj7/HOg2sYuuM8nz1kR0TSgwX7/0y/7JfjBa0JIlP7o75sNJscE8oyoIMzuy | ||
46 | Dvn6/U9g3BCDXn83A/s+ke60qn9gBFC6NAeLOlXal1YVWYhMQNOqCyUfAjiXBTawaysQb1Mk | ||
47 | YgeNlF8xuEFcUQWIP+vNG7FJ5JPMaMRL4YEoaQ3sVFhYOERJR1cSb+8xt4QCYtBKQgRIUOmJ | ||
48 | CHW5o1hXJWJiTkZK2qWFcEMzTINSj5EpYFySr8aVBjkRnI7vxegRT/+XZZXoYedQ3UNsnGI3 | ||
49 | DdkWii5VzX0PNF6C60pfBEiVpausYuX7Wjb3Lfm8cBj7GgN69i6Pm2gxtobVcmpo2nS4D714 | ||
50 | ePyhlX9n8kJ6QAcqWMRj22smDPrHVGNTizfzHBh5zNllK9gESJizILOWI327og3ZWp+qUht5 | ||
51 | kNDJCzMK7Z09UAy+h+vq0VTQuEo3FgLzVdqkJujjSL4Nx97lXg51AovrEn3nd4evydwcjKLX | ||
52 | 1wRIo72NaeWuUEQ+rt1SlCsOJ7k1ioJSqhrPOfvwcaFcb4beVet1JWiy4yvowTjLDGbUje2s | ||
53 | xjrlVt4BJWI/uA6jbQsrxSe89ADZBAi5YAlR4qszeAQIXD3VSBVKbRUECNTtyvw9vvqXBAhb | ||
54 | IZNn4H4cxgQI+XW7GkfL+ekECCCCg2reMyGDBAh1PYqkg3lw3gQQkNlggEPU+BH8eh7Gm7n7 | ||
55 | 7AQIjC5EWbkil5cEEKcpuqwTWww/X89KnQAg8TcECJPomqHvrlZFBBiRSuIiHpmN+PaujXpv | ||
56 | qZV2VhjkB2j09GEECOIdv8AVOJgKBAjlHgIqAD9jZQQIXHbs44+wogcEIGGqTACRJxrhMcMG | ||
57 | X8drNjksIPt+snxTXUBIkTVpZWoABAh6unXPTyIr8QQgBF8xKoX27MWk7iTNmkSNZggZXa2a | ||
58 | DWCGHSYLngbSOHIECD9XmO6VsvTgBAjfqB70CEW4WwQIVIBkbCocznUEEHB/zFXy/sR4OYHe | ||
59 | UfbNPnIEEDWBB/NTCLMGE+o8BfyujcAECFik7GQnnF9VBBAhLXExQeWAofZNc6NtN7qZBCC1 | ||
60 | gVIS3ruTwKltmcrgx3heT3M8ZJhCfWa+6KzchnmKygQQ+1NL5sSzR4m/fdrqxHFyUAQYCT2x | ||
61 | PamQr3wK3h0lyZER+4H0zPM86AhFBBC3CkmvL2vjflMfujnzPBVpBBge9rMbI5+0q9DLrTiT | ||
62 | 5F3AIgXLpD8PQWAECHkHVo6RomV3BAgMbi8E271UeAQIqtS8wnI3XngECG3TWmOMb3/iBEha | ||
63 | y+mvCS6I3n3JfL8e1B5P4qX9/czJRaERLuKpGNjLiL4A+zxN0LZ0UHd0qfmJjwOTxAx3iJAC | ||
64 | lGXX4nB9ATYPUT5EU+o1Y4sECN01pP6vWNIdBDAsiE0Ts8/9ltJlqX2B3AoOM4qOt9EaCjXf | ||
65 | lB+aEmrhtjUwuZ6GqS5Ke7P6XnakTk4ECCLIMatNdootAAAAAAAAAAAAAA== | ||
66 | -----END PKCS7----- | ||
diff --git a/src/lib/libcrypto/pkcs7/example.c b/src/lib/libcrypto/pkcs7/example.c new file mode 100644 index 0000000000..c993947cc3 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/example.c | |||
@@ -0,0 +1,329 @@ | |||
1 | #include <stdio.h> | ||
2 | #include <stdlib.h> | ||
3 | #include <string.h> | ||
4 | #include <openssl/pkcs7.h> | ||
5 | #include <openssl/asn1_mac.h> | ||
6 | #include <openssl/x509.h> | ||
7 | |||
8 | int add_signed_time(PKCS7_SIGNER_INFO *si) | ||
9 | { | ||
10 | ASN1_UTCTIME *sign_time; | ||
11 | |||
12 | /* The last parameter is the amount to add/subtract from the current | ||
13 | * time (in seconds) */ | ||
14 | sign_time=X509_gmtime_adj(NULL,0); | ||
15 | PKCS7_add_signed_attribute(si,NID_pkcs9_signingTime, | ||
16 | V_ASN1_UTCTIME,(char *)sign_time); | ||
17 | return(1); | ||
18 | } | ||
19 | |||
20 | ASN1_UTCTIME *get_signed_time(PKCS7_SIGNER_INFO *si) | ||
21 | { | ||
22 | ASN1_TYPE *so; | ||
23 | |||
24 | so=PKCS7_get_signed_attribute(si,NID_pkcs9_signingTime); | ||
25 | if (so->type == V_ASN1_UTCTIME) | ||
26 | return so->value.utctime; | ||
27 | return NULL; | ||
28 | } | ||
29 | |||
30 | static int signed_string_nid= -1; | ||
31 | |||
32 | void add_signed_string(PKCS7_SIGNER_INFO *si, char *str) | ||
33 | { | ||
34 | ASN1_OCTET_STRING *os; | ||
35 | |||
36 | /* To a an object of OID 1.2.3.4.5, which is an octet string */ | ||
37 | if (signed_string_nid == -1) | ||
38 | signed_string_nid= | ||
39 | OBJ_create("1.2.3.4.5","OID_example","Our example OID"); | ||
40 | os=ASN1_OCTET_STRING_new(); | ||
41 | ASN1_OCTET_STRING_set(os,(unsigned char*)str,strlen(str)); | ||
42 | /* When we add, we do not free */ | ||
43 | PKCS7_add_signed_attribute(si,signed_string_nid, | ||
44 | V_ASN1_OCTET_STRING,(char *)os); | ||
45 | } | ||
46 | |||
47 | int get_signed_string(PKCS7_SIGNER_INFO *si, char *buf, int len) | ||
48 | { | ||
49 | ASN1_TYPE *so; | ||
50 | ASN1_OCTET_STRING *os; | ||
51 | int i; | ||
52 | |||
53 | if (signed_string_nid == -1) | ||
54 | signed_string_nid= | ||
55 | OBJ_create("1.2.3.4.5","OID_example","Our example OID"); | ||
56 | /* To retrieve */ | ||
57 | so=PKCS7_get_signed_attribute(si,signed_string_nid); | ||
58 | if (so != NULL) | ||
59 | { | ||
60 | if (so->type == V_ASN1_OCTET_STRING) | ||
61 | { | ||
62 | os=so->value.octet_string; | ||
63 | i=os->length; | ||
64 | if ((i+1) > len) | ||
65 | i=len-1; | ||
66 | memcpy(buf,os->data,i); | ||
67 | return(i); | ||
68 | } | ||
69 | } | ||
70 | return(0); | ||
71 | } | ||
72 | |||
73 | static int signed_seq2string_nid= -1; | ||
74 | /* ########################################### */ | ||
75 | int add_signed_seq2string(PKCS7_SIGNER_INFO *si, char *str1, char *str2) | ||
76 | { | ||
77 | /* To add an object of OID 1.9.999, which is a sequence containing | ||
78 | * 2 octet strings */ | ||
79 | unsigned char *p; | ||
80 | ASN1_OCTET_STRING *os1,*os2; | ||
81 | ASN1_STRING *seq; | ||
82 | unsigned char *data; | ||
83 | int i,total; | ||
84 | |||
85 | if (signed_seq2string_nid == -1) | ||
86 | signed_seq2string_nid= | ||
87 | OBJ_create("1.9.9999","OID_example","Our example OID"); | ||
88 | |||
89 | os1=ASN1_OCTET_STRING_new(); | ||
90 | os2=ASN1_OCTET_STRING_new(); | ||
91 | ASN1_OCTET_STRING_set(os1,(unsigned char*)str1,strlen(str1)); | ||
92 | ASN1_OCTET_STRING_set(os2,(unsigned char*)str1,strlen(str1)); | ||
93 | i =i2d_ASN1_OCTET_STRING(os1,NULL); | ||
94 | i+=i2d_ASN1_OCTET_STRING(os2,NULL); | ||
95 | total=ASN1_object_size(1,i,V_ASN1_SEQUENCE); | ||
96 | |||
97 | data=malloc(total); | ||
98 | p=data; | ||
99 | ASN1_put_object(&p,1,i,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL); | ||
100 | i2d_ASN1_OCTET_STRING(os1,&p); | ||
101 | i2d_ASN1_OCTET_STRING(os2,&p); | ||
102 | |||
103 | seq=ASN1_STRING_new(); | ||
104 | ASN1_STRING_set(seq,data,total); | ||
105 | free(data); | ||
106 | ASN1_OCTET_STRING_free(os1); | ||
107 | ASN1_OCTET_STRING_free(os2); | ||
108 | |||
109 | PKCS7_add_signed_attribute(si,signed_seq2string_nid, | ||
110 | V_ASN1_SEQUENCE,(char *)seq); | ||
111 | return(1); | ||
112 | } | ||
113 | |||
114 | /* For this case, I will malloc the return strings */ | ||
115 | int get_signed_seq2string(PKCS7_SIGNER_INFO *si, char **str1, char **str2) | ||
116 | { | ||
117 | ASN1_TYPE *so; | ||
118 | |||
119 | if (signed_seq2string_nid == -1) | ||
120 | signed_seq2string_nid= | ||
121 | OBJ_create("1.9.9999","OID_example","Our example OID"); | ||
122 | /* To retrieve */ | ||
123 | so=PKCS7_get_signed_attribute(si,signed_seq2string_nid); | ||
124 | if (so && (so->type == V_ASN1_SEQUENCE)) | ||
125 | { | ||
126 | ASN1_CTX c; | ||
127 | ASN1_STRING *s; | ||
128 | long length; | ||
129 | ASN1_OCTET_STRING *os1,*os2; | ||
130 | |||
131 | s=so->value.sequence; | ||
132 | c.p=ASN1_STRING_data(s); | ||
133 | c.max=c.p+ASN1_STRING_length(s); | ||
134 | if (!asn1_GetSequence(&c,&length)) goto err; | ||
135 | /* Length is the length of the seqence */ | ||
136 | |||
137 | c.q=c.p; | ||
138 | if ((os1=d2i_ASN1_OCTET_STRING(NULL,&c.p,c.slen)) == NULL) | ||
139 | goto err; | ||
140 | c.slen-=(c.p-c.q); | ||
141 | |||
142 | c.q=c.p; | ||
143 | if ((os2=d2i_ASN1_OCTET_STRING(NULL,&c.p,c.slen)) == NULL) | ||
144 | goto err; | ||
145 | c.slen-=(c.p-c.q); | ||
146 | |||
147 | if (!asn1_Finish(&c)) goto err; | ||
148 | *str1=malloc(os1->length+1); | ||
149 | *str2=malloc(os2->length+1); | ||
150 | memcpy(*str1,os1->data,os1->length); | ||
151 | memcpy(*str2,os2->data,os2->length); | ||
152 | (*str1)[os1->length]='\0'; | ||
153 | (*str2)[os2->length]='\0'; | ||
154 | ASN1_OCTET_STRING_free(os1); | ||
155 | ASN1_OCTET_STRING_free(os2); | ||
156 | return(1); | ||
157 | } | ||
158 | err: | ||
159 | return(0); | ||
160 | } | ||
161 | |||
162 | |||
163 | /* ####################################### | ||
164 | * THE OTHER WAY TO DO THINGS | ||
165 | * ####################################### | ||
166 | */ | ||
167 | X509_ATTRIBUTE *create_time(void) | ||
168 | { | ||
169 | ASN1_UTCTIME *sign_time; | ||
170 | X509_ATTRIBUTE *ret; | ||
171 | |||
172 | /* The last parameter is the amount to add/subtract from the current | ||
173 | * time (in seconds) */ | ||
174 | sign_time=X509_gmtime_adj(NULL,0); | ||
175 | ret=X509_ATTRIBUTE_create(NID_pkcs9_signingTime, | ||
176 | V_ASN1_UTCTIME,(char *)sign_time); | ||
177 | return(ret); | ||
178 | } | ||
179 | |||
180 | ASN1_UTCTIME *sk_get_time(STACK_OF(X509_ATTRIBUTE) *sk) | ||
181 | { | ||
182 | ASN1_TYPE *so; | ||
183 | PKCS7_SIGNER_INFO si; | ||
184 | |||
185 | si.auth_attr=sk; | ||
186 | so=PKCS7_get_signed_attribute(&si,NID_pkcs9_signingTime); | ||
187 | if (so->type == V_ASN1_UTCTIME) | ||
188 | return so->value.utctime; | ||
189 | return NULL; | ||
190 | } | ||
191 | |||
192 | X509_ATTRIBUTE *create_string(char *str) | ||
193 | { | ||
194 | ASN1_OCTET_STRING *os; | ||
195 | X509_ATTRIBUTE *ret; | ||
196 | |||
197 | /* To a an object of OID 1.2.3.4.5, which is an octet string */ | ||
198 | if (signed_string_nid == -1) | ||
199 | signed_string_nid= | ||
200 | OBJ_create("1.2.3.4.5","OID_example","Our example OID"); | ||
201 | os=ASN1_OCTET_STRING_new(); | ||
202 | ASN1_OCTET_STRING_set(os,(unsigned char*)str,strlen(str)); | ||
203 | /* When we add, we do not free */ | ||
204 | ret=X509_ATTRIBUTE_create(signed_string_nid, | ||
205 | V_ASN1_OCTET_STRING,(char *)os); | ||
206 | return(ret); | ||
207 | } | ||
208 | |||
209 | int sk_get_string(STACK_OF(X509_ATTRIBUTE) *sk, char *buf, int len) | ||
210 | { | ||
211 | ASN1_TYPE *so; | ||
212 | ASN1_OCTET_STRING *os; | ||
213 | int i; | ||
214 | PKCS7_SIGNER_INFO si; | ||
215 | |||
216 | si.auth_attr=sk; | ||
217 | |||
218 | if (signed_string_nid == -1) | ||
219 | signed_string_nid= | ||
220 | OBJ_create("1.2.3.4.5","OID_example","Our example OID"); | ||
221 | /* To retrieve */ | ||
222 | so=PKCS7_get_signed_attribute(&si,signed_string_nid); | ||
223 | if (so != NULL) | ||
224 | { | ||
225 | if (so->type == V_ASN1_OCTET_STRING) | ||
226 | { | ||
227 | os=so->value.octet_string; | ||
228 | i=os->length; | ||
229 | if ((i+1) > len) | ||
230 | i=len-1; | ||
231 | memcpy(buf,os->data,i); | ||
232 | return(i); | ||
233 | } | ||
234 | } | ||
235 | return(0); | ||
236 | } | ||
237 | |||
238 | X509_ATTRIBUTE *add_seq2string(PKCS7_SIGNER_INFO *si, char *str1, char *str2) | ||
239 | { | ||
240 | /* To add an object of OID 1.9.999, which is a sequence containing | ||
241 | * 2 octet strings */ | ||
242 | unsigned char *p; | ||
243 | ASN1_OCTET_STRING *os1,*os2; | ||
244 | ASN1_STRING *seq; | ||
245 | X509_ATTRIBUTE *ret; | ||
246 | unsigned char *data; | ||
247 | int i,total; | ||
248 | |||
249 | if (signed_seq2string_nid == -1) | ||
250 | signed_seq2string_nid= | ||
251 | OBJ_create("1.9.9999","OID_example","Our example OID"); | ||
252 | |||
253 | os1=ASN1_OCTET_STRING_new(); | ||
254 | os2=ASN1_OCTET_STRING_new(); | ||
255 | ASN1_OCTET_STRING_set(os1,(unsigned char*)str1,strlen(str1)); | ||
256 | ASN1_OCTET_STRING_set(os2,(unsigned char*)str1,strlen(str1)); | ||
257 | i =i2d_ASN1_OCTET_STRING(os1,NULL); | ||
258 | i+=i2d_ASN1_OCTET_STRING(os2,NULL); | ||
259 | total=ASN1_object_size(1,i,V_ASN1_SEQUENCE); | ||
260 | |||
261 | data=malloc(total); | ||
262 | p=data; | ||
263 | ASN1_put_object(&p,1,i,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL); | ||
264 | i2d_ASN1_OCTET_STRING(os1,&p); | ||
265 | i2d_ASN1_OCTET_STRING(os2,&p); | ||
266 | |||
267 | seq=ASN1_STRING_new(); | ||
268 | ASN1_STRING_set(seq,data,total); | ||
269 | free(data); | ||
270 | ASN1_OCTET_STRING_free(os1); | ||
271 | ASN1_OCTET_STRING_free(os2); | ||
272 | |||
273 | ret=X509_ATTRIBUTE_create(signed_seq2string_nid, | ||
274 | V_ASN1_SEQUENCE,(char *)seq); | ||
275 | return(ret); | ||
276 | } | ||
277 | |||
278 | /* For this case, I will malloc the return strings */ | ||
279 | int sk_get_seq2string(STACK_OF(X509_ATTRIBUTE) *sk, char **str1, char **str2) | ||
280 | { | ||
281 | ASN1_TYPE *so; | ||
282 | PKCS7_SIGNER_INFO si; | ||
283 | |||
284 | if (signed_seq2string_nid == -1) | ||
285 | signed_seq2string_nid= | ||
286 | OBJ_create("1.9.9999","OID_example","Our example OID"); | ||
287 | |||
288 | si.auth_attr=sk; | ||
289 | /* To retrieve */ | ||
290 | so=PKCS7_get_signed_attribute(&si,signed_seq2string_nid); | ||
291 | if (so->type == V_ASN1_SEQUENCE) | ||
292 | { | ||
293 | ASN1_CTX c; | ||
294 | ASN1_STRING *s; | ||
295 | long length; | ||
296 | ASN1_OCTET_STRING *os1,*os2; | ||
297 | |||
298 | s=so->value.sequence; | ||
299 | c.p=ASN1_STRING_data(s); | ||
300 | c.max=c.p+ASN1_STRING_length(s); | ||
301 | if (!asn1_GetSequence(&c,&length)) goto err; | ||
302 | /* Length is the length of the seqence */ | ||
303 | |||
304 | c.q=c.p; | ||
305 | if ((os1=d2i_ASN1_OCTET_STRING(NULL,&c.p,c.slen)) == NULL) | ||
306 | goto err; | ||
307 | c.slen-=(c.p-c.q); | ||
308 | |||
309 | c.q=c.p; | ||
310 | if ((os2=d2i_ASN1_OCTET_STRING(NULL,&c.p,c.slen)) == NULL) | ||
311 | goto err; | ||
312 | c.slen-=(c.p-c.q); | ||
313 | |||
314 | if (!asn1_Finish(&c)) goto err; | ||
315 | *str1=malloc(os1->length+1); | ||
316 | *str2=malloc(os2->length+1); | ||
317 | memcpy(*str1,os1->data,os1->length); | ||
318 | memcpy(*str2,os2->data,os2->length); | ||
319 | (*str1)[os1->length]='\0'; | ||
320 | (*str2)[os2->length]='\0'; | ||
321 | ASN1_OCTET_STRING_free(os1); | ||
322 | ASN1_OCTET_STRING_free(os2); | ||
323 | return(1); | ||
324 | } | ||
325 | err: | ||
326 | return(0); | ||
327 | } | ||
328 | |||
329 | |||
diff --git a/src/lib/libcrypto/pkcs7/example.h b/src/lib/libcrypto/pkcs7/example.h new file mode 100644 index 0000000000..96167de188 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/example.h | |||
@@ -0,0 +1,57 @@ | |||
1 | /* ==================================================================== | ||
2 | * Copyright (c) 1999 The OpenSSL Project. All rights reserved. | ||
3 | * | ||
4 | * Redistribution and use in source and binary forms, with or without | ||
5 | * modification, are permitted provided that the following conditions | ||
6 | * are met: | ||
7 | * | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * | ||
11 | * 2. Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in | ||
13 | * the documentation and/or other materials provided with the | ||
14 | * distribution. | ||
15 | * | ||
16 | * 3. All advertising materials mentioning features or use of this | ||
17 | * software must display the following acknowledgment: | ||
18 | * "This product includes software developed by the OpenSSL Project | ||
19 | * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" | ||
20 | * | ||
21 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
22 | * endorse or promote products derived from this software without | ||
23 | * prior written permission. For written permission, please contact | ||
24 | * openssl-core@openssl.org. | ||
25 | * | ||
26 | * 5. Products derived from this software may not be called "OpenSSL" | ||
27 | * nor may "OpenSSL" appear in their names without prior written | ||
28 | * permission of the OpenSSL Project. | ||
29 | * | ||
30 | * 6. Redistributions of any form whatsoever must retain the following | ||
31 | * acknowledgment: | ||
32 | * "This product includes software developed by the OpenSSL Project | ||
33 | * for use in the OpenSSL Toolkit (http://www.openssl.org/)" | ||
34 | * | ||
35 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
36 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
37 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
38 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
39 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
40 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
41 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
42 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
43 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
44 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
45 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
46 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
47 | * ==================================================================== | ||
48 | * | ||
49 | * This product includes cryptographic software written by Eric Young | ||
50 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
51 | * Hudson (tjh@cryptsoft.com). | ||
52 | * | ||
53 | */ | ||
54 | |||
55 | int add_signed_time(PKCS7_SIGNER_INFO *si); | ||
56 | ASN1_UTCTIME *get_signed_time(PKCS7_SIGNER_INFO *si); | ||
57 | int get_signed_seq2string(PKCS7_SIGNER_INFO *si, char **str1, char **str2); | ||
diff --git a/src/lib/libcrypto/pkcs7/info.pem b/src/lib/libcrypto/pkcs7/info.pem new file mode 100644 index 0000000000..989baf8709 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/info.pem | |||
@@ -0,0 +1,57 @@ | |||
1 | issuer :/C=AU/SP=Queensland/L=Brisbane/O=Cryptsoft Pty Ltd/OU=DEMONSTRATION AND TESTING/CN=DEMO ZERO VALUE CA | ||
2 | subject:/C=AU/SP=Queensland/L=Brisbane/O=Cryptsoft Pty Ltd/OU=SMIME 003/CN=Information/Email=info@cryptsoft.com | ||
3 | serial :047D | ||
4 | |||
5 | Certificate: | ||
6 | Data: | ||
7 | Version: 3 (0x2) | ||
8 | Serial Number: 1149 (0x47d) | ||
9 | Signature Algorithm: md5withRSAEncryption | ||
10 | Issuer: C=AU, SP=Queensland, L=Brisbane, O=Cryptsoft Pty Ltd, OU=DEMONSTRATION AND TESTING, CN=DEMO ZERO VALUE CA | ||
11 | Validity | ||
12 | Not Before: May 13 05:40:58 1998 GMT | ||
13 | Not After : May 12 05:40:58 2000 GMT | ||
14 | Subject: C=AU, SP=Queensland, L=Brisbane, O=Cryptsoft Pty Ltd, OU=SMIME 003, CN=Information/Email=info@cryptsoft.com | ||
15 | Subject Public Key Info: | ||
16 | Public Key Algorithm: rsaEncryption | ||
17 | Modulus: | ||
18 | 00:ad:e7:23:89:ee:0d:87:b7:9c:32:44:4b:95:81: | ||
19 | 73:dd:22:80:4b:2d:c5:60:b8:fe:1e:18:63:ef:dc: | ||
20 | 89:89:22:df:95:3c:7a:db:3d:9a:06:a8:08:d6:29: | ||
21 | fd:ef:41:09:91:ed:bc:ad:98:f9:f6:28:90:62:6f: | ||
22 | e7:e7:0c:4d:0b | ||
23 | Exponent: 65537 (0x10001) | ||
24 | X509v3 extensions: | ||
25 | Netscape Comment: | ||
26 | Generated with SSLeay | ||
27 | Signature Algorithm: md5withRSAEncryption | ||
28 | 52:15:ea:88:f4:f0:f9:0b:ef:ce:d5:f8:83:40:61:16:5e:55: | ||
29 | f9:ce:2d:d1:8b:31:5c:03:c6:2d:10:7c:61:d5:5c:0a:42:97: | ||
30 | d1:fd:65:b6:b6:84:a5:39:ec:46:ec:fc:e0:0d:d9:22:da:1b: | ||
31 | 50:74:ad:92:cb:4e:90:e5:fa:7d | ||
32 | |||
33 | -----BEGIN CERTIFICATE----- | ||
34 | MIICTDCCAfagAwIBAgICBH0wDQYJKoZIhvcNAQEEBQAwgZIxCzAJBgNVBAYTAkFV | ||
35 | MRMwEQYDVQQIEwpRdWVlbnNsYW5kMREwDwYDVQQHEwhCcmlzYmFuZTEaMBgGA1UE | ||
36 | ChMRQ3J5cHRzb2Z0IFB0eSBMdGQxIjAgBgNVBAsTGURFTU9OU1RSQVRJT04gQU5E | ||
37 | IFRFU1RJTkcxGzAZBgNVBAMTEkRFTU8gWkVSTyBWQUxVRSBDQTAeFw05ODA1MTMw | ||
38 | NTQwNThaFw0wMDA1MTIwNTQwNThaMIGeMQswCQYDVQQGEwJBVTETMBEGA1UECBMK | ||
39 | UXVlZW5zbGFuZDERMA8GA1UEBxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29m | ||
40 | dCBQdHkgTHRkMRIwEAYDVQQLEwlTTUlNRSAwMDMxFDASBgNVBAMTC0luZm9ybWF0 | ||
41 | aW9uMSEwHwYJKoZIhvcNAQkBFhJpbmZvQGNyeXB0c29mdC5jb20wXDANBgkqhkiG | ||
42 | 9w0BAQEFAANLADBIAkEArecjie4Nh7ecMkRLlYFz3SKASy3FYLj+Hhhj79yJiSLf | ||
43 | lTx62z2aBqgI1in970EJke28rZj59iiQYm/n5wxNCwIDAQABoygwJjAkBglghkgB | ||
44 | hvhCAQ0EFxYVR2VuZXJhdGVkIHdpdGggU1NMZWF5MA0GCSqGSIb3DQEBBAUAA0EA | ||
45 | UhXqiPTw+QvvztX4g0BhFl5V+c4t0YsxXAPGLRB8YdVcCkKX0f1ltraEpTnsRuz8 | ||
46 | 4A3ZItobUHStkstOkOX6fQ== | ||
47 | -----END CERTIFICATE----- | ||
48 | |||
49 | -----BEGIN RSA PRIVATE KEY----- | ||
50 | MIIBOgIBAAJBAK3nI4nuDYe3nDJES5WBc90igEstxWC4/h4YY+/ciYki35U8ets9 | ||
51 | mgaoCNYp/e9BCZHtvK2Y+fYokGJv5+cMTQsCAwEAAQJBAIHpvXvqEcOEoDRRHuIG | ||
52 | fkcB4jPHcr9KE9TpxabH6xs9beN6OJnkePXAHwaz5MnUgSnbpOKq+cw8miKjXwe/ | ||
53 | zVECIQDVLwncT2lRmXarEYHzb+q/0uaSvKhWKKt3kJasLNTrAwIhANDUc/ghut29 | ||
54 | p3jJYjurzUKuG774/5eLjPLsxPPIZzNZAiA/10hSq41UnGqHLEUIS9m2/EeEZe7b | ||
55 | bm567dfRU9OnVQIgDo8ROrZXSchEGbaog5J5r/Fle83uO8l93R3GqVxKXZkCIFfk | ||
56 | IPD5PIYQAyyod3hyKKza7ZP4CGY4oOfZetbkSGGG | ||
57 | -----END RSA PRIVATE KEY----- | ||
diff --git a/src/lib/libcrypto/pkcs7/infokey.pem b/src/lib/libcrypto/pkcs7/infokey.pem new file mode 100644 index 0000000000..1e2acc954d --- /dev/null +++ b/src/lib/libcrypto/pkcs7/infokey.pem | |||
@@ -0,0 +1,9 @@ | |||
1 | -----BEGIN RSA PRIVATE KEY----- | ||
2 | MIIBOgIBAAJBAK3nI4nuDYe3nDJES5WBc90igEstxWC4/h4YY+/ciYki35U8ets9 | ||
3 | mgaoCNYp/e9BCZHtvK2Y+fYokGJv5+cMTQsCAwEAAQJBAIHpvXvqEcOEoDRRHuIG | ||
4 | fkcB4jPHcr9KE9TpxabH6xs9beN6OJnkePXAHwaz5MnUgSnbpOKq+cw8miKjXwe/ | ||
5 | zVECIQDVLwncT2lRmXarEYHzb+q/0uaSvKhWKKt3kJasLNTrAwIhANDUc/ghut29 | ||
6 | p3jJYjurzUKuG774/5eLjPLsxPPIZzNZAiA/10hSq41UnGqHLEUIS9m2/EeEZe7b | ||
7 | bm567dfRU9OnVQIgDo8ROrZXSchEGbaog5J5r/Fle83uO8l93R3GqVxKXZkCIFfk | ||
8 | IPD5PIYQAyyod3hyKKza7ZP4CGY4oOfZetbkSGGG | ||
9 | -----END RSA PRIVATE KEY----- | ||
diff --git a/src/lib/libcrypto/pkcs7/p7/a1 b/src/lib/libcrypto/pkcs7/p7/a1 new file mode 100644 index 0000000000..56ca943762 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/p7/a1 | |||
@@ -0,0 +1,2 @@ | |||
1 | j,H>_æá_DôzEîLœ VJ³ß觬¤””E3ûáYäx%_Àk | ||
2 | 3ê)DLScñ8%ôM \ No newline at end of file | ||
diff --git a/src/lib/libcrypto/pkcs7/p7/a2 b/src/lib/libcrypto/pkcs7/p7/a2 new file mode 100644 index 0000000000..23d8fb5e93 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/p7/a2 | |||
@@ -0,0 +1 @@ | |||
k~@a”,NâM͹¼ <O( KP—é¨ ¤K²>×U¿o_½BqrmÎ?Ù t?t÷ÏéId2‰Š \ No newline at end of file | |||
diff --git a/src/lib/libcrypto/pkcs7/p7/cert.p7c b/src/lib/libcrypto/pkcs7/p7/cert.p7c new file mode 100644 index 0000000000..2b75ec05f7 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/p7/cert.p7c | |||
Binary files differ | |||
diff --git a/src/lib/libcrypto/pkcs7/p7/smime.p7m b/src/lib/libcrypto/pkcs7/p7/smime.p7m new file mode 100644 index 0000000000..2b6e6f82ba --- /dev/null +++ b/src/lib/libcrypto/pkcs7/p7/smime.p7m | |||
Binary files differ | |||
diff --git a/src/lib/libcrypto/pkcs7/p7/smime.p7s b/src/lib/libcrypto/pkcs7/p7/smime.p7s new file mode 100644 index 0000000000..2b5d4fb0e3 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/p7/smime.p7s | |||
Binary files differ | |||
diff --git a/src/lib/libcrypto/pkcs7/pk7_asn1.c b/src/lib/libcrypto/pkcs7/pk7_asn1.c new file mode 100644 index 0000000000..46f0fc9375 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/pk7_asn1.c | |||
@@ -0,0 +1,213 @@ | |||
1 | /* pk7_asn.c */ | ||
2 | /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL | ||
3 | * project 2000. | ||
4 | */ | ||
5 | /* ==================================================================== | ||
6 | * Copyright (c) 2000 The OpenSSL Project. All rights reserved. | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * | ||
12 | * 1. Redistributions of source code must retain the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer. | ||
14 | * | ||
15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
16 | * notice, this list of conditions and the following disclaimer in | ||
17 | * the documentation and/or other materials provided with the | ||
18 | * distribution. | ||
19 | * | ||
20 | * 3. All advertising materials mentioning features or use of this | ||
21 | * software must display the following acknowledgment: | ||
22 | * "This product includes software developed by the OpenSSL Project | ||
23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
24 | * | ||
25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
26 | * endorse or promote products derived from this software without | ||
27 | * prior written permission. For written permission, please contact | ||
28 | * licensing@OpenSSL.org. | ||
29 | * | ||
30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
31 | * nor may "OpenSSL" appear in their names without prior written | ||
32 | * permission of the OpenSSL Project. | ||
33 | * | ||
34 | * 6. Redistributions of any form whatsoever must retain the following | ||
35 | * acknowledgment: | ||
36 | * "This product includes software developed by the OpenSSL Project | ||
37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
38 | * | ||
39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
51 | * ==================================================================== | ||
52 | * | ||
53 | * This product includes cryptographic software written by Eric Young | ||
54 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
55 | * Hudson (tjh@cryptsoft.com). | ||
56 | * | ||
57 | */ | ||
58 | |||
59 | #include <stdio.h> | ||
60 | #include "cryptlib.h" | ||
61 | #include <openssl/asn1t.h> | ||
62 | #include <openssl/pkcs7.h> | ||
63 | #include <openssl/x509.h> | ||
64 | |||
65 | /* PKCS#7 ASN1 module */ | ||
66 | |||
67 | /* This is the ANY DEFINED BY table for the top level PKCS#7 structure */ | ||
68 | |||
69 | ASN1_ADB_TEMPLATE(p7default) = ASN1_EXP_OPT(PKCS7, d.other, ASN1_ANY, 0); | ||
70 | |||
71 | ASN1_ADB(PKCS7) = { | ||
72 | ADB_ENTRY(NID_pkcs7_data, ASN1_EXP_OPT(PKCS7, d.data, ASN1_OCTET_STRING, 0)), | ||
73 | ADB_ENTRY(NID_pkcs7_signed, ASN1_EXP_OPT(PKCS7, d.sign, PKCS7_SIGNED, 0)), | ||
74 | ADB_ENTRY(NID_pkcs7_enveloped, ASN1_EXP_OPT(PKCS7, d.enveloped, PKCS7_ENVELOPE, 0)), | ||
75 | ADB_ENTRY(NID_pkcs7_signedAndEnveloped, ASN1_EXP_OPT(PKCS7, d.signed_and_enveloped, PKCS7_SIGN_ENVELOPE, 0)), | ||
76 | ADB_ENTRY(NID_pkcs7_digest, ASN1_EXP_OPT(PKCS7, d.digest, PKCS7_DIGEST, 0)), | ||
77 | ADB_ENTRY(NID_pkcs7_encrypted, ASN1_EXP_OPT(PKCS7, d.encrypted, PKCS7_ENCRYPT, 0)) | ||
78 | } ASN1_ADB_END(PKCS7, 0, type, 0, &p7default_tt, NULL); | ||
79 | |||
80 | ASN1_SEQUENCE(PKCS7) = { | ||
81 | ASN1_SIMPLE(PKCS7, type, ASN1_OBJECT), | ||
82 | ASN1_ADB_OBJECT(PKCS7) | ||
83 | }ASN1_SEQUENCE_END(PKCS7) | ||
84 | |||
85 | IMPLEMENT_ASN1_FUNCTIONS(PKCS7) | ||
86 | IMPLEMENT_ASN1_DUP_FUNCTION(PKCS7) | ||
87 | |||
88 | ASN1_SEQUENCE(PKCS7_SIGNED) = { | ||
89 | ASN1_SIMPLE(PKCS7_SIGNED, version, ASN1_INTEGER), | ||
90 | ASN1_SET_OF(PKCS7_SIGNED, md_algs, X509_ALGOR), | ||
91 | ASN1_SIMPLE(PKCS7_SIGNED, contents, PKCS7), | ||
92 | ASN1_IMP_SEQUENCE_OF_OPT(PKCS7_SIGNED, cert, X509, 0), | ||
93 | ASN1_IMP_SET_OF_OPT(PKCS7_SIGNED, crl, X509_CRL, 1), | ||
94 | ASN1_SET_OF(PKCS7_SIGNED, signer_info, PKCS7_SIGNER_INFO) | ||
95 | } ASN1_SEQUENCE_END(PKCS7_SIGNED) | ||
96 | |||
97 | IMPLEMENT_ASN1_FUNCTIONS(PKCS7_SIGNED) | ||
98 | |||
99 | /* Minor tweak to operation: free up EVP_PKEY */ | ||
100 | static int si_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
101 | { | ||
102 | if(operation == ASN1_OP_FREE_POST) { | ||
103 | PKCS7_SIGNER_INFO *si = (PKCS7_SIGNER_INFO *)*pval; | ||
104 | EVP_PKEY_free(si->pkey); | ||
105 | } | ||
106 | return 1; | ||
107 | } | ||
108 | |||
109 | ASN1_SEQUENCE_cb(PKCS7_SIGNER_INFO, si_cb) = { | ||
110 | ASN1_SIMPLE(PKCS7_SIGNER_INFO, version, ASN1_INTEGER), | ||
111 | ASN1_SIMPLE(PKCS7_SIGNER_INFO, issuer_and_serial, PKCS7_ISSUER_AND_SERIAL), | ||
112 | ASN1_SIMPLE(PKCS7_SIGNER_INFO, digest_alg, X509_ALGOR), | ||
113 | /* NB this should be a SET OF but we use a SEQUENCE OF so the | ||
114 | * original order * is retained when the structure is reencoded. | ||
115 | * Since the attributes are implicitly tagged this will not affect | ||
116 | * the encoding. | ||
117 | */ | ||
118 | ASN1_IMP_SEQUENCE_OF_OPT(PKCS7_SIGNER_INFO, auth_attr, X509_ATTRIBUTE, 0), | ||
119 | ASN1_SIMPLE(PKCS7_SIGNER_INFO, digest_enc_alg, X509_ALGOR), | ||
120 | ASN1_SIMPLE(PKCS7_SIGNER_INFO, enc_digest, ASN1_OCTET_STRING), | ||
121 | ASN1_IMP_SET_OF_OPT(PKCS7_SIGNER_INFO, unauth_attr, X509_ATTRIBUTE, 1) | ||
122 | } ASN1_SEQUENCE_END_cb(PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO) | ||
123 | |||
124 | IMPLEMENT_ASN1_FUNCTIONS(PKCS7_SIGNER_INFO) | ||
125 | |||
126 | ASN1_SEQUENCE(PKCS7_ISSUER_AND_SERIAL) = { | ||
127 | ASN1_SIMPLE(PKCS7_ISSUER_AND_SERIAL, issuer, X509_NAME), | ||
128 | ASN1_SIMPLE(PKCS7_ISSUER_AND_SERIAL, serial, ASN1_INTEGER) | ||
129 | } ASN1_SEQUENCE_END(PKCS7_ISSUER_AND_SERIAL) | ||
130 | |||
131 | IMPLEMENT_ASN1_FUNCTIONS(PKCS7_ISSUER_AND_SERIAL) | ||
132 | |||
133 | ASN1_SEQUENCE(PKCS7_ENVELOPE) = { | ||
134 | ASN1_SIMPLE(PKCS7_ENVELOPE, version, ASN1_INTEGER), | ||
135 | ASN1_SET_OF(PKCS7_ENVELOPE, recipientinfo, PKCS7_RECIP_INFO), | ||
136 | ASN1_SIMPLE(PKCS7_ENVELOPE, enc_data, PKCS7_ENC_CONTENT) | ||
137 | } ASN1_SEQUENCE_END(PKCS7_ENVELOPE) | ||
138 | |||
139 | IMPLEMENT_ASN1_FUNCTIONS(PKCS7_ENVELOPE) | ||
140 | |||
141 | /* Minor tweak to operation: free up X509 */ | ||
142 | static int ri_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
143 | { | ||
144 | if(operation == ASN1_OP_FREE_POST) { | ||
145 | PKCS7_RECIP_INFO *ri = (PKCS7_RECIP_INFO *)*pval; | ||
146 | X509_free(ri->cert); | ||
147 | } | ||
148 | return 1; | ||
149 | } | ||
150 | |||
151 | ASN1_SEQUENCE_cb(PKCS7_RECIP_INFO, ri_cb) = { | ||
152 | ASN1_SIMPLE(PKCS7_RECIP_INFO, version, ASN1_INTEGER), | ||
153 | ASN1_SIMPLE(PKCS7_RECIP_INFO, issuer_and_serial, PKCS7_ISSUER_AND_SERIAL), | ||
154 | ASN1_SIMPLE(PKCS7_RECIP_INFO, key_enc_algor, X509_ALGOR), | ||
155 | ASN1_SIMPLE(PKCS7_RECIP_INFO, enc_key, ASN1_OCTET_STRING) | ||
156 | } ASN1_SEQUENCE_END_cb(PKCS7_RECIP_INFO, PKCS7_RECIP_INFO) | ||
157 | |||
158 | IMPLEMENT_ASN1_FUNCTIONS(PKCS7_RECIP_INFO) | ||
159 | |||
160 | ASN1_SEQUENCE(PKCS7_ENC_CONTENT) = { | ||
161 | ASN1_SIMPLE(PKCS7_ENC_CONTENT, content_type, ASN1_OBJECT), | ||
162 | ASN1_SIMPLE(PKCS7_ENC_CONTENT, algorithm, X509_ALGOR), | ||
163 | ASN1_IMP_OPT(PKCS7_ENC_CONTENT, enc_data, ASN1_OCTET_STRING, 0) | ||
164 | } ASN1_SEQUENCE_END(PKCS7_ENC_CONTENT) | ||
165 | |||
166 | IMPLEMENT_ASN1_FUNCTIONS(PKCS7_ENC_CONTENT) | ||
167 | |||
168 | ASN1_SEQUENCE(PKCS7_SIGN_ENVELOPE) = { | ||
169 | ASN1_SIMPLE(PKCS7_SIGN_ENVELOPE, version, ASN1_INTEGER), | ||
170 | ASN1_SET_OF(PKCS7_SIGN_ENVELOPE, recipientinfo, PKCS7_RECIP_INFO), | ||
171 | ASN1_SET_OF(PKCS7_SIGN_ENVELOPE, md_algs, X509_ALGOR), | ||
172 | ASN1_SIMPLE(PKCS7_SIGN_ENVELOPE, enc_data, PKCS7_ENC_CONTENT), | ||
173 | ASN1_IMP_SET_OF_OPT(PKCS7_SIGN_ENVELOPE, cert, X509, 0), | ||
174 | ASN1_IMP_SET_OF_OPT(PKCS7_SIGN_ENVELOPE, crl, X509_CRL, 1), | ||
175 | ASN1_SET_OF(PKCS7_SIGN_ENVELOPE, signer_info, PKCS7_SIGNER_INFO) | ||
176 | } ASN1_SEQUENCE_END(PKCS7_SIGN_ENVELOPE) | ||
177 | |||
178 | IMPLEMENT_ASN1_FUNCTIONS(PKCS7_SIGN_ENVELOPE) | ||
179 | |||
180 | ASN1_SEQUENCE(PKCS7_ENCRYPT) = { | ||
181 | ASN1_SIMPLE(PKCS7_ENCRYPT, version, ASN1_INTEGER), | ||
182 | ASN1_SIMPLE(PKCS7_ENCRYPT, enc_data, PKCS7_ENC_CONTENT) | ||
183 | } ASN1_SEQUENCE_END(PKCS7_ENCRYPT) | ||
184 | |||
185 | IMPLEMENT_ASN1_FUNCTIONS(PKCS7_ENCRYPT) | ||
186 | |||
187 | ASN1_SEQUENCE(PKCS7_DIGEST) = { | ||
188 | ASN1_SIMPLE(PKCS7_DIGEST, version, ASN1_INTEGER), | ||
189 | ASN1_SIMPLE(PKCS7_DIGEST, md, X509_ALGOR), | ||
190 | ASN1_SIMPLE(PKCS7_DIGEST, contents, PKCS7), | ||
191 | ASN1_SIMPLE(PKCS7_DIGEST, digest, ASN1_OCTET_STRING) | ||
192 | } ASN1_SEQUENCE_END(PKCS7_DIGEST) | ||
193 | |||
194 | IMPLEMENT_ASN1_FUNCTIONS(PKCS7_DIGEST) | ||
195 | |||
196 | /* Specials for authenticated attributes */ | ||
197 | |||
198 | /* When signing attributes we want to reorder them to match the sorted | ||
199 | * encoding. | ||
200 | */ | ||
201 | |||
202 | ASN1_ITEM_TEMPLATE(PKCS7_ATTR_SIGN) = | ||
203 | ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SET_ORDER, 0, PKCS7_ATTRIBUTES, X509_ATTRIBUTE) | ||
204 | ASN1_ITEM_TEMPLATE_END(PKCS7_ATTR_SIGN) | ||
205 | |||
206 | /* When verifying attributes we need to use the received order. So | ||
207 | * we use SEQUENCE OF and tag it to SET OF | ||
208 | */ | ||
209 | |||
210 | ASN1_ITEM_TEMPLATE(PKCS7_ATTR_VERIFY) = | ||
211 | ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_IMPTAG | ASN1_TFLG_UNIVERSAL, | ||
212 | V_ASN1_SET, PKCS7_ATTRIBUTES, X509_ATTRIBUTE) | ||
213 | ASN1_ITEM_TEMPLATE_END(PKCS7_ATTR_VERIFY) | ||
diff --git a/src/lib/libcrypto/pkcs7/pk7_attr.c b/src/lib/libcrypto/pkcs7/pk7_attr.c new file mode 100644 index 0000000000..5ff5a88b5c --- /dev/null +++ b/src/lib/libcrypto/pkcs7/pk7_attr.c | |||
@@ -0,0 +1,139 @@ | |||
1 | /* pk7_attr.c */ | ||
2 | /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL | ||
3 | * project 2001. | ||
4 | */ | ||
5 | /* ==================================================================== | ||
6 | * Copyright (c) 2001 The OpenSSL Project. All rights reserved. | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * | ||
12 | * 1. Redistributions of source code must retain the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer. | ||
14 | * | ||
15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
16 | * notice, this list of conditions and the following disclaimer in | ||
17 | * the documentation and/or other materials provided with the | ||
18 | * distribution. | ||
19 | * | ||
20 | * 3. All advertising materials mentioning features or use of this | ||
21 | * software must display the following acknowledgment: | ||
22 | * "This product includes software developed by the OpenSSL Project | ||
23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
24 | * | ||
25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
26 | * endorse or promote products derived from this software without | ||
27 | * prior written permission. For written permission, please contact | ||
28 | * licensing@OpenSSL.org. | ||
29 | * | ||
30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
31 | * nor may "OpenSSL" appear in their names without prior written | ||
32 | * permission of the OpenSSL Project. | ||
33 | * | ||
34 | * 6. Redistributions of any form whatsoever must retain the following | ||
35 | * acknowledgment: | ||
36 | * "This product includes software developed by the OpenSSL Project | ||
37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
38 | * | ||
39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
51 | * ==================================================================== | ||
52 | * | ||
53 | * This product includes cryptographic software written by Eric Young | ||
54 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
55 | * Hudson (tjh@cryptsoft.com). | ||
56 | * | ||
57 | */ | ||
58 | |||
59 | #include <stdio.h> | ||
60 | #include <stdlib.h> | ||
61 | #include <openssl/bio.h> | ||
62 | #include <openssl/asn1.h> | ||
63 | #include <openssl/pem.h> | ||
64 | #include <openssl/pkcs7.h> | ||
65 | #include <openssl/x509.h> | ||
66 | #include <openssl/err.h> | ||
67 | |||
68 | int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si, STACK_OF(X509_ALGOR) *cap) | ||
69 | { | ||
70 | ASN1_STRING *seq; | ||
71 | unsigned char *p, *pp; | ||
72 | int len; | ||
73 | len=i2d_ASN1_SET_OF_X509_ALGOR(cap,NULL,i2d_X509_ALGOR, | ||
74 | V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL, | ||
75 | IS_SEQUENCE); | ||
76 | if(!(pp=(unsigned char *)OPENSSL_malloc(len))) { | ||
77 | PKCS7err(PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP,ERR_R_MALLOC_FAILURE); | ||
78 | return 0; | ||
79 | } | ||
80 | p=pp; | ||
81 | i2d_ASN1_SET_OF_X509_ALGOR(cap,&p,i2d_X509_ALGOR, V_ASN1_SEQUENCE, | ||
82 | V_ASN1_UNIVERSAL, IS_SEQUENCE); | ||
83 | if(!(seq = ASN1_STRING_new())) { | ||
84 | PKCS7err(PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP,ERR_R_MALLOC_FAILURE); | ||
85 | return 0; | ||
86 | } | ||
87 | if(!ASN1_STRING_set (seq, pp, len)) { | ||
88 | PKCS7err(PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP,ERR_R_MALLOC_FAILURE); | ||
89 | return 0; | ||
90 | } | ||
91 | OPENSSL_free (pp); | ||
92 | return PKCS7_add_signed_attribute(si, NID_SMIMECapabilities, | ||
93 | V_ASN1_SEQUENCE, seq); | ||
94 | } | ||
95 | |||
96 | STACK_OF(X509_ALGOR) *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si) | ||
97 | { | ||
98 | ASN1_TYPE *cap; | ||
99 | unsigned char *p; | ||
100 | cap = PKCS7_get_signed_attribute(si, NID_SMIMECapabilities); | ||
101 | if (!cap) return NULL; | ||
102 | p = cap->value.sequence->data; | ||
103 | return d2i_ASN1_SET_OF_X509_ALGOR(NULL, &p, | ||
104 | cap->value.sequence->length, | ||
105 | d2i_X509_ALGOR, X509_ALGOR_free, | ||
106 | V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL); | ||
107 | } | ||
108 | |||
109 | /* Basic smime-capabilities OID and optional integer arg */ | ||
110 | int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) *sk, int nid, int arg) | ||
111 | { | ||
112 | X509_ALGOR *alg; | ||
113 | |||
114 | if(!(alg = X509_ALGOR_new())) { | ||
115 | PKCS7err(PKCS7_F_PKCS7_SIMPLE_SMIMECAP,ERR_R_MALLOC_FAILURE); | ||
116 | return 0; | ||
117 | } | ||
118 | ASN1_OBJECT_free(alg->algorithm); | ||
119 | alg->algorithm = OBJ_nid2obj (nid); | ||
120 | if (arg > 0) { | ||
121 | ASN1_INTEGER *nbit; | ||
122 | if(!(alg->parameter = ASN1_TYPE_new())) { | ||
123 | PKCS7err(PKCS7_F_PKCS7_SIMPLE_SMIMECAP,ERR_R_MALLOC_FAILURE); | ||
124 | return 0; | ||
125 | } | ||
126 | if(!(nbit = ASN1_INTEGER_new())) { | ||
127 | PKCS7err(PKCS7_F_PKCS7_SIMPLE_SMIMECAP,ERR_R_MALLOC_FAILURE); | ||
128 | return 0; | ||
129 | } | ||
130 | if(!ASN1_INTEGER_set (nbit, arg)) { | ||
131 | PKCS7err(PKCS7_F_PKCS7_SIMPLE_SMIMECAP,ERR_R_MALLOC_FAILURE); | ||
132 | return 0; | ||
133 | } | ||
134 | alg->parameter->value.integer = nbit; | ||
135 | alg->parameter->type = V_ASN1_INTEGER; | ||
136 | } | ||
137 | sk_X509_ALGOR_push (sk, alg); | ||
138 | return 1; | ||
139 | } | ||
diff --git a/src/lib/libcrypto/pkcs7/pk7_dgst.c b/src/lib/libcrypto/pkcs7/pk7_dgst.c new file mode 100644 index 0000000000..90edfa5001 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/pk7_dgst.c | |||
@@ -0,0 +1,66 @@ | |||
1 | /* crypto/pkcs7/pk7_dgst.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/evp.h> | ||
62 | #include <openssl/rand.h> | ||
63 | #include <openssl/objects.h> | ||
64 | #include <openssl/x509.h> | ||
65 | #include <openssl/pkcs7.h> | ||
66 | |||
diff --git a/src/lib/libcrypto/pkcs7/pk7_doit.c b/src/lib/libcrypto/pkcs7/pk7_doit.c new file mode 100644 index 0000000000..b78e22819c --- /dev/null +++ b/src/lib/libcrypto/pkcs7/pk7_doit.c | |||
@@ -0,0 +1,983 @@ | |||
1 | /* crypto/pkcs7/pk7_doit.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/rand.h> | ||
62 | #include <openssl/objects.h> | ||
63 | #include <openssl/x509.h> | ||
64 | #include <openssl/x509v3.h> | ||
65 | |||
66 | static int add_attribute(STACK_OF(X509_ATTRIBUTE) **sk, int nid, int atrtype, | ||
67 | void *value); | ||
68 | static ASN1_TYPE *get_attribute(STACK_OF(X509_ATTRIBUTE) *sk, int nid); | ||
69 | |||
70 | static int PKCS7_type_is_other(PKCS7* p7) | ||
71 | { | ||
72 | int isOther=1; | ||
73 | |||
74 | int nid=OBJ_obj2nid(p7->type); | ||
75 | |||
76 | switch( nid ) | ||
77 | { | ||
78 | case NID_pkcs7_data: | ||
79 | case NID_pkcs7_signed: | ||
80 | case NID_pkcs7_enveloped: | ||
81 | case NID_pkcs7_signedAndEnveloped: | ||
82 | case NID_pkcs7_digest: | ||
83 | case NID_pkcs7_encrypted: | ||
84 | isOther=0; | ||
85 | break; | ||
86 | default: | ||
87 | isOther=1; | ||
88 | } | ||
89 | |||
90 | return isOther; | ||
91 | |||
92 | } | ||
93 | |||
94 | static ASN1_OCTET_STRING *PKCS7_get_octet_string(PKCS7 *p7) | ||
95 | { | ||
96 | if ( PKCS7_type_is_data(p7)) | ||
97 | return p7->d.data; | ||
98 | if ( PKCS7_type_is_other(p7) && p7->d.other | ||
99 | && (p7->d.other->type == V_ASN1_OCTET_STRING)) | ||
100 | return p7->d.other->value.octet_string; | ||
101 | return NULL; | ||
102 | } | ||
103 | |||
104 | BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio) | ||
105 | { | ||
106 | int i; | ||
107 | BIO *out=NULL,*btmp=NULL; | ||
108 | X509_ALGOR *xa; | ||
109 | const EVP_MD *evp_md; | ||
110 | const EVP_CIPHER *evp_cipher=NULL; | ||
111 | STACK_OF(X509_ALGOR) *md_sk=NULL; | ||
112 | STACK_OF(PKCS7_RECIP_INFO) *rsk=NULL; | ||
113 | X509_ALGOR *xalg=NULL; | ||
114 | PKCS7_RECIP_INFO *ri=NULL; | ||
115 | EVP_PKEY *pkey; | ||
116 | |||
117 | i=OBJ_obj2nid(p7->type); | ||
118 | p7->state=PKCS7_S_HEADER; | ||
119 | |||
120 | switch (i) | ||
121 | { | ||
122 | case NID_pkcs7_signed: | ||
123 | md_sk=p7->d.sign->md_algs; | ||
124 | break; | ||
125 | case NID_pkcs7_signedAndEnveloped: | ||
126 | rsk=p7->d.signed_and_enveloped->recipientinfo; | ||
127 | md_sk=p7->d.signed_and_enveloped->md_algs; | ||
128 | xalg=p7->d.signed_and_enveloped->enc_data->algorithm; | ||
129 | evp_cipher=p7->d.signed_and_enveloped->enc_data->cipher; | ||
130 | if (evp_cipher == NULL) | ||
131 | { | ||
132 | PKCS7err(PKCS7_F_PKCS7_DATAINIT, | ||
133 | PKCS7_R_CIPHER_NOT_INITIALIZED); | ||
134 | goto err; | ||
135 | } | ||
136 | break; | ||
137 | case NID_pkcs7_enveloped: | ||
138 | rsk=p7->d.enveloped->recipientinfo; | ||
139 | xalg=p7->d.enveloped->enc_data->algorithm; | ||
140 | evp_cipher=p7->d.enveloped->enc_data->cipher; | ||
141 | if (evp_cipher == NULL) | ||
142 | { | ||
143 | PKCS7err(PKCS7_F_PKCS7_DATAINIT, | ||
144 | PKCS7_R_CIPHER_NOT_INITIALIZED); | ||
145 | goto err; | ||
146 | } | ||
147 | break; | ||
148 | default: | ||
149 | PKCS7err(PKCS7_F_PKCS7_DATAINIT,PKCS7_R_UNSUPPORTED_CONTENT_TYPE); | ||
150 | goto err; | ||
151 | } | ||
152 | |||
153 | if (md_sk != NULL) | ||
154 | { | ||
155 | for (i=0; i<sk_X509_ALGOR_num(md_sk); i++) | ||
156 | { | ||
157 | xa=sk_X509_ALGOR_value(md_sk,i); | ||
158 | if ((btmp=BIO_new(BIO_f_md())) == NULL) | ||
159 | { | ||
160 | PKCS7err(PKCS7_F_PKCS7_DATAINIT,ERR_R_BIO_LIB); | ||
161 | goto err; | ||
162 | } | ||
163 | |||
164 | evp_md=EVP_get_digestbyobj(xa->algorithm); | ||
165 | if (evp_md == NULL) | ||
166 | { | ||
167 | PKCS7err(PKCS7_F_PKCS7_DATAINIT,PKCS7_R_UNKNOWN_DIGEST_TYPE); | ||
168 | goto err; | ||
169 | } | ||
170 | |||
171 | BIO_set_md(btmp,evp_md); | ||
172 | if (out == NULL) | ||
173 | out=btmp; | ||
174 | else | ||
175 | BIO_push(out,btmp); | ||
176 | btmp=NULL; | ||
177 | } | ||
178 | } | ||
179 | |||
180 | if (evp_cipher != NULL) | ||
181 | { | ||
182 | unsigned char key[EVP_MAX_KEY_LENGTH]; | ||
183 | unsigned char iv[EVP_MAX_IV_LENGTH]; | ||
184 | int keylen,ivlen; | ||
185 | int jj,max; | ||
186 | unsigned char *tmp; | ||
187 | EVP_CIPHER_CTX *ctx; | ||
188 | |||
189 | if ((btmp=BIO_new(BIO_f_cipher())) == NULL) | ||
190 | { | ||
191 | PKCS7err(PKCS7_F_PKCS7_DATAINIT,ERR_R_BIO_LIB); | ||
192 | goto err; | ||
193 | } | ||
194 | BIO_get_cipher_ctx(btmp, &ctx); | ||
195 | keylen=EVP_CIPHER_key_length(evp_cipher); | ||
196 | ivlen=EVP_CIPHER_iv_length(evp_cipher); | ||
197 | if (RAND_bytes(key,keylen) <= 0) | ||
198 | goto err; | ||
199 | xalg->algorithm = OBJ_nid2obj(EVP_CIPHER_type(evp_cipher)); | ||
200 | if (ivlen > 0) RAND_pseudo_bytes(iv,ivlen); | ||
201 | EVP_CipherInit_ex(ctx, evp_cipher, NULL, key, iv, 1); | ||
202 | |||
203 | if (ivlen > 0) { | ||
204 | if (xalg->parameter == NULL) | ||
205 | xalg->parameter=ASN1_TYPE_new(); | ||
206 | if(EVP_CIPHER_param_to_asn1(ctx, xalg->parameter) < 0) | ||
207 | goto err; | ||
208 | } | ||
209 | |||
210 | /* Lets do the pub key stuff :-) */ | ||
211 | max=0; | ||
212 | for (i=0; i<sk_PKCS7_RECIP_INFO_num(rsk); i++) | ||
213 | { | ||
214 | ri=sk_PKCS7_RECIP_INFO_value(rsk,i); | ||
215 | if (ri->cert == NULL) | ||
216 | { | ||
217 | PKCS7err(PKCS7_F_PKCS7_DATAINIT,PKCS7_R_MISSING_CERIPEND_INFO); | ||
218 | goto err; | ||
219 | } | ||
220 | pkey=X509_get_pubkey(ri->cert); | ||
221 | jj=EVP_PKEY_size(pkey); | ||
222 | EVP_PKEY_free(pkey); | ||
223 | if (max < jj) max=jj; | ||
224 | } | ||
225 | if ((tmp=(unsigned char *)OPENSSL_malloc(max)) == NULL) | ||
226 | { | ||
227 | PKCS7err(PKCS7_F_PKCS7_DATAINIT,ERR_R_MALLOC_FAILURE); | ||
228 | goto err; | ||
229 | } | ||
230 | for (i=0; i<sk_PKCS7_RECIP_INFO_num(rsk); i++) | ||
231 | { | ||
232 | ri=sk_PKCS7_RECIP_INFO_value(rsk,i); | ||
233 | pkey=X509_get_pubkey(ri->cert); | ||
234 | jj=EVP_PKEY_encrypt(tmp,key,keylen,pkey); | ||
235 | EVP_PKEY_free(pkey); | ||
236 | if (jj <= 0) | ||
237 | { | ||
238 | PKCS7err(PKCS7_F_PKCS7_DATAINIT,ERR_R_EVP_LIB); | ||
239 | OPENSSL_free(tmp); | ||
240 | goto err; | ||
241 | } | ||
242 | M_ASN1_OCTET_STRING_set(ri->enc_key,tmp,jj); | ||
243 | } | ||
244 | OPENSSL_free(tmp); | ||
245 | OPENSSL_cleanse(key, keylen); | ||
246 | |||
247 | if (out == NULL) | ||
248 | out=btmp; | ||
249 | else | ||
250 | BIO_push(out,btmp); | ||
251 | btmp=NULL; | ||
252 | } | ||
253 | |||
254 | if (bio == NULL) | ||
255 | { | ||
256 | if (PKCS7_is_detached(p7)) | ||
257 | bio=BIO_new(BIO_s_null()); | ||
258 | else | ||
259 | { | ||
260 | if (PKCS7_type_is_signed(p7)) | ||
261 | { | ||
262 | ASN1_OCTET_STRING *os; | ||
263 | os = PKCS7_get_octet_string( | ||
264 | p7->d.sign->contents); | ||
265 | if (os && os->length > 0) | ||
266 | bio = BIO_new_mem_buf(os->data, | ||
267 | os->length); | ||
268 | } | ||
269 | if(bio == NULL) | ||
270 | { | ||
271 | bio=BIO_new(BIO_s_mem()); | ||
272 | BIO_set_mem_eof_return(bio,0); | ||
273 | } | ||
274 | } | ||
275 | } | ||
276 | BIO_push(out,bio); | ||
277 | bio=NULL; | ||
278 | if (0) | ||
279 | { | ||
280 | err: | ||
281 | if (out != NULL) | ||
282 | BIO_free_all(out); | ||
283 | if (btmp != NULL) | ||
284 | BIO_free_all(btmp); | ||
285 | out=NULL; | ||
286 | } | ||
287 | return(out); | ||
288 | } | ||
289 | |||
290 | /* int */ | ||
291 | BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert) | ||
292 | { | ||
293 | int i,j; | ||
294 | BIO *out=NULL,*btmp=NULL,*etmp=NULL,*bio=NULL; | ||
295 | unsigned char *tmp=NULL; | ||
296 | X509_ALGOR *xa; | ||
297 | ASN1_OCTET_STRING *data_body=NULL; | ||
298 | const EVP_MD *evp_md; | ||
299 | const EVP_CIPHER *evp_cipher=NULL; | ||
300 | EVP_CIPHER_CTX *evp_ctx=NULL; | ||
301 | X509_ALGOR *enc_alg=NULL; | ||
302 | STACK_OF(X509_ALGOR) *md_sk=NULL; | ||
303 | STACK_OF(PKCS7_RECIP_INFO) *rsk=NULL; | ||
304 | X509_ALGOR *xalg=NULL; | ||
305 | PKCS7_RECIP_INFO *ri=NULL; | ||
306 | |||
307 | i=OBJ_obj2nid(p7->type); | ||
308 | p7->state=PKCS7_S_HEADER; | ||
309 | |||
310 | switch (i) | ||
311 | { | ||
312 | case NID_pkcs7_signed: | ||
313 | data_body=PKCS7_get_octet_string(p7->d.sign->contents); | ||
314 | md_sk=p7->d.sign->md_algs; | ||
315 | break; | ||
316 | case NID_pkcs7_signedAndEnveloped: | ||
317 | rsk=p7->d.signed_and_enveloped->recipientinfo; | ||
318 | md_sk=p7->d.signed_and_enveloped->md_algs; | ||
319 | data_body=p7->d.signed_and_enveloped->enc_data->enc_data; | ||
320 | enc_alg=p7->d.signed_and_enveloped->enc_data->algorithm; | ||
321 | evp_cipher=EVP_get_cipherbyobj(enc_alg->algorithm); | ||
322 | if (evp_cipher == NULL) | ||
323 | { | ||
324 | PKCS7err(PKCS7_F_PKCS7_DATADECODE,PKCS7_R_UNSUPPORTED_CIPHER_TYPE); | ||
325 | goto err; | ||
326 | } | ||
327 | xalg=p7->d.signed_and_enveloped->enc_data->algorithm; | ||
328 | break; | ||
329 | case NID_pkcs7_enveloped: | ||
330 | rsk=p7->d.enveloped->recipientinfo; | ||
331 | enc_alg=p7->d.enveloped->enc_data->algorithm; | ||
332 | data_body=p7->d.enveloped->enc_data->enc_data; | ||
333 | evp_cipher=EVP_get_cipherbyobj(enc_alg->algorithm); | ||
334 | if (evp_cipher == NULL) | ||
335 | { | ||
336 | PKCS7err(PKCS7_F_PKCS7_DATADECODE,PKCS7_R_UNSUPPORTED_CIPHER_TYPE); | ||
337 | goto err; | ||
338 | } | ||
339 | xalg=p7->d.enveloped->enc_data->algorithm; | ||
340 | break; | ||
341 | default: | ||
342 | PKCS7err(PKCS7_F_PKCS7_DATADECODE,PKCS7_R_UNSUPPORTED_CONTENT_TYPE); | ||
343 | goto err; | ||
344 | } | ||
345 | |||
346 | /* We will be checking the signature */ | ||
347 | if (md_sk != NULL) | ||
348 | { | ||
349 | for (i=0; i<sk_X509_ALGOR_num(md_sk); i++) | ||
350 | { | ||
351 | xa=sk_X509_ALGOR_value(md_sk,i); | ||
352 | if ((btmp=BIO_new(BIO_f_md())) == NULL) | ||
353 | { | ||
354 | PKCS7err(PKCS7_F_PKCS7_DATADECODE,ERR_R_BIO_LIB); | ||
355 | goto err; | ||
356 | } | ||
357 | |||
358 | j=OBJ_obj2nid(xa->algorithm); | ||
359 | evp_md=EVP_get_digestbynid(j); | ||
360 | if (evp_md == NULL) | ||
361 | { | ||
362 | PKCS7err(PKCS7_F_PKCS7_DATADECODE,PKCS7_R_UNKNOWN_DIGEST_TYPE); | ||
363 | goto err; | ||
364 | } | ||
365 | |||
366 | BIO_set_md(btmp,evp_md); | ||
367 | if (out == NULL) | ||
368 | out=btmp; | ||
369 | else | ||
370 | BIO_push(out,btmp); | ||
371 | btmp=NULL; | ||
372 | } | ||
373 | } | ||
374 | |||
375 | if (evp_cipher != NULL) | ||
376 | { | ||
377 | #if 0 | ||
378 | unsigned char key[EVP_MAX_KEY_LENGTH]; | ||
379 | unsigned char iv[EVP_MAX_IV_LENGTH]; | ||
380 | unsigned char *p; | ||
381 | int keylen,ivlen; | ||
382 | int max; | ||
383 | X509_OBJECT ret; | ||
384 | #endif | ||
385 | int jj; | ||
386 | |||
387 | if ((etmp=BIO_new(BIO_f_cipher())) == NULL) | ||
388 | { | ||
389 | PKCS7err(PKCS7_F_PKCS7_DATADECODE,ERR_R_BIO_LIB); | ||
390 | goto err; | ||
391 | } | ||
392 | |||
393 | /* It was encrypted, we need to decrypt the secret key | ||
394 | * with the private key */ | ||
395 | |||
396 | /* Find the recipientInfo which matches the passed certificate | ||
397 | * (if any) | ||
398 | */ | ||
399 | |||
400 | for (i=0; i<sk_PKCS7_RECIP_INFO_num(rsk); i++) { | ||
401 | ri=sk_PKCS7_RECIP_INFO_value(rsk,i); | ||
402 | if(!X509_NAME_cmp(ri->issuer_and_serial->issuer, | ||
403 | pcert->cert_info->issuer) && | ||
404 | !M_ASN1_INTEGER_cmp(pcert->cert_info->serialNumber, | ||
405 | ri->issuer_and_serial->serial)) break; | ||
406 | ri=NULL; | ||
407 | } | ||
408 | if (ri == NULL) { | ||
409 | PKCS7err(PKCS7_F_PKCS7_DATADECODE, | ||
410 | PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE); | ||
411 | goto err; | ||
412 | } | ||
413 | |||
414 | jj=EVP_PKEY_size(pkey); | ||
415 | tmp=(unsigned char *)OPENSSL_malloc(jj+10); | ||
416 | if (tmp == NULL) | ||
417 | { | ||
418 | PKCS7err(PKCS7_F_PKCS7_DATADECODE,ERR_R_MALLOC_FAILURE); | ||
419 | goto err; | ||
420 | } | ||
421 | |||
422 | jj=EVP_PKEY_decrypt(tmp, M_ASN1_STRING_data(ri->enc_key), | ||
423 | M_ASN1_STRING_length(ri->enc_key), pkey); | ||
424 | if (jj <= 0) | ||
425 | { | ||
426 | PKCS7err(PKCS7_F_PKCS7_DATADECODE,ERR_R_EVP_LIB); | ||
427 | goto err; | ||
428 | } | ||
429 | |||
430 | evp_ctx=NULL; | ||
431 | BIO_get_cipher_ctx(etmp,&evp_ctx); | ||
432 | EVP_CipherInit_ex(evp_ctx,evp_cipher,NULL,NULL,NULL,0); | ||
433 | if (EVP_CIPHER_asn1_to_param(evp_ctx,enc_alg->parameter) < 0) | ||
434 | goto err; | ||
435 | |||
436 | if (jj != EVP_CIPHER_CTX_key_length(evp_ctx)) { | ||
437 | /* Some S/MIME clients don't use the same key | ||
438 | * and effective key length. The key length is | ||
439 | * determined by the size of the decrypted RSA key. | ||
440 | */ | ||
441 | if(!EVP_CIPHER_CTX_set_key_length(evp_ctx, jj)) | ||
442 | { | ||
443 | PKCS7err(PKCS7_F_PKCS7_DATADECODE, | ||
444 | PKCS7_R_DECRYPTED_KEY_IS_WRONG_LENGTH); | ||
445 | goto err; | ||
446 | } | ||
447 | } | ||
448 | EVP_CipherInit_ex(evp_ctx,NULL,NULL,tmp,NULL,0); | ||
449 | |||
450 | OPENSSL_cleanse(tmp,jj); | ||
451 | |||
452 | if (out == NULL) | ||
453 | out=etmp; | ||
454 | else | ||
455 | BIO_push(out,etmp); | ||
456 | etmp=NULL; | ||
457 | } | ||
458 | |||
459 | #if 1 | ||
460 | if (PKCS7_is_detached(p7) || (in_bio != NULL)) | ||
461 | { | ||
462 | bio=in_bio; | ||
463 | } | ||
464 | else | ||
465 | { | ||
466 | #if 0 | ||
467 | bio=BIO_new(BIO_s_mem()); | ||
468 | /* We need to set this so that when we have read all | ||
469 | * the data, the encrypt BIO, if present, will read | ||
470 | * EOF and encode the last few bytes */ | ||
471 | BIO_set_mem_eof_return(bio,0); | ||
472 | |||
473 | if (data_body->length > 0) | ||
474 | BIO_write(bio,(char *)data_body->data,data_body->length); | ||
475 | #else | ||
476 | if (data_body->length > 0) | ||
477 | bio = BIO_new_mem_buf(data_body->data,data_body->length); | ||
478 | else { | ||
479 | bio=BIO_new(BIO_s_mem()); | ||
480 | BIO_set_mem_eof_return(bio,0); | ||
481 | } | ||
482 | #endif | ||
483 | } | ||
484 | BIO_push(out,bio); | ||
485 | bio=NULL; | ||
486 | #endif | ||
487 | if (0) | ||
488 | { | ||
489 | err: | ||
490 | if (out != NULL) BIO_free_all(out); | ||
491 | if (btmp != NULL) BIO_free_all(btmp); | ||
492 | if (etmp != NULL) BIO_free_all(etmp); | ||
493 | if (bio != NULL) BIO_free_all(bio); | ||
494 | out=NULL; | ||
495 | } | ||
496 | if (tmp != NULL) | ||
497 | OPENSSL_free(tmp); | ||
498 | return(out); | ||
499 | } | ||
500 | |||
501 | int PKCS7_dataFinal(PKCS7 *p7, BIO *bio) | ||
502 | { | ||
503 | int ret=0; | ||
504 | int i,j; | ||
505 | BIO *btmp; | ||
506 | BUF_MEM *buf_mem=NULL; | ||
507 | BUF_MEM *buf=NULL; | ||
508 | PKCS7_SIGNER_INFO *si; | ||
509 | EVP_MD_CTX *mdc,ctx_tmp; | ||
510 | STACK_OF(X509_ATTRIBUTE) *sk; | ||
511 | STACK_OF(PKCS7_SIGNER_INFO) *si_sk=NULL; | ||
512 | ASN1_OCTET_STRING *os=NULL; | ||
513 | |||
514 | EVP_MD_CTX_init(&ctx_tmp); | ||
515 | i=OBJ_obj2nid(p7->type); | ||
516 | p7->state=PKCS7_S_HEADER; | ||
517 | |||
518 | switch (i) | ||
519 | { | ||
520 | case NID_pkcs7_signedAndEnveloped: | ||
521 | /* XXXXXXXXXXXXXXXX */ | ||
522 | si_sk=p7->d.signed_and_enveloped->signer_info; | ||
523 | os=M_ASN1_OCTET_STRING_new(); | ||
524 | p7->d.signed_and_enveloped->enc_data->enc_data=os; | ||
525 | break; | ||
526 | case NID_pkcs7_enveloped: | ||
527 | /* XXXXXXXXXXXXXXXX */ | ||
528 | os=M_ASN1_OCTET_STRING_new(); | ||
529 | p7->d.enveloped->enc_data->enc_data=os; | ||
530 | break; | ||
531 | case NID_pkcs7_signed: | ||
532 | si_sk=p7->d.sign->signer_info; | ||
533 | os=PKCS7_get_octet_string(p7->d.sign->contents); | ||
534 | /* If detached data then the content is excluded */ | ||
535 | if(PKCS7_type_is_data(p7->d.sign->contents) && p7->detached) { | ||
536 | M_ASN1_OCTET_STRING_free(os); | ||
537 | p7->d.sign->contents->d.data = NULL; | ||
538 | } | ||
539 | break; | ||
540 | } | ||
541 | |||
542 | if (si_sk != NULL) | ||
543 | { | ||
544 | if ((buf=BUF_MEM_new()) == NULL) | ||
545 | { | ||
546 | PKCS7err(PKCS7_F_PKCS7_DATASIGN,ERR_R_BIO_LIB); | ||
547 | goto err; | ||
548 | } | ||
549 | for (i=0; i<sk_PKCS7_SIGNER_INFO_num(si_sk); i++) | ||
550 | { | ||
551 | si=sk_PKCS7_SIGNER_INFO_value(si_sk,i); | ||
552 | if (si->pkey == NULL) continue; | ||
553 | |||
554 | j=OBJ_obj2nid(si->digest_alg->algorithm); | ||
555 | |||
556 | btmp=bio; | ||
557 | for (;;) | ||
558 | { | ||
559 | if ((btmp=BIO_find_type(btmp,BIO_TYPE_MD)) | ||
560 | == NULL) | ||
561 | { | ||
562 | PKCS7err(PKCS7_F_PKCS7_DATASIGN,PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST); | ||
563 | goto err; | ||
564 | } | ||
565 | BIO_get_md_ctx(btmp,&mdc); | ||
566 | if (mdc == NULL) | ||
567 | { | ||
568 | PKCS7err(PKCS7_F_PKCS7_DATASIGN,ERR_R_INTERNAL_ERROR); | ||
569 | goto err; | ||
570 | } | ||
571 | if (EVP_MD_CTX_type(mdc) == j) | ||
572 | break; | ||
573 | else | ||
574 | btmp=BIO_next(btmp); | ||
575 | } | ||
576 | |||
577 | /* We now have the EVP_MD_CTX, lets do the | ||
578 | * signing. */ | ||
579 | EVP_MD_CTX_copy_ex(&ctx_tmp,mdc); | ||
580 | if (!BUF_MEM_grow_clean(buf,EVP_PKEY_size(si->pkey))) | ||
581 | { | ||
582 | PKCS7err(PKCS7_F_PKCS7_DATASIGN,ERR_R_BIO_LIB); | ||
583 | goto err; | ||
584 | } | ||
585 | |||
586 | sk=si->auth_attr; | ||
587 | |||
588 | /* If there are attributes, we add the digest | ||
589 | * attribute and only sign the attributes */ | ||
590 | if ((sk != NULL) && (sk_X509_ATTRIBUTE_num(sk) != 0)) | ||
591 | { | ||
592 | unsigned char md_data[EVP_MAX_MD_SIZE], *abuf=NULL; | ||
593 | unsigned int md_len, alen; | ||
594 | ASN1_OCTET_STRING *digest; | ||
595 | ASN1_UTCTIME *sign_time; | ||
596 | const EVP_MD *md_tmp; | ||
597 | |||
598 | /* Add signing time if not already present */ | ||
599 | if (!PKCS7_get_signed_attribute(si, | ||
600 | NID_pkcs9_signingTime)) | ||
601 | { | ||
602 | sign_time=X509_gmtime_adj(NULL,0); | ||
603 | PKCS7_add_signed_attribute(si, | ||
604 | NID_pkcs9_signingTime, | ||
605 | V_ASN1_UTCTIME,sign_time); | ||
606 | } | ||
607 | |||
608 | /* Add digest */ | ||
609 | md_tmp=EVP_MD_CTX_md(&ctx_tmp); | ||
610 | EVP_DigestFinal_ex(&ctx_tmp,md_data,&md_len); | ||
611 | digest=M_ASN1_OCTET_STRING_new(); | ||
612 | M_ASN1_OCTET_STRING_set(digest,md_data,md_len); | ||
613 | PKCS7_add_signed_attribute(si, | ||
614 | NID_pkcs9_messageDigest, | ||
615 | V_ASN1_OCTET_STRING,digest); | ||
616 | |||
617 | /* Now sign the attributes */ | ||
618 | EVP_SignInit_ex(&ctx_tmp,md_tmp,NULL); | ||
619 | alen = ASN1_item_i2d((ASN1_VALUE *)sk,&abuf, | ||
620 | ASN1_ITEM_rptr(PKCS7_ATTR_SIGN)); | ||
621 | if(!abuf) goto err; | ||
622 | EVP_SignUpdate(&ctx_tmp,abuf,alen); | ||
623 | OPENSSL_free(abuf); | ||
624 | } | ||
625 | |||
626 | #ifndef OPENSSL_NO_DSA | ||
627 | if (si->pkey->type == EVP_PKEY_DSA) | ||
628 | ctx_tmp.digest=EVP_dss1(); | ||
629 | #endif | ||
630 | |||
631 | if (!EVP_SignFinal(&ctx_tmp,(unsigned char *)buf->data, | ||
632 | (unsigned int *)&buf->length,si->pkey)) | ||
633 | { | ||
634 | PKCS7err(PKCS7_F_PKCS7_DATASIGN,ERR_R_EVP_LIB); | ||
635 | goto err; | ||
636 | } | ||
637 | if (!ASN1_STRING_set(si->enc_digest, | ||
638 | (unsigned char *)buf->data,buf->length)) | ||
639 | { | ||
640 | PKCS7err(PKCS7_F_PKCS7_DATASIGN,ERR_R_ASN1_LIB); | ||
641 | goto err; | ||
642 | } | ||
643 | } | ||
644 | } | ||
645 | |||
646 | if (!PKCS7_is_detached(p7)) | ||
647 | { | ||
648 | btmp=BIO_find_type(bio,BIO_TYPE_MEM); | ||
649 | if (btmp == NULL) | ||
650 | { | ||
651 | PKCS7err(PKCS7_F_PKCS7_DATASIGN,PKCS7_R_UNABLE_TO_FIND_MEM_BIO); | ||
652 | goto err; | ||
653 | } | ||
654 | BIO_get_mem_ptr(btmp,&buf_mem); | ||
655 | /* Mark the BIO read only then we can use its copy of the data | ||
656 | * instead of making an extra copy. | ||
657 | */ | ||
658 | BIO_set_flags(btmp, BIO_FLAGS_MEM_RDONLY); | ||
659 | BIO_set_mem_eof_return(btmp, 0); | ||
660 | os->data = (unsigned char *)buf_mem->data; | ||
661 | os->length = buf_mem->length; | ||
662 | #if 0 | ||
663 | M_ASN1_OCTET_STRING_set(os, | ||
664 | (unsigned char *)buf_mem->data,buf_mem->length); | ||
665 | #endif | ||
666 | } | ||
667 | ret=1; | ||
668 | err: | ||
669 | EVP_MD_CTX_cleanup(&ctx_tmp); | ||
670 | if (buf != NULL) BUF_MEM_free(buf); | ||
671 | return(ret); | ||
672 | } | ||
673 | |||
674 | int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, BIO *bio, | ||
675 | PKCS7 *p7, PKCS7_SIGNER_INFO *si) | ||
676 | { | ||
677 | PKCS7_ISSUER_AND_SERIAL *ias; | ||
678 | int ret=0,i; | ||
679 | STACK_OF(X509) *cert; | ||
680 | X509 *x509; | ||
681 | |||
682 | if (PKCS7_type_is_signed(p7)) | ||
683 | { | ||
684 | cert=p7->d.sign->cert; | ||
685 | } | ||
686 | else if (PKCS7_type_is_signedAndEnveloped(p7)) | ||
687 | { | ||
688 | cert=p7->d.signed_and_enveloped->cert; | ||
689 | } | ||
690 | else | ||
691 | { | ||
692 | PKCS7err(PKCS7_F_PKCS7_DATAVERIFY,PKCS7_R_WRONG_PKCS7_TYPE); | ||
693 | goto err; | ||
694 | } | ||
695 | /* XXXXXXXXXXXXXXXXXXXXXXX */ | ||
696 | ias=si->issuer_and_serial; | ||
697 | |||
698 | x509=X509_find_by_issuer_and_serial(cert,ias->issuer,ias->serial); | ||
699 | |||
700 | /* were we able to find the cert in passed to us */ | ||
701 | if (x509 == NULL) | ||
702 | { | ||
703 | PKCS7err(PKCS7_F_PKCS7_DATAVERIFY,PKCS7_R_UNABLE_TO_FIND_CERTIFICATE); | ||
704 | goto err; | ||
705 | } | ||
706 | |||
707 | /* Lets verify */ | ||
708 | if(!X509_STORE_CTX_init(ctx,cert_store,x509,cert)) | ||
709 | { | ||
710 | PKCS7err(PKCS7_F_PKCS7_DATAVERIFY,ERR_R_X509_LIB); | ||
711 | goto err; | ||
712 | } | ||
713 | X509_STORE_CTX_set_purpose(ctx, X509_PURPOSE_SMIME_SIGN); | ||
714 | i=X509_verify_cert(ctx); | ||
715 | if (i <= 0) | ||
716 | { | ||
717 | PKCS7err(PKCS7_F_PKCS7_DATAVERIFY,ERR_R_X509_LIB); | ||
718 | X509_STORE_CTX_cleanup(ctx); | ||
719 | goto err; | ||
720 | } | ||
721 | X509_STORE_CTX_cleanup(ctx); | ||
722 | |||
723 | return PKCS7_signatureVerify(bio, p7, si, x509); | ||
724 | err: | ||
725 | return ret; | ||
726 | } | ||
727 | |||
728 | int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si, | ||
729 | X509 *x509) | ||
730 | { | ||
731 | ASN1_OCTET_STRING *os; | ||
732 | EVP_MD_CTX mdc_tmp,*mdc; | ||
733 | int ret=0,i; | ||
734 | int md_type; | ||
735 | STACK_OF(X509_ATTRIBUTE) *sk; | ||
736 | BIO *btmp; | ||
737 | EVP_PKEY *pkey; | ||
738 | |||
739 | EVP_MD_CTX_init(&mdc_tmp); | ||
740 | |||
741 | if (!PKCS7_type_is_signed(p7) && | ||
742 | !PKCS7_type_is_signedAndEnveloped(p7)) { | ||
743 | PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, | ||
744 | PKCS7_R_WRONG_PKCS7_TYPE); | ||
745 | goto err; | ||
746 | } | ||
747 | |||
748 | md_type=OBJ_obj2nid(si->digest_alg->algorithm); | ||
749 | |||
750 | btmp=bio; | ||
751 | for (;;) | ||
752 | { | ||
753 | if ((btmp == NULL) || | ||
754 | ((btmp=BIO_find_type(btmp,BIO_TYPE_MD)) == NULL)) | ||
755 | { | ||
756 | PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, | ||
757 | PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST); | ||
758 | goto err; | ||
759 | } | ||
760 | BIO_get_md_ctx(btmp,&mdc); | ||
761 | if (mdc == NULL) | ||
762 | { | ||
763 | PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, | ||
764 | ERR_R_INTERNAL_ERROR); | ||
765 | goto err; | ||
766 | } | ||
767 | if (EVP_MD_CTX_type(mdc) == md_type) | ||
768 | break; | ||
769 | /* Workaround for some broken clients that put the signature | ||
770 | * OID instead of the digest OID in digest_alg->algorithm | ||
771 | */ | ||
772 | if (EVP_MD_pkey_type(EVP_MD_CTX_md(mdc)) == md_type) | ||
773 | break; | ||
774 | btmp=BIO_next(btmp); | ||
775 | } | ||
776 | |||
777 | /* mdc is the digest ctx that we want, unless there are attributes, | ||
778 | * in which case the digest is the signed attributes */ | ||
779 | EVP_MD_CTX_copy_ex(&mdc_tmp,mdc); | ||
780 | |||
781 | sk=si->auth_attr; | ||
782 | if ((sk != NULL) && (sk_X509_ATTRIBUTE_num(sk) != 0)) | ||
783 | { | ||
784 | unsigned char md_dat[EVP_MAX_MD_SIZE], *abuf = NULL; | ||
785 | unsigned int md_len, alen; | ||
786 | ASN1_OCTET_STRING *message_digest; | ||
787 | |||
788 | EVP_DigestFinal_ex(&mdc_tmp,md_dat,&md_len); | ||
789 | message_digest=PKCS7_digest_from_attributes(sk); | ||
790 | if (!message_digest) | ||
791 | { | ||
792 | PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, | ||
793 | PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST); | ||
794 | goto err; | ||
795 | } | ||
796 | if ((message_digest->length != (int)md_len) || | ||
797 | (memcmp(message_digest->data,md_dat,md_len))) | ||
798 | { | ||
799 | #if 0 | ||
800 | { | ||
801 | int ii; | ||
802 | for (ii=0; ii<message_digest->length; ii++) | ||
803 | printf("%02X",message_digest->data[ii]); printf(" sent\n"); | ||
804 | for (ii=0; ii<md_len; ii++) printf("%02X",md_dat[ii]); printf(" calc\n"); | ||
805 | } | ||
806 | #endif | ||
807 | PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, | ||
808 | PKCS7_R_DIGEST_FAILURE); | ||
809 | ret= -1; | ||
810 | goto err; | ||
811 | } | ||
812 | |||
813 | EVP_VerifyInit_ex(&mdc_tmp,EVP_get_digestbynid(md_type), NULL); | ||
814 | |||
815 | alen = ASN1_item_i2d((ASN1_VALUE *)sk, &abuf, | ||
816 | ASN1_ITEM_rptr(PKCS7_ATTR_VERIFY)); | ||
817 | EVP_VerifyUpdate(&mdc_tmp, abuf, alen); | ||
818 | |||
819 | OPENSSL_free(abuf); | ||
820 | } | ||
821 | |||
822 | os=si->enc_digest; | ||
823 | pkey = X509_get_pubkey(x509); | ||
824 | if (!pkey) | ||
825 | { | ||
826 | ret = -1; | ||
827 | goto err; | ||
828 | } | ||
829 | #ifndef OPENSSL_NO_DSA | ||
830 | if(pkey->type == EVP_PKEY_DSA) mdc_tmp.digest=EVP_dss1(); | ||
831 | #endif | ||
832 | |||
833 | i=EVP_VerifyFinal(&mdc_tmp,os->data,os->length, pkey); | ||
834 | EVP_PKEY_free(pkey); | ||
835 | if (i <= 0) | ||
836 | { | ||
837 | PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, | ||
838 | PKCS7_R_SIGNATURE_FAILURE); | ||
839 | ret= -1; | ||
840 | goto err; | ||
841 | } | ||
842 | else | ||
843 | ret=1; | ||
844 | err: | ||
845 | EVP_MD_CTX_cleanup(&mdc_tmp); | ||
846 | return(ret); | ||
847 | } | ||
848 | |||
849 | PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx) | ||
850 | { | ||
851 | STACK_OF(PKCS7_RECIP_INFO) *rsk; | ||
852 | PKCS7_RECIP_INFO *ri; | ||
853 | int i; | ||
854 | |||
855 | i=OBJ_obj2nid(p7->type); | ||
856 | if (i != NID_pkcs7_signedAndEnveloped) return(NULL); | ||
857 | rsk=p7->d.signed_and_enveloped->recipientinfo; | ||
858 | ri=sk_PKCS7_RECIP_INFO_value(rsk,0); | ||
859 | if (sk_PKCS7_RECIP_INFO_num(rsk) <= idx) return(NULL); | ||
860 | ri=sk_PKCS7_RECIP_INFO_value(rsk,idx); | ||
861 | return(ri->issuer_and_serial); | ||
862 | } | ||
863 | |||
864 | ASN1_TYPE *PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid) | ||
865 | { | ||
866 | return(get_attribute(si->auth_attr,nid)); | ||
867 | } | ||
868 | |||
869 | ASN1_TYPE *PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid) | ||
870 | { | ||
871 | return(get_attribute(si->unauth_attr,nid)); | ||
872 | } | ||
873 | |||
874 | static ASN1_TYPE *get_attribute(STACK_OF(X509_ATTRIBUTE) *sk, int nid) | ||
875 | { | ||
876 | int i; | ||
877 | X509_ATTRIBUTE *xa; | ||
878 | ASN1_OBJECT *o; | ||
879 | |||
880 | o=OBJ_nid2obj(nid); | ||
881 | if (!o || !sk) return(NULL); | ||
882 | for (i=0; i<sk_X509_ATTRIBUTE_num(sk); i++) | ||
883 | { | ||
884 | xa=sk_X509_ATTRIBUTE_value(sk,i); | ||
885 | if (OBJ_cmp(xa->object,o) == 0) | ||
886 | { | ||
887 | if (!xa->single && sk_ASN1_TYPE_num(xa->value.set)) | ||
888 | return(sk_ASN1_TYPE_value(xa->value.set,0)); | ||
889 | else | ||
890 | return(NULL); | ||
891 | } | ||
892 | } | ||
893 | return(NULL); | ||
894 | } | ||
895 | |||
896 | ASN1_OCTET_STRING *PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk) | ||
897 | { | ||
898 | ASN1_TYPE *astype; | ||
899 | if(!(astype = get_attribute(sk, NID_pkcs9_messageDigest))) return NULL; | ||
900 | return astype->value.octet_string; | ||
901 | } | ||
902 | |||
903 | int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si, | ||
904 | STACK_OF(X509_ATTRIBUTE) *sk) | ||
905 | { | ||
906 | int i; | ||
907 | |||
908 | if (p7si->auth_attr != NULL) | ||
909 | sk_X509_ATTRIBUTE_pop_free(p7si->auth_attr,X509_ATTRIBUTE_free); | ||
910 | p7si->auth_attr=sk_X509_ATTRIBUTE_dup(sk); | ||
911 | for (i=0; i<sk_X509_ATTRIBUTE_num(sk); i++) | ||
912 | { | ||
913 | if ((sk_X509_ATTRIBUTE_set(p7si->auth_attr,i, | ||
914 | X509_ATTRIBUTE_dup(sk_X509_ATTRIBUTE_value(sk,i)))) | ||
915 | == NULL) | ||
916 | return(0); | ||
917 | } | ||
918 | return(1); | ||
919 | } | ||
920 | |||
921 | int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si, STACK_OF(X509_ATTRIBUTE) *sk) | ||
922 | { | ||
923 | int i; | ||
924 | |||
925 | if (p7si->unauth_attr != NULL) | ||
926 | sk_X509_ATTRIBUTE_pop_free(p7si->unauth_attr, | ||
927 | X509_ATTRIBUTE_free); | ||
928 | p7si->unauth_attr=sk_X509_ATTRIBUTE_dup(sk); | ||
929 | for (i=0; i<sk_X509_ATTRIBUTE_num(sk); i++) | ||
930 | { | ||
931 | if ((sk_X509_ATTRIBUTE_set(p7si->unauth_attr,i, | ||
932 | X509_ATTRIBUTE_dup(sk_X509_ATTRIBUTE_value(sk,i)))) | ||
933 | == NULL) | ||
934 | return(0); | ||
935 | } | ||
936 | return(1); | ||
937 | } | ||
938 | |||
939 | int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype, | ||
940 | void *value) | ||
941 | { | ||
942 | return(add_attribute(&(p7si->auth_attr),nid,atrtype,value)); | ||
943 | } | ||
944 | |||
945 | int PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype, | ||
946 | void *value) | ||
947 | { | ||
948 | return(add_attribute(&(p7si->unauth_attr),nid,atrtype,value)); | ||
949 | } | ||
950 | |||
951 | static int add_attribute(STACK_OF(X509_ATTRIBUTE) **sk, int nid, int atrtype, | ||
952 | void *value) | ||
953 | { | ||
954 | X509_ATTRIBUTE *attr=NULL; | ||
955 | |||
956 | if (*sk == NULL) | ||
957 | { | ||
958 | *sk = sk_X509_ATTRIBUTE_new_null(); | ||
959 | new_attrib: | ||
960 | attr=X509_ATTRIBUTE_create(nid,atrtype,value); | ||
961 | sk_X509_ATTRIBUTE_push(*sk,attr); | ||
962 | } | ||
963 | else | ||
964 | { | ||
965 | int i; | ||
966 | |||
967 | for (i=0; i<sk_X509_ATTRIBUTE_num(*sk); i++) | ||
968 | { | ||
969 | attr=sk_X509_ATTRIBUTE_value(*sk,i); | ||
970 | if (OBJ_obj2nid(attr->object) == nid) | ||
971 | { | ||
972 | X509_ATTRIBUTE_free(attr); | ||
973 | attr=X509_ATTRIBUTE_create(nid,atrtype,value); | ||
974 | sk_X509_ATTRIBUTE_set(*sk,i,attr); | ||
975 | goto end; | ||
976 | } | ||
977 | } | ||
978 | goto new_attrib; | ||
979 | } | ||
980 | end: | ||
981 | return(1); | ||
982 | } | ||
983 | |||
diff --git a/src/lib/libcrypto/pkcs7/pk7_enc.c b/src/lib/libcrypto/pkcs7/pk7_enc.c new file mode 100644 index 0000000000..acbb189c59 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/pk7_enc.c | |||
@@ -0,0 +1,76 @@ | |||
1 | /* crypto/pkcs7/pk7_enc.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/evp.h> | ||
62 | #include <openssl/rand.h> | ||
63 | #include <openssl/objects.h> | ||
64 | #include <openssl/x509.h> | ||
65 | #include <openssl/pkcs7.h> | ||
66 | |||
67 | PKCS7_in_bio(PKCS7 *p7,BIO *in); | ||
68 | PKCS7_out_bio(PKCS7 *p7,BIO *out); | ||
69 | |||
70 | PKCS7_add_signer(PKCS7 *p7,X509 *cert,EVP_PKEY *key); | ||
71 | PKCS7_cipher(PKCS7 *p7,EVP_CIPHER *cipher); | ||
72 | |||
73 | PKCS7_Init(PKCS7 *p7); | ||
74 | PKCS7_Update(PKCS7 *p7); | ||
75 | PKCS7_Finish(PKCS7 *p7); | ||
76 | |||
diff --git a/src/lib/libcrypto/pkcs7/pk7_lib.c b/src/lib/libcrypto/pkcs7/pk7_lib.c new file mode 100644 index 0000000000..985b07245c --- /dev/null +++ b/src/lib/libcrypto/pkcs7/pk7_lib.c | |||
@@ -0,0 +1,484 @@ | |||
1 | /* crypto/pkcs7/pk7_lib.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/objects.h> | ||
62 | #include <openssl/x509.h> | ||
63 | |||
64 | long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg) | ||
65 | { | ||
66 | int nid; | ||
67 | long ret; | ||
68 | |||
69 | nid=OBJ_obj2nid(p7->type); | ||
70 | |||
71 | switch (cmd) | ||
72 | { | ||
73 | case PKCS7_OP_SET_DETACHED_SIGNATURE: | ||
74 | if (nid == NID_pkcs7_signed) | ||
75 | { | ||
76 | ret=p7->detached=(int)larg; | ||
77 | if (ret && PKCS7_type_is_data(p7->d.sign->contents)) | ||
78 | { | ||
79 | ASN1_OCTET_STRING *os; | ||
80 | os=p7->d.sign->contents->d.data; | ||
81 | ASN1_OCTET_STRING_free(os); | ||
82 | p7->d.sign->contents->d.data = NULL; | ||
83 | } | ||
84 | } | ||
85 | else | ||
86 | { | ||
87 | PKCS7err(PKCS7_F_PKCS7_CTRL,PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE); | ||
88 | ret=0; | ||
89 | } | ||
90 | break; | ||
91 | case PKCS7_OP_GET_DETACHED_SIGNATURE: | ||
92 | if (nid == NID_pkcs7_signed) | ||
93 | { | ||
94 | if(!p7->d.sign || !p7->d.sign->contents->d.ptr) | ||
95 | ret = 1; | ||
96 | else ret = 0; | ||
97 | |||
98 | p7->detached = ret; | ||
99 | } | ||
100 | else | ||
101 | { | ||
102 | PKCS7err(PKCS7_F_PKCS7_CTRL,PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE); | ||
103 | ret=0; | ||
104 | } | ||
105 | |||
106 | break; | ||
107 | default: | ||
108 | PKCS7err(PKCS7_F_PKCS7_CTRL,PKCS7_R_UNKNOWN_OPERATION); | ||
109 | ret=0; | ||
110 | } | ||
111 | return(ret); | ||
112 | } | ||
113 | |||
114 | int PKCS7_content_new(PKCS7 *p7, int type) | ||
115 | { | ||
116 | PKCS7 *ret=NULL; | ||
117 | |||
118 | if ((ret=PKCS7_new()) == NULL) goto err; | ||
119 | if (!PKCS7_set_type(ret,type)) goto err; | ||
120 | if (!PKCS7_set_content(p7,ret)) goto err; | ||
121 | |||
122 | return(1); | ||
123 | err: | ||
124 | if (ret != NULL) PKCS7_free(ret); | ||
125 | return(0); | ||
126 | } | ||
127 | |||
128 | int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data) | ||
129 | { | ||
130 | int i; | ||
131 | |||
132 | i=OBJ_obj2nid(p7->type); | ||
133 | switch (i) | ||
134 | { | ||
135 | case NID_pkcs7_signed: | ||
136 | if (p7->d.sign->contents != NULL) | ||
137 | PKCS7_free(p7->d.sign->contents); | ||
138 | p7->d.sign->contents=p7_data; | ||
139 | break; | ||
140 | case NID_pkcs7_digest: | ||
141 | case NID_pkcs7_data: | ||
142 | case NID_pkcs7_enveloped: | ||
143 | case NID_pkcs7_signedAndEnveloped: | ||
144 | case NID_pkcs7_encrypted: | ||
145 | default: | ||
146 | PKCS7err(PKCS7_F_PKCS7_SET_CONTENT,PKCS7_R_UNSUPPORTED_CONTENT_TYPE); | ||
147 | goto err; | ||
148 | } | ||
149 | return(1); | ||
150 | err: | ||
151 | return(0); | ||
152 | } | ||
153 | |||
154 | int PKCS7_set_type(PKCS7 *p7, int type) | ||
155 | { | ||
156 | ASN1_OBJECT *obj; | ||
157 | |||
158 | /*PKCS7_content_free(p7);*/ | ||
159 | obj=OBJ_nid2obj(type); /* will not fail */ | ||
160 | |||
161 | switch (type) | ||
162 | { | ||
163 | case NID_pkcs7_signed: | ||
164 | p7->type=obj; | ||
165 | if ((p7->d.sign=PKCS7_SIGNED_new()) == NULL) | ||
166 | goto err; | ||
167 | ASN1_INTEGER_set(p7->d.sign->version,1); | ||
168 | break; | ||
169 | case NID_pkcs7_data: | ||
170 | p7->type=obj; | ||
171 | if ((p7->d.data=M_ASN1_OCTET_STRING_new()) == NULL) | ||
172 | goto err; | ||
173 | break; | ||
174 | case NID_pkcs7_signedAndEnveloped: | ||
175 | p7->type=obj; | ||
176 | if ((p7->d.signed_and_enveloped=PKCS7_SIGN_ENVELOPE_new()) | ||
177 | == NULL) goto err; | ||
178 | ASN1_INTEGER_set(p7->d.signed_and_enveloped->version,1); | ||
179 | p7->d.signed_and_enveloped->enc_data->content_type | ||
180 | = OBJ_nid2obj(NID_pkcs7_data); | ||
181 | break; | ||
182 | case NID_pkcs7_enveloped: | ||
183 | p7->type=obj; | ||
184 | if ((p7->d.enveloped=PKCS7_ENVELOPE_new()) | ||
185 | == NULL) goto err; | ||
186 | ASN1_INTEGER_set(p7->d.enveloped->version,0); | ||
187 | p7->d.enveloped->enc_data->content_type | ||
188 | = OBJ_nid2obj(NID_pkcs7_data); | ||
189 | break; | ||
190 | case NID_pkcs7_encrypted: | ||
191 | p7->type=obj; | ||
192 | if ((p7->d.encrypted=PKCS7_ENCRYPT_new()) | ||
193 | == NULL) goto err; | ||
194 | ASN1_INTEGER_set(p7->d.encrypted->version,0); | ||
195 | p7->d.encrypted->enc_data->content_type | ||
196 | = OBJ_nid2obj(NID_pkcs7_data); | ||
197 | break; | ||
198 | |||
199 | case NID_pkcs7_digest: | ||
200 | default: | ||
201 | PKCS7err(PKCS7_F_PKCS7_SET_TYPE,PKCS7_R_UNSUPPORTED_CONTENT_TYPE); | ||
202 | goto err; | ||
203 | } | ||
204 | return(1); | ||
205 | err: | ||
206 | return(0); | ||
207 | } | ||
208 | |||
209 | int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *psi) | ||
210 | { | ||
211 | int i,j,nid; | ||
212 | X509_ALGOR *alg; | ||
213 | STACK_OF(PKCS7_SIGNER_INFO) *signer_sk; | ||
214 | STACK_OF(X509_ALGOR) *md_sk; | ||
215 | |||
216 | i=OBJ_obj2nid(p7->type); | ||
217 | switch (i) | ||
218 | { | ||
219 | case NID_pkcs7_signed: | ||
220 | signer_sk= p7->d.sign->signer_info; | ||
221 | md_sk= p7->d.sign->md_algs; | ||
222 | break; | ||
223 | case NID_pkcs7_signedAndEnveloped: | ||
224 | signer_sk= p7->d.signed_and_enveloped->signer_info; | ||
225 | md_sk= p7->d.signed_and_enveloped->md_algs; | ||
226 | break; | ||
227 | default: | ||
228 | PKCS7err(PKCS7_F_PKCS7_ADD_SIGNER,PKCS7_R_WRONG_CONTENT_TYPE); | ||
229 | return(0); | ||
230 | } | ||
231 | |||
232 | nid=OBJ_obj2nid(psi->digest_alg->algorithm); | ||
233 | |||
234 | /* If the digest is not currently listed, add it */ | ||
235 | j=0; | ||
236 | for (i=0; i<sk_X509_ALGOR_num(md_sk); i++) | ||
237 | { | ||
238 | alg=sk_X509_ALGOR_value(md_sk,i); | ||
239 | if (OBJ_obj2nid(alg->algorithm) == nid) | ||
240 | { | ||
241 | j=1; | ||
242 | break; | ||
243 | } | ||
244 | } | ||
245 | if (!j) /* we need to add another algorithm */ | ||
246 | { | ||
247 | if(!(alg=X509_ALGOR_new()) | ||
248 | || !(alg->parameter = ASN1_TYPE_new())) { | ||
249 | PKCS7err(PKCS7_F_PKCS7_ADD_SIGNER,ERR_R_MALLOC_FAILURE); | ||
250 | return(0); | ||
251 | } | ||
252 | alg->algorithm=OBJ_nid2obj(nid); | ||
253 | alg->parameter->type = V_ASN1_NULL; | ||
254 | sk_X509_ALGOR_push(md_sk,alg); | ||
255 | } | ||
256 | |||
257 | sk_PKCS7_SIGNER_INFO_push(signer_sk,psi); | ||
258 | return(1); | ||
259 | } | ||
260 | |||
261 | int PKCS7_add_certificate(PKCS7 *p7, X509 *x509) | ||
262 | { | ||
263 | int i; | ||
264 | STACK_OF(X509) **sk; | ||
265 | |||
266 | i=OBJ_obj2nid(p7->type); | ||
267 | switch (i) | ||
268 | { | ||
269 | case NID_pkcs7_signed: | ||
270 | sk= &(p7->d.sign->cert); | ||
271 | break; | ||
272 | case NID_pkcs7_signedAndEnveloped: | ||
273 | sk= &(p7->d.signed_and_enveloped->cert); | ||
274 | break; | ||
275 | default: | ||
276 | PKCS7err(PKCS7_F_PKCS7_ADD_CERTIFICATE,PKCS7_R_WRONG_CONTENT_TYPE); | ||
277 | return(0); | ||
278 | } | ||
279 | |||
280 | if (*sk == NULL) | ||
281 | *sk=sk_X509_new_null(); | ||
282 | CRYPTO_add(&x509->references,1,CRYPTO_LOCK_X509); | ||
283 | sk_X509_push(*sk,x509); | ||
284 | return(1); | ||
285 | } | ||
286 | |||
287 | int PKCS7_add_crl(PKCS7 *p7, X509_CRL *crl) | ||
288 | { | ||
289 | int i; | ||
290 | STACK_OF(X509_CRL) **sk; | ||
291 | |||
292 | i=OBJ_obj2nid(p7->type); | ||
293 | switch (i) | ||
294 | { | ||
295 | case NID_pkcs7_signed: | ||
296 | sk= &(p7->d.sign->crl); | ||
297 | break; | ||
298 | case NID_pkcs7_signedAndEnveloped: | ||
299 | sk= &(p7->d.signed_and_enveloped->crl); | ||
300 | break; | ||
301 | default: | ||
302 | PKCS7err(PKCS7_F_PKCS7_ADD_CRL,PKCS7_R_WRONG_CONTENT_TYPE); | ||
303 | return(0); | ||
304 | } | ||
305 | |||
306 | if (*sk == NULL) | ||
307 | *sk=sk_X509_CRL_new_null(); | ||
308 | |||
309 | CRYPTO_add(&crl->references,1,CRYPTO_LOCK_X509_CRL); | ||
310 | sk_X509_CRL_push(*sk,crl); | ||
311 | return(1); | ||
312 | } | ||
313 | |||
314 | int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey, | ||
315 | const EVP_MD *dgst) | ||
316 | { | ||
317 | char is_dsa; | ||
318 | if (pkey->type == EVP_PKEY_DSA) is_dsa = 1; | ||
319 | else is_dsa = 0; | ||
320 | /* We now need to add another PKCS7_SIGNER_INFO entry */ | ||
321 | ASN1_INTEGER_set(p7i->version,1); | ||
322 | X509_NAME_set(&p7i->issuer_and_serial->issuer, | ||
323 | X509_get_issuer_name(x509)); | ||
324 | |||
325 | /* because ASN1_INTEGER_set is used to set a 'long' we will do | ||
326 | * things the ugly way. */ | ||
327 | M_ASN1_INTEGER_free(p7i->issuer_and_serial->serial); | ||
328 | p7i->issuer_and_serial->serial= | ||
329 | M_ASN1_INTEGER_dup(X509_get_serialNumber(x509)); | ||
330 | |||
331 | /* lets keep the pkey around for a while */ | ||
332 | CRYPTO_add(&pkey->references,1,CRYPTO_LOCK_EVP_PKEY); | ||
333 | p7i->pkey=pkey; | ||
334 | |||
335 | /* Set the algorithms */ | ||
336 | if (is_dsa) p7i->digest_alg->algorithm=OBJ_nid2obj(NID_sha1); | ||
337 | else | ||
338 | p7i->digest_alg->algorithm=OBJ_nid2obj(EVP_MD_type(dgst)); | ||
339 | |||
340 | if (p7i->digest_alg->parameter != NULL) | ||
341 | ASN1_TYPE_free(p7i->digest_alg->parameter); | ||
342 | if ((p7i->digest_alg->parameter=ASN1_TYPE_new()) == NULL) | ||
343 | goto err; | ||
344 | p7i->digest_alg->parameter->type=V_ASN1_NULL; | ||
345 | |||
346 | p7i->digest_enc_alg->algorithm=OBJ_nid2obj(EVP_PKEY_type(pkey->type)); | ||
347 | |||
348 | if (p7i->digest_enc_alg->parameter != NULL) | ||
349 | ASN1_TYPE_free(p7i->digest_enc_alg->parameter); | ||
350 | if(is_dsa) p7i->digest_enc_alg->parameter = NULL; | ||
351 | else { | ||
352 | if (!(p7i->digest_enc_alg->parameter=ASN1_TYPE_new())) | ||
353 | goto err; | ||
354 | p7i->digest_enc_alg->parameter->type=V_ASN1_NULL; | ||
355 | } | ||
356 | |||
357 | return(1); | ||
358 | err: | ||
359 | return(0); | ||
360 | } | ||
361 | |||
362 | PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509, EVP_PKEY *pkey, | ||
363 | const EVP_MD *dgst) | ||
364 | { | ||
365 | PKCS7_SIGNER_INFO *si; | ||
366 | |||
367 | if ((si=PKCS7_SIGNER_INFO_new()) == NULL) goto err; | ||
368 | if (!PKCS7_SIGNER_INFO_set(si,x509,pkey,dgst)) goto err; | ||
369 | if (!PKCS7_add_signer(p7,si)) goto err; | ||
370 | return(si); | ||
371 | err: | ||
372 | return(NULL); | ||
373 | } | ||
374 | |||
375 | STACK_OF(PKCS7_SIGNER_INFO) *PKCS7_get_signer_info(PKCS7 *p7) | ||
376 | { | ||
377 | if (PKCS7_type_is_signed(p7)) | ||
378 | { | ||
379 | return(p7->d.sign->signer_info); | ||
380 | } | ||
381 | else if (PKCS7_type_is_signedAndEnveloped(p7)) | ||
382 | { | ||
383 | return(p7->d.signed_and_enveloped->signer_info); | ||
384 | } | ||
385 | else | ||
386 | return(NULL); | ||
387 | } | ||
388 | |||
389 | PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509) | ||
390 | { | ||
391 | PKCS7_RECIP_INFO *ri; | ||
392 | |||
393 | if ((ri=PKCS7_RECIP_INFO_new()) == NULL) goto err; | ||
394 | if (!PKCS7_RECIP_INFO_set(ri,x509)) goto err; | ||
395 | if (!PKCS7_add_recipient_info(p7,ri)) goto err; | ||
396 | return(ri); | ||
397 | err: | ||
398 | return(NULL); | ||
399 | } | ||
400 | |||
401 | int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri) | ||
402 | { | ||
403 | int i; | ||
404 | STACK_OF(PKCS7_RECIP_INFO) *sk; | ||
405 | |||
406 | i=OBJ_obj2nid(p7->type); | ||
407 | switch (i) | ||
408 | { | ||
409 | case NID_pkcs7_signedAndEnveloped: | ||
410 | sk= p7->d.signed_and_enveloped->recipientinfo; | ||
411 | break; | ||
412 | case NID_pkcs7_enveloped: | ||
413 | sk= p7->d.enveloped->recipientinfo; | ||
414 | break; | ||
415 | default: | ||
416 | PKCS7err(PKCS7_F_PKCS7_ADD_RECIPIENT_INFO,PKCS7_R_WRONG_CONTENT_TYPE); | ||
417 | return(0); | ||
418 | } | ||
419 | |||
420 | sk_PKCS7_RECIP_INFO_push(sk,ri); | ||
421 | return(1); | ||
422 | } | ||
423 | |||
424 | int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509) | ||
425 | { | ||
426 | ASN1_INTEGER_set(p7i->version,0); | ||
427 | X509_NAME_set(&p7i->issuer_and_serial->issuer, | ||
428 | X509_get_issuer_name(x509)); | ||
429 | |||
430 | M_ASN1_INTEGER_free(p7i->issuer_and_serial->serial); | ||
431 | p7i->issuer_and_serial->serial= | ||
432 | M_ASN1_INTEGER_dup(X509_get_serialNumber(x509)); | ||
433 | |||
434 | X509_ALGOR_free(p7i->key_enc_algor); | ||
435 | p7i->key_enc_algor= X509_ALGOR_dup(x509->cert_info->key->algor); | ||
436 | |||
437 | CRYPTO_add(&x509->references,1,CRYPTO_LOCK_X509); | ||
438 | p7i->cert=x509; | ||
439 | |||
440 | return(1); | ||
441 | } | ||
442 | |||
443 | X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si) | ||
444 | { | ||
445 | if (PKCS7_type_is_signed(p7)) | ||
446 | return(X509_find_by_issuer_and_serial(p7->d.sign->cert, | ||
447 | si->issuer_and_serial->issuer, | ||
448 | si->issuer_and_serial->serial)); | ||
449 | else | ||
450 | return(NULL); | ||
451 | } | ||
452 | |||
453 | int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher) | ||
454 | { | ||
455 | int i; | ||
456 | ASN1_OBJECT *objtmp; | ||
457 | PKCS7_ENC_CONTENT *ec; | ||
458 | |||
459 | i=OBJ_obj2nid(p7->type); | ||
460 | switch (i) | ||
461 | { | ||
462 | case NID_pkcs7_signedAndEnveloped: | ||
463 | ec=p7->d.signed_and_enveloped->enc_data; | ||
464 | break; | ||
465 | case NID_pkcs7_enveloped: | ||
466 | ec=p7->d.enveloped->enc_data; | ||
467 | break; | ||
468 | default: | ||
469 | PKCS7err(PKCS7_F_PKCS7_SET_CIPHER,PKCS7_R_WRONG_CONTENT_TYPE); | ||
470 | return(0); | ||
471 | } | ||
472 | |||
473 | /* Check cipher OID exists and has data in it*/ | ||
474 | i = EVP_CIPHER_type(cipher); | ||
475 | if(i == NID_undef) { | ||
476 | PKCS7err(PKCS7_F_PKCS7_SET_CIPHER,PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER); | ||
477 | return(0); | ||
478 | } | ||
479 | objtmp = OBJ_nid2obj(i); | ||
480 | |||
481 | ec->cipher = cipher; | ||
482 | return 1; | ||
483 | } | ||
484 | |||
diff --git a/src/lib/libcrypto/pkcs7/pk7_mime.c b/src/lib/libcrypto/pkcs7/pk7_mime.c new file mode 100644 index 0000000000..5d2a97839d --- /dev/null +++ b/src/lib/libcrypto/pkcs7/pk7_mime.c | |||
@@ -0,0 +1,714 @@ | |||
1 | /* pk7_mime.c */ | ||
2 | /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL | ||
3 | * project 1999. | ||
4 | */ | ||
5 | /* ==================================================================== | ||
6 | * Copyright (c) 1999-2003 The OpenSSL Project. All rights reserved. | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * | ||
12 | * 1. Redistributions of source code must retain the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer. | ||
14 | * | ||
15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
16 | * notice, this list of conditions and the following disclaimer in | ||
17 | * the documentation and/or other materials provided with the | ||
18 | * distribution. | ||
19 | * | ||
20 | * 3. All advertising materials mentioning features or use of this | ||
21 | * software must display the following acknowledgment: | ||
22 | * "This product includes software developed by the OpenSSL Project | ||
23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
24 | * | ||
25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
26 | * endorse or promote products derived from this software without | ||
27 | * prior written permission. For written permission, please contact | ||
28 | * licensing@OpenSSL.org. | ||
29 | * | ||
30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
31 | * nor may "OpenSSL" appear in their names without prior written | ||
32 | * permission of the OpenSSL Project. | ||
33 | * | ||
34 | * 6. Redistributions of any form whatsoever must retain the following | ||
35 | * acknowledgment: | ||
36 | * "This product includes software developed by the OpenSSL Project | ||
37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
38 | * | ||
39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
51 | * ==================================================================== | ||
52 | * | ||
53 | * This product includes cryptographic software written by Eric Young | ||
54 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
55 | * Hudson (tjh@cryptsoft.com). | ||
56 | * | ||
57 | */ | ||
58 | |||
59 | #include <stdio.h> | ||
60 | #include <ctype.h> | ||
61 | #include "cryptlib.h" | ||
62 | #include <openssl/rand.h> | ||
63 | #include <openssl/x509.h> | ||
64 | |||
65 | /* MIME and related routines */ | ||
66 | |||
67 | /* MIME format structures | ||
68 | * Note that all are translated to lower case apart from | ||
69 | * parameter values. Quotes are stripped off | ||
70 | */ | ||
71 | |||
72 | typedef struct { | ||
73 | char *param_name; /* Param name e.g. "micalg" */ | ||
74 | char *param_value; /* Param value e.g. "sha1" */ | ||
75 | } MIME_PARAM; | ||
76 | |||
77 | DECLARE_STACK_OF(MIME_PARAM) | ||
78 | IMPLEMENT_STACK_OF(MIME_PARAM) | ||
79 | |||
80 | typedef struct { | ||
81 | char *name; /* Name of line e.g. "content-type" */ | ||
82 | char *value; /* Value of line e.g. "text/plain" */ | ||
83 | STACK_OF(MIME_PARAM) *params; /* Zero or more parameters */ | ||
84 | } MIME_HEADER; | ||
85 | |||
86 | DECLARE_STACK_OF(MIME_HEADER) | ||
87 | IMPLEMENT_STACK_OF(MIME_HEADER) | ||
88 | |||
89 | static int B64_write_PKCS7(BIO *bio, PKCS7 *p7); | ||
90 | static PKCS7 *B64_read_PKCS7(BIO *bio); | ||
91 | static char * strip_ends(char *name); | ||
92 | static char * strip_start(char *name); | ||
93 | static char * strip_end(char *name); | ||
94 | static MIME_HEADER *mime_hdr_new(char *name, char *value); | ||
95 | static int mime_hdr_addparam(MIME_HEADER *mhdr, char *name, char *value); | ||
96 | static STACK_OF(MIME_HEADER) *mime_parse_hdr(BIO *bio); | ||
97 | static int mime_hdr_cmp(const MIME_HEADER * const *a, | ||
98 | const MIME_HEADER * const *b); | ||
99 | static int mime_param_cmp(const MIME_PARAM * const *a, | ||
100 | const MIME_PARAM * const *b); | ||
101 | static void mime_param_free(MIME_PARAM *param); | ||
102 | static int mime_bound_check(char *line, int linelen, char *bound, int blen); | ||
103 | static int multi_split(BIO *bio, char *bound, STACK_OF(BIO) **ret); | ||
104 | static int strip_eol(char *linebuf, int *plen); | ||
105 | static MIME_HEADER *mime_hdr_find(STACK_OF(MIME_HEADER) *hdrs, char *name); | ||
106 | static MIME_PARAM *mime_param_find(MIME_HEADER *hdr, char *name); | ||
107 | static void mime_hdr_free(MIME_HEADER *hdr); | ||
108 | |||
109 | #define MAX_SMLEN 1024 | ||
110 | #define mime_debug(x) /* x */ | ||
111 | |||
112 | |||
113 | typedef void (*stkfree)(); | ||
114 | |||
115 | /* Base 64 read and write of PKCS#7 structure */ | ||
116 | |||
117 | static int B64_write_PKCS7(BIO *bio, PKCS7 *p7) | ||
118 | { | ||
119 | BIO *b64; | ||
120 | if(!(b64 = BIO_new(BIO_f_base64()))) { | ||
121 | PKCS7err(PKCS7_F_B64_WRITE_PKCS7,ERR_R_MALLOC_FAILURE); | ||
122 | return 0; | ||
123 | } | ||
124 | bio = BIO_push(b64, bio); | ||
125 | i2d_PKCS7_bio(bio, p7); | ||
126 | BIO_flush(bio); | ||
127 | bio = BIO_pop(bio); | ||
128 | BIO_free(b64); | ||
129 | return 1; | ||
130 | } | ||
131 | |||
132 | static PKCS7 *B64_read_PKCS7(BIO *bio) | ||
133 | { | ||
134 | BIO *b64; | ||
135 | PKCS7 *p7; | ||
136 | if(!(b64 = BIO_new(BIO_f_base64()))) { | ||
137 | PKCS7err(PKCS7_F_B64_READ_PKCS7,ERR_R_MALLOC_FAILURE); | ||
138 | return 0; | ||
139 | } | ||
140 | bio = BIO_push(b64, bio); | ||
141 | if(!(p7 = d2i_PKCS7_bio(bio, NULL))) | ||
142 | PKCS7err(PKCS7_F_B64_READ_PKCS7,PKCS7_R_DECODE_ERROR); | ||
143 | BIO_flush(bio); | ||
144 | bio = BIO_pop(bio); | ||
145 | BIO_free(b64); | ||
146 | return p7; | ||
147 | } | ||
148 | |||
149 | /* SMIME sender */ | ||
150 | |||
151 | int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags) | ||
152 | { | ||
153 | char bound[33], c; | ||
154 | int i; | ||
155 | char *mime_prefix, *mime_eol; | ||
156 | if (flags & PKCS7_NOOLDMIMETYPE) | ||
157 | mime_prefix = "application/pkcs7-"; | ||
158 | else | ||
159 | mime_prefix = "application/x-pkcs7-"; | ||
160 | if (flags & PKCS7_CRLFEOL) | ||
161 | mime_eol = "\r\n"; | ||
162 | else | ||
163 | mime_eol = "\n"; | ||
164 | if((flags & PKCS7_DETACHED) && data) { | ||
165 | /* We want multipart/signed */ | ||
166 | /* Generate a random boundary */ | ||
167 | RAND_pseudo_bytes((unsigned char *)bound, 32); | ||
168 | for(i = 0; i < 32; i++) { | ||
169 | c = bound[i] & 0xf; | ||
170 | if(c < 10) c += '0'; | ||
171 | else c += 'A' - 10; | ||
172 | bound[i] = c; | ||
173 | } | ||
174 | bound[32] = 0; | ||
175 | BIO_printf(bio, "MIME-Version: 1.0%s", mime_eol); | ||
176 | BIO_printf(bio, "Content-Type: multipart/signed;"); | ||
177 | BIO_printf(bio, " protocol=\"%ssignature\";", mime_prefix); | ||
178 | BIO_printf(bio, " micalg=sha1; boundary=\"----%s\"%s%s", | ||
179 | bound, mime_eol, mime_eol); | ||
180 | BIO_printf(bio, "This is an S/MIME signed message%s%s", | ||
181 | mime_eol, mime_eol); | ||
182 | /* Now write out the first part */ | ||
183 | BIO_printf(bio, "------%s%s", bound, mime_eol); | ||
184 | SMIME_crlf_copy(data, bio, flags); | ||
185 | BIO_printf(bio, "%s------%s%s", mime_eol, bound, mime_eol); | ||
186 | |||
187 | /* Headers for signature */ | ||
188 | |||
189 | BIO_printf(bio, "Content-Type: %ssignature;", mime_prefix); | ||
190 | BIO_printf(bio, " name=\"smime.p7s\"%s", mime_eol); | ||
191 | BIO_printf(bio, "Content-Transfer-Encoding: base64%s", | ||
192 | mime_eol); | ||
193 | BIO_printf(bio, "Content-Disposition: attachment;"); | ||
194 | BIO_printf(bio, " filename=\"smime.p7s\"%s%s", | ||
195 | mime_eol, mime_eol); | ||
196 | B64_write_PKCS7(bio, p7); | ||
197 | BIO_printf(bio,"%s------%s--%s%s", mime_eol, bound, | ||
198 | mime_eol, mime_eol); | ||
199 | return 1; | ||
200 | } | ||
201 | /* MIME headers */ | ||
202 | BIO_printf(bio, "MIME-Version: 1.0%s", mime_eol); | ||
203 | BIO_printf(bio, "Content-Disposition: attachment;"); | ||
204 | BIO_printf(bio, " filename=\"smime.p7m\"%s", mime_eol); | ||
205 | BIO_printf(bio, "Content-Type: %smime;", mime_prefix); | ||
206 | BIO_printf(bio, " name=\"smime.p7m\"%s", mime_eol); | ||
207 | BIO_printf(bio, "Content-Transfer-Encoding: base64%s%s", | ||
208 | mime_eol, mime_eol); | ||
209 | B64_write_PKCS7(bio, p7); | ||
210 | BIO_printf(bio, "%s", mime_eol); | ||
211 | return 1; | ||
212 | } | ||
213 | |||
214 | /* SMIME reader: handle multipart/signed and opaque signing. | ||
215 | * in multipart case the content is placed in a memory BIO | ||
216 | * pointed to by "bcont". In opaque this is set to NULL | ||
217 | */ | ||
218 | |||
219 | PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont) | ||
220 | { | ||
221 | BIO *p7in; | ||
222 | STACK_OF(MIME_HEADER) *headers = NULL; | ||
223 | STACK_OF(BIO) *parts = NULL; | ||
224 | MIME_HEADER *hdr; | ||
225 | MIME_PARAM *prm; | ||
226 | PKCS7 *p7; | ||
227 | int ret; | ||
228 | |||
229 | if(bcont) *bcont = NULL; | ||
230 | |||
231 | if (!(headers = mime_parse_hdr(bio))) { | ||
232 | PKCS7err(PKCS7_F_SMIME_READ_PKCS7,PKCS7_R_MIME_PARSE_ERROR); | ||
233 | return NULL; | ||
234 | } | ||
235 | |||
236 | if(!(hdr = mime_hdr_find(headers, "content-type")) || !hdr->value) { | ||
237 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
238 | PKCS7err(PKCS7_F_SMIME_READ_PKCS7, PKCS7_R_NO_CONTENT_TYPE); | ||
239 | return NULL; | ||
240 | } | ||
241 | |||
242 | /* Handle multipart/signed */ | ||
243 | |||
244 | if(!strcmp(hdr->value, "multipart/signed")) { | ||
245 | /* Split into two parts */ | ||
246 | prm = mime_param_find(hdr, "boundary"); | ||
247 | if(!prm || !prm->param_value) { | ||
248 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
249 | PKCS7err(PKCS7_F_SMIME_READ_PKCS7, PKCS7_R_NO_MULTIPART_BOUNDARY); | ||
250 | return NULL; | ||
251 | } | ||
252 | ret = multi_split(bio, prm->param_value, &parts); | ||
253 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
254 | if(!ret || (sk_BIO_num(parts) != 2) ) { | ||
255 | PKCS7err(PKCS7_F_SMIME_READ_PKCS7, PKCS7_R_NO_MULTIPART_BODY_FAILURE); | ||
256 | sk_BIO_pop_free(parts, BIO_vfree); | ||
257 | return NULL; | ||
258 | } | ||
259 | |||
260 | /* Parse the signature piece */ | ||
261 | p7in = sk_BIO_value(parts, 1); | ||
262 | |||
263 | if (!(headers = mime_parse_hdr(p7in))) { | ||
264 | PKCS7err(PKCS7_F_SMIME_READ_PKCS7,PKCS7_R_MIME_SIG_PARSE_ERROR); | ||
265 | sk_BIO_pop_free(parts, BIO_vfree); | ||
266 | return NULL; | ||
267 | } | ||
268 | |||
269 | /* Get content type */ | ||
270 | |||
271 | if(!(hdr = mime_hdr_find(headers, "content-type")) || | ||
272 | !hdr->value) { | ||
273 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
274 | PKCS7err(PKCS7_F_SMIME_READ_PKCS7, PKCS7_R_NO_SIG_CONTENT_TYPE); | ||
275 | return NULL; | ||
276 | } | ||
277 | |||
278 | if(strcmp(hdr->value, "application/x-pkcs7-signature") && | ||
279 | strcmp(hdr->value, "application/pkcs7-signature")) { | ||
280 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
281 | PKCS7err(PKCS7_F_SMIME_READ_PKCS7,PKCS7_R_SIG_INVALID_MIME_TYPE); | ||
282 | ERR_add_error_data(2, "type: ", hdr->value); | ||
283 | sk_BIO_pop_free(parts, BIO_vfree); | ||
284 | return NULL; | ||
285 | } | ||
286 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
287 | /* Read in PKCS#7 */ | ||
288 | if(!(p7 = B64_read_PKCS7(p7in))) { | ||
289 | PKCS7err(PKCS7_F_SMIME_READ_PKCS7,PKCS7_R_PKCS7_SIG_PARSE_ERROR); | ||
290 | sk_BIO_pop_free(parts, BIO_vfree); | ||
291 | return NULL; | ||
292 | } | ||
293 | |||
294 | if(bcont) { | ||
295 | *bcont = sk_BIO_value(parts, 0); | ||
296 | BIO_free(p7in); | ||
297 | sk_BIO_free(parts); | ||
298 | } else sk_BIO_pop_free(parts, BIO_vfree); | ||
299 | return p7; | ||
300 | } | ||
301 | |||
302 | /* OK, if not multipart/signed try opaque signature */ | ||
303 | |||
304 | if (strcmp (hdr->value, "application/x-pkcs7-mime") && | ||
305 | strcmp (hdr->value, "application/pkcs7-mime")) { | ||
306 | PKCS7err(PKCS7_F_SMIME_READ_PKCS7,PKCS7_R_INVALID_MIME_TYPE); | ||
307 | ERR_add_error_data(2, "type: ", hdr->value); | ||
308 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
309 | return NULL; | ||
310 | } | ||
311 | |||
312 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
313 | |||
314 | if(!(p7 = B64_read_PKCS7(bio))) { | ||
315 | PKCS7err(PKCS7_F_SMIME_READ_PKCS7, PKCS7_R_PKCS7_PARSE_ERROR); | ||
316 | return NULL; | ||
317 | } | ||
318 | return p7; | ||
319 | |||
320 | } | ||
321 | |||
322 | /* Copy text from one BIO to another making the output CRLF at EOL */ | ||
323 | int SMIME_crlf_copy(BIO *in, BIO *out, int flags) | ||
324 | { | ||
325 | char eol; | ||
326 | int len; | ||
327 | char linebuf[MAX_SMLEN]; | ||
328 | if(flags & PKCS7_BINARY) { | ||
329 | while((len = BIO_read(in, linebuf, MAX_SMLEN)) > 0) | ||
330 | BIO_write(out, linebuf, len); | ||
331 | return 1; | ||
332 | } | ||
333 | if(flags & PKCS7_TEXT) BIO_printf(out, "Content-Type: text/plain\r\n\r\n"); | ||
334 | while ((len = BIO_gets(in, linebuf, MAX_SMLEN)) > 0) { | ||
335 | eol = strip_eol(linebuf, &len); | ||
336 | if (len) | ||
337 | BIO_write(out, linebuf, len); | ||
338 | if(eol) BIO_write(out, "\r\n", 2); | ||
339 | } | ||
340 | return 1; | ||
341 | } | ||
342 | |||
343 | /* Strip off headers if they are text/plain */ | ||
344 | int SMIME_text(BIO *in, BIO *out) | ||
345 | { | ||
346 | char iobuf[4096]; | ||
347 | int len; | ||
348 | STACK_OF(MIME_HEADER) *headers; | ||
349 | MIME_HEADER *hdr; | ||
350 | |||
351 | if (!(headers = mime_parse_hdr(in))) { | ||
352 | PKCS7err(PKCS7_F_SMIME_TEXT,PKCS7_R_MIME_PARSE_ERROR); | ||
353 | return 0; | ||
354 | } | ||
355 | if(!(hdr = mime_hdr_find(headers, "content-type")) || !hdr->value) { | ||
356 | PKCS7err(PKCS7_F_SMIME_TEXT,PKCS7_R_MIME_NO_CONTENT_TYPE); | ||
357 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
358 | return 0; | ||
359 | } | ||
360 | if (strcmp (hdr->value, "text/plain")) { | ||
361 | PKCS7err(PKCS7_F_SMIME_TEXT,PKCS7_R_INVALID_MIME_TYPE); | ||
362 | ERR_add_error_data(2, "type: ", hdr->value); | ||
363 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
364 | return 0; | ||
365 | } | ||
366 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
367 | while ((len = BIO_read(in, iobuf, sizeof(iobuf))) > 0) | ||
368 | BIO_write(out, iobuf, len); | ||
369 | return 1; | ||
370 | } | ||
371 | |||
372 | /* Split a multipart/XXX message body into component parts: result is | ||
373 | * canonical parts in a STACK of bios | ||
374 | */ | ||
375 | |||
376 | static int multi_split(BIO *bio, char *bound, STACK_OF(BIO) **ret) | ||
377 | { | ||
378 | char linebuf[MAX_SMLEN]; | ||
379 | int len, blen; | ||
380 | int eol = 0, next_eol = 0; | ||
381 | BIO *bpart = NULL; | ||
382 | STACK_OF(BIO) *parts; | ||
383 | char state, part, first; | ||
384 | |||
385 | blen = strlen(bound); | ||
386 | part = 0; | ||
387 | state = 0; | ||
388 | first = 1; | ||
389 | parts = sk_BIO_new_null(); | ||
390 | *ret = parts; | ||
391 | while ((len = BIO_gets(bio, linebuf, MAX_SMLEN)) > 0) { | ||
392 | state = mime_bound_check(linebuf, len, bound, blen); | ||
393 | if(state == 1) { | ||
394 | first = 1; | ||
395 | part++; | ||
396 | } else if(state == 2) { | ||
397 | sk_BIO_push(parts, bpart); | ||
398 | return 1; | ||
399 | } else if(part) { | ||
400 | /* Strip CR+LF from linebuf */ | ||
401 | next_eol = strip_eol(linebuf, &len); | ||
402 | if(first) { | ||
403 | first = 0; | ||
404 | if(bpart) sk_BIO_push(parts, bpart); | ||
405 | bpart = BIO_new(BIO_s_mem()); | ||
406 | BIO_set_mem_eof_return(bpart, 0); | ||
407 | } else if (eol) | ||
408 | BIO_write(bpart, "\r\n", 2); | ||
409 | eol = next_eol; | ||
410 | if (len) | ||
411 | BIO_write(bpart, linebuf, len); | ||
412 | } | ||
413 | } | ||
414 | return 0; | ||
415 | } | ||
416 | |||
417 | /* This is the big one: parse MIME header lines up to message body */ | ||
418 | |||
419 | #define MIME_INVALID 0 | ||
420 | #define MIME_START 1 | ||
421 | #define MIME_TYPE 2 | ||
422 | #define MIME_NAME 3 | ||
423 | #define MIME_VALUE 4 | ||
424 | #define MIME_QUOTE 5 | ||
425 | #define MIME_COMMENT 6 | ||
426 | |||
427 | |||
428 | static STACK_OF(MIME_HEADER) *mime_parse_hdr(BIO *bio) | ||
429 | { | ||
430 | char *p, *q, c; | ||
431 | char *ntmp; | ||
432 | char linebuf[MAX_SMLEN]; | ||
433 | MIME_HEADER *mhdr = NULL; | ||
434 | STACK_OF(MIME_HEADER) *headers; | ||
435 | int len, state, save_state = 0; | ||
436 | |||
437 | headers = sk_MIME_HEADER_new(mime_hdr_cmp); | ||
438 | while ((len = BIO_gets(bio, linebuf, MAX_SMLEN)) > 0) { | ||
439 | /* If whitespace at line start then continuation line */ | ||
440 | if(mhdr && isspace((unsigned char)linebuf[0])) state = MIME_NAME; | ||
441 | else state = MIME_START; | ||
442 | ntmp = NULL; | ||
443 | /* Go through all characters */ | ||
444 | for(p = linebuf, q = linebuf; (c = *p) && (c!='\r') && (c!='\n'); p++) { | ||
445 | |||
446 | /* State machine to handle MIME headers | ||
447 | * if this looks horrible that's because it *is* | ||
448 | */ | ||
449 | |||
450 | switch(state) { | ||
451 | case MIME_START: | ||
452 | if(c == ':') { | ||
453 | state = MIME_TYPE; | ||
454 | *p = 0; | ||
455 | ntmp = strip_ends(q); | ||
456 | q = p + 1; | ||
457 | } | ||
458 | break; | ||
459 | |||
460 | case MIME_TYPE: | ||
461 | if(c == ';') { | ||
462 | mime_debug("Found End Value\n"); | ||
463 | *p = 0; | ||
464 | mhdr = mime_hdr_new(ntmp, strip_ends(q)); | ||
465 | sk_MIME_HEADER_push(headers, mhdr); | ||
466 | ntmp = NULL; | ||
467 | q = p + 1; | ||
468 | state = MIME_NAME; | ||
469 | } else if(c == '(') { | ||
470 | save_state = state; | ||
471 | state = MIME_COMMENT; | ||
472 | } | ||
473 | break; | ||
474 | |||
475 | case MIME_COMMENT: | ||
476 | if(c == ')') { | ||
477 | state = save_state; | ||
478 | } | ||
479 | break; | ||
480 | |||
481 | case MIME_NAME: | ||
482 | if(c == '=') { | ||
483 | state = MIME_VALUE; | ||
484 | *p = 0; | ||
485 | ntmp = strip_ends(q); | ||
486 | q = p + 1; | ||
487 | } | ||
488 | break ; | ||
489 | |||
490 | case MIME_VALUE: | ||
491 | if(c == ';') { | ||
492 | state = MIME_NAME; | ||
493 | *p = 0; | ||
494 | mime_hdr_addparam(mhdr, ntmp, strip_ends(q)); | ||
495 | ntmp = NULL; | ||
496 | q = p + 1; | ||
497 | } else if (c == '"') { | ||
498 | mime_debug("Found Quote\n"); | ||
499 | state = MIME_QUOTE; | ||
500 | } else if(c == '(') { | ||
501 | save_state = state; | ||
502 | state = MIME_COMMENT; | ||
503 | } | ||
504 | break; | ||
505 | |||
506 | case MIME_QUOTE: | ||
507 | if(c == '"') { | ||
508 | mime_debug("Found Match Quote\n"); | ||
509 | state = MIME_VALUE; | ||
510 | } | ||
511 | break; | ||
512 | } | ||
513 | } | ||
514 | |||
515 | if(state == MIME_TYPE) { | ||
516 | mhdr = mime_hdr_new(ntmp, strip_ends(q)); | ||
517 | sk_MIME_HEADER_push(headers, mhdr); | ||
518 | } else if(state == MIME_VALUE) | ||
519 | mime_hdr_addparam(mhdr, ntmp, strip_ends(q)); | ||
520 | if(p == linebuf) break; /* Blank line means end of headers */ | ||
521 | } | ||
522 | |||
523 | return headers; | ||
524 | |||
525 | } | ||
526 | |||
527 | static char *strip_ends(char *name) | ||
528 | { | ||
529 | return strip_end(strip_start(name)); | ||
530 | } | ||
531 | |||
532 | /* Strip a parameter of whitespace from start of param */ | ||
533 | static char *strip_start(char *name) | ||
534 | { | ||
535 | char *p, c; | ||
536 | /* Look for first non white space or quote */ | ||
537 | for(p = name; (c = *p) ;p++) { | ||
538 | if(c == '"') { | ||
539 | /* Next char is start of string if non null */ | ||
540 | if(p[1]) return p + 1; | ||
541 | /* Else null string */ | ||
542 | return NULL; | ||
543 | } | ||
544 | if(!isspace((unsigned char)c)) return p; | ||
545 | } | ||
546 | return NULL; | ||
547 | } | ||
548 | |||
549 | /* As above but strip from end of string : maybe should handle brackets? */ | ||
550 | static char *strip_end(char *name) | ||
551 | { | ||
552 | char *p, c; | ||
553 | if(!name) return NULL; | ||
554 | /* Look for first non white space or quote */ | ||
555 | for(p = name + strlen(name) - 1; p >= name ;p--) { | ||
556 | c = *p; | ||
557 | if(c == '"') { | ||
558 | if(p - 1 == name) return NULL; | ||
559 | *p = 0; | ||
560 | return name; | ||
561 | } | ||
562 | if(isspace((unsigned char)c)) *p = 0; | ||
563 | else return name; | ||
564 | } | ||
565 | return NULL; | ||
566 | } | ||
567 | |||
568 | static MIME_HEADER *mime_hdr_new(char *name, char *value) | ||
569 | { | ||
570 | MIME_HEADER *mhdr; | ||
571 | char *tmpname, *tmpval, *p; | ||
572 | int c; | ||
573 | if(name) { | ||
574 | if(!(tmpname = BUF_strdup(name))) return NULL; | ||
575 | for(p = tmpname ; *p; p++) { | ||
576 | c = *p; | ||
577 | if(isupper(c)) { | ||
578 | c = tolower(c); | ||
579 | *p = c; | ||
580 | } | ||
581 | } | ||
582 | } else tmpname = NULL; | ||
583 | if(value) { | ||
584 | if(!(tmpval = BUF_strdup(value))) return NULL; | ||
585 | for(p = tmpval ; *p; p++) { | ||
586 | c = *p; | ||
587 | if(isupper(c)) { | ||
588 | c = tolower(c); | ||
589 | *p = c; | ||
590 | } | ||
591 | } | ||
592 | } else tmpval = NULL; | ||
593 | mhdr = (MIME_HEADER *) OPENSSL_malloc(sizeof(MIME_HEADER)); | ||
594 | if(!mhdr) return NULL; | ||
595 | mhdr->name = tmpname; | ||
596 | mhdr->value = tmpval; | ||
597 | if(!(mhdr->params = sk_MIME_PARAM_new(mime_param_cmp))) return NULL; | ||
598 | return mhdr; | ||
599 | } | ||
600 | |||
601 | static int mime_hdr_addparam(MIME_HEADER *mhdr, char *name, char *value) | ||
602 | { | ||
603 | char *tmpname, *tmpval, *p; | ||
604 | int c; | ||
605 | MIME_PARAM *mparam; | ||
606 | if(name) { | ||
607 | tmpname = BUF_strdup(name); | ||
608 | if(!tmpname) return 0; | ||
609 | for(p = tmpname ; *p; p++) { | ||
610 | c = *p; | ||
611 | if(isupper(c)) { | ||
612 | c = tolower(c); | ||
613 | *p = c; | ||
614 | } | ||
615 | } | ||
616 | } else tmpname = NULL; | ||
617 | if(value) { | ||
618 | tmpval = BUF_strdup(value); | ||
619 | if(!tmpval) return 0; | ||
620 | } else tmpval = NULL; | ||
621 | /* Parameter values are case sensitive so leave as is */ | ||
622 | mparam = (MIME_PARAM *) OPENSSL_malloc(sizeof(MIME_PARAM)); | ||
623 | if(!mparam) return 0; | ||
624 | mparam->param_name = tmpname; | ||
625 | mparam->param_value = tmpval; | ||
626 | sk_MIME_PARAM_push(mhdr->params, mparam); | ||
627 | return 1; | ||
628 | } | ||
629 | |||
630 | static int mime_hdr_cmp(const MIME_HEADER * const *a, | ||
631 | const MIME_HEADER * const *b) | ||
632 | { | ||
633 | return(strcmp((*a)->name, (*b)->name)); | ||
634 | } | ||
635 | |||
636 | static int mime_param_cmp(const MIME_PARAM * const *a, | ||
637 | const MIME_PARAM * const *b) | ||
638 | { | ||
639 | return(strcmp((*a)->param_name, (*b)->param_name)); | ||
640 | } | ||
641 | |||
642 | /* Find a header with a given name (if possible) */ | ||
643 | |||
644 | static MIME_HEADER *mime_hdr_find(STACK_OF(MIME_HEADER) *hdrs, char *name) | ||
645 | { | ||
646 | MIME_HEADER htmp; | ||
647 | int idx; | ||
648 | htmp.name = name; | ||
649 | idx = sk_MIME_HEADER_find(hdrs, &htmp); | ||
650 | if(idx < 0) return NULL; | ||
651 | return sk_MIME_HEADER_value(hdrs, idx); | ||
652 | } | ||
653 | |||
654 | static MIME_PARAM *mime_param_find(MIME_HEADER *hdr, char *name) | ||
655 | { | ||
656 | MIME_PARAM param; | ||
657 | int idx; | ||
658 | param.param_name = name; | ||
659 | idx = sk_MIME_PARAM_find(hdr->params, ¶m); | ||
660 | if(idx < 0) return NULL; | ||
661 | return sk_MIME_PARAM_value(hdr->params, idx); | ||
662 | } | ||
663 | |||
664 | static void mime_hdr_free(MIME_HEADER *hdr) | ||
665 | { | ||
666 | if(hdr->name) OPENSSL_free(hdr->name); | ||
667 | if(hdr->value) OPENSSL_free(hdr->value); | ||
668 | if(hdr->params) sk_MIME_PARAM_pop_free(hdr->params, mime_param_free); | ||
669 | OPENSSL_free(hdr); | ||
670 | } | ||
671 | |||
672 | static void mime_param_free(MIME_PARAM *param) | ||
673 | { | ||
674 | if(param->param_name) OPENSSL_free(param->param_name); | ||
675 | if(param->param_value) OPENSSL_free(param->param_value); | ||
676 | OPENSSL_free(param); | ||
677 | } | ||
678 | |||
679 | /* Check for a multipart boundary. Returns: | ||
680 | * 0 : no boundary | ||
681 | * 1 : part boundary | ||
682 | * 2 : final boundary | ||
683 | */ | ||
684 | static int mime_bound_check(char *line, int linelen, char *bound, int blen) | ||
685 | { | ||
686 | if(linelen == -1) linelen = strlen(line); | ||
687 | if(blen == -1) blen = strlen(bound); | ||
688 | /* Quickly eliminate if line length too short */ | ||
689 | if(blen + 2 > linelen) return 0; | ||
690 | /* Check for part boundary */ | ||
691 | if(!strncmp(line, "--", 2) && !strncmp(line + 2, bound, blen)) { | ||
692 | if(!strncmp(line + blen + 2, "--", 2)) return 2; | ||
693 | else return 1; | ||
694 | } | ||
695 | return 0; | ||
696 | } | ||
697 | |||
698 | static int strip_eol(char *linebuf, int *plen) | ||
699 | { | ||
700 | int len = *plen; | ||
701 | char *p, c; | ||
702 | int is_eol = 0; | ||
703 | p = linebuf + len - 1; | ||
704 | for (p = linebuf + len - 1; len > 0; len--, p--) | ||
705 | { | ||
706 | c = *p; | ||
707 | if (c == '\n') | ||
708 | is_eol = 1; | ||
709 | else if (c != '\r') | ||
710 | break; | ||
711 | } | ||
712 | *plen = len; | ||
713 | return is_eol; | ||
714 | } | ||
diff --git a/src/lib/libcrypto/pkcs7/pk7_smime.c b/src/lib/libcrypto/pkcs7/pk7_smime.c new file mode 100644 index 0000000000..6e5735de11 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/pk7_smime.c | |||
@@ -0,0 +1,441 @@ | |||
1 | /* pk7_smime.c */ | ||
2 | /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL | ||
3 | * project 1999. | ||
4 | */ | ||
5 | /* ==================================================================== | ||
6 | * Copyright (c) 1999-2003 The OpenSSL Project. All rights reserved. | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * | ||
12 | * 1. Redistributions of source code must retain the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer. | ||
14 | * | ||
15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
16 | * notice, this list of conditions and the following disclaimer in | ||
17 | * the documentation and/or other materials provided with the | ||
18 | * distribution. | ||
19 | * | ||
20 | * 3. All advertising materials mentioning features or use of this | ||
21 | * software must display the following acknowledgment: | ||
22 | * "This product includes software developed by the OpenSSL Project | ||
23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
24 | * | ||
25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
26 | * endorse or promote products derived from this software without | ||
27 | * prior written permission. For written permission, please contact | ||
28 | * licensing@OpenSSL.org. | ||
29 | * | ||
30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
31 | * nor may "OpenSSL" appear in their names without prior written | ||
32 | * permission of the OpenSSL Project. | ||
33 | * | ||
34 | * 6. Redistributions of any form whatsoever must retain the following | ||
35 | * acknowledgment: | ||
36 | * "This product includes software developed by the OpenSSL Project | ||
37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
38 | * | ||
39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
51 | * ==================================================================== | ||
52 | * | ||
53 | * This product includes cryptographic software written by Eric Young | ||
54 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
55 | * Hudson (tjh@cryptsoft.com). | ||
56 | * | ||
57 | */ | ||
58 | |||
59 | /* Simple PKCS#7 processing functions */ | ||
60 | |||
61 | #include <stdio.h> | ||
62 | #include "cryptlib.h" | ||
63 | #include <openssl/x509.h> | ||
64 | #include <openssl/x509v3.h> | ||
65 | |||
66 | PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs, | ||
67 | BIO *data, int flags) | ||
68 | { | ||
69 | PKCS7 *p7; | ||
70 | PKCS7_SIGNER_INFO *si; | ||
71 | BIO *p7bio; | ||
72 | STACK_OF(X509_ALGOR) *smcap; | ||
73 | int i; | ||
74 | |||
75 | if(!X509_check_private_key(signcert, pkey)) { | ||
76 | PKCS7err(PKCS7_F_PKCS7_SIGN,PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE); | ||
77 | return NULL; | ||
78 | } | ||
79 | |||
80 | if(!(p7 = PKCS7_new())) { | ||
81 | PKCS7err(PKCS7_F_PKCS7_SIGN,ERR_R_MALLOC_FAILURE); | ||
82 | return NULL; | ||
83 | } | ||
84 | |||
85 | PKCS7_set_type(p7, NID_pkcs7_signed); | ||
86 | |||
87 | PKCS7_content_new(p7, NID_pkcs7_data); | ||
88 | |||
89 | if (!(si = PKCS7_add_signature(p7,signcert,pkey,EVP_sha1()))) { | ||
90 | PKCS7err(PKCS7_F_PKCS7_SIGN,PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR); | ||
91 | return NULL; | ||
92 | } | ||
93 | |||
94 | if(!(flags & PKCS7_NOCERTS)) { | ||
95 | PKCS7_add_certificate(p7, signcert); | ||
96 | if(certs) for(i = 0; i < sk_X509_num(certs); i++) | ||
97 | PKCS7_add_certificate(p7, sk_X509_value(certs, i)); | ||
98 | } | ||
99 | |||
100 | if(!(p7bio = PKCS7_dataInit(p7, NULL))) { | ||
101 | PKCS7err(PKCS7_F_PKCS7_SIGN,ERR_R_MALLOC_FAILURE); | ||
102 | return NULL; | ||
103 | } | ||
104 | |||
105 | |||
106 | SMIME_crlf_copy(data, p7bio, flags); | ||
107 | |||
108 | if(!(flags & PKCS7_NOATTR)) { | ||
109 | PKCS7_add_signed_attribute(si, NID_pkcs9_contentType, | ||
110 | V_ASN1_OBJECT, OBJ_nid2obj(NID_pkcs7_data)); | ||
111 | /* Add SMIMECapabilities */ | ||
112 | if(!(flags & PKCS7_NOSMIMECAP)) | ||
113 | { | ||
114 | if(!(smcap = sk_X509_ALGOR_new_null())) { | ||
115 | PKCS7err(PKCS7_F_PKCS7_SIGN,ERR_R_MALLOC_FAILURE); | ||
116 | return NULL; | ||
117 | } | ||
118 | #ifndef OPENSSL_NO_DES | ||
119 | PKCS7_simple_smimecap (smcap, NID_des_ede3_cbc, -1); | ||
120 | #endif | ||
121 | #ifndef OPENSSL_NO_RC2 | ||
122 | PKCS7_simple_smimecap (smcap, NID_rc2_cbc, 128); | ||
123 | PKCS7_simple_smimecap (smcap, NID_rc2_cbc, 64); | ||
124 | #endif | ||
125 | #ifndef OPENSSL_NO_DES | ||
126 | PKCS7_simple_smimecap (smcap, NID_des_cbc, -1); | ||
127 | #endif | ||
128 | #ifndef OPENSSL_NO_RC2 | ||
129 | PKCS7_simple_smimecap (smcap, NID_rc2_cbc, 40); | ||
130 | #endif | ||
131 | PKCS7_add_attrib_smimecap (si, smcap); | ||
132 | sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free); | ||
133 | } | ||
134 | } | ||
135 | |||
136 | if(flags & PKCS7_DETACHED)PKCS7_set_detached(p7, 1); | ||
137 | |||
138 | if (!PKCS7_dataFinal(p7,p7bio)) { | ||
139 | PKCS7err(PKCS7_F_PKCS7_SIGN,PKCS7_R_PKCS7_DATASIGN); | ||
140 | return NULL; | ||
141 | } | ||
142 | |||
143 | BIO_free_all(p7bio); | ||
144 | return p7; | ||
145 | } | ||
146 | |||
147 | int PKCS7_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store, | ||
148 | BIO *indata, BIO *out, int flags) | ||
149 | { | ||
150 | STACK_OF(X509) *signers; | ||
151 | X509 *signer; | ||
152 | STACK_OF(PKCS7_SIGNER_INFO) *sinfos; | ||
153 | PKCS7_SIGNER_INFO *si; | ||
154 | X509_STORE_CTX cert_ctx; | ||
155 | char buf[4096]; | ||
156 | int i, j=0, k, ret = 0; | ||
157 | BIO *p7bio; | ||
158 | BIO *tmpout; | ||
159 | |||
160 | if(!p7) { | ||
161 | PKCS7err(PKCS7_F_PKCS7_VERIFY,PKCS7_R_INVALID_NULL_POINTER); | ||
162 | return 0; | ||
163 | } | ||
164 | |||
165 | if(!PKCS7_type_is_signed(p7)) { | ||
166 | PKCS7err(PKCS7_F_PKCS7_VERIFY,PKCS7_R_WRONG_CONTENT_TYPE); | ||
167 | return 0; | ||
168 | } | ||
169 | |||
170 | /* Check for no data and no content: no data to verify signature */ | ||
171 | if(PKCS7_get_detached(p7) && !indata) { | ||
172 | PKCS7err(PKCS7_F_PKCS7_VERIFY,PKCS7_R_NO_CONTENT); | ||
173 | return 0; | ||
174 | } | ||
175 | #if 0 | ||
176 | /* NB: this test commented out because some versions of Netscape | ||
177 | * illegally include zero length content when signing data. | ||
178 | */ | ||
179 | |||
180 | /* Check for data and content: two sets of data */ | ||
181 | if(!PKCS7_get_detached(p7) && indata) { | ||
182 | PKCS7err(PKCS7_F_PKCS7_VERIFY,PKCS7_R_CONTENT_AND_DATA_PRESENT); | ||
183 | return 0; | ||
184 | } | ||
185 | #endif | ||
186 | |||
187 | sinfos = PKCS7_get_signer_info(p7); | ||
188 | |||
189 | if(!sinfos || !sk_PKCS7_SIGNER_INFO_num(sinfos)) { | ||
190 | PKCS7err(PKCS7_F_PKCS7_VERIFY,PKCS7_R_NO_SIGNATURES_ON_DATA); | ||
191 | return 0; | ||
192 | } | ||
193 | |||
194 | |||
195 | signers = PKCS7_get0_signers(p7, certs, flags); | ||
196 | |||
197 | if(!signers) return 0; | ||
198 | |||
199 | /* Now verify the certificates */ | ||
200 | |||
201 | if (!(flags & PKCS7_NOVERIFY)) for (k = 0; k < sk_X509_num(signers); k++) { | ||
202 | signer = sk_X509_value (signers, k); | ||
203 | if (!(flags & PKCS7_NOCHAIN)) { | ||
204 | if(!X509_STORE_CTX_init(&cert_ctx, store, signer, | ||
205 | p7->d.sign->cert)) | ||
206 | { | ||
207 | PKCS7err(PKCS7_F_PKCS7_VERIFY,ERR_R_X509_LIB); | ||
208 | sk_X509_free(signers); | ||
209 | return 0; | ||
210 | } | ||
211 | X509_STORE_CTX_set_purpose(&cert_ctx, | ||
212 | X509_PURPOSE_SMIME_SIGN); | ||
213 | } else if(!X509_STORE_CTX_init (&cert_ctx, store, signer, NULL)) { | ||
214 | PKCS7err(PKCS7_F_PKCS7_VERIFY,ERR_R_X509_LIB); | ||
215 | sk_X509_free(signers); | ||
216 | return 0; | ||
217 | } | ||
218 | i = X509_verify_cert(&cert_ctx); | ||
219 | if (i <= 0) j = X509_STORE_CTX_get_error(&cert_ctx); | ||
220 | X509_STORE_CTX_cleanup(&cert_ctx); | ||
221 | if (i <= 0) { | ||
222 | PKCS7err(PKCS7_F_PKCS7_VERIFY,PKCS7_R_CERTIFICATE_VERIFY_ERROR); | ||
223 | ERR_add_error_data(2, "Verify error:", | ||
224 | X509_verify_cert_error_string(j)); | ||
225 | sk_X509_free(signers); | ||
226 | return 0; | ||
227 | } | ||
228 | /* Check for revocation status here */ | ||
229 | } | ||
230 | |||
231 | p7bio=PKCS7_dataInit(p7,indata); | ||
232 | |||
233 | if(flags & PKCS7_TEXT) { | ||
234 | if(!(tmpout = BIO_new(BIO_s_mem()))) { | ||
235 | PKCS7err(PKCS7_F_PKCS7_VERIFY,ERR_R_MALLOC_FAILURE); | ||
236 | goto err; | ||
237 | } | ||
238 | } else tmpout = out; | ||
239 | |||
240 | /* We now have to 'read' from p7bio to calculate digests etc. */ | ||
241 | for (;;) | ||
242 | { | ||
243 | i=BIO_read(p7bio,buf,sizeof(buf)); | ||
244 | if (i <= 0) break; | ||
245 | if (tmpout) BIO_write(tmpout, buf, i); | ||
246 | } | ||
247 | |||
248 | if(flags & PKCS7_TEXT) { | ||
249 | if(!SMIME_text(tmpout, out)) { | ||
250 | PKCS7err(PKCS7_F_PKCS7_VERIFY,PKCS7_R_SMIME_TEXT_ERROR); | ||
251 | BIO_free(tmpout); | ||
252 | goto err; | ||
253 | } | ||
254 | BIO_free(tmpout); | ||
255 | } | ||
256 | |||
257 | /* Now Verify All Signatures */ | ||
258 | if (!(flags & PKCS7_NOSIGS)) | ||
259 | for (i=0; i<sk_PKCS7_SIGNER_INFO_num(sinfos); i++) | ||
260 | { | ||
261 | si=sk_PKCS7_SIGNER_INFO_value(sinfos,i); | ||
262 | signer = sk_X509_value (signers, i); | ||
263 | j=PKCS7_signatureVerify(p7bio,p7,si, signer); | ||
264 | if (j <= 0) { | ||
265 | PKCS7err(PKCS7_F_PKCS7_VERIFY,PKCS7_R_SIGNATURE_FAILURE); | ||
266 | goto err; | ||
267 | } | ||
268 | } | ||
269 | |||
270 | ret = 1; | ||
271 | |||
272 | err: | ||
273 | |||
274 | if(indata) BIO_pop(p7bio); | ||
275 | BIO_free_all(p7bio); | ||
276 | sk_X509_free(signers); | ||
277 | |||
278 | return ret; | ||
279 | } | ||
280 | |||
281 | STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, int flags) | ||
282 | { | ||
283 | STACK_OF(X509) *signers; | ||
284 | STACK_OF(PKCS7_SIGNER_INFO) *sinfos; | ||
285 | PKCS7_SIGNER_INFO *si; | ||
286 | PKCS7_ISSUER_AND_SERIAL *ias; | ||
287 | X509 *signer; | ||
288 | int i; | ||
289 | |||
290 | if(!p7) { | ||
291 | PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS,PKCS7_R_INVALID_NULL_POINTER); | ||
292 | return NULL; | ||
293 | } | ||
294 | |||
295 | if(!PKCS7_type_is_signed(p7)) { | ||
296 | PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS,PKCS7_R_WRONG_CONTENT_TYPE); | ||
297 | return NULL; | ||
298 | } | ||
299 | if(!(signers = sk_X509_new_null())) { | ||
300 | PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS,ERR_R_MALLOC_FAILURE); | ||
301 | return NULL; | ||
302 | } | ||
303 | |||
304 | /* Collect all the signers together */ | ||
305 | |||
306 | sinfos = PKCS7_get_signer_info(p7); | ||
307 | |||
308 | if(sk_PKCS7_SIGNER_INFO_num(sinfos) <= 0) { | ||
309 | PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS,PKCS7_R_NO_SIGNERS); | ||
310 | return 0; | ||
311 | } | ||
312 | |||
313 | for (i = 0; i < sk_PKCS7_SIGNER_INFO_num(sinfos); i++) | ||
314 | { | ||
315 | si = sk_PKCS7_SIGNER_INFO_value(sinfos, i); | ||
316 | ias = si->issuer_and_serial; | ||
317 | signer = NULL; | ||
318 | /* If any certificates passed they take priority */ | ||
319 | if (certs) signer = X509_find_by_issuer_and_serial (certs, | ||
320 | ias->issuer, ias->serial); | ||
321 | if (!signer && !(flags & PKCS7_NOINTERN) | ||
322 | && p7->d.sign->cert) signer = | ||
323 | X509_find_by_issuer_and_serial (p7->d.sign->cert, | ||
324 | ias->issuer, ias->serial); | ||
325 | if (!signer) { | ||
326 | PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS,PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND); | ||
327 | sk_X509_free(signers); | ||
328 | return 0; | ||
329 | } | ||
330 | |||
331 | sk_X509_push(signers, signer); | ||
332 | } | ||
333 | return signers; | ||
334 | } | ||
335 | |||
336 | |||
337 | /* Build a complete PKCS#7 enveloped data */ | ||
338 | |||
339 | PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, const EVP_CIPHER *cipher, | ||
340 | int flags) | ||
341 | { | ||
342 | PKCS7 *p7; | ||
343 | BIO *p7bio = NULL; | ||
344 | int i; | ||
345 | X509 *x509; | ||
346 | if(!(p7 = PKCS7_new())) { | ||
347 | PKCS7err(PKCS7_F_PKCS7_ENCRYPT,ERR_R_MALLOC_FAILURE); | ||
348 | return NULL; | ||
349 | } | ||
350 | |||
351 | PKCS7_set_type(p7, NID_pkcs7_enveloped); | ||
352 | if(!PKCS7_set_cipher(p7, cipher)) { | ||
353 | PKCS7err(PKCS7_F_PKCS7_ENCRYPT,PKCS7_R_ERROR_SETTING_CIPHER); | ||
354 | goto err; | ||
355 | } | ||
356 | |||
357 | for(i = 0; i < sk_X509_num(certs); i++) { | ||
358 | x509 = sk_X509_value(certs, i); | ||
359 | if(!PKCS7_add_recipient(p7, x509)) { | ||
360 | PKCS7err(PKCS7_F_PKCS7_ENCRYPT, | ||
361 | PKCS7_R_ERROR_ADDING_RECIPIENT); | ||
362 | goto err; | ||
363 | } | ||
364 | } | ||
365 | |||
366 | if(!(p7bio = PKCS7_dataInit(p7, NULL))) { | ||
367 | PKCS7err(PKCS7_F_PKCS7_ENCRYPT,ERR_R_MALLOC_FAILURE); | ||
368 | goto err; | ||
369 | } | ||
370 | |||
371 | SMIME_crlf_copy(in, p7bio, flags); | ||
372 | |||
373 | BIO_flush(p7bio); | ||
374 | |||
375 | if (!PKCS7_dataFinal(p7,p7bio)) { | ||
376 | PKCS7err(PKCS7_F_PKCS7_ENCRYPT,PKCS7_R_PKCS7_DATAFINAL_ERROR); | ||
377 | goto err; | ||
378 | } | ||
379 | BIO_free_all(p7bio); | ||
380 | |||
381 | return p7; | ||
382 | |||
383 | err: | ||
384 | |||
385 | BIO_free(p7bio); | ||
386 | PKCS7_free(p7); | ||
387 | return NULL; | ||
388 | |||
389 | } | ||
390 | |||
391 | int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags) | ||
392 | { | ||
393 | BIO *tmpmem; | ||
394 | int ret, i; | ||
395 | char buf[4096]; | ||
396 | |||
397 | if(!p7) { | ||
398 | PKCS7err(PKCS7_F_PKCS7_DECRYPT,PKCS7_R_INVALID_NULL_POINTER); | ||
399 | return 0; | ||
400 | } | ||
401 | |||
402 | if(!PKCS7_type_is_enveloped(p7)) { | ||
403 | PKCS7err(PKCS7_F_PKCS7_DECRYPT,PKCS7_R_WRONG_CONTENT_TYPE); | ||
404 | return 0; | ||
405 | } | ||
406 | |||
407 | if(!X509_check_private_key(cert, pkey)) { | ||
408 | PKCS7err(PKCS7_F_PKCS7_DECRYPT, | ||
409 | PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE); | ||
410 | return 0; | ||
411 | } | ||
412 | |||
413 | if(!(tmpmem = PKCS7_dataDecode(p7, pkey, NULL, cert))) { | ||
414 | PKCS7err(PKCS7_F_PKCS7_DECRYPT, PKCS7_R_DECRYPT_ERROR); | ||
415 | return 0; | ||
416 | } | ||
417 | |||
418 | if (flags & PKCS7_TEXT) { | ||
419 | BIO *tmpbuf, *bread; | ||
420 | /* Encrypt BIOs can't do BIO_gets() so add a buffer BIO */ | ||
421 | if(!(tmpbuf = BIO_new(BIO_f_buffer()))) { | ||
422 | PKCS7err(PKCS7_F_PKCS7_DECRYPT, ERR_R_MALLOC_FAILURE); | ||
423 | return 0; | ||
424 | } | ||
425 | if(!(bread = BIO_push(tmpbuf, tmpmem))) { | ||
426 | PKCS7err(PKCS7_F_PKCS7_DECRYPT, ERR_R_MALLOC_FAILURE); | ||
427 | return 0; | ||
428 | } | ||
429 | ret = SMIME_text(bread, data); | ||
430 | BIO_free_all(bread); | ||
431 | return ret; | ||
432 | } else { | ||
433 | for(;;) { | ||
434 | i = BIO_read(tmpmem, buf, sizeof(buf)); | ||
435 | if(i <= 0) break; | ||
436 | BIO_write(data, buf, i); | ||
437 | } | ||
438 | BIO_free_all(tmpmem); | ||
439 | return 1; | ||
440 | } | ||
441 | } | ||
diff --git a/src/lib/libcrypto/pkcs7/pkcs7.h b/src/lib/libcrypto/pkcs7/pkcs7.h new file mode 100644 index 0000000000..15372e18f8 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/pkcs7.h | |||
@@ -0,0 +1,451 @@ | |||
1 | /* crypto/pkcs7/pkcs7.h */ | ||
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 | #ifndef HEADER_PKCS7_H | ||
60 | #define HEADER_PKCS7_H | ||
61 | |||
62 | #include <openssl/asn1.h> | ||
63 | #include <openssl/bio.h> | ||
64 | #include <openssl/e_os2.h> | ||
65 | |||
66 | #include <openssl/symhacks.h> | ||
67 | #include <openssl/ossl_typ.h> | ||
68 | |||
69 | #ifdef __cplusplus | ||
70 | extern "C" { | ||
71 | #endif | ||
72 | |||
73 | #ifdef OPENSSL_SYS_WIN32 | ||
74 | /* Under Win32 thes are defined in wincrypt.h */ | ||
75 | #undef PKCS7_ISSUER_AND_SERIAL | ||
76 | #undef PKCS7_SIGNER_INFO | ||
77 | #endif | ||
78 | |||
79 | /* | ||
80 | Encryption_ID DES-CBC | ||
81 | Digest_ID MD5 | ||
82 | Digest_Encryption_ID rsaEncryption | ||
83 | Key_Encryption_ID rsaEncryption | ||
84 | */ | ||
85 | |||
86 | typedef struct pkcs7_issuer_and_serial_st | ||
87 | { | ||
88 | X509_NAME *issuer; | ||
89 | ASN1_INTEGER *serial; | ||
90 | } PKCS7_ISSUER_AND_SERIAL; | ||
91 | |||
92 | typedef struct pkcs7_signer_info_st | ||
93 | { | ||
94 | ASN1_INTEGER *version; /* version 1 */ | ||
95 | PKCS7_ISSUER_AND_SERIAL *issuer_and_serial; | ||
96 | X509_ALGOR *digest_alg; | ||
97 | STACK_OF(X509_ATTRIBUTE) *auth_attr; /* [ 0 ] */ | ||
98 | X509_ALGOR *digest_enc_alg; | ||
99 | ASN1_OCTET_STRING *enc_digest; | ||
100 | STACK_OF(X509_ATTRIBUTE) *unauth_attr; /* [ 1 ] */ | ||
101 | |||
102 | /* The private key to sign with */ | ||
103 | EVP_PKEY *pkey; | ||
104 | } PKCS7_SIGNER_INFO; | ||
105 | |||
106 | DECLARE_STACK_OF(PKCS7_SIGNER_INFO) | ||
107 | DECLARE_ASN1_SET_OF(PKCS7_SIGNER_INFO) | ||
108 | |||
109 | typedef struct pkcs7_recip_info_st | ||
110 | { | ||
111 | ASN1_INTEGER *version; /* version 0 */ | ||
112 | PKCS7_ISSUER_AND_SERIAL *issuer_and_serial; | ||
113 | X509_ALGOR *key_enc_algor; | ||
114 | ASN1_OCTET_STRING *enc_key; | ||
115 | X509 *cert; /* get the pub-key from this */ | ||
116 | } PKCS7_RECIP_INFO; | ||
117 | |||
118 | DECLARE_STACK_OF(PKCS7_RECIP_INFO) | ||
119 | DECLARE_ASN1_SET_OF(PKCS7_RECIP_INFO) | ||
120 | |||
121 | typedef struct pkcs7_signed_st | ||
122 | { | ||
123 | ASN1_INTEGER *version; /* version 1 */ | ||
124 | STACK_OF(X509_ALGOR) *md_algs; /* md used */ | ||
125 | STACK_OF(X509) *cert; /* [ 0 ] */ | ||
126 | STACK_OF(X509_CRL) *crl; /* [ 1 ] */ | ||
127 | STACK_OF(PKCS7_SIGNER_INFO) *signer_info; | ||
128 | |||
129 | struct pkcs7_st *contents; | ||
130 | } PKCS7_SIGNED; | ||
131 | /* The above structure is very very similar to PKCS7_SIGN_ENVELOPE. | ||
132 | * How about merging the two */ | ||
133 | |||
134 | typedef struct pkcs7_enc_content_st | ||
135 | { | ||
136 | ASN1_OBJECT *content_type; | ||
137 | X509_ALGOR *algorithm; | ||
138 | ASN1_OCTET_STRING *enc_data; /* [ 0 ] */ | ||
139 | const EVP_CIPHER *cipher; | ||
140 | } PKCS7_ENC_CONTENT; | ||
141 | |||
142 | typedef struct pkcs7_enveloped_st | ||
143 | { | ||
144 | ASN1_INTEGER *version; /* version 0 */ | ||
145 | STACK_OF(PKCS7_RECIP_INFO) *recipientinfo; | ||
146 | PKCS7_ENC_CONTENT *enc_data; | ||
147 | } PKCS7_ENVELOPE; | ||
148 | |||
149 | typedef struct pkcs7_signedandenveloped_st | ||
150 | { | ||
151 | ASN1_INTEGER *version; /* version 1 */ | ||
152 | STACK_OF(X509_ALGOR) *md_algs; /* md used */ | ||
153 | STACK_OF(X509) *cert; /* [ 0 ] */ | ||
154 | STACK_OF(X509_CRL) *crl; /* [ 1 ] */ | ||
155 | STACK_OF(PKCS7_SIGNER_INFO) *signer_info; | ||
156 | |||
157 | PKCS7_ENC_CONTENT *enc_data; | ||
158 | STACK_OF(PKCS7_RECIP_INFO) *recipientinfo; | ||
159 | } PKCS7_SIGN_ENVELOPE; | ||
160 | |||
161 | typedef struct pkcs7_digest_st | ||
162 | { | ||
163 | ASN1_INTEGER *version; /* version 0 */ | ||
164 | X509_ALGOR *md; /* md used */ | ||
165 | struct pkcs7_st *contents; | ||
166 | ASN1_OCTET_STRING *digest; | ||
167 | } PKCS7_DIGEST; | ||
168 | |||
169 | typedef struct pkcs7_encrypted_st | ||
170 | { | ||
171 | ASN1_INTEGER *version; /* version 0 */ | ||
172 | PKCS7_ENC_CONTENT *enc_data; | ||
173 | } PKCS7_ENCRYPT; | ||
174 | |||
175 | typedef struct pkcs7_st | ||
176 | { | ||
177 | /* The following is non NULL if it contains ASN1 encoding of | ||
178 | * this structure */ | ||
179 | unsigned char *asn1; | ||
180 | long length; | ||
181 | |||
182 | #define PKCS7_S_HEADER 0 | ||
183 | #define PKCS7_S_BODY 1 | ||
184 | #define PKCS7_S_TAIL 2 | ||
185 | int state; /* used during processing */ | ||
186 | |||
187 | int detached; | ||
188 | |||
189 | ASN1_OBJECT *type; | ||
190 | /* content as defined by the type */ | ||
191 | /* all encryption/message digests are applied to the 'contents', | ||
192 | * leaving out the 'type' field. */ | ||
193 | union { | ||
194 | char *ptr; | ||
195 | |||
196 | /* NID_pkcs7_data */ | ||
197 | ASN1_OCTET_STRING *data; | ||
198 | |||
199 | /* NID_pkcs7_signed */ | ||
200 | PKCS7_SIGNED *sign; | ||
201 | |||
202 | /* NID_pkcs7_enveloped */ | ||
203 | PKCS7_ENVELOPE *enveloped; | ||
204 | |||
205 | /* NID_pkcs7_signedAndEnveloped */ | ||
206 | PKCS7_SIGN_ENVELOPE *signed_and_enveloped; | ||
207 | |||
208 | /* NID_pkcs7_digest */ | ||
209 | PKCS7_DIGEST *digest; | ||
210 | |||
211 | /* NID_pkcs7_encrypted */ | ||
212 | PKCS7_ENCRYPT *encrypted; | ||
213 | |||
214 | /* Anything else */ | ||
215 | ASN1_TYPE *other; | ||
216 | } d; | ||
217 | } PKCS7; | ||
218 | |||
219 | DECLARE_STACK_OF(PKCS7) | ||
220 | DECLARE_ASN1_SET_OF(PKCS7) | ||
221 | DECLARE_PKCS12_STACK_OF(PKCS7) | ||
222 | |||
223 | #define PKCS7_OP_SET_DETACHED_SIGNATURE 1 | ||
224 | #define PKCS7_OP_GET_DETACHED_SIGNATURE 2 | ||
225 | |||
226 | #define PKCS7_get_signed_attributes(si) ((si)->auth_attr) | ||
227 | #define PKCS7_get_attributes(si) ((si)->unauth_attr) | ||
228 | |||
229 | #define PKCS7_type_is_signed(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signed) | ||
230 | #define PKCS7_type_is_encrypted(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted) | ||
231 | #define PKCS7_type_is_enveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_enveloped) | ||
232 | #define PKCS7_type_is_signedAndEnveloped(a) \ | ||
233 | (OBJ_obj2nid((a)->type) == NID_pkcs7_signedAndEnveloped) | ||
234 | #define PKCS7_type_is_data(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_data) | ||
235 | |||
236 | #define PKCS7_set_detached(p,v) \ | ||
237 | PKCS7_ctrl(p,PKCS7_OP_SET_DETACHED_SIGNATURE,v,NULL) | ||
238 | #define PKCS7_get_detached(p) \ | ||
239 | PKCS7_ctrl(p,PKCS7_OP_GET_DETACHED_SIGNATURE,0,NULL) | ||
240 | |||
241 | #define PKCS7_is_detached(p7) (PKCS7_type_is_signed(p7) && PKCS7_get_detached(p7)) | ||
242 | |||
243 | #ifdef SSLEAY_MACROS | ||
244 | #ifndef PKCS7_ISSUER_AND_SERIAL_digest | ||
245 | #define PKCS7_ISSUER_AND_SERIAL_digest(data,type,md,len) \ | ||
246 | ASN1_digest((int (*)())i2d_PKCS7_ISSUER_AND_SERIAL,type,\ | ||
247 | (char *)data,md,len) | ||
248 | #endif | ||
249 | #endif | ||
250 | |||
251 | /* S/MIME related flags */ | ||
252 | |||
253 | #define PKCS7_TEXT 0x1 | ||
254 | #define PKCS7_NOCERTS 0x2 | ||
255 | #define PKCS7_NOSIGS 0x4 | ||
256 | #define PKCS7_NOCHAIN 0x8 | ||
257 | #define PKCS7_NOINTERN 0x10 | ||
258 | #define PKCS7_NOVERIFY 0x20 | ||
259 | #define PKCS7_DETACHED 0x40 | ||
260 | #define PKCS7_BINARY 0x80 | ||
261 | #define PKCS7_NOATTR 0x100 | ||
262 | #define PKCS7_NOSMIMECAP 0x200 | ||
263 | #define PKCS7_NOOLDMIMETYPE 0x400 | ||
264 | #define PKCS7_CRLFEOL 0x800 | ||
265 | |||
266 | /* Flags: for compatibility with older code */ | ||
267 | |||
268 | #define SMIME_TEXT PKCS7_TEXT | ||
269 | #define SMIME_NOCERTS PKCS7_NOCERTS | ||
270 | #define SMIME_NOSIGS PKCS7_NOSIGS | ||
271 | #define SMIME_NOCHAIN PKCS7_NOCHAIN | ||
272 | #define SMIME_NOINTERN PKCS7_NOINTERN | ||
273 | #define SMIME_NOVERIFY PKCS7_NOVERIFY | ||
274 | #define SMIME_DETACHED PKCS7_DETACHED | ||
275 | #define SMIME_BINARY PKCS7_BINARY | ||
276 | #define SMIME_NOATTR PKCS7_NOATTR | ||
277 | |||
278 | DECLARE_ASN1_FUNCTIONS(PKCS7_ISSUER_AND_SERIAL) | ||
279 | |||
280 | #ifndef SSLEAY_MACROS | ||
281 | int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,const EVP_MD *type, | ||
282 | unsigned char *md,unsigned int *len); | ||
283 | #ifndef OPENSSL_NO_FP_API | ||
284 | PKCS7 *d2i_PKCS7_fp(FILE *fp,PKCS7 **p7); | ||
285 | int i2d_PKCS7_fp(FILE *fp,PKCS7 *p7); | ||
286 | #endif | ||
287 | PKCS7 *PKCS7_dup(PKCS7 *p7); | ||
288 | PKCS7 *d2i_PKCS7_bio(BIO *bp,PKCS7 **p7); | ||
289 | int i2d_PKCS7_bio(BIO *bp,PKCS7 *p7); | ||
290 | #endif | ||
291 | |||
292 | DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNER_INFO) | ||
293 | DECLARE_ASN1_FUNCTIONS(PKCS7_RECIP_INFO) | ||
294 | DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNED) | ||
295 | DECLARE_ASN1_FUNCTIONS(PKCS7_ENC_CONTENT) | ||
296 | DECLARE_ASN1_FUNCTIONS(PKCS7_ENVELOPE) | ||
297 | DECLARE_ASN1_FUNCTIONS(PKCS7_SIGN_ENVELOPE) | ||
298 | DECLARE_ASN1_FUNCTIONS(PKCS7_DIGEST) | ||
299 | DECLARE_ASN1_FUNCTIONS(PKCS7_ENCRYPT) | ||
300 | DECLARE_ASN1_FUNCTIONS(PKCS7) | ||
301 | |||
302 | DECLARE_ASN1_ITEM(PKCS7_ATTR_SIGN) | ||
303 | DECLARE_ASN1_ITEM(PKCS7_ATTR_VERIFY) | ||
304 | |||
305 | |||
306 | long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg); | ||
307 | |||
308 | int PKCS7_set_type(PKCS7 *p7, int type); | ||
309 | int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data); | ||
310 | int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey, | ||
311 | const EVP_MD *dgst); | ||
312 | int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *p7i); | ||
313 | int PKCS7_add_certificate(PKCS7 *p7, X509 *x509); | ||
314 | int PKCS7_add_crl(PKCS7 *p7, X509_CRL *x509); | ||
315 | int PKCS7_content_new(PKCS7 *p7, int nid); | ||
316 | int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, | ||
317 | BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si); | ||
318 | int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si, | ||
319 | X509 *x509); | ||
320 | |||
321 | BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio); | ||
322 | int PKCS7_dataFinal(PKCS7 *p7, BIO *bio); | ||
323 | BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert); | ||
324 | |||
325 | |||
326 | PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509, | ||
327 | EVP_PKEY *pkey, const EVP_MD *dgst); | ||
328 | X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si); | ||
329 | STACK_OF(PKCS7_SIGNER_INFO) *PKCS7_get_signer_info(PKCS7 *p7); | ||
330 | |||
331 | PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509); | ||
332 | int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri); | ||
333 | int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509); | ||
334 | int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher); | ||
335 | |||
336 | PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx); | ||
337 | ASN1_OCTET_STRING *PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk); | ||
338 | int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si,int nid,int type, | ||
339 | void *data); | ||
340 | int PKCS7_add_attribute (PKCS7_SIGNER_INFO *p7si, int nid, int atrtype, | ||
341 | void *value); | ||
342 | ASN1_TYPE *PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid); | ||
343 | ASN1_TYPE *PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid); | ||
344 | int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si, | ||
345 | STACK_OF(X509_ATTRIBUTE) *sk); | ||
346 | int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si,STACK_OF(X509_ATTRIBUTE) *sk); | ||
347 | |||
348 | |||
349 | PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs, | ||
350 | BIO *data, int flags); | ||
351 | int PKCS7_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store, | ||
352 | BIO *indata, BIO *out, int flags); | ||
353 | STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, int flags); | ||
354 | PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, const EVP_CIPHER *cipher, | ||
355 | int flags); | ||
356 | int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags); | ||
357 | |||
358 | int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si, | ||
359 | STACK_OF(X509_ALGOR) *cap); | ||
360 | STACK_OF(X509_ALGOR) *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si); | ||
361 | int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) *sk, int nid, int arg); | ||
362 | |||
363 | int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags); | ||
364 | PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont); | ||
365 | int SMIME_crlf_copy(BIO *in, BIO *out, int flags); | ||
366 | int SMIME_text(BIO *in, BIO *out); | ||
367 | |||
368 | /* BEGIN ERROR CODES */ | ||
369 | /* The following lines are auto generated by the script mkerr.pl. Any changes | ||
370 | * made after this point may be overwritten when the script is next run. | ||
371 | */ | ||
372 | void ERR_load_PKCS7_strings(void); | ||
373 | |||
374 | /* Error codes for the PKCS7 functions. */ | ||
375 | |||
376 | /* Function codes. */ | ||
377 | #define PKCS7_F_B64_READ_PKCS7 120 | ||
378 | #define PKCS7_F_B64_WRITE_PKCS7 121 | ||
379 | #define PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP 118 | ||
380 | #define PKCS7_F_PKCS7_ADD_CERTIFICATE 100 | ||
381 | #define PKCS7_F_PKCS7_ADD_CRL 101 | ||
382 | #define PKCS7_F_PKCS7_ADD_RECIPIENT_INFO 102 | ||
383 | #define PKCS7_F_PKCS7_ADD_SIGNER 103 | ||
384 | #define PKCS7_F_PKCS7_CTRL 104 | ||
385 | #define PKCS7_F_PKCS7_DATADECODE 112 | ||
386 | #define PKCS7_F_PKCS7_DATAINIT 105 | ||
387 | #define PKCS7_F_PKCS7_DATASIGN 106 | ||
388 | #define PKCS7_F_PKCS7_DATAVERIFY 107 | ||
389 | #define PKCS7_F_PKCS7_DECRYPT 114 | ||
390 | #define PKCS7_F_PKCS7_ENCRYPT 115 | ||
391 | #define PKCS7_F_PKCS7_GET0_SIGNERS 124 | ||
392 | #define PKCS7_F_PKCS7_SET_CIPHER 108 | ||
393 | #define PKCS7_F_PKCS7_SET_CONTENT 109 | ||
394 | #define PKCS7_F_PKCS7_SET_TYPE 110 | ||
395 | #define PKCS7_F_PKCS7_SIGN 116 | ||
396 | #define PKCS7_F_PKCS7_SIGNATUREVERIFY 113 | ||
397 | #define PKCS7_F_PKCS7_SIMPLE_SMIMECAP 119 | ||
398 | #define PKCS7_F_PKCS7_VERIFY 117 | ||
399 | #define PKCS7_F_SMIME_READ_PKCS7 122 | ||
400 | #define PKCS7_F_SMIME_TEXT 123 | ||
401 | |||
402 | /* Reason codes. */ | ||
403 | #define PKCS7_R_CERTIFICATE_VERIFY_ERROR 117 | ||
404 | #define PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 144 | ||
405 | #define PKCS7_R_CIPHER_NOT_INITIALIZED 116 | ||
406 | #define PKCS7_R_CONTENT_AND_DATA_PRESENT 118 | ||
407 | #define PKCS7_R_DECODE_ERROR 130 | ||
408 | #define PKCS7_R_DECRYPTED_KEY_IS_WRONG_LENGTH 100 | ||
409 | #define PKCS7_R_DECRYPT_ERROR 119 | ||
410 | #define PKCS7_R_DIGEST_FAILURE 101 | ||
411 | #define PKCS7_R_ERROR_ADDING_RECIPIENT 120 | ||
412 | #define PKCS7_R_ERROR_SETTING_CIPHER 121 | ||
413 | #define PKCS7_R_INVALID_MIME_TYPE 131 | ||
414 | #define PKCS7_R_INVALID_NULL_POINTER 143 | ||
415 | #define PKCS7_R_MIME_NO_CONTENT_TYPE 132 | ||
416 | #define PKCS7_R_MIME_PARSE_ERROR 133 | ||
417 | #define PKCS7_R_MIME_SIG_PARSE_ERROR 134 | ||
418 | #define PKCS7_R_MISSING_CERIPEND_INFO 103 | ||
419 | #define PKCS7_R_NO_CONTENT 122 | ||
420 | #define PKCS7_R_NO_CONTENT_TYPE 135 | ||
421 | #define PKCS7_R_NO_MULTIPART_BODY_FAILURE 136 | ||
422 | #define PKCS7_R_NO_MULTIPART_BOUNDARY 137 | ||
423 | #define PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE 115 | ||
424 | #define PKCS7_R_NO_SIGNATURES_ON_DATA 123 | ||
425 | #define PKCS7_R_NO_SIGNERS 142 | ||
426 | #define PKCS7_R_NO_SIG_CONTENT_TYPE 138 | ||
427 | #define PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE 104 | ||
428 | #define PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR 124 | ||
429 | #define PKCS7_R_PKCS7_DATAFINAL_ERROR 125 | ||
430 | #define PKCS7_R_PKCS7_DATASIGN 126 | ||
431 | #define PKCS7_R_PKCS7_PARSE_ERROR 139 | ||
432 | #define PKCS7_R_PKCS7_SIG_PARSE_ERROR 140 | ||
433 | #define PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 127 | ||
434 | #define PKCS7_R_SIGNATURE_FAILURE 105 | ||
435 | #define PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND 128 | ||
436 | #define PKCS7_R_SIG_INVALID_MIME_TYPE 141 | ||
437 | #define PKCS7_R_SMIME_TEXT_ERROR 129 | ||
438 | #define PKCS7_R_UNABLE_TO_FIND_CERTIFICATE 106 | ||
439 | #define PKCS7_R_UNABLE_TO_FIND_MEM_BIO 107 | ||
440 | #define PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST 108 | ||
441 | #define PKCS7_R_UNKNOWN_DIGEST_TYPE 109 | ||
442 | #define PKCS7_R_UNKNOWN_OPERATION 110 | ||
443 | #define PKCS7_R_UNSUPPORTED_CIPHER_TYPE 111 | ||
444 | #define PKCS7_R_UNSUPPORTED_CONTENT_TYPE 112 | ||
445 | #define PKCS7_R_WRONG_CONTENT_TYPE 113 | ||
446 | #define PKCS7_R_WRONG_PKCS7_TYPE 114 | ||
447 | |||
448 | #ifdef __cplusplus | ||
449 | } | ||
450 | #endif | ||
451 | #endif | ||
diff --git a/src/lib/libcrypto/pkcs7/pkcs7err.c b/src/lib/libcrypto/pkcs7/pkcs7err.c new file mode 100644 index 0000000000..5e51527a40 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/pkcs7err.c | |||
@@ -0,0 +1,160 @@ | |||
1 | /* crypto/pkcs7/pkcs7err.c */ | ||
2 | /* ==================================================================== | ||
3 | * Copyright (c) 1999 The OpenSSL Project. All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * | ||
9 | * 1. Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * | ||
12 | * 2. Redistributions in binary form must reproduce the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer in | ||
14 | * the documentation and/or other materials provided with the | ||
15 | * distribution. | ||
16 | * | ||
17 | * 3. All advertising materials mentioning features or use of this | ||
18 | * software must display the following acknowledgment: | ||
19 | * "This product includes software developed by the OpenSSL Project | ||
20 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
21 | * | ||
22 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
23 | * endorse or promote products derived from this software without | ||
24 | * prior written permission. For written permission, please contact | ||
25 | * openssl-core@OpenSSL.org. | ||
26 | * | ||
27 | * 5. Products derived from this software may not be called "OpenSSL" | ||
28 | * nor may "OpenSSL" appear in their names without prior written | ||
29 | * permission of the OpenSSL Project. | ||
30 | * | ||
31 | * 6. Redistributions of any form whatsoever must retain the following | ||
32 | * acknowledgment: | ||
33 | * "This product includes software developed by the OpenSSL Project | ||
34 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
35 | * | ||
36 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
37 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
38 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
39 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
40 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
41 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
42 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
43 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
44 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
45 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
46 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
47 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
48 | * ==================================================================== | ||
49 | * | ||
50 | * This product includes cryptographic software written by Eric Young | ||
51 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
52 | * Hudson (tjh@cryptsoft.com). | ||
53 | * | ||
54 | */ | ||
55 | |||
56 | /* NOTE: this file was auto generated by the mkerr.pl script: any changes | ||
57 | * made to it will be overwritten when the script next updates this file, | ||
58 | * only reason strings will be preserved. | ||
59 | */ | ||
60 | |||
61 | #include <stdio.h> | ||
62 | #include <openssl/err.h> | ||
63 | #include <openssl/pkcs7.h> | ||
64 | |||
65 | /* BEGIN ERROR CODES */ | ||
66 | #ifndef OPENSSL_NO_ERR | ||
67 | static ERR_STRING_DATA PKCS7_str_functs[]= | ||
68 | { | ||
69 | {ERR_PACK(0,PKCS7_F_B64_READ_PKCS7,0), "B64_READ_PKCS7"}, | ||
70 | {ERR_PACK(0,PKCS7_F_B64_WRITE_PKCS7,0), "B64_WRITE_PKCS7"}, | ||
71 | {ERR_PACK(0,PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP,0), "PKCS7_add_attrib_smimecap"}, | ||
72 | {ERR_PACK(0,PKCS7_F_PKCS7_ADD_CERTIFICATE,0), "PKCS7_add_certificate"}, | ||
73 | {ERR_PACK(0,PKCS7_F_PKCS7_ADD_CRL,0), "PKCS7_add_crl"}, | ||
74 | {ERR_PACK(0,PKCS7_F_PKCS7_ADD_RECIPIENT_INFO,0), "PKCS7_add_recipient_info"}, | ||
75 | {ERR_PACK(0,PKCS7_F_PKCS7_ADD_SIGNER,0), "PKCS7_add_signer"}, | ||
76 | {ERR_PACK(0,PKCS7_F_PKCS7_CTRL,0), "PKCS7_ctrl"}, | ||
77 | {ERR_PACK(0,PKCS7_F_PKCS7_DATADECODE,0), "PKCS7_dataDecode"}, | ||
78 | {ERR_PACK(0,PKCS7_F_PKCS7_DATAINIT,0), "PKCS7_dataInit"}, | ||
79 | {ERR_PACK(0,PKCS7_F_PKCS7_DATASIGN,0), "PKCS7_DATASIGN"}, | ||
80 | {ERR_PACK(0,PKCS7_F_PKCS7_DATAVERIFY,0), "PKCS7_dataVerify"}, | ||
81 | {ERR_PACK(0,PKCS7_F_PKCS7_DECRYPT,0), "PKCS7_decrypt"}, | ||
82 | {ERR_PACK(0,PKCS7_F_PKCS7_ENCRYPT,0), "PKCS7_encrypt"}, | ||
83 | {ERR_PACK(0,PKCS7_F_PKCS7_GET0_SIGNERS,0), "PKCS7_get0_signers"}, | ||
84 | {ERR_PACK(0,PKCS7_F_PKCS7_SET_CIPHER,0), "PKCS7_set_cipher"}, | ||
85 | {ERR_PACK(0,PKCS7_F_PKCS7_SET_CONTENT,0), "PKCS7_set_content"}, | ||
86 | {ERR_PACK(0,PKCS7_F_PKCS7_SET_TYPE,0), "PKCS7_set_type"}, | ||
87 | {ERR_PACK(0,PKCS7_F_PKCS7_SIGN,0), "PKCS7_sign"}, | ||
88 | {ERR_PACK(0,PKCS7_F_PKCS7_SIGNATUREVERIFY,0), "PKCS7_signatureVerify"}, | ||
89 | {ERR_PACK(0,PKCS7_F_PKCS7_SIMPLE_SMIMECAP,0), "PKCS7_simple_smimecap"}, | ||
90 | {ERR_PACK(0,PKCS7_F_PKCS7_VERIFY,0), "PKCS7_verify"}, | ||
91 | {ERR_PACK(0,PKCS7_F_SMIME_READ_PKCS7,0), "SMIME_read_PKCS7"}, | ||
92 | {ERR_PACK(0,PKCS7_F_SMIME_TEXT,0), "SMIME_text"}, | ||
93 | {0,NULL} | ||
94 | }; | ||
95 | |||
96 | static ERR_STRING_DATA PKCS7_str_reasons[]= | ||
97 | { | ||
98 | {PKCS7_R_CERTIFICATE_VERIFY_ERROR ,"certificate verify error"}, | ||
99 | {PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER ,"cipher has no object identifier"}, | ||
100 | {PKCS7_R_CIPHER_NOT_INITIALIZED ,"cipher not initialized"}, | ||
101 | {PKCS7_R_CONTENT_AND_DATA_PRESENT ,"content and data present"}, | ||
102 | {PKCS7_R_DECODE_ERROR ,"decode error"}, | ||
103 | {PKCS7_R_DECRYPTED_KEY_IS_WRONG_LENGTH ,"decrypted key is wrong length"}, | ||
104 | {PKCS7_R_DECRYPT_ERROR ,"decrypt error"}, | ||
105 | {PKCS7_R_DIGEST_FAILURE ,"digest failure"}, | ||
106 | {PKCS7_R_ERROR_ADDING_RECIPIENT ,"error adding recipient"}, | ||
107 | {PKCS7_R_ERROR_SETTING_CIPHER ,"error setting cipher"}, | ||
108 | {PKCS7_R_INVALID_MIME_TYPE ,"invalid mime type"}, | ||
109 | {PKCS7_R_INVALID_NULL_POINTER ,"invalid null pointer"}, | ||
110 | {PKCS7_R_MIME_NO_CONTENT_TYPE ,"mime no content type"}, | ||
111 | {PKCS7_R_MIME_PARSE_ERROR ,"mime parse error"}, | ||
112 | {PKCS7_R_MIME_SIG_PARSE_ERROR ,"mime sig parse error"}, | ||
113 | {PKCS7_R_MISSING_CERIPEND_INFO ,"missing ceripend info"}, | ||
114 | {PKCS7_R_NO_CONTENT ,"no content"}, | ||
115 | {PKCS7_R_NO_CONTENT_TYPE ,"no content type"}, | ||
116 | {PKCS7_R_NO_MULTIPART_BODY_FAILURE ,"no multipart body failure"}, | ||
117 | {PKCS7_R_NO_MULTIPART_BOUNDARY ,"no multipart boundary"}, | ||
118 | {PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE,"no recipient matches certificate"}, | ||
119 | {PKCS7_R_NO_SIGNATURES_ON_DATA ,"no signatures on data"}, | ||
120 | {PKCS7_R_NO_SIGNERS ,"no signers"}, | ||
121 | {PKCS7_R_NO_SIG_CONTENT_TYPE ,"no sig content type"}, | ||
122 | {PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE,"operation not supported on this type"}, | ||
123 | {PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR ,"pkcs7 add signature error"}, | ||
124 | {PKCS7_R_PKCS7_DATAFINAL_ERROR ,"pkcs7 datafinal error"}, | ||
125 | {PKCS7_R_PKCS7_DATASIGN ,"pkcs7 datasign"}, | ||
126 | {PKCS7_R_PKCS7_PARSE_ERROR ,"pkcs7 parse error"}, | ||
127 | {PKCS7_R_PKCS7_SIG_PARSE_ERROR ,"pkcs7 sig parse error"}, | ||
128 | {PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE,"private key does not match certificate"}, | ||
129 | {PKCS7_R_SIGNATURE_FAILURE ,"signature failure"}, | ||
130 | {PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND ,"signer certificate not found"}, | ||
131 | {PKCS7_R_SIG_INVALID_MIME_TYPE ,"sig invalid mime type"}, | ||
132 | {PKCS7_R_SMIME_TEXT_ERROR ,"smime text error"}, | ||
133 | {PKCS7_R_UNABLE_TO_FIND_CERTIFICATE ,"unable to find certificate"}, | ||
134 | {PKCS7_R_UNABLE_TO_FIND_MEM_BIO ,"unable to find mem bio"}, | ||
135 | {PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST ,"unable to find message digest"}, | ||
136 | {PKCS7_R_UNKNOWN_DIGEST_TYPE ,"unknown digest type"}, | ||
137 | {PKCS7_R_UNKNOWN_OPERATION ,"unknown operation"}, | ||
138 | {PKCS7_R_UNSUPPORTED_CIPHER_TYPE ,"unsupported cipher type"}, | ||
139 | {PKCS7_R_UNSUPPORTED_CONTENT_TYPE ,"unsupported content type"}, | ||
140 | {PKCS7_R_WRONG_CONTENT_TYPE ,"wrong content type"}, | ||
141 | {PKCS7_R_WRONG_PKCS7_TYPE ,"wrong pkcs7 type"}, | ||
142 | {0,NULL} | ||
143 | }; | ||
144 | |||
145 | #endif | ||
146 | |||
147 | void ERR_load_PKCS7_strings(void) | ||
148 | { | ||
149 | static int init=1; | ||
150 | |||
151 | if (init) | ||
152 | { | ||
153 | init=0; | ||
154 | #ifndef OPENSSL_NO_ERR | ||
155 | ERR_load_strings(ERR_LIB_PKCS7,PKCS7_str_functs); | ||
156 | ERR_load_strings(ERR_LIB_PKCS7,PKCS7_str_reasons); | ||
157 | #endif | ||
158 | |||
159 | } | ||
160 | } | ||
diff --git a/src/lib/libcrypto/pkcs7/server.pem b/src/lib/libcrypto/pkcs7/server.pem new file mode 100644 index 0000000000..750aac2094 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/server.pem | |||
@@ -0,0 +1,24 @@ | |||
1 | issuer= /C=AU/ST=Queensland/O=CryptSoft Pty Ltd/CN=Test CA (1024 bit) | ||
2 | subject=/C=AU/ST=Queensland/O=CryptSoft Pty Ltd/CN=Server test cert (512 bit) | ||
3 | -----BEGIN CERTIFICATE----- | ||
4 | MIIB6TCCAVICAQAwDQYJKoZIhvcNAQEEBQAwWzELMAkGA1UEBhMCQVUxEzARBgNV | ||
5 | BAgTClF1ZWVuc2xhbmQxGjAYBgNVBAoTEUNyeXB0U29mdCBQdHkgTHRkMRswGQYD | ||
6 | VQQDExJUZXN0IENBICgxMDI0IGJpdCkwHhcNOTcwNjA5MTM1NzQ2WhcNOTgwNjA5 | ||
7 | MTM1NzQ2WjBjMQswCQYDVQQGEwJBVTETMBEGA1UECBMKUXVlZW5zbGFuZDEaMBgG | ||
8 | A1UEChMRQ3J5cHRTb2Z0IFB0eSBMdGQxIzAhBgNVBAMTGlNlcnZlciB0ZXN0IGNl | ||
9 | cnQgKDUxMiBiaXQpMFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJ+zw4Qnlf8SMVIP | ||
10 | Fe9GEcStgOY2Ww/dgNdhjeD8ckUJNP5VZkVDTGiXav6ooKXfX3j/7tdkuD8Ey2// | ||
11 | Kv7+ue0CAwEAATANBgkqhkiG9w0BAQQFAAOBgQB4TMR2CvacKE9wAsu9jyCX8YiW | ||
12 | mgCM+YoP6kt4Zkj2z5IRfm7WrycKsnpnOR+tGeqAjkCeZ6/36o9l91RvPnN1VJ/i | ||
13 | xQv2df0KFeMr00IkDdTNAdIWqFkSsZTAY2QAdgenb7MB1joejquYzO2DQIO7+wpH | ||
14 | irObpESxAZLySCmPPg== | ||
15 | -----END CERTIFICATE----- | ||
16 | -----BEGIN RSA PRIVATE KEY----- | ||
17 | MIIBPAIBAAJBAJ+zw4Qnlf8SMVIPFe9GEcStgOY2Ww/dgNdhjeD8ckUJNP5VZkVD | ||
18 | TGiXav6ooKXfX3j/7tdkuD8Ey2//Kv7+ue0CAwEAAQJAN6W31vDEP2DjdqhzCDDu | ||
19 | OA4NACqoiFqyblo7yc2tM4h4xMbC3Yx5UKMN9ZkCtX0gzrz6DyF47bdKcWBzNWCj | ||
20 | gQIhANEoojVt7hq+SQ6MCN6FTAysGgQf56Q3TYoJMoWvdiXVAiEAw3e3rc+VJpOz | ||
21 | rHuDo6bgpjUAAXM+v3fcpsfZSNO6V7kCIQCtbVjanpUwvZkMI9by02oUk9taki3b | ||
22 | PzPfAfNPYAbCJQIhAJXNQDWyqwn/lGmR11cqY2y9nZ1+5w3yHGatLrcDnQHxAiEA | ||
23 | vnlEGo8K85u+KwIOimM48ZG8oTk7iFdkqLJR1utT3aU= | ||
24 | -----END RSA PRIVATE KEY----- | ||
diff --git a/src/lib/libcrypto/pkcs7/sign.c b/src/lib/libcrypto/pkcs7/sign.c new file mode 100644 index 0000000000..8b59885f7e --- /dev/null +++ b/src/lib/libcrypto/pkcs7/sign.c | |||
@@ -0,0 +1,154 @@ | |||
1 | /* crypto/pkcs7/sign.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 | #include <stdio.h> | ||
59 | #include <string.h> | ||
60 | #include <openssl/bio.h> | ||
61 | #include <openssl/x509.h> | ||
62 | #include <openssl/pem.h> | ||
63 | #include <openssl/err.h> | ||
64 | |||
65 | int main(argc,argv) | ||
66 | int argc; | ||
67 | char *argv[]; | ||
68 | { | ||
69 | X509 *x509; | ||
70 | EVP_PKEY *pkey; | ||
71 | PKCS7 *p7; | ||
72 | PKCS7_SIGNER_INFO *si; | ||
73 | BIO *in; | ||
74 | BIO *data,*p7bio; | ||
75 | char buf[1024*4]; | ||
76 | int i; | ||
77 | int nodetach=0; | ||
78 | |||
79 | #ifndef OPENSSL_NO_MD2 | ||
80 | EVP_add_digest(EVP_md2()); | ||
81 | #endif | ||
82 | #ifndef OPENSSL_NO_MD5 | ||
83 | EVP_add_digest(EVP_md5()); | ||
84 | #endif | ||
85 | #ifndef OPENSSL_NO_SHA1 | ||
86 | EVP_add_digest(EVP_sha1()); | ||
87 | #endif | ||
88 | #ifndef OPENSSL_NO_MDC2 | ||
89 | EVP_add_digest(EVP_mdc2()); | ||
90 | #endif | ||
91 | |||
92 | data=BIO_new(BIO_s_file()); | ||
93 | again: | ||
94 | if (argc > 1) | ||
95 | { | ||
96 | if (strcmp(argv[1],"-nd") == 0) | ||
97 | { | ||
98 | nodetach=1; | ||
99 | argv++; argc--; | ||
100 | goto again; | ||
101 | } | ||
102 | if (!BIO_read_filename(data,argv[1])) | ||
103 | goto err; | ||
104 | } | ||
105 | else | ||
106 | BIO_set_fp(data,stdin,BIO_NOCLOSE); | ||
107 | |||
108 | if ((in=BIO_new_file("server.pem","r")) == NULL) goto err; | ||
109 | if ((x509=PEM_read_bio_X509(in,NULL,NULL,NULL)) == NULL) goto err; | ||
110 | BIO_reset(in); | ||
111 | if ((pkey=PEM_read_bio_PrivateKey(in,NULL,NULL,NULL)) == NULL) goto err; | ||
112 | BIO_free(in); | ||
113 | |||
114 | p7=PKCS7_new(); | ||
115 | PKCS7_set_type(p7,NID_pkcs7_signed); | ||
116 | |||
117 | si=PKCS7_add_signature(p7,x509,pkey,EVP_sha1()); | ||
118 | if (si == NULL) goto err; | ||
119 | |||
120 | /* If you do this then you get signing time automatically added */ | ||
121 | PKCS7_add_signed_attribute(si, NID_pkcs9_contentType, V_ASN1_OBJECT, | ||
122 | OBJ_nid2obj(NID_pkcs7_data)); | ||
123 | |||
124 | /* we may want to add more */ | ||
125 | PKCS7_add_certificate(p7,x509); | ||
126 | |||
127 | /* Set the content of the signed to 'data' */ | ||
128 | PKCS7_content_new(p7,NID_pkcs7_data); | ||
129 | |||
130 | if (!nodetach) | ||
131 | PKCS7_set_detached(p7,1); | ||
132 | |||
133 | if ((p7bio=PKCS7_dataInit(p7,NULL)) == NULL) goto err; | ||
134 | |||
135 | for (;;) | ||
136 | { | ||
137 | i=BIO_read(data,buf,sizeof(buf)); | ||
138 | if (i <= 0) break; | ||
139 | BIO_write(p7bio,buf,i); | ||
140 | } | ||
141 | |||
142 | if (!PKCS7_dataFinal(p7,p7bio)) goto err; | ||
143 | BIO_free(p7bio); | ||
144 | |||
145 | PEM_write_PKCS7(stdout,p7); | ||
146 | PKCS7_free(p7); | ||
147 | |||
148 | exit(0); | ||
149 | err: | ||
150 | ERR_load_crypto_strings(); | ||
151 | ERR_print_errors_fp(stderr); | ||
152 | exit(1); | ||
153 | } | ||
154 | |||
diff --git a/src/lib/libcrypto/pkcs7/t/3des.pem b/src/lib/libcrypto/pkcs7/t/3des.pem new file mode 100644 index 0000000000..b2b5081a10 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/3des.pem | |||
@@ -0,0 +1,16 @@ | |||
1 | -----BEGIN PKCS7----- | ||
2 | MIAGCSqGSIb3DQEHA6CAMIACAQAxggHmMIHwAgEAMIGZMIGSMQswCQYDVQQGEwJBVTETMBEG | ||
3 | A1UECBMKUXVlZW5zbGFuZDERMA8GA1UEBxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29m | ||
4 | dCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNUUkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQD | ||
5 | ExJERU1PIFpFUk8gVkFMVUUgQ0ECAgR+MA0GCSqGSIb3DQEBAQUABEC2vXI1xQDW6lUHM3zQ | ||
6 | /9uBEBOO5A3TtkrklAXq7v01gsIC21t52qSk36REXY+slhNZ0OQ349tgkTsoETHFLoEwMIHw | ||
7 | AgEAMIGZMIGSMQswCQYDVQQGEwJBVTETMBEGA1UECBMKUXVlZW5zbGFuZDERMA8GA1UEBxMI | ||
8 | QnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29mdCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNU | ||
9 | UkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQDExJERU1PIFpFUk8gVkFMVUUgQ0ECAgR9MA0G | ||
10 | CSqGSIb3DQEBAQUABEB8ujxbabxXUYJhopuDm3oDq4JNqX6Io4p3ro+ShqfIndsXTZ1v5a2N | ||
11 | WtLLCWlHn/habjBwZ/DgQgcKASbZ7QxNMIAGCSqGSIb3DQEHATAaBggqhkiG9w0DAjAOAgIA | ||
12 | oAQIbsL5v1wX98KggAQoAaJ4WHm68fXY1WE5OIjfVBIDpO1K+i8dmKhjnAjrjoyZ9Bwc8rDL | ||
13 | lgQg4CXb805h5xl+GfvSwUaHJayte1m2mcOhs3J2YyqbQ+MEIMIiJQccmhO3oDKm36CFvYR8 | ||
14 | 5PjpclVcZyX2ngbwPFMnBAgy0clOAE6UKAAAAAAAAAAAAAA= | ||
15 | -----END PKCS7----- | ||
16 | |||
diff --git a/src/lib/libcrypto/pkcs7/t/3dess.pem b/src/lib/libcrypto/pkcs7/t/3dess.pem new file mode 100644 index 0000000000..23f013516a --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/3dess.pem | |||
@@ -0,0 +1,32 @@ | |||
1 | -----BEGIN PKCS7----- | ||
2 | MIIGHgYJKoZIhvcNAQcCoIIGDzCCBgsCAQExCzAJBgUrDgMCGgUAMAsGCSqGSIb3DQEHAaCC | ||
3 | BGswggJTMIIB/aADAgECAgIEfjANBgkqhkiG9w0BAQQFADCBkjELMAkGA1UEBhMCQVUxEzAR | ||
4 | BgNVBAgTClF1ZWVuc2xhbmQxETAPBgNVBAcTCEJyaXNiYW5lMRowGAYDVQQKExFDcnlwdHNv | ||
5 | ZnQgUHR5IEx0ZDEiMCAGA1UECxMZREVNT05TVFJBVElPTiBBTkQgVEVTVElORzEbMBkGA1UE | ||
6 | AxMSREVNTyBaRVJPIFZBTFVFIENBMB4XDTk4MDUxMzA2MjY1NloXDTAwMDUxMjA2MjY1Nlow | ||
7 | gaUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpRdWVlbnNsYW5kMREwDwYDVQQHEwhCcmlzYmFu | ||
8 | ZTEaMBgGA1UEChMRQ3J5cHRzb2Z0IFB0eSBMdGQxEjAQBgNVBAsTCVNNSU1FIDAwMzEZMBcG | ||
9 | A1UEAxMQQW5nZWxhIHZhbiBMZWVudDEjMCEGCSqGSIb3DQEJARYUYW5nZWxhQGNyeXB0c29m | ||
10 | dC5jb20wXDANBgkqhkiG9w0BAQEFAANLADBIAkEAuC3+7dAb2LhuO7gt2cTM8vsNjhG5JfDh | ||
11 | hX1Vl/wVGbKEEj0MA6vWEolvefQlxB+EzwCtR0YZ7eEC/T/4JoCyeQIDAQABoygwJjAkBglg | ||
12 | hkgBhvhCAQ0EFxYVR2VuZXJhdGVkIHdpdGggU1NMZWF5MA0GCSqGSIb3DQEBBAUAA0EAUnSP | ||
13 | igs6TMFISTjw8cBtJYb98czgAVkVFjKyJQwYMH8FbDnCyx6NocM555nsyDstaw8fKR11Khds | ||
14 | syd3ikkrhDCCAhAwggG6AgEDMA0GCSqGSIb3DQEBBAUAMIGSMQswCQYDVQQGEwJBVTETMBEG | ||
15 | A1UECBMKUXVlZW5zbGFuZDERMA8GA1UEBxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29m | ||
16 | dCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNUUkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQD | ||
17 | ExJERU1PIFpFUk8gVkFMVUUgQ0EwHhcNOTgwMzAzMDc0MTMyWhcNMDgwMjI5MDc0MTMyWjCB | ||
18 | kjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClF1ZWVuc2xhbmQxETAPBgNVBAcTCEJyaXNiYW5l | ||
19 | MRowGAYDVQQKExFDcnlwdHNvZnQgUHR5IEx0ZDEiMCAGA1UECxMZREVNT05TVFJBVElPTiBB | ||
20 | TkQgVEVTVElORzEbMBkGA1UEAxMSREVNTyBaRVJPIFZBTFVFIENBMFwwDQYJKoZIhvcNAQEB | ||
21 | BQADSwAwSAJBAL+0E2fLej3FSCwe2A2iRnMuC3z12qHIp6Ky1wo2zZcxft7AI+RfkrWrSGtf | ||
22 | mfzBEuPrLdfulncC5Y1pNcM8RTUCAwEAATANBgkqhkiG9w0BAQQFAANBAGSbLMphL6F5pp3s | ||
23 | 8o0Xyh86FHFdpVOwYx09ELLkuG17V/P9pgIc0Eo/gDMbN+KT3IdgECf8S//pCRA6RrNjcXIx | ||
24 | ggF7MIIBdwIBATCBmTCBkjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClF1ZWVuc2xhbmQxETAP | ||
25 | BgNVBAcTCEJyaXNiYW5lMRowGAYDVQQKExFDcnlwdHNvZnQgUHR5IEx0ZDEiMCAGA1UECxMZ | ||
26 | REVNT05TVFJBVElPTiBBTkQgVEVTVElORzEbMBkGA1UEAxMSREVNTyBaRVJPIFZBTFVFIENB | ||
27 | AgIEfjAJBgUrDgMCGgUAoHowGAYJKoZIhvcNAQkDMQsGCSqGSIb3DQEHATAbBgkqhkiG9w0B | ||
28 | CQ8xDjAMMAoGCCqGSIb3DQMHMBwGCSqGSIb3DQEJBTEPFw05ODA1MTQwMzM5MzdaMCMGCSqG | ||
29 | SIb3DQEJBDEWBBQstNMnSV26ba8PapQEDhO21yNFrjANBgkqhkiG9w0BAQEFAARAW9Xb9YXv | ||
30 | BfcNkutgFX9Gr8iXhBVsNtGEVrjrpkQwpKa7jHI8SjAlLhk/4RFwDHf+ISB9Np3Z1WDWnLcA | ||
31 | 9CWR6g== | ||
32 | -----END PKCS7----- | ||
diff --git a/src/lib/libcrypto/pkcs7/t/c.pem b/src/lib/libcrypto/pkcs7/t/c.pem new file mode 100644 index 0000000000..a4b55e321a --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/c.pem | |||
@@ -0,0 +1,48 @@ | |||
1 | issuer :/C=AU/SP=Queensland/L=Brisbane/O=Cryptsoft Pty Ltd/OU=DEMONSTRATION AND TESTING/CN=DEMO ZERO VALUE CA | ||
2 | subject:/C=AU/SP=Queensland/L=Brisbane/O=Cryptsoft Pty Ltd/OU=SMIME 003/CN=Information/Email=info@cryptsoft.com | ||
3 | serial :047D | ||
4 | |||
5 | Certificate: | ||
6 | Data: | ||
7 | Version: 3 (0x2) | ||
8 | Serial Number: 1149 (0x47d) | ||
9 | Signature Algorithm: md5withRSAEncryption | ||
10 | Issuer: C=AU, SP=Queensland, L=Brisbane, O=Cryptsoft Pty Ltd, OU=DEMONSTRATION AND TESTING, CN=DEMO ZERO VALUE CA | ||
11 | Validity | ||
12 | Not Before: May 13 05:40:58 1998 GMT | ||
13 | Not After : May 12 05:40:58 2000 GMT | ||
14 | Subject: C=AU, SP=Queensland, L=Brisbane, O=Cryptsoft Pty Ltd, OU=SMIME 003, CN=Information/Email=info@cryptsoft.com | ||
15 | Subject Public Key Info: | ||
16 | Public Key Algorithm: rsaEncryption | ||
17 | Modulus: | ||
18 | 00:ad:e7:23:89:ee:0d:87:b7:9c:32:44:4b:95:81: | ||
19 | 73:dd:22:80:4b:2d:c5:60:b8:fe:1e:18:63:ef:dc: | ||
20 | 89:89:22:df:95:3c:7a:db:3d:9a:06:a8:08:d6:29: | ||
21 | fd:ef:41:09:91:ed:bc:ad:98:f9:f6:28:90:62:6f: | ||
22 | e7:e7:0c:4d:0b | ||
23 | Exponent: 65537 (0x10001) | ||
24 | X509v3 extensions: | ||
25 | Netscape Comment: | ||
26 | Generated with SSLeay | ||
27 | Signature Algorithm: md5withRSAEncryption | ||
28 | 52:15:ea:88:f4:f0:f9:0b:ef:ce:d5:f8:83:40:61:16:5e:55: | ||
29 | f9:ce:2d:d1:8b:31:5c:03:c6:2d:10:7c:61:d5:5c:0a:42:97: | ||
30 | d1:fd:65:b6:b6:84:a5:39:ec:46:ec:fc:e0:0d:d9:22:da:1b: | ||
31 | 50:74:ad:92:cb:4e:90:e5:fa:7d | ||
32 | |||
33 | -----BEGIN CERTIFICATE----- | ||
34 | MIICTDCCAfagAwIBAgICBH0wDQYJKoZIhvcNAQEEBQAwgZIxCzAJBgNVBAYTAkFV | ||
35 | MRMwEQYDVQQIEwpRdWVlbnNsYW5kMREwDwYDVQQHEwhCcmlzYmFuZTEaMBgGA1UE | ||
36 | ChMRQ3J5cHRzb2Z0IFB0eSBMdGQxIjAgBgNVBAsTGURFTU9OU1RSQVRJT04gQU5E | ||
37 | IFRFU1RJTkcxGzAZBgNVBAMTEkRFTU8gWkVSTyBWQUxVRSBDQTAeFw05ODA1MTMw | ||
38 | NTQwNThaFw0wMDA1MTIwNTQwNThaMIGeMQswCQYDVQQGEwJBVTETMBEGA1UECBMK | ||
39 | UXVlZW5zbGFuZDERMA8GA1UEBxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29m | ||
40 | dCBQdHkgTHRkMRIwEAYDVQQLEwlTTUlNRSAwMDMxFDASBgNVBAMTC0luZm9ybWF0 | ||
41 | aW9uMSEwHwYJKoZIhvcNAQkBFhJpbmZvQGNyeXB0c29mdC5jb20wXDANBgkqhkiG | ||
42 | 9w0BAQEFAANLADBIAkEArecjie4Nh7ecMkRLlYFz3SKASy3FYLj+Hhhj79yJiSLf | ||
43 | lTx62z2aBqgI1in970EJke28rZj59iiQYm/n5wxNCwIDAQABoygwJjAkBglghkgB | ||
44 | hvhCAQ0EFxYVR2VuZXJhdGVkIHdpdGggU1NMZWF5MA0GCSqGSIb3DQEBBAUAA0EA | ||
45 | UhXqiPTw+QvvztX4g0BhFl5V+c4t0YsxXAPGLRB8YdVcCkKX0f1ltraEpTnsRuz8 | ||
46 | 4A3ZItobUHStkstOkOX6fQ== | ||
47 | -----END CERTIFICATE----- | ||
48 | |||
diff --git a/src/lib/libcrypto/pkcs7/t/ff b/src/lib/libcrypto/pkcs7/t/ff new file mode 100644 index 0000000000..23f013516a --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/ff | |||
@@ -0,0 +1,32 @@ | |||
1 | -----BEGIN PKCS7----- | ||
2 | MIIGHgYJKoZIhvcNAQcCoIIGDzCCBgsCAQExCzAJBgUrDgMCGgUAMAsGCSqGSIb3DQEHAaCC | ||
3 | BGswggJTMIIB/aADAgECAgIEfjANBgkqhkiG9w0BAQQFADCBkjELMAkGA1UEBhMCQVUxEzAR | ||
4 | BgNVBAgTClF1ZWVuc2xhbmQxETAPBgNVBAcTCEJyaXNiYW5lMRowGAYDVQQKExFDcnlwdHNv | ||
5 | ZnQgUHR5IEx0ZDEiMCAGA1UECxMZREVNT05TVFJBVElPTiBBTkQgVEVTVElORzEbMBkGA1UE | ||
6 | AxMSREVNTyBaRVJPIFZBTFVFIENBMB4XDTk4MDUxMzA2MjY1NloXDTAwMDUxMjA2MjY1Nlow | ||
7 | gaUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpRdWVlbnNsYW5kMREwDwYDVQQHEwhCcmlzYmFu | ||
8 | ZTEaMBgGA1UEChMRQ3J5cHRzb2Z0IFB0eSBMdGQxEjAQBgNVBAsTCVNNSU1FIDAwMzEZMBcG | ||
9 | A1UEAxMQQW5nZWxhIHZhbiBMZWVudDEjMCEGCSqGSIb3DQEJARYUYW5nZWxhQGNyeXB0c29m | ||
10 | dC5jb20wXDANBgkqhkiG9w0BAQEFAANLADBIAkEAuC3+7dAb2LhuO7gt2cTM8vsNjhG5JfDh | ||
11 | hX1Vl/wVGbKEEj0MA6vWEolvefQlxB+EzwCtR0YZ7eEC/T/4JoCyeQIDAQABoygwJjAkBglg | ||
12 | hkgBhvhCAQ0EFxYVR2VuZXJhdGVkIHdpdGggU1NMZWF5MA0GCSqGSIb3DQEBBAUAA0EAUnSP | ||
13 | igs6TMFISTjw8cBtJYb98czgAVkVFjKyJQwYMH8FbDnCyx6NocM555nsyDstaw8fKR11Khds | ||
14 | syd3ikkrhDCCAhAwggG6AgEDMA0GCSqGSIb3DQEBBAUAMIGSMQswCQYDVQQGEwJBVTETMBEG | ||
15 | A1UECBMKUXVlZW5zbGFuZDERMA8GA1UEBxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29m | ||
16 | dCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNUUkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQD | ||
17 | ExJERU1PIFpFUk8gVkFMVUUgQ0EwHhcNOTgwMzAzMDc0MTMyWhcNMDgwMjI5MDc0MTMyWjCB | ||
18 | kjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClF1ZWVuc2xhbmQxETAPBgNVBAcTCEJyaXNiYW5l | ||
19 | MRowGAYDVQQKExFDcnlwdHNvZnQgUHR5IEx0ZDEiMCAGA1UECxMZREVNT05TVFJBVElPTiBB | ||
20 | TkQgVEVTVElORzEbMBkGA1UEAxMSREVNTyBaRVJPIFZBTFVFIENBMFwwDQYJKoZIhvcNAQEB | ||
21 | BQADSwAwSAJBAL+0E2fLej3FSCwe2A2iRnMuC3z12qHIp6Ky1wo2zZcxft7AI+RfkrWrSGtf | ||
22 | mfzBEuPrLdfulncC5Y1pNcM8RTUCAwEAATANBgkqhkiG9w0BAQQFAANBAGSbLMphL6F5pp3s | ||
23 | 8o0Xyh86FHFdpVOwYx09ELLkuG17V/P9pgIc0Eo/gDMbN+KT3IdgECf8S//pCRA6RrNjcXIx | ||
24 | ggF7MIIBdwIBATCBmTCBkjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClF1ZWVuc2xhbmQxETAP | ||
25 | BgNVBAcTCEJyaXNiYW5lMRowGAYDVQQKExFDcnlwdHNvZnQgUHR5IEx0ZDEiMCAGA1UECxMZ | ||
26 | REVNT05TVFJBVElPTiBBTkQgVEVTVElORzEbMBkGA1UEAxMSREVNTyBaRVJPIFZBTFVFIENB | ||
27 | AgIEfjAJBgUrDgMCGgUAoHowGAYJKoZIhvcNAQkDMQsGCSqGSIb3DQEHATAbBgkqhkiG9w0B | ||
28 | CQ8xDjAMMAoGCCqGSIb3DQMHMBwGCSqGSIb3DQEJBTEPFw05ODA1MTQwMzM5MzdaMCMGCSqG | ||
29 | SIb3DQEJBDEWBBQstNMnSV26ba8PapQEDhO21yNFrjANBgkqhkiG9w0BAQEFAARAW9Xb9YXv | ||
30 | BfcNkutgFX9Gr8iXhBVsNtGEVrjrpkQwpKa7jHI8SjAlLhk/4RFwDHf+ISB9Np3Z1WDWnLcA | ||
31 | 9CWR6g== | ||
32 | -----END PKCS7----- | ||
diff --git a/src/lib/libcrypto/pkcs7/t/msie-e b/src/lib/libcrypto/pkcs7/t/msie-e new file mode 100644 index 0000000000..aafae69fc9 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/msie-e | |||
@@ -0,0 +1,20 @@ | |||
1 | |||
2 | MIAGCSqGSIb3DQEHA6CAMIACAQAxggHCMIHMAgEAMHYwYjERMA8GA1UEBxMISW50ZXJuZXQxFzAV | ||
3 | BgNVBAoTDlZlcmlTaWduLCBJbmMuMTQwMgYDVQQLEytWZXJpU2lnbiBDbGFzcyAxIENBIC0gSW5k | ||
4 | aXZpZHVhbCBTdWJzY3JpYmVyAhBgQJiC3qfbCbjdj5INYLnKMA0GCSqGSIb3DQEBAQUABECMzu8y | ||
5 | wQ/qZbO8cAGMRBF+mPruv3+Dvb9aWNZ2k8njUgqF6mcdhVB2MkGcsG3memRXJBixvMYWVkU3qK4Z | ||
6 | VuKsMIHwAgEAMIGZMIGSMQswCQYDVQQGEwJBVTETMBEGA1UECBMKUXVlZW5zbGFuZDERMA8GA1UE | ||
7 | BxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29mdCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNU | ||
8 | UkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQDExJERU1PIFpFUk8gVkFMVUUgQ0ECAgRuMA0GCSqG | ||
9 | SIb3DQEBAQUABEBcWwYFHJbJGhiztt7lzue3Lc9CH5WAbyR+2BZ3uv+JxZfRs1PuaWPOwRa0Vgs3 | ||
10 | YwSJoRfxQj2Gk0wFqG1qt6d1MIAGCSqGSIb3DQEHATAaBggqhkiG9w0DAjAOAgIAoAQI8vRlP/Nx | ||
11 | 2iSggASCAZhR5srxyspy7DfomRJ9ff8eMCtaNwEoEx7G25PZRonC57hBvGoScLtEPU3Wp9FEbPN7 | ||
12 | oJESeC+AqMTyTLNy8aQsyC5s53E9UkoIvg62ekYZBbXZqXsrxx4PhiiX3NH8GVh42phB0Chjw0nK | ||
13 | HZeRDmxGY3Cmk+J+l0uVKxbNIfJIKOguLBnhqmnKH/PrnzDt591u0ULy2aTLqRm+4/1Yat/QPb6J | ||
14 | eoKGwNPBbS9ogBdrCNCp9ZFg3Xar2AtQHzyTQIfYeH3SRQUpKmRm5U5o9p5emgEdT+ZfJm/J4tSH | ||
15 | OmbgAFsbHQakA4MBZ4J5qfDJhOA2g5lWk1hIeu5Dn/AaLRZd0yz3oY0Ieo/erPWx/bCqtBzYbMe9 | ||
16 | qSFTedKlbc9EGe3opOTdBZVzK8KH3w3zsy5luxKdOUG59YYb5F1IZiWGiDyuo/HuacX+griu5LeD | ||
17 | bEzOtZnko+TZXvWIko30fD79j3T4MRRhWXbgj2HKza+4vJ0mzcC/1+GPsJjAEAA/JgIEDU4w6/DI | ||
18 | /HQHhLAO3G+9xKD7MvmrzkoAAAAAAAAAAAAA | ||
19 | |||
20 | |||
diff --git a/src/lib/libcrypto/pkcs7/t/msie-e.pem b/src/lib/libcrypto/pkcs7/t/msie-e.pem new file mode 100644 index 0000000000..a2a5e24e74 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/msie-e.pem | |||
@@ -0,0 +1,22 @@ | |||
1 | -----BEGIN PKCS7----- | ||
2 | MIAGCSqGSIb3DQEHA6CAMIIDkAIBADGCAcIwgcwCAQAwdjBiMREwDwYDVQQHEwhJ | ||
3 | bnRlcm5ldDEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xNDAyBgNVBAsTK1ZlcmlT | ||
4 | aWduIENsYXNzIDEgQ0EgLSBJbmRpdmlkdWFsIFN1YnNjcmliZXICEGBAmILep9sJ | ||
5 | uN2Pkg1gucowDQYJKoZIhvcNAQEBBQAEQIzO7zLBD+pls7xwAYxEEX6Y+u6/f4O9 | ||
6 | v1pY1naTyeNSCoXqZx2FUHYyQZywbeZ6ZFckGLG8xhZWRTeorhlW4qwwgfACAQAw | ||
7 | gZkwgZIxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpRdWVlbnNsYW5kMREwDwYDVQQH | ||
8 | EwhCcmlzYmFuZTEaMBgGA1UEChMRQ3J5cHRzb2Z0IFB0eSBMdGQxIjAgBgNVBAsT | ||
9 | GURFTU9OU1RSQVRJT04gQU5EIFRFU1RJTkcxGzAZBgNVBAMTEkRFTU8gWkVSTyBW | ||
10 | QUxVRSBDQQICBG4wDQYJKoZIhvcNAQEBBQAEQFxbBgUclskaGLO23uXO57ctz0If | ||
11 | lYBvJH7YFne6/4nFl9GzU+5pY87BFrRWCzdjBImhF/FCPYaTTAWobWq3p3UwggHD | ||
12 | BgkqhkiG9w0BBwEwGgYIKoZIhvcNAwIwDgICAKAECPL0ZT/zcdokgIIBmFHmyvHK | ||
13 | ynLsN+iZEn19/x4wK1o3ASgTHsbbk9lGicLnuEG8ahJwu0Q9Tdan0URs83ugkRJ4 | ||
14 | L4CoxPJMs3LxpCzILmzncT1SSgi+DrZ6RhkFtdmpeyvHHg+GKJfc0fwZWHjamEHQ | ||
15 | KGPDScodl5EObEZjcKaT4n6XS5UrFs0h8kgo6C4sGeGqacof8+ufMO3n3W7RQvLZ | ||
16 | pMupGb7j/Vhq39A9vol6gobA08FtL2iAF2sI0Kn1kWDddqvYC1AfPJNAh9h4fdJF | ||
17 | BSkqZGblTmj2nl6aAR1P5l8mb8ni1Ic6ZuAAWxsdBqQDgwFngnmp8MmE4DaDmVaT | ||
18 | WEh67kOf8BotFl3TLPehjQh6j96s9bH9sKq0HNhsx72pIVN50qVtz0QZ7eik5N0F | ||
19 | lXMrwoffDfOzLmW7Ep05Qbn1hhvkXUhmJYaIPK6j8e5pxf6CuK7kt4NsTM61meSj | ||
20 | 5Nle9YiSjfR8Pv2PdPgxFGFZduCPYcrNr7i8nSbNwL/X4Y+wmMAQAD8mAgQNTjDr | ||
21 | 8Mj8dAeEsA7cb73EoPsy+avOSgAAAAA= | ||
22 | -----END PKCS7----- | ||
diff --git a/src/lib/libcrypto/pkcs7/t/msie-enc-01 b/src/lib/libcrypto/pkcs7/t/msie-enc-01 new file mode 100644 index 0000000000..2c93ab6462 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/msie-enc-01 | |||
@@ -0,0 +1,62 @@ | |||
1 | |||
2 | MIAGCSqGSIb3DQEHA6CAMIACAQAxgfMwgfACAQAwgZkwgZIxCzAJBgNVBAYTAkFVMRMwEQYD | ||
3 | VQQIEwpRdWVlbnNsYW5kMREwDwYDVQQHEwhCcmlzYmFuZTEaMBgGA1UEChMRQ3J5cHRzb2Z0 | ||
4 | IFB0eSBMdGQxIjAgBgNVBAsTGURFTU9OU1RSQVRJT04gQU5EIFRFU1RJTkcxGzAZBgNVBAMT | ||
5 | EkRFTU8gWkVSTyBWQUxVRSBDQQICBG4wDQYJKoZIhvcNAQEBBQAEQKvMaW8xh6oF/X+CJivz | ||
6 | IZV7yHxlp4O3NHQtWG0A8MOZB+CtKlU7/6g5e/a9Du/TOqxRMqtYRp63pa2Q/mM4IYMwgAYJ | ||
7 | KoZIhvcNAQcBMBoGCCqGSIb3DQMCMA4CAgCgBAifz6RvzOPYlKCABIGwxtGA/FLBBRs1wbBP | ||
8 | gDCbSG0yCwjJNsFg89/k6xuXo8c5YTwsw8+XlIVq03navpew6XxxzY090rD2OJ0t6HA6GqrI | ||
9 | pd8WiSh/Atqn0yfLFmkLqgIAPRfzxUxqUocxLpQsLIFp2YNUGE+yps+UZmIjw/WHfdqrcWTm | ||
10 | STSvKuy3UkIJZCkGDBpTvqk4BFaHh4oTXEpgpNY+GKxjf9TDN9GQPqQZR7sgQki4t2g4/Saq | ||
11 | Kl4EMISgluk6swdND0tiHY7v5d6YR29ePCl2/STJ98eJpWkEEC22GNNvOy7ru/Rv2He4MgQg | ||
12 | optd7sk9MMd9xhJppg7CcH/yDx//HrtgpOcWmn6VxpgECFqon4uXkQtIBIH4PaNclFn7/hLx | ||
13 | Pw2VmBGaC0SYF3U1jyN96EBxdjqy8Aa6ByMXYDW5BcfqniD5mYXfw+b81lh1kutxaPaV4YJ9 | ||
14 | ZlRUW752N7VHo/fG0/fukoe5W9a8kIhgLpygllb/GP4oSF4wM6n1/OgRzZj2IWFiobKO4d/t | ||
15 | Mnh+C+PoEVAuFZcxQwi9GqvsK5OoIjVwNx0XcVSOl1TTYS9SwC7ugMBCab73JiruC24pL78Y | ||
16 | M+NaIpIQ3On4DokJA2ZHtjBjZIxF4tKA144RvFN6pBd6TVE5XM6KD/Vh9bjSmujtEAfdQ3Te | ||
17 | dvKJsbZuu0stErbvWcRy11I328l557EECAJT7d44OJ3rBBBj6bnnx6dDU2SRqp2CEoQaBAhK | ||
18 | RBuyhNxkygQIOY9/NhwqAJAECOvX0Zd0DqgoBAjobPpMHhVV3gQQWLU2vEoZ51BwzxdzCmxO | ||
19 | wwQI4oKfudaNqoAESKzBNAqv5kGumHOlMKsRfrs7jZCcSaOuEj97pYx08FLEgF23cav39MOQ | ||
20 | NUEM1dNU+EYslL4o3RoSHRjUgPU+2t9c0prS9A/bPARIEOP94PynaTNxwHi3VTK7SzuQmgzA | ||
21 | 4n942E9joSiqsQPlsKAb3sPUaLC3SuUxSjNBgfpvD0bmrA/5h+WZoYXvIogFpwjkSmnFBEie | ||
22 | 0lh5Ov1aRrvCw5/j3Q/W/4ZtN5U+aeVBJMtA8n0Mxd5kPxHbNVh4oGprZ6wEegV8ht3voyZa | ||
23 | mZ5Cyxc8ffMYnM/JJI6/oEYEUEMyyiS5FnYyvxKzfMtyn2lZ2st9nZGNNgMc9N62r5HgNbdD | ||
24 | FHuRdKKzV+8kQfuMc3mOPpK1t9TFY+QgrxiB5p6S7VooI97YtP3PbfknszCEBEh4PdXYbbaR | ||
25 | 3AacN3Q5kYYmWsq3WW6xgrg0mmEGosGvwSQxBBuiXZrxScCa4ivEq05UZwyShePvKduOvnUE | ||
26 | 2zDO6IXFLZxhTZAESEm9/FovLgGAiJ7iMGmYvsISLJScwG4n+wrSaQNQXizs9N3ykys54wBN | ||
27 | d/+BQ4F7pncHhDQ2Dyt5MekB8Y8iNOocUTFCu524vQRIaWCXmXP3vU7D21dp0XnAMzRQJ565 | ||
28 | JV3aHRoY7XDa4LePa7PP9ywyafOE5yCW7ndqx3J+2JhTDvSFsW8/q3H3iyeFhykuJVS6BFDK | ||
29 | 6CmKbnyyjOfE2iLGJmTFa905V2KrVDCmlEu/xyGMs80yTyZC+ySzM83FMVvLEQmSzcTNUZVp | ||
30 | DfA1kNXbXkPouBXXT6g8r8JCRljaKKABmgRIlMheOJQRUUU4cgvhMreXPayhq5Ao4VMSCkA5 | ||
31 | hYRCBczm4Di/MMohF0SxIsdRY6gY9CPnrBXAsY6h1RbR7Tw0iQZmeXi52DCiBEj0by+SYMAa | ||
32 | 9z0CReIzl8JLL6EVIFz8kFxlkGWjr4dnOzhhPOq/mCpp0WxbavDfdhE87MdXJZBnLwoT62QG | ||
33 | 955HlAoEQBOGJbcESCgd5XSirZ9Y3AbCfuKOqoMBvEUGn+w/pMaqnGvnr5FZhuBDKrhRXqtx | ||
34 | QsxA//drGUxsrZOuSL/0+fbvo7n2h1Z8Ny86jOvVZAQIAjw2l1Yc5RAESNc9i3I8pKEOVQf/ | ||
35 | UBczJ0NR9aTEF80dRg2lpXwD0ho4N0AvSiVbgxC7cPZHQwIqvq9LHRUs/4n+Vu3SVYU3cAxo | ||
36 | lUTiCGUSlARIF+TD57SI5+RI+MNtnD9rs4E1ml51YoHGWFj3UPriDmY0FKEwIgqtMXMY3fZ9 | ||
37 | Kq8d83bjDzxwbDX7WwR7KbSeJWT42pCz7kM+BEjjPsOnZHuusXT3x2rrsBnYtYsbt98mSFiS | ||
38 | KzTtFmXfkOBbCQdit1P76QnYJ1aXMGs6zP6GypQTadK/zYWvlm38QkVwueaJ0woESKW2pqKA | ||
39 | 70h2UMDHOrpepU1lj0YMzmotDHSTU3L909VvUMNg9uqfrQ6mSkb9j5Tl8oF2otOw5EzA1Yda | ||
40 | KPmgsv62RWLYl80wXQRQwG0e/mgG75jp9lOhJdVXqcYbQpS9viwVaVkwH+69mu/bQI4gjoEs | ||
41 | UYX6O71Re2z+cYhcm9UrK+DXuSFBXQOIlAFxKMW4B0apd6fU84FsZLMESOorXE5OE0A2B2ji | ||
42 | J8QI0Exk4hUvWrMNJfUZwFyS7E05xV9ORuX1xmsKqkT4tVR5Nqln4vhvAY860VBoloz0CDkd | ||
43 | 8seSBEjeMgRI9FvpYuflIeHg9urkwp6N+1f0DrJJhJY9ZQ0HTQhziJmIfvbEjNqCl7hEC28+ | ||
44 | F8I5tuViLgfSwcFFCvnS6WFoN4X6QdFdqMCbBEjdlI1c+IQGA/IuTDMJYCuQ/v+8BG5ZeWVH | ||
45 | icPZmXfRat9eFK1dGKAJef6+Tf9HPuDjSpDyffrifsp7Dc34lmm7GN1+ON3ZMtwEUNm6epb8 | ||
46 | 1RKWjoI7jIKUV/M2p/0eeGSqs4b06KF/VR6dBwsJVL5DpnTsp3MV4j/CAOlRdSPZ5++tsKbM | ||
47 | aplk+ceqQtpEFz1MYTtVV4+rlrWaBEA1okJyNZ5/tNOwM7B+XfOZ0xw+uyVi9v4byTZM2Qds | ||
48 | J+d3YGYLAugTGHISLqQEerD8/gGK+/SL06b2gNedXPHtBAiBKX+Mdy3wFQQIqE9gVgvrFNUE | ||
49 | CKKoTFoMGqnPBAjDPgLCklNfrwQI3Ek1vSq68w8ECBodu2FOZJVkBAgzwjfSr2N9WQQQTCoQ | ||
50 | KkAbrS9tnjXn1I3+ZwQIrPx3eINo/YUECIeYWCFskxlYBAiDUdvZXwD3vgQIkEyZbbZWbUUE | ||
51 | CH4+odl1Isk3BBj68fkqJ0fKJRWVLWuW/O3VE4BOPKwFlaIECFseVTdDUho8BAj+cOKvV2WA | ||
52 | hgQgaXr+wwq+ItblG0Qxz8IVUXX6PV2mIdHwz4SCCvnCsaIECJhBYxdfLI/XBCDswamPn9MR | ||
53 | yXi2HVQBineV+GtWVkIoZ2dCLFB9mQRMoAQI0nUR5a5AOJoECA+AunKlAlx8BAi5RtFeF4g1 | ||
54 | FQQIz/ie+16LlQcECOmNuVg5DXjMBAjH2nkfpXZgWwQIVdLuO/+kuHAECO/5rEHmyI9vBBD4 | ||
55 | 16BU4Rd3YerDQnHtrwOQBCCkho1XxK5Maz8KLCNi20wvcGt8wsIXlj2h5q9ITBq7IgQQvKVY | ||
56 | 4OfJ7bKbItP2dylwQgQYPIGxwkkbRXNraONYvN19G8UdF35rFOuIBAjf0sKz/618ZQQIxObr | ||
57 | xJkRe0sECIC+ssnjEb2NBBBI+XM4OntVWGsRV9Td3sFgBAinGwIroo8O0gQQMGAwgc9PaLaG | ||
58 | gBCiwSTrYQQIVHjfCQgOtygEUIoraFoANfhZgIShpOd/RRxFU4/7xZR5tMdGoYz/g0thR0lM | ||
59 | +Hi88FtFD4mAh/Oat4Ri8B7bv04aokjN2UHz6nPbHHjZ8zIqpbYTCy043GNZBAhOqjyB2JbD | ||
60 | NwQoR23XCYD9x6E20ChHJRXmaHwyMdYXKl5CUxypl7ois+sy2D7jDukS3wQIsTyyPgJi0GsA | ||
61 | AAAAAAAAAAAA | ||
62 | |||
diff --git a/src/lib/libcrypto/pkcs7/t/msie-enc-01.pem b/src/lib/libcrypto/pkcs7/t/msie-enc-01.pem new file mode 100644 index 0000000000..9abf00b2f2 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/msie-enc-01.pem | |||
@@ -0,0 +1,66 @@ | |||
1 | -----BEGIN PKCS7----- | ||
2 | MIAGCSqGSIb3DQEHA6CAMIILyAIBADGB8zCB8AIBADCBmTCBkjELMAkGA1UEBhMC | ||
3 | QVUxEzARBgNVBAgTClF1ZWVuc2xhbmQxETAPBgNVBAcTCEJyaXNiYW5lMRowGAYD | ||
4 | VQQKExFDcnlwdHNvZnQgUHR5IEx0ZDEiMCAGA1UECxMZREVNT05TVFJBVElPTiBB | ||
5 | TkQgVEVTVElORzEbMBkGA1UEAxMSREVNTyBaRVJPIFZBTFVFIENBAgIEbjANBgkq | ||
6 | hkiG9w0BAQEFAARAq8xpbzGHqgX9f4ImK/MhlXvIfGWng7c0dC1YbQDww5kH4K0q | ||
7 | VTv/qDl79r0O79M6rFEyq1hGnrelrZD+YzghgzCCCssGCSqGSIb3DQEHATAaBggq | ||
8 | hkiG9w0DAjAOAgIAoAQIn8+kb8zj2JSAggqgxtGA/FLBBRs1wbBPgDCbSG0yCwjJ | ||
9 | NsFg89/k6xuXo8c5YTwsw8+XlIVq03navpew6XxxzY090rD2OJ0t6HA6GqrIpd8W | ||
10 | iSh/Atqn0yfLFmkLqgIAPRfzxUxqUocxLpQsLIFp2YNUGE+yps+UZmIjw/WHfdqr | ||
11 | cWTmSTSvKuy3UkIJZCkGDBpTvqk4BFaHh4oTXEpgpNY+GKxjf9TDN9GQPqQZR7sg | ||
12 | Qki4t2g4/SaqKl6EoJbpOrMHTQ9LYh2O7+XemEdvXjwpdv0kyffHiaVpBBAtthjT | ||
13 | bzsu67v0b9h3uDKim13uyT0wx33GEmmmDsJwf/IPH/8eu2Ck5xaafpXGmFqon4uX | ||
14 | kQtIPaNclFn7/hLxPw2VmBGaC0SYF3U1jyN96EBxdjqy8Aa6ByMXYDW5BcfqniD5 | ||
15 | mYXfw+b81lh1kutxaPaV4YJ9ZlRUW752N7VHo/fG0/fukoe5W9a8kIhgLpygllb/ | ||
16 | GP4oSF4wM6n1/OgRzZj2IWFiobKO4d/tMnh+C+PoEVAuFZcxQwi9GqvsK5OoIjVw | ||
17 | Nx0XcVSOl1TTYS9SwC7ugMBCab73JiruC24pL78YM+NaIpIQ3On4DokJA2ZHtjBj | ||
18 | ZIxF4tKA144RvFN6pBd6TVE5XM6KD/Vh9bjSmujtEAfdQ3TedvKJsbZuu0stErbv | ||
19 | WcRy11I328l557ECU+3eODid62PpuefHp0NTZJGqnYIShBpKRBuyhNxkyjmPfzYc | ||
20 | KgCQ69fRl3QOqCjobPpMHhVV3li1NrxKGedQcM8XcwpsTsPigp+51o2qgKzBNAqv | ||
21 | 5kGumHOlMKsRfrs7jZCcSaOuEj97pYx08FLEgF23cav39MOQNUEM1dNU+EYslL4o | ||
22 | 3RoSHRjUgPU+2t9c0prS9A/bPBDj/eD8p2kzccB4t1Uyu0s7kJoMwOJ/eNhPY6Eo | ||
23 | qrED5bCgG97D1Giwt0rlMUozQYH6bw9G5qwP+YflmaGF7yKIBacI5EppxZ7SWHk6 | ||
24 | /VpGu8LDn+PdD9b/hm03lT5p5UEky0DyfQzF3mQ/Eds1WHigamtnrAR6BXyG3e+j | ||
25 | JlqZnkLLFzx98xicz8kkjr+gRkMyyiS5FnYyvxKzfMtyn2lZ2st9nZGNNgMc9N62 | ||
26 | r5HgNbdDFHuRdKKzV+8kQfuMc3mOPpK1t9TFY+QgrxiB5p6S7VooI97YtP3Pbfkn | ||
27 | szCEeD3V2G22kdwGnDd0OZGGJlrKt1lusYK4NJphBqLBr8EkMQQbol2a8UnAmuIr | ||
28 | xKtOVGcMkoXj7ynbjr51BNswzuiFxS2cYU2QSb38Wi8uAYCInuIwaZi+whIslJzA | ||
29 | bif7CtJpA1BeLOz03fKTKznjAE13/4FDgXumdweENDYPK3kx6QHxjyI06hxRMUK7 | ||
30 | nbi9aWCXmXP3vU7D21dp0XnAMzRQJ565JV3aHRoY7XDa4LePa7PP9ywyafOE5yCW | ||
31 | 7ndqx3J+2JhTDvSFsW8/q3H3iyeFhykuJVS6yugpim58soznxNoixiZkxWvdOVdi | ||
32 | q1QwppRLv8chjLPNMk8mQvskszPNxTFbyxEJks3EzVGVaQ3wNZDV215D6LgV10+o | ||
33 | PK/CQkZY2iigAZqUyF44lBFRRThyC+Eyt5c9rKGrkCjhUxIKQDmFhEIFzObgOL8w | ||
34 | yiEXRLEix1FjqBj0I+esFcCxjqHVFtHtPDSJBmZ5eLnYMKL0by+SYMAa9z0CReIz | ||
35 | l8JLL6EVIFz8kFxlkGWjr4dnOzhhPOq/mCpp0WxbavDfdhE87MdXJZBnLwoT62QG | ||
36 | 955HlAoEQBOGJbcoHeV0oq2fWNwGwn7ijqqDAbxFBp/sP6TGqpxr56+RWYbgQyq4 | ||
37 | UV6rcULMQP/3axlMbK2Trki/9Pn276O59odWfDcvOozr1WQCPDaXVhzlENc9i3I8 | ||
38 | pKEOVQf/UBczJ0NR9aTEF80dRg2lpXwD0ho4N0AvSiVbgxC7cPZHQwIqvq9LHRUs | ||
39 | /4n+Vu3SVYU3cAxolUTiCGUSlBfkw+e0iOfkSPjDbZw/a7OBNZpedWKBxlhY91D6 | ||
40 | 4g5mNBShMCIKrTFzGN32fSqvHfN24w88cGw1+1sEeym0niVk+NqQs+5DPuM+w6dk | ||
41 | e66xdPfHauuwGdi1ixu33yZIWJIrNO0WZd+Q4FsJB2K3U/vpCdgnVpcwazrM/obK | ||
42 | lBNp0r/Nha+WbfxCRXC55onTCqW2pqKA70h2UMDHOrpepU1lj0YMzmotDHSTU3L9 | ||
43 | 09VvUMNg9uqfrQ6mSkb9j5Tl8oF2otOw5EzA1YdaKPmgsv62RWLYl80wXcBtHv5o | ||
44 | Bu+Y6fZToSXVV6nGG0KUvb4sFWlZMB/uvZrv20COII6BLFGF+ju9UXts/nGIXJvV | ||
45 | Kyvg17khQV0DiJQBcSjFuAdGqXen1POBbGSz6itcTk4TQDYHaOInxAjQTGTiFS9a | ||
46 | sw0l9RnAXJLsTTnFX05G5fXGawqqRPi1VHk2qWfi+G8BjzrRUGiWjPQIOR3yx5IE | ||
47 | SN4y9FvpYuflIeHg9urkwp6N+1f0DrJJhJY9ZQ0HTQhziJmIfvbEjNqCl7hEC28+ | ||
48 | F8I5tuViLgfSwcFFCvnS6WFoN4X6QdFdqMCb3ZSNXPiEBgPyLkwzCWArkP7/vARu | ||
49 | WXllR4nD2Zl30WrfXhStXRigCXn+vk3/Rz7g40qQ8n364n7Kew3N+JZpuxjdfjjd | ||
50 | 2TLc2bp6lvzVEpaOgjuMgpRX8zan/R54ZKqzhvTooX9VHp0HCwlUvkOmdOyncxXi | ||
51 | P8IA6VF1I9nn762wpsxqmWT5x6pC2kQXPUxhO1VXj6uWtZo1okJyNZ5/tNOwM7B+ | ||
52 | XfOZ0xw+uyVi9v4byTZM2QdsJ+d3YGYLAugTGHISLqQEerD8/gGK+/SL06b2gNed | ||
53 | XPHtgSl/jHct8BWoT2BWC+sU1aKoTFoMGqnPwz4CwpJTX6/cSTW9KrrzDxodu2FO | ||
54 | ZJVkM8I30q9jfVlMKhAqQButL22eNefUjf5nrPx3eINo/YWHmFghbJMZWINR29lf | ||
55 | APe+kEyZbbZWbUV+PqHZdSLJN/rx+SonR8olFZUta5b87dUTgE48rAWVolseVTdD | ||
56 | Uho8/nDir1dlgIZpev7DCr4i1uUbRDHPwhVRdfo9XaYh0fDPhIIK+cKxophBYxdf | ||
57 | LI/X7MGpj5/TEcl4th1UAYp3lfhrVlZCKGdnQixQfZkETKDSdRHlrkA4mg+AunKl | ||
58 | Alx8uUbRXheINRXP+J77XouVB+mNuVg5DXjMx9p5H6V2YFtV0u47/6S4cO/5rEHm | ||
59 | yI9v+NegVOEXd2Hqw0Jx7a8DkKSGjVfErkxrPwosI2LbTC9wa3zCwheWPaHmr0hM | ||
60 | GrsivKVY4OfJ7bKbItP2dylwQjyBscJJG0Vza2jjWLzdfRvFHRd+axTriN/SwrP/ | ||
61 | rXxlxObrxJkRe0uAvrLJ4xG9jUj5czg6e1VYaxFX1N3ewWCnGwIroo8O0jBgMIHP | ||
62 | T2i2hoAQosEk62FUeN8JCA63KIoraFoANfhZgIShpOd/RRxFU4/7xZR5tMdGoYz/ | ||
63 | g0thR0lM+Hi88FtFD4mAh/Oat4Ri8B7bv04aokjN2UHz6nPbHHjZ8zIqpbYTCy04 | ||
64 | 3GNZTqo8gdiWwzdHbdcJgP3HoTbQKEclFeZofDIx1hcqXkJTHKmXuiKz6zLYPuMO | ||
65 | 6RLfsTyyPgJi0GsAAAAA | ||
66 | -----END PKCS7----- | ||
diff --git a/src/lib/libcrypto/pkcs7/t/msie-enc-02 b/src/lib/libcrypto/pkcs7/t/msie-enc-02 new file mode 100644 index 0000000000..7017055965 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/msie-enc-02 | |||
@@ -0,0 +1,90 @@ | |||
1 | |||
2 | MIAGCSqGSIb3DQEHA6CAMIACAQAxggHCMIHMAgEAMHYwYjERMA8GA1UEBxMISW50ZXJuZXQxFzAV | ||
3 | BgNVBAoTDlZlcmlTaWduLCBJbmMuMTQwMgYDVQQLEytWZXJpU2lnbiBDbGFzcyAxIENBIC0gSW5k | ||
4 | aXZpZHVhbCBTdWJzY3JpYmVyAhBgQJiC3qfbCbjdj5INYLnKMA0GCSqGSIb3DQEBAQUABEACr4tn | ||
5 | kSzvo3aIlHfJLGbfokNCV6FjdDP1vQhL+kdXONqcFCEf9ReETCvaHslIr/Wepc5j2hjZselzgqLn | ||
6 | rM1ZMIHwAgEAMIGZMIGSMQswCQYDVQQGEwJBVTETMBEGA1UECBMKUXVlZW5zbGFuZDERMA8GA1UE | ||
7 | BxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29mdCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNU | ||
8 | UkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQDExJERU1PIFpFUk8gVkFMVUUgQ0ECAgRuMA0GCSqG | ||
9 | SIb3DQEBAQUABEBanBxKOvUoRn3DiFY55lly2TPu2Cv+dI/GLrzW6qvnUMZPWGPGaUlPyWLMZrXJ | ||
10 | xGXZUiRJKTBwDu91fnodUEK9MIAGCSqGSIb3DQEHATAaBggqhkiG9w0DAjAOAgIAoAQImxKZEDWP | ||
11 | EuOggASCBACBi1bX/qc3geqFyfRpX7JyIo/g4CDr62GlwvassAGlIO8zJ5Z/UDIIooeV6QS4D4OW | ||
12 | PymKd0WXhwcJI0yBcJTWEoxND27LM7CWFJpA07AoxVCRHTOPgm794NynLecNUOqVTFyS4CRuLhVG | ||
13 | PAk0nFZG/RE2yMtx4rAkSiVgOexES7wq/xWuoDSSmuTMNQOTbKfkEKqdFLkM/d62gD2wnaph7vKk | ||
14 | PPK82wdZP8rF3nUUC5c4ahbNoa8g+5B3tIF/Jz3ZZK3vGLU0IWO+i7W451dna13MglDDjXOeikNl | ||
15 | XLsQdAVo0nsjfGu+f66besJojPzysNA+IEZl6gNWUetl9lim4SqrxubUExdS2rmXnXXmEuEW/HC7 | ||
16 | dlTAeYq5Clqx5id6slhC2C2oegMww3XH9yxHw6OqzvXY6pVPEScEtBMQLgaKFQT+m2SRtbTVFG7c | ||
17 | QcnUODyVB1IbpQTF1DHeeOX1W/HfpWZym8dzkti6SCyeumHmqO406xDiIMVKtHOqM86nEHuAMZsr | ||
18 | cLy+ey6TEJvR6S4N8QRzng8JJDZDTJXQN6q84aEudsnOrw2KyOVwPpI6ey4qBsHUgQ8kAFy5lsQa | ||
19 | WV45h6exgUwbBcKLgPZGFj+OdD2RKJsTb83/UqbJS5Q/lGXhzBlnaYucyJxEprRxbntmcnOEPFJe | ||
20 | +tRDUwOTd7qlJljdhIJL+uDcooL9Ahgo6Cwep6tduekv2cSEohJeTE8Dvy34YRhMbLvnFNdmnpNy | ||
21 | rNZDYVVxxaKoyd2AfB8NPFZh1VdAYfI3R1QAQ2kXEef5NNIfVQfMzD9akJn4RP+Kv32Qaxm4FrnK | ||
22 | xmwRyGJShavIBc2ax+F1r1+NZXuSBHn5vfoRTxOk0ST4dXsw74dnlYUMRaSu4qqUdM9jsXSyeX4Z | ||
23 | gQgkR2bkaYO6ezFgenFIa7QWVw8rXZAEZ5aibCxbnY1VE41PYIvhlLdbFJhH9gY22s+fFAuwnzyA | ||
24 | SRjC40A9aAEItRlaPStWSGiqlLRgNkBBwdpv2l2YPBd2QzHx6ek6XGrvRJuAC+Nh62rtQKwpNH54 | ||
25 | YAOHW55maBFW2SQ3TF+cZ6NbbqhCmHTyyR7mcSYc9sXSVDWEhYKQ1iyU870zhHWVpvglZizZetJC | ||
26 | ZFjYex3b1ngVdcgargOvpPq9urCKKi2mbkqv/EFpzSWGXkKSpfCG/XfMnEOtkNrB8S06vnk2JcJB | ||
27 | OBqJot+uuSH5hOg0vTpxX2DuONJSiWSWyfRE/lTfJJFXwhod7SXclUyXPeSyibcSic2hVAzDmwjD | ||
28 | 31js/j2k02PI/agPhr3UQ8cMgcNAiaoCKbNaWfn6BGbCAbTchxzUlo2cSJiLlrX2IDZmfXbXmZCo | ||
29 | m1smWIG+BIIEALiuAxDb6dWLAYyVBoN9hYI4AiPeZAY9MtvQ6AV8o2/EFm6PvYGXy3Hei5830CH0 | ||
30 | PBeX7Kdd6ff1y33TW/l5qSkIL1ULTGR7okFfJePHDmq1dFt6/JOMptiQ8WSu7CsJQvZ9VTFXeYFc | ||
31 | ZqCPPZc1NrPegNK70Zf9QxWIbDAevJ5KLBf1c6j8pU2/6LnvDY6VjaTvYSgr7vTR8eVzH4Rm77W0 | ||
32 | iOHxg5VcODv6cGSVyuvbX8UAGo8Cmb58ERDtBDJBQXVpWKLNAuDJ9GX8n2zNkpjZLbPSkcmuhqGa | ||
33 | BJBE/BaCTkUQWlY9dIbRtEnxIU1mfbPPdx1Ppa8DqGDjSOsQdKcKYNNZtayEw++EIpmpdBNsKphC | ||
34 | fB8UEK2Wkk4ZVW+qyGoi/r0MFsvO1NmSOOZ0o/jy/YHmoeURHhPy97AO3eVTkEAa5CfJEJybmo56 | ||
35 | 7CDw/FwoGAUCgsoz7rlxzMudr/IhHIH+APinncxXlHO2ecvHD9i8DaHGA8tVifgsUhqQoZieULut | ||
36 | eF94O5UAxOkv41UZssYTwN4nYrN1QkesZl3BX4ORS4EE30/PQ23ARf3WZptZrCJevGm2ZYzGeh8x | ||
37 | g17mCDfiLO+bff4qP/4mC96Pu4ia6j4to5BwKIJS/+DCuoD8WeSKF4pugXQkMUiHdQnNnVP9Sp2O | ||
38 | /4ly5mO8JzrQC59V2bnTNBqPhpno8kfJvK5TypPSVC+bTzern3rJ6UceB3srcn9zxKx9GdNydJQj | ||
39 | yWjv8ec3n3d1nuQwhz5Q053NBhIjwoGg3Go7LO6i78ZOlpF7dcoAO13NfHLyNjnyHCaiWtVRTct9 | ||
40 | rLf5vN00urSn8YJngHk1eTKK8nHGIcOg6YdYDOD2nE5XwRijKmieG8Xa3eKRzfbL06GrBQENle6J | ||
41 | mC131bp3cRVxpjq+o6RAbGoMm4yICsL4eTarCQrsyHmoPHqr91UHo91avyxU7knWmEhX27ybmsrs | ||
42 | 8aeZwPHixL14TeyhruCqRVvkf1Ks7P+z8MPUboGNqQe2WLN8ktCGEr15O8MJR/em86G03Jfo4oaw | ||
43 | /DVUH5RwLT6acedOGuzMh/2r8BcmemhVQ8/cWvV4YJ0tOW4hzyVHC5hQf8sZ3LzxXLH6Ohnrbprh | ||
44 | xvrdbaSdChWZDDP0bCCbxEhkwuBkBeKZrMbwRTP+TPTPYLVTH/CmKLzKh/114tkGkyO3hHS4qExU | ||
45 | V39F2Sj4mylx+hD0+20D9pntpNi7htccGlOm6yNM69at/3+kLgJJyoIlaxLcCUYHNMifDt+T3p/t | ||
46 | 5U4XmD53uUQ6M8dvj/udqPekNSUfse15yrd9pjOt5PcJuqW28q0sFHf9pHIgz3XZFMe5PD7ppw6r | ||
47 | S+C6Ir4PrYIEggQA7ZDVtiCm+BbtNNB/UJm79/OQ5mp5bTI0kPmDeycaWTa0Ojpum+c/dpG/iJOB | ||
48 | DICj7jHOXSHT7JlGyX6aSFJUltucAnZvwzhPDmdDaIDiKSk85GqgdDWVfGosSCX9Ph/T3WpIxnwf | ||
49 | WSDRtIHkWTjly+pe4yy5K6/XISy/L5Zh/fhiI5fjHjgzmlibs2ru4nVw6hBhUvlSSe2BEs5d9h/y | ||
50 | NH8Wy3qvb2D3jh7hkepFtZJGNTHp8ZUC7Ns2JIpQYObsaxdI65i3mMOu7fRwI+0/4ejsWhP6KCEi | ||
51 | LgwvLg0qM82ma6YB7qHAHboaczRVEffDcJUG4a5uycB0DoZFn+uEaEFyili20hCn4hVfsqUQk2PT | ||
52 | 8Mo1tSl5e30xI1YJZrRgiJm9nHRX6fLizngP+ILJLPHZsPvlSVIfY+/v/FR8feKOjaGhyGF51BAx | ||
53 | aM2NIQ4jMP5/X+U5gQybi0E6u7rroDhaHsKmCMgXqszwXWCpedA/sEbeHpiTC59YlPPSlIOMc9vP | ||
54 | Ko/mQCfWy/9icUaIfKQldvkllUxxNkqu6AbIpHVscbAEzSPs5xbQXU8EZNNCDisFnnpY3nQ3eLnl | ||
55 | m89saTJxRb7NWHRMlmPv7qgD7uMIq3vdOGA7i5wT9MeoNIgK1/DsgH30s6RWjJy4YyyLmRTXPzbj | ||
56 | hbQVpEmiMRbEidIvUx2OjKVxVQIcgtLsa2lvHQ4XL1cpLr5GVtOgy0fMg5OCDUUDsvjgjgLQ3P2U | ||
57 | p2nVY5FM6/QpPc5DTLuuR9ekI2/c9Biz09RtcYDUQK2ajdo8h1IyKqHFoB7h48OXxXKKY94DY0TG | ||
58 | x6PonB/epj8orAw4QKmm5M0vXYwBOqRymCTHTqOJGObdLx1euFFyqguzHJOU2gAGZI0z9Lg1yRuF | ||
59 | yhdPZyuniIcmtLNxRZ1duYHErcAyX56qndmLXt7UVkATai/rIMuoJLfAsUnVuTUS5p7tJM754UZT | ||
60 | 7lTcXvDJgOUNnBRaIcxC3pxvbrYDJ2iFJ72xkxUP2p74gucqg25XnCVmQuLg6zDDxF6CLuw9isxy | ||
61 | Xg4pkneMN//7fpp8GYl9nyZm2yqYYM+jcw0fcVc64L+X4w/gL3H2UMGgxIHSJp7HIG7VKHtXrNyj | ||
62 | dPXXPVUsMsAAimqOr0Lr2sZWirfuivLaPTqhbkvG5PF7K3gT80AOIcd/6EIHBy2hZ7ukfjHmdP4L | ||
63 | yQOhTQklaKzGHI0mypq0uFLWJOUlZnVrMiLP1xrWkpC8Ro9eo6mfjjQ45z8adC43a47klwTEzvod | ||
64 | 3rNEFIGJJUEjAN3mbqie7IxoSJknBBJK0D9lZEQ8lZWlq7vuN8JdqPM6xh155jMVsPwjLK6Tzkj5 | ||
65 | BpRD9Tgm3u6HPQSCBADgkWEN75Mu9TGosXY0xm1k6K6sPv8L949CrLWo4r1I2LA072bTGvQP28Vs | ||
66 | hUA76jgcT1ocC++9PoktIK10YCq5w+FfMAQ04KeCXuAdmiY2iAT4Slea61PMCMta3mVGyLUZCLEm | ||
67 | P+I0UKR5mlO0fGEcjU9j8TmbjZqxNFqloLsU7oSi7Os0EtYHkdAVrExUyOc/ZDie6fBjdLTmLdCm | ||
68 | bE9JNwjlbXypdTZupGgLNhKGDIskUAAMwZYayI6YfSIMkNCeAYTnjOuGZZ1msCXGXsfMBR1sfUIj | ||
69 | 9UeGjwD8gq+UVVHX/oeoH/m0eJ5ppqi3+nUlgc9DvpYsC/Fg0G2KuYb9B+VJ+a4GMzQSPREoFtQp | ||
70 | B9dtLkBb7Ha/hpGWTIdqzW0eAo5llyN8FNvl2Fu2IcLaNmWFO69gLjRKQopp0dvFOuwAVI6fvGDj | ||
71 | p1WigoNbFZl8N+iiWmzKOjoG2ZLbez1clZCms/JPJrXhEMMOxWpVzkQyN336VWHmGgMcjaKCGSeA | ||
72 | 2nnESIGuiCXMrkHlGfabYIsKcHFCo2t13uXyZPf0zSPTkuD0Eh92wqC9pvA3gvrrCUfo9Mn3bs+e | ||
73 | KWKmDlpcs8mDn032oIg+zrQhIduMqXVn3evzeVM3B5MBOGMvg51/SXg7R+MC/463juQQEb9IVe/I | ||
74 | YGnO//oWm9lw/377Af/qH+FnN02obJw1FvesQIs9e5RHNQykKbO+vmVJQl1nd9DZWrHDNO7/80Yz | ||
75 | 2hCm7Tws5nSRN2iFlyRaYJHr7ypxkU2rCak2r6ua7XDwu1qU2RT3+qPjT1RuxQ2oTlHyGkKPMZGC | ||
76 | Rc+CSWz5aeeCmHZVwdb3nC8YpfsujMiYqygLeuQ82pjKuR7DIKGmnfcOLdv5F+Ek2Wyy0D98iSgk | ||
77 | +aoQGYLhL9llU13pn21uRsDY5uGcXiIw1IETFlTdgENEv8futZuJsegrp7fmFXyNoNyFNyypeDrM | ||
78 | 6ZqR4vKxFjg3tKKeVpkw/W4EAklzMxmNiazGNDBHsnYV3rwPlKa+HeeE2YxnsKwGLCNgRYUXTaJk | ||
79 | 461vS160z3dvh/mLfdZ7MYCkmO3bNE3ELUDAw7YQkSuo9ujzdFKte9LC34sjg9fOex3ThAg5Y50n | ||
80 | wYm4zBmGM7yEqL8O6QgnM6tIDFS9XryDaLNzcGhMWqMvhzO6sC/AA2WfLgwS517Cp03IkJQWqG9q | ||
81 | w52+E+GAtpioJfczEhlv9BrhjttdugRSjJrG8SYVYE4zG3Aur5eNBoGaALIOHOtPw8+JovQmIWcF | ||
82 | oaJ/WQuglFrWtew51IK6F8RiHAOBVavZOuZcO7tV+5enVfreOd0rX8ZOy4hYmHhmF1hOrrWOn+Ee | ||
83 | E0SYKonXN01BM9xMBIIBSLCvNAppnGPTUGjwbMJRg1VJ2KMiBWH5oJp8tyfIAxMuWFdtaLYbRSOD | ||
84 | XbOAshPVK8JAY8DQDkzqaCTAkLTfSRAt9yY6SbUpMsRv7xa8nMZNJBJzJT9b/wNjgiOJgaGuJMkV | ||
85 | 2g/DX2jfP3PrMM/Sbnz7edORXHj1Pa5XTT8nG5MS0FuZgvevdq3o/gVVAz+ZCKOH3ShMzZvfp01l | ||
86 | SX5gaJTflmU6cdNwtn2yZ6IScF7OrjUeA9iEoSVR9dQcA+4lB3RAG3LMwcnxXY35D7+PMJzHIZdF | ||
87 | cSnq+n03ACY2/E/T31iijRH29rvYHGI+mP/ieYs45iq4fTWo6i1HofeWLdP0fX7xW3XO0/hWYFiw | ||
88 | BxKu66whAbRhaib3XJNvetVs25ToYXyiDpjG+cd5rCMei8sGQwTBj9Zeh0URoeMW1inTP0JvCmMU | ||
89 | rZgAAAAAAAAAAAAA | ||
90 | |||
diff --git a/src/lib/libcrypto/pkcs7/t/msie-enc-02.pem b/src/lib/libcrypto/pkcs7/t/msie-enc-02.pem new file mode 100644 index 0000000000..279c5d830b --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/msie-enc-02.pem | |||
@@ -0,0 +1,106 @@ | |||
1 | -----BEGIN PKCS7----- | ||
2 | MIAGCSqGSIb3DQEHA6CAMIITQAIBADGCAcIwgcwCAQAwdjBiMREwDwYDVQQHEwhJ | ||
3 | bnRlcm5ldDEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xNDAyBgNVBAsTK1ZlcmlT | ||
4 | aWduIENsYXNzIDEgQ0EgLSBJbmRpdmlkdWFsIFN1YnNjcmliZXICEGBAmILep9sJ | ||
5 | uN2Pkg1gucowDQYJKoZIhvcNAQEBBQAEQAKvi2eRLO+jdoiUd8ksZt+iQ0JXoWN0 | ||
6 | M/W9CEv6R1c42pwUIR/1F4RMK9oeyUiv9Z6lzmPaGNmx6XOCoueszVkwgfACAQAw | ||
7 | gZkwgZIxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpRdWVlbnNsYW5kMREwDwYDVQQH | ||
8 | EwhCcmlzYmFuZTEaMBgGA1UEChMRQ3J5cHRzb2Z0IFB0eSBMdGQxIjAgBgNVBAsT | ||
9 | GURFTU9OU1RSQVRJT04gQU5EIFRFU1RJTkcxGzAZBgNVBAMTEkRFTU8gWkVSTyBW | ||
10 | QUxVRSBDQQICBG4wDQYJKoZIhvcNAQEBBQAEQFqcHEo69ShGfcOIVjnmWXLZM+7Y | ||
11 | K/50j8YuvNbqq+dQxk9YY8ZpSU/JYsxmtcnEZdlSJEkpMHAO73V+eh1QQr0wghFz | ||
12 | BgkqhkiG9w0BBwEwGgYIKoZIhvcNAwIwDgICAKAECJsSmRA1jxLjgIIRSIGLVtf+ | ||
13 | pzeB6oXJ9GlfsnIij+DgIOvrYaXC9qywAaUg7zMnln9QMgiih5XpBLgPg5Y/KYp3 | ||
14 | RZeHBwkjTIFwlNYSjE0PbsszsJYUmkDTsCjFUJEdM4+Cbv3g3Kct5w1Q6pVMXJLg | ||
15 | JG4uFUY8CTScVkb9ETbIy3HisCRKJWA57ERLvCr/Fa6gNJKa5Mw1A5Nsp+QQqp0U | ||
16 | uQz93raAPbCdqmHu8qQ88rzbB1k/ysXedRQLlzhqFs2hryD7kHe0gX8nPdlkre8Y | ||
17 | tTQhY76LtbjnV2drXcyCUMONc56KQ2VcuxB0BWjSeyN8a75/rpt6wmiM/PKw0D4g | ||
18 | RmXqA1ZR62X2WKbhKqvG5tQTF1LauZeddeYS4Rb8cLt2VMB5irkKWrHmJ3qyWELY | ||
19 | Lah6AzDDdcf3LEfDo6rO9djqlU8RJwS0ExAuBooVBP6bZJG1tNUUbtxBydQ4PJUH | ||
20 | UhulBMXUMd545fVb8d+lZnKbx3OS2LpILJ66Yeao7jTrEOIgxUq0c6ozzqcQe4Ax | ||
21 | mytwvL57LpMQm9HpLg3xBHOeDwkkNkNMldA3qrzhoS52yc6vDYrI5XA+kjp7LioG | ||
22 | wdSBDyQAXLmWxBpZXjmHp7GBTBsFwouA9kYWP450PZEomxNvzf9SpslLlD+UZeHM | ||
23 | GWdpi5zInESmtHFue2Zyc4Q8Ul761ENTA5N3uqUmWN2Egkv64Nyigv0CGCjoLB6n | ||
24 | q1256S/ZxISiEl5MTwO/LfhhGExsu+cU12aek3Ks1kNhVXHFoqjJ3YB8Hw08VmHV | ||
25 | V0Bh8jdHVABDaRcR5/k00h9VB8zMP1qQmfhE/4q/fZBrGbgWucrGbBHIYlKFq8gF | ||
26 | zZrH4XWvX41le5IEefm9+hFPE6TRJPh1ezDvh2eVhQxFpK7iqpR0z2OxdLJ5fhmB | ||
27 | CCRHZuRpg7p7MWB6cUhrtBZXDytdkARnlqJsLFudjVUTjU9gi+GUt1sUmEf2Bjba | ||
28 | z58UC7CfPIBJGMLjQD1oAQi1GVo9K1ZIaKqUtGA2QEHB2m/aXZg8F3ZDMfHp6Tpc | ||
29 | au9Em4AL42Hrau1ArCk0fnhgA4dbnmZoEVbZJDdMX5xno1tuqEKYdPLJHuZxJhz2 | ||
30 | xdJUNYSFgpDWLJTzvTOEdZWm+CVmLNl60kJkWNh7HdvWeBV1yBquA6+k+r26sIoq | ||
31 | LaZuSq/8QWnNJYZeQpKl8Ib9d8ycQ62Q2sHxLTq+eTYlwkE4Gomi3665IfmE6DS9 | ||
32 | OnFfYO440lKJZJbJ9ET+VN8kkVfCGh3tJdyVTJc95LKJtxKJzaFUDMObCMPfWOz+ | ||
33 | PaTTY8j9qA+GvdRDxwyBw0CJqgIps1pZ+foEZsIBtNyHHNSWjZxImIuWtfYgNmZ9 | ||
34 | dteZkKibWyZYgb64rgMQ2+nViwGMlQaDfYWCOAIj3mQGPTLb0OgFfKNvxBZuj72B | ||
35 | l8tx3oufN9Ah9DwXl+ynXen39ct901v5eakpCC9VC0xke6JBXyXjxw5qtXRbevyT | ||
36 | jKbYkPFkruwrCUL2fVUxV3mBXGagjz2XNTaz3oDSu9GX/UMViGwwHryeSiwX9XOo | ||
37 | /KVNv+i57w2OlY2k72EoK+700fHlcx+EZu+1tIjh8YOVXDg7+nBklcrr21/FABqP | ||
38 | Apm+fBEQ7QQyQUF1aViizQLgyfRl/J9szZKY2S2z0pHJroahmgSQRPwWgk5FEFpW | ||
39 | PXSG0bRJ8SFNZn2zz3cdT6WvA6hg40jrEHSnCmDTWbWshMPvhCKZqXQTbCqYQnwf | ||
40 | FBCtlpJOGVVvqshqIv69DBbLztTZkjjmdKP48v2B5qHlER4T8vewDt3lU5BAGuQn | ||
41 | yRCcm5qOeuwg8PxcKBgFAoLKM+65cczLna/yIRyB/gD4p53MV5RztnnLxw/YvA2h | ||
42 | xgPLVYn4LFIakKGYnlC7rXhfeDuVAMTpL+NVGbLGE8DeJ2KzdUJHrGZdwV+DkUuB | ||
43 | BN9Pz0NtwEX91mabWawiXrxptmWMxnofMYNe5gg34izvm33+Kj/+Jgvej7uImuo+ | ||
44 | LaOQcCiCUv/gwrqA/FnkiheKboF0JDFIh3UJzZ1T/Uqdjv+JcuZjvCc60AufVdm5 | ||
45 | 0zQaj4aZ6PJHybyuU8qT0lQvm083q596yelHHgd7K3J/c8SsfRnTcnSUI8lo7/Hn | ||
46 | N593dZ7kMIc+UNOdzQYSI8KBoNxqOyzuou/GTpaRe3XKADtdzXxy8jY58hwmolrV | ||
47 | UU3Lfay3+bzdNLq0p/GCZ4B5NXkyivJxxiHDoOmHWAzg9pxOV8EYoyponhvF2t3i | ||
48 | kc32y9OhqwUBDZXuiZgtd9W6d3EVcaY6vqOkQGxqDJuMiArC+Hk2qwkK7Mh5qDx6 | ||
49 | q/dVB6PdWr8sVO5J1phIV9u8m5rK7PGnmcDx4sS9eE3soa7gqkVb5H9SrOz/s/DD | ||
50 | 1G6BjakHtlizfJLQhhK9eTvDCUf3pvOhtNyX6OKGsPw1VB+UcC0+mnHnThrszIf9 | ||
51 | q/AXJnpoVUPP3Fr1eGCdLTluIc8lRwuYUH/LGdy88Vyx+joZ626a4cb63W2knQoV | ||
52 | mQwz9Gwgm8RIZMLgZAXimazG8EUz/kz0z2C1Ux/wpii8yof9deLZBpMjt4R0uKhM | ||
53 | VFd/Rdko+JspcfoQ9PttA/aZ7aTYu4bXHBpTpusjTOvWrf9/pC4CScqCJWsS3AlG | ||
54 | BzTInw7fk96f7eVOF5g+d7lEOjPHb4/7naj3pDUlH7Htecq3faYzreT3CbqltvKt | ||
55 | LBR3/aRyIM912RTHuTw+6acOq0vguiK+D62C7ZDVtiCm+BbtNNB/UJm79/OQ5mp5 | ||
56 | bTI0kPmDeycaWTa0Ojpum+c/dpG/iJOBDICj7jHOXSHT7JlGyX6aSFJUltucAnZv | ||
57 | wzhPDmdDaIDiKSk85GqgdDWVfGosSCX9Ph/T3WpIxnwfWSDRtIHkWTjly+pe4yy5 | ||
58 | K6/XISy/L5Zh/fhiI5fjHjgzmlibs2ru4nVw6hBhUvlSSe2BEs5d9h/yNH8Wy3qv | ||
59 | b2D3jh7hkepFtZJGNTHp8ZUC7Ns2JIpQYObsaxdI65i3mMOu7fRwI+0/4ejsWhP6 | ||
60 | KCEiLgwvLg0qM82ma6YB7qHAHboaczRVEffDcJUG4a5uycB0DoZFn+uEaEFyili2 | ||
61 | 0hCn4hVfsqUQk2PT8Mo1tSl5e30xI1YJZrRgiJm9nHRX6fLizngP+ILJLPHZsPvl | ||
62 | SVIfY+/v/FR8feKOjaGhyGF51BAxaM2NIQ4jMP5/X+U5gQybi0E6u7rroDhaHsKm | ||
63 | CMgXqszwXWCpedA/sEbeHpiTC59YlPPSlIOMc9vPKo/mQCfWy/9icUaIfKQldvkl | ||
64 | lUxxNkqu6AbIpHVscbAEzSPs5xbQXU8EZNNCDisFnnpY3nQ3eLnlm89saTJxRb7N | ||
65 | WHRMlmPv7qgD7uMIq3vdOGA7i5wT9MeoNIgK1/DsgH30s6RWjJy4YyyLmRTXPzbj | ||
66 | hbQVpEmiMRbEidIvUx2OjKVxVQIcgtLsa2lvHQ4XL1cpLr5GVtOgy0fMg5OCDUUD | ||
67 | svjgjgLQ3P2Up2nVY5FM6/QpPc5DTLuuR9ekI2/c9Biz09RtcYDUQK2ajdo8h1Iy | ||
68 | KqHFoB7h48OXxXKKY94DY0TGx6PonB/epj8orAw4QKmm5M0vXYwBOqRymCTHTqOJ | ||
69 | GObdLx1euFFyqguzHJOU2gAGZI0z9Lg1yRuFyhdPZyuniIcmtLNxRZ1duYHErcAy | ||
70 | X56qndmLXt7UVkATai/rIMuoJLfAsUnVuTUS5p7tJM754UZT7lTcXvDJgOUNnBRa | ||
71 | IcxC3pxvbrYDJ2iFJ72xkxUP2p74gucqg25XnCVmQuLg6zDDxF6CLuw9isxyXg4p | ||
72 | kneMN//7fpp8GYl9nyZm2yqYYM+jcw0fcVc64L+X4w/gL3H2UMGgxIHSJp7HIG7V | ||
73 | KHtXrNyjdPXXPVUsMsAAimqOr0Lr2sZWirfuivLaPTqhbkvG5PF7K3gT80AOIcd/ | ||
74 | 6EIHBy2hZ7ukfjHmdP4LyQOhTQklaKzGHI0mypq0uFLWJOUlZnVrMiLP1xrWkpC8 | ||
75 | Ro9eo6mfjjQ45z8adC43a47klwTEzvod3rNEFIGJJUEjAN3mbqie7IxoSJknBBJK | ||
76 | 0D9lZEQ8lZWlq7vuN8JdqPM6xh155jMVsPwjLK6Tzkj5BpRD9Tgm3u6HPeCRYQ3v | ||
77 | ky71MaixdjTGbWTorqw+/wv3j0KstajivUjYsDTvZtMa9A/bxWyFQDvqOBxPWhwL | ||
78 | 770+iS0grXRgKrnD4V8wBDTgp4Je4B2aJjaIBPhKV5rrU8wIy1reZUbItRkIsSY/ | ||
79 | 4jRQpHmaU7R8YRyNT2PxOZuNmrE0WqWguxTuhKLs6zQS1geR0BWsTFTI5z9kOJ7p | ||
80 | 8GN0tOYt0KZsT0k3COVtfKl1Nm6kaAs2EoYMiyRQAAzBlhrIjph9IgyQ0J4BhOeM | ||
81 | 64ZlnWawJcZex8wFHWx9QiP1R4aPAPyCr5RVUdf+h6gf+bR4nmmmqLf6dSWBz0O+ | ||
82 | liwL8WDQbYq5hv0H5Un5rgYzNBI9ESgW1CkH120uQFvsdr+GkZZMh2rNbR4CjmWX | ||
83 | I3wU2+XYW7Yhwto2ZYU7r2AuNEpCimnR28U67ABUjp+8YOOnVaKCg1sVmXw36KJa | ||
84 | bMo6OgbZktt7PVyVkKaz8k8mteEQww7FalXORDI3ffpVYeYaAxyNooIZJ4DaecRI | ||
85 | ga6IJcyuQeUZ9ptgiwpwcUKja3Xe5fJk9/TNI9OS4PQSH3bCoL2m8DeC+usJR+j0 | ||
86 | yfduz54pYqYOWlyzyYOfTfagiD7OtCEh24ypdWfd6/N5UzcHkwE4Yy+DnX9JeDtH | ||
87 | 4wL/jreO5BARv0hV78hgac7/+hab2XD/fvsB/+of4Wc3TahsnDUW96xAiz17lEc1 | ||
88 | DKQps76+ZUlCXWd30NlascM07v/zRjPaEKbtPCzmdJE3aIWXJFpgkevvKnGRTasJ | ||
89 | qTavq5rtcPC7WpTZFPf6o+NPVG7FDahOUfIaQo8xkYJFz4JJbPlp54KYdlXB1vec | ||
90 | Lxil+y6MyJirKAt65DzamMq5HsMgoaad9w4t2/kX4STZbLLQP3yJKCT5qhAZguEv | ||
91 | 2WVTXemfbW5GwNjm4ZxeIjDUgRMWVN2AQ0S/x+61m4mx6Cunt+YVfI2g3IU3LKl4 | ||
92 | OszpmpHi8rEWODe0op5WmTD9bgQCSXMzGY2JrMY0MEeydhXevA+Upr4d54TZjGew | ||
93 | rAYsI2BFhRdNomTjrW9LXrTPd2+H+Yt91nsxgKSY7ds0TcQtQMDDthCRK6j26PN0 | ||
94 | Uq170sLfiyOD1857HdOECDljnSfBibjMGYYzvISovw7pCCczq0gMVL1evINos3Nw | ||
95 | aExaoy+HM7qwL8ADZZ8uDBLnXsKnTciQlBaob2rDnb4T4YC2mKgl9zMSGW/0GuGO | ||
96 | 2126BFKMmsbxJhVgTjMbcC6vl40GgZoAsg4c60/Dz4mi9CYhZwWhon9ZC6CUWta1 | ||
97 | 7DnUgroXxGIcA4FVq9k65lw7u1X7l6dV+t453Stfxk7LiFiYeGYXWE6utY6f4R4T | ||
98 | RJgqidc3TUEz3EywrzQKaZxj01Bo8GzCUYNVSdijIgVh+aCafLcnyAMTLlhXbWi2 | ||
99 | G0Ujg12zgLIT1SvCQGPA0A5M6mgkwJC030kQLfcmOkm1KTLEb+8WvJzGTSQScyU/ | ||
100 | W/8DY4IjiYGhriTJFdoPw19o3z9z6zDP0m58+3nTkVx49T2uV00/JxuTEtBbmYL3 | ||
101 | r3at6P4FVQM/mQijh90oTM2b36dNZUl+YGiU35ZlOnHTcLZ9smeiEnBezq41HgPY | ||
102 | hKElUfXUHAPuJQd0QBtyzMHJ8V2N+Q+/jzCcxyGXRXEp6vp9NwAmNvxP099Yoo0R | ||
103 | 9va72BxiPpj/4nmLOOYquH01qOotR6H3li3T9H1+8Vt1ztP4VmBYsAcSruusIQG0 | ||
104 | YWom91yTb3rVbNuU6GF8og6YxvnHeawjHovLBkMEwY/WXodFEaHjFtYp0z9Cbwpj | ||
105 | FK2YAAAAAA== | ||
106 | -----END PKCS7----- | ||
diff --git a/src/lib/libcrypto/pkcs7/t/msie-s-a-e b/src/lib/libcrypto/pkcs7/t/msie-s-a-e new file mode 100644 index 0000000000..0067794d70 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/msie-s-a-e | |||
@@ -0,0 +1,91 @@ | |||
1 | |||
2 | MIAGCSqGSIb3DQEHA6CAMIACAQAxggHCMIHMAgEAMHYwYjERMA8GA1UEBxMISW50ZXJuZXQxFzAV | ||
3 | BgNVBAoTDlZlcmlTaWduLCBJbmMuMTQwMgYDVQQLEytWZXJpU2lnbiBDbGFzcyAxIENBIC0gSW5k | ||
4 | aXZpZHVhbCBTdWJzY3JpYmVyAhBgQJiC3qfbCbjdj5INYLnKMA0GCSqGSIb3DQEBAQUABECjscaS | ||
5 | G0U299fqiEAgTqTFQBp8Ai6zzjl557cVb3k6z4QZ7CbqBjSXAjLbh5e7S5Hd/FrFcDnxl1Ka06ha | ||
6 | VHGPMIHwAgEAMIGZMIGSMQswCQYDVQQGEwJBVTETMBEGA1UECBMKUXVlZW5zbGFuZDERMA8GA1UE | ||
7 | BxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29mdCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNU | ||
8 | UkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQDExJERU1PIFpFUk8gVkFMVUUgQ0ECAgRuMA0GCSqG | ||
9 | SIb3DQEBAQUABECsyHXZ1xaiv0UQRvOmVYsaF38AL2XX75wxbCsz5/wOg7g3RP4aicZxaR4sBog0 | ||
10 | f2G1o9om/hu+A0rIYF/L4/GUMIAGCSqGSIb3DQEHATAaBggqhkiG9w0DAjAOAgIAoAQIsozQrnwj | ||
11 | cc2ggASCBAAQz/LPoJe/+iYWeTwSebz6Q9UeKZzQ2UWm7GLtEM3s3c9SCvpmkwIRdEhLjWaBJMyI | ||
12 | DiL7t1I1vMf9inB8LXgAcIEYkpNScjS8ERA9Ebb7ieNKSBg7w7B8ATHFxLSlDADqRgoZrB1Ctfgf | ||
13 | ximp3EgxTgnhtyQhZxXW7kBQyFRwumplrJXOp7albP7IothrOKncw30IJT1fwPxWNMItI9juXF0U | ||
14 | CbWVSjPzGBo4+XNXMvUO6MplOQEz/ywEQ9E8OZAQex1Zw9qq5ppsXB2pMsYV5sLJGikukMYKquiz | ||
15 | 3YK+tN6J8ahLcDUs+VGwqvZi17gpBTlbEP+ZmXJpnO63t1yTEB0V5AZcRKWUOhzlCBM5YUagqNoY | ||
16 | cpsmSvOK6bYzkUKOrzWpDCAtGZ/Dvul5dTZZmxs2WpM+iyeHXMxO3huy8K1brPTqt1f1sHhuq1jD | ||
17 | 1eXedaCjIgUW9qV18vNAQCof/Yb6T/1fxztf/jD7pPLQJ+7LJkKCAEHGcaizpoKqhYcttaEhLq1G | ||
18 | O+Ohqf7yFegMdTJ3wwP324w5ZYSU5fLo2Z34/Edf6EGvXyTIqVfAmEBALd6JGVdN5GlYYTxrL+eO | ||
19 | P80Z4ao4YKoxwEmRp5bmQsQ8B29QhOFKmC6eiG5B96qLMtp7Zmu1grDNxTd6OXShWVwYARD0/B1P | ||
20 | Sy0PAfk9Gb4fAkO9fZJDQYZ7s0mM5iOPEeSR7820TolOb+KfRabLA9d714jsc2jEykKlpP66Bh4j | ||
21 | aCsyqJ0uUQcE8SnzrKAqGwgWiCGQpiTa+HBiP6eRlRGOKQj5Y06vcNx6Ija4cGe6+yCN8HV8tCY0 | ||
22 | okZK98NQCl5t79R/ZB2c3NvBJH+/g3ulU48ikT3tVmDxE3mOZofZyGFEM99P+YCMScLDxTl3hzGy | ||
23 | 0YkI8U855P7qOAbcFfh2T5n+LSELwLhbkymEfZT917GWTfmypBWMvJx0WHeDhKwQYPdzbKgWETnc | ||
24 | yeKasaCW+oLdhBwrd6Ws2r4MA8cwiYXDLbwYmCxJA8VF++8kubF2HJOjSyMBS+QT2PSV/0D9UWoi | ||
25 | Vfk7R4OvWBJVvq7nV+lXS0O5igjExxlmx1OaBfg7+Cr/MbK4zVNrKSJn82NnKKt6LC6RaTmvFYay | ||
26 | 0sDFxQ7Xo+Th6tDNKmKWJt6Kegfjc+qTWJTKb3kL+UI8vS0zTLy1+M/rZ4ekos/JiS5rYIcAswvg | ||
27 | 58kBgp/0rc6upBeWjBaK5O0aLAeBQfLulo1axWX04OSVKmYeoAltyR6UO9ME3acurQyg7Ta24yqO | ||
28 | whi/PrIaEiO7dsWvFtzsshVzBLic02NlAkPkMUzliPYnZHWQglDAVxL5K2qhvK1OFCkQpIgBsBDM | ||
29 | 6KYRL/mkBIIEALIl927rIkaN37/BQIcxLcSa05YfC0Hl3mxWESt1A0D4lA37A9S8EbYmDfAYlMc0 | ||
30 | 3HhZGdZEtawfpJFyDHzNZceNWBch6nxeNZCY4YFdsbzuGS0RKpwNA9S/czOJ4p9ymBCxuhGepI3U | ||
31 | PKbC8C749Www1/wMdAot1n+K7M/PBGR8hWmaH5SS7U3yMwAB1fq2NDjx4ur+Um+MclSdN01MDXzG | ||
32 | EO+eAo1pdAY8479234l8dB2YVAhZ1ZlJ4KmbqMKJrGJXnQUEYS6/cTDRjsUocsoW7uGg1ci2GiHa | ||
33 | qjlkfpBfie3SdhFW/K8hwAH0HALs56oFN66wUkP/AaJAPfIUNhR6RpHKzZ9zCC42oB2mNawQRMnF | ||
34 | ETBl1s/SwMxLKRp7jAfKs4NZxSY6I9z/2dTpzS3tsHMjxVDuxkolvRNWBILEMeL1CBvip2HhmoUw | ||
35 | /Sz5NDgyzk1aQLV6DQNJ2RZLMZDRCtSwZSBu6lhhSgTJGazP0+NbqXXC5aQTrqrFIcWyDXz+ADle | ||
36 | kszzYM/gSaQTCALTwfDDaU9Ek3xVgW+XBtExtJ3U+0AN3l0j86rUIdIvp6eWdxWQqv9LtpoorKMD | ||
37 | KfUc5PYV09Z1JgsT4X51Zzq+74l5dz7udIM7UNbdTpmRm9PDj3TUbGCvNR9hqOEGTLbkvb1ZR24a | ||
38 | h6uGRl2znB25IpDAGRhNRb9is/pO2tvHwHTDMOjrgvZG/pNvXgSUxz0pRjUjXIcqBe2X2gcQfeal | ||
39 | r8gY76o83WEGL6ODryV9vTQVHt52+izgpYoBZaVlpgqbZl54c+OE0Zxf9RwXwDbcYu5Ku5E0MPL0 | ||
40 | qUjc0y2+Y6E4P5bAWaZGMGT+ORkyVUzcaWmM/+XlO7PER5wrWlCIMZCX1L/nvioY0q0CKqALn7DJ | ||
41 | QU+qenbwrb6uwS7uNZY6V86s0aDYpU7yRyqxC5SbuyNJb02gdxUCgpIscFaMUjMVRml4M4BIjX/b | ||
42 | U+HgHoVMUm8SnN9gRcT2izPrgOGVcMTJjfenzoCKoCPo9RjgGMctgB4DvKamErNU7OrilIfuoqzE | ||
43 | PNSeP9SPw/zkDmNvMebM499We9CVnsHUWqF00/ZJWoua77+0f1bLS/tmci1JBvIcMo/4SJvgH+KF | ||
44 | o0gijP9gqAPd5iCOnpnJlHUqRIym42SmyKEDuzdSwXKjAR6j7uXda39JyMJr8gGzEsu0jYRkAmj1 | ||
45 | YdiqwKXUcLMkcj1AKeU/PxTUVw0YKsv/rowrPYww3xQUWqNivrXB7GCHE3BzsYNdHsmziaGIXQbA | ||
46 | +EBHdkuKrM8BcC+fxhF/l/KUxngsD1E75IcUv8zFDF+sk4CBYHqks9S4JYlcubuizqsILbdGzIMN | ||
47 | Z7w34k0XT+sEggQAyzr8MHeIJGsT+AYnZr08PeTbyr01JEoT7lPYT6PzX4F63QKKDl+mB+PwLMzY | ||
48 | CXrxZcUmuay6/MV8w/f5T6vQXdoSw5puWodBYwVReYh1IaEN+jiTapm9YBVmcIsJPO6abHowknSV | ||
49 | OWSvST0AtAX57fFOTckm+facfBK9s9T1lUUgF44Bh5e8f9qKqfOV44nqdCOEyUm0Dao497ieN4Eg | ||
50 | XBLNvOZY9+irMiXjp0lcyFvhrJOczfyCr9EiiaiH1TfSzKGKsf2W84iKn/JH6x2eOo7xjwJ40BQD | ||
51 | c6S1cUNEuqBhP6by0FioOXYOKVyifpxk84Eb+F/4CNdTJTvCPwsiegdfsX/Q53DvKVtXp9Ycam5J | ||
52 | TmKRHXK/bMHF4ONv3p/O/kn/BqRx+fbbP2eMX8Z1F/ltHKfp6B+06HljUwQLBJs9XtCfqH5Zgdz9 | ||
53 | gad5WZF5ykFArmHDgeFlgggvbZ7z9vqnjN/TH68TxJzauYQ5vLHQ6wGXik4/4uq7/TqNmhxlQEM4 | ||
54 | zVkwsn203bUmKLyz+yl1zItDpn5zy1uXfGo99rBdUzdbdE9LmEFPMaFsaHd4a8oDaUroD7FgCbeD | ||
55 | JJVld3ac6F8+3QbExPs48OrgA1kI3/UwXr52ldjiYzTLfAGR9BjqNFTw45FUHuMf8TEM5hcHx56w | ||
56 | 95eKAqraDk28o9k+M2UKpcmrdlWoWzdqVVFeWGpM8x9Y9Nt0lf/4VUQgrXjqTkUCQkJyqTeTeGgH | ||
57 | rn3QBk2XAgpxZhaJs3InW0BkAlBmK99cMinUiJeFt5a4p5wPeXrVuh6V9m7Mpl9hzpogg++EZqah | ||
58 | fzzNnDgxOZfW342DX052PdgXo0NnkhCk005LvFt6M2mRn0fLgNVfyUZZoOp8cO5ZWbhXXlrhrgUt | ||
59 | j2zKPK6Q94Zj4kdXHBGpAkrB8ZQ4EGGODE0Dqusm8WPXzB+9236IMHPU7lFbyjBrFNI7O4jg+qRI | ||
60 | Ipi+7tX0FsilqEbmjG+OPwhZXrdqUqyF+rjKQuSRq7lOeDB4c6S2dq4OOny01i5HCbbyc9UvSHRm | ||
61 | hOhGqUlzHyHLo3W7j+26V/MhkDXJ+Tx+qfylv4pbliwTteJJj+CZwzjv29qb6lxYi+38Bw10ERap | ||
62 | m8UCRFBecVN7xXlcIfyeAl666Vi7EBJZv3EdFNrx1nlLwM65nYya7uj6L7IwJWotIUx8E0XH0/cU | ||
63 | xS/dG8bxf9L/8652h5gq3LI+wTNGuEX0DMuz7BGQG+NtgabrZ6SsKGthGa7eULTpz0McWTLRU0y/ | ||
64 | /tkckpm5pDnXSFbIMskwwjECz82UZBSPpigdN/Pjg5d+0yWu7s3VJxw4ENWPPpzZ+j7sOXmdvn9P | ||
65 | O1tQd60EO+3awASCBAAZQvWV3/yJ6FxPttbP+qeURpJoPEZfpN2UYZmd8HqtR0YbaOZ6Rln9nvpd | ||
66 | K9fylXdw9z2xeCbjDWUttJB4VqZxGJM8eCTC1VDVyAOsQ5n7SY55dMkQbU+o4Z/4J5m8+wz50BBI | ||
67 | LfruL1eZ6/CF6CdvxVRiJ10sXc0Tn2sVMXqkw7Adp1GYoCI9c6VFSFK74+n+y7LVFQ5HBnbQyKJc | ||
68 | dvdLOXwZOPaFHC5UNXRmOpcwdPqyXUe+xIsOMYbzdlAnI9eGDNeRDktUa/Rh0CbZCxjmJzoZEYOE | ||
69 | ZjsYZlEfp1Kb61t8z4m28hGLEg88T1Ihmxa2HeUWes1RpmgIOP+/2Lb3smj/l/fpSu4gabFgyCAV | ||
70 | H5HdCYMScUv8SVu55+tpeO8ELoHHQUXV4rr084O4budzhgNSOPyLGDl5sfDUXiyusPCxS4JVO/KY | ||
71 | 6V2Qrtg/q2wtmXpEkZnGT+Qi3WDzwt4W81alztnYMP17oGLmxX71KV9OEiMZjI4WaaGt+OOINLtR | ||
72 | qefioZ1NI2L1s5M0tybwTsyU9WERM+3pUwXIfJVsbMZRlNaO2OogcHbaR4UWvhOj+3CTG1sThiYQ | ||
73 | MxMnp1Rpqx3nhyzqLO3TRrkYvxnA3cdPBn9EeqpgBMg7X3hCiMV3Fl5cj/WOMhtHYgY7BgeCXo46 | ||
74 | EFVZ4+WroGZ46xGiRDiIblo8bzLd7QCxvukzxy3mUDgsZQ8pds4N28weSUhBk5MAPbfBpRvXUVJx | ||
75 | MhKqXucQU1Md1qSGLbuuIQuz9pAGp1JFUx/vEkCgm74daSoVWCZuB+1ZE4f48clvrBj51xMNf8CP | ||
76 | EFE7vySzVb6X2H1i5X3Z+Y3DdIcWw4Y2FClfcJk4Mwq8Cq2GALGFEge9YSEE9YmyuU6OFeU0ICon | ||
77 | iXAgZ72SM8fBwJPruLFbdsNYKW+oAfmPisXSWMcZmdSbfk0GYv+vKtu3eegSbWw1UsCVtZOh9E5Z | ||
78 | uQ83l59CBqO9sV/SFU3WrrJ0qNWxrmXu9nJn5Qf5iCRoFGYNHYHkIG5FS6N00GEDZxGkxmro2d++ | ||
79 | Adj5LVHc/b1cYWmrux+jEqI8ZK8cyTB0XMbBA/HYbx9NXazr7znP4/Mlv3pZToEcYt+lgLHAArtU | ||
80 | AdhybhbLIwNMq0gr6EwtDklBa3ns4Wx/rJU8H7LGs6gV8uqeaSketv+nz+sQhfctxZ1rx+5qzXfy | ||
81 | FOQVpO23KDQunBi1Bl9k61Di4q9JWcyADBXPHXJzp7mL8Fk7zdvMAEfuED1phdRm6GgDYoYUs4yQ | ||
82 | IrhSjFlWyk7hT8475xk3BIv++obvWSAv/3+pF6A6U2RXDChVmnG0JnPa9wYYtdzBmLfZKBjX+DjD | ||
83 | yEMsuhPsCzuN4R6tBIIBWCVRKmKwdkatmpsQBgDw48u0/Arffl5/DRlS9ee+QffFecUitDdCK+kt | ||
84 | X5L2fGYrL5g6SltncMIeV1ptx4nuSjC/O944q1KYtqvQiPFWJqEXIRMNbbYOC47sjLza0tEFrimN | ||
85 | wxcrWGSzsy5R9beFQ1aHPcMrDWfCoviNRk2qPtxuKIC5Qk2ZuOmJLjCiLwUGEb0/1Mpzv3MqQa7d | ||
86 | mRayXg3DZWJPajxNZv6eS357ElMvwGQmqafb2mlQJwWLsg9m9PG7uqEoyrqSc6MiuY+icLEFib9j | ||
87 | OfRQrx70rTSKUfTr4MtP0aZZAefjCrpVIyTekhFDOk0Nmx057eonlyGgmGpl5/Uo+t1J1Z11Ya/l | ||
88 | bNbfmebRISJeTVW0I8FhseAZMI1GSwp/ludJxSLYOgyRkh+GX134MexNo7O9F1SxLCfWaSG9Fc3s | ||
89 | 5ify04ua9/t8SGrYZPm/l3MkAAAAAAAAAAAAAA== | ||
90 | |||
91 | |||
diff --git a/src/lib/libcrypto/pkcs7/t/msie-s-a-e.pem b/src/lib/libcrypto/pkcs7/t/msie-s-a-e.pem new file mode 100644 index 0000000000..55dbd8f80b --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/msie-s-a-e.pem | |||
@@ -0,0 +1,106 @@ | |||
1 | -----BEGIN PKCS7----- | ||
2 | MIAGCSqGSIb3DQEHA6CAMIITUAIBADGCAcIwgcwCAQAwdjBiMREwDwYDVQQHEwhJ | ||
3 | bnRlcm5ldDEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xNDAyBgNVBAsTK1ZlcmlT | ||
4 | aWduIENsYXNzIDEgQ0EgLSBJbmRpdmlkdWFsIFN1YnNjcmliZXICEGBAmILep9sJ | ||
5 | uN2Pkg1gucowDQYJKoZIhvcNAQEBBQAEQKOxxpIbRTb31+qIQCBOpMVAGnwCLrPO | ||
6 | OXnntxVveTrPhBnsJuoGNJcCMtuHl7tLkd38WsVwOfGXUprTqFpUcY8wgfACAQAw | ||
7 | gZkwgZIxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpRdWVlbnNsYW5kMREwDwYDVQQH | ||
8 | EwhCcmlzYmFuZTEaMBgGA1UEChMRQ3J5cHRzb2Z0IFB0eSBMdGQxIjAgBgNVBAsT | ||
9 | GURFTU9OU1RSQVRJT04gQU5EIFRFU1RJTkcxGzAZBgNVBAMTEkRFTU8gWkVSTyBW | ||
10 | QUxVRSBDQQICBG4wDQYJKoZIhvcNAQEBBQAEQKzIddnXFqK/RRBG86ZVixoXfwAv | ||
11 | ZdfvnDFsKzPn/A6DuDdE/hqJxnFpHiwGiDR/YbWj2ib+G74DSshgX8vj8ZQwghGD | ||
12 | BgkqhkiG9w0BBwEwGgYIKoZIhvcNAwIwDgICAKAECLKM0K58I3HNgIIRWBDP8s+g | ||
13 | l7/6JhZ5PBJ5vPpD1R4pnNDZRabsYu0Qzezdz1IK+maTAhF0SEuNZoEkzIgOIvu3 | ||
14 | UjW8x/2KcHwteABwgRiSk1JyNLwRED0RtvuJ40pIGDvDsHwBMcXEtKUMAOpGChms | ||
15 | HUK1+B/GKancSDFOCeG3JCFnFdbuQFDIVHC6amWslc6ntqVs/sii2Gs4qdzDfQgl | ||
16 | PV/A/FY0wi0j2O5cXRQJtZVKM/MYGjj5c1cy9Q7oymU5ATP/LARD0Tw5kBB7HVnD | ||
17 | 2qrmmmxcHakyxhXmwskaKS6Qxgqq6LPdgr603onxqEtwNSz5UbCq9mLXuCkFOVsQ | ||
18 | /5mZcmmc7re3XJMQHRXkBlxEpZQ6HOUIEzlhRqCo2hhymyZK84rptjORQo6vNakM | ||
19 | IC0Zn8O+6Xl1NlmbGzZakz6LJ4dczE7eG7LwrVus9Oq3V/WweG6rWMPV5d51oKMi | ||
20 | BRb2pXXy80BAKh/9hvpP/V/HO1/+MPuk8tAn7ssmQoIAQcZxqLOmgqqFhy21oSEu | ||
21 | rUY746Gp/vIV6Ax1MnfDA/fbjDllhJTl8ujZnfj8R1/oQa9fJMipV8CYQEAt3okZ | ||
22 | V03kaVhhPGsv544/zRnhqjhgqjHASZGnluZCxDwHb1CE4UqYLp6IbkH3qosy2ntm | ||
23 | a7WCsM3FN3o5dKFZXBgBEPT8HU9LLQ8B+T0Zvh8CQ719kkNBhnuzSYzmI48R5JHv | ||
24 | zbROiU5v4p9FpssD13vXiOxzaMTKQqWk/roGHiNoKzKonS5RBwTxKfOsoCobCBaI | ||
25 | IZCmJNr4cGI/p5GVEY4pCPljTq9w3HoiNrhwZ7r7II3wdXy0JjSiRkr3w1AKXm3v | ||
26 | 1H9kHZzc28Ekf7+De6VTjyKRPe1WYPETeY5mh9nIYUQz30/5gIxJwsPFOXeHMbLR | ||
27 | iQjxTznk/uo4BtwV+HZPmf4tIQvAuFuTKYR9lP3XsZZN+bKkFYy8nHRYd4OErBBg | ||
28 | 93NsqBYROdzJ4pqxoJb6gt2EHCt3pazavgwDxzCJhcMtvBiYLEkDxUX77yS5sXYc | ||
29 | k6NLIwFL5BPY9JX/QP1RaiJV+TtHg69YElW+rudX6VdLQ7mKCMTHGWbHU5oF+Dv4 | ||
30 | Kv8xsrjNU2spImfzY2coq3osLpFpOa8VhrLSwMXFDtej5OHq0M0qYpYm3op6B+Nz | ||
31 | 6pNYlMpveQv5Qjy9LTNMvLX4z+tnh6Siz8mJLmtghwCzC+DnyQGCn/Stzq6kF5aM | ||
32 | Fork7RosB4FB8u6WjVrFZfTg5JUqZh6gCW3JHpQ70wTdpy6tDKDtNrbjKo7CGL8+ | ||
33 | shoSI7t2xa8W3OyyFXMEuJzTY2UCQ+QxTOWI9idkdZCCUMBXEvkraqG8rU4UKRCk | ||
34 | iAGwEMzophEv+aSyJfdu6yJGjd+/wUCHMS3EmtOWHwtB5d5sVhErdQNA+JQN+wPU | ||
35 | vBG2Jg3wGJTHNNx4WRnWRLWsH6SRcgx8zWXHjVgXIep8XjWQmOGBXbG87hktESqc | ||
36 | DQPUv3MzieKfcpgQsboRnqSN1DymwvAu+PVsMNf8DHQKLdZ/iuzPzwRkfIVpmh+U | ||
37 | ku1N8jMAAdX6tjQ48eLq/lJvjHJUnTdNTA18xhDvngKNaXQGPOO/dt+JfHQdmFQI | ||
38 | WdWZSeCpm6jCiaxiV50FBGEuv3Ew0Y7FKHLKFu7hoNXIthoh2qo5ZH6QX4nt0nYR | ||
39 | VvyvIcAB9BwC7OeqBTeusFJD/wGiQD3yFDYUekaRys2fcwguNqAdpjWsEETJxREw | ||
40 | ZdbP0sDMSykae4wHyrODWcUmOiPc/9nU6c0t7bBzI8VQ7sZKJb0TVgSCxDHi9Qgb | ||
41 | 4qdh4ZqFMP0s+TQ4Ms5NWkC1eg0DSdkWSzGQ0QrUsGUgbupYYUoEyRmsz9PjW6l1 | ||
42 | wuWkE66qxSHFsg18/gA5XpLM82DP4EmkEwgC08Hww2lPRJN8VYFvlwbRMbSd1PtA | ||
43 | Dd5dI/Oq1CHSL6enlncVkKr/S7aaKKyjAyn1HOT2FdPWdSYLE+F+dWc6vu+JeXc+ | ||
44 | 7nSDO1DW3U6ZkZvTw4901GxgrzUfYajhBky25L29WUduGoerhkZds5wduSKQwBkY | ||
45 | TUW/YrP6Ttrbx8B0wzDo64L2Rv6Tb14ElMc9KUY1I1yHKgXtl9oHEH3mpa/IGO+q | ||
46 | PN1hBi+jg68lfb00FR7edvos4KWKAWWlZaYKm2ZeeHPjhNGcX/UcF8A23GLuSruR | ||
47 | NDDy9KlI3NMtvmOhOD+WwFmmRjBk/jkZMlVM3GlpjP/l5TuzxEecK1pQiDGQl9S/ | ||
48 | 574qGNKtAiqgC5+wyUFPqnp28K2+rsEu7jWWOlfOrNGg2KVO8kcqsQuUm7sjSW9N | ||
49 | oHcVAoKSLHBWjFIzFUZpeDOASI1/21Ph4B6FTFJvEpzfYEXE9osz64DhlXDEyY33 | ||
50 | p86AiqAj6PUY4BjHLYAeA7ymphKzVOzq4pSH7qKsxDzUnj/Uj8P85A5jbzHmzOPf | ||
51 | VnvQlZ7B1FqhdNP2SVqLmu+/tH9Wy0v7ZnItSQbyHDKP+Eib4B/ihaNIIoz/YKgD | ||
52 | 3eYgjp6ZyZR1KkSMpuNkpsihA7s3UsFyowEeo+7l3Wt/ScjCa/IBsxLLtI2EZAJo | ||
53 | 9WHYqsCl1HCzJHI9QCnlPz8U1FcNGCrL/66MKz2MMN8UFFqjYr61wexghxNwc7GD | ||
54 | XR7Js4mhiF0GwPhAR3ZLiqzPAXAvn8YRf5fylMZ4LA9RO+SHFL/MxQxfrJOAgWB6 | ||
55 | pLPUuCWJXLm7os6rCC23RsyDDWe8N+JNF0/ryzr8MHeIJGsT+AYnZr08PeTbyr01 | ||
56 | JEoT7lPYT6PzX4F63QKKDl+mB+PwLMzYCXrxZcUmuay6/MV8w/f5T6vQXdoSw5pu | ||
57 | WodBYwVReYh1IaEN+jiTapm9YBVmcIsJPO6abHowknSVOWSvST0AtAX57fFOTckm | ||
58 | +facfBK9s9T1lUUgF44Bh5e8f9qKqfOV44nqdCOEyUm0Dao497ieN4EgXBLNvOZY | ||
59 | 9+irMiXjp0lcyFvhrJOczfyCr9EiiaiH1TfSzKGKsf2W84iKn/JH6x2eOo7xjwJ4 | ||
60 | 0BQDc6S1cUNEuqBhP6by0FioOXYOKVyifpxk84Eb+F/4CNdTJTvCPwsiegdfsX/Q | ||
61 | 53DvKVtXp9Ycam5JTmKRHXK/bMHF4ONv3p/O/kn/BqRx+fbbP2eMX8Z1F/ltHKfp | ||
62 | 6B+06HljUwQLBJs9XtCfqH5Zgdz9gad5WZF5ykFArmHDgeFlgggvbZ7z9vqnjN/T | ||
63 | H68TxJzauYQ5vLHQ6wGXik4/4uq7/TqNmhxlQEM4zVkwsn203bUmKLyz+yl1zItD | ||
64 | pn5zy1uXfGo99rBdUzdbdE9LmEFPMaFsaHd4a8oDaUroD7FgCbeDJJVld3ac6F8+ | ||
65 | 3QbExPs48OrgA1kI3/UwXr52ldjiYzTLfAGR9BjqNFTw45FUHuMf8TEM5hcHx56w | ||
66 | 95eKAqraDk28o9k+M2UKpcmrdlWoWzdqVVFeWGpM8x9Y9Nt0lf/4VUQgrXjqTkUC | ||
67 | QkJyqTeTeGgHrn3QBk2XAgpxZhaJs3InW0BkAlBmK99cMinUiJeFt5a4p5wPeXrV | ||
68 | uh6V9m7Mpl9hzpogg++EZqahfzzNnDgxOZfW342DX052PdgXo0NnkhCk005LvFt6 | ||
69 | M2mRn0fLgNVfyUZZoOp8cO5ZWbhXXlrhrgUtj2zKPK6Q94Zj4kdXHBGpAkrB8ZQ4 | ||
70 | EGGODE0Dqusm8WPXzB+9236IMHPU7lFbyjBrFNI7O4jg+qRIIpi+7tX0FsilqEbm | ||
71 | jG+OPwhZXrdqUqyF+rjKQuSRq7lOeDB4c6S2dq4OOny01i5HCbbyc9UvSHRmhOhG | ||
72 | qUlzHyHLo3W7j+26V/MhkDXJ+Tx+qfylv4pbliwTteJJj+CZwzjv29qb6lxYi+38 | ||
73 | Bw10ERapm8UCRFBecVN7xXlcIfyeAl666Vi7EBJZv3EdFNrx1nlLwM65nYya7uj6 | ||
74 | L7IwJWotIUx8E0XH0/cUxS/dG8bxf9L/8652h5gq3LI+wTNGuEX0DMuz7BGQG+Nt | ||
75 | gabrZ6SsKGthGa7eULTpz0McWTLRU0y//tkckpm5pDnXSFbIMskwwjECz82UZBSP | ||
76 | pigdN/Pjg5d+0yWu7s3VJxw4ENWPPpzZ+j7sOXmdvn9PO1tQd60EO+3awBlC9ZXf | ||
77 | /InoXE+21s/6p5RGkmg8Rl+k3ZRhmZ3weq1HRhto5npGWf2e+l0r1/KVd3D3PbF4 | ||
78 | JuMNZS20kHhWpnEYkzx4JMLVUNXIA6xDmftJjnl0yRBtT6jhn/gnmbz7DPnQEEgt | ||
79 | +u4vV5nr8IXoJ2/FVGInXSxdzROfaxUxeqTDsB2nUZigIj1zpUVIUrvj6f7LstUV | ||
80 | DkcGdtDIolx290s5fBk49oUcLlQ1dGY6lzB0+rJdR77Eiw4xhvN2UCcj14YM15EO | ||
81 | S1Rr9GHQJtkLGOYnOhkRg4RmOxhmUR+nUpvrW3zPibbyEYsSDzxPUiGbFrYd5RZ6 | ||
82 | zVGmaAg4/7/YtveyaP+X9+lK7iBpsWDIIBUfkd0JgxJxS/xJW7nn62l47wQugcdB | ||
83 | RdXiuvTzg7hu53OGA1I4/IsYOXmx8NReLK6w8LFLglU78pjpXZCu2D+rbC2ZekSR | ||
84 | mcZP5CLdYPPC3hbzVqXO2dgw/XugYubFfvUpX04SIxmMjhZpoa3444g0u1Gp5+Kh | ||
85 | nU0jYvWzkzS3JvBOzJT1YREz7elTBch8lWxsxlGU1o7Y6iBwdtpHhRa+E6P7cJMb | ||
86 | WxOGJhAzEyenVGmrHeeHLOos7dNGuRi/GcDdx08Gf0R6qmAEyDtfeEKIxXcWXlyP | ||
87 | 9Y4yG0diBjsGB4JejjoQVVnj5augZnjrEaJEOIhuWjxvMt3tALG+6TPHLeZQOCxl | ||
88 | Dyl2zg3bzB5JSEGTkwA9t8GlG9dRUnEyEqpe5xBTUx3WpIYtu64hC7P2kAanUkVT | ||
89 | H+8SQKCbvh1pKhVYJm4H7VkTh/jxyW+sGPnXEw1/wI8QUTu/JLNVvpfYfWLlfdn5 | ||
90 | jcN0hxbDhjYUKV9wmTgzCrwKrYYAsYUSB71hIQT1ibK5To4V5TQgKieJcCBnvZIz | ||
91 | x8HAk+u4sVt2w1gpb6gB+Y+KxdJYxxmZ1Jt+TQZi/68q27d56BJtbDVSwJW1k6H0 | ||
92 | Tlm5DzeXn0IGo72xX9IVTdausnSo1bGuZe72cmflB/mIJGgUZg0dgeQgbkVLo3TQ | ||
93 | YQNnEaTGaujZ374B2PktUdz9vVxhaau7H6MSojxkrxzJMHRcxsED8dhvH01drOvv | ||
94 | Oc/j8yW/ellOgRxi36WAscACu1QB2HJuFssjA0yrSCvoTC0OSUFreezhbH+slTwf | ||
95 | ssazqBXy6p5pKR62/6fP6xCF9y3FnWvH7mrNd/IU5BWk7bcoNC6cGLUGX2TrUOLi | ||
96 | r0lZzIAMFc8dcnOnuYvwWTvN28wAR+4QPWmF1GboaANihhSzjJAiuFKMWVbKTuFP | ||
97 | zjvnGTcEi/76hu9ZIC//f6kXoDpTZFcMKFWacbQmc9r3Bhi13MGYt9koGNf4OMPI | ||
98 | Qyy6E+wLO43hHq0lUSpisHZGrZqbEAYA8OPLtPwK335efw0ZUvXnvkH3xXnFIrQ3 | ||
99 | QivpLV+S9nxmKy+YOkpbZ3DCHldabceJ7kowvzveOKtSmLar0IjxViahFyETDW22 | ||
100 | DguO7Iy82tLRBa4pjcMXK1hks7MuUfW3hUNWhz3DKw1nwqL4jUZNqj7cbiiAuUJN | ||
101 | mbjpiS4woi8FBhG9P9TKc79zKkGu3ZkWsl4Nw2ViT2o8TWb+nkt+exJTL8BkJqmn | ||
102 | 29ppUCcFi7IPZvTxu7qhKMq6knOjIrmPonCxBYm/Yzn0UK8e9K00ilH06+DLT9Gm | ||
103 | WQHn4wq6VSMk3pIRQzpNDZsdOe3qJ5choJhqZef1KPrdSdWddWGv5WzW35nm0SEi | ||
104 | Xk1VtCPBYbHgGTCNRksKf5bnScUi2DoMkZIfhl9d+DHsTaOzvRdUsSwn1mkhvRXN | ||
105 | 7OYn8tOLmvf7fEhq2GT5v5dzJAAAAAA= | ||
106 | -----END PKCS7----- | ||
diff --git a/src/lib/libcrypto/pkcs7/t/nav-smime b/src/lib/libcrypto/pkcs7/t/nav-smime new file mode 100644 index 0000000000..6ee4b597a1 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/nav-smime | |||
@@ -0,0 +1,157 @@ | |||
1 | From angela@c2.net.au Thu May 14 13:32:27 1998 | ||
2 | X-UIDL: 83c94dd550e54329bf9571b72038b8c8 | ||
3 | Return-Path: angela@c2.net.au | ||
4 | Received: from cryptsoft.com (play.cryptsoft.com [203.56.44.3]) by pandora.cryptsoft.com (8.8.3/8.7.3) with ESMTP id NAA27838 for <tjh@cryptsoft.com>; Thu, 14 May 1998 13:32:26 +1000 (EST) | ||
5 | Message-ID: <355A6779.4B63E64C@cryptsoft.com> | ||
6 | Date: Thu, 14 May 1998 13:39:37 +1000 | ||
7 | From: Angela van Lent <angela@c2.net.au> | ||
8 | X-Mailer: Mozilla 4.03 [en] (Win95; U) | ||
9 | MIME-Version: 1.0 | ||
10 | To: tjh@cryptsoft.com | ||
11 | Subject: signed | ||
12 | Content-Type: multipart/signed; protocol="application/x-pkcs7-signature"; micalg=sha1; boundary="------------ms9A58844C95949ECC78A1C54C" | ||
13 | Content-Length: 2604 | ||
14 | Status: OR | ||
15 | |||
16 | This is a cryptographically signed message in MIME format. | ||
17 | |||
18 | --------------ms9A58844C95949ECC78A1C54C | ||
19 | Content-Type: text/plain; charset=us-ascii | ||
20 | Content-Transfer-Encoding: 7bit | ||
21 | |||
22 | signed body | ||
23 | |||
24 | --------------ms9A58844C95949ECC78A1C54C | ||
25 | Content-Type: application/x-pkcs7-signature; name="smime.p7s" | ||
26 | Content-Transfer-Encoding: base64 | ||
27 | Content-Disposition: attachment; filename="smime.p7s" | ||
28 | Content-Description: S/MIME Cryptographic Signature | ||
29 | |||
30 | MIIGHgYJKoZIhvcNAQcCoIIGDzCCBgsCAQExCzAJBgUrDgMCGgUAMAsGCSqGSIb3DQEHAaCC | ||
31 | BGswggJTMIIB/aADAgECAgIEfjANBgkqhkiG9w0BAQQFADCBkjELMAkGA1UEBhMCQVUxEzAR | ||
32 | BgNVBAgTClF1ZWVuc2xhbmQxETAPBgNVBAcTCEJyaXNiYW5lMRowGAYDVQQKExFDcnlwdHNv | ||
33 | ZnQgUHR5IEx0ZDEiMCAGA1UECxMZREVNT05TVFJBVElPTiBBTkQgVEVTVElORzEbMBkGA1UE | ||
34 | AxMSREVNTyBaRVJPIFZBTFVFIENBMB4XDTk4MDUxMzA2MjY1NloXDTAwMDUxMjA2MjY1Nlow | ||
35 | gaUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpRdWVlbnNsYW5kMREwDwYDVQQHEwhCcmlzYmFu | ||
36 | ZTEaMBgGA1UEChMRQ3J5cHRzb2Z0IFB0eSBMdGQxEjAQBgNVBAsTCVNNSU1FIDAwMzEZMBcG | ||
37 | A1UEAxMQQW5nZWxhIHZhbiBMZWVudDEjMCEGCSqGSIb3DQEJARYUYW5nZWxhQGNyeXB0c29m | ||
38 | dC5jb20wXDANBgkqhkiG9w0BAQEFAANLADBIAkEAuC3+7dAb2LhuO7gt2cTM8vsNjhG5JfDh | ||
39 | hX1Vl/wVGbKEEj0MA6vWEolvefQlxB+EzwCtR0YZ7eEC/T/4JoCyeQIDAQABoygwJjAkBglg | ||
40 | hkgBhvhCAQ0EFxYVR2VuZXJhdGVkIHdpdGggU1NMZWF5MA0GCSqGSIb3DQEBBAUAA0EAUnSP | ||
41 | igs6TMFISTjw8cBtJYb98czgAVkVFjKyJQwYMH8FbDnCyx6NocM555nsyDstaw8fKR11Khds | ||
42 | syd3ikkrhDCCAhAwggG6AgEDMA0GCSqGSIb3DQEBBAUAMIGSMQswCQYDVQQGEwJBVTETMBEG | ||
43 | A1UECBMKUXVlZW5zbGFuZDERMA8GA1UEBxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29m | ||
44 | dCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNUUkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQD | ||
45 | ExJERU1PIFpFUk8gVkFMVUUgQ0EwHhcNOTgwMzAzMDc0MTMyWhcNMDgwMjI5MDc0MTMyWjCB | ||
46 | kjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClF1ZWVuc2xhbmQxETAPBgNVBAcTCEJyaXNiYW5l | ||
47 | MRowGAYDVQQKExFDcnlwdHNvZnQgUHR5IEx0ZDEiMCAGA1UECxMZREVNT05TVFJBVElPTiBB | ||
48 | TkQgVEVTVElORzEbMBkGA1UEAxMSREVNTyBaRVJPIFZBTFVFIENBMFwwDQYJKoZIhvcNAQEB | ||
49 | BQADSwAwSAJBAL+0E2fLej3FSCwe2A2iRnMuC3z12qHIp6Ky1wo2zZcxft7AI+RfkrWrSGtf | ||
50 | mfzBEuPrLdfulncC5Y1pNcM8RTUCAwEAATANBgkqhkiG9w0BAQQFAANBAGSbLMphL6F5pp3s | ||
51 | 8o0Xyh86FHFdpVOwYx09ELLkuG17V/P9pgIc0Eo/gDMbN+KT3IdgECf8S//pCRA6RrNjcXIx | ||
52 | ggF7MIIBdwIBATCBmTCBkjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClF1ZWVuc2xhbmQxETAP | ||
53 | BgNVBAcTCEJyaXNiYW5lMRowGAYDVQQKExFDcnlwdHNvZnQgUHR5IEx0ZDEiMCAGA1UECxMZ | ||
54 | REVNT05TVFJBVElPTiBBTkQgVEVTVElORzEbMBkGA1UEAxMSREVNTyBaRVJPIFZBTFVFIENB | ||
55 | AgIEfjAJBgUrDgMCGgUAoHowGAYJKoZIhvcNAQkDMQsGCSqGSIb3DQEHATAbBgkqhkiG9w0B | ||
56 | CQ8xDjAMMAoGCCqGSIb3DQMHMBwGCSqGSIb3DQEJBTEPFw05ODA1MTQwMzM5MzdaMCMGCSqG | ||
57 | SIb3DQEJBDEWBBQstNMnSV26ba8PapQEDhO21yNFrjANBgkqhkiG9w0BAQEFAARAW9Xb9YXv | ||
58 | BfcNkutgFX9Gr8iXhBVsNtGEVrjrpkQwpKa7jHI8SjAlLhk/4RFwDHf+ISB9Np3Z1WDWnLcA | ||
59 | 9CWR6g== | ||
60 | --------------ms9A58844C95949ECC78A1C54C-- | ||
61 | |||
62 | |||
63 | From angela@c2.net.au Thu May 14 13:33:16 1998 | ||
64 | X-UIDL: 8f076c44ff7c5967fd5b00c4588a8731 | ||
65 | Return-Path: angela@c2.net.au | ||
66 | Received: from cryptsoft.com (play.cryptsoft.com [203.56.44.3]) by pandora.cryptsoft.com (8.8.3/8.7.3) with ESMTP id NAA27847 for <tjh@cryptsoft.com>; Thu, 14 May 1998 13:33:15 +1000 (EST) | ||
67 | Message-ID: <355A67AB.2AF38806@cryptsoft.com> | ||
68 | Date: Thu, 14 May 1998 13:40:27 +1000 | ||
69 | From: Angela van Lent <angela@c2.net.au> | ||
70 | X-Mailer: Mozilla 4.03 [en] (Win95; U) | ||
71 | MIME-Version: 1.0 | ||
72 | To: tjh@cryptsoft.com | ||
73 | Subject: signed | ||
74 | Content-Type: multipart/signed; protocol="application/x-pkcs7-signature"; micalg=sha1; boundary="------------msD7863B84BD61E02C407F2F5E" | ||
75 | Content-Length: 2679 | ||
76 | Status: OR | ||
77 | |||
78 | This is a cryptographically signed message in MIME format. | ||
79 | |||
80 | --------------msD7863B84BD61E02C407F2F5E | ||
81 | Content-Type: text/plain; charset=us-ascii | ||
82 | Content-Transfer-Encoding: 7bit | ||
83 | |||
84 | signed body 2 | ||
85 | |||
86 | --------------msD7863B84BD61E02C407F2F5E | ||
87 | Content-Type: application/x-pkcs7-signature; name="smime.p7s" | ||
88 | Content-Transfer-Encoding: base64 | ||
89 | Content-Disposition: attachment; filename="smime.p7s" | ||
90 | Content-Description: S/MIME Cryptographic Signature | ||
91 | |||
92 | MIIGVgYJKoZIhvcNAQcCoIIGRzCCBkMCAQExCzAJBgUrDgMCGgUAMAsGCSqGSIb3DQEHAaCC | ||
93 | BGswggJTMIIB/aADAgECAgIEfjANBgkqhkiG9w0BAQQFADCBkjELMAkGA1UEBhMCQVUxEzAR | ||
94 | BgNVBAgTClF1ZWVuc2xhbmQxETAPBgNVBAcTCEJyaXNiYW5lMRowGAYDVQQKExFDcnlwdHNv | ||
95 | ZnQgUHR5IEx0ZDEiMCAGA1UECxMZREVNT05TVFJBVElPTiBBTkQgVEVTVElORzEbMBkGA1UE | ||
96 | AxMSREVNTyBaRVJPIFZBTFVFIENBMB4XDTk4MDUxMzA2MjY1NloXDTAwMDUxMjA2MjY1Nlow | ||
97 | gaUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpRdWVlbnNsYW5kMREwDwYDVQQHEwhCcmlzYmFu | ||
98 | ZTEaMBgGA1UEChMRQ3J5cHRzb2Z0IFB0eSBMdGQxEjAQBgNVBAsTCVNNSU1FIDAwMzEZMBcG | ||
99 | A1UEAxMQQW5nZWxhIHZhbiBMZWVudDEjMCEGCSqGSIb3DQEJARYUYW5nZWxhQGNyeXB0c29m | ||
100 | dC5jb20wXDANBgkqhkiG9w0BAQEFAANLADBIAkEAuC3+7dAb2LhuO7gt2cTM8vsNjhG5JfDh | ||
101 | hX1Vl/wVGbKEEj0MA6vWEolvefQlxB+EzwCtR0YZ7eEC/T/4JoCyeQIDAQABoygwJjAkBglg | ||
102 | hkgBhvhCAQ0EFxYVR2VuZXJhdGVkIHdpdGggU1NMZWF5MA0GCSqGSIb3DQEBBAUAA0EAUnSP | ||
103 | igs6TMFISTjw8cBtJYb98czgAVkVFjKyJQwYMH8FbDnCyx6NocM555nsyDstaw8fKR11Khds | ||
104 | syd3ikkrhDCCAhAwggG6AgEDMA0GCSqGSIb3DQEBBAUAMIGSMQswCQYDVQQGEwJBVTETMBEG | ||
105 | A1UECBMKUXVlZW5zbGFuZDERMA8GA1UEBxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29m | ||
106 | dCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNUUkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQD | ||
107 | ExJERU1PIFpFUk8gVkFMVUUgQ0EwHhcNOTgwMzAzMDc0MTMyWhcNMDgwMjI5MDc0MTMyWjCB | ||
108 | kjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClF1ZWVuc2xhbmQxETAPBgNVBAcTCEJyaXNiYW5l | ||
109 | MRowGAYDVQQKExFDcnlwdHNvZnQgUHR5IEx0ZDEiMCAGA1UECxMZREVNT05TVFJBVElPTiBB | ||
110 | TkQgVEVTVElORzEbMBkGA1UEAxMSREVNTyBaRVJPIFZBTFVFIENBMFwwDQYJKoZIhvcNAQEB | ||
111 | BQADSwAwSAJBAL+0E2fLej3FSCwe2A2iRnMuC3z12qHIp6Ky1wo2zZcxft7AI+RfkrWrSGtf | ||
112 | mfzBEuPrLdfulncC5Y1pNcM8RTUCAwEAATANBgkqhkiG9w0BAQQFAANBAGSbLMphL6F5pp3s | ||
113 | 8o0Xyh86FHFdpVOwYx09ELLkuG17V/P9pgIc0Eo/gDMbN+KT3IdgECf8S//pCRA6RrNjcXIx | ||
114 | ggGzMIIBrwIBATCBmTCBkjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClF1ZWVuc2xhbmQxETAP | ||
115 | BgNVBAcTCEJyaXNiYW5lMRowGAYDVQQKExFDcnlwdHNvZnQgUHR5IEx0ZDEiMCAGA1UECxMZ | ||
116 | REVNT05TVFJBVElPTiBBTkQgVEVTVElORzEbMBkGA1UEAxMSREVNTyBaRVJPIFZBTFVFIENB | ||
117 | AgIEfjAJBgUrDgMCGgUAoIGxMBgGCSqGSIb3DQEJAzELBgkqhkiG9w0BBwEwHAYJKoZIhvcN | ||
118 | AQkFMQ8XDTk4MDUxNDAzNDAyN1owIwYJKoZIhvcNAQkEMRYEFOKcV8mNYJnM8rHQajcSEqJN | ||
119 | rwdDMFIGCSqGSIb3DQEJDzFFMEMwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCAMAcGBSsO | ||
120 | AwIHMA0GCCqGSIb3DQMCAgFAMA0GCCqGSIb3DQMCAgEoMA0GCSqGSIb3DQEBAQUABEADPE/N | ||
121 | coH+zTFuX5YpolupTKxKK8eEjc48TuADuO8bIHHDE/fEYaWunlwDuTlcFJl1ig0idffPB1qC | ||
122 | Zp8SSVVY | ||
123 | --------------msD7863B84BD61E02C407F2F5E-- | ||
124 | |||
125 | |||
126 | From angela@c2.net.au Thu May 14 14:05:32 1998 | ||
127 | X-UIDL: a7d629b4b9acacaee8b39371b860a32a | ||
128 | Return-Path: angela@c2.net.au | ||
129 | Received: from cryptsoft.com (play.cryptsoft.com [203.56.44.3]) by pandora.cryptsoft.com (8.8.3/8.7.3) with ESMTP id OAA28033 for <tjh@cryptsoft.com>; Thu, 14 May 1998 14:05:32 +1000 (EST) | ||
130 | Message-ID: <355A6F3B.AC385981@cryptsoft.com> | ||
131 | Date: Thu, 14 May 1998 14:12:43 +1000 | ||
132 | From: Angela van Lent <angela@c2.net.au> | ||
133 | X-Mailer: Mozilla 4.03 [en] (Win95; U) | ||
134 | MIME-Version: 1.0 | ||
135 | To: tjh@cryptsoft.com | ||
136 | Subject: encrypted | ||
137 | Content-Type: application/x-pkcs7-mime; name="smime.p7m" | ||
138 | Content-Transfer-Encoding: base64 | ||
139 | Content-Disposition: attachment; filename="smime.p7m" | ||
140 | Content-Description: S/MIME Encrypted Message | ||
141 | Content-Length: 905 | ||
142 | Status: OR | ||
143 | |||
144 | MIAGCSqGSIb3DQEHA6CAMIACAQAxggHmMIHwAgEAMIGZMIGSMQswCQYDVQQGEwJBVTETMBEG | ||
145 | A1UECBMKUXVlZW5zbGFuZDERMA8GA1UEBxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29m | ||
146 | dCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNUUkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQD | ||
147 | ExJERU1PIFpFUk8gVkFMVUUgQ0ECAgR+MA0GCSqGSIb3DQEBAQUABEA92N29Yk39RUY2tIVd | ||
148 | exGT2MFX3J6H8LB8aDRJjw7843ALgJ5zXpM5+f80QkAWwEN2A6Pl3VxiCeKLi435zXVyMIHw | ||
149 | AgEAMIGZMIGSMQswCQYDVQQGEwJBVTETMBEGA1UECBMKUXVlZW5zbGFuZDERMA8GA1UEBxMI | ||
150 | QnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29mdCBQdHkgTHRkMSIwIAYDVQQLExlERU1PTlNU | ||
151 | UkFUSU9OIEFORCBURVNUSU5HMRswGQYDVQQDExJERU1PIFpFUk8gVkFMVUUgQ0ECAgRuMA0G | ||
152 | CSqGSIb3DQEBAQUABECR9IfyHtvnjFmZ8B2oUCEs1vxMsG0u1kxKE4RMPFyDqDCEARq7zXMg | ||
153 | nzSUI7Wgv5USSKDqcLRJeW+jvYURv/nJMIAGCSqGSIb3DQEHATAaBggqhkiG9w0DAjAOAgIA | ||
154 | oAQIrLqrij2ZMpeggAQoibtn6reRZWuWk5Iv5IAhgitr8EYE4w4ySQ7EMB6mTlBoFpccUMWX | ||
155 | BwQgQn1UoWCvYAlhDzURdbui64Dc0rS2wtj+kE/InS6y25EEEPe4NUKaF8/UlE+lo3LtILQE | ||
156 | CL3uV8k7m0iqAAAAAAAAAAAAAA== | ||
157 | |||
diff --git a/src/lib/libcrypto/pkcs7/t/s.pem b/src/lib/libcrypto/pkcs7/t/s.pem new file mode 100644 index 0000000000..4fa925b182 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/s.pem | |||
@@ -0,0 +1,57 @@ | |||
1 | -----BEGIN RSA PRIVATE KEY----- | ||
2 | MIIBOgIBAAJBAK3nI4nuDYe3nDJES5WBc90igEstxWC4/h4YY+/ciYki35U8ets9 | ||
3 | mgaoCNYp/e9BCZHtvK2Y+fYokGJv5+cMTQsCAwEAAQJBAIHpvXvqEcOEoDRRHuIG | ||
4 | fkcB4jPHcr9KE9TpxabH6xs9beN6OJnkePXAHwaz5MnUgSnbpOKq+cw8miKjXwe/ | ||
5 | zVECIQDVLwncT2lRmXarEYHzb+q/0uaSvKhWKKt3kJasLNTrAwIhANDUc/ghut29 | ||
6 | p3jJYjurzUKuG774/5eLjPLsxPPIZzNZAiA/10hSq41UnGqHLEUIS9m2/EeEZe7b | ||
7 | bm567dfRU9OnVQIgDo8ROrZXSchEGbaog5J5r/Fle83uO8l93R3GqVxKXZkCIFfk | ||
8 | IPD5PIYQAyyod3hyKKza7ZP4CGY4oOfZetbkSGGG | ||
9 | -----END RSA PRIVATE KEY----- | ||
10 | issuer :/C=AU/SP=Queensland/L=Brisbane/O=Cryptsoft Pty Ltd/OU=DEMONSTRATION AND TESTING/CN=DEMO ZERO VALUE CA | ||
11 | subject:/C=AU/SP=Queensland/L=Brisbane/O=Cryptsoft Pty Ltd/OU=SMIME 003/CN=Information/Email=info@cryptsoft.com | ||
12 | serial :047D | ||
13 | |||
14 | Certificate: | ||
15 | Data: | ||
16 | Version: 3 (0x2) | ||
17 | Serial Number: 1149 (0x47d) | ||
18 | Signature Algorithm: md5withRSAEncryption | ||
19 | Issuer: C=AU, SP=Queensland, L=Brisbane, O=Cryptsoft Pty Ltd, OU=DEMONSTRATION AND TESTING, CN=DEMO ZERO VALUE CA | ||
20 | Validity | ||
21 | Not Before: May 13 05:40:58 1998 GMT | ||
22 | Not After : May 12 05:40:58 2000 GMT | ||
23 | Subject: C=AU, SP=Queensland, L=Brisbane, O=Cryptsoft Pty Ltd, OU=SMIME 003, CN=Information/Email=info@cryptsoft.com | ||
24 | Subject Public Key Info: | ||
25 | Public Key Algorithm: rsaEncryption | ||
26 | Modulus: | ||
27 | 00:ad:e7:23:89:ee:0d:87:b7:9c:32:44:4b:95:81: | ||
28 | 73:dd:22:80:4b:2d:c5:60:b8:fe:1e:18:63:ef:dc: | ||
29 | 89:89:22:df:95:3c:7a:db:3d:9a:06:a8:08:d6:29: | ||
30 | fd:ef:41:09:91:ed:bc:ad:98:f9:f6:28:90:62:6f: | ||
31 | e7:e7:0c:4d:0b | ||
32 | Exponent: 65537 (0x10001) | ||
33 | X509v3 extensions: | ||
34 | Netscape Comment: | ||
35 | Generated with SSLeay | ||
36 | Signature Algorithm: md5withRSAEncryption | ||
37 | 52:15:ea:88:f4:f0:f9:0b:ef:ce:d5:f8:83:40:61:16:5e:55: | ||
38 | f9:ce:2d:d1:8b:31:5c:03:c6:2d:10:7c:61:d5:5c:0a:42:97: | ||
39 | d1:fd:65:b6:b6:84:a5:39:ec:46:ec:fc:e0:0d:d9:22:da:1b: | ||
40 | 50:74:ad:92:cb:4e:90:e5:fa:7d | ||
41 | |||
42 | -----BEGIN CERTIFICATE----- | ||
43 | MIICTDCCAfagAwIBAgICBH0wDQYJKoZIhvcNAQEEBQAwgZIxCzAJBgNVBAYTAkFV | ||
44 | MRMwEQYDVQQIEwpRdWVlbnNsYW5kMREwDwYDVQQHEwhCcmlzYmFuZTEaMBgGA1UE | ||
45 | ChMRQ3J5cHRzb2Z0IFB0eSBMdGQxIjAgBgNVBAsTGURFTU9OU1RSQVRJT04gQU5E | ||
46 | IFRFU1RJTkcxGzAZBgNVBAMTEkRFTU8gWkVSTyBWQUxVRSBDQTAeFw05ODA1MTMw | ||
47 | NTQwNThaFw0wMDA1MTIwNTQwNThaMIGeMQswCQYDVQQGEwJBVTETMBEGA1UECBMK | ||
48 | UXVlZW5zbGFuZDERMA8GA1UEBxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29m | ||
49 | dCBQdHkgTHRkMRIwEAYDVQQLEwlTTUlNRSAwMDMxFDASBgNVBAMTC0luZm9ybWF0 | ||
50 | aW9uMSEwHwYJKoZIhvcNAQkBFhJpbmZvQGNyeXB0c29mdC5jb20wXDANBgkqhkiG | ||
51 | 9w0BAQEFAANLADBIAkEArecjie4Nh7ecMkRLlYFz3SKASy3FYLj+Hhhj79yJiSLf | ||
52 | lTx62z2aBqgI1in970EJke28rZj59iiQYm/n5wxNCwIDAQABoygwJjAkBglghkgB | ||
53 | hvhCAQ0EFxYVR2VuZXJhdGVkIHdpdGggU1NMZWF5MA0GCSqGSIb3DQEBBAUAA0EA | ||
54 | UhXqiPTw+QvvztX4g0BhFl5V+c4t0YsxXAPGLRB8YdVcCkKX0f1ltraEpTnsRuz8 | ||
55 | 4A3ZItobUHStkstOkOX6fQ== | ||
56 | -----END CERTIFICATE----- | ||
57 | |||
diff --git a/src/lib/libcrypto/pkcs7/t/server.pem b/src/lib/libcrypto/pkcs7/t/server.pem new file mode 100644 index 0000000000..989baf8709 --- /dev/null +++ b/src/lib/libcrypto/pkcs7/t/server.pem | |||
@@ -0,0 +1,57 @@ | |||
1 | issuer :/C=AU/SP=Queensland/L=Brisbane/O=Cryptsoft Pty Ltd/OU=DEMONSTRATION AND TESTING/CN=DEMO ZERO VALUE CA | ||
2 | subject:/C=AU/SP=Queensland/L=Brisbane/O=Cryptsoft Pty Ltd/OU=SMIME 003/CN=Information/Email=info@cryptsoft.com | ||
3 | serial :047D | ||
4 | |||
5 | Certificate: | ||
6 | Data: | ||
7 | Version: 3 (0x2) | ||
8 | Serial Number: 1149 (0x47d) | ||
9 | Signature Algorithm: md5withRSAEncryption | ||
10 | Issuer: C=AU, SP=Queensland, L=Brisbane, O=Cryptsoft Pty Ltd, OU=DEMONSTRATION AND TESTING, CN=DEMO ZERO VALUE CA | ||
11 | Validity | ||
12 | Not Before: May 13 05:40:58 1998 GMT | ||
13 | Not After : May 12 05:40:58 2000 GMT | ||
14 | Subject: C=AU, SP=Queensland, L=Brisbane, O=Cryptsoft Pty Ltd, OU=SMIME 003, CN=Information/Email=info@cryptsoft.com | ||
15 | Subject Public Key Info: | ||
16 | Public Key Algorithm: rsaEncryption | ||
17 | Modulus: | ||
18 | 00:ad:e7:23:89:ee:0d:87:b7:9c:32:44:4b:95:81: | ||
19 | 73:dd:22:80:4b:2d:c5:60:b8:fe:1e:18:63:ef:dc: | ||
20 | 89:89:22:df:95:3c:7a:db:3d:9a:06:a8:08:d6:29: | ||
21 | fd:ef:41:09:91:ed:bc:ad:98:f9:f6:28:90:62:6f: | ||
22 | e7:e7:0c:4d:0b | ||
23 | Exponent: 65537 (0x10001) | ||
24 | X509v3 extensions: | ||
25 | Netscape Comment: | ||
26 | Generated with SSLeay | ||
27 | Signature Algorithm: md5withRSAEncryption | ||
28 | 52:15:ea:88:f4:f0:f9:0b:ef:ce:d5:f8:83:40:61:16:5e:55: | ||
29 | f9:ce:2d:d1:8b:31:5c:03:c6:2d:10:7c:61:d5:5c:0a:42:97: | ||
30 | d1:fd:65:b6:b6:84:a5:39:ec:46:ec:fc:e0:0d:d9:22:da:1b: | ||
31 | 50:74:ad:92:cb:4e:90:e5:fa:7d | ||
32 | |||
33 | -----BEGIN CERTIFICATE----- | ||
34 | MIICTDCCAfagAwIBAgICBH0wDQYJKoZIhvcNAQEEBQAwgZIxCzAJBgNVBAYTAkFV | ||
35 | MRMwEQYDVQQIEwpRdWVlbnNsYW5kMREwDwYDVQQHEwhCcmlzYmFuZTEaMBgGA1UE | ||
36 | ChMRQ3J5cHRzb2Z0IFB0eSBMdGQxIjAgBgNVBAsTGURFTU9OU1RSQVRJT04gQU5E | ||
37 | IFRFU1RJTkcxGzAZBgNVBAMTEkRFTU8gWkVSTyBWQUxVRSBDQTAeFw05ODA1MTMw | ||
38 | NTQwNThaFw0wMDA1MTIwNTQwNThaMIGeMQswCQYDVQQGEwJBVTETMBEGA1UECBMK | ||
39 | UXVlZW5zbGFuZDERMA8GA1UEBxMIQnJpc2JhbmUxGjAYBgNVBAoTEUNyeXB0c29m | ||
40 | dCBQdHkgTHRkMRIwEAYDVQQLEwlTTUlNRSAwMDMxFDASBgNVBAMTC0luZm9ybWF0 | ||
41 | aW9uMSEwHwYJKoZIhvcNAQkBFhJpbmZvQGNyeXB0c29mdC5jb20wXDANBgkqhkiG | ||
42 | 9w0BAQEFAANLADBIAkEArecjie4Nh7ecMkRLlYFz3SKASy3FYLj+Hhhj79yJiSLf | ||
43 | lTx62z2aBqgI1in970EJke28rZj59iiQYm/n5wxNCwIDAQABoygwJjAkBglghkgB | ||
44 | hvhCAQ0EFxYVR2VuZXJhdGVkIHdpdGggU1NMZWF5MA0GCSqGSIb3DQEBBAUAA0EA | ||
45 | UhXqiPTw+QvvztX4g0BhFl5V+c4t0YsxXAPGLRB8YdVcCkKX0f1ltraEpTnsRuz8 | ||
46 | 4A3ZItobUHStkstOkOX6fQ== | ||
47 | -----END CERTIFICATE----- | ||
48 | |||
49 | -----BEGIN RSA PRIVATE KEY----- | ||
50 | MIIBOgIBAAJBAK3nI4nuDYe3nDJES5WBc90igEstxWC4/h4YY+/ciYki35U8ets9 | ||
51 | mgaoCNYp/e9BCZHtvK2Y+fYokGJv5+cMTQsCAwEAAQJBAIHpvXvqEcOEoDRRHuIG | ||
52 | fkcB4jPHcr9KE9TpxabH6xs9beN6OJnkePXAHwaz5MnUgSnbpOKq+cw8miKjXwe/ | ||
53 | zVECIQDVLwncT2lRmXarEYHzb+q/0uaSvKhWKKt3kJasLNTrAwIhANDUc/ghut29 | ||
54 | p3jJYjurzUKuG774/5eLjPLsxPPIZzNZAiA/10hSq41UnGqHLEUIS9m2/EeEZe7b | ||
55 | bm567dfRU9OnVQIgDo8ROrZXSchEGbaog5J5r/Fle83uO8l93R3GqVxKXZkCIFfk | ||
56 | IPD5PIYQAyyod3hyKKza7ZP4CGY4oOfZetbkSGGG | ||
57 | -----END RSA PRIVATE KEY----- | ||
diff --git a/src/lib/libcrypto/pkcs7/verify.c b/src/lib/libcrypto/pkcs7/verify.c new file mode 100644 index 0000000000..b40f26032e --- /dev/null +++ b/src/lib/libcrypto/pkcs7/verify.c | |||
@@ -0,0 +1,263 @@ | |||
1 | /* crypto/pkcs7/verify.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 | #include <stdio.h> | ||
59 | #include <string.h> | ||
60 | #include <openssl/bio.h> | ||
61 | #include <openssl/asn1.h> | ||
62 | #include <openssl/x509.h> | ||
63 | #include <openssl/pem.h> | ||
64 | #include <openssl/err.h> | ||
65 | #include "example.h" | ||
66 | |||
67 | int verify_callback(int ok, X509_STORE_CTX *ctx); | ||
68 | |||
69 | BIO *bio_err=NULL; | ||
70 | BIO *bio_out=NULL; | ||
71 | |||
72 | int main(argc,argv) | ||
73 | int argc; | ||
74 | char *argv[]; | ||
75 | { | ||
76 | PKCS7 *p7; | ||
77 | PKCS7_SIGNER_INFO *si; | ||
78 | X509_STORE_CTX cert_ctx; | ||
79 | X509_STORE *cert_store=NULL; | ||
80 | BIO *data,*detached=NULL,*p7bio=NULL; | ||
81 | char buf[1024*4]; | ||
82 | char *pp; | ||
83 | int i,printit=0; | ||
84 | STACK_OF(PKCS7_SIGNER_INFO) *sk; | ||
85 | |||
86 | bio_err=BIO_new_fp(stderr,BIO_NOCLOSE); | ||
87 | bio_out=BIO_new_fp(stdout,BIO_NOCLOSE); | ||
88 | #ifndef OPENSSL_NO_MD2 | ||
89 | EVP_add_digest(EVP_md2()); | ||
90 | #endif | ||
91 | #ifndef OPENSSL_NO_MD5 | ||
92 | EVP_add_digest(EVP_md5()); | ||
93 | #endif | ||
94 | #ifndef OPENSSL_NO_SHA1 | ||
95 | EVP_add_digest(EVP_sha1()); | ||
96 | #endif | ||
97 | #ifndef OPENSSL_NO_MDC2 | ||
98 | EVP_add_digest(EVP_mdc2()); | ||
99 | #endif | ||
100 | |||
101 | data=BIO_new(BIO_s_file()); | ||
102 | |||
103 | pp=NULL; | ||
104 | while (argc > 1) | ||
105 | { | ||
106 | argc--; | ||
107 | argv++; | ||
108 | if (strcmp(argv[0],"-p") == 0) | ||
109 | { | ||
110 | printit=1; | ||
111 | } | ||
112 | else if ((strcmp(argv[0],"-d") == 0) && (argc >= 2)) | ||
113 | { | ||
114 | detached=BIO_new(BIO_s_file()); | ||
115 | if (!BIO_read_filename(detached,argv[1])) | ||
116 | goto err; | ||
117 | argc--; | ||
118 | argv++; | ||
119 | } | ||
120 | else | ||
121 | { | ||
122 | pp=argv[0]; | ||
123 | if (!BIO_read_filename(data,argv[0])) | ||
124 | goto err; | ||
125 | } | ||
126 | } | ||
127 | |||
128 | if (pp == NULL) | ||
129 | BIO_set_fp(data,stdin,BIO_NOCLOSE); | ||
130 | |||
131 | |||
132 | /* Load the PKCS7 object from a file */ | ||
133 | if ((p7=PEM_read_bio_PKCS7(data,NULL,NULL,NULL)) == NULL) goto err; | ||
134 | |||
135 | /* This stuff is being setup for certificate verification. | ||
136 | * When using SSL, it could be replaced with a | ||
137 | * cert_stre=SSL_CTX_get_cert_store(ssl_ctx); */ | ||
138 | cert_store=X509_STORE_new(); | ||
139 | X509_STORE_set_default_paths(cert_store); | ||
140 | X509_STORE_load_locations(cert_store,NULL,"../../certs"); | ||
141 | X509_STORE_set_verify_cb_func(cert_store,verify_callback); | ||
142 | |||
143 | ERR_clear_error(); | ||
144 | |||
145 | /* We need to process the data */ | ||
146 | if ((PKCS7_get_detached(p7) || detached)) | ||
147 | { | ||
148 | if (detached == NULL) | ||
149 | { | ||
150 | printf("no data to verify the signature on\n"); | ||
151 | exit(1); | ||
152 | } | ||
153 | else | ||
154 | p7bio=PKCS7_dataInit(p7,detached); | ||
155 | } | ||
156 | else | ||
157 | { | ||
158 | p7bio=PKCS7_dataInit(p7,NULL); | ||
159 | } | ||
160 | |||
161 | /* We now have to 'read' from p7bio to calculate digests etc. */ | ||
162 | for (;;) | ||
163 | { | ||
164 | i=BIO_read(p7bio,buf,sizeof(buf)); | ||
165 | /* print it? */ | ||
166 | if (i <= 0) break; | ||
167 | } | ||
168 | |||
169 | /* We can now verify signatures */ | ||
170 | sk=PKCS7_get_signer_info(p7); | ||
171 | if (sk == NULL) | ||
172 | { | ||
173 | printf("there are no signatures on this data\n"); | ||
174 | exit(1); | ||
175 | } | ||
176 | |||
177 | /* Ok, first we need to, for each subject entry, see if we can verify */ | ||
178 | for (i=0; i<sk_PKCS7_SIGNER_INFO_num(sk); i++) | ||
179 | { | ||
180 | ASN1_UTCTIME *tm; | ||
181 | char *str1,*str2; | ||
182 | int rc; | ||
183 | |||
184 | si=sk_PKCS7_SIGNER_INFO_value(sk,i); | ||
185 | rc=PKCS7_dataVerify(cert_store,&cert_ctx,p7bio,p7,si); | ||
186 | if (rc <= 0) | ||
187 | goto err; | ||
188 | printf("signer info\n"); | ||
189 | if ((tm=get_signed_time(si)) != NULL) | ||
190 | { | ||
191 | BIO_printf(bio_out,"Signed time:"); | ||
192 | ASN1_UTCTIME_print(bio_out,tm); | ||
193 | ASN1_UTCTIME_free(tm); | ||
194 | BIO_printf(bio_out,"\n"); | ||
195 | } | ||
196 | if (get_signed_seq2string(si,&str1,&str2)) | ||
197 | { | ||
198 | BIO_printf(bio_out,"String 1 is %s\n",str1); | ||
199 | BIO_printf(bio_out,"String 2 is %s\n",str2); | ||
200 | } | ||
201 | |||
202 | } | ||
203 | |||
204 | X509_STORE_free(cert_store); | ||
205 | |||
206 | printf("done\n"); | ||
207 | exit(0); | ||
208 | err: | ||
209 | ERR_load_crypto_strings(); | ||
210 | ERR_print_errors_fp(stderr); | ||
211 | exit(1); | ||
212 | } | ||
213 | |||
214 | /* should be X509 * but we can just have them as char *. */ | ||
215 | int verify_callback(int ok, X509_STORE_CTX *ctx) | ||
216 | { | ||
217 | char buf[256]; | ||
218 | X509 *err_cert; | ||
219 | int err,depth; | ||
220 | |||
221 | err_cert=X509_STORE_CTX_get_current_cert(ctx); | ||
222 | err= X509_STORE_CTX_get_error(ctx); | ||
223 | depth= X509_STORE_CTX_get_error_depth(ctx); | ||
224 | |||
225 | X509_NAME_oneline(X509_get_subject_name(err_cert),buf,256); | ||
226 | BIO_printf(bio_err,"depth=%d %s\n",depth,buf); | ||
227 | if (!ok) | ||
228 | { | ||
229 | BIO_printf(bio_err,"verify error:num=%d:%s\n",err, | ||
230 | X509_verify_cert_error_string(err)); | ||
231 | if (depth < 6) | ||
232 | { | ||
233 | ok=1; | ||
234 | X509_STORE_CTX_set_error(ctx,X509_V_OK); | ||
235 | } | ||
236 | else | ||
237 | { | ||
238 | ok=0; | ||
239 | X509_STORE_CTX_set_error(ctx,X509_V_ERR_CERT_CHAIN_TOO_LONG); | ||
240 | } | ||
241 | } | ||
242 | switch (ctx->error) | ||
243 | { | ||
244 | case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT: | ||
245 | X509_NAME_oneline(X509_get_issuer_name(ctx->current_cert),buf,256); | ||
246 | BIO_printf(bio_err,"issuer= %s\n",buf); | ||
247 | break; | ||
248 | case X509_V_ERR_CERT_NOT_YET_VALID: | ||
249 | case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD: | ||
250 | BIO_printf(bio_err,"notBefore="); | ||
251 | ASN1_UTCTIME_print(bio_err,X509_get_notBefore(ctx->current_cert)); | ||
252 | BIO_printf(bio_err,"\n"); | ||
253 | break; | ||
254 | case X509_V_ERR_CERT_HAS_EXPIRED: | ||
255 | case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD: | ||
256 | BIO_printf(bio_err,"notAfter="); | ||
257 | ASN1_UTCTIME_print(bio_err,X509_get_notAfter(ctx->current_cert)); | ||
258 | BIO_printf(bio_err,"\n"); | ||
259 | break; | ||
260 | } | ||
261 | BIO_printf(bio_err,"verify return:%d\n",ok); | ||
262 | return(ok); | ||
263 | } | ||