?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* gpg.texi (OpenPGP Options): Don't mention --no-sk-comment (doesn't
[gnupg.git] / sm / gpgsm.c
blob93e9076589988673959faef5ab90d72c628f6167
1 /* gpgsm.c - GnuPG for S/MIME
2 * Copyright (C) 2001, 2002, 2003, 2004, 2005,
3 * 2006, 2007, 2008 Free Software Foundation, Inc.
4 *
5 * This file is part of GnuPG.
6 *
7 * GnuPG is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * GnuPG is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29 /*#include <mcheck.h>*/
30
31 #include "gpgsm.h"
32 #include <gcrypt.h>
33 #include <assuan.h> /* malloc hooks */
34
35 #include "../kbx/keybox.h" /* malloc hooks */
36 #include "i18n.h"
37 #include "keydb.h"
38 #include "sysutils.h"
39 #include "gc-opt-flags.h"
40
41
42 #ifndef O_BINARY
43 #define O_BINARY 0
44 #endif
45
46 enum cmd_and_opt_values {
47 aNull = 0,
48 oArmor = 'a',
49 aDetachedSign = 'b',
50 aSym = 'c',
51 aDecrypt = 'd',
52 aEncr = 'e',
53 aListKeys = 'k',
54 aListSecretKeys = 'K',
55 oDryRun = 'n',
56 oOutput = 'o',
57 oQuiet = 'q',
58 oRecipient = 'r',
59 aSign = 's',
60 oUser = 'u',
61 oVerbose = 'v',
62 oBatch = 500,
63 aClearsign,
64 aKeygen,
65 aSignEncr,
66 aDeleteKey,
67 aImport,
68 aVerify,
69 aListExternalKeys,
70 aListChain,
71 aSendKeys,
72 aRecvKeys,
73 aExport,
74 aExportSecretKeyP12,
75 aServer,
76 aLearnCard,
77 aCallDirmngr,
78 aCallProtectTool,
79 aPasswd,
80 aGPGConfList,
81 aGPGConfTest,
82 aDumpKeys,
83 aDumpChain,
84 aDumpSecretKeys,
85 aDumpExternalKeys,
86 aKeydbClearSomeCertFlags,
87 aFingerprint,
88
89 oOptions,
90 oDebug,
91 oDebugLevel,
92 oDebugAll,
93 oDebugNone,
94 oDebugWait,
95 oDebugAllowCoreDump,
96 oDebugNoChainValidation,
97 oDebugIgnoreExpiration,
98 oFixedPassphrase,
99 oLogFile,
100 oNoLogFile,
101 oAuditLog,
102
103 oEnableSpecialFilenames,
104
105 oAgentProgram,
106 oDisplay,
107 oTTYname,
108 oTTYtype,
109 oLCctype,
110 oLCmessages,
111 oXauthority,
112
113 oPreferSystemDirmngr,
114 oDirmngrProgram,
115 oDisableDirmngr,
116 oProtectToolProgram,
117 oFakedSystemTime,
118
119
120 oAssumeArmor,
121 oAssumeBase64,
122 oAssumeBinary,
123
124 oBase64,
125 oNoArmor,
126 oP12Charset,
127
128 oDisableCRLChecks,
129 oEnableCRLChecks,
130 oDisableTrustedCertCRLCheck,
131 oEnableTrustedCertCRLCheck,
132 oForceCRLRefresh,
133
134 oDisableOCSP,
135 oEnableOCSP,
136
137 oIncludeCerts,
138 oPolicyFile,
139 oDisablePolicyChecks,
140 oEnablePolicyChecks,
141 oAutoIssuerKeyRetrieve,
142
143 oWithFingerprint,
144 oWithMD5Fingerprint,
145 oAnswerYes,
146 oAnswerNo,
147 oKeyring,
148 oDefaultKey,
149 oDefRecipient,
150 oDefRecipientSelf,
151 oNoDefRecipient,
152 oStatusFD,
153 oCipherAlgo,
154 oDigestAlgo,
155 oExtraDigestAlgo,
156 oNoVerbose,
157 oNoSecmemWarn,
158 oNoDefKeyring,
159 oNoGreeting,
160 oNoTTY,
161 oNoOptions,
162 oNoBatch,
163 oHomedir,
164 oWithColons,
165 oWithKeyData,
166 oWithValidation,
167 oWithEphemeralKeys,
168 oSkipVerify,
169 oValidationModel,
170 oKeyServer,
171 oEncryptTo,
172 oNoEncryptTo,
173 oLoggerFD,
174 oDisableCipherAlgo,
175 oDisablePubkeyAlgo,
176 oIgnoreTimeConflict,
177 oNoRandomSeedFile,
178 oNoCommonCertsImport
179 };
180
181
182 static ARGPARSE_OPTS opts[] = {
183
184 ARGPARSE_group (300, N_("@Commands:\n ")),
185
186 ARGPARSE_c (aSign, "sign", N_("make a signature")),
187 ARGPARSE_c (aClearsign, "clearsign", N_("make a clear text signature") ),
188 ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
189 ARGPARSE_c (aEncr, "encrypt", N_("encrypt data")),
190 ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),
191 ARGPARSE_c (aDecrypt, "decrypt", N_("decrypt data (default)")),
192 ARGPARSE_c (aVerify, "verify", N_("verify a signature")),
193 ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
194 ARGPARSE_c (aListExternalKeys, "list-external-keys",
195 N_("list external keys")),
196 ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
197 ARGPARSE_c (aListChain, "list-chain", N_("list certificate chain")),
198 ARGPARSE_c (aFingerprint, "fingerprint", N_("list keys and fingerprints")),
199 ARGPARSE_c (aKeygen, "gen-key", N_("generate a new key pair")),
200 ARGPARSE_c (aDeleteKey, "delete-keys",
201 N_("remove keys from the public keyring")),
202 ARGPARSE_c (aSendKeys, "send-keys", N_("export keys to a key server")),
203 ARGPARSE_c (aRecvKeys, "recv-keys", N_("import keys from a key server")),
204 ARGPARSE_c (aImport, "import", N_("import certificates")),
205 ARGPARSE_c (aExport, "export", N_("export certificates")),
206 ARGPARSE_c (aExportSecretKeyP12, "export-secret-key-p12", "@"),
207 ARGPARSE_c (aLearnCard, "learn-card", N_("register a smartcard")),
208 ARGPARSE_c (aServer, "server", N_("run in server mode")),
209 ARGPARSE_c (aCallDirmngr, "call-dirmngr",
210 N_("pass a command to the dirmngr")),
211 ARGPARSE_c (aCallProtectTool, "call-protect-tool",
212 N_("invoke gpg-protect-tool")),
213 ARGPARSE_c (aPasswd, "passwd", N_("change a passphrase")),
214 ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
215 ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
216
217 ARGPARSE_c (aDumpKeys, "dump-cert", "@"),
218 ARGPARSE_c (aDumpKeys, "dump-keys", "@"),
219 ARGPARSE_c (aDumpChain, "dump-chain", "@"),
220 ARGPARSE_c (aDumpExternalKeys, "dump-external-keys", "@"),
221 ARGPARSE_c (aDumpSecretKeys, "dump-secret-keys", "@"),
222 ARGPARSE_c (aKeydbClearSomeCertFlags, "keydb-clear-some-cert-flags", "@"),
223
224 ARGPARSE_group (301, N_("@\nOptions:\n ")),
225
226 ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
227 ARGPARSE_s_n (oArmor, "armour", "@"),
228 ARGPARSE_s_n (oBase64, "base64", N_("create base-64 encoded output")),
229
230 ARGPARSE_s_s (oP12Charset, "p12-charset", "@"),
231
232 ARGPARSE_s_n (oAssumeArmor, "assume-armor",
233 N_("assume input is in PEM format")),
234 ARGPARSE_s_n (oAssumeBase64, "assume-base64",
235 N_("assume input is in base-64 format")),
236 ARGPARSE_s_n (oAssumeBinary, "assume-binary",
237 N_("assume input is in binary format")),
238
239 ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
240
241 ARGPARSE_s_n (oPreferSystemDirmngr,"prefer-system-dirmngr",
242 N_("use system's dirmngr if available")),
243
244 ARGPARSE_s_n (oDisableCRLChecks, "disable-crl-checks",
245 N_("never consult a CRL")),
246 ARGPARSE_s_n (oEnableCRLChecks, "enable-crl-checks", "@"),
247 ARGPARSE_s_n (oDisableTrustedCertCRLCheck,
248 "disable-trusted-cert-crl-check", "@"),
249 ARGPARSE_s_n (oEnableTrustedCertCRLCheck,
250 "enable-trusted-cert-crl-check", "@"),
251
252 ARGPARSE_s_n (oForceCRLRefresh, "force-crl-refresh", "@"),
253
254 ARGPARSE_s_n (oDisableOCSP, "disable-ocsp", "@"),
255 ARGPARSE_s_n (oEnableOCSP, "enable-ocsp", N_("check validity using OCSP")),
256
257 ARGPARSE_s_s (oValidationModel, "validation-model", "@"),
258
259 ARGPARSE_s_i (oIncludeCerts, "include-certs",
260 N_("|N|number of certificates to include") ),
261
262 ARGPARSE_s_s (oPolicyFile, "policy-file",
263 N_("|FILE|take policy information from FILE")),
264
265 ARGPARSE_s_n (oDisablePolicyChecks, "disable-policy-checks",
266 N_("do not check certificate policies")),
267 ARGPARSE_s_n (oEnablePolicyChecks, "enable-policy-checks", "@"),
268
269 ARGPARSE_s_n (oAutoIssuerKeyRetrieve, "auto-issuer-key-retrieve",
270 N_("fetch missing issuer certificates")),
271
272 ARGPARSE_s_s (oEncryptTo, "encrypt-to", "@"),
273 ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
274
275 ARGPARSE_s_s (oUser, "local-user",
276 N_("|USER-ID|use USER-ID to sign or decrypt")),
277
278 ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
279 ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
280 ARGPARSE_s_n (oQuiet, "quiet", N_("be somewhat more quiet")),
281 ARGPARSE_s_n (oNoTTY, "no-tty", N_("don't use the terminal at all")),
282 ARGPARSE_s_s (oLogFile, "log-file",
283 N_("|FILE|write a server mode log to FILE")),
284 ARGPARSE_s_n (oNoLogFile, "no-log-file", "@"),
285 ARGPARSE_s_i (oLoggerFD, "logger-fd", "@"),
286
287 ARGPARSE_s_s (oAuditLog, "audit-log",
288 N_("|FILE|write an audit log to FILE")),
289 ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
290 ARGPARSE_s_n (oBatch, "batch", N_("batch mode: never ask")),
291 ARGPARSE_s_n (oAnswerYes, "yes", N_("assume yes on most questions")),
292 ARGPARSE_s_n (oAnswerNo, "no", N_("assume no on most questions")),
293
294 ARGPARSE_s_s (oKeyring, "keyring",
295 N_("|FILE|add keyring to the list of keyrings")),
296
297 ARGPARSE_s_s (oDefaultKey, "default-key",
298 N_("|USER-ID|use USER-ID as default secret key")),
299
300 /* Not yet used: */
301 /* ARGPARSE_s_s (oDefRecipient, "default-recipient", */
302 /* N_("|NAME|use NAME as default recipient")), */
303 /* ARGPARSE_s_n (oDefRecipientSelf, "default-recipient-self", */
304 /* N_("use the default key as default recipient")), */
305 /* ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"), */
306
307 ARGPARSE_s_s (oKeyServer, "keyserver",
308 N_("|SPEC|use this keyserver to lookup keys")),
309 ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
310
311 ARGPARSE_p_u (oDebug, "debug", "@"),
312 ARGPARSE_s_s (oDebugLevel, "debug-level",
313 N_("|LEVEL|set the debugging level to LEVEL")),
314 ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
315 ARGPARSE_s_n (oDebugNone, "debug-none", "@"),
316 ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
317 ARGPARSE_s_n (oDebugAllowCoreDump, "debug-allow-core-dump", "@"),
318 ARGPARSE_s_n (oDebugNoChainValidation, "debug-no-chain-validation", "@"),
319 ARGPARSE_s_n (oDebugIgnoreExpiration, "debug-ignore-expiration", "@"),
320 ARGPARSE_s_s (oFixedPassphrase, "fixed-passphrase", "@"),
321
322 ARGPARSE_s_i (oStatusFD, "status-fd",
323 N_("|FD|write status info to this FD")),
324
325 ARGPARSE_s_s (oCipherAlgo, "cipher-algo",
326 N_("|NAME|use cipher algorithm NAME")),
327 ARGPARSE_s_s (oDigestAlgo, "digest-algo",
328 N_("|NAME|use message digest algorithm NAME")),
329 ARGPARSE_s_s (oExtraDigestAlgo, "extra-digest-algo", "@"),
330
331
332 ARGPARSE_group (302, N_(
333 "@\n(See the man page for a complete listing of all commands and options)\n"
334 )),
335
336 ARGPARSE_group (303, N_("@\nExamples:\n\n"
337 " -se -r Bob [file] sign and encrypt for user Bob\n"
338 " --clearsign [file] make a clear text signature\n"
339 " --detach-sign [file] make a detached signature\n"
340 " --list-keys [names] show keys\n"
341 " --fingerprint [names] show fingerprints\n" )),
342
343 /* Hidden options. */
344 ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
345 ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
346 ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
347 ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
348 ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
349 ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
350 ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
351 ARGPARSE_s_n (oNoOptions, "no-options", "@"),
352 ARGPARSE_s_s (oHomedir, "homedir", "@"),
353 ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
354 ARGPARSE_s_s (oDisplay, "display", "@"),
355 ARGPARSE_s_s (oTTYname, "ttyname", "@"),
356 ARGPARSE_s_s (oTTYtype, "ttytype", "@"),
357 ARGPARSE_s_s (oLCctype, "lc-ctype", "@"),
358 ARGPARSE_s_s (oLCmessages, "lc-messages", "@"),
359 ARGPARSE_s_s (oXauthority, "xauthority", "@"),
360 ARGPARSE_s_s (oDirmngrProgram, "dirmngr-program", "@"),
361 ARGPARSE_s_n (oDisableDirmngr, "disable-dirmngr", "@"),
362 ARGPARSE_s_s (oProtectToolProgram, "protect-tool-program", "@"),
363 ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
364 ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
365 ARGPARSE_s_n (oWithColons, "with-colons", "@"),
366 ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
367 ARGPARSE_s_n (oWithValidation, "with-validation", "@"),
368 ARGPARSE_s_n (oWithMD5Fingerprint, "with-md5-fingerprint", "@"),
369 ARGPARSE_s_n (oWithEphemeralKeys, "with-ephemeral-keys", "@"),
370 ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
371 ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
372 ARGPARSE_s_s (oDisableCipherAlgo, "disable-cipher-algo", "@"),
373 ARGPARSE_s_s (oDisablePubkeyAlgo, "disable-pubkey-algo", "@"),
374 ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
375 ARGPARSE_s_n (oNoRandomSeedFile, "no-random-seed-file", "@"),
376 ARGPARSE_s_n (oNoCommonCertsImport, "no-common-certs-import", "@"),
377
378 /* Command aliases. */
379 ARGPARSE_c (aListKeys, "list-key", "@"),
380 ARGPARSE_c (aListChain, "list-sig", "@"),
381 ARGPARSE_c (aListChain, "list-sigs", "@"),
382 ARGPARSE_c (aListChain, "check-sig", "@"),
383 ARGPARSE_c (aListChain, "check-sigs", "@"),
384 ARGPARSE_c (aDeleteKey, "delete-key", "@"),
385
386 ARGPARSE_end ()
387 };
388
389
390
391
392 /* Global variable to keep an error count. */
393 int gpgsm_errors_seen = 0;
394
395 /* It is possible that we are currentlu running under setuid permissions */
396 static int maybe_setuid = 1;
397
398 /* Helper to implement --debug-level and --debug*/
399 static const char *debug_level;
400 static unsigned int debug_value;
401
402 /* Option --enable-special-filenames */
403 static int allow_special_filenames;
404
405 /* Default value for include-certs. */
406 static int default_include_certs = 1; /* Only include the signer's cert. */
407
408 /* Whether the chain mode shall be used for validation. */
409 static int default_validation_model;
410
411
412 static char *build_list (const char *text,
413 const char *(*mapf)(int), int (*chkf)(int));
414 static void set_cmd (enum cmd_and_opt_values *ret_cmd,
415 enum cmd_and_opt_values new_cmd );
416
417 static void emergency_cleanup (void);
418 static int check_special_filename (const char *fname, int for_write);
419 static int open_read (const char *filename);
420 static estream_t open_es_fread (const char *filename);
421 static FILE *open_fwrite (const char *filename);
422 static estream_t open_es_fwrite (const char *filename);
423 static void run_protect_tool (int argc, char **argv);
424
425 static int
426 our_pk_test_algo (int algo)
427 {
428 switch (algo)
429 {
430 case GCRY_PK_RSA:
431 case GCRY_PK_ECDSA:
432 return gcry_pk_test_algo (algo);
433 default:
434 return 1;
435 }
436 }
437
438 static int
439 our_cipher_test_algo (int algo)
440 {
441 switch (algo)
442 {
443 case GCRY_CIPHER_3DES:
444 case GCRY_CIPHER_AES128:
445 case GCRY_CIPHER_AES192:
446 case GCRY_CIPHER_AES256:
447 case GCRY_CIPHER_SERPENT128:
448 case GCRY_CIPHER_SERPENT192:
449 case GCRY_CIPHER_SERPENT256:
450 case GCRY_CIPHER_SEED:
451 case GCRY_CIPHER_CAMELLIA128:
452 case GCRY_CIPHER_CAMELLIA192:
453 case GCRY_CIPHER_CAMELLIA256:
454 return gcry_cipher_test_algo (algo);
455 default:
456 return 1;
457 }
458 }
459
460
461 static int
462 our_md_test_algo (int algo)
463 {
464 switch (algo)
465 {
466 case GCRY_MD_MD5:
467 case GCRY_MD_SHA1:
468 case GCRY_MD_RMD160:
469 case GCRY_MD_SHA224:
470 case GCRY_MD_SHA256:
471 case GCRY_MD_SHA384:
472 case GCRY_MD_SHA512:
473 case GCRY_MD_WHIRLPOOL:
474 return gcry_md_test_algo (algo);
475 default:
476 return 1;
477 }
478 }
479
480
481 static char *
482 make_libversion (const char *libname, const char *(*getfnc)(const char*))
483 {
484 const char *s;
485 char *result;
486
487 if (maybe_setuid)
488 {
489 gcry_control (GCRYCTL_INIT_SECMEM, 0, 0); /* Drop setuid. */
490 maybe_setuid = 0;
491 }
492 s = getfnc (NULL);
493 result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
494 strcpy (stpcpy (stpcpy (result, libname), " "), s);
495 return result;
496 }
497
498
499 static const char *
500 my_strusage( int level )
501 {
502 static char *digests, *pubkeys, *ciphers;
503 static char *ver_gcry, *ver_ksba;
504 const char *p;
505
506 switch (level)
507 {
508 case 11: p = "gpgsm (GnuPG)";
509 break;
510 case 13: p = VERSION; break;
511 case 17: p = PRINTABLE_OS_NAME; break;
512 case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
513
514 case 1:
515 case 40: p = _("Usage: gpgsm [options] [files] (-h for help)");
516 break;
517 case 41:
518 p = _("Syntax: gpgsm [options] [files]\n"
519 "sign, check, encrypt or decrypt using the S/MIME protocol\n"
520 "default operation depends on the input data\n");
521 break;
522
523 case 20:
524 if (!ver_gcry)
525 ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
526 p = ver_gcry;
527 break;
528 case 21:
529 if (!ver_ksba)
530 ver_ksba = make_libversion ("libksba", ksba_check_version);
531 p = ver_ksba;
532 break;
533
534 case 31: p = "\nHome: "; break;
535 case 32: p = opt.homedir; break;
536 case 33: p = _("\nSupported algorithms:\n"); break;
537 case 34:
538 if (!ciphers)
539 ciphers = build_list ("Cipher: ", gcry_cipher_algo_name,
540 our_cipher_test_algo );
541 p = ciphers;
542 break;
543 case 35:
544 if (!pubkeys)
545 pubkeys = build_list ("Pubkey: ", gcry_pk_algo_name,
546 our_pk_test_algo );
547 p = pubkeys;
548 break;
549 case 36:
550 if (!digests)
551 digests = build_list("Hash: ", gcry_md_algo_name, our_md_test_algo );
552 p = digests;
553 break;
554
555 default: p = NULL; break;
556 }
557 return p;
558 }
559
560
561 static char *
562 build_list (const char *text, const char * (*mapf)(int), int (*chkf)(int))
563 {
564 int i;
565 size_t n=strlen(text)+2;
566 char *list, *p;
567
568 if (maybe_setuid) {
569 gcry_control (GCRYCTL_DROP_PRIVS); /* drop setuid */
570 }
571
572 for (i=1; i < 400; i++ )
573 if (!chkf(i))
574 n += strlen(mapf(i)) + 2;
575 list = xmalloc (21 + n);
576 *list = 0;
577 for (p=NULL, i=1; i < 400; i++)
578 {
579 if (!chkf(i))
580 {
581 if( !p )
582 p = stpcpy (list, text );
583 else
584 p = stpcpy (p, ", ");
585 p = stpcpy (p, mapf(i) );
586 }
587 }
588 if (p)
589 p = stpcpy(p, "\n" );
590 return list;
591 }
592
593
594 /* Set the file pointer into binary mode if required. */
595 static void
596 set_binary (FILE *fp)
597 {
598 #ifdef HAVE_DOSISH_SYSTEM
599 setmode (fileno (fp), O_BINARY);
600 #else
601 (void)fp;
602 #endif
603 }
604
605
606
607 static void
608 wrong_args (const char *text)
609 {
610 fputs (_("usage: gpgsm [options] "), stderr);
611 fputs (text, stderr);
612 putc ('\n', stderr);
613 gpgsm_exit (2);
614 }
615
616
617 static void
618 set_opt_session_env (const char *name, const char *value)
619 {
620 gpg_error_t err;
621
622 err = session_env_setenv (opt.session_env, name, value);
623 if (err)
624 log_fatal ("error setting session environment: %s\n",
625 gpg_strerror (err));
626 }
627
628
629 /* Setup the debugging. With a DEBUG_LEVEL of NULL only the active
630 debug flags are propagated to the subsystems. With DEBUG_LEVEL
631 set, a specific set of debug flags is set; and individual debugging
632 flags will be added on top. */
633 static void
634 set_debug (void)
635 {
636 if (!debug_level)
637 ;
638 else if (!strcmp (debug_level, "none"))
639 opt.debug = 0;
640 else if (!strcmp (debug_level, "basic"))
641 opt.debug = DBG_ASSUAN_VALUE;
642 else if (!strcmp (debug_level, "advanced"))
643 opt.debug = DBG_ASSUAN_VALUE|DBG_X509_VALUE;
644 else if (!strcmp (debug_level, "expert"))
645 opt.debug = (DBG_ASSUAN_VALUE|DBG_X509_VALUE
646 |DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
647 else if (!strcmp (debug_level, "guru"))
648 opt.debug = ~0;
649 else
650 {
651 log_error (_("invalid debug-level `%s' given\n"), debug_level);
652 gpgsm_exit(2);
653 }
654
655 opt.debug |= debug_value;
656
657 if (opt.debug && !opt.verbose)
658 opt.verbose = 1;
659 if (opt.debug)
660 opt.quiet = 0;
661
662 if (opt.debug & DBG_MPI_VALUE)
663 gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
664 if (opt.debug & DBG_CRYPTO_VALUE )
665 gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
666 gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
667 }
668
669
670
671 static void
672 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
673 {
674 enum cmd_and_opt_values cmd = *ret_cmd;
675
676 if (!cmd || cmd == new_cmd)
677 cmd = new_cmd;
678 else if ( cmd == aSign && new_cmd == aEncr )
679 cmd = aSignEncr;
680 else if ( cmd == aEncr && new_cmd == aSign )
681 cmd = aSignEncr;
682 else if ( (cmd == aSign && new_cmd == aClearsign)
683 || (cmd == aClearsign && new_cmd == aSign) )
684 cmd = aClearsign;
685 else
686 {
687 log_error(_("conflicting commands\n"));
688 gpgsm_exit(2);
689 }
690
691 *ret_cmd = cmd;
692 }
693
694
695 /* Helper to add recipients to a list. */
696 static void
697 do_add_recipient (ctrl_t ctrl, const char *name,
698 certlist_t *recplist, int is_encrypt_to, int recp_required)
699 {
700 int rc = gpgsm_add_to_certlist (ctrl, name, 0, recplist, is_encrypt_to);
701 if (rc)
702 {
703 if (recp_required)
704 {
705 log_error ("can't encrypt to `%s': %s\n", name, gpg_strerror (rc));
706 gpgsm_status2 (ctrl, STATUS_INV_RECP,
707 gpg_err_code (rc) == -1? "1":
708 gpg_err_code (rc) == GPG_ERR_NO_PUBKEY? "1":
709 gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME? "2":
710 gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE? "3":
711 gpg_err_code (rc) == GPG_ERR_CERT_REVOKED? "4":
712 gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED? "5":
713 gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN? "6":
714 gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD? "7":
715 gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH? "8":
716 "0",
717 name, NULL);
718 }
719 else
720 log_info (_("NOTE: won't be able to encrypt to `%s': %s\n"),
721 name, gpg_strerror (rc));
722 }
723 }
724
725
726 static void
727 parse_validation_model (const char *model)
728 {
729 int i = gpgsm_parse_validation_model (model);
730 if (i == -1)
731 log_error (_("unknown validation model `%s'\n"), model);
732 else
733 default_validation_model = i;
734 }
735
736
737 /* Release the list of SERVERS. As usual it is okay to call this
738 function with SERVERS passed as NULL. */
739 void
740 keyserver_list_free (struct keyserver_spec *servers)
741 {
742 while (servers)
743 {
744 struct keyserver_spec *tmp = servers->next;
745 xfree (servers->host);
746 xfree (servers->user);
747 if (servers->pass)
748 memset (servers->pass, 0, strlen (servers->pass));
749 xfree (servers->pass);
750 xfree (servers->base);
751 xfree (servers);
752 servers = tmp;
753 }
754 }
755
756 /* See also dirmngr ldapserver_parse_one(). */
757 struct keyserver_spec *
758 parse_keyserver_line (char *line,
759 const char *filename, unsigned int lineno)
760 {
761 char *p;
762 char *endp;
763 struct keyserver_spec *server;
764 int fieldno;
765 int fail = 0;
766
767 /* Parse the colon separated fields. */
768 server = xcalloc (1, sizeof *server);
769 for (fieldno = 1, p = line; p; p = endp, fieldno++ )
770 {
771 endp = strchr (p, ':');
772 if (endp)
773 *endp++ = '\0';
774 trim_spaces (p);
775 switch (fieldno)
776 {
777 case 1:
778 if (*p)
779 server->host = xstrdup (p);
780 else
781 {
782 log_error (_("%s:%u: no hostname given\n"),
783 filename, lineno);
784 fail = 1;
785 }
786 break;
787
788 case 2:
789 if (*p)
790 server->port = atoi (p);
791 break;
792
793 case 3:
794 if (*p)
795 server->user = xstrdup (p);
796 break;
797
798 case 4:
799 if (*p && !server->user)
800 {
801 log_error (_("%s:%u: password given without user\n"),
802 filename, lineno);
803 fail = 1;
804 }
805 else if (*p)
806 server->pass = xstrdup (p);
807 break;
808
809 case 5:
810 if (*p)
811 server->base = xstrdup (p);
812 break;
813
814 default:
815 /* (We silently ignore extra fields.) */
816 break;
817 }
818 }
819
820 if (fail)
821 {
822 log_info (_("%s:%u: skipping this line\n"), filename, lineno);
823 keyserver_list_free (server);
824 }
825
826 return server;
827 }
828
829
830 int
831 main ( int argc, char **argv)
832 {
833 ARGPARSE_ARGS pargs;
834 int orig_argc;
835 char **orig_argv;
836 const char *fname;
837 /* char *username;*/
838 int may_coredump;
839 strlist_t sl, remusr= NULL, locusr=NULL;
840 strlist_t nrings=NULL;
841 int detached_sig = 0;
842 FILE *configfp = NULL;
843 char *configname = NULL;
844 unsigned configlineno;
845 int parse_debug = 0;
846 int no_more_options = 0;
847 int default_config =1;
848 int default_keyring = 1;
849 char *logfile = NULL;
850 char *auditlog = NULL;
851 int greeting = 0;
852 int nogreeting = 0;
853 int debug_wait = 0;
854 int use_random_seed = 1;
855 int no_common_certs_import = 0;
856 int with_fpr = 0;
857 const char *forced_digest_algo = NULL;
858 const char *extra_digest_algo = NULL;
859 enum cmd_and_opt_values cmd = 0;
860 struct server_control_s ctrl;
861 certlist_t recplist = NULL;
862 certlist_t signerlist = NULL;
863 int do_not_setup_keys = 0;
864 int recp_required = 0;
865 estream_t auditfp = NULL;
866
867 /*mtrace();*/
868
869 gnupg_reopen_std ("gpgsm");
870 /* trap_unaligned ();*/
871 gnupg_rl_initialize ();
872 set_strusage (my_strusage);
873 gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
874 /* We don't need any locking in libgcrypt unless we use any kind of
875 threading. */
876 gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
877
878 /* Please note that we may running SUID(ROOT), so be very CAREFUL
879 when adding any stuff between here and the call to secmem_init()
880 somewhere after the option parsing */
881 log_set_prefix ("gpgsm", 1);
882
883 /* Make sure that our subsystems are ready. */
884 i18n_init();
885 init_common_subsystems ();
886
887 /* Check that the libraries are suitable. Do it here because the
888 option parse may need services of the library */
889 if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
890 log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
891 NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
892 if (!ksba_check_version (NEED_KSBA_VERSION) )
893 log_fatal (_("%s is too old (need %s, have %s)\n"), "libksba",
894 NEED_KSBA_VERSION, ksba_check_version (NULL) );
895
896
897 gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
898
899 may_coredump = disable_core_dumps ();
900
901 gnupg_init_signals (0, emergency_cleanup);
902
903 create_dotlock (NULL); /* register locking cleanup */
904
905 opt.session_env = session_env_new ();
906 if (!opt.session_env)
907 log_fatal ("error allocating session environment block: %s\n",
908 strerror (errno));
909
910 /* Note: If you change this default cipher algorithm , please
911 remember to update the Gpgconflist entry as well. */
912 opt.def_cipher_algoid = "3DES"; /*des-EDE3-CBC*/
913
914 opt.homedir = default_homedir ();
915
916 /* First check whether we have a config file on the commandline */
917 orig_argc = argc;
918 orig_argv = argv;
919 pargs.argc = &argc;
920 pargs.argv = &argv;
921 pargs.flags= 1|(1<<6); /* do not remove the args, ignore version */
922 while (arg_parse( &pargs, opts))
923 {
924 if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
925 parse_debug++;
926 else if (pargs.r_opt == oOptions)
927 { /* yes there is one, so we do not try the default one but
928 read the config file when it is encountered at the
929 commandline */
930 default_config = 0;
931 }
932 else if (pargs.r_opt == oNoOptions)
933 default_config = 0; /* --no-options */
934 else if (pargs.r_opt == oHomedir)
935 opt.homedir = pargs.r.ret_str;
936 else if (pargs.r_opt == aCallProtectTool)
937 break; /* This break makes sure that --version and --help are
938 passed to the protect-tool. */
939 }
940
941
942 /* Initialize the secure memory. */
943 gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
944 maybe_setuid = 0;
945
946 /*
947 Now we are now working under our real uid
948 */
949
950 ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
951
952 assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
953 assuan_set_assuan_log_stream (log_get_stream ());
954 assuan_set_assuan_log_prefix (log_get_prefix (NULL));
955 assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
956
957 keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
958
959 /* Setup a default control structure for command line mode */
960 memset (&ctrl, 0, sizeof ctrl);
961 gpgsm_init_default_ctrl (&ctrl);
962 ctrl.no_server = 1;
963 ctrl.status_fd = -1; /* No status output. */
964 ctrl.autodetect_encoding = 1;
965
966 /* Set the default option file */
967 if (default_config )
968 configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
969 /* Set the default policy file */
970 opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
971
972 argc = orig_argc;
973 argv = orig_argv;
974 pargs.argc = &argc;
975 pargs.argv = &argv;
976 pargs.flags = 1; /* do not remove the args */
977
978 next_pass:
979 if (configname) {
980 configlineno = 0;
981 configfp = fopen (configname, "r");
982 if (!configfp)
983 {
984 if (default_config)
985 {
986 if (parse_debug)
987 log_info (_("NOTE: no default option file `%s'\n"), configname);
988 }
989 else
990 {
991 log_error (_("option file `%s': %s\n"), configname, strerror(errno));
992 gpgsm_exit(2);
993 }
994 xfree(configname);
995 configname = NULL;
996 }
997 if (parse_debug && configname)
998 log_info (_("reading options from `%s'\n"), configname);
999 default_config = 0;
1000 }
1001
1002 while (!no_more_options
1003 && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
1004 {
1005 switch (pargs.r_opt)
1006 {
1007 case aGPGConfList:
1008 case aGPGConfTest:
1009 set_cmd (&cmd, pargs.r_opt);
1010 do_not_setup_keys = 1;
1011 nogreeting = 1;
1012 break;
1013
1014 case aServer:
1015 opt.batch = 1;
1016 set_cmd (&cmd, aServer);
1017 break;
1018
1019 case aCallDirmngr:
1020 opt.batch = 1;
1021 set_cmd (&cmd, aCallDirmngr);
1022 do_not_setup_keys = 1;
1023 break;
1024
1025 case aCallProtectTool:
1026 opt.batch = 1;
1027 set_cmd (&cmd, aCallProtectTool);
1028 no_more_options = 1; /* Stop parsing. */
1029 do_not_setup_keys = 1;
1030 break;
1031
1032 case aDeleteKey:
1033 set_cmd (&cmd, aDeleteKey);
1034 /*greeting=1;*/
1035 do_not_setup_keys = 1;
1036 break;
1037
1038 case aDetachedSign:
1039 detached_sig = 1;
1040 set_cmd (&cmd, aSign );
1041 break;
1042
1043 case aKeygen:
1044 set_cmd (&cmd, aKeygen);
1045 greeting=1;
1046 do_not_setup_keys = 1;
1047 break;
1048
1049 case aImport:
1050 case aSendKeys:
1051 case aRecvKeys:
1052 case aExport:
1053 case aExportSecretKeyP12:
1054 case aDumpKeys:
1055 case aDumpChain:
1056 case aDumpExternalKeys:
1057 case aDumpSecretKeys:
1058 case aListKeys:
1059 case aListExternalKeys:
1060 case aListSecretKeys:
1061 case aListChain:
1062 case aLearnCard:
1063 case aPasswd:
1064 case aKeydbClearSomeCertFlags:
1065 do_not_setup_keys = 1;
1066 set_cmd (&cmd, pargs.r_opt);
1067 break;
1068
1069 case aEncr:
1070 recp_required = 1;
1071 set_cmd (&cmd, pargs.r_opt);
1072 break;
1073
1074 case aSym:
1075 case aDecrypt:
1076 case aSign:
1077 case aClearsign:
1078 case aVerify:
1079 set_cmd (&cmd, pargs.r_opt);
1080 break;
1081
1082 /* Output encoding selection. */
1083 case oArmor:
1084 ctrl.create_pem = 1;
1085 break;
1086 case oBase64:
1087 ctrl.create_pem = 0;
1088 ctrl.create_base64 = 1;
1089 break;
1090 case oNoArmor:
1091 ctrl.create_pem = 0;
1092 ctrl.create_base64 = 0;
1093 break;
1094
1095 case oP12Charset:
1096 opt.p12_charset = pargs.r.ret_str;
1097 break;
1098
1099 /* Input encoding selection. */
1100 case oAssumeArmor:
1101 ctrl.autodetect_encoding = 0;
1102 ctrl.is_pem = 1;
1103 ctrl.is_base64 = 0;
1104 break;
1105 case oAssumeBase64:
1106 ctrl.autodetect_encoding = 0;
1107 ctrl.is_pem = 0;
1108 ctrl.is_base64 = 1;
1109 break;
1110 case oAssumeBinary:
1111 ctrl.autodetect_encoding = 0;
1112 ctrl.is_pem = 0;
1113 ctrl.is_base64 = 0;
1114 break;
1115
1116 case oDisableCRLChecks:
1117 opt.no_crl_check = 1;
1118 break;
1119 case oEnableCRLChecks:
1120 opt.no_crl_check = 0;
1121 break;
1122 case oDisableTrustedCertCRLCheck:
1123 opt.no_trusted_cert_crl_check = 1;
1124 break;
1125 case oEnableTrustedCertCRLCheck:
1126 opt.no_trusted_cert_crl_check = 0;
1127 break;
1128 case oForceCRLRefresh:
1129 opt.force_crl_refresh = 1;
1130 break;
1131
1132 case oDisableOCSP:
1133 ctrl.use_ocsp = opt.enable_ocsp = 0;
1134 break;
1135 case oEnableOCSP:
1136 ctrl.use_ocsp = opt.enable_ocsp = 1;
1137 break;
1138
1139 case oIncludeCerts:
1140 ctrl.include_certs = default_include_certs = pargs.r.ret_int;
1141 break;
1142
1143 case oPolicyFile:
1144 xfree (opt.policy_file);
1145 if (*pargs.r.ret_str)
1146 opt.policy_file = xstrdup (pargs.r.ret_str);
1147 else
1148 opt.policy_file = NULL;
1149 break;
1150
1151 case oDisablePolicyChecks:
1152 opt.no_policy_check = 1;
1153 break;
1154 case oEnablePolicyChecks:
1155 opt.no_policy_check = 0;
1156 break;
1157
1158 case oAutoIssuerKeyRetrieve:
1159 opt.auto_issuer_key_retrieve = 1;
1160 break;
1161
1162 case oOutput: opt.outfile = pargs.r.ret_str; break;
1163
1164
1165 case oQuiet: opt.quiet = 1; break;
1166 case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
1167 case oDryRun: opt.dry_run = 1; break;
1168
1169 case oVerbose:
1170 opt.verbose++;
1171 gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1172 break;
1173 case oNoVerbose:
1174 opt.verbose = 0;
1175 gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1176 break;
1177
1178 case oLogFile: logfile = pargs.r.ret_str; break;
1179 case oNoLogFile: logfile = NULL; break;
1180
1181 case oAuditLog: auditlog = pargs.r.ret_str; break;
1182
1183 case oBatch:
1184 opt.batch = 1;
1185 greeting = 0;
1186 break;
1187 case oNoBatch: opt.batch = 0; break;
1188
1189 case oAnswerYes: opt.answer_yes = 1; break;
1190 case oAnswerNo: opt.answer_no = 1; break;
1191
1192 case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1193
1194 case oDebug: debug_value |= pargs.r.ret_ulong; break;
1195 case oDebugAll: debug_value = ~0; break;
1196 case oDebugNone: debug_value = 0; break;
1197 case oDebugLevel: debug_level = pargs.r.ret_str; break;
1198 case oDebugWait: debug_wait = pargs.r.ret_int; break;
1199 case oDebugAllowCoreDump:
1200 may_coredump = enable_core_dumps ();
1201 break;
1202 case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1203 case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1204 case oFixedPassphrase: opt.fixed_passphrase = pargs.r.ret_str; break;
1205
1206 case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1207 case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1208 case oWithMD5Fingerprint:
1209 opt.with_md5_fingerprint=1; /*fall thru*/
1210 case oWithFingerprint:
1211 with_fpr=1; /*fall thru*/
1212 case aFingerprint:
1213 opt.fingerprint++;
1214 break;
1215
1216 case oOptions:
1217 /* config files may not be nested (silently ignore them) */
1218 if (!configfp)
1219 {
1220 xfree(configname);
1221 configname = xstrdup (pargs.r.ret_str);
1222 goto next_pass;
1223 }
1224 break;
1225 case oNoOptions: break; /* no-options */
1226 case oHomedir: opt.homedir = pargs.r.ret_str; break;
1227 case oAgentProgram: opt.agent_program = pargs.r.ret_str; break;
1228
1229 case oDisplay:
1230 set_opt_session_env ("DISPLAY", pargs.r.ret_str);
1231 break;
1232 case oTTYname:
1233 set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
1234 break;
1235 case oTTYtype:
1236 set_opt_session_env ("TERM", pargs.r.ret_str);
1237 break;
1238 case oXauthority:
1239 set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
1240 break;
1241
1242 case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1243 case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1244
1245 case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
1246 case oDisableDirmngr: opt.disable_dirmngr = 1; break;
1247 case oPreferSystemDirmngr: opt.prefer_system_dirmngr = 1; break;
1248 case oProtectToolProgram:
1249 opt.protect_tool_program = pargs.r.ret_str;
1250 break;
1251
1252 case oFakedSystemTime:
1253 {
1254 time_t faked_time = isotime2epoch (pargs.r.ret_str);
1255 if (faked_time == (time_t)(-1))
1256 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
1257 gnupg_set_time (faked_time, 0);
1258 }
1259 break;
1260
1261 case oNoDefKeyring: default_keyring = 0; break;
1262 case oNoGreeting: nogreeting = 1; break;
1263
1264 case oDefaultKey:
1265 if (*pargs.r.ret_str)
1266 {
1267 xfree (opt.local_user);
1268 opt.local_user = xstrdup (pargs.r.ret_str);
1269 }
1270 break;
1271 case oDefRecipient:
1272 if (*pargs.r.ret_str)
1273 opt.def_recipient = xstrdup (pargs.r.ret_str);
1274 break;
1275 case oDefRecipientSelf:
1276 xfree (opt.def_recipient);
1277 opt.def_recipient = NULL;
1278 opt.def_recipient_self = 1;
1279 break;
1280 case oNoDefRecipient:
1281 xfree (opt.def_recipient);
1282 opt.def_recipient = NULL;
1283 opt.def_recipient_self = 0;
1284 break;
1285
1286 case oWithKeyData: opt.with_key_data=1; /* fall thru */
1287 case oWithColons: ctrl.with_colons = 1; break;
1288 case oWithValidation: ctrl.with_validation=1; break;
1289 case oWithEphemeralKeys: ctrl.with_ephemeral_keys=1; break;
1290
1291 case oSkipVerify: opt.skip_verify=1; break;
1292
1293 case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1294 case oEncryptTo: /* Store the recipient in the second list */
1295 sl = add_to_strlist (&remusr, pargs.r.ret_str);
1296 sl->flags = 1;
1297 break;
1298
1299 case oRecipient: /* store the recipient */
1300 add_to_strlist ( &remusr, pargs.r.ret_str);
1301 break;
1302
1303 case oUser: /* Store the local users, the first one is the default */
1304 if (!opt.local_user)
1305 opt.local_user = xstrdup (pargs.r.ret_str);
1306 add_to_strlist (&locusr, pargs.r.ret_str);
1307 break;
1308
1309 case oNoSecmemWarn:
1310 gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
1311 break;
1312
1313 case oCipherAlgo:
1314 opt.def_cipher_algoid = pargs.r.ret_str;
1315 break;
1316
1317 case oDisableCipherAlgo:
1318 {
1319 int algo = gcry_cipher_map_name (pargs.r.ret_str);
1320 gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1321 }
1322 break;
1323 case oDisablePubkeyAlgo:
1324 {
1325 int algo = gcry_pk_map_name (pargs.r.ret_str);
1326 gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1327 }
1328 break;
1329
1330 case oDigestAlgo:
1331 forced_digest_algo = pargs.r.ret_str;
1332 break;
1333
1334 case oExtraDigestAlgo:
1335 extra_digest_algo = pargs.r.ret_str;
1336 break;
1337
1338 case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1339 case oNoRandomSeedFile: use_random_seed = 0; break;
1340 case oNoCommonCertsImport: no_common_certs_import = 1; break;
1341
1342 case oEnableSpecialFilenames: allow_special_filenames =1; break;
1343
1344 case oValidationModel: parse_validation_model (pargs.r.ret_str); break;
1345
1346 case oKeyServer:
1347 {
1348 struct keyserver_spec *keyserver;
1349 keyserver = parse_keyserver_line (pargs.r.ret_str,
1350 configname, configlineno);
1351 if (! keyserver)
1352 log_error (_("could not parse keyserver\n"));
1353 else
1354 {
1355 /* FIXME: Keep last next pointer. */
1356 struct keyserver_spec **next_p = &opt.keyserver;
1357 while (*next_p)
1358 next_p = &(*next_p)->next;
1359 *next_p = keyserver;
1360 }
1361 }
1362 break;
1363
1364 default:
1365 pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
1366 break;
1367 }
1368 }
1369
1370 if (configfp)
1371 {
1372 fclose (configfp);
1373 configfp = NULL;
1374 /* Keep a copy of the config filename. */
1375 opt.config_filename = configname;
1376 configname = NULL;
1377 goto next_pass;
1378 }
1379 xfree (configname);
1380 configname = NULL;
1381
1382 if (!opt.config_filename)
1383 opt.config_filename = make_filename (opt.homedir, "gpgsm.conf", NULL);
1384
1385 if (log_get_errorcount(0))
1386 gpgsm_exit(2);
1387
1388 /* Now that we have the options parsed we need to update the default
1389 control structure. */
1390 gpgsm_init_default_ctrl (&ctrl);
1391
1392 if (nogreeting)
1393 greeting = 0;
1394
1395 if (greeting)
1396 {
1397 fprintf(stderr, "%s %s; %s\n",
1398 strusage(11), strusage(13), strusage(14) );
1399 fprintf(stderr, "%s\n", strusage(15) );
1400 }
1401 # ifdef IS_DEVELOPMENT_VERSION
1402 if (!opt.batch)
1403 {
1404 log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1405 log_info ("It is only intended for test purposes and should NOT be\n");
1406 log_info ("used in a production environment or with production keys!\n");
1407 }
1408 # endif
1409
1410 if (auditlog)
1411 log_info ("NOTE: The audit log feature (--audit-log) is "
1412 "WORK IN PRORESS and not ready for use!\n");
1413
1414
1415 if (may_coredump && !opt.quiet)
1416 log_info (_("WARNING: program may create a core file!\n"));
1417
1418 /* if (opt.qualsig_approval && !opt.quiet) */
1419 /* log_info (_("This software has offically been approved to " */
1420 /* "create and verify\n" */
1421 /* "qualified signatures according to German law.\n")); */
1422
1423 if (logfile && cmd == aServer)
1424 {
1425 log_set_file (logfile);
1426 log_set_prefix (NULL, 1|2|4);
1427 }
1428
1429 if (gnupg_faked_time_p ())
1430 {
1431 gnupg_isotime_t tbuf;
1432
1433 log_info (_("WARNING: running with faked system time: "));
1434 gnupg_get_isotime (tbuf);
1435 dump_isotime (tbuf);
1436 log_printf ("\n");
1437 }
1438
1439 /*FIXME if (opt.batch) */
1440 /* tty_batchmode (1); */
1441
1442 gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1443
1444 set_debug ();
1445
1446 /* Although we alwasy use gpgsm_exit, we better install a regualr
1447 exit handler so that at least the secure memory gets wiped
1448 out. */
1449 if (atexit (emergency_cleanup))
1450 {
1451 log_error ("atexit failed\n");
1452 gpgsm_exit (2);
1453 }
1454
1455 /* Must do this after dropping setuid, because the mapping functions
1456 may try to load an module and we may have disabled an algorithm.
1457 We remap the commonly used algorithms to the OIDs for
1458 convenience. We need to work with the OIDs because they are used
1459 to check whether the encryption mode is actually available. */
1460 if (!strcmp (opt.def_cipher_algoid, "3DES") )
1461 opt.def_cipher_algoid = "1.2.840.113549.3.7";
1462 else if (!strcmp (opt.def_cipher_algoid, "AES")
1463 || !strcmp (opt.def_cipher_algoid, "AES128"))
1464 opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.2";
1465 else if (!strcmp (opt.def_cipher_algoid, "AES256") )
1466 opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.42";
1467 else if (!strcmp (opt.def_cipher_algoid, "SERPENT")
1468 || !strcmp (opt.def_cipher_algoid, "SERPENT128") )
1469 opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.2";
1470 else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
1471 opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.22";
1472 else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
1473 opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.42";
1474 else if (!strcmp (opt.def_cipher_algoid, "SEED") )
1475 opt.def_cipher_algoid = "1.2.410.200004.1.4";
1476 else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA")
1477 || !strcmp (opt.def_cipher_algoid, "CAMELLIA128") )
1478 opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.2";
1479 else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA192") )
1480 opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.3";
1481 else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA256") )
1482 opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.4";
1483
1484 if (cmd != aGPGConfList)
1485 {
1486 if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1487 || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1488 log_error (_("selected cipher algorithm is invalid\n"));
1489
1490 if (forced_digest_algo)
1491 {
1492 opt.forced_digest_algo = gcry_md_map_name (forced_digest_algo);
1493 if (our_md_test_algo(opt.forced_digest_algo) )
1494 log_error (_("selected digest algorithm is invalid\n"));
1495 }
1496 if (extra_digest_algo)
1497 {
1498 opt.extra_digest_algo = gcry_md_map_name (extra_digest_algo);
1499 if (our_md_test_algo (opt.extra_digest_algo) )
1500 log_error (_("selected digest algorithm is invalid\n"));
1501 }
1502 }
1503
1504 if (log_get_errorcount(0))
1505 gpgsm_exit(2);
1506
1507 /* Set the random seed file. */
1508 if (use_random_seed)
1509 {
1510 char *p = make_filename (opt.homedir, "random_seed", NULL);
1511 gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1512 xfree(p);
1513 }
1514
1515 if (!cmd && opt.fingerprint && !with_fpr)
1516 set_cmd (&cmd, aListKeys);
1517
1518 /* Add default keybox. */
1519 if (!nrings && default_keyring)
1520 {
1521 int created;
1522
1523 keydb_add_resource ("pubring.kbx", 0, 0, &created);
1524 if (created && !no_common_certs_import)
1525 {
1526 /* Import the standard certificates for a new default keybox. */
1527 char *filelist[2];
1528
1529 filelist[0] = make_filename (gnupg_datadir (),"com-certs.pem", NULL);
1530 filelist[1] = NULL;
1531 if (!access (filelist[0], F_OK))
1532 {
1533 log_info (_("importing common certificates `%s'\n"),
1534 filelist[0]);
1535 gpgsm_import_files (&ctrl, 1, filelist, open_read);
1536 }
1537 xfree (filelist[0]);
1538 }
1539 }
1540 for (sl = nrings; sl; sl = sl->next)
1541 keydb_add_resource (sl->d, 0, 0, NULL);
1542 FREE_STRLIST(nrings);
1543
1544
1545 /* Prepare the audit log feature for certain commands. */
1546 if (auditlog)
1547 {
1548 switch (cmd)
1549 {
1550 case aEncr:
1551 case aSign:
1552 case aDecrypt:
1553 case aVerify:
1554 audit_release (ctrl.audit);
1555 ctrl.audit = audit_new ();
1556 auditfp = open_es_fwrite (auditlog);
1557 break;
1558 default:
1559 break;
1560 }
1561 }
1562
1563
1564 if (!do_not_setup_keys)
1565 {
1566 for (sl = locusr; sl ; sl = sl->next)
1567 {
1568 int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1569 if (rc)
1570 {
1571 log_error (_("can't sign using `%s': %s\n"),
1572 sl->d, gpg_strerror (rc));
1573 gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1574 gpg_err_code (rc) == -1? "1":
1575 gpg_err_code (rc) == GPG_ERR_NO_PUBKEY? "1":
1576 gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME? "2":
1577 gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE? "3":
1578 gpg_err_code (rc) == GPG_ERR_CERT_REVOKED? "4":
1579 gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED? "5":
1580 gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN? "6":
1581 gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD? "7":
1582 gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH? "8":
1583 gpg_err_code (rc) == GPG_ERR_NO_SECKEY? "9":
1584 "0",
1585 sl->d, NULL);
1586 }
1587 }
1588
1589 /* Build the recipient list. We first add the regular ones and then
1590 the encrypt-to ones because the underlying function will silently
1591 ignore duplicates and we can't allow to keep a duplicate which is
1592 flagged as encrypt-to as the actually encrypt function would then
1593 complain about no (regular) recipients. */
1594 for (sl = remusr; sl; sl = sl->next)
1595 if (!(sl->flags & 1))
1596 do_add_recipient (&ctrl, sl->d, &recplist, 0, recp_required);
1597 if (!opt.no_encrypt_to)
1598 {
1599 for (sl = remusr; sl; sl = sl->next)
1600 if ((sl->flags & 1))
1601 do_add_recipient (&ctrl, sl->d, &recplist, 1, recp_required);
1602 }
1603 }
1604
1605 if (log_get_errorcount(0))
1606 gpgsm_exit(1); /* Must stop for invalid recipients. */
1607
1608 fname = argc? *argv : NULL;
1609
1610 /* Dispatch command. */
1611 switch (cmd)
1612 {
1613 case aGPGConfList:
1614 { /* List options and default values in the GPG Conf format. */
1615 char *config_filename_esc = percent_escape (opt.config_filename, NULL);
1616
1617 printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
1618 GC_OPT_FLAG_DEFAULT, config_filename_esc);
1619 xfree (config_filename_esc);
1620
1621 printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1622 printf ("quiet:%lu:\n", GC_OPT_FLAG_NONE);
1623 printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
1624 printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
1625 printf ("disable-crl-checks:%lu:\n", GC_OPT_FLAG_NONE);
1626 printf ("disable-trusted-cert-crl-check:%lu:\n", GC_OPT_FLAG_NONE);
1627 printf ("enable-ocsp:%lu:\n", GC_OPT_FLAG_NONE);
1628 printf ("include-certs:%lu:1:\n", GC_OPT_FLAG_DEFAULT);
1629 printf ("disable-policy-checks:%lu:\n", GC_OPT_FLAG_NONE);
1630 printf ("auto-issuer-key-retrieve:%lu:\n", GC_OPT_FLAG_NONE);
1631 printf ("disable-dirmngr:%lu:\n", GC_OPT_FLAG_NONE);
1632 #ifndef HAVE_W32_SYSTEM
1633 printf ("prefer-system-dirmngr:%lu:\n", GC_OPT_FLAG_NONE);
1634 #endif
1635 printf ("cipher-algo:%lu:\"3DES:\n", GC_OPT_FLAG_DEFAULT);
1636 printf ("p12-charset:%lu:\n", GC_OPT_FLAG_DEFAULT);
1637 printf ("default-key:%lu:\n", GC_OPT_FLAG_DEFAULT);
1638 printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_DEFAULT);
1639 printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1640
1641 }
1642 break;
1643 case aGPGConfTest:
1644 /* This is merely a dummy command to test whether the
1645 configuration file is valid. */
1646 break;
1647
1648 case aServer:
1649 if (debug_wait)
1650 {
1651 log_debug ("waiting for debugger - my pid is %u .....\n",
1652 (unsigned int)getpid());
1653 gnupg_sleep (debug_wait);
1654 log_debug ("... okay\n");
1655 }
1656 gpgsm_server (recplist);
1657 break;
1658
1659 case aCallDirmngr:
1660 if (!argc)
1661 wrong_args ("--call-dirmngr <command> {args}");
1662 else
1663 if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1664 gpgsm_exit (1);
1665 break;
1666
1667 case aCallProtectTool:
1668 run_protect_tool (argc, argv);
1669 break;
1670
1671 case aEncr: /* Encrypt the given file. */
1672 {
1673 FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1674
1675 set_binary (stdin);
1676
1677 if (!argc) /* Source is stdin. */
1678 gpgsm_encrypt (&ctrl, recplist, 0, fp);
1679 else if (argc == 1) /* Source is the given file. */
1680 gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
1681 else
1682 wrong_args ("--encrypt [datafile]");
1683
1684 if (fp != stdout)
1685 fclose (fp);
1686 }
1687 break;
1688
1689 case aSign: /* Sign the given file. */
1690 {
1691 FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1692
1693 /* Fixme: We should also allow to concatenate multiple files for
1694 signing because that is what gpg does.*/
1695 set_binary (stdin);
1696 if (!argc) /* Create from stdin. */
1697 gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp);
1698 else if (argc == 1) /* From file. */
1699 gpgsm_sign (&ctrl, signerlist,
1700 open_read (*argv), detached_sig, fp);
1701 else
1702 wrong_args ("--sign [datafile]");
1703
1704 if (fp != stdout)
1705 fclose (fp);
1706 }
1707 break;
1708
1709 case aSignEncr: /* sign and encrypt the given file */
1710 log_error ("this command has not yet been implemented\n");
1711 break;
1712
1713 case aClearsign: /* make a clearsig */
1714 log_error ("this command has not yet been implemented\n");
1715 break;
1716
1717 case aVerify:
1718 {
1719 FILE *fp = NULL;
1720
1721 set_binary (stdin);
1722 if (argc == 2 && opt.outfile)
1723 log_info ("option --output ignored for a detached signature\n");
1724 else if (opt.outfile)
1725 fp = open_fwrite (opt.outfile);
1726
1727 if (!argc)
1728 gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1729 else if (argc == 1)
1730 gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1731 else if (argc == 2) /* detached signature (sig, detached) */
1732 gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL);
1733 else
1734 wrong_args ("--verify [signature [detached_data]]");
1735
1736 if (fp && fp != stdout)
1737 fclose (fp);
1738 }
1739 break;
1740
1741 case aDecrypt:
1742 {
1743 FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1744
1745 set_binary (stdin);
1746 if (!argc)
1747 gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
1748 else if (argc == 1)
1749 gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
1750 else
1751 wrong_args ("--decrypt [filename]");
1752 if (fp != stdout)
1753 fclose (fp);
1754 }
1755 break;
1756
1757 case aDeleteKey:
1758 for (sl=NULL; argc; argc--, argv++)
1759 add_to_strlist (&sl, *argv);
1760 gpgsm_delete (&ctrl, sl);
1761 free_strlist(sl);
1762 break;
1763
1764 case aListChain:
1765 case aDumpChain:
1766 ctrl.with_chain = 1;
1767 case aListKeys:
1768 case aDumpKeys:
1769 case aListExternalKeys:
1770 case aDumpExternalKeys:
1771 case aListSecretKeys:
1772 case aDumpSecretKeys:
1773 {
1774 unsigned int mode;
1775 estream_t fp;
1776
1777 switch (cmd)
1778 {
1779 case aListChain:
1780 case aListKeys: mode = (0 | 0 | (1<<6)); break;
1781 case aDumpChain:
1782 case aDumpKeys: mode = (256 | 0 | (1<<6)); break;
1783 case aListExternalKeys: mode = (0 | 0 | (1<<7)); break;
1784 case aDumpExternalKeys: mode = (256 | 0 | (1<<7)); break;
1785 case aListSecretKeys: mode = (0 | 2 | (1<<6)); break;
1786 case aDumpSecretKeys: mode = (256 | 2 | (1<<6)); break;
1787 default: BUG();
1788 }
1789
1790 fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1791 for (sl=NULL; argc; argc--, argv++)
1792 add_to_strlist (&sl, *argv);
1793 gpgsm_list_keys (&ctrl, sl, fp, mode);
1794 free_strlist(sl);
1795 es_fclose (fp);
1796 }
1797 break;
1798
1799
1800 case aKeygen: /* Generate a key; well kind of. */
1801 {
1802 estream_t fpin = NULL;
1803 FILE *fpout;
1804
1805 if (opt.batch)
1806 {
1807 if (!argc) /* Create from stdin. */
1808 fpin = open_es_fread ("-");
1809 else if (argc == 1) /* From file. */
1810 fpin = open_es_fread (*argv);
1811 else
1812 wrong_args ("--gen-key --batch [parmfile]");
1813 }
1814
1815 fpout = open_fwrite (opt.outfile?opt.outfile:"-");
1816
1817 if (fpin)
1818 gpgsm_genkey (&ctrl, fpin, fpout);
1819 else
1820 gpgsm_gencertreq_tty (&ctrl, fpout);
1821
1822 if (fpout != stdout)
1823 fclose (fpout);
1824 }
1825 break;
1826
1827
1828 case aImport:
1829 gpgsm_import_files (&ctrl, argc, argv, open_read);
1830 break;
1831
1832 case aExport:
1833 {
1834 FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1835
1836 for (sl=NULL; argc; argc--, argv++)
1837 add_to_strlist (&sl, *argv);
1838 gpgsm_export (&ctrl, sl, fp, NULL);
1839 free_strlist(sl);
1840 if (fp != stdout)
1841 fclose (fp);
1842 }
1843 break;
1844
1845 case aExportSecretKeyP12:
1846 {
1847 FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1848
1849 if (argc == 1)
1850 gpgsm_p12_export (&ctrl, *argv, fp);
1851 else
1852 wrong_args ("--export-secret-key-p12 KEY-ID");
1853 if (fp != stdout)
1854 fclose (fp);
1855 }
1856 break;
1857
1858 case aSendKeys:
1859 case aRecvKeys:
1860 log_error ("this command has not yet been implemented\n");
1861 break;
1862
1863
1864 case aLearnCard:
1865 if (argc)
1866 wrong_args ("--learn-card");
1867 else
1868 {
1869 int rc = gpgsm_agent_learn (&ctrl);
1870 if (rc)
1871 log_error ("error learning card: %s\n", gpg_strerror (rc));
1872 }
1873 break;
1874
1875 case aPasswd:
1876 if (argc != 1)
1877 wrong_args ("--passwd <key-Id>");
1878 else
1879 {
1880 int rc;
1881 ksba_cert_t cert = NULL;
1882 char *grip = NULL;
1883
1884 rc = gpgsm_find_cert (*argv, NULL, &cert);
1885 if (rc)
1886 ;
1887 else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1888 rc = gpg_error (GPG_ERR_BUG);
1889 else
1890 {
1891 char *desc = gpgsm_format_keydesc (cert);
1892 rc = gpgsm_agent_passwd (&ctrl, grip, desc);
1893 xfree (desc);
1894 }
1895 if (rc)
1896 log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1897 xfree (grip);
1898 ksba_cert_release (cert);
1899 }
1900 break;
1901
1902 case aKeydbClearSomeCertFlags:
1903 for (sl=NULL; argc; argc--, argv++)
1904 add_to_strlist (&sl, *argv);
1905 keydb_clear_some_cert_flags (&ctrl, sl);
1906 free_strlist(sl);
1907 break;
1908
1909
1910 default:
1911 log_error (_("invalid command (there is no implicit command)\n"));
1912 break;
1913 }
1914
1915 /* Print the audit result if needed. */
1916 if (auditlog && auditfp)
1917 {
1918 audit_print_result (ctrl.audit, auditfp, 0);
1919 audit_release (ctrl.audit);
1920 ctrl.audit = NULL;
1921 es_fclose (auditfp);
1922 }
1923
1924 /* cleanup */
1925 keyserver_list_free (opt.keyserver);
1926 opt.keyserver = NULL;
1927 gpgsm_release_certlist (recplist);
1928 gpgsm_release_certlist (signerlist);
1929 FREE_STRLIST (remusr);
1930 FREE_STRLIST (locusr);
1931 gpgsm_exit(0);
1932 return 8; /*NOTREACHED*/
1933 }
1934
1935 /* Note: This function is used by signal handlers!. */
1936 static void
1937 emergency_cleanup (void)
1938 {
1939 gcry_control (GCRYCTL_TERM_SECMEM );
1940 }
1941
1942
1943 void
1944 gpgsm_exit (int rc)
1945 {
1946 gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1947 if (opt.debug & DBG_MEMSTAT_VALUE)
1948 {
1949 gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1950 gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1951 }
1952 if (opt.debug)
1953 gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1954 emergency_cleanup ();
1955 rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1956 exit (rc);
1957 }
1958
1959
1960 void
1961 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1962 {
1963 ctrl->include_certs = default_include_certs;
1964 ctrl->use_ocsp = opt.enable_ocsp;
1965 ctrl->validation_model = default_validation_model;
1966 }
1967
1968
1969 int
1970 gpgsm_parse_validation_model (const char *model)
1971 {
1972 if (!ascii_strcasecmp (model, "shell") )
1973 return 0;
1974 else if ( !ascii_strcasecmp (model, "chain") )
1975 return 1;
1976 else
1977 return -1;
1978 }
1979
1980
1981 /* Check whether the filename has the form "-&nnnn", where n is a
1982 non-zero number. Returns this number or -1 if it is not the case. */
1983 static int
1984 check_special_filename (const char *fname, int for_write)
1985 {
1986 if (allow_special_filenames
1987 && fname && *fname == '-' && fname[1] == '&' ) {
1988 int i;
1989
1990 fname += 2;
1991 for (i=0; isdigit (fname[i]); i++ )
1992 ;
1993 if ( !fname[i] )
1994 return translate_sys2libc_fd_int (atoi (fname), for_write);
1995 }
1996 return -1;
1997 }
1998
1999
2000
2001 /* Open the FILENAME for read and return the filedescriptor. Stop
2002 with an error message in case of problems. "-" denotes stdin and
2003 if special filenames are allowed the given fd is opened instead. */
2004 static int
2005 open_read (const char *filename)
2006 {
2007 int fd;
2008
2009 if (filename[0] == '-' && !filename[1])
2010 {
2011 set_binary (stdin);
2012 return 0; /* stdin */
2013 }
2014 fd = check_special_filename (filename, 0);
2015 if (fd != -1)
2016 return fd;
2017 fd = open (filename, O_RDONLY | O_BINARY);
2018 if (fd == -1)
2019 {
2020 log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2021 gpgsm_exit (2);
2022 }
2023 return fd;
2024 }
2025
2026 /* Same as open_read but return an estream_t. */
2027 static estream_t
2028 open_es_fread (const char *filename)
2029 {
2030 int fd;
2031 estream_t fp;
2032
2033 if (filename[0] == '-' && !filename[1])
2034 fd = fileno (stdin);
2035 else
2036 fd = check_special_filename (filename, 0);
2037 if (fd != -1)
2038 {
2039 fp = es_fdopen_nc (fd, "rb");
2040 if (!fp)
2041 {
2042 log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
2043 gpgsm_exit (2);
2044 }
2045 return fp;
2046 }
2047 fp = es_fopen (filename, "rb");
2048 if (!fp)
2049 {
2050 log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2051 gpgsm_exit (2);
2052 }
2053 return fp;
2054 }
2055
2056
2057 /* Open FILENAME for fwrite and return the stream. Stop with an error
2058 message in case of problems. "-" denotes stdout and if special
2059 filenames are allowed the given fd is opened instead. Caller must
2060 close the returned stream unless it is stdout. */
2061 static FILE *
2062 open_fwrite (const char *filename)
2063 {
2064 int fd;
2065 FILE *fp;
2066
2067 if (filename[0] == '-' && !filename[1])
2068 {
2069 set_binary (stdout);
2070 return stdout;
2071 }
2072
2073 fd = check_special_filename (filename, 1);
2074 if (fd != -1)
2075 {
2076 fp = fdopen (dup (fd), "wb");
2077 if (!fp)
2078 {
2079 log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
2080 gpgsm_exit (2);
2081 }
2082 set_binary (fp);
2083 return fp;
2084 }
2085 fp = fopen (filename, "wb");
2086 if (!fp)
2087 {
2088 log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2089 gpgsm_exit (2);
2090 }
2091 return fp;
2092 }
2093
2094
2095 /* Open FILENAME for fwrite and return an extended stream. Stop with
2096 an error message in case of problems. "-" denotes stdout and if
2097 special filenames are allowed the given fd is opened instead.
2098 Caller must close the returned stream. */
2099 static estream_t
2100 open_es_fwrite (const char *filename)
2101 {
2102 int fd;
2103 estream_t fp;
2104
2105 if (filename[0] == '-' && !filename[1])
2106 {
2107 fflush (stdout);
2108 fp = es_fdopen_nc (fileno(stdout), "wb");
2109 return fp;
2110 }
2111
2112 fd = check_special_filename (filename, 1);
2113 if (fd != -1)
2114 {
2115 fp = es_fdopen_nc (fd, "wb");
2116 if (!fp)
2117 {
2118 log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
2119 gpgsm_exit (2);
2120 }
2121 return fp;
2122 }
2123 fp = es_fopen (filename, "wb");
2124 if (!fp)
2125 {
2126 log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2127 gpgsm_exit (2);
2128 }
2129 return fp;
2130 }
2131
2132
2133 static void
2134 run_protect_tool (int argc, char **argv)
2135 {
2136 #ifndef HAVE_W32_SYSTEM
2137 const char *pgm;
2138 char **av;
2139 int i;
2140
2141 if (!opt.protect_tool_program || !*opt.protect_tool_program)
2142 pgm = gnupg_module_name (GNUPG_MODULE_NAME_PROTECT_TOOL);
2143 else
2144 pgm = opt.protect_tool_program;
2145
2146 av = xcalloc (argc+2, sizeof *av);
2147 av[0] = strrchr (pgm, '/');
2148 if (!av[0])
2149 av[0] = xstrdup (pgm);
2150 for (i=1; argc; i++, argc--, argv++)
2151 av[i] = *argv;
2152 av[i] = NULL;
2153 execv (pgm, av);
2154 log_error ("error executing `%s': %s\n", pgm, strerror (errno));
2155 #endif /*HAVE_W32_SYSTEM*/
2156 gpgsm_exit (2);
2157 }
gnupg svn clone