1 /*
2 * Copyright 2008-2025 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 /* CMS utility function */
11
12 #include <stdio.h>
13 #include <string.h>
14 #include "apps.h"
15 #include "progs.h"
16
17 #include <openssl/crypto.h>
18 #include <openssl/pem.h>
19 #include <openssl/err.h>
20 #include <openssl/x509_vfy.h>
21 #include <openssl/x509v3.h>
22 #include <openssl/cms.h>
23
24 static int save_certs(char *signerfile, STACK_OF(X509) *signers);
25 static int cms_cb(int ok, X509_STORE_CTX *ctx);
26 static void receipt_request_print(CMS_ContentInfo *cms);
27 static CMS_ReceiptRequest
28 *make_receipt_request(STACK_OF(OPENSSL_STRING) *rr_to, int rr_allorfirst,
29 STACK_OF(OPENSSL_STRING) *rr_from);
30 static int cms_set_pkey_param(EVP_PKEY_CTX *pctx,
31 STACK_OF(OPENSSL_STRING) *param);
32
33 #define SMIME_OP 0x100
34 #define SMIME_IP 0x200
35 #define SMIME_SIGNERS 0x400
36 #define SMIME_ENCRYPT (1 | SMIME_OP)
37 #define SMIME_DECRYPT (2 | SMIME_IP)
38 #define SMIME_SIGN (3 | SMIME_OP | SMIME_SIGNERS)
39 #define SMIME_VERIFY (4 | SMIME_IP)
40 #define SMIME_RESIGN (5 | SMIME_IP | SMIME_OP | SMIME_SIGNERS)
41 #define SMIME_SIGN_RECEIPT (6 | SMIME_IP | SMIME_OP)
42 #define SMIME_VERIFY_RECEIPT (7 | SMIME_IP)
43 #define SMIME_DIGEST_CREATE (8 | SMIME_OP)
44 #define SMIME_DIGEST_VERIFY (9 | SMIME_IP)
45 #define SMIME_COMPRESS (10 | SMIME_OP)
46 #define SMIME_UNCOMPRESS (11 | SMIME_IP)
47 #define SMIME_ENCRYPTED_ENCRYPT (12 | SMIME_OP)
48 #define SMIME_ENCRYPTED_DECRYPT (13 | SMIME_IP)
49 #define SMIME_DATA_CREATE (14 | SMIME_OP)
50 #define SMIME_DATA_OUT (15 | SMIME_IP)
51 #define SMIME_CMSOUT (16 | SMIME_IP | SMIME_OP)
52
53 static int verify_err = 0;
54
55 typedef struct cms_key_param_st cms_key_param;
56
57 struct cms_key_param_st {
58 int idx;
59 STACK_OF(OPENSSL_STRING) *param;
60 cms_key_param *next;
61 };
62
63 typedef enum OPTION_choice {
64 OPT_COMMON,
65 OPT_INFORM, OPT_OUTFORM, OPT_IN, OPT_OUT, OPT_ENCRYPT,
66 OPT_DECRYPT, OPT_SIGN, OPT_CADES, OPT_SIGN_RECEIPT, OPT_RESIGN,
67 OPT_VERIFY, OPT_VERIFY_RETCODE, OPT_VERIFY_RECEIPT,
68 OPT_CMSOUT, OPT_DATA_OUT, OPT_DATA_CREATE, OPT_DIGEST_VERIFY,
69 OPT_DIGEST, OPT_DIGEST_CREATE, OPT_COMPRESS, OPT_UNCOMPRESS,
70 OPT_ED_DECRYPT, OPT_ED_ENCRYPT, OPT_DEBUG_DECRYPT, OPT_TEXT,
71 OPT_ASCIICRLF, OPT_NOINTERN, OPT_NOVERIFY, OPT_NOCERTS,
72 OPT_NOATTR, OPT_NODETACH, OPT_NOSMIMECAP, OPT_NO_SIGNING_TIME,
73 OPT_BINARY, OPT_KEYID,
74 OPT_NOSIGS, OPT_NO_CONTENT_VERIFY, OPT_NO_ATTR_VERIFY, OPT_INDEF,
75 OPT_NOINDEF, OPT_CRLFEOL, OPT_NOOUT, OPT_RR_PRINT,
76 OPT_RR_ALL, OPT_RR_FIRST, OPT_RCTFORM, OPT_CERTFILE, OPT_CAFILE,
77 OPT_CAPATH, OPT_CASTORE, OPT_NOCAPATH, OPT_NOCAFILE, OPT_NOCASTORE,
78 OPT_CONTENT, OPT_PRINT, OPT_NAMEOPT,
79 OPT_SECRETKEY, OPT_SECRETKEYID, OPT_PWRI_PASSWORD, OPT_ECONTENT_TYPE,
80 OPT_PASSIN, OPT_TO, OPT_FROM, OPT_SUBJECT, OPT_SIGNER, OPT_RECIP,
81 OPT_CERTSOUT, OPT_MD, OPT_INKEY, OPT_KEYFORM, OPT_KEYOPT, OPT_RR_FROM,
82 OPT_RR_TO, OPT_AES128_WRAP, OPT_AES192_WRAP, OPT_AES256_WRAP,
83 OPT_3DES_WRAP, OPT_WRAP, OPT_ENGINE,
84 OPT_R_ENUM,
85 OPT_PROV_ENUM, OPT_CONFIG,
86 OPT_V_ENUM,
87 OPT_CIPHER,
88 OPT_ORIGINATOR
89 } OPTION_CHOICE;
90
91 const OPTIONS cms_options[] = {
92 {OPT_HELP_STR, 1, '-', "Usage: %s [options] [cert...]\n"},
93 {"help", OPT_HELP, '-', "Display this summary"},
94
95 OPT_SECTION("General"),
96 {"in", OPT_IN, '<', "Input file"},
97 {"out", OPT_OUT, '>', "Output file"},
98 OPT_CONFIG_OPTION,
99
100 OPT_SECTION("Operation"),
101 {"encrypt", OPT_ENCRYPT, '-', "Encrypt message"},
102 {"decrypt", OPT_DECRYPT, '-', "Decrypt encrypted message"},
103 {"sign", OPT_SIGN, '-', "Sign message"},
104 {"verify", OPT_VERIFY, '-', "Verify signed message"},
105 {"resign", OPT_RESIGN, '-', "Resign a signed message"},
106 {"sign_receipt", OPT_SIGN_RECEIPT, '-',
107 "Generate a signed receipt for a message"},
108 {"verify_receipt", OPT_VERIFY_RECEIPT, '<',
109 "Verify receipts; exit if receipt signatures do not verify"},
110 {"digest", OPT_DIGEST, 's', "Sign a pre-computed digest in hex notation"},
111 {"digest_create", OPT_DIGEST_CREATE, '-',
112 "Create a CMS \"DigestedData\" object"},
113 {"digest_verify", OPT_DIGEST_VERIFY, '-',
114 "Verify a CMS \"DigestedData\" object and output it"},
115 {"compress", OPT_COMPRESS, '-', "Create a CMS \"CompressedData\" object"},
116 {"uncompress", OPT_UNCOMPRESS, '-',
117 "Uncompress a CMS \"CompressedData\" object"},
118 {"EncryptedData_encrypt", OPT_ED_ENCRYPT, '-',
119 "Create CMS \"EncryptedData\" object using symmetric key"},
120 {"EncryptedData_decrypt", OPT_ED_DECRYPT, '-',
121 "Decrypt CMS \"EncryptedData\" object using symmetric key"},
122 {"data_create", OPT_DATA_CREATE, '-', "Create a CMS \"Data\" object"},
123 {"data_out", OPT_DATA_OUT, '-', "Copy CMS \"Data\" object to output"},
124 {"cmsout", OPT_CMSOUT, '-', "Output CMS structure"},
125
126 OPT_SECTION("File format"),
127 {"inform", OPT_INFORM, 'c', "Input format SMIME (default), PEM or DER"},
128 {"outform", OPT_OUTFORM, 'c',
129 "Output format SMIME (default), PEM or DER"},
130 {"rctform", OPT_RCTFORM, 'F', "Receipt file format"},
131 {"stream", OPT_INDEF, '-', "Enable CMS streaming"},
132 {"indef", OPT_INDEF, '-', "Same as -stream"},
133 {"noindef", OPT_NOINDEF, '-', "Disable CMS streaming"},
134 {"binary", OPT_BINARY, '-',
135 "Treat input as binary: do not translate to canonical form"},
136 {"crlfeol", OPT_CRLFEOL, '-',
137 "Use CRLF as EOL termination instead of LF only" },
138 {"asciicrlf", OPT_ASCIICRLF, '-',
139 "Perform CRLF canonicalisation when signing"},
140
141 OPT_SECTION("Keys and passwords"),
142 {"pwri_password", OPT_PWRI_PASSWORD, 's',
143 "Specific password for recipient"},
144 {"secretkey", OPT_SECRETKEY, 's',
145 "Use specified hex-encoded key to decrypt/encrypt recipients or content"},
146 {"secretkeyid", OPT_SECRETKEYID, 's',
147 "Identity of the -secretkey for CMS \"KEKRecipientInfo\" object"},
148 {"inkey", OPT_INKEY, 's',
149 "Input private key (if not signer or recipient)"},
150 {"passin", OPT_PASSIN, 's', "Input file pass phrase source"},
151 {"keyopt", OPT_KEYOPT, 's', "Set public key parameters as n:v pairs"},
152 {"keyform", OPT_KEYFORM, 'f',
153 "Input private key format (ENGINE, other values ignored)"},
154 #ifndef OPENSSL_NO_ENGINE
155 {"engine", OPT_ENGINE, 's', "Use engine e, possibly a hardware device"},
156 #endif
157 OPT_PROV_OPTIONS,
158 OPT_R_OPTIONS,
159
160 OPT_SECTION("Encryption and decryption"),
161 {"originator", OPT_ORIGINATOR, 's', "Originator certificate file"},
162 {"recip", OPT_RECIP, '<', "Recipient cert file"},
163 {"cert...", OPT_PARAM, '.',
164 "Recipient certs (optional; used only when encrypting)"},
165 {"", OPT_CIPHER, '-',
166 "The encryption algorithm to use (any supported cipher)"},
167 {"wrap", OPT_WRAP, 's',
168 "Key wrap algorithm to use when encrypting with key agreement"},
169 {"aes128-wrap", OPT_AES128_WRAP, '-', "Use AES128 to wrap key"},
170 {"aes192-wrap", OPT_AES192_WRAP, '-', "Use AES192 to wrap key"},
171 {"aes256-wrap", OPT_AES256_WRAP, '-', "Use AES256 to wrap key"},
172 {"des3-wrap", OPT_3DES_WRAP, '-', "Use 3DES-EDE to wrap key"},
173 {"debug_decrypt", OPT_DEBUG_DECRYPT, '-',
174 "Disable MMA protection, return error if no recipient found (see doc)"},
175
176 OPT_SECTION("Signing"),
177 {"md", OPT_MD, 's', "Digest algorithm to use"},
178 {"signer", OPT_SIGNER, 's', "Signer certificate input file"},
179 {"certfile", OPT_CERTFILE, '<',
180 "Extra signer and intermediate CA certificates to include when signing"},
181 {OPT_MORE_STR, 0, 0,
182 "or to use as preferred signer certs and for chain building when verifying"},
183 {"cades", OPT_CADES, '-',
184 "Include signingCertificate attribute (CAdES-BES)"},
185 {"nodetach", OPT_NODETACH, '-', "Use opaque signing"},
186 {"nocerts", OPT_NOCERTS, '-',
187 "Don't include signer's certificate when signing"},
188 {"noattr", OPT_NOATTR, '-', "Don't include any signed attributes"},
189 {"nosmimecap", OPT_NOSMIMECAP, '-', "Omit the SMIMECapabilities attribute"},
190 {"no_signing_time", OPT_NO_SIGNING_TIME, '-',
191 "Omit the signing time attribute"},
192 {"receipt_request_all", OPT_RR_ALL, '-',
193 "When signing, create a receipt request for all recipients"},
194 {"receipt_request_first", OPT_RR_FIRST, '-',
195 "When signing, create a receipt request for first recipient"},
196 {"receipt_request_from", OPT_RR_FROM, 's',
197 "Create signed receipt request with specified email address"},
198 {"receipt_request_to", OPT_RR_TO, 's',
199 "Create signed receipt targeted to specified address"},
200
201 OPT_SECTION("Verification"),
202 {"signer", OPT_DUP, 's', "Signer certificate(s) output file"},
203 {"content", OPT_CONTENT, '<',
204 "Supply or override content for detached signature"},
205 {"no_content_verify", OPT_NO_CONTENT_VERIFY, '-',
206 "Do not verify signed content signatures"},
207 {"no_attr_verify", OPT_NO_ATTR_VERIFY, '-',
208 "Do not verify signed attribute signatures"},
209 {"nosigs", OPT_NOSIGS, '-', "Don't verify message signature"},
210 {"noverify", OPT_NOVERIFY, '-', "Don't verify signers certificate"},
211 {"nointern", OPT_NOINTERN, '-',
212 "Don't search certificates in message for signer"},
213 {"cades", OPT_DUP, '-', "Check signingCertificate (CAdES-BES)"},
214 {"verify_retcode", OPT_VERIFY_RETCODE, '-',
215 "Exit non-zero on verification failure"},
216 {"CAfile", OPT_CAFILE, '<', "Trusted certificates file"},
217 {"CApath", OPT_CAPATH, '/', "Trusted certificates directory"},
218 {"CAstore", OPT_CASTORE, ':', "Trusted certificates store URI"},
219 {"no-CAfile", OPT_NOCAFILE, '-',
220 "Do not load the default certificates file"},
221 {"no-CApath", OPT_NOCAPATH, '-',
222 "Do not load certificates from the default certificates directory"},
223 {"no-CAstore", OPT_NOCASTORE, '-',
224 "Do not load certificates from the default certificates store"},
225
226 OPT_SECTION("Output"),
227 {"keyid", OPT_KEYID, '-', "Use subject key identifier"},
228 {"econtent_type", OPT_ECONTENT_TYPE, 's', "OID for external content"},
229 {"text", OPT_TEXT, '-', "Include or delete text MIME headers"},
230 {"certsout", OPT_CERTSOUT, '>', "Certificate output file"},
231 {"to", OPT_TO, 's', "To address"},
232 {"from", OPT_FROM, 's', "From address"},
233 {"subject", OPT_SUBJECT, 's', "Subject"},
234
235 OPT_SECTION("Printing"),
236 {"noout", OPT_NOOUT, '-',
237 "For the -cmsout operation do not output the parsed CMS structure"},
238 {"print", OPT_PRINT, '-',
239 "For the -cmsout operation print out all fields of the CMS structure"},
240 {"nameopt", OPT_NAMEOPT, 's',
241 "For the -print option specifies various strings printing options"},
242 {"receipt_request_print", OPT_RR_PRINT, '-', "Print CMS Receipt Request" },
243
244 OPT_V_OPTIONS,
245 {NULL}
246 };
247
load_content_info(int informat,BIO * in,int flags,BIO ** indata,const char * name)248 static CMS_ContentInfo *load_content_info(int informat, BIO *in, int flags,
249 BIO **indata, const char *name)
250 {
251 CMS_ContentInfo *ret, *ci;
252
253 ret = CMS_ContentInfo_new_ex(app_get0_libctx(), app_get0_propq());
254 if (ret == NULL) {
255 BIO_printf(bio_err, "Error allocating CMS_contentinfo\n");
256 return NULL;
257 }
258 switch (informat) {
259 case FORMAT_SMIME:
260 ci = SMIME_read_CMS_ex(in, flags, indata, &ret);
261 break;
262 case FORMAT_PEM:
263 ci = PEM_read_bio_CMS(in, &ret, NULL, NULL);
264 break;
265 case FORMAT_ASN1:
266 ci = d2i_CMS_bio(in, &ret);
267 break;
268 default:
269 BIO_printf(bio_err, "Bad input format for %s\n", name);
270 goto err;
271 }
272 if (ci == NULL) {
273 BIO_printf(bio_err, "Error reading %s Content Info\n", name);
274 goto err;
275 }
276 return ret;
277 err:
278 CMS_ContentInfo_free(ret);
279 return NULL;
280 }
281
cms_main(int argc,char ** argv)282 int cms_main(int argc, char **argv)
283 {
284 CONF *conf = NULL;
285 ASN1_OBJECT *econtent_type = NULL;
286 BIO *in = NULL, *out = NULL, *indata = NULL, *rctin = NULL;
287 CMS_ContentInfo *cms = NULL, *rcms = NULL;
288 CMS_ReceiptRequest *rr = NULL;
289 ENGINE *e = NULL;
290 EVP_PKEY *key = NULL;
291 EVP_CIPHER *cipher = NULL, *wrap_cipher = NULL;
292 EVP_MD *sign_md = NULL;
293 STACK_OF(OPENSSL_STRING) *rr_to = NULL, *rr_from = NULL;
294 STACK_OF(OPENSSL_STRING) *sksigners = NULL, *skkeys = NULL;
295 STACK_OF(X509) *encerts = sk_X509_new_null(), *other = NULL;
296 X509 *cert = NULL, *recip = NULL, *signer = NULL, *originator = NULL;
297 X509_STORE *store = NULL;
298 X509_VERIFY_PARAM *vpm = X509_VERIFY_PARAM_new();
299 char *certfile = NULL, *keyfile = NULL, *contfile = NULL;
300 const char *CAfile = NULL, *CApath = NULL, *CAstore = NULL;
301 char *certsoutfile = NULL, *digestname = NULL, *wrapname = NULL;
302 int noCAfile = 0, noCApath = 0, noCAstore = 0;
303 char *digesthex = NULL;
304 unsigned char *digestbin = NULL;
305 long digestlen = 0;
306 char *infile = NULL, *outfile = NULL, *rctfile = NULL;
307 char *passinarg = NULL, *passin = NULL, *signerfile = NULL;
308 char *originatorfile = NULL, *recipfile = NULL, *ciphername = NULL;
309 char *to = NULL, *from = NULL, *subject = NULL, *prog;
310 cms_key_param *key_first = NULL, *key_param = NULL;
311 int flags = CMS_DETACHED, binary_files = 0;
312 int noout = 0, print = 0, keyidx = -1, vpmtouched = 0;
313 int informat = FORMAT_SMIME, outformat = FORMAT_SMIME;
314 int operation = 0, ret = 1, rr_print = 0, rr_allorfirst = -1;
315 int verify_retcode = 0, rctformat = FORMAT_SMIME, keyform = FORMAT_UNDEF;
316 size_t secret_keylen = 0, secret_keyidlen = 0;
317 unsigned char *pwri_pass = NULL, *pwri_tmp = NULL;
318 unsigned char *secret_key = NULL, *secret_keyid = NULL;
319 long ltmp;
320 const char *mime_eol = "\n";
321 OPTION_CHOICE o;
322 OSSL_LIB_CTX *libctx = app_get0_libctx();
323
324 if (encerts == NULL || vpm == NULL)
325 goto end;
326
327 opt_set_unknown_name("cipher");
328 prog = opt_init(argc, argv, cms_options);
329 while ((o = opt_next()) != OPT_EOF) {
330 switch (o) {
331 case OPT_EOF:
332 case OPT_ERR:
333 opthelp:
334 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
335 goto end;
336 case OPT_HELP:
337 opt_help(cms_options);
338 ret = 0;
339 goto end;
340 case OPT_INFORM:
341 if (!opt_format(opt_arg(), OPT_FMT_PDS, &informat))
342 goto opthelp;
343 break;
344 case OPT_OUTFORM:
345 if (!opt_format(opt_arg(), OPT_FMT_PDS, &outformat))
346 goto opthelp;
347 break;
348 case OPT_OUT:
349 outfile = opt_arg();
350 break;
351
352 case OPT_ENCRYPT:
353 operation = SMIME_ENCRYPT;
354 break;
355 case OPT_DECRYPT:
356 operation = SMIME_DECRYPT;
357 break;
358 case OPT_SIGN:
359 operation = SMIME_SIGN;
360 break;
361 case OPT_VERIFY:
362 operation = SMIME_VERIFY;
363 break;
364 case OPT_RESIGN:
365 operation = SMIME_RESIGN;
366 break;
367 case OPT_SIGN_RECEIPT:
368 operation = SMIME_SIGN_RECEIPT;
369 break;
370 case OPT_VERIFY_RECEIPT:
371 operation = SMIME_VERIFY_RECEIPT;
372 rctfile = opt_arg();
373 break;
374 case OPT_VERIFY_RETCODE:
375 verify_retcode = 1;
376 break;
377 case OPT_DIGEST_CREATE:
378 operation = SMIME_DIGEST_CREATE;
379 break;
380 case OPT_DIGEST:
381 digesthex = opt_arg();
382 break;
383 case OPT_DIGEST_VERIFY:
384 operation = SMIME_DIGEST_VERIFY;
385 break;
386 case OPT_COMPRESS:
387 operation = SMIME_COMPRESS;
388 break;
389 case OPT_UNCOMPRESS:
390 operation = SMIME_UNCOMPRESS;
391 break;
392 case OPT_ED_ENCRYPT:
393 operation = SMIME_ENCRYPTED_ENCRYPT;
394 break;
395 case OPT_ED_DECRYPT:
396 operation = SMIME_ENCRYPTED_DECRYPT;
397 break;
398 case OPT_DATA_CREATE:
399 operation = SMIME_DATA_CREATE;
400 break;
401 case OPT_DATA_OUT:
402 operation = SMIME_DATA_OUT;
403 break;
404 case OPT_CMSOUT:
405 operation = SMIME_CMSOUT;
406 break;
407
408 case OPT_DEBUG_DECRYPT:
409 flags |= CMS_DEBUG_DECRYPT;
410 break;
411 case OPT_TEXT:
412 flags |= CMS_TEXT;
413 break;
414 case OPT_ASCIICRLF:
415 flags |= CMS_ASCIICRLF;
416 break;
417 case OPT_NOINTERN:
418 flags |= CMS_NOINTERN;
419 break;
420 case OPT_NOVERIFY:
421 flags |= CMS_NO_SIGNER_CERT_VERIFY;
422 break;
423 case OPT_NOCERTS:
424 flags |= CMS_NOCERTS;
425 break;
426 case OPT_NOATTR:
427 flags |= CMS_NOATTR;
428 break;
429 case OPT_NODETACH:
430 flags &= ~CMS_DETACHED;
431 break;
432 case OPT_NOSMIMECAP:
433 flags |= CMS_NOSMIMECAP;
434 break;
435 case OPT_NO_SIGNING_TIME:
436 flags |= CMS_NO_SIGNING_TIME;
437 break;
438 case OPT_BINARY:
439 flags |= CMS_BINARY;
440 break;
441 case OPT_CADES:
442 flags |= CMS_CADES;
443 break;
444 case OPT_KEYID:
445 flags |= CMS_USE_KEYID;
446 break;
447 case OPT_NOSIGS:
448 flags |= CMS_NOSIGS;
449 break;
450 case OPT_NO_CONTENT_VERIFY:
451 flags |= CMS_NO_CONTENT_VERIFY;
452 break;
453 case OPT_NO_ATTR_VERIFY:
454 flags |= CMS_NO_ATTR_VERIFY;
455 break;
456 case OPT_INDEF:
457 flags |= CMS_STREAM;
458 break;
459 case OPT_NOINDEF:
460 flags &= ~CMS_STREAM;
461 break;
462 case OPT_CRLFEOL:
463 mime_eol = "\r\n";
464 flags |= CMS_CRLFEOL;
465 break;
466 case OPT_NOOUT:
467 noout = 1;
468 break;
469 case OPT_RR_PRINT:
470 rr_print = 1;
471 break;
472 case OPT_RR_ALL:
473 rr_allorfirst = 0;
474 break;
475 case OPT_RR_FIRST:
476 rr_allorfirst = 1;
477 break;
478 case OPT_RCTFORM:
479 if (!opt_format(opt_arg(),
480 OPT_FMT_PEMDER | OPT_FMT_SMIME, &rctformat))
481 goto opthelp;
482 break;
483 case OPT_CERTFILE:
484 certfile = opt_arg();
485 break;
486 case OPT_CAFILE:
487 CAfile = opt_arg();
488 break;
489 case OPT_CAPATH:
490 CApath = opt_arg();
491 break;
492 case OPT_CASTORE:
493 CAstore = opt_arg();
494 break;
495 case OPT_NOCAFILE:
496 noCAfile = 1;
497 break;
498 case OPT_NOCAPATH:
499 noCApath = 1;
500 break;
501 case OPT_NOCASTORE:
502 noCAstore = 1;
503 break;
504 case OPT_IN:
505 infile = opt_arg();
506 break;
507 case OPT_CONTENT:
508 contfile = opt_arg();
509 break;
510 case OPT_RR_FROM:
511 if (rr_from == NULL
512 && (rr_from = sk_OPENSSL_STRING_new_null()) == NULL)
513 goto end;
514 if (sk_OPENSSL_STRING_push(rr_from, opt_arg()) <= 0)
515 goto end;
516 break;
517 case OPT_RR_TO:
518 if (rr_to == NULL
519 && (rr_to = sk_OPENSSL_STRING_new_null()) == NULL)
520 goto end;
521 if (sk_OPENSSL_STRING_push(rr_to, opt_arg()) <= 0)
522 goto end;
523 break;
524 case OPT_PRINT:
525 noout = print = 1;
526 break;
527 case OPT_NAMEOPT:
528 if (!set_nameopt(opt_arg()))
529 goto opthelp;
530 break;
531 case OPT_SECRETKEY:
532 if (secret_key != NULL) {
533 BIO_printf(bio_err, "Invalid key (supplied twice) %s\n",
534 opt_arg());
535 goto opthelp;
536 }
537 secret_key = OPENSSL_hexstr2buf(opt_arg(), <mp);
538 if (secret_key == NULL) {
539 BIO_printf(bio_err, "Invalid key %s\n", opt_arg());
540 goto end;
541 }
542 secret_keylen = (size_t)ltmp;
543 break;
544 case OPT_SECRETKEYID:
545 if (secret_keyid != NULL) {
546 BIO_printf(bio_err, "Invalid id (supplied twice) %s\n",
547 opt_arg());
548 goto opthelp;
549 }
550 secret_keyid = OPENSSL_hexstr2buf(opt_arg(), <mp);
551 if (secret_keyid == NULL) {
552 BIO_printf(bio_err, "Invalid id %s\n", opt_arg());
553 goto opthelp;
554 }
555 secret_keyidlen = (size_t)ltmp;
556 break;
557 case OPT_PWRI_PASSWORD:
558 pwri_pass = (unsigned char *)opt_arg();
559 break;
560 case OPT_ECONTENT_TYPE:
561 if (econtent_type != NULL) {
562 BIO_printf(bio_err, "Invalid OID (supplied twice) %s\n",
563 opt_arg());
564 goto opthelp;
565 }
566 econtent_type = OBJ_txt2obj(opt_arg(), 0);
567 if (econtent_type == NULL) {
568 BIO_printf(bio_err, "Invalid OID %s\n", opt_arg());
569 goto opthelp;
570 }
571 break;
572 case OPT_ENGINE:
573 e = setup_engine(opt_arg(), 0);
574 break;
575 case OPT_PASSIN:
576 passinarg = opt_arg();
577 break;
578 case OPT_TO:
579 to = opt_arg();
580 break;
581 case OPT_FROM:
582 from = opt_arg();
583 break;
584 case OPT_SUBJECT:
585 subject = opt_arg();
586 break;
587 case OPT_CERTSOUT:
588 certsoutfile = opt_arg();
589 break;
590 case OPT_MD:
591 digestname = opt_arg();
592 break;
593 case OPT_SIGNER:
594 /* If previous -signer argument add signer to list */
595 if (signerfile != NULL) {
596 if (sksigners == NULL
597 && (sksigners = sk_OPENSSL_STRING_new_null()) == NULL)
598 goto end;
599 if (sk_OPENSSL_STRING_push(sksigners, signerfile) <= 0)
600 goto end;
601 if (keyfile == NULL)
602 keyfile = signerfile;
603 if (skkeys == NULL
604 && (skkeys = sk_OPENSSL_STRING_new_null()) == NULL)
605 goto end;
606 if (sk_OPENSSL_STRING_push(skkeys, keyfile) <= 0)
607 goto end;
608 keyfile = NULL;
609 }
610 signerfile = opt_arg();
611 break;
612 case OPT_ORIGINATOR:
613 originatorfile = opt_arg();
614 break;
615 case OPT_INKEY:
616 /* If previous -inkey argument add signer to list */
617 if (keyfile != NULL) {
618 if (signerfile == NULL) {
619 BIO_puts(bio_err, "Illegal -inkey without -signer\n");
620 goto end;
621 }
622 if (sksigners == NULL
623 && (sksigners = sk_OPENSSL_STRING_new_null()) == NULL)
624 goto end;
625 if (sk_OPENSSL_STRING_push(sksigners, signerfile) <= 0)
626 goto end;
627 signerfile = NULL;
628 if (skkeys == NULL
629 && (skkeys = sk_OPENSSL_STRING_new_null()) == NULL)
630 goto end;
631 if (sk_OPENSSL_STRING_push(skkeys, keyfile) <= 0)
632 goto end;
633 }
634 keyfile = opt_arg();
635 break;
636 case OPT_KEYFORM:
637 if (!opt_format(opt_arg(), OPT_FMT_ANY, &keyform))
638 goto opthelp;
639 break;
640 case OPT_RECIP:
641 if (operation == SMIME_ENCRYPT) {
642 cert = load_cert(opt_arg(), FORMAT_UNDEF,
643 "recipient certificate file");
644 if (cert == NULL)
645 goto end;
646 if (!sk_X509_push(encerts, cert))
647 goto end;
648 cert = NULL;
649 } else {
650 recipfile = opt_arg();
651 }
652 break;
653 case OPT_CIPHER:
654 ciphername = opt_unknown();
655 break;
656 case OPT_KEYOPT:
657 keyidx = -1;
658 if (operation == SMIME_ENCRYPT) {
659 if (sk_X509_num(encerts) > 0)
660 keyidx += sk_X509_num(encerts);
661 } else {
662 if (keyfile != NULL || signerfile != NULL)
663 keyidx++;
664 if (skkeys != NULL)
665 keyidx += sk_OPENSSL_STRING_num(skkeys);
666 }
667 if (keyidx < 0) {
668 BIO_printf(bio_err, "No key specified\n");
669 goto opthelp;
670 }
671 if (key_param == NULL || key_param->idx != keyidx) {
672 cms_key_param *nparam;
673 nparam = app_malloc(sizeof(*nparam), "key param buffer");
674 if ((nparam->param = sk_OPENSSL_STRING_new_null()) == NULL) {
675 OPENSSL_free(nparam);
676 goto end;
677 }
678 nparam->idx = keyidx;
679 nparam->next = NULL;
680 if (key_first == NULL)
681 key_first = nparam;
682 else
683 key_param->next = nparam;
684 key_param = nparam;
685 }
686 if (sk_OPENSSL_STRING_push(key_param->param, opt_arg()) <= 0)
687 goto end;
688 break;
689 case OPT_V_CASES:
690 if (!opt_verify(o, vpm))
691 goto end;
692 vpmtouched++;
693 break;
694 case OPT_R_CASES:
695 if (!opt_rand(o))
696 goto end;
697 break;
698 case OPT_PROV_CASES:
699 if (!opt_provider(o))
700 goto end;
701 break;
702 case OPT_CONFIG:
703 conf = app_load_config_modules(opt_arg());
704 if (conf == NULL)
705 goto end;
706 break;
707 case OPT_WRAP:
708 wrapname = opt_arg();
709 break;
710 case OPT_AES128_WRAP:
711 case OPT_AES192_WRAP:
712 case OPT_AES256_WRAP:
713 case OPT_3DES_WRAP:
714 wrapname = opt_flag() + 1;
715 break;
716 }
717 }
718 if (!app_RAND_load())
719 goto end;
720
721 if (digestname != NULL) {
722 if (!opt_md(digestname, &sign_md))
723 goto end;
724 }
725 if (!opt_cipher_any(ciphername, &cipher))
726 goto end;
727 if (wrapname != NULL) {
728 if (!opt_cipher_any(wrapname, &wrap_cipher))
729 goto end;
730 }
731
732 /* Remaining args are files to process. */
733 argv = opt_rest();
734
735 if ((rr_allorfirst != -1 || rr_from != NULL) && rr_to == NULL) {
736 BIO_puts(bio_err, "No Signed Receipts Recipients\n");
737 goto opthelp;
738 }
739
740 if (!(operation & SMIME_SIGNERS) && (rr_to != NULL || rr_from != NULL)) {
741 BIO_puts(bio_err, "Signed receipts only allowed with -sign\n");
742 goto opthelp;
743 }
744 if (!(operation & SMIME_SIGNERS) && (skkeys != NULL || sksigners != NULL)) {
745 BIO_puts(bio_err, "Multiple signers or keys not allowed\n");
746 goto opthelp;
747 }
748
749 if ((flags & CMS_CADES) != 0) {
750 if ((flags & CMS_NOATTR) != 0) {
751 BIO_puts(bio_err, "Incompatible options: "
752 "CAdES requires signed attributes\n");
753 goto opthelp;
754 }
755 if (operation == SMIME_VERIFY
756 && (flags & (CMS_NO_SIGNER_CERT_VERIFY | CMS_NO_ATTR_VERIFY)) != 0) {
757 BIO_puts(bio_err, "Incompatible options: CAdES validation requires"
758 " certs and signed attributes validations\n");
759 goto opthelp;
760 }
761 }
762
763 if (operation & SMIME_SIGNERS) {
764 if (keyfile != NULL && signerfile == NULL) {
765 BIO_puts(bio_err, "Illegal -inkey without -signer\n");
766 goto opthelp;
767 }
768 /* Check to see if any final signer needs to be appended */
769 if (signerfile != NULL) {
770 if (sksigners == NULL
771 && (sksigners = sk_OPENSSL_STRING_new_null()) == NULL)
772 goto end;
773 if (sk_OPENSSL_STRING_push(sksigners, signerfile) <= 0)
774 goto end;
775 if (skkeys == NULL && (skkeys = sk_OPENSSL_STRING_new_null()) == NULL)
776 goto end;
777 if (keyfile == NULL)
778 keyfile = signerfile;
779 if (sk_OPENSSL_STRING_push(skkeys, keyfile) <= 0)
780 goto end;
781 }
782 if (sksigners == NULL) {
783 BIO_printf(bio_err, "No signer certificate specified\n");
784 goto opthelp;
785 }
786 signerfile = NULL;
787 keyfile = NULL;
788 } else if (operation == SMIME_DECRYPT) {
789 if (recipfile == NULL && keyfile == NULL
790 && secret_key == NULL && pwri_pass == NULL) {
791 BIO_printf(bio_err,
792 "No recipient certificate or key specified\n");
793 goto opthelp;
794 }
795 } else if (operation == SMIME_ENCRYPT) {
796 if (*argv == NULL && secret_key == NULL
797 && pwri_pass == NULL && sk_X509_num(encerts) <= 0) {
798 BIO_printf(bio_err, "No recipient(s) certificate(s) specified\n");
799 goto opthelp;
800 }
801 } else if (!operation) {
802 BIO_printf(bio_err, "No operation option (-encrypt|-decrypt|-sign|-verify|...) specified.\n");
803 goto opthelp;
804 }
805
806 if (!app_passwd(passinarg, NULL, &passin, NULL)) {
807 BIO_printf(bio_err, "Error getting password\n");
808 goto end;
809 }
810
811 ret = 2;
812
813 if ((operation & SMIME_SIGNERS) == 0) {
814 if ((flags & CMS_DETACHED) == 0)
815 BIO_printf(bio_err,
816 "Warning: -nodetach option is ignored for non-signing operation\n");
817
818 flags &= ~CMS_DETACHED;
819 }
820 if ((operation & SMIME_IP) == 0 && contfile != NULL)
821 BIO_printf(bio_err,
822 "Warning: -contfile option is ignored for the given operation\n");
823 if (operation != SMIME_ENCRYPT && *argv != NULL)
824 BIO_printf(bio_err,
825 "Warning: recipient certificate file parameters ignored for operation other than -encrypt\n");
826
827 if ((flags & CMS_BINARY) != 0) {
828 if (!(operation & SMIME_OP))
829 outformat = FORMAT_BINARY;
830 if (!(operation & SMIME_IP))
831 informat = FORMAT_BINARY;
832 if ((operation & SMIME_SIGNERS) != 0 && (flags & CMS_DETACHED) != 0)
833 binary_files = 1;
834 if ((operation & SMIME_IP) != 0 && contfile == NULL)
835 binary_files = 1;
836 }
837
838 if (operation == SMIME_ENCRYPT) {
839 if (!cipher)
840 cipher = (EVP_CIPHER *)EVP_aes_256_cbc();
841 if (secret_key && !secret_keyid) {
842 BIO_printf(bio_err, "No secret key id\n");
843 goto end;
844 }
845
846 for (; *argv != NULL; argv++) {
847 cert = load_cert(*argv, FORMAT_UNDEF,
848 "recipient certificate file");
849 if (cert == NULL)
850 goto end;
851 if (!sk_X509_push(encerts, cert))
852 goto end;
853 cert = NULL;
854 }
855 }
856
857 if (certfile != NULL) {
858 if (!load_certs(certfile, 0, &other, NULL, "certificate file")) {
859 ERR_print_errors(bio_err);
860 goto end;
861 }
862 }
863
864 if (recipfile != NULL && (operation == SMIME_DECRYPT)) {
865 if ((recip = load_cert(recipfile, FORMAT_UNDEF,
866 "recipient certificate file")) == NULL) {
867 ERR_print_errors(bio_err);
868 goto end;
869 }
870 }
871
872 if (originatorfile != NULL) {
873 if ((originator = load_cert(originatorfile, FORMAT_UNDEF,
874 "originator certificate file")) == NULL) {
875 ERR_print_errors(bio_err);
876 goto end;
877 }
878 }
879
880 if (operation == SMIME_SIGN_RECEIPT) {
881 if ((signer = load_cert(signerfile, FORMAT_UNDEF,
882 "receipt signer certificate file")) == NULL) {
883 ERR_print_errors(bio_err);
884 goto end;
885 }
886 }
887
888 if ((operation == SMIME_DECRYPT) || (operation == SMIME_ENCRYPT)) {
889 if (keyfile == NULL)
890 keyfile = recipfile;
891 } else if ((operation == SMIME_SIGN) || (operation == SMIME_SIGN_RECEIPT)) {
892 if (keyfile == NULL)
893 keyfile = signerfile;
894 } else {
895 keyfile = NULL;
896 }
897
898 if (keyfile != NULL) {
899 key = load_key(keyfile, keyform, 0, passin, e, "signing key");
900 if (key == NULL)
901 goto end;
902 }
903
904 if (digesthex != NULL) {
905 if (operation != SMIME_SIGN) {
906 BIO_printf(bio_err,
907 "Cannot use -digest for non-signing operation\n");
908 goto end;
909 }
910 if (infile != NULL
911 || (flags & CMS_DETACHED) == 0
912 || (flags & CMS_STREAM) != 0) {
913 BIO_printf(bio_err,
914 "Cannot use -digest when -in, -nodetach or streaming is used\n");
915 goto end;
916 }
917 digestbin = OPENSSL_hexstr2buf(digesthex, &digestlen);
918 if (digestbin == NULL) {
919 BIO_printf(bio_err,
920 "Invalid hex value after -digest\n");
921 goto end;
922 }
923 } else {
924 in = bio_open_default(infile, 'r',
925 binary_files ? FORMAT_BINARY : informat);
926 if (in == NULL)
927 goto end;
928 }
929
930 if (operation & SMIME_IP) {
931 cms = load_content_info(informat, in, flags, &indata, "SMIME");
932 if (cms == NULL)
933 goto end;
934 if (contfile != NULL) {
935 BIO_free(indata);
936 if ((indata = BIO_new_file(contfile, "rb")) == NULL) {
937 BIO_printf(bio_err, "Can't read content file %s\n", contfile);
938 goto end;
939 }
940 }
941 if (certsoutfile != NULL) {
942 STACK_OF(X509) *allcerts;
943 allcerts = CMS_get1_certs(cms);
944 if (!save_certs(certsoutfile, allcerts)) {
945 BIO_printf(bio_err,
946 "Error writing certs to %s\n", certsoutfile);
947 ret = 5;
948 goto end;
949 }
950 OSSL_STACK_OF_X509_free(allcerts);
951 }
952 }
953
954 if (rctfile != NULL) {
955 char *rctmode = (rctformat == FORMAT_ASN1) ? "rb" : "r";
956
957 if ((rctin = BIO_new_file(rctfile, rctmode)) == NULL) {
958 BIO_printf(bio_err, "Can't open receipt file %s\n", rctfile);
959 goto end;
960 }
961
962 rcms = load_content_info(rctformat, rctin, 0, NULL, "receipt");
963 if (rcms == NULL)
964 goto end;
965 }
966
967 out = bio_open_default(outfile, 'w',
968 binary_files ? FORMAT_BINARY : outformat);
969 if (out == NULL)
970 goto end;
971
972 if ((operation == SMIME_VERIFY) || (operation == SMIME_VERIFY_RECEIPT)) {
973 if ((store = setup_verify(CAfile, noCAfile, CApath, noCApath,
974 CAstore, noCAstore)) == NULL)
975 goto end;
976 X509_STORE_set_verify_cb(store, cms_cb);
977 if (vpmtouched)
978 X509_STORE_set1_param(store, vpm);
979 }
980
981 ret = 3;
982
983 if (operation == SMIME_DATA_CREATE) {
984 cms = CMS_data_create_ex(in, flags, libctx, app_get0_propq());
985 } else if (operation == SMIME_DIGEST_CREATE) {
986 cms = CMS_digest_create_ex(in, sign_md, flags, libctx, app_get0_propq());
987 } else if (operation == SMIME_COMPRESS) {
988 cms = CMS_compress(in, -1, flags);
989 } else if (operation == SMIME_ENCRYPT) {
990 int i;
991 flags |= CMS_PARTIAL;
992 cms = CMS_encrypt_ex(NULL, in, cipher, flags, libctx, app_get0_propq());
993 if (cms == NULL)
994 goto end;
995 for (i = 0; i < sk_X509_num(encerts); i++) {
996 CMS_RecipientInfo *ri;
997 cms_key_param *kparam;
998 int tflags = flags | CMS_KEY_PARAM;
999 /* This flag enforces allocating the EVP_PKEY_CTX for the recipient here */
1000 EVP_PKEY_CTX *pctx;
1001 X509 *x = sk_X509_value(encerts, i);
1002 int res;
1003
1004 for (kparam = key_first; kparam; kparam = kparam->next) {
1005 if (kparam->idx == i) {
1006 break;
1007 }
1008 }
1009 ri = CMS_add1_recipient(cms, x, key, originator, tflags);
1010 if (ri == NULL)
1011 goto end;
1012
1013 pctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
1014 if (pctx != NULL && kparam != NULL) {
1015 if (!cms_set_pkey_param(pctx, kparam->param))
1016 goto end;
1017 }
1018
1019 res = EVP_PKEY_CTX_ctrl(pctx, -1, -1,
1020 EVP_PKEY_CTRL_CIPHER,
1021 EVP_CIPHER_get_nid(cipher), NULL);
1022 if (res <= 0 && res != -2)
1023 goto end;
1024
1025 if (CMS_RecipientInfo_type(ri) == CMS_RECIPINFO_AGREE
1026 && wrap_cipher != NULL) {
1027 EVP_CIPHER_CTX *wctx;
1028 wctx = CMS_RecipientInfo_kari_get0_ctx(ri);
1029 if (EVP_EncryptInit_ex(wctx, wrap_cipher, NULL, NULL, NULL) != 1)
1030 goto end;
1031 }
1032 }
1033
1034 if (secret_key != NULL) {
1035 if (!CMS_add0_recipient_key(cms, NID_undef,
1036 secret_key, secret_keylen,
1037 secret_keyid, secret_keyidlen,
1038 NULL, NULL, NULL))
1039 goto end;
1040 /* NULL these because call absorbs them */
1041 secret_key = NULL;
1042 secret_keyid = NULL;
1043 }
1044 if (pwri_pass != NULL) {
1045 pwri_tmp = (unsigned char *)OPENSSL_strdup((char *)pwri_pass);
1046 if (pwri_tmp == NULL)
1047 goto end;
1048 if (CMS_add0_recipient_password(cms,
1049 -1, NID_undef, NID_undef,
1050 pwri_tmp, -1, NULL) == NULL)
1051 goto end;
1052 pwri_tmp = NULL;
1053 }
1054 if (!(flags & CMS_STREAM)) {
1055 if (!CMS_final(cms, in, NULL, flags)) {
1056 if (originator != NULL
1057 && ERR_GET_REASON(ERR_peek_error())
1058 == CMS_R_ERROR_UNSUPPORTED_STATIC_KEY_AGREEMENT) {
1059 BIO_printf(bio_err, "Cannot use originator for encryption\n");
1060 goto end;
1061 }
1062 goto end;
1063 }
1064 }
1065 } else if (operation == SMIME_ENCRYPTED_ENCRYPT) {
1066 cms = CMS_EncryptedData_encrypt_ex(in, cipher, secret_key,
1067 secret_keylen, flags, libctx, app_get0_propq());
1068
1069 } else if (operation == SMIME_SIGN_RECEIPT) {
1070 CMS_ContentInfo *srcms = NULL;
1071 STACK_OF(CMS_SignerInfo) *sis;
1072 CMS_SignerInfo *si;
1073 sis = CMS_get0_SignerInfos(cms);
1074 if (sis == NULL)
1075 goto end;
1076 si = sk_CMS_SignerInfo_value(sis, 0);
1077 srcms = CMS_sign_receipt(si, signer, key, other, flags);
1078 if (srcms == NULL)
1079 goto end;
1080 CMS_ContentInfo_free(cms);
1081 cms = srcms;
1082 } else if (operation & SMIME_SIGNERS) {
1083 int i;
1084 /*
1085 * If detached data content and not signing pre-computed digest, we
1086 * enable streaming if S/MIME output format.
1087 */
1088 if (operation == SMIME_SIGN) {
1089
1090 if ((flags & CMS_DETACHED) != 0 && digestbin == NULL) {
1091 if (outformat == FORMAT_SMIME)
1092 flags |= CMS_STREAM;
1093 }
1094 flags |= CMS_PARTIAL;
1095 cms = CMS_sign_ex(NULL, NULL, other, in, flags, libctx, app_get0_propq());
1096 if (cms == NULL)
1097 goto end;
1098 if (econtent_type != NULL)
1099 CMS_set1_eContentType(cms, econtent_type);
1100
1101 if (rr_to != NULL
1102 && ((rr = make_receipt_request(rr_to, rr_allorfirst, rr_from))
1103 == NULL)) {
1104 BIO_puts(bio_err, "Signed Receipt Request Creation Error\n");
1105 goto end;
1106 }
1107 } else {
1108 flags |= CMS_REUSE_DIGEST;
1109 }
1110 for (i = 0; i < sk_OPENSSL_STRING_num(sksigners); i++) {
1111 CMS_SignerInfo *si;
1112 cms_key_param *kparam;
1113 int tflags = flags;
1114 signerfile = sk_OPENSSL_STRING_value(sksigners, i);
1115 keyfile = sk_OPENSSL_STRING_value(skkeys, i);
1116
1117 signer = load_cert(signerfile, FORMAT_UNDEF, "signer certificate");
1118 if (signer == NULL) {
1119 ret = 2;
1120 goto end;
1121 }
1122 key = load_key(keyfile, keyform, 0, passin, e, "signing key");
1123 if (key == NULL) {
1124 ret = 2;
1125 goto end;
1126 }
1127
1128 for (kparam = key_first; kparam; kparam = kparam->next) {
1129 if (kparam->idx == i) {
1130 tflags |= CMS_KEY_PARAM;
1131 break;
1132 }
1133 }
1134 si = CMS_add1_signer(cms, signer, key, sign_md, tflags);
1135 if (si == NULL)
1136 goto end;
1137 if (kparam != NULL) {
1138 EVP_PKEY_CTX *pctx;
1139 pctx = CMS_SignerInfo_get0_pkey_ctx(si);
1140 if (!cms_set_pkey_param(pctx, kparam->param))
1141 goto end;
1142 }
1143 if (rr != NULL && !CMS_add1_ReceiptRequest(si, rr))
1144 goto end;
1145 X509_free(signer);
1146 signer = NULL;
1147 EVP_PKEY_free(key);
1148 key = NULL;
1149 }
1150 /* If not streaming or resigning finalize structure */
1151 if (operation == SMIME_SIGN && digestbin != NULL
1152 && (flags & CMS_STREAM) == 0) {
1153 /* Use pre-computed digest instead of content */
1154 if (!CMS_final_digest(cms, digestbin, digestlen, NULL, flags))
1155 goto end;
1156 } else if (operation == SMIME_SIGN && (flags & CMS_STREAM) == 0) {
1157 if (!CMS_final(cms, in, NULL, flags))
1158 goto end;
1159 }
1160 }
1161
1162 if (cms == NULL) {
1163 BIO_printf(bio_err, "Error creating CMS structure\n");
1164 goto end;
1165 }
1166
1167 ret = 4;
1168 if (operation == SMIME_DECRYPT) {
1169 if (flags & CMS_DEBUG_DECRYPT)
1170 CMS_decrypt(cms, NULL, NULL, NULL, NULL, flags);
1171
1172 if (secret_key != NULL) {
1173 if (!CMS_decrypt_set1_key(cms,
1174 secret_key, secret_keylen,
1175 secret_keyid, secret_keyidlen)) {
1176 BIO_puts(bio_err, "Error decrypting CMS using secret key\n");
1177 goto end;
1178 }
1179 }
1180
1181 if (key != NULL) {
1182 if (!CMS_decrypt_set1_pkey_and_peer(cms, key, recip, originator)) {
1183 BIO_puts(bio_err, "Error decrypting CMS using private key\n");
1184 goto end;
1185 }
1186 }
1187
1188 if (pwri_pass != NULL) {
1189 if (!CMS_decrypt_set1_password(cms, pwri_pass, -1)) {
1190 BIO_puts(bio_err, "Error decrypting CMS using password\n");
1191 goto end;
1192 }
1193 }
1194
1195 if (!CMS_decrypt(cms, NULL, NULL, indata, out, flags)) {
1196 BIO_printf(bio_err, "Error decrypting CMS structure\n");
1197 goto end;
1198 }
1199 } else if (operation == SMIME_DATA_OUT) {
1200 if (!CMS_data(cms, out, flags))
1201 goto end;
1202 } else if (operation == SMIME_UNCOMPRESS) {
1203 if (!CMS_uncompress(cms, indata, out, flags))
1204 goto end;
1205 } else if (operation == SMIME_DIGEST_VERIFY) {
1206 if (CMS_digest_verify(cms, indata, out, flags) > 0) {
1207 BIO_printf(bio_err, "Verification successful\n");
1208 } else {
1209 BIO_printf(bio_err, "Verification failure\n");
1210 goto end;
1211 }
1212 } else if (operation == SMIME_ENCRYPTED_DECRYPT) {
1213 if (!CMS_EncryptedData_decrypt(cms, secret_key, secret_keylen,
1214 indata, out, flags))
1215 goto end;
1216 } else if (operation == SMIME_VERIFY) {
1217 if (CMS_verify(cms, other, store, indata, out, flags) > 0) {
1218 BIO_printf(bio_err, "%s Verification successful\n",
1219 (flags & CMS_CADES) != 0 ? "CAdES" : "CMS");
1220 } else {
1221 BIO_printf(bio_err, "%s Verification failure\n",
1222 (flags & CMS_CADES) != 0 ? "CAdES" : "CMS");
1223 if (verify_retcode)
1224 ret = verify_err + 32;
1225 goto end;
1226 }
1227 if (signerfile != NULL) {
1228 STACK_OF(X509) *signers = CMS_get0_signers(cms);
1229
1230 if (!save_certs(signerfile, signers)) {
1231 BIO_printf(bio_err,
1232 "Error writing signers to %s\n", signerfile);
1233 ret = 5;
1234 goto end;
1235 }
1236 sk_X509_free(signers);
1237 }
1238 if (rr_print)
1239 receipt_request_print(cms);
1240
1241 } else if (operation == SMIME_VERIFY_RECEIPT) {
1242 if (CMS_verify_receipt(rcms, cms, other, store, flags) > 0) {
1243 BIO_printf(bio_err, "Verification successful\n");
1244 } else {
1245 BIO_printf(bio_err, "Verification failure\n");
1246 goto end;
1247 }
1248 } else {
1249 if (noout) {
1250 if (print) {
1251 ASN1_PCTX *pctx = NULL;
1252 if (get_nameopt() != XN_FLAG_ONELINE) {
1253 pctx = ASN1_PCTX_new();
1254 if (pctx != NULL) { /* Print anyway if malloc failed */
1255 ASN1_PCTX_set_flags(pctx, ASN1_PCTX_FLAGS_SHOW_ABSENT);
1256 ASN1_PCTX_set_str_flags(pctx, get_nameopt());
1257 ASN1_PCTX_set_nm_flags(pctx, get_nameopt());
1258 }
1259 }
1260 CMS_ContentInfo_print_ctx(out, cms, 0, pctx);
1261 ASN1_PCTX_free(pctx);
1262 }
1263 } else if (outformat == FORMAT_SMIME) {
1264 if (to)
1265 BIO_printf(out, "To: %s%s", to, mime_eol);
1266 if (from)
1267 BIO_printf(out, "From: %s%s", from, mime_eol);
1268 if (subject)
1269 BIO_printf(out, "Subject: %s%s", subject, mime_eol);
1270 if (operation == SMIME_RESIGN)
1271 ret = SMIME_write_CMS(out, cms, indata, flags);
1272 else
1273 ret = SMIME_write_CMS(out, cms, in, flags);
1274 } else if (outformat == FORMAT_PEM) {
1275 ret = PEM_write_bio_CMS_stream(out, cms, in, flags);
1276 } else if (outformat == FORMAT_ASN1) {
1277 ret = i2d_CMS_bio_stream(out, cms, in, flags);
1278 } else {
1279 BIO_printf(bio_err, "Bad output format for CMS file\n");
1280 goto end;
1281 }
1282 if (ret <= 0) {
1283 ret = 6;
1284 goto end;
1285 }
1286 }
1287 ret = 0;
1288 end:
1289 if (ret)
1290 ERR_print_errors(bio_err);
1291 OSSL_STACK_OF_X509_free(encerts);
1292 OSSL_STACK_OF_X509_free(other);
1293 X509_VERIFY_PARAM_free(vpm);
1294 sk_OPENSSL_STRING_free(sksigners);
1295 sk_OPENSSL_STRING_free(skkeys);
1296 OPENSSL_free(secret_key);
1297 OPENSSL_free(secret_keyid);
1298 OPENSSL_free(pwri_tmp);
1299 ASN1_OBJECT_free(econtent_type);
1300 CMS_ReceiptRequest_free(rr);
1301 sk_OPENSSL_STRING_free(rr_to);
1302 sk_OPENSSL_STRING_free(rr_from);
1303 for (key_param = key_first; key_param;) {
1304 cms_key_param *tparam;
1305 sk_OPENSSL_STRING_free(key_param->param);
1306 tparam = key_param->next;
1307 OPENSSL_free(key_param);
1308 key_param = tparam;
1309 }
1310 X509_STORE_free(store);
1311 X509_free(cert);
1312 X509_free(recip);
1313 X509_free(signer);
1314 X509_free(originator);
1315 EVP_PKEY_free(key);
1316 EVP_CIPHER_free(cipher);
1317 EVP_CIPHER_free(wrap_cipher);
1318 EVP_MD_free(sign_md);
1319 CMS_ContentInfo_free(cms);
1320 CMS_ContentInfo_free(rcms);
1321 release_engine(e);
1322 BIO_free(rctin);
1323 BIO_free(in);
1324 BIO_free(indata);
1325 BIO_free_all(out);
1326 OPENSSL_free(digestbin);
1327 OPENSSL_free(passin);
1328 NCONF_free(conf);
1329 return ret;
1330 }
1331
save_certs(char * signerfile,STACK_OF (X509)* signers)1332 static int save_certs(char *signerfile, STACK_OF(X509) *signers)
1333 {
1334 int i;
1335 BIO *tmp;
1336 if (signerfile == NULL)
1337 return 1;
1338 tmp = BIO_new_file(signerfile, "w");
1339 if (tmp == NULL)
1340 return 0;
1341 for (i = 0; i < sk_X509_num(signers); i++)
1342 PEM_write_bio_X509(tmp, sk_X509_value(signers, i));
1343 BIO_free(tmp);
1344 return 1;
1345 }
1346
1347 /* Minimal callback just to output policy info (if any) */
1348
cms_cb(int ok,X509_STORE_CTX * ctx)1349 static int cms_cb(int ok, X509_STORE_CTX *ctx)
1350 {
1351 int error;
1352
1353 error = X509_STORE_CTX_get_error(ctx);
1354
1355 verify_err = error;
1356
1357 if ((error != X509_V_ERR_NO_EXPLICIT_POLICY)
1358 && ((error != X509_V_OK) || (ok != 2)))
1359 return ok;
1360
1361 policies_print(ctx);
1362
1363 return ok;
1364
1365 }
1366
gnames_stack_print(STACK_OF (GENERAL_NAMES)* gns)1367 static void gnames_stack_print(STACK_OF(GENERAL_NAMES) *gns)
1368 {
1369 STACK_OF(GENERAL_NAME) *gens;
1370 GENERAL_NAME *gen;
1371 int i, j;
1372
1373 for (i = 0; i < sk_GENERAL_NAMES_num(gns); i++) {
1374 gens = sk_GENERAL_NAMES_value(gns, i);
1375 for (j = 0; j < sk_GENERAL_NAME_num(gens); j++) {
1376 gen = sk_GENERAL_NAME_value(gens, j);
1377 BIO_puts(bio_err, " ");
1378 GENERAL_NAME_print(bio_err, gen);
1379 BIO_puts(bio_err, "\n");
1380 }
1381 }
1382 return;
1383 }
1384
receipt_request_print(CMS_ContentInfo * cms)1385 static void receipt_request_print(CMS_ContentInfo *cms)
1386 {
1387 STACK_OF(CMS_SignerInfo) *sis;
1388 CMS_SignerInfo *si;
1389 CMS_ReceiptRequest *rr;
1390 int allorfirst;
1391 STACK_OF(GENERAL_NAMES) *rto, *rlist;
1392 ASN1_STRING *scid;
1393 int i, rv;
1394 sis = CMS_get0_SignerInfos(cms);
1395 for (i = 0; i < sk_CMS_SignerInfo_num(sis); i++) {
1396 si = sk_CMS_SignerInfo_value(sis, i);
1397 rv = CMS_get1_ReceiptRequest(si, &rr);
1398 BIO_printf(bio_err, "Signer %d:\n", i + 1);
1399 if (rv == 0) {
1400 BIO_puts(bio_err, " No Receipt Request\n");
1401 } else if (rv < 0) {
1402 BIO_puts(bio_err, " Receipt Request Parse Error\n");
1403 ERR_print_errors(bio_err);
1404 } else {
1405 const char *id;
1406 int idlen;
1407 CMS_ReceiptRequest_get0_values(rr, &scid, &allorfirst,
1408 &rlist, &rto);
1409 BIO_puts(bio_err, " Signed Content ID:\n");
1410 idlen = ASN1_STRING_length(scid);
1411 id = (const char *)ASN1_STRING_get0_data(scid);
1412 BIO_dump_indent(bio_err, id, idlen, 4);
1413 BIO_puts(bio_err, " Receipts From");
1414 if (rlist != NULL) {
1415 BIO_puts(bio_err, " List:\n");
1416 gnames_stack_print(rlist);
1417 } else if (allorfirst == 1) {
1418 BIO_puts(bio_err, ": First Tier\n");
1419 } else if (allorfirst == 0) {
1420 BIO_puts(bio_err, ": All\n");
1421 } else {
1422 BIO_printf(bio_err, " Unknown (%d)\n", allorfirst);
1423 }
1424 BIO_puts(bio_err, " Receipts To:\n");
1425 gnames_stack_print(rto);
1426 }
1427 CMS_ReceiptRequest_free(rr);
1428 }
1429 }
1430
STACK_OF(GENERAL_NAMES)1431 static STACK_OF(GENERAL_NAMES) *make_names_stack(STACK_OF(OPENSSL_STRING) *ns)
1432 {
1433 int i;
1434 STACK_OF(GENERAL_NAMES) *ret;
1435 GENERAL_NAMES *gens = NULL;
1436 GENERAL_NAME *gen = NULL;
1437 ret = sk_GENERAL_NAMES_new_null();
1438 if (ret == NULL)
1439 goto err;
1440 for (i = 0; i < sk_OPENSSL_STRING_num(ns); i++) {
1441 char *str = sk_OPENSSL_STRING_value(ns, i);
1442 gen = a2i_GENERAL_NAME(NULL, NULL, NULL, GEN_EMAIL, str, 0);
1443 if (gen == NULL)
1444 goto err;
1445 gens = GENERAL_NAMES_new();
1446 if (gens == NULL)
1447 goto err;
1448 if (!sk_GENERAL_NAME_push(gens, gen))
1449 goto err;
1450 gen = NULL;
1451 if (!sk_GENERAL_NAMES_push(ret, gens))
1452 goto err;
1453 gens = NULL;
1454 }
1455
1456 return ret;
1457
1458 err:
1459 sk_GENERAL_NAMES_pop_free(ret, GENERAL_NAMES_free);
1460 GENERAL_NAMES_free(gens);
1461 GENERAL_NAME_free(gen);
1462 return NULL;
1463 }
1464
1465 static CMS_ReceiptRequest
make_receipt_request(STACK_OF (OPENSSL_STRING)* rr_to,int rr_allorfirst,STACK_OF (OPENSSL_STRING)* rr_from)1466 *make_receipt_request(STACK_OF(OPENSSL_STRING) *rr_to, int rr_allorfirst,
1467 STACK_OF(OPENSSL_STRING) *rr_from)
1468 {
1469 STACK_OF(GENERAL_NAMES) *rct_to = NULL, *rct_from = NULL;
1470 CMS_ReceiptRequest *rr;
1471
1472 rct_to = make_names_stack(rr_to);
1473 if (rct_to == NULL)
1474 goto err;
1475 if (rr_from != NULL) {
1476 rct_from = make_names_stack(rr_from);
1477 if (rct_from == NULL)
1478 goto err;
1479 } else {
1480 rct_from = NULL;
1481 }
1482 rr = CMS_ReceiptRequest_create0_ex(NULL, -1, rr_allorfirst, rct_from,
1483 rct_to, app_get0_libctx());
1484 if (rr == NULL)
1485 goto err;
1486 return rr;
1487 err:
1488 sk_GENERAL_NAMES_pop_free(rct_to, GENERAL_NAMES_free);
1489 sk_GENERAL_NAMES_pop_free(rct_from, GENERAL_NAMES_free);
1490 return NULL;
1491 }
1492
cms_set_pkey_param(EVP_PKEY_CTX * pctx,STACK_OF (OPENSSL_STRING)* param)1493 static int cms_set_pkey_param(EVP_PKEY_CTX *pctx,
1494 STACK_OF(OPENSSL_STRING) *param)
1495 {
1496 char *keyopt;
1497 int i;
1498 if (sk_OPENSSL_STRING_num(param) <= 0)
1499 return 1;
1500 for (i = 0; i < sk_OPENSSL_STRING_num(param); i++) {
1501 keyopt = sk_OPENSSL_STRING_value(param, i);
1502 if (pkey_ctrl_string(pctx, keyopt) <= 0) {
1503 BIO_printf(bio_err, "parameter error \"%s\"\n", keyopt);
1504 ERR_print_errors(bio_err);
1505 return 0;
1506 }
1507 }
1508 return 1;
1509 }
1510