2c8dd8713637e3989d641f0a7ed88cf779d06d00
[openssl.git] / crypto / pkcs7 / pk7_doit.c
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 "internal/cryptlib.h"
61 #include <openssl/rand.h>
62 #include <openssl/objects.h>
63 #include <openssl/x509.h>
64 #include <openssl/x509v3.h>
65 #include <openssl/err.h>
66
67 static int add_attribute(STACK_OF(X509_ATTRIBUTE) **sk, int nid, int atrtype,
68                          void *value);
69 static ASN1_TYPE *get_attribute(STACK_OF(X509_ATTRIBUTE) *sk, int nid);
70
71 static int PKCS7_type_is_other(PKCS7 *p7)
72 {
73     int isOther = 1;
74
75     int nid = OBJ_obj2nid(p7->type);
76
77     switch (nid) {
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 static int PKCS7_bio_add_digest(BIO **pbio, X509_ALGOR *alg)
105 {
106     BIO *btmp;
107     const EVP_MD *md;
108     if ((btmp = BIO_new(BIO_f_md())) == NULL) {
109         PKCS7err(PKCS7_F_PKCS7_BIO_ADD_DIGEST, ERR_R_BIO_LIB);
110         goto err;
111     }
112
113     md = EVP_get_digestbyobj(alg->algorithm);
114     if (md == NULL) {
115         PKCS7err(PKCS7_F_PKCS7_BIO_ADD_DIGEST, PKCS7_R_UNKNOWN_DIGEST_TYPE);
116         goto err;
117     }
118
119     BIO_set_md(btmp, md);
120     if (*pbio == NULL)
121         *pbio = btmp;
122     else if (!BIO_push(*pbio, btmp)) {
123         PKCS7err(PKCS7_F_PKCS7_BIO_ADD_DIGEST, ERR_R_BIO_LIB);
124         goto err;
125     }
126     btmp = NULL;
127
128     return 1;
129
130  err:
131     BIO_free(btmp);
132     return 0;
133
134 }
135
136 static int pkcs7_encode_rinfo(PKCS7_RECIP_INFO *ri,
137                               unsigned char *key, int keylen)
138 {
139     EVP_PKEY_CTX *pctx = NULL;
140     EVP_PKEY *pkey = NULL;
141     unsigned char *ek = NULL;
142     int ret = 0;
143     size_t eklen;
144
145     pkey = X509_get_pubkey(ri->cert);
146
147     if (!pkey)
148         return 0;
149
150     pctx = EVP_PKEY_CTX_new(pkey, NULL);
151     if (!pctx)
152         return 0;
153
154     if (EVP_PKEY_encrypt_init(pctx) <= 0)
155         goto err;
156
157     if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_ENCRYPT,
158                           EVP_PKEY_CTRL_PKCS7_ENCRYPT, 0, ri) <= 0) {
159         PKCS7err(PKCS7_F_PKCS7_ENCODE_RINFO, PKCS7_R_CTRL_ERROR);
160         goto err;
161     }
162
163     if (EVP_PKEY_encrypt(pctx, NULL, &eklen, key, keylen) <= 0)
164         goto err;
165
166     ek = OPENSSL_malloc(eklen);
167
168     if (ek == NULL) {
169         PKCS7err(PKCS7_F_PKCS7_ENCODE_RINFO, ERR_R_MALLOC_FAILURE);
170         goto err;
171     }
172
173     if (EVP_PKEY_encrypt(pctx, ek, &eklen, key, keylen) <= 0)
174         goto err;
175
176     ASN1_STRING_set0(ri->enc_key, ek, eklen);
177     ek = NULL;
178
179     ret = 1;
180
181  err:
182     EVP_PKEY_free(pkey);
183     EVP_PKEY_CTX_free(pctx);
184     OPENSSL_free(ek);
185     return ret;
186
187 }
188
189 static int pkcs7_decrypt_rinfo(unsigned char **pek, int *peklen,
190                                PKCS7_RECIP_INFO *ri, EVP_PKEY *pkey)
191 {
192     EVP_PKEY_CTX *pctx = NULL;
193     unsigned char *ek = NULL;
194     size_t eklen;
195
196     int ret = -1;
197
198     pctx = EVP_PKEY_CTX_new(pkey, NULL);
199     if (!pctx)
200         return -1;
201
202     if (EVP_PKEY_decrypt_init(pctx) <= 0)
203         goto err;
204
205     if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DECRYPT,
206                           EVP_PKEY_CTRL_PKCS7_DECRYPT, 0, ri) <= 0) {
207         PKCS7err(PKCS7_F_PKCS7_DECRYPT_RINFO, PKCS7_R_CTRL_ERROR);
208         goto err;
209     }
210
211     if (EVP_PKEY_decrypt(pctx, NULL, &eklen,
212                          ri->enc_key->data, ri->enc_key->length) <= 0)
213         goto err;
214
215     ek = OPENSSL_malloc(eklen);
216
217     if (ek == NULL) {
218         PKCS7err(PKCS7_F_PKCS7_DECRYPT_RINFO, ERR_R_MALLOC_FAILURE);
219         goto err;
220     }
221
222     if (EVP_PKEY_decrypt(pctx, ek, &eklen,
223                          ri->enc_key->data, ri->enc_key->length) <= 0) {
224         ret = 0;
225         PKCS7err(PKCS7_F_PKCS7_DECRYPT_RINFO, ERR_R_EVP_LIB);
226         goto err;
227     }
228
229     ret = 1;
230
231     OPENSSL_clear_free(*pek, *peklen);
232     *pek = ek;
233     *peklen = eklen;
234
235  err:
236     EVP_PKEY_CTX_free(pctx);
237     if (!ret)
238         OPENSSL_free(ek);
239
240     return ret;
241 }
242
243 BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio)
244 {
245     int i;
246     BIO *out = NULL, *btmp = NULL;
247     X509_ALGOR *xa = NULL;
248     const EVP_CIPHER *evp_cipher = NULL;
249     STACK_OF(X509_ALGOR) *md_sk = NULL;
250     STACK_OF(PKCS7_RECIP_INFO) *rsk = NULL;
251     X509_ALGOR *xalg = NULL;
252     PKCS7_RECIP_INFO *ri = NULL;
253     ASN1_OCTET_STRING *os = NULL;
254
255     if (p7 == NULL) {
256         PKCS7err(PKCS7_F_PKCS7_DATAINIT, PKCS7_R_INVALID_NULL_POINTER);
257         return NULL;
258     }
259     /*
260      * The content field in the PKCS7 ContentInfo is optional, but that really
261      * only applies to inner content (precisely, detached signatures).
262      *
263      * When reading content, missing outer content is therefore treated as an
264      * error.
265      *
266      * When creating content, PKCS7_content_new() must be called before
267      * calling this method, so a NULL p7->d is always an error.
268      */
269     if (p7->d.ptr == NULL) {
270         PKCS7err(PKCS7_F_PKCS7_DATAINIT, PKCS7_R_NO_CONTENT);
271         return NULL;
272     }
273
274     i = OBJ_obj2nid(p7->type);
275     p7->state = PKCS7_S_HEADER;
276
277     switch (i) {
278     case NID_pkcs7_signed:
279         md_sk = p7->d.sign->md_algs;
280         os = PKCS7_get_octet_string(p7->d.sign->contents);
281         break;
282     case NID_pkcs7_signedAndEnveloped:
283         rsk = p7->d.signed_and_enveloped->recipientinfo;
284         md_sk = p7->d.signed_and_enveloped->md_algs;
285         xalg = p7->d.signed_and_enveloped->enc_data->algorithm;
286         evp_cipher = p7->d.signed_and_enveloped->enc_data->cipher;
287         if (evp_cipher == NULL) {
288             PKCS7err(PKCS7_F_PKCS7_DATAINIT, PKCS7_R_CIPHER_NOT_INITIALIZED);
289             goto err;
290         }
291         break;
292     case NID_pkcs7_enveloped:
293         rsk = p7->d.enveloped->recipientinfo;
294         xalg = p7->d.enveloped->enc_data->algorithm;
295         evp_cipher = p7->d.enveloped->enc_data->cipher;
296         if (evp_cipher == NULL) {
297             PKCS7err(PKCS7_F_PKCS7_DATAINIT, PKCS7_R_CIPHER_NOT_INITIALIZED);
298             goto err;
299         }
300         break;
301     case NID_pkcs7_digest:
302         xa = p7->d.digest->md;
303         os = PKCS7_get_octet_string(p7->d.digest->contents);
304         break;
305     case NID_pkcs7_data:
306         break;
307     default:
308         PKCS7err(PKCS7_F_PKCS7_DATAINIT, PKCS7_R_UNSUPPORTED_CONTENT_TYPE);
309         goto err;
310     }
311
312     for (i = 0; i < sk_X509_ALGOR_num(md_sk); i++)
313         if (!PKCS7_bio_add_digest(&out, sk_X509_ALGOR_value(md_sk, i)))
314             goto err;
315
316     if (xa && !PKCS7_bio_add_digest(&out, xa))
317         goto err;
318
319     if (evp_cipher != NULL) {
320         unsigned char key[EVP_MAX_KEY_LENGTH];
321         unsigned char iv[EVP_MAX_IV_LENGTH];
322         int keylen, ivlen;
323         EVP_CIPHER_CTX *ctx;
324
325         if ((btmp = BIO_new(BIO_f_cipher())) == NULL) {
326             PKCS7err(PKCS7_F_PKCS7_DATAINIT, ERR_R_BIO_LIB);
327             goto err;
328         }
329         BIO_get_cipher_ctx(btmp, &ctx);
330         keylen = EVP_CIPHER_key_length(evp_cipher);
331         ivlen = EVP_CIPHER_iv_length(evp_cipher);
332         xalg->algorithm = OBJ_nid2obj(EVP_CIPHER_type(evp_cipher));
333         if (ivlen > 0)
334             if (RAND_bytes(iv, ivlen) <= 0)
335                 goto err;
336         if (EVP_CipherInit_ex(ctx, evp_cipher, NULL, NULL, NULL, 1) <= 0)
337             goto err;
338         if (EVP_CIPHER_CTX_rand_key(ctx, key) <= 0)
339             goto err;
340         if (EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, 1) <= 0)
341             goto err;
342
343         if (ivlen > 0) {
344             if (xalg->parameter == NULL) {
345                 xalg->parameter = ASN1_TYPE_new();
346                 if (xalg->parameter == NULL)
347                     goto err;
348             }
349             if (EVP_CIPHER_param_to_asn1(ctx, xalg->parameter) < 0)
350                 goto err;
351         }
352
353         /* Lets do the pub key stuff :-) */
354         for (i = 0; i < sk_PKCS7_RECIP_INFO_num(rsk); i++) {
355             ri = sk_PKCS7_RECIP_INFO_value(rsk, i);
356             if (pkcs7_encode_rinfo(ri, key, keylen) <= 0)
357                 goto err;
358         }
359         OPENSSL_cleanse(key, keylen);
360
361         if (out == NULL)
362             out = btmp;
363         else
364             BIO_push(out, btmp);
365         btmp = NULL;
366     }
367
368     if (bio == NULL) {
369         if (PKCS7_is_detached(p7))
370             bio = BIO_new(BIO_s_null());
371         else if (os && os->length > 0)
372             bio = BIO_new_mem_buf(os->data, os->length);
373         if (bio == NULL) {
374             bio = BIO_new(BIO_s_mem());
375             if (bio == NULL)
376                 goto err;
377             BIO_set_mem_eof_return(bio, 0);
378         }
379     }
380     if (out)
381         BIO_push(out, bio);
382     else
383         out = bio;
384     return out;
385
386  err:
387     BIO_free_all(out);
388     BIO_free_all(btmp);
389     return NULL;
390 }
391
392 static int pkcs7_cmp_ri(PKCS7_RECIP_INFO *ri, X509 *pcert)
393 {
394     int ret;
395     ret = X509_NAME_cmp(ri->issuer_and_serial->issuer,
396                         pcert->cert_info->issuer);
397     if (ret)
398         return ret;
399     return ASN1_INTEGER_cmp(pcert->cert_info->serialNumber,
400                               ri->issuer_and_serial->serial);
401 }
402
403 /* int */
404 BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert)
405 {
406     int i, j;
407     BIO *out = NULL, *btmp = NULL, *etmp = NULL, *bio = NULL;
408     X509_ALGOR *xa;
409     ASN1_OCTET_STRING *data_body = NULL;
410     const EVP_MD *evp_md;
411     const EVP_CIPHER *evp_cipher = NULL;
412     EVP_CIPHER_CTX *evp_ctx = NULL;
413     X509_ALGOR *enc_alg = NULL;
414     STACK_OF(X509_ALGOR) *md_sk = NULL;
415     STACK_OF(PKCS7_RECIP_INFO) *rsk = NULL;
416     PKCS7_RECIP_INFO *ri = NULL;
417     unsigned char *ek = NULL, *tkey = NULL;
418     int eklen = 0, tkeylen = 0;
419
420     if (p7 == NULL) {
421         PKCS7err(PKCS7_F_PKCS7_DATADECODE, PKCS7_R_INVALID_NULL_POINTER);
422         return NULL;
423     }
424
425     if (p7->d.ptr == NULL) {
426         PKCS7err(PKCS7_F_PKCS7_DATADECODE, PKCS7_R_NO_CONTENT);
427         return NULL;
428     }
429
430     i = OBJ_obj2nid(p7->type);
431     p7->state = PKCS7_S_HEADER;
432
433     switch (i) {
434     case NID_pkcs7_signed:
435         data_body = PKCS7_get_octet_string(p7->d.sign->contents);
436         if (!PKCS7_is_detached(p7) && data_body == NULL) {
437             PKCS7err(PKCS7_F_PKCS7_DATADECODE,
438                      PKCS7_R_INVALID_SIGNED_DATA_TYPE);
439             goto err;
440         }
441         md_sk = p7->d.sign->md_algs;
442         break;
443     case NID_pkcs7_signedAndEnveloped:
444         rsk = p7->d.signed_and_enveloped->recipientinfo;
445         md_sk = p7->d.signed_and_enveloped->md_algs;
446         data_body = p7->d.signed_and_enveloped->enc_data->enc_data;
447         enc_alg = p7->d.signed_and_enveloped->enc_data->algorithm;
448         evp_cipher = EVP_get_cipherbyobj(enc_alg->algorithm);
449         if (evp_cipher == NULL) {
450             PKCS7err(PKCS7_F_PKCS7_DATADECODE,
451                      PKCS7_R_UNSUPPORTED_CIPHER_TYPE);
452             goto err;
453         }
454         break;
455     case NID_pkcs7_enveloped:
456         rsk = p7->d.enveloped->recipientinfo;
457         enc_alg = p7->d.enveloped->enc_data->algorithm;
458         data_body = p7->d.enveloped->enc_data->enc_data;
459         evp_cipher = EVP_get_cipherbyobj(enc_alg->algorithm);
460         if (evp_cipher == NULL) {
461             PKCS7err(PKCS7_F_PKCS7_DATADECODE,
462                      PKCS7_R_UNSUPPORTED_CIPHER_TYPE);
463             goto err;
464         }
465         break;
466     default:
467         PKCS7err(PKCS7_F_PKCS7_DATADECODE, PKCS7_R_UNSUPPORTED_CONTENT_TYPE);
468         goto err;
469     }
470
471     /* We will be checking the signature */
472     if (md_sk != NULL) {
473         for (i = 0; i < sk_X509_ALGOR_num(md_sk); i++) {
474             xa = sk_X509_ALGOR_value(md_sk, i);
475             if ((btmp = BIO_new(BIO_f_md())) == NULL) {
476                 PKCS7err(PKCS7_F_PKCS7_DATADECODE, ERR_R_BIO_LIB);
477                 goto err;
478             }
479
480             j = OBJ_obj2nid(xa->algorithm);
481             evp_md = EVP_get_digestbynid(j);
482             if (evp_md == NULL) {
483                 PKCS7err(PKCS7_F_PKCS7_DATADECODE,
484                          PKCS7_R_UNKNOWN_DIGEST_TYPE);
485                 goto err;
486             }
487
488             BIO_set_md(btmp, evp_md);
489             if (out == NULL)
490                 out = btmp;
491             else
492                 BIO_push(out, btmp);
493             btmp = NULL;
494         }
495     }
496
497     if (evp_cipher != NULL) {
498         if ((etmp = BIO_new(BIO_f_cipher())) == NULL) {
499             PKCS7err(PKCS7_F_PKCS7_DATADECODE, ERR_R_BIO_LIB);
500             goto err;
501         }
502
503         /*
504          * It was encrypted, we need to decrypt the secret key with the
505          * private key
506          */
507
508         /*
509          * Find the recipientInfo which matches the passed certificate (if
510          * any)
511          */
512
513         if (pcert) {
514             for (i = 0; i < sk_PKCS7_RECIP_INFO_num(rsk); i++) {
515                 ri = sk_PKCS7_RECIP_INFO_value(rsk, i);
516                 if (!pkcs7_cmp_ri(ri, pcert))
517                     break;
518                 ri = NULL;
519             }
520             if (ri == NULL) {
521                 PKCS7err(PKCS7_F_PKCS7_DATADECODE,
522                          PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE);
523                 goto err;
524             }
525         }
526
527         /* If we haven't got a certificate try each ri in turn */
528         if (pcert == NULL) {
529             /*
530              * Always attempt to decrypt all rinfo even after success as a
531              * defence against MMA timing attacks.
532              */
533             for (i = 0; i < sk_PKCS7_RECIP_INFO_num(rsk); i++) {
534                 ri = sk_PKCS7_RECIP_INFO_value(rsk, i);
535
536                 if (pkcs7_decrypt_rinfo(&ek, &eklen, ri, pkey) < 0)
537                     goto err;
538                 ERR_clear_error();
539             }
540         } else {
541             /* Only exit on fatal errors, not decrypt failure */
542             if (pkcs7_decrypt_rinfo(&ek, &eklen, ri, pkey) < 0)
543                 goto err;
544             ERR_clear_error();
545         }
546
547         evp_ctx = NULL;
548         BIO_get_cipher_ctx(etmp, &evp_ctx);
549         if (EVP_CipherInit_ex(evp_ctx, evp_cipher, NULL, NULL, NULL, 0) <= 0)
550             goto err;
551         if (EVP_CIPHER_asn1_to_param(evp_ctx, enc_alg->parameter) < 0)
552             goto err;
553         /* Generate random key as MMA defence */
554         tkeylen = EVP_CIPHER_CTX_key_length(evp_ctx);
555         tkey = OPENSSL_malloc(tkeylen);
556         if (!tkey)
557             goto err;
558         if (EVP_CIPHER_CTX_rand_key(evp_ctx, tkey) <= 0)
559             goto err;
560         if (ek == NULL) {
561             ek = tkey;
562             eklen = tkeylen;
563             tkey = NULL;
564         }
565
566         if (eklen != EVP_CIPHER_CTX_key_length(evp_ctx)) {
567             /*
568              * Some S/MIME clients don't use the same key and effective key
569              * length. The key length is determined by the size of the
570              * decrypted RSA key.
571              */
572             if (!EVP_CIPHER_CTX_set_key_length(evp_ctx, eklen)) {
573                 /* Use random key as MMA defence */
574                 OPENSSL_clear_free(ek, eklen);
575                 ek = tkey;
576                 eklen = tkeylen;
577                 tkey = NULL;
578             }
579         }
580         /* Clear errors so we don't leak information useful in MMA */
581         ERR_clear_error();
582         if (EVP_CipherInit_ex(evp_ctx, NULL, NULL, ek, NULL, 0) <= 0)
583             goto err;
584
585         OPENSSL_clear_free(ek, eklen);
586         ek = NULL;
587         OPENSSL_clear_free(tkey, tkeylen);
588         tkey = NULL;
589
590         if (out == NULL)
591             out = etmp;
592         else
593             BIO_push(out, etmp);
594         etmp = NULL;
595     }
596     if (PKCS7_is_detached(p7) || (in_bio != NULL)) {
597         bio = in_bio;
598     } else {
599         if (data_body->length > 0)
600             bio = BIO_new_mem_buf(data_body->data, data_body->length);
601         else {
602             bio = BIO_new(BIO_s_mem());
603             BIO_set_mem_eof_return(bio, 0);
604         }
605         if (bio == NULL)
606             goto err;
607     }
608     BIO_push(out, bio);
609     bio = NULL;
610     return out;
611
612  err:
613     OPENSSL_clear_free(ek, eklen);
614     OPENSSL_clear_free(tkey, tkeylen);
615     BIO_free_all(out);
616     BIO_free_all(btmp);
617     BIO_free_all(etmp);
618     BIO_free_all(bio);
619     return  NULL;
620 }
621
622 static BIO *PKCS7_find_digest(EVP_MD_CTX **pmd, BIO *bio, int nid)
623 {
624     for (;;) {
625         bio = BIO_find_type(bio, BIO_TYPE_MD);
626         if (bio == NULL) {
627             PKCS7err(PKCS7_F_PKCS7_FIND_DIGEST,
628                      PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST);
629             return NULL;
630         }
631         BIO_get_md_ctx(bio, pmd);
632         if (*pmd == NULL) {
633             PKCS7err(PKCS7_F_PKCS7_FIND_DIGEST, ERR_R_INTERNAL_ERROR);
634             return NULL;
635         }
636         if (EVP_MD_CTX_type(*pmd) == nid)
637             return bio;
638         bio = BIO_next(bio);
639     }
640     return NULL;
641 }
642
643 static int do_pkcs7_signed_attrib(PKCS7_SIGNER_INFO *si, EVP_MD_CTX *mctx)
644 {
645     unsigned char md_data[EVP_MAX_MD_SIZE];
646     unsigned int md_len;
647
648     /* Add signing time if not already present */
649     if (!PKCS7_get_signed_attribute(si, NID_pkcs9_signingTime)) {
650         if (!PKCS7_add0_attrib_signing_time(si, NULL)) {
651             PKCS7err(PKCS7_F_DO_PKCS7_SIGNED_ATTRIB, ERR_R_MALLOC_FAILURE);
652             return 0;
653         }
654     }
655
656     /* Add digest */
657     if (!EVP_DigestFinal_ex(mctx, md_data, &md_len)) {
658         PKCS7err(PKCS7_F_DO_PKCS7_SIGNED_ATTRIB, ERR_R_EVP_LIB);
659         return 0;
660     }
661     if (!PKCS7_add1_attrib_digest(si, md_data, md_len)) {
662         PKCS7err(PKCS7_F_DO_PKCS7_SIGNED_ATTRIB, ERR_R_MALLOC_FAILURE);
663         return 0;
664     }
665
666     /* Now sign the attributes */
667     if (!PKCS7_SIGNER_INFO_sign(si))
668         return 0;
669
670     return 1;
671 }
672
673 int PKCS7_dataFinal(PKCS7 *p7, BIO *bio)
674 {
675     int ret = 0;
676     int i, j;
677     BIO *btmp;
678     PKCS7_SIGNER_INFO *si;
679     EVP_MD_CTX *mdc, ctx_tmp;
680     STACK_OF(X509_ATTRIBUTE) *sk;
681     STACK_OF(PKCS7_SIGNER_INFO) *si_sk = NULL;
682     ASN1_OCTET_STRING *os = NULL;
683
684     if (p7 == NULL) {
685         PKCS7err(PKCS7_F_PKCS7_DATAFINAL, PKCS7_R_INVALID_NULL_POINTER);
686         return 0;
687     }
688
689     if (p7->d.ptr == NULL) {
690         PKCS7err(PKCS7_F_PKCS7_DATAFINAL, PKCS7_R_NO_CONTENT);
691         return 0;
692     }
693
694     EVP_MD_CTX_init(&ctx_tmp);
695     i = OBJ_obj2nid(p7->type);
696     p7->state = PKCS7_S_HEADER;
697
698     switch (i) {
699     case NID_pkcs7_data:
700         os = p7->d.data;
701         break;
702     case NID_pkcs7_signedAndEnveloped:
703         /* XXXXXXXXXXXXXXXX */
704         si_sk = p7->d.signed_and_enveloped->signer_info;
705         os = p7->d.signed_and_enveloped->enc_data->enc_data;
706         if (!os) {
707             os = ASN1_OCTET_STRING_new();
708             if (!os) {
709                 PKCS7err(PKCS7_F_PKCS7_DATAFINAL, ERR_R_MALLOC_FAILURE);
710                 goto err;
711             }
712             p7->d.signed_and_enveloped->enc_data->enc_data = os;
713         }
714         break;
715     case NID_pkcs7_enveloped:
716         /* XXXXXXXXXXXXXXXX */
717         os = p7->d.enveloped->enc_data->enc_data;
718         if (!os) {
719             os = ASN1_OCTET_STRING_new();
720             if (!os) {
721                 PKCS7err(PKCS7_F_PKCS7_DATAFINAL, ERR_R_MALLOC_FAILURE);
722                 goto err;
723             }
724             p7->d.enveloped->enc_data->enc_data = os;
725         }
726         break;
727     case NID_pkcs7_signed:
728         si_sk = p7->d.sign->signer_info;
729         os = PKCS7_get_octet_string(p7->d.sign->contents);
730         /* If detached data then the content is excluded */
731         if (PKCS7_type_is_data(p7->d.sign->contents) && p7->detached) {
732             ASN1_OCTET_STRING_free(os);
733             os = NULL;
734             p7->d.sign->contents->d.data = NULL;
735         }
736         break;
737
738     case NID_pkcs7_digest:
739         os = PKCS7_get_octet_string(p7->d.digest->contents);
740         /* If detached data then the content is excluded */
741         if (PKCS7_type_is_data(p7->d.digest->contents) && p7->detached) {
742             ASN1_OCTET_STRING_free(os);
743             os = NULL;
744             p7->d.digest->contents->d.data = NULL;
745         }
746         break;
747
748     default:
749         PKCS7err(PKCS7_F_PKCS7_DATAFINAL, PKCS7_R_UNSUPPORTED_CONTENT_TYPE);
750         goto err;
751     }
752
753     if (si_sk != NULL) {
754         for (i = 0; i < sk_PKCS7_SIGNER_INFO_num(si_sk); i++) {
755             si = sk_PKCS7_SIGNER_INFO_value(si_sk, i);
756             if (si->pkey == NULL)
757                 continue;
758
759             j = OBJ_obj2nid(si->digest_alg->algorithm);
760
761             btmp = bio;
762
763             btmp = PKCS7_find_digest(&mdc, btmp, j);
764
765             if (btmp == NULL)
766                 goto err;
767
768             /*
769              * We now have the EVP_MD_CTX, lets do the signing.
770              */
771             if (!EVP_MD_CTX_copy_ex(&ctx_tmp, mdc))
772                 goto err;
773
774             sk = si->auth_attr;
775
776             /*
777              * If there are attributes, we add the digest attribute and only
778              * sign the attributes
779              */
780             if (sk_X509_ATTRIBUTE_num(sk) > 0) {
781                 if (!do_pkcs7_signed_attrib(si, &ctx_tmp))
782                     goto err;
783             } else {
784                 unsigned char *abuf = NULL;
785                 unsigned int abuflen;
786                 abuflen = EVP_PKEY_size(si->pkey);
787                 abuf = OPENSSL_malloc(abuflen);
788                 if (!abuf)
789                     goto err;
790
791                 if (!EVP_SignFinal(&ctx_tmp, abuf, &abuflen, si->pkey)) {
792                     PKCS7err(PKCS7_F_PKCS7_DATAFINAL, ERR_R_EVP_LIB);
793                     goto err;
794                 }
795                 ASN1_STRING_set0(si->enc_digest, abuf, abuflen);
796             }
797         }
798     } else if (i == NID_pkcs7_digest) {
799         unsigned char md_data[EVP_MAX_MD_SIZE];
800         unsigned int md_len;
801         if (!PKCS7_find_digest(&mdc, bio,
802                                OBJ_obj2nid(p7->d.digest->md->algorithm)))
803             goto err;
804         if (!EVP_DigestFinal_ex(mdc, md_data, &md_len))
805             goto err;
806         ASN1_OCTET_STRING_set(p7->d.digest->digest, md_data, md_len);
807     }
808
809     if (!PKCS7_is_detached(p7)) {
810         /*
811          * NOTE(emilia): I think we only reach os == NULL here because detached
812          * digested data support is broken.
813          */
814         if (os == NULL)
815             goto err;
816         if (!(os->flags & ASN1_STRING_FLAG_NDEF)) {
817             char *cont;
818             long contlen;
819             btmp = BIO_find_type(bio, BIO_TYPE_MEM);
820             if (btmp == NULL) {
821                 PKCS7err(PKCS7_F_PKCS7_DATAFINAL, PKCS7_R_UNABLE_TO_FIND_MEM_BIO);
822                 goto err;
823             }
824             contlen = BIO_get_mem_data(btmp, &cont);
825             /*
826              * Mark the BIO read only then we can use its copy of the data
827              * instead of making an extra copy.
828              */
829             BIO_set_flags(btmp, BIO_FLAGS_MEM_RDONLY);
830             BIO_set_mem_eof_return(btmp, 0);
831             ASN1_STRING_set0(os, (unsigned char *)cont, contlen);
832         }
833     }
834     ret = 1;
835  err:
836     EVP_MD_CTX_cleanup(&ctx_tmp);
837     return (ret);
838 }
839
840 int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si)
841 {
842     EVP_MD_CTX mctx;
843     EVP_PKEY_CTX *pctx;
844     unsigned char *abuf = NULL;
845     int alen;
846     size_t siglen;
847     const EVP_MD *md = NULL;
848
849     md = EVP_get_digestbyobj(si->digest_alg->algorithm);
850     if (md == NULL)
851         return 0;
852
853     EVP_MD_CTX_init(&mctx);
854     if (EVP_DigestSignInit(&mctx, &pctx, md, NULL, si->pkey) <= 0)
855         goto err;
856
857     if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_SIGN,
858                           EVP_PKEY_CTRL_PKCS7_SIGN, 0, si) <= 0) {
859         PKCS7err(PKCS7_F_PKCS7_SIGNER_INFO_SIGN, PKCS7_R_CTRL_ERROR);
860         goto err;
861     }
862
863     alen = ASN1_item_i2d((ASN1_VALUE *)si->auth_attr, &abuf,
864                          ASN1_ITEM_rptr(PKCS7_ATTR_SIGN));
865     if (!abuf)
866         goto err;
867     if (EVP_DigestSignUpdate(&mctx, abuf, alen) <= 0)
868         goto err;
869     OPENSSL_free(abuf);
870     abuf = NULL;
871     if (EVP_DigestSignFinal(&mctx, NULL, &siglen) <= 0)
872         goto err;
873     abuf = OPENSSL_malloc(siglen);
874     if (!abuf)
875         goto err;
876     if (EVP_DigestSignFinal(&mctx, abuf, &siglen) <= 0)
877         goto err;
878
879     if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_SIGN,
880                           EVP_PKEY_CTRL_PKCS7_SIGN, 1, si) <= 0) {
881         PKCS7err(PKCS7_F_PKCS7_SIGNER_INFO_SIGN, PKCS7_R_CTRL_ERROR);
882         goto err;
883     }
884
885     EVP_MD_CTX_cleanup(&mctx);
886
887     ASN1_STRING_set0(si->enc_digest, abuf, siglen);
888
889     return 1;
890
891  err:
892     OPENSSL_free(abuf);
893     EVP_MD_CTX_cleanup(&mctx);
894     return 0;
895
896 }
897
898 int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, BIO *bio,
899                      PKCS7 *p7, PKCS7_SIGNER_INFO *si)
900 {
901     PKCS7_ISSUER_AND_SERIAL *ias;
902     int ret = 0, i;
903     STACK_OF(X509) *cert;
904     X509 *x509;
905
906     if (p7 == NULL) {
907         PKCS7err(PKCS7_F_PKCS7_DATAVERIFY, PKCS7_R_INVALID_NULL_POINTER);
908         return 0;
909     }
910
911     if (p7->d.ptr == NULL) {
912         PKCS7err(PKCS7_F_PKCS7_DATAVERIFY, PKCS7_R_NO_CONTENT);
913         return 0;
914     }
915
916     if (PKCS7_type_is_signed(p7)) {
917         cert = p7->d.sign->cert;
918     } else if (PKCS7_type_is_signedAndEnveloped(p7)) {
919         cert = p7->d.signed_and_enveloped->cert;
920     } else {
921         PKCS7err(PKCS7_F_PKCS7_DATAVERIFY, PKCS7_R_WRONG_PKCS7_TYPE);
922         goto err;
923     }
924     /* XXXXXXXXXXXXXXXXXXXXXXX */
925     ias = si->issuer_and_serial;
926
927     x509 = X509_find_by_issuer_and_serial(cert, ias->issuer, ias->serial);
928
929     /* were we able to find the cert in passed to us */
930     if (x509 == NULL) {
931         PKCS7err(PKCS7_F_PKCS7_DATAVERIFY,
932                  PKCS7_R_UNABLE_TO_FIND_CERTIFICATE);
933         goto err;
934     }
935
936     /* Lets verify */
937     if (!X509_STORE_CTX_init(ctx, cert_store, x509, cert)) {
938         PKCS7err(PKCS7_F_PKCS7_DATAVERIFY, ERR_R_X509_LIB);
939         goto err;
940     }
941     X509_STORE_CTX_set_purpose(ctx, X509_PURPOSE_SMIME_SIGN);
942     i = X509_verify_cert(ctx);
943     if (i <= 0) {
944         PKCS7err(PKCS7_F_PKCS7_DATAVERIFY, ERR_R_X509_LIB);
945         X509_STORE_CTX_cleanup(ctx);
946         goto err;
947     }
948     X509_STORE_CTX_cleanup(ctx);
949
950     return PKCS7_signatureVerify(bio, p7, si, x509);
951  err:
952     return ret;
953 }
954
955 int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si,
956                           X509 *x509)
957 {
958     ASN1_OCTET_STRING *os;
959     EVP_MD_CTX mdc_tmp, *mdc;
960     int ret = 0, i;
961     int md_type;
962     STACK_OF(X509_ATTRIBUTE) *sk;
963     BIO *btmp;
964     EVP_PKEY *pkey;
965
966     EVP_MD_CTX_init(&mdc_tmp);
967
968     if (!PKCS7_type_is_signed(p7) && !PKCS7_type_is_signedAndEnveloped(p7)) {
969         PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, PKCS7_R_WRONG_PKCS7_TYPE);
970         goto err;
971     }
972
973     md_type = OBJ_obj2nid(si->digest_alg->algorithm);
974
975     btmp = bio;
976     for (;;) {
977         if ((btmp == NULL) ||
978             ((btmp = BIO_find_type(btmp, BIO_TYPE_MD)) == NULL)) {
979             PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY,
980                      PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST);
981             goto err;
982         }
983         BIO_get_md_ctx(btmp, &mdc);
984         if (mdc == NULL) {
985             PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, ERR_R_INTERNAL_ERROR);
986             goto err;
987         }
988         if (EVP_MD_CTX_type(mdc) == md_type)
989             break;
990         /*
991          * Workaround for some broken clients that put the signature OID
992          * instead of the digest OID in digest_alg->algorithm
993          */
994         if (EVP_MD_pkey_type(EVP_MD_CTX_md(mdc)) == md_type)
995             break;
996         btmp = BIO_next(btmp);
997     }
998
999     /*
1000      * mdc is the digest ctx that we want, unless there are attributes, in
1001      * which case the digest is the signed attributes
1002      */
1003     if (!EVP_MD_CTX_copy_ex(&mdc_tmp, mdc))
1004         goto err;
1005
1006     sk = si->auth_attr;
1007     if ((sk != NULL) && (sk_X509_ATTRIBUTE_num(sk) != 0)) {
1008         unsigned char md_dat[EVP_MAX_MD_SIZE], *abuf = NULL;
1009         unsigned int md_len;
1010         int alen;
1011         ASN1_OCTET_STRING *message_digest;
1012
1013         if (!EVP_DigestFinal_ex(&mdc_tmp, md_dat, &md_len))
1014             goto err;
1015         message_digest = PKCS7_digest_from_attributes(sk);
1016         if (!message_digest) {
1017             PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY,
1018                      PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST);
1019             goto err;
1020         }
1021         if ((message_digest->length != (int)md_len) ||
1022             (memcmp(message_digest->data, md_dat, md_len))) {
1023             PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, PKCS7_R_DIGEST_FAILURE);
1024             ret = -1;
1025             goto err;
1026         }
1027
1028         if (!EVP_VerifyInit_ex(&mdc_tmp, EVP_get_digestbynid(md_type), NULL))
1029             goto err;
1030
1031         alen = ASN1_item_i2d((ASN1_VALUE *)sk, &abuf,
1032                              ASN1_ITEM_rptr(PKCS7_ATTR_VERIFY));
1033         if (alen <= 0) {
1034             PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, ERR_R_ASN1_LIB);
1035             ret = -1;
1036             goto err;
1037         }
1038         if (!EVP_VerifyUpdate(&mdc_tmp, abuf, alen))
1039             goto err;
1040
1041         OPENSSL_free(abuf);
1042     }
1043
1044     os = si->enc_digest;
1045     pkey = X509_get_pubkey(x509);
1046     if (!pkey) {
1047         ret = -1;
1048         goto err;
1049     }
1050
1051     i = EVP_VerifyFinal(&mdc_tmp, os->data, os->length, pkey);
1052     EVP_PKEY_free(pkey);
1053     if (i <= 0) {
1054         PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY, PKCS7_R_SIGNATURE_FAILURE);
1055         ret = -1;
1056         goto err;
1057     }
1058     ret = 1;
1059  err:
1060     EVP_MD_CTX_cleanup(&mdc_tmp);
1061     return (ret);
1062 }
1063
1064 PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx)
1065 {
1066     STACK_OF(PKCS7_RECIP_INFO) *rsk;
1067     PKCS7_RECIP_INFO *ri;
1068     int i;
1069
1070     i = OBJ_obj2nid(p7->type);
1071     if (i != NID_pkcs7_signedAndEnveloped)
1072         return NULL;
1073     if (p7->d.signed_and_enveloped == NULL)
1074         return NULL;
1075     rsk = p7->d.signed_and_enveloped->recipientinfo;
1076     if (rsk == NULL)
1077         return NULL;
1078     ri = sk_PKCS7_RECIP_INFO_value(rsk, 0);
1079     if (sk_PKCS7_RECIP_INFO_num(rsk) <= idx)
1080         return (NULL);
1081     ri = sk_PKCS7_RECIP_INFO_value(rsk, idx);
1082     return (ri->issuer_and_serial);
1083 }
1084
1085 ASN1_TYPE *PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid)
1086 {
1087     return (get_attribute(si->auth_attr, nid));
1088 }
1089
1090 ASN1_TYPE *PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid)
1091 {
1092     return (get_attribute(si->unauth_attr, nid));
1093 }
1094
1095 static ASN1_TYPE *get_attribute(STACK_OF(X509_ATTRIBUTE) *sk, int nid)
1096 {
1097     int idx;
1098     X509_ATTRIBUTE *xa;
1099     idx = X509at_get_attr_by_NID(sk, nid, -1);
1100     xa = X509at_get_attr(sk, idx);
1101     return X509_ATTRIBUTE_get0_type(xa, 0);
1102 }
1103
1104 ASN1_OCTET_STRING *PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk)
1105 {
1106     ASN1_TYPE *astype;
1107     if ((astype = get_attribute(sk, NID_pkcs9_messageDigest)) == NULL)
1108         return NULL;
1109     return astype->value.octet_string;
1110 }
1111
1112 int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si,
1113                                 STACK_OF(X509_ATTRIBUTE) *sk)
1114 {
1115     int i;
1116
1117     sk_X509_ATTRIBUTE_pop_free(p7si->auth_attr, X509_ATTRIBUTE_free);
1118     p7si->auth_attr = sk_X509_ATTRIBUTE_dup(sk);
1119     if (p7si->auth_attr == NULL)
1120         return 0;
1121     for (i = 0; i < sk_X509_ATTRIBUTE_num(sk); i++) {
1122         if ((sk_X509_ATTRIBUTE_set(p7si->auth_attr, i,
1123                                    X509_ATTRIBUTE_dup(sk_X509_ATTRIBUTE_value
1124                                                       (sk, i))))
1125             == NULL)
1126             return (0);
1127     }
1128     return (1);
1129 }
1130
1131 int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si,
1132                          STACK_OF(X509_ATTRIBUTE) *sk)
1133 {
1134     int i;
1135
1136     sk_X509_ATTRIBUTE_pop_free(p7si->unauth_attr, X509_ATTRIBUTE_free);
1137     p7si->unauth_attr = sk_X509_ATTRIBUTE_dup(sk);
1138     if (p7si->unauth_attr == NULL)
1139         return 0;
1140     for (i = 0; i < sk_X509_ATTRIBUTE_num(sk); i++) {
1141         if ((sk_X509_ATTRIBUTE_set(p7si->unauth_attr, i,
1142                                    X509_ATTRIBUTE_dup(sk_X509_ATTRIBUTE_value
1143                                                       (sk, i))))
1144             == NULL)
1145             return (0);
1146     }
1147     return (1);
1148 }
1149
1150 int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
1151                                void *value)
1152 {
1153     return (add_attribute(&(p7si->auth_attr), nid, atrtype, value));
1154 }
1155
1156 int PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
1157                         void *value)
1158 {
1159     return (add_attribute(&(p7si->unauth_attr), nid, atrtype, value));
1160 }
1161
1162 static int add_attribute(STACK_OF(X509_ATTRIBUTE) **sk, int nid, int atrtype,
1163                          void *value)
1164 {
1165     X509_ATTRIBUTE *attr = NULL;
1166
1167     if (*sk == NULL) {
1168         if ((*sk = sk_X509_ATTRIBUTE_new_null()) == NULL)
1169             return 0;
1170  new_attrib:
1171         if ((attr = X509_ATTRIBUTE_create(nid, atrtype, value)) == NULL)
1172             return 0;
1173         if (!sk_X509_ATTRIBUTE_push(*sk, attr)) {
1174             X509_ATTRIBUTE_free(attr);
1175             return 0;
1176         }
1177     } else {
1178         int i;
1179
1180         for (i = 0; i < sk_X509_ATTRIBUTE_num(*sk); i++) {
1181             attr = sk_X509_ATTRIBUTE_value(*sk, i);
1182             if (OBJ_obj2nid(X509_ATTRIBUTE_get0_object(attr)) == nid) {
1183                 X509_ATTRIBUTE_free(attr);
1184                 attr = X509_ATTRIBUTE_create(nid, atrtype, value);
1185                 if (attr == NULL)
1186                     return 0;
1187                 if (!sk_X509_ATTRIBUTE_set(*sk, i, attr)) {
1188                     X509_ATTRIBUTE_free(attr);
1189                     return 0;
1190                 }
1191                 goto end;
1192             }
1193         }
1194         goto new_attrib;
1195     }
1196  end:
1197     return (1);
1198 }