?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2006-09-06 Marcus Brinkmann <marcus@g10code.de>
[gnupg.git] / g10 / gpg.c
blob826cdd30537abc1fdfe98b3edcfd3883cfac41db
1 /* gpg.c - The GnuPG utility (main for gpg)
2 * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 * 2006 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 2 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, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20 * USA.
21 */
22
23 #include <config.h>
24 #include <errno.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <ctype.h>
29 #include <unistd.h>
30 #include <assert.h>
31 #ifdef HAVE_DOSISH_SYSTEM
32 #include <fcntl.h> /* for setmode() */
33 #endif
34 #ifdef HAVE_STAT
35 #include <sys/stat.h> /* for stat() */
36 #endif
37 #include <fcntl.h>
38 #include <assuan.h>
39 #ifdef HAVE_W32_SYSTEM
40 #include <windows.h>
41 #endif
42
43 #define INCLUDED_BY_MAIN_MODULE 1
44 #include "gpg.h"
45 #include "packet.h"
46 #include "../common/iobuf.h"
47 #include "util.h"
48 #include "main.h"
49 #include "options.h"
50 #include "keydb.h"
51 #include "trustdb.h"
52 #include "cipher.h"
53 #include "filter.h"
54 #include "ttyio.h"
55 #include "i18n.h"
56 #include "status.h"
57 #include "keyserver-internal.h"
58 #include "exec.h"
59
60
61 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
62 #define MY_O_BINARY O_BINARY
63 #ifndef S_IRGRP
64 # define S_IRGRP 0
65 # define S_IWGRP 0
66 #endif
67 #else
68 #define MY_O_BINARY 0
69 #endif
70
71
72 enum cmd_and_opt_values
73 {
74 aNull = 0,
75 oArmor = 'a',
76 aDetachedSign = 'b',
77 aSym = 'c',
78 aDecrypt = 'd',
79 aEncr = 'e',
80 oInteractive = 'i',
81 oKOption = 'k',
82 oDryRun = 'n',
83 oOutput = 'o',
84 oQuiet = 'q',
85 oRecipient = 'r',
86 oHiddenRecipient = 'R',
87 aSign = 's',
88 oTextmodeShort= 't',
89 oLocalUser = 'u',
90 oVerbose = 'v',
91 oCompress = 'z',
92 oSetNotation = 'N',
93 aListSecretKeys = 'K',
94 oBatch = 500,
95 oMaxOutput,
96 oSigNotation,
97 oCertNotation,
98 oShowNotation,
99 oNoShowNotation,
100 aEncrFiles,
101 aEncrSym,
102 aDecryptFiles,
103 aClearsign,
104 aStore,
105 aKeygen,
106 aSignEncr,
107 aSignEncrSym,
108 aSignSym,
109 aSignKey,
110 aLSignKey,
111 aListConfig,
112 aGPGConfList,
113 aListPackets,
114 aEditKey,
115 aDeleteKeys,
116 aDeleteSecretKeys,
117 aDeleteSecretAndPublicKeys,
118 aKMode,
119 aKModeC,
120 aImport,
121 aFastImport,
122 aVerify,
123 aVerifyFiles,
124 aListKeys,
125 aListSigs,
126 aSendKeys,
127 aRecvKeys,
128 aSearchKeys,
129 aRefreshKeys,
130 aFetchKeys,
131 aExport,
132 aExportSecret,
133 aExportSecretSub,
134 aCheckKeys,
135 aGenRevoke,
136 aDesigRevoke,
137 aPrimegen,
138 aPrintMD,
139 aPrintMDs,
140 aCheckTrustDB,
141 aUpdateTrustDB,
142 aFixTrustDB,
143 aListTrustDB,
144 aListTrustPath,
145 aExportOwnerTrust,
146 aListOwnerTrust,
147 aImportOwnerTrust,
148 aDeArmor,
149 aEnArmor,
150 aGenRandom,
151 aRebuildKeydbCaches,
152 aCardStatus,
153 aCardEdit,
154 aChangePIN,
155
156 oTextmode,
157 oNoTextmode,
158 oExpert,
159 oNoExpert,
160 oDefSigExpire,
161 oAskSigExpire,
162 oNoAskSigExpire,
163 oDefCertExpire,
164 oAskCertExpire,
165 oNoAskCertExpire,
166 oDefCertLevel,
167 oMinCertLevel,
168 oAskCertLevel,
169 oNoAskCertLevel,
170 oFingerprint,
171 oWithFingerprint,
172 oAnswerYes,
173 oAnswerNo,
174 oKeyring,
175 oPrimaryKeyring,
176 oSecretKeyring,
177 oShowKeyring,
178 oDefaultKey,
179 oDefRecipient,
180 oDefRecipientSelf,
181 oNoDefRecipient,
182 oOptions,
183 oDebug,
184 oDebugLevel,
185 oDebugAll,
186 oDebugCCIDDriver,
187 oStatusFD,
188 oStatusFile,
189 oAttributeFD,
190 oAttributeFile,
191 oEmitVersion,
192 oNoEmitVersion,
193 oCompletesNeeded,
194 oMarginalsNeeded,
195 oMaxCertDepth,
196 oLoadExtension,
197 oGnuPG,
198 oRFC1991,
199 oRFC2440,
200 oOpenPGP,
201 oPGP2,
202 oPGP6,
203 oPGP7,
204 oPGP8,
205 oRFC2440Text,
206 oNoRFC2440Text,
207 oCipherAlgo,
208 oDigestAlgo,
209 oCertDigestAlgo,
210 oCompressAlgo,
211 oCompressLevel,
212 oBZ2CompressLevel,
213 oBZ2DecompressLowmem,
214 oPasswd,
215 oPasswdFD,
216 oPasswdFile,
217 oCommandFD,
218 oCommandFile,
219 oQuickRandom,
220 oNoVerbose,
221 oTrustDBName,
222 oNoSecmemWarn,
223 oRequireSecmem,
224 oNoRequireSecmem,
225 oNoPermissionWarn,
226 oNoMDCWarn,
227 oNoArmor,
228 oNoDefKeyring,
229 oNoGreeting,
230 oNoTTY,
231 oNoOptions,
232 oNoBatch,
233 oHomedir,
234 oWithColons,
235 oWithKeyData,
236 oSkipVerify,
237 oCompressKeys,
238 oCompressSigs,
239 oAlwaysTrust,
240 oTrustModel,
241 oForceOwnertrust,
242 oSetFilename,
243 oForYourEyesOnly,
244 oNoForYourEyesOnly,
245 oSetPolicyURL,
246 oSigPolicyURL,
247 oCertPolicyURL,
248 oShowPolicyURL,
249 oNoShowPolicyURL,
250 oSigKeyserverURL,
251 oUseEmbeddedFilename,
252 oNoUseEmbeddedFilename,
253 oComment,
254 oDefaultComment,
255 oNoComments,
256 oThrowKeyids,
257 oNoThrowKeyids,
258 oShowPhotos,
259 oNoShowPhotos,
260 oPhotoViewer,
261 oForceV3Sigs,
262 oNoForceV3Sigs,
263 oForceV4Certs,
264 oNoForceV4Certs,
265 oForceMDC,
266 oNoForceMDC,
267 oDisableMDC,
268 oNoDisableMDC,
269 oS2KMode,
270 oS2KDigest,
271 oS2KCipher,
272 oSimpleSKChecksum,
273 oDisplayCharset,
274 oNotDashEscaped,
275 oEscapeFrom,
276 oNoEscapeFrom,
277 oLockOnce,
278 oLockMultiple,
279 oLockNever,
280 oKeyServer,
281 oKeyServerOptions,
282 oImportOptions,
283 oExportOptions,
284 oListOptions,
285 oVerifyOptions,
286 oTempDir,
287 oExecPath,
288 oEncryptTo,
289 oHiddenEncryptTo,
290 oNoEncryptTo,
291 oLoggerFD,
292 oLoggerFile,
293 oUtf8Strings,
294 oNoUtf8Strings,
295 oDisableCipherAlgo,
296 oDisablePubkeyAlgo,
297 oAllowNonSelfsignedUID,
298 oNoAllowNonSelfsignedUID,
299 oAllowFreeformUID,
300 oNoAllowFreeformUID,
301 oAllowSecretKeyImport,
302 oEnableSpecialFilenames,
303 oNoLiteral,
304 oSetFilesize,
305 oHonorHttpProxy,
306 oFastListMode,
307 oListOnly,
308 oIgnoreTimeConflict,
309 oIgnoreValidFrom,
310 oIgnoreCrcError,
311 oIgnoreMDCError,
312 oShowSessionKey,
313 oOverrideSessionKey,
314 oNoRandomSeedFile,
315 oAutoKeyRetrieve,
316 oNoAutoKeyRetrieve,
317 oUseAgent,
318 oNoUseAgent,
319 oGpgAgentInfo,
320 oMergeOnly,
321 oTryAllSecrets,
322 oTrustedKey,
323 oNoExpensiveTrustChecks,
324 oFixedListMode,
325 oNoSigCache,
326 oNoSigCreateCheck,
327 oAutoCheckTrustDB,
328 oNoAutoCheckTrustDB,
329 oPreservePermissions,
330 oDefaultPreferenceList,
331 oDefaultKeyserverURL,
332 oPersonalCipherPreferences,
333 oPersonalDigestPreferences,
334 oPersonalCompressPreferences,
335 oAgentProgram,
336 oDisplay,
337 oTTYname,
338 oTTYtype,
339 oLCctype,
340 oLCmessages,
341 oGroup,
342 oUnGroup,
343 oNoGroups,
344 oStrict,
345 oNoStrict,
346 oMangleDosFilenames,
347 oNoMangleDosFilenames,
348 oEnableProgressFilter,
349 oMultifile,
350 oKeyidFormat,
351 oExitOnStatusWriteError,
352 oLimitCardInsertTries,
353 oRequireCrossCert,
354 oNoRequireCrossCert,
355 oAutoKeyLocate,
356 oNoAutoKeyLocate,
357 oAllowMultisigVerification,
358 oEnableDSA2,
359 oDisableDSA2,
360
361 oNoop
362 };
363
364
365 static ARGPARSE_OPTS opts[] = {
366
367 { 300, NULL, 0, N_("@Commands:\n ") },
368
369 { aSign, "sign", 256, N_("|[file]|make a signature")},
370 { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature")},
371 { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
372 { aEncr, "encrypt", 256, N_("encrypt data")},
373 { aEncrFiles, "encrypt-files", 256, "@"},
374 { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
375 { aStore, "store", 256, "@"},
376 { aDecrypt, "decrypt", 256, N_("decrypt data (default)")},
377 { aDecryptFiles, "decrypt-files", 256, "@"},
378 { aVerify, "verify" , 256, N_("verify a signature")},
379 { aVerifyFiles, "verify-files" , 256, "@" },
380 { aListKeys, "list-keys", 256, N_("list keys")},
381 { aListKeys, "list-public-keys", 256, "@" },
382 { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
383 { aCheckKeys, "check-sigs",256, N_("list and check key signatures")},
384 { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
385 { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
386 { aKeygen, "gen-key", 256, N_("generate a new key pair")},
387 { aDeleteKeys,"delete-keys",256,N_("remove keys from the public keyring")},
388 { aDeleteSecretKeys, "delete-secret-keys",256,
389 N_("remove keys from the secret keyring")},
390 { aSignKey, "sign-key" ,256, N_("sign a key")},
391 { aLSignKey, "lsign-key" ,256, N_("sign a key locally")},
392 { aEditKey, "edit-key" ,256, N_("sign or edit a key")},
393 { aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
394 { aDesigRevoke, "desig-revoke",256, "@" },
395 { aExport, "export" , 256, N_("export keys") },
396 { aSendKeys, "send-keys" , 256, N_("export keys to a key server") },
397 { aRecvKeys, "recv-keys" , 256, N_("import keys from a key server") },
398 { aSearchKeys, "search-keys" , 256,
399 N_("search for keys on a key server") },
400 { aRefreshKeys, "refresh-keys", 256,
401 N_("update all keys from a keyserver")},
402 { aFetchKeys, "fetch-keys" , 256, "@" },
403 { aExportSecret, "export-secret-keys" , 256, "@" },
404 { aExportSecretSub, "export-secret-subkeys" , 256, "@" },
405 { aImport, "import", 256 , N_("import/merge keys")},
406 { aFastImport, "fast-import", 256 , "@"},
407 #ifdef ENABLE_CARD_SUPPORT
408 { aCardStatus, "card-status", 256, N_("print the card status")},
409 { aCardEdit, "card-edit", 256, N_("change data on a card")},
410 { aChangePIN, "change-pin", 256, N_("change a card's PIN")},
411 #endif
412 { aListConfig, "list-config", 256, "@"},
413 { aGPGConfList, "gpgconf-list", 256, "@" },
414 { aListPackets, "list-packets",256, "@"},
415 { aExportOwnerTrust, "export-ownertrust", 256, "@"},
416 { aImportOwnerTrust, "import-ownertrust", 256, "@"},
417 { aUpdateTrustDB,
418 "update-trustdb",0 , N_("update the trust database")},
419 { aCheckTrustDB, "check-trustdb", 0, "@"},
420 { aFixTrustDB, "fix-trustdb", 0, "@"},
421 { aDeArmor, "dearmor", 256, "@"},
422 { aDeArmor, "dearmour", 256, "@"},
423 { aEnArmor, "enarmor", 256, "@"},
424 { aEnArmor, "enarmour", 256, "@"},
425 { aPrintMD, "print-md" , 256, N_("|algo [files]|print message digests")},
426 { aPrimegen, "gen-prime" , 256, "@" },
427 { aGenRandom, "gen-random" , 256, "@" },
428
429 { 301, NULL, 0, N_("@\nOptions:\n ") },
430
431 { oArmor, "armor", 0, N_("create ascii armored output")},
432 { oArmor, "armour", 0, "@" },
433 { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
434 { oHiddenRecipient, "hidden-recipient", 2, "@" },
435 { oRecipient, "remote-user", 2, "@"}, /* old option name */
436 { oDefRecipient, "default-recipient", 2, "@"},
437 { oDefRecipientSelf, "default-recipient-self", 0, "@"},
438 { oNoDefRecipient, "no-default-recipient", 0, "@" },
439 { oTempDir, "temp-directory", 2, "@" },
440 { oExecPath, "exec-path", 2, "@" },
441 { oEncryptTo, "encrypt-to", 2, "@" },
442 { oHiddenEncryptTo, "hidden-encrypt-to", 2, "@" },
443 { oNoEncryptTo, "no-encrypt-to", 0, "@" },
444 { oLocalUser, "local-user",2, N_("use this user-id to sign or decrypt")},
445 { oCompress, NULL, 1, N_("|N|set compress level N (0 disables)") },
446 { oCompressLevel, "compress-level", 1, "@" },
447 { oBZ2CompressLevel, "bzip2-compress-level", 1, "@" },
448 { oBZ2DecompressLowmem, "bzip2-decompress-lowmem", 0, "@" },
449 { oTextmodeShort, NULL, 0, "@"},
450 { oTextmode, "textmode", 0, N_("use canonical text mode")},
451 { oNoTextmode, "no-textmode", 0, "@"},
452 { oExpert, "expert", 0, "@"},
453 { oNoExpert, "no-expert", 0, "@"},
454 { oDefSigExpire, "default-sig-expire", 2, "@"},
455 { oAskSigExpire, "ask-sig-expire", 0, "@"},
456 { oNoAskSigExpire, "no-ask-sig-expire", 0, "@"},
457 { oDefCertExpire, "default-cert-expire", 2, "@"},
458 { oAskCertExpire, "ask-cert-expire", 0, "@"},
459 { oNoAskCertExpire, "no-ask-cert-expire", 0, "@"},
460 { oDefCertLevel, "default-cert-level", 1, "@"},
461 { oMinCertLevel, "min-cert-level", 1, "@"},
462 { oAskCertLevel, "ask-cert-level", 0, "@"},
463 { oNoAskCertLevel, "no-ask-cert-level", 0, "@"},
464 { oOutput, "output", 2, N_("use as output file")},
465 { oMaxOutput, "max-output", 16|4, "@" },
466 { oVerbose, "verbose", 0, N_("verbose") },
467 { oQuiet, "quiet", 0, "@"},
468 { oNoTTY, "no-tty", 0, "@"},
469 { oForceV3Sigs, "force-v3-sigs", 0, "@"},
470 { oNoForceV3Sigs, "no-force-v3-sigs", 0, "@"},
471 { oForceV4Certs, "force-v4-certs", 0, "@"},
472 { oNoForceV4Certs, "no-force-v4-certs", 0, "@"},
473 { oForceMDC, "force-mdc", 0, "@"},
474 { oNoForceMDC, "no-force-mdc", 0, "@" },
475 { oDisableMDC, "disable-mdc", 0, "@"},
476 { oNoDisableMDC, "no-disable-mdc", 0, "@" },
477 { oDryRun, "dry-run", 0, N_("do not make any changes") },
478 { oInteractive, "interactive", 0, N_("prompt before overwriting") },
479 { oUseAgent, "use-agent",0, "@"},
480 { oNoUseAgent, "no-use-agent",0, "@"},
481 { oGpgAgentInfo, "gpg-agent-info",2, "@"},
482 { oBatch, "batch", 0, "@"},
483 { oAnswerYes, "yes", 0, "@"},
484 { oAnswerNo, "no", 0, "@"},
485 { oKeyring, "keyring", 2, "@"},
486 { oPrimaryKeyring, "primary-keyring",2, "@" },
487 { oSecretKeyring, "secret-keyring", 2, "@"},
488 { oShowKeyring, "show-keyring", 0, "@"},
489 { oDefaultKey, "default-key", 2, "@"},
490 { oKeyServer, "keyserver", 2, "@"},
491 { oKeyServerOptions, "keyserver-options",2,"@"},
492 { oImportOptions, "import-options",2,"@"},
493 { oExportOptions, "export-options",2,"@"},
494 { oListOptions, "list-options",2,"@"},
495 { oVerifyOptions, "verify-options",2,"@"},
496 { oDisplayCharset, "display-charset", 2, "@"},
497 { oDisplayCharset, "charset", 2, "@"},
498 { oOptions, "options", 2, "@"},
499 { oDebug, "debug" ,4|16, "@"},
500 { oDebugLevel, "debug-level" ,2, "@"},
501 { oDebugAll, "debug-all" ,0, "@"},
502 { oStatusFD, "status-fd" ,1, "@"},
503 { oStatusFile, "status-file" ,2, "@"},
504 { oAttributeFD, "attribute-fd" ,1, "@" },
505 { oAttributeFile, "attribute-file" ,2, "@" },
506 { oNoop, "sk-comments", 0, "@"},
507 { oNoop, "no-sk-comments", 0, "@"},
508 { oCompletesNeeded, "completes-needed", 1, "@"},
509 { oMarginalsNeeded, "marginals-needed", 1, "@"},
510 { oMaxCertDepth, "max-cert-depth", 1, "@" },
511 { oTrustedKey, "trusted-key", 2, "@"},
512 { oLoadExtension, "load-extension", 2, "@"},
513 { oGnuPG, "gnupg", 0, "@"},
514 { oGnuPG, "no-pgp2", 0, "@"},
515 { oGnuPG, "no-pgp6", 0, "@"},
516 { oGnuPG, "no-pgp7", 0, "@"},
517 { oGnuPG, "no-pgp8", 0, "@"},
518 { oRFC1991, "rfc1991", 0, "@"},
519 { oRFC2440, "rfc2440", 0, "@" },
520 { oOpenPGP, "openpgp", 0, N_("use strict OpenPGP behavior")},
521 { oPGP2, "pgp2", 0, N_("generate PGP 2.x compatible messages")},
522 { oPGP6, "pgp6", 0, "@"},
523 { oPGP7, "pgp7", 0, "@"},
524 { oPGP8, "pgp8", 0, "@"},
525 { oRFC2440Text, "rfc2440-text", 0, "@"},
526 { oNoRFC2440Text, "no-rfc2440-text", 0, "@"},
527 { oS2KMode, "s2k-mode", 1, "@"},
528 { oS2KDigest, "s2k-digest-algo", 2, "@"},
529 { oS2KCipher, "s2k-cipher-algo", 2, "@"},
530 { oSimpleSKChecksum, "simple-sk-checksum", 0, "@"},
531 { oCipherAlgo, "cipher-algo", 2, "@"},
532 { oDigestAlgo, "digest-algo", 2, "@"},
533 { oCertDigestAlgo, "cert-digest-algo", 2 , "@" },
534 { oCompressAlgo,"compress-algo", 2, "@"},
535 { oCompressAlgo, "compression-algo", 2, "@"}, /* Alias */
536 { oThrowKeyids, "throw-keyid", 0, "@"},
537 { oThrowKeyids, "throw-keyids", 0, "@"},
538 { oNoThrowKeyids, "no-throw-keyid", 0, "@" },
539 { oNoThrowKeyids, "no-throw-keyids", 0, "@" },
540 { oShowPhotos, "show-photos", 0, "@" },
541 { oNoShowPhotos, "no-show-photos", 0, "@" },
542 { oPhotoViewer, "photo-viewer", 2, "@" },
543 { oSetNotation, "set-notation", 2, "@" },
544 { oSetNotation, "notation-data", 2, "@" }, /* Alias */
545 { oSigNotation, "sig-notation", 2, "@" },
546 { oCertNotation, "cert-notation", 2, "@" },
547
548 { 302, NULL, 0, N_(
549 "@\n(See the man page for a complete listing of all commands and options)\n"
550 )},
551
552 { 303, NULL, 0, N_("@\nExamples:\n\n"
553 " -se -r Bob [file] sign and encrypt for user Bob\n"
554 " --clearsign [file] make a clear text signature\n"
555 " --detach-sign [file] make a detached signature\n"
556 " --list-keys [names] show keys\n"
557 " --fingerprint [names] show fingerprints\n" ) },
558
559 /* hidden options */
560 { aListOwnerTrust, "list-ownertrust", 256, "@"}, /* deprecated */
561 { aPrintMDs, "print-mds" , 256, "@"}, /* old */
562 { aListTrustDB, "list-trustdb",0 , "@"},
563 /* Not yet used */
564 /* { aListTrustPath, "list-trust-path",0, "@"}, */
565 { oKOption, NULL, 0, "@"},
566 { oPasswd, "passphrase",2, "@" },
567 { oPasswdFD, "passphrase-fd",1, "@" },
568 { oPasswdFile, "passphrase-file",2, "@" },
569 { oCommandFD, "command-fd",1, "@" },
570 { oCommandFile, "command-file",2, "@" },
571 { oQuickRandom, "debug-quick-random", 0, "@"},
572 { oNoVerbose, "no-verbose", 0, "@"},
573 { oTrustDBName, "trustdb-name", 2, "@" },
574 { oNoSecmemWarn, "no-secmem-warning", 0, "@" },
575 { oRequireSecmem,"require-secmem", 0, "@" },
576 { oNoRequireSecmem,"no-require-secmem", 0, "@" },
577 { oNoPermissionWarn, "no-permission-warning", 0, "@" },
578 { oNoMDCWarn, "no-mdc-warning", 0, "@" },
579 { oNoArmor, "no-armor", 0, "@"},
580 { oNoArmor, "no-armour", 0, "@"},
581 { oNoDefKeyring, "no-default-keyring", 0, "@" },
582 { oNoGreeting, "no-greeting", 0, "@" },
583 { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
584 { oHomedir, "homedir", 2, "@" }, /* defaults to "~/.gnupg" */
585 { oNoBatch, "no-batch", 0, "@" },
586 { oWithColons, "with-colons", 0, "@"},
587 { oWithKeyData,"with-key-data", 0, "@"},
588 { aListKeys, "list-key", 0, "@" }, /* alias */
589 { aListSigs, "list-sig", 0, "@" }, /* alias */
590 { aCheckKeys, "check-sig",0, "@" }, /* alias */
591 { oSkipVerify, "skip-verify",0, "@" },
592 { oCompressKeys, "compress-keys",0, "@"},
593 { oCompressSigs, "compress-sigs",0, "@"},
594 { oDefCertLevel, "default-cert-check-level", 1, "@"}, /* Old option */
595 { oAlwaysTrust, "always-trust", 0, "@"},
596 { oTrustModel, "trust-model", 2, "@"},
597 { oForceOwnertrust, "force-ownertrust", 2, "@"},
598 { oSetFilename, "set-filename", 2, "@" },
599 { oForYourEyesOnly, "for-your-eyes-only", 0, "@" },
600 { oNoForYourEyesOnly, "no-for-your-eyes-only", 0, "@" },
601 { oSetPolicyURL, "set-policy-url", 2, "@" },
602 { oSigPolicyURL, "sig-policy-url", 2, "@" },
603 { oCertPolicyURL, "cert-policy-url", 2, "@" },
604 { oShowPolicyURL, "show-policy-url", 0, "@" },
605 { oNoShowPolicyURL, "no-show-policy-url", 0, "@" },
606 { oSigKeyserverURL, "sig-keyserver-url", 2, "@" },
607 { oShowNotation, "show-notation", 0, "@" },
608 { oNoShowNotation, "no-show-notation", 0, "@" },
609 { oComment, "comment", 2, "@" },
610 { oDefaultComment, "default-comment", 0, "@" },
611 { oNoComments, "no-comments", 0, "@" },
612 { oEmitVersion, "emit-version", 0, "@"},
613 { oNoEmitVersion, "no-emit-version", 0, "@"},
614 { oNoEmitVersion, "no-version", 0, "@"}, /* alias */
615 { oNotDashEscaped, "not-dash-escaped", 0, "@" },
616 { oEscapeFrom, "escape-from-lines", 0, "@" },
617 { oNoEscapeFrom, "no-escape-from-lines", 0, "@" },
618 { oLockOnce, "lock-once", 0, "@" },
619 { oLockMultiple, "lock-multiple", 0, "@" },
620 { oLockNever, "lock-never", 0, "@" },
621 { oLoggerFD, "logger-fd",1, "@" },
622 { oLoggerFile, "log-file",2, "@" },
623 { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
624 { oNoUseEmbeddedFilename, "no-use-embedded-filename", 0, "@" },
625 { oUtf8Strings, "utf8-strings", 0, "@" },
626 { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
627 { oWithFingerprint, "with-fingerprint", 0, "@" },
628 { oDisableCipherAlgo, "disable-cipher-algo", 2, "@" },
629 { oDisablePubkeyAlgo, "disable-pubkey-algo", 2, "@" },
630 { oAllowNonSelfsignedUID, "allow-non-selfsigned-uid", 0, "@" },
631 { oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", 0, "@" },
632 { oAllowFreeformUID, "allow-freeform-uid", 0, "@" },
633 { oNoAllowFreeformUID, "no-allow-freeform-uid", 0, "@" },
634 { oNoLiteral, "no-literal", 0, "@" },
635 { oSetFilesize, "set-filesize", 20, "@" },
636 { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
637 { oFastListMode,"fast-list-mode", 0, "@" },
638 { oFixedListMode,"fixed-list-mode", 0, "@" },
639 { oListOnly, "list-only", 0, "@"},
640 { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
641 { oIgnoreValidFrom, "ignore-valid-from", 0, "@" },
642 { oIgnoreCrcError, "ignore-crc-error", 0,"@" },
643 { oIgnoreMDCError, "ignore-mdc-error", 0,"@" },
644 { oShowSessionKey, "show-session-key", 0, "@" },
645 { oOverrideSessionKey, "override-session-key", 2, "@" },
646 { oNoRandomSeedFile, "no-random-seed-file", 0, "@" },
647 { oAutoKeyRetrieve, "auto-key-retrieve", 0, "@" },
648 { oNoAutoKeyRetrieve, "no-auto-key-retrieve", 0, "@" },
649 { oNoSigCache, "no-sig-cache", 0, "@" },
650 { oNoSigCreateCheck, "no-sig-create-check", 0, "@" },
651 { oAutoCheckTrustDB, "auto-check-trustdb", 0, "@"},
652 { oNoAutoCheckTrustDB, "no-auto-check-trustdb", 0, "@"},
653 { oMergeOnly, "merge-only", 0, "@" },
654 { oAllowSecretKeyImport, "allow-secret-key-import", 0, "@" },
655 { oTryAllSecrets, "try-all-secrets", 0, "@" },
656 { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
657 { oNoExpensiveTrustChecks, "no-expensive-trust-checks", 0, "@" },
658 { aDeleteSecretAndPublicKeys, "delete-secret-and-public-keys",256, "@" },
659 { aRebuildKeydbCaches, "rebuild-keydb-caches", 256, "@"},
660 { oPreservePermissions, "preserve-permissions", 0, "@"},
661 { oDefaultPreferenceList, "default-preference-list", 2, "@"},
662 { oDefaultKeyserverURL, "default-keyserver-url", 2, "@"},
663 { oPersonalCipherPreferences, "personal-cipher-preferences", 2, "@"},
664 { oPersonalDigestPreferences, "personal-digest-preferences", 2, "@"},
665 { oPersonalCompressPreferences, "personal-compress-preferences", 2, "@"},
666 /* Aliases. I constantly mistype these, and assume other people
667 do as well. */
668 { oPersonalCipherPreferences, "personal-cipher-prefs", 2, "@"},
669 { oPersonalDigestPreferences, "personal-digest-prefs", 2, "@"},
670 { oPersonalCompressPreferences, "personal-compress-prefs", 2, "@"},
671 { oAgentProgram, "agent-program", 2 , "@" },
672 { oDisplay, "display", 2, "@" },
673 { oTTYname, "ttyname", 2, "@" },
674 { oTTYtype, "ttytype", 2, "@" },
675 { oLCctype, "lc-ctype", 2, "@" },
676 { oLCmessages, "lc-messages", 2, "@" },
677 { oGroup, "group", 2, "@" },
678 { oUnGroup, "ungroup", 2, "@" },
679 { oNoGroups, "no-groups", 0, "@" },
680 { oStrict, "strict", 0, "@" },
681 { oNoStrict, "no-strict", 0, "@" },
682 { oMangleDosFilenames, "mangle-dos-filenames", 0, "@" },
683 { oNoMangleDosFilenames, "no-mangle-dos-filenames", 0, "@" },
684 { oEnableProgressFilter, "enable-progress-filter", 0, "@" },
685 { oMultifile, "multifile", 0, "@" },
686 { oKeyidFormat, "keyid-format", 2, "@" },
687 { oExitOnStatusWriteError, "exit-on-status-write-error", 0, "@" },
688 { oLimitCardInsertTries, "limit-card-insert-tries", 1, "@"},
689
690 { oAllowMultisigVerification, "allow-multisig-verification", 0, "@"},
691 { oEnableDSA2, "enable-dsa2", 0, "@"},
692 { oDisableDSA2, "disable-dsa2", 0, "@"},
693
694 /* These two are aliases to help users of the PGP command line
695 product use gpg with minimal pain. Many commands are common
696 already as they seem to have borrowed commands from us. Now
697 I'm returning the favor. */
698 { oLocalUser, "sign-with", 2, "@" },
699 { oRecipient, "user", 2, "@" },
700 { oRequireCrossCert, "require-backsigs", 0, "@"},
701 { oRequireCrossCert, "require-cross-certification", 0, "@"},
702 { oNoRequireCrossCert, "no-require-backsigs", 0, "@"},
703 { oNoRequireCrossCert, "no-require-cross-certification", 0, "@"},
704 { oAutoKeyLocate, "auto-key-locate", 2, "@"},
705 { oNoAutoKeyLocate, "no-auto-key-locate", 0, "@"},
706
707 {0,NULL,0,NULL}
708 };
709
710
711 #ifdef ENABLE_SELINUX_HACKS
712 #define ALWAYS_ADD_KEYRINGS 1
713 #else
714 #define ALWAYS_ADD_KEYRINGS 0
715 #endif
716
717
718 int g10_errors_seen = 0;
719
720 static int utf8_strings = 0;
721 static int maybe_setuid = 1;
722
723 static char *build_list( const char *text, char letter,
724 const char *(*mapf)(int), int (*chkf)(int) );
725 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
726 enum cmd_and_opt_values new_cmd );
727 static void print_mds( const char *fname, int algo );
728 static void add_notation_data( const char *string, int which );
729 static void add_policy_url( const char *string, int which );
730 static void add_keyserver_url( const char *string, int which );
731 static void emergency_cleanup (void);
732
733
734 static const char *
735 my_strusage( int level )
736 {
737 static char *digests, *pubkeys, *ciphers, *zips;
738 const char *p;
739 switch( level ) {
740 case 11: p = "gpg (GnuPG)";
741 break;
742 case 13: p = VERSION; break;
743 case 17: p = PRINTABLE_OS_NAME; break;
744 case 19: p =
745 _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
746 break;
747
748 #ifdef IS_DEVELOPMENT_VERSION
749 case 20:
750 p="NOTE: THIS IS A DEVELOPMENT VERSION!";
751 break;
752 case 21:
753 p="It is only intended for test purposes and should NOT be";
754 break;
755 case 22:
756 p="used in a production environment or with production keys!";
757 break;
758 #endif
759
760 case 1:
761 case 40: p =
762 _("Usage: gpg [options] [files] (-h for help)");
763 break;
764 case 41: p =
765 _("Syntax: gpg [options] [files]\n"
766 "sign, check, encrypt or decrypt\n"
767 "default operation depends on the input data\n");
768 break;
769
770 case 31: p = "\nHome: "; break;
771 #ifndef __riscos__
772 case 32: p = opt.homedir; break;
773 #else /* __riscos__ */
774 case 32: p = make_filename(opt.homedir, NULL); break;
775 #endif /* __riscos__ */
776 case 33: p = _("\nSupported algorithms:\n"); break;
777 case 34:
778 if (!pubkeys)
779 pubkeys = build_list (_("Pubkey: "), 0,
780 gcry_pk_algo_name,
781 openpgp_pk_test_algo );
782 p = pubkeys;
783 break;
784 case 35:
785 if( !ciphers )
786 ciphers = build_list(_("Cipher: "), 'S',
787 gcry_cipher_algo_name,
788 openpgp_cipher_test_algo );
789 p = ciphers;
790 break;
791 case 36:
792 if( !digests )
793 digests = build_list(_("Hash: "), 'H',
794 gcry_md_algo_name,
795 openpgp_md_test_algo );
796 p = digests;
797 break;
798 case 37:
799 if( !zips )
800 zips = build_list(_("Compression: "),'Z',
801 compress_algo_to_string,
802 check_compress_algo);
803 p = zips;
804 break;
805
806 default: p = NULL;
807 }
808 return p;
809 }
810
811
812 static char *
813 build_list( const char *text, char letter,
814 const char * (*mapf)(int), int (*chkf)(int) )
815 {
816 int i;
817 const char *s;
818 size_t n=strlen(text)+2;
819 char *list, *p, *line=NULL;
820
821 if (maybe_setuid)
822 gcry_control (GCRYCTL_INIT_SECMEM, 0, 0); /* Drop setuid. */
823
824 for(i=0; i <= 110; i++ )
825 if( !chkf(i) && (s=mapf(i)) )
826 n += strlen(s) + 7 + 2;
827 list = xmalloc( 21 + n ); *list = 0;
828 for(p=NULL, i=0; i <= 110; i++ ) {
829 if( !chkf(i) && (s=mapf(i)) ) {
830 if( !p ) {
831 p = stpcpy( list, text );
832 line=p;
833 }
834 else
835 p = stpcpy( p, ", ");
836
837 if(strlen(line)>60) {
838 int spaces=strlen(text);
839
840 list=xrealloc(list,n+spaces+1);
841 /* realloc could move the block, so find the end again */
842 p=list;
843 while(*p)
844 p++;
845
846 p=stpcpy(p, "\n");
847 line=p;
848 for(;spaces;spaces--)
849 p=stpcpy(p, " ");
850 }
851
852 p = stpcpy(p, s );
853 if(opt.verbose && letter)
854 {
855 char num[8];
856 sprintf(num," (%c%d)",letter,i);
857 p = stpcpy(p,num);
858 }
859 }
860 }
861 if( p )
862 p = stpcpy(p, "\n" );
863 return list;
864 }
865
866
867 static void
868 i18n_init(void)
869 {
870 #ifdef USE_SIMPLE_GETTEXT
871 set_gettext_file (PACKAGE_GT, "Software\\GNU\\GnuPG");
872 #else
873 #ifdef ENABLE_NLS
874 setlocale (LC_ALL, "");
875 bindtextdomain (PACKAGE_GT, LOCALEDIR);
876 textdomain (PACKAGE_GT);
877 #endif
878 #endif
879 }
880
881 static void
882 wrong_args( const char *text)
883 {
884 fputs(_("usage: gpg [options] "),stderr);
885 fputs(text,stderr);
886 putc('\n',stderr);
887 g10_exit(2);
888 }
889
890
891 static char *
892 make_username( const char *string )
893 {
894 char *p;
895 if( utf8_strings )
896 p = xstrdup(string);
897 else
898 p = native_to_utf8( string );
899 return p;
900 }
901
902
903 /* Setup the debugging. With a LEVEL of NULL only the active debug
904 flags are propagated to the subsystems. With LEVEL set, a specific
905 set of debug flags is set; thus overriding all flags already
906 set. */
907 static void
908 set_debug (const char *level)
909 {
910 if (!level)
911 ;
912 else if (!strcmp (level, "none"))
913 opt.debug = 0;
914 else if (!strcmp (level, "basic"))
915 opt.debug = DBG_MEMSTAT_VALUE;
916 else if (!strcmp (level, "advanced"))
917 opt.debug = DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE;
918 else if (!strcmp (level, "expert"))
919 opt.debug = (DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE
920 |DBG_CACHE_VALUE|DBG_FILTER_VALUE|DBG_PACKET_VALUE);
921 else if (!strcmp (level, "guru"))
922 opt.debug = ~0;
923 else
924 {
925 log_error (_("invalid debug-level `%s' given\n"), level);
926 g10_exit (2);
927 }
928
929 if (opt.debug & DBG_MEMORY_VALUE )
930 memory_debug_mode = 1;
931 if (opt.debug & DBG_MEMSTAT_VALUE )
932 memory_stat_debug_mode = 1;
933 if (opt.debug & DBG_MPI_VALUE)
934 gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
935 if (opt.debug & DBG_CIPHER_VALUE )
936 gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
937 if (opt.debug & DBG_IOBUF_VALUE )
938 iobuf_debug_mode = 1;
939 gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
940 }
941
942
943
944 /* We need the home directory also in some other directories, so make
945 sure that both variables are always in sync. */
946 static void
947 set_homedir (const char *dir)
948 {
949 if (!dir)
950 dir = "";
951 opt.homedir = dir;
952 }
953
954
955 /* We set the screen dimensions for UI purposes. Do not allow screens
956 smaller than 80x24 for the sake of simplicity. */
957 static void
958 set_screen_dimensions(void)
959 {
960 #ifndef HAVE_W32_SYSTEM
961 char *str;
962
963 str=getenv("COLUMNS");
964 if(str)
965 opt.screen_columns=atoi(str);
966
967 str=getenv("LINES");
968 if(str)
969 opt.screen_lines=atoi(str);
970 #endif
971
972 if(opt.screen_columns<80 || opt.screen_columns>255)
973 opt.screen_columns=80;
974
975 if(opt.screen_lines<24 || opt.screen_lines>255)
976 opt.screen_lines=24;
977 }
978
979
980 /* Helper to open a file FNAME either for reading or writing to be
981 used with --status-file etc functions. Not generally useful but it
982 avoids the riscos specific functions and well some Windows people
983 might like it too. Prints an error message and returns -1 on
984 error. On success the file descriptor is returned. */
985 static int
986 open_info_file (const char *fname, int for_write)
987 {
988 #ifdef __riscos__
989 return riscos_fdopenfile (fname, for_write);
990 #elif defined (ENABLE_SELINUX_HACKS)
991 /* We can't allow these even when testing for a secured filename
992 because files to be secured might not yet been secured. This is
993 similar to the option file but in that case it is unlikely that
994 sensitive information may be retrieved by means of error
995 messages. */
996 return -1;
997 #else
998 int fd;
999
1000 /* if (is_secured_filename (fname)) */
1001 /* { */
1002 /* fd = -1; */
1003 /* errno = EPERM; */
1004 /* } */
1005 /* else */
1006 /* { */
1007 do
1008 {
1009 if (for_write)
1010 fd = open (fname, O_CREAT | O_TRUNC | O_WRONLY,
1011 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
1012 else
1013 fd = open (fname, O_RDONLY | MY_O_BINARY);
1014 }
1015 while (fd == -1 && errno == EINTR);
1016 /* } */
1017 if ( fd == -1)
1018 log_error ( for_write? _("can't create `%s': %s\n")
1019 : _("can't open `%s': %s\n"), fname, strerror(errno));
1020
1021 return fd;
1022 #endif
1023 }
1024
1025 static void
1026 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
1027 {
1028 enum cmd_and_opt_values cmd = *ret_cmd;
1029
1030 if( !cmd || cmd == new_cmd )
1031 cmd = new_cmd;
1032 else if( cmd == aSign && new_cmd == aEncr )
1033 cmd = aSignEncr;
1034 else if( cmd == aEncr && new_cmd == aSign )
1035 cmd = aSignEncr;
1036 else if( cmd == aSign && new_cmd == aSym )
1037 cmd = aSignSym;
1038 else if( cmd == aSym && new_cmd == aSign )
1039 cmd = aSignSym;
1040 else if( cmd == aSym && new_cmd == aEncr )
1041 cmd = aEncrSym;
1042 else if( cmd == aEncr && new_cmd == aSym )
1043 cmd = aEncrSym;
1044 else if( cmd == aKMode && new_cmd == aSym )
1045 cmd = aKModeC;
1046 else if (cmd == aSignEncr && new_cmd == aSym)
1047 cmd = aSignEncrSym;
1048 else if (cmd == aSignSym && new_cmd == aEncr)
1049 cmd = aSignEncrSym;
1050 else if (cmd == aEncrSym && new_cmd == aSign)
1051 cmd = aSignEncrSym;
1052 else if( ( cmd == aSign && new_cmd == aClearsign )
1053 || ( cmd == aClearsign && new_cmd == aSign ) )
1054 cmd = aClearsign;
1055 else {
1056 log_error(_("conflicting commands\n"));
1057 g10_exit(2);
1058 }
1059
1060 *ret_cmd = cmd;
1061 }
1062
1063
1064 static void
1065 add_group(char *string)
1066 {
1067 char *name,*value;
1068 struct groupitem *item;
1069
1070 /* Break off the group name */
1071 name=strsep(&string,"=");
1072 if(string==NULL)
1073 {
1074 log_error(_("no = sign found in group definition `%s'\n"),name);
1075 return;
1076 }
1077
1078 trim_trailing_ws(name,strlen(name));
1079
1080 /* Does this group already exist? */
1081 for(item=opt.grouplist;item;item=item->next)
1082 if(strcasecmp(item->name,name)==0)
1083 break;
1084
1085 if(!item)
1086 {
1087 item=xmalloc(sizeof(struct groupitem));
1088 item->name=name;
1089 item->next=opt.grouplist;
1090 item->values=NULL;
1091 opt.grouplist=item;
1092 }
1093
1094 /* Break apart the values */
1095 while ((value= strsep(&string," \t")))
1096 {
1097 if (*value)
1098 add_to_strlist2(&item->values,value,utf8_strings);
1099 }
1100 }
1101
1102
1103 static void
1104 rm_group(char *name)
1105 {
1106 struct groupitem *item,*last=NULL;
1107
1108 trim_trailing_ws(name,strlen(name));
1109
1110 for(item=opt.grouplist;item;last=item,item=item->next)
1111 {
1112 if(strcasecmp(item->name,name)==0)
1113 {
1114 if(last)
1115 last->next=item->next;
1116 else
1117 opt.grouplist=item->next;
1118
1119 free_strlist(item->values);
1120 xfree(item);
1121 break;
1122 }
1123 }
1124 }
1125
1126
1127 /* We need to check three things.
1128
1129 0) The homedir. It must be x00, a directory, and owned by the
1130 user.
1131
1132 1) The options/gpg.conf file. Okay unless it or its containing
1133 directory is group or other writable or not owned by us. Disable
1134 exec in this case.
1135
1136 2) Extensions. Same as #1.
1137
1138 Returns true if the item is unsafe. */
1139 static int
1140 check_permissions(const char *path,int item)
1141 {
1142 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
1143 static int homedir_cache=-1;
1144 char *tmppath,*dir;
1145 struct stat statbuf,dirbuf;
1146 int homedir=0,ret=0,checkonly=0;
1147 int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
1148
1149 if(opt.no_perm_warn)
1150 return 0;
1151
1152 assert(item==0 || item==1 || item==2);
1153
1154 /* extensions may attach a path */
1155 if(item==2 && path[0]!=DIRSEP_C)
1156 {
1157 if(strchr(path,DIRSEP_C))
1158 tmppath=make_filename(path,NULL);
1159 else
1160 tmppath=make_filename(GNUPG_LIBDIR,path,NULL);
1161 }
1162 else
1163 tmppath=xstrdup(path);
1164
1165 /* If the item is located in the homedir, but isn't the homedir,
1166 don't continue if we already checked the homedir itself. This is
1167 to avoid user confusion with an extra options file warning which
1168 could be rectified if the homedir itself had proper
1169 permissions. */
1170 if(item!=0 && homedir_cache>-1
1171 && ascii_strncasecmp(opt.homedir,tmppath,strlen(opt.homedir))==0)
1172 {
1173 ret=homedir_cache;
1174 goto end;
1175 }
1176
1177 /* It's okay if the file or directory doesn't exist */
1178 if(stat(tmppath,&statbuf)!=0)
1179 {
1180 ret=0;
1181 goto end;
1182 }
1183
1184 /* Now check the enclosing directory. Theoretically, we could walk
1185 this test up to the root directory /, but for the sake of sanity,
1186 I'm stopping at one level down. */
1187 dir=make_dirname(tmppath);
1188
1189 if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
1190 {
1191 /* Weird error */
1192 ret=1;
1193 goto end;
1194 }
1195
1196 xfree(dir);
1197
1198 /* Assume failure */
1199 ret=1;
1200
1201 if(item==0)
1202 {
1203 /* The homedir must be x00, a directory, and owned by the user. */
1204
1205 if(S_ISDIR(statbuf.st_mode))
1206 {
1207 if(statbuf.st_uid==getuid())
1208 {
1209 if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1210 ret=0;
1211 else
1212 perm=1;
1213 }
1214 else
1215 own=1;
1216
1217 homedir_cache=ret;
1218 }
1219 }
1220 else if(item==1 || item==2)
1221 {
1222 /* The options or extension file. Okay unless it or its
1223 containing directory is group or other writable or not owned
1224 by us or root. */
1225
1226 if(S_ISREG(statbuf.st_mode))
1227 {
1228 if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
1229 {
1230 if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1231 {
1232 /* it's not writable, so make sure the enclosing
1233 directory is also not writable */
1234 if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1235 {
1236 if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1237 ret=0;
1238 else
1239 enc_dir_perm=1;
1240 }
1241 else
1242 enc_dir_own=1;
1243 }
1244 else
1245 {
1246 /* it's writable, so the enclosing directory had
1247 better not let people get to it. */
1248 if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1249 {
1250 if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1251 ret=0;
1252 else
1253 perm=enc_dir_perm=1; /* unclear which one to fix! */
1254 }
1255 else
1256 enc_dir_own=1;
1257 }
1258 }
1259 else
1260 own=1;
1261 }
1262 }
1263 else
1264 BUG();
1265
1266 if(!checkonly)
1267 {
1268 if(own)
1269 {
1270 if(item==0)
1271 log_info(_("WARNING: unsafe ownership on"
1272 " homedir `%s'\n"),tmppath);
1273 else if(item==1)
1274 log_info(_("WARNING: unsafe ownership on"
1275 " configuration file `%s'\n"),tmppath);
1276 else
1277 log_info(_("WARNING: unsafe ownership on"
1278 " extension `%s'\n"),tmppath);
1279 }
1280 if(perm)
1281 {
1282 if(item==0)
1283 log_info(_("WARNING: unsafe permissions on"
1284 " homedir `%s'\n"),tmppath);
1285 else if(item==1)
1286 log_info(_("WARNING: unsafe permissions on"
1287 " configuration file `%s'\n"),tmppath);
1288 else
1289 log_info(_("WARNING: unsafe permissions on"
1290 " extension `%s'\n"),tmppath);
1291 }
1292 if(enc_dir_own)
1293 {
1294 if(item==0)
1295 log_info(_("WARNING: unsafe enclosing directory ownership on"
1296 " homedir `%s'\n"),tmppath);
1297 else if(item==1)
1298 log_info(_("WARNING: unsafe enclosing directory ownership on"
1299 " configuration file `%s'\n"),tmppath);
1300 else
1301 log_info(_("WARNING: unsafe enclosing directory ownership on"
1302 " extension `%s'\n"),tmppath);
1303 }
1304 if(enc_dir_perm)
1305 {
1306 if(item==0)
1307 log_info(_("WARNING: unsafe enclosing directory permissions on"
1308 " homedir `%s'\n"),tmppath);
1309 else if(item==1)
1310 log_info(_("WARNING: unsafe enclosing directory permissions on"
1311 " configuration file `%s'\n"),tmppath);
1312 else
1313 log_info(_("WARNING: unsafe enclosing directory permissions on"
1314 " extension `%s'\n"),tmppath);
1315 }
1316 }
1317
1318 end:
1319 xfree(tmppath);
1320
1321 if(homedir)
1322 homedir_cache=ret;
1323
1324 return ret;
1325
1326 #endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
1327
1328 return 0;
1329 }
1330
1331
1332 static void
1333 print_algo_numbers(int (*checker)(int))
1334 {
1335 int i,first=1;
1336
1337 for(i=0;i<=110;i++)
1338 {
1339 if(!checker(i))
1340 {
1341 if(first)
1342 first=0;
1343 else
1344 printf(";");
1345 printf("%d",i);
1346 }
1347 }
1348 }
1349
1350
1351 /* In the future, we can do all sorts of interesting configuration
1352 output here. For now, just give "group" as the Enigmail folks need
1353 it, and pubkey, cipher, hash, and compress as they may be useful
1354 for frontends. */
1355 static void
1356 list_config(char *items)
1357 {
1358 int show_all=(items==NULL);
1359 char *name=NULL;
1360
1361 if(!opt.with_colons)
1362 return;
1363
1364 while(show_all || (name=strsep(&items," ")))
1365 {
1366 int any=0;
1367
1368 if(show_all || ascii_strcasecmp(name,"group")==0)
1369 {
1370 struct groupitem *iter;
1371
1372 for(iter=opt.grouplist;iter;iter=iter->next)
1373 {
1374 STRLIST sl;
1375
1376 printf("cfg:group:");
1377 print_string(stdout,iter->name,strlen(iter->name),':');
1378 printf(":");
1379
1380 for(sl=iter->values;sl;sl=sl->next)
1381 {
1382 print_sanitized_string2 (stdout, sl->d, ':',';');
1383 if(sl->next)
1384 printf(";");
1385 }
1386
1387 printf("\n");
1388 }
1389
1390 any=1;
1391 }
1392
1393 if(show_all || ascii_strcasecmp(name,"version")==0)
1394 {
1395 printf("cfg:version:");
1396 print_string(stdout,VERSION,strlen(VERSION),':');
1397 printf("\n");
1398 any=1;
1399 }
1400
1401 if(show_all || ascii_strcasecmp(name,"pubkey")==0)
1402 {
1403 printf("cfg:pubkey:");
1404 print_algo_numbers (openpgp_pk_test_algo);
1405 printf("\n");
1406 any=1;
1407 }
1408
1409 if(show_all || ascii_strcasecmp(name,"cipher")==0)
1410 {
1411 printf("cfg:cipher:");
1412 print_algo_numbers(openpgp_cipher_test_algo);
1413 printf("\n");
1414 any=1;
1415 }
1416
1417 if(show_all
1418 || ascii_strcasecmp(name,"digest")==0
1419 || ascii_strcasecmp(name,"hash")==0)
1420 {
1421 printf("cfg:digest:");
1422 print_algo_numbers(openpgp_md_test_algo);
1423 printf("\n");
1424 any=1;
1425 }
1426
1427 if(show_all || ascii_strcasecmp(name,"compress")==0)
1428 {
1429 printf("cfg:compress:");
1430 print_algo_numbers(check_compress_algo);
1431 printf("\n");
1432 any=1;
1433 }
1434
1435 if(show_all || ascii_strcasecmp(name,"ccid-reader-id")==0)
1436 {
1437 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB) \
1438 && GNUPG_MAJOR_VERSION == 1
1439
1440 char *p, *p2, *list = ccid_get_reader_list ();
1441
1442 for (p=list; p && (p2 = strchr (p, '\n')); p = p2+1)
1443 {
1444 *p2 = 0;
1445 printf("cfg:ccid-reader-id:%s\n", p);
1446 }
1447 free (list);
1448 #endif
1449 any=1;
1450 }
1451
1452 if(show_all)
1453 break;
1454
1455 if(!any)
1456 log_error(_("unknown configuration item `%s'\n"),name);
1457 }
1458 }
1459
1460
1461 /* List options and default values in the GPG Conf format. This is a
1462 new tool distributed with gnupg 1.9.x but we also want some limited
1463 support in older gpg versions. The output is the name of the
1464 configuration file and a list of options available for editing by
1465 gpgconf. */
1466 static void
1467 gpgconf_list (const char *configfile)
1468 {
1469 /* The following definitions are taken from gnupg/tools/gpgconf-comp.c. */
1470 #define GC_OPT_FLAG_NONE 0UL
1471 #define GC_OPT_FLAG_DEFAULT (1UL << 4)
1472
1473 printf ("gpgconf-gpg.conf:%lu:\"%s\n",
1474 GC_OPT_FLAG_DEFAULT,configfile?configfile:"/dev/null");
1475 printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1476 printf ("quiet:%lu:\n", GC_OPT_FLAG_NONE);
1477 printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1478 printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
1479 }
1480
1481
1482 static int
1483 parse_subpacket_list(char *list)
1484 {
1485 char *tok;
1486 byte subpackets[128],i;
1487 int count=0;
1488
1489 if(!list)
1490 {
1491 /* No arguments means all subpackets */
1492 memset(subpackets+1,1,sizeof(subpackets)-1);
1493 count=127;
1494 }
1495 else
1496 {
1497 memset(subpackets,0,sizeof(subpackets));
1498
1499 /* Merge with earlier copy */
1500 if(opt.show_subpackets)
1501 {
1502 byte *in;
1503
1504 for(in=opt.show_subpackets;*in;in++)
1505 {
1506 if(*in>127 || *in<1)
1507 BUG();
1508
1509 if(!subpackets[*in])
1510 count++;
1511 subpackets[*in]=1;
1512 }
1513 }
1514
1515 while((tok=strsep(&list," ,")))
1516 {
1517 if(!*tok)
1518 continue;
1519
1520 i=atoi(tok);
1521 if(i>127 || i<1)
1522 return 0;
1523
1524 if(!subpackets[i])
1525 count++;
1526 subpackets[i]=1;
1527 }
1528 }
1529
1530 xfree(opt.show_subpackets);
1531 opt.show_subpackets=xmalloc(count+1);
1532 opt.show_subpackets[count--]=0;
1533
1534 for(i=1;i<128 && count>=0;i++)
1535 if(subpackets[i])
1536 opt.show_subpackets[count--]=i;
1537
1538 return 1;
1539 }
1540
1541
1542 static int
1543 parse_list_options(char *str)
1544 {
1545 char *subpackets=""; /* something that isn't NULL */
1546 struct parse_options lopts[]=
1547 {
1548 {"show-photos",LIST_SHOW_PHOTOS,NULL,
1549 N_("display photo IDs during key listings")},
1550 {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1551 N_("show policy URLs during signature listings")},
1552 {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1553 N_("show all notations during signature listings")},
1554 {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1555 N_("show IETF standard notations during signature listings")},
1556 {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1557 NULL},
1558 {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1559 N_("show user-supplied notations during signature listings")},
1560 {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1561 N_("show preferred keyserver URLs during signature listings")},
1562 {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1563 N_("show user ID validity during key listings")},
1564 {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1565 N_("show revoked and expired user IDs in key listings")},
1566 {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1567 N_("show revoked and expired subkeys in key listings")},
1568 {"show-keyring",LIST_SHOW_KEYRING,NULL,
1569 N_("show the keyring name in key listings")},
1570 {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1571 N_("show expiration dates during signature listings")},
1572 {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1573 NULL},
1574 {NULL,0,NULL,NULL}
1575 };
1576
1577 /* C99 allows for non-constant initializers, but we'd like to
1578 compile everywhere, so fill in the show-sig-subpackets argument
1579 here. Note that if the parse_options array changes, we'll have
1580 to change the subscript here. */
1581 lopts[12].value=&subpackets;
1582
1583 if(parse_options(str,&opt.list_options,lopts,1))
1584 {
1585 if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1586 {
1587 /* Unset so users can pass multiple lists in. */
1588 opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1589 if(!parse_subpacket_list(subpackets))
1590 return 0;
1591 }
1592 else if(subpackets==NULL && opt.show_subpackets)
1593 {
1594 /* User did 'no-show-subpackets' */
1595 xfree(opt.show_subpackets);
1596 opt.show_subpackets=NULL;
1597 }
1598
1599 return 1;
1600 }
1601 else
1602 return 0;
1603 }
1604
1605
1606 /* Collapses argc/argv into a single string that must be freed */
1607 static char *
1608 collapse_args(int argc,char *argv[])
1609 {
1610 char *str=NULL;
1611 int i,first=1,len=0;
1612
1613 for(i=0;i<argc;i++)
1614 {
1615 len+=strlen(argv[i])+2;
1616 str=xrealloc(str,len);
1617 if(first)
1618 {
1619 str[0]='\0';
1620 first=0;
1621 }
1622 else
1623 strcat(str," ");
1624
1625 strcat(str,argv[i]);
1626 }
1627
1628 return str;
1629 }
1630
1631 static void
1632 parse_trust_model(const char *model)
1633 {
1634 if(ascii_strcasecmp(model,"pgp")==0)
1635 opt.trust_model=TM_PGP;
1636 else if(ascii_strcasecmp(model,"classic")==0)
1637 opt.trust_model=TM_CLASSIC;
1638 else if(ascii_strcasecmp(model,"always")==0)
1639 opt.trust_model=TM_ALWAYS;
1640 else if(ascii_strcasecmp(model,"direct")==0)
1641 opt.trust_model=TM_DIRECT;
1642 else if(ascii_strcasecmp(model,"auto")==0)
1643 opt.trust_model=TM_AUTO;
1644 else
1645 log_error("unknown trust model `%s'\n",model);
1646 }
1647
1648
1649
1650 /* Make sure that the standard file descriptors are opened. Obviously
1651 some folks close them before an exec and the next file we open will
1652 get one of them assigned and thus any output (i.e. diagnostics) end
1653 up in that file (e.g. the trustdb). Not actually a gpg problem as
1654 this will hapenn with almost all utilities when called in a wrong
1655 way. However we try to minimize the damage here and raise
1656 awareness of the problem.
1657
1658 Must be called before we open any files! */
1659 static void
1660 reopen_std(void)
1661 {
1662 #if defined(HAVE_STAT) && !defined(HAVE_W32_SYSTEM)
1663 struct stat statbuf;
1664 int did_stdin=0,did_stdout=0,did_stderr=0;
1665 FILE *complain;
1666
1667 if(fstat(STDIN_FILENO,&statbuf)==-1 && errno==EBADF)
1668 {
1669 if(open("/dev/null",O_RDONLY)==STDIN_FILENO)
1670 did_stdin=1;
1671 else
1672 did_stdin=2;
1673 }
1674
1675 if(fstat(STDOUT_FILENO,&statbuf)==-1 && errno==EBADF)
1676 {
1677 if(open("/dev/null",O_WRONLY)==STDOUT_FILENO)
1678 did_stdout=1;
1679 else
1680 did_stdout=2;
1681 }
1682
1683 if(fstat(STDERR_FILENO,&statbuf)==-1 && errno==EBADF)
1684 {
1685 if(open("/dev/null",O_WRONLY)==STDERR_FILENO)
1686 did_stderr=1;
1687 else
1688 did_stderr=2;
1689 }
1690
1691 /* It's hard to log this sort of thing since the filehandle we would
1692 complain to may be closed... */
1693 if(did_stderr==0)
1694 complain=stderr;
1695 else if(did_stdout==0)
1696 complain=stdout;
1697 else
1698 complain=NULL;
1699
1700 if(complain)
1701 {
1702 if(did_stdin==1)
1703 fprintf(complain,"gpg: WARNING: standard input reopened\n");
1704 if(did_stdout==1)
1705 fprintf(complain,"gpg: WARNING: standard output reopened\n");
1706 if(did_stderr==1)
1707 fprintf(complain,"gpg: WARNING: standard error reopened\n");
1708
1709 if(did_stdin==2 || did_stdout==2 || did_stderr==2)
1710 fprintf(complain,"gpg: fatal: unable to reopen standard input,"
1711 " output, or error\n");
1712 }
1713
1714 if(did_stdin==2 || did_stdout==2 || did_stderr==2)
1715 exit(3);
1716 #endif /* HAVE_STAT && !HAVE_W32_SYSTEM */
1717 }
1718
1719
1720 int
1721 main (int argc, char **argv )
1722 {
1723 ARGPARSE_ARGS pargs;
1724 IOBUF a;
1725 int rc=0;
1726 int orig_argc;
1727 char **orig_argv;
1728 const char *fname;
1729 char *username;
1730 int may_coredump;
1731 STRLIST sl, remusr= NULL, locusr=NULL;
1732 STRLIST nrings=NULL, sec_nrings=NULL;
1733 armor_filter_context_t afx;
1734 int detached_sig = 0;
1735 FILE *configfp = NULL;
1736 char *configname = NULL;
1737 char *save_configname = NULL;
1738 unsigned configlineno;
1739 int parse_debug = 0;
1740 int default_config = 1;
1741 int default_keyring = 1;
1742 int greeting = 0;
1743 int nogreeting = 0;
1744 char *logfile = NULL;
1745 int use_random_seed = 1;
1746 enum cmd_and_opt_values cmd = 0;
1747 const char *debug_level = NULL;
1748 const char *trustdb_name = NULL;
1749 char *def_cipher_string = NULL;
1750 char *def_digest_string = NULL;
1751 char *compress_algo_string = NULL;
1752 char *cert_digest_string = NULL;
1753 char *s2k_cipher_string = NULL;
1754 char *s2k_digest_string = NULL;
1755 char *pers_cipher_list = NULL;
1756 char *pers_digest_list = NULL;
1757 char *pers_compress_list = NULL;
1758 int eyes_only=0;
1759 int multifile=0;
1760 int pwfd = -1;
1761 int with_fpr = 0; /* make an option out of --fingerprint */
1762 int any_explicit_recipient = 0;
1763 int require_secmem=0,got_secmem=0;
1764
1765 #ifdef __riscos__
1766 opt.lock_once = 1;
1767 #endif /* __riscos__ */
1768
1769
1770 /* Please note that we may running SUID(ROOT), so be very CAREFUL
1771 when adding any stuff between here and the call to
1772 secmem_init() somewhere after the option parsing. */
1773 reopen_std ();
1774 trap_unaligned();
1775 set_strusage (my_strusage);
1776 gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
1777 /* We don't need any locking in libgcrypt unless we use any kind of
1778 threading. */
1779 gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
1780 log_set_prefix ("gpg", 1);
1781
1782 /* Check that the libraries are suitable. Do it right here because the
1783 option parsing may need services of the library. */
1784 if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
1785 {
1786 log_fatal ( _("libgcrypt is too old (need %s, have %s)\n"),
1787 NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
1788 }
1789
1790 /* Put random number into secure memory */
1791 gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
1792
1793 may_coredump = disable_core_dumps();
1794
1795 gnupg_init_signals (0, emergency_cleanup);
1796
1797 create_dotlock(NULL); /* Register locking cleanup. */
1798
1799 i18n_init();
1800
1801 opt.command_fd = -1; /* no command fd */
1802 opt.compress_level = -1; /* defaults to standard compress level */
1803 opt.bz2_compress_level = -1; /* defaults to standard compress level */
1804 /* note: if you change these lines, look at oOpenPGP */
1805 opt.def_cipher_algo = 0;
1806 opt.def_digest_algo = 0;
1807 opt.cert_digest_algo = 0;
1808 opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
1809 opt.s2k_mode = 3; /* iterated+salted */
1810 #ifdef USE_CAST5
1811 opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1812 #else
1813 opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1814 #endif
1815 opt.completes_needed = 1;
1816 opt.marginals_needed = 3;
1817 opt.max_cert_depth = 5;
1818 opt.pgp2_workarounds = 1;
1819 opt.force_v3_sigs = 1;
1820 opt.escape_from = 1;
1821 opt.import_options=IMPORT_SK2PK;
1822 opt.export_options=EXPORT_ATTRIBUTES;
1823 opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1824 opt.keyserver_options.export_options=EXPORT_ATTRIBUTES;
1825 opt.keyserver_options.options=
1826 KEYSERVER_HONOR_KEYSERVER_URL|KEYSERVER_HONOR_PKA_RECORD;
1827 opt.verify_options=
1828 VERIFY_SHOW_POLICY_URLS|VERIFY_SHOW_STD_NOTATIONS|VERIFY_SHOW_KEYSERVER_URLS;
1829 opt.trust_model=TM_AUTO;
1830 opt.mangle_dos_filenames=0;
1831 opt.min_cert_level=2;
1832 set_screen_dimensions();
1833 opt.keyid_format=KF_SHORT;
1834 opt.rfc2440_text=1;
1835 opt.def_sig_expire="0";
1836 opt.def_cert_expire="0";
1837 set_homedir ( default_homedir () );
1838
1839 /* Check whether we have a config file on the command line. */
1840 orig_argc = argc;
1841 orig_argv = argv;
1842 pargs.argc = &argc;
1843 pargs.argv = &argv;
1844 pargs.flags= 1|(1<<6); /* do not remove the args, ignore version */
1845 while( arg_parse( &pargs, opts) ) {
1846 if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1847 parse_debug++;
1848 else if( pargs.r_opt == oOptions ) {
1849 /* yes there is one, so we do not try the default one, but
1850 * read the option file when it is encountered at the commandline
1851 */
1852 default_config = 0;
1853 }
1854 else if( pargs.r_opt == oNoOptions )
1855 default_config = 0; /* --no-options */
1856 else if( pargs.r_opt == oHomedir )
1857 set_homedir ( pargs.r.ret_str );
1858 else if( pargs.r_opt == oNoPermissionWarn )
1859 opt.no_perm_warn=1;
1860 else if (pargs.r_opt == oStrict )
1861 {
1862 /* Not used */
1863 }
1864 else if (pargs.r_opt == oNoStrict )
1865 {
1866 /* Not used */
1867 }
1868 }
1869
1870 #ifdef HAVE_DOSISH_SYSTEM
1871 if ( strchr (opt.homedir,'\\') ) {
1872 char *d, *buf = xmalloc (strlen (opt.homedir)+1);
1873 const char *s = opt.homedir;
1874 for (d=buf,s=opt.homedir; *s; s++)
1875 {
1876 *d++ = *s == '\\'? '/': *s;
1877 #ifdef HAVE_W32_SYSTEM
1878 if (s[1] && IsDBCSLeadByte (*s))
1879 *d++ = *++s;
1880 #endif
1881 }
1882 *d = 0;
1883 set_homedir (buf);
1884 }
1885 #endif
1886
1887 /* Initialize the secure memory. */
1888 gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
1889 got_secmem = 1; /* FIXME: gcry_control should return an indicator. */
1890 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
1891 /* There should be no way to get to this spot while still carrying
1892 setuid privs. Just in case, bomb out if we are. */
1893 if(getuid()!=geteuid())
1894 BUG();
1895 #endif
1896 maybe_setuid = 0;
1897
1898 /* Okay, we are now working under our real uid */
1899
1900 /* malloc hooks go here ... */
1901 assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
1902 assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
1903
1904
1905 set_native_charset (NULL); /* Try to auto set the character set */
1906
1907 /* Try for a version specific config file first */
1908 if( default_config )
1909 {
1910 char *name=xstrdup("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1911 char *ver=&name[strlen("gpg" EXTSEP_S "conf-")];
1912
1913 do
1914 {
1915 if(configname)
1916 {
1917 char *tok;
1918
1919 xfree(configname);
1920 configname=NULL;
1921
1922 if((tok=strrchr(ver,SAFE_VERSION_DASH)))
1923 *tok='\0';
1924 else if((tok=strrchr(ver,SAFE_VERSION_DOT)))
1925 *tok='\0';
1926 else
1927 break;
1928 }
1929
1930 configname = make_filename(opt.homedir,name,NULL);
1931 }
1932 while(access(configname,R_OK));
1933
1934 xfree(name);
1935
1936 if(!configname)
1937 configname=make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
1938 if (!access (configname, R_OK))
1939 { /* Print a warning when both config files are present. */
1940 char *p = make_filename(opt.homedir, "options", NULL );
1941 if (!access (p, R_OK))
1942 log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1943 xfree (p);
1944 }
1945 else
1946 { /* Keep on using the old default one. */
1947 xfree (configname);
1948 configname = make_filename(opt.homedir, "options", NULL );
1949 }
1950 }
1951 argc = orig_argc;
1952 argv = orig_argv;
1953 pargs.argc = &argc;
1954 pargs.argv = &argv;
1955 pargs.flags= 1; /* do not remove the args */
1956
1957 /* By this point we have a homedir, and cannot change it. */
1958 check_permissions(opt.homedir,0);
1959
1960 next_pass:
1961 if( configname ) {
1962 if(check_permissions(configname,1))
1963 {
1964 /* If any options file is unsafe, then disable any external
1965 programs for keyserver calls or photo IDs. Since the
1966 external program to call is set in the options file, a
1967 unsafe options file can lead to an arbitrary program
1968 being run. */
1969
1970 opt.exec_disable=1;
1971 }
1972
1973 configlineno = 0;
1974 configfp = fopen( configname, "r" );
1975 if (configfp && is_secured_file (fileno (configfp)))
1976 {
1977 fclose (configfp);
1978 configfp = NULL;
1979 errno = EPERM;
1980 }
1981 if( !configfp ) {
1982 if( default_config ) {
1983 if( parse_debug )
1984 log_info(_("NOTE: no default option file `%s'\n"),
1985 configname );
1986 }
1987 else {
1988 log_error(_("option file `%s': %s\n"),
1989 configname, strerror(errno) );
1990 g10_exit(2);
1991 }
1992 xfree(configname); configname = NULL;
1993 }
1994 if( parse_debug && configname )
1995 log_info(_("reading options from `%s'\n"), configname );
1996 default_config = 0;
1997 }
1998
1999 while( optfile_parse( configfp, configname, &configlineno,
2000 &pargs, opts) )
2001 {
2002 switch( pargs.r_opt )
2003 {
2004 case aCheckKeys:
2005 case aListConfig:
2006 case aGPGConfList:
2007 case aListPackets:
2008 case aImport:
2009 case aFastImport:
2010 case aSendKeys:
2011 case aRecvKeys:
2012 case aSearchKeys:
2013 case aRefreshKeys:
2014 case aFetchKeys:
2015 case aExport:
2016 #ifdef ENABLE_CARD_SUPPORT
2017 case aCardStatus:
2018 case aCardEdit:
2019 case aChangePIN:
2020 #endif /* ENABLE_CARD_SUPPORT*/
2021 set_cmd (&cmd, pargs.r_opt);
2022 break;
2023
2024 case aListKeys: set_cmd( &cmd, aListKeys); break;
2025 case aListSigs: set_cmd( &cmd, aListSigs); break;
2026 case aExportSecret: set_cmd( &cmd, aExportSecret); break;
2027 case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
2028 case aDeleteSecretKeys:
2029 set_cmd( &cmd, aDeleteSecretKeys);
2030 greeting=1;
2031 break;
2032 case aDeleteSecretAndPublicKeys:
2033 set_cmd( &cmd, aDeleteSecretAndPublicKeys);
2034 greeting=1;
2035 break;
2036 case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
2037
2038 case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2039 case aSym: set_cmd( &cmd, aSym); break;
2040
2041 case aDecryptFiles: multifile=1; /* fall through */
2042 case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2043
2044 case aEncrFiles: multifile=1; /* fall through */
2045 case aEncr: set_cmd( &cmd, aEncr); break;
2046
2047 case aVerifyFiles: multifile=1; /* fall through */
2048 case aVerify: set_cmd( &cmd, aVerify); break;
2049
2050 case aSign: set_cmd( &cmd, aSign ); break;
2051 case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
2052 case aSignKey: set_cmd( &cmd, aSignKey); break;
2053 case aLSignKey: set_cmd( &cmd, aLSignKey); break;
2054 case aStore: set_cmd( &cmd, aStore); break;
2055 case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
2056 case aClearsign: set_cmd( &cmd, aClearsign); break;
2057 case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
2058 case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
2059 case aPrimegen: set_cmd( &cmd, aPrimegen); break;
2060 case aGenRandom: set_cmd( &cmd, aGenRandom); break;
2061 case aPrintMD: set_cmd( &cmd, aPrintMD); break;
2062 case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
2063 case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
2064 case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
2065 case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
2066 case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
2067 case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
2068 case aDeArmor: set_cmd( &cmd, aDeArmor); break;
2069 case aEnArmor: set_cmd( &cmd, aEnArmor); break;
2070 case aListOwnerTrust:
2071 deprecated_warning(configname,configlineno,
2072 "--list-ownertrust","--export-ownertrust","");
2073 case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
2074 case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
2075 case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
2076
2077 case oArmor: opt.armor = 1; opt.no_armor=0; break;
2078 case oOutput: opt.outfile = pargs.r.ret_str; break;
2079 case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2080 case oQuiet: opt.quiet = 1; break;
2081 case oNoTTY: tty_no_terminal(1); break;
2082 case oDryRun: opt.dry_run = 1; break;
2083 case oInteractive: opt.interactive = 1; break;
2084 case oVerbose:
2085 opt.verbose++;
2086 gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2087 opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2088 opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2089 break;
2090 case oKOption: set_cmd( &cmd, aKMode ); break;
2091
2092 case oBatch: opt.batch = 1; nogreeting = 1; break;
2093 case oUseAgent:
2094 #ifndef __riscos__
2095 opt.use_agent = 1;
2096 #else /* __riscos__ */
2097 opt.use_agent = 0;
2098 riscos_not_implemented("use-agent");
2099 #endif /* __riscos__ */
2100 break;
2101 case oNoUseAgent: opt.use_agent = 0; break;
2102 case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
2103 case oAnswerYes: opt.answer_yes = 1; break;
2104 case oAnswerNo: opt.answer_no = 1; break;
2105 case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2106 case oPrimaryKeyring:
2107 sl=append_to_strlist( &nrings, pargs.r.ret_str);
2108 sl->flags=2;
2109 break;
2110 case oShowKeyring:
2111 deprecated_warning(configname,configlineno,"--show-keyring",
2112 "--list-options ","show-keyring");
2113 opt.list_options|=LIST_SHOW_KEYRING;
2114 break;
2115
2116 case oDebug: opt.debug |= pargs.r.ret_ulong; break;
2117 case oDebugAll: opt.debug = ~0; break;
2118 case oDebugLevel: debug_level = pargs.r.ret_str; break;
2119
2120 case oStatusFD:
2121 set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
2122 break;
2123 case oStatusFile:
2124 set_status_fd ( open_info_file (pargs.r.ret_str, 1) );
2125 break;
2126 case oAttributeFD:
2127 set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
2128 break;
2129 case oAttributeFile:
2130 set_attrib_fd ( open_info_file (pargs.r.ret_str, 1) );
2131 break;
2132 case oLoggerFD:
2133 log_set_fd (iobuf_translate_file_handle (pargs.r.ret_int, 1));
2134 break;
2135 case oLoggerFile:
2136 logfile = pargs.r.ret_str;
2137 break;
2138
2139 case oWithFingerprint:
2140 opt.with_fingerprint = 1;
2141 with_fpr=1; /*fall thru*/
2142 case oFingerprint: opt.fingerprint++; break;
2143 case oSecretKeyring:
2144 append_to_strlist( &sec_nrings, pargs.r.ret_str);
2145 break;
2146 case oOptions:
2147 /* config files may not be nested (silently ignore them) */
2148 if( !configfp ) {
2149 xfree(configname);
2150 configname = xstrdup(pargs.r.ret_str);
2151 goto next_pass;
2152 }
2153 break;
2154 case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2155 case oNoDefKeyring: default_keyring = 0; break;
2156 case oNoGreeting: nogreeting = 1; break;
2157 case oNoVerbose:
2158 opt.verbose = 0;
2159 gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2160 opt.list_sigs=0;
2161 break;
2162 case oQuickRandom:
2163 gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2164 break;
2165 case oEmitVersion: opt.no_version=0; break;
2166 case oNoEmitVersion: opt.no_version=1; break;
2167 case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2168 case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2169 case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2170 case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2171 case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
2172 case oDefRecipient:
2173 if( *pargs.r.ret_str )
2174 opt.def_recipient = make_username(pargs.r.ret_str);
2175 break;
2176 case oDefRecipientSelf:
2177 xfree(opt.def_recipient); opt.def_recipient = NULL;
2178 opt.def_recipient_self = 1;
2179 break;
2180 case oNoDefRecipient:
2181 xfree(opt.def_recipient); opt.def_recipient = NULL;
2182 opt.def_recipient_self = 0;
2183 break;
2184 case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2185 case oHomedir: break;
2186 case oNoBatch: opt.batch = 0; break;
2187 case oWithKeyData: opt.with_key_data=1; /* fall thru */
2188 case oWithColons: opt.with_colons=':'; break;
2189
2190 case oSkipVerify: opt.skip_verify=1; break;
2191 case oCompressKeys: opt.compress_keys = 1; break;
2192 case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2193 /* There are many programs (like mutt) that call gpg with
2194 --always-trust so keep this option around for a long
2195 time. */
2196 case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2197 case oTrustModel:
2198 parse_trust_model(pargs.r.ret_str);
2199 break;
2200 case oForceOwnertrust:
2201 log_info(_("NOTE: %s is not for normal use!\n"),
2202 "--force-ownertrust");
2203 opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2204 if(opt.force_ownertrust==-1)
2205 {
2206 log_error("invalid ownertrust `%s'\n",pargs.r.ret_str);
2207 opt.force_ownertrust=0;
2208 }
2209 break;
2210 case oLoadExtension:
2211 #ifndef __riscos__
2212 #if defined(USE_DYNAMIC_LINKING) || defined(_WIN32)
2213 if(check_permissions(pargs.r.ret_str,2))
2214 log_info(_("cipher extension `%s' not loaded due to"
2215 " unsafe permissions\n"),pargs.r.ret_str);
2216 else
2217 register_cipher_extension(orig_argc? *orig_argv:NULL,
2218 pargs.r.ret_str);
2219 #endif
2220 #else /* __riscos__ */
2221 riscos_not_implemented("load-extension");
2222 #endif /* __riscos__ */
2223 break;
2224 case oRFC1991:
2225 opt.compliance = CO_RFC1991;
2226 opt.force_v4_certs = 0;
2227 opt.escape_from = 1;
2228 break;
2229 case oOpenPGP:
2230 case oRFC2440:
2231 /* TODO: When 2440bis becomes a RFC, set new values for
2232 oOpenPGP. */
2233 opt.rfc2440_text=1;
2234 opt.compliance = CO_RFC2440;
2235 opt.allow_non_selfsigned_uid = 1;
2236 opt.allow_freeform_uid = 1;
2237 opt.pgp2_workarounds = 0;
2238 opt.escape_from = 0;
2239 opt.force_v3_sigs = 0;
2240 opt.compress_keys = 0; /* not mandated, but we do it */
2241 opt.compress_sigs = 0; /* ditto. */
2242 opt.not_dash_escaped = 0;
2243 opt.def_cipher_algo = 0;
2244 opt.def_digest_algo = 0;
2245 opt.cert_digest_algo = 0;
2246 opt.compress_algo = -1;
2247 opt.s2k_mode = 3; /* iterated+salted */
2248 opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2249 opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2250 break;
2251 case oPGP2: opt.compliance = CO_PGP2; break;
2252 case oPGP6: opt.compliance = CO_PGP6; break;
2253 case oPGP7: opt.compliance = CO_PGP7; break;
2254 case oPGP8: opt.compliance = CO_PGP8; break;
2255 case oGnuPG: opt.compliance = CO_GNUPG; break;
2256 case oCompressSigs: opt.compress_sigs = 1; break;
2257 case oRFC2440Text: opt.rfc2440_text=1; break;
2258 case oNoRFC2440Text: opt.rfc2440_text=0; break;
2259 case oSetFilename:
2260 if(utf8_strings)
2261 opt.set_filename = pargs.r.ret_str;
2262 else
2263 opt.set_filename = native_to_utf8(pargs.r.ret_str);
2264 break;
2265 case oForYourEyesOnly: eyes_only = 1; break;
2266 case oNoForYourEyesOnly: eyes_only = 0; break;
2267 case oSetPolicyURL:
2268 add_policy_url(pargs.r.ret_str,0);
2269 add_policy_url(pargs.r.ret_str,1);
2270 break;
2271 case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2272 case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2273 case oShowPolicyURL:
2274 deprecated_warning(configname,configlineno,"--show-policy-url",
2275 "--list-options ","show-policy-urls");
2276 deprecated_warning(configname,configlineno,"--show-policy-url",
2277 "--verify-options ","show-policy-urls");
2278 opt.list_options|=LIST_SHOW_POLICY_URLS;
2279 opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2280 break;
2281 case oNoShowPolicyURL:
2282 deprecated_warning(configname,configlineno,"--no-show-policy-url",
2283 "--list-options ","no-show-policy-urls");
2284 deprecated_warning(configname,configlineno,"--no-show-policy-url",
2285 "--verify-options ","no-show-policy-urls");
2286 opt.list_options&=~LIST_SHOW_POLICY_URLS;
2287 opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2288 break;
2289 case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2290 case oUseEmbeddedFilename:
2291 opt.flags.use_embedded_filename=1;
2292 break;
2293 case oNoUseEmbeddedFilename:
2294 opt.flags.use_embedded_filename=0;
2295 break;
2296 case oComment:
2297 if(pargs.r.ret_str[0])
2298 append_to_strlist(&opt.comments,pargs.r.ret_str);
2299 break;
2300 case oDefaultComment:
2301 deprecated_warning(configname,configlineno,
2302 "--default-comment","--no-comments","");
2303 /* fall through */
2304 case oNoComments:
2305 free_strlist(opt.comments);
2306 opt.comments=NULL;
2307 break;
2308 case oThrowKeyids: opt.throw_keyid = 1; break;
2309 case oNoThrowKeyids: opt.throw_keyid = 0; break;
2310 case oShowPhotos:
2311 deprecated_warning(configname,configlineno,"--show-photos",
2312 "--list-options ","show-photos");
2313 deprecated_warning(configname,configlineno,"--show-photos",
2314 "--verify-options ","show-photos");
2315 opt.list_options|=LIST_SHOW_PHOTOS;
2316 opt.verify_options|=VERIFY_SHOW_PHOTOS;
2317 break;
2318 case oNoShowPhotos:
2319 deprecated_warning(configname,configlineno,"--no-show-photos",
2320 "--list-options ","no-show-photos");
2321 deprecated_warning(configname,configlineno,"--no-show-photos",
2322 "--verify-options ","no-show-photos");
2323 opt.list_options&=~LIST_SHOW_PHOTOS;
2324 opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2325 break;
2326 case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2327 case oForceV3Sigs: opt.force_v3_sigs = 1; break;
2328 case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
2329 case oForceV4Certs: opt.force_v4_certs = 1; break;
2330 case oNoForceV4Certs: opt.force_v4_certs = 0; break;
2331 case oForceMDC: opt.force_mdc = 1; break;
2332 case oNoForceMDC: opt.force_mdc = 0; break;
2333 case oDisableMDC: opt.disable_mdc = 1; break;
2334 case oNoDisableMDC: opt.disable_mdc = 0; break;
2335 case oS2KMode: opt.s2k_mode = pargs.r.ret_int; break;
2336 case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2337 case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2338 case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
2339 case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2340 case oEncryptTo: /* store the recipient in the second list */
2341 sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2342 sl->flags = 1;
2343 break;
2344 case oHiddenEncryptTo: /* store the recipient in the second list */
2345 sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2346 sl->flags = 1|2;
2347 break;
2348 case oRecipient: /* store the recipient */
2349 add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2350 any_explicit_recipient = 1;
2351 break;
2352 case oHiddenRecipient: /* store the recipient with a flag */
2353 sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2354 sl->flags = 2;
2355 any_explicit_recipient = 1;
2356 break;
2357 case oTextmodeShort: opt.textmode = 2; break;
2358 case oTextmode: opt.textmode=1; break;
2359 case oNoTextmode: opt.textmode=0; break;
2360 case oExpert: opt.expert = 1; break;
2361 case oNoExpert: opt.expert = 0; break;
2362 case oDefSigExpire:
2363 if(*pargs.r.ret_str!='\0')
2364 {
2365 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2366 log_error(_("`%s' is not a valid signature expiration\n"),
2367 pargs.r.ret_str);
2368 else
2369 opt.def_sig_expire=pargs.r.ret_str;
2370 }
2371 break;
2372 case oAskSigExpire: opt.ask_sig_expire = 1; break;
2373 case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2374 case oDefCertExpire:
2375 if(*pargs.r.ret_str!='\0')
2376 {
2377 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2378 log_error(_("`%s' is not a valid signature expiration\n"),
2379 pargs.r.ret_str);
2380 else
2381 opt.def_cert_expire=pargs.r.ret_str;
2382 }
2383 break;
2384 case oAskCertExpire: opt.ask_cert_expire = 1; break;
2385 case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2386 case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2387 case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2388 case oAskCertLevel: opt.ask_cert_level = 1; break;
2389 case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2390 case oLocalUser: /* store the local users */
2391 add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2392 break;
2393 case oCompress:
2394 /* this is the -z command line option */
2395 opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2396 break;
2397 case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2398 case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2399 case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2400 case oPasswd:
2401 set_passphrase_from_string(pargs.r.ret_str);
2402 break;
2403 case oPasswdFD:
2404 pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2405 opt.use_agent = 0;
2406 break;
2407 case oPasswdFile:
2408 pwfd = open_info_file (pargs.r.ret_str, 0);
2409 break;
2410 case oCommandFD:
2411 opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2412 break;
2413 case oCommandFile:
2414 opt.command_fd = open_info_file (pargs.r.ret_str, 0);
2415 break;
2416 case oCipherAlgo:
2417 def_cipher_string = xstrdup(pargs.r.ret_str);
2418 break;
2419 case oDigestAlgo:
2420 def_digest_string = xstrdup(pargs.r.ret_str);
2421 break;
2422 case oCompressAlgo:
2423 /* If it is all digits, stick a Z in front of it for
2424 later. This is for backwards compatibility with
2425 versions that took the compress algorithm number. */
2426 {
2427 char *pt=pargs.r.ret_str;
2428 while(*pt)
2429 {
2430 if (!isascii (*pt) || !isdigit (*pt))
2431 break;
2432
2433 pt++;
2434 }
2435
2436 if(*pt=='\0')
2437 {
2438 compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2439 strcpy(compress_algo_string,"Z");
2440 strcat(compress_algo_string,pargs.r.ret_str);
2441 }
2442 else
2443 compress_algo_string = xstrdup(pargs.r.ret_str);
2444 }
2445 break;
2446 case oCertDigestAlgo:
2447 cert_digest_string = xstrdup(pargs.r.ret_str);
2448 break;
2449
2450 case oNoSecmemWarn:
2451 gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
2452 break;
2453
2454 case oRequireSecmem: require_secmem=1; break;
2455 case oNoRequireSecmem: require_secmem=0; break;
2456 case oNoPermissionWarn: opt.no_perm_warn=1; break;
2457 case oNoMDCWarn: opt.no_mdc_warn=1; break;
2458 case oDisplayCharset:
2459 if( set_native_charset( pargs.r.ret_str ) )
2460 log_error(_("`%s' is not a valid character set\n"),
2461 pargs.r.ret_str);
2462 break;
2463 case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2464 case oEscapeFrom: opt.escape_from = 1; break;
2465 case oNoEscapeFrom: opt.escape_from = 0; break;
2466 case oLockOnce: opt.lock_once = 1; break;
2467 case oLockNever:
2468 disable_dotlock ();
2469 break;
2470 case oLockMultiple:
2471 #ifndef __riscos__
2472 opt.lock_once = 0;
2473 #else /* __riscos__ */
2474 riscos_not_implemented("lock-multiple");
2475 #endif /* __riscos__ */
2476 break;
2477 case oKeyServer:
2478 {
2479 struct keyserver_spec *keyserver;
2480 keyserver=parse_keyserver_uri(pargs.r.ret_str,0,
2481 configname,configlineno);
2482 if(!keyserver)
2483 log_error(_("could not parse keyserver URL\n"));
2484 else
2485 {
2486 keyserver->next=opt.keyserver;
2487 opt.keyserver=keyserver;
2488 }
2489 }
2490 break;
2491 case oKeyServerOptions:
2492 if(!parse_keyserver_options(pargs.r.ret_str))
2493 {
2494 if(configname)
2495 log_error(_("%s:%d: invalid keyserver options\n"),
2496 configname,configlineno);
2497 else
2498 log_error(_("invalid keyserver options\n"));
2499 }
2500 break;
2501 case oImportOptions:
2502 if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2503 {
2504 if(configname)
2505 log_error(_("%s:%d: invalid import options\n"),
2506 configname,configlineno);
2507 else
2508 log_error(_("invalid import options\n"));
2509 }
2510 break;
2511 case oExportOptions:
2512 if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2513 {
2514 if(configname)
2515 log_error(_("%s:%d: invalid export options\n"),
2516 configname,configlineno);
2517 else
2518 log_error(_("invalid export options\n"));
2519 }
2520 break;
2521 case oListOptions:
2522 if(!parse_list_options(pargs.r.ret_str))
2523 {
2524 if(configname)
2525 log_error(_("%s:%d: invalid list options\n"),
2526 configname,configlineno);
2527 else
2528 log_error(_("invalid list options\n"));
2529 }
2530 break;
2531 case oVerifyOptions:
2532 {
2533 struct parse_options vopts[]=
2534 {
2535 {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
2536 N_("display photo IDs during signature verification")},
2537 {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
2538 N_("show policy URLs during signature verification")},
2539 {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
2540 N_("show all notations during signature verification")},
2541 {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2542 N_("show IETF standard notations during signature verification")},
2543 {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2544 NULL},
2545 {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
2546 N_("show user-supplied notations during signature verification")},
2547 {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
2548 N_("show preferred keyserver URLs during signature verification")},
2549 {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
2550 N_("show user ID validity during signature verification")},
2551 {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
2552 N_("show revoked and expired user IDs in signature verification")},
2553 {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
2554 N_("validate signatures with PKA data")},
2555 {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
2556 N_("elevate the trust of signatures with valid PKA data")},
2557 {NULL,0,NULL,NULL}
2558 };
2559
2560 if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2561 {
2562 if(configname)
2563 log_error(_("%s:%d: invalid verify options\n"),
2564 configname,configlineno);
2565 else
2566 log_error(_("invalid verify options\n"));
2567 }
2568 }
2569 break;
2570 case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2571 case oExecPath:
2572 if(set_exec_path(pargs.r.ret_str))
2573 log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2574 else
2575 opt.exec_path_set=1;
2576 break;
2577 case oSetNotation:
2578 add_notation_data( pargs.r.ret_str, 0 );
2579 add_notation_data( pargs.r.ret_str, 1 );
2580 break;
2581 case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2582 case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2583 case oShowNotation:
2584 deprecated_warning(configname,configlineno,"--show-notation",
2585 "--list-options ","show-notations");
2586 deprecated_warning(configname,configlineno,"--show-notation",
2587 "--verify-options ","show-notations");
2588 opt.list_options|=LIST_SHOW_NOTATIONS;
2589 opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2590 break;
2591 case oNoShowNotation:
2592 deprecated_warning(configname,configlineno,"--no-show-notation",
2593 "--list-options ","no-show-notations");
2594 deprecated_warning(configname,configlineno,"--no-show-notation",
2595 "--verify-options ","no-show-notations");
2596 opt.list_options&=~LIST_SHOW_NOTATIONS;
2597 opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2598 break;
2599 case oUtf8Strings: utf8_strings = 1; break;
2600 case oNoUtf8Strings: utf8_strings = 0; break;
2601 case oDisableCipherAlgo:
2602 {
2603 int algo = string_to_cipher_algo (pargs.r.ret_str);
2604 gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2605 }
2606 break;
2607 case oDisablePubkeyAlgo:
2608 {
2609 int algo = gcry_pk_map_name (pargs.r.ret_str);
2610 gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2611 }
2612 break;
2613 case oNoSigCache: opt.no_sig_cache = 1; break;
2614 case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2615 case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2616 case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2617 case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2618 case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2619 case oNoLiteral: opt.no_literal = 1; break;
2620 case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2621 case oHonorHttpProxy:
2622 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2623 deprecated_warning(configname,configlineno,
2624 "--honor-http-proxy",
2625 "--keyserver-options ","http-proxy");
2626 break;
2627 case oFastListMode: opt.fast_list_mode = 1; break;
2628 case oFixedListMode: opt.fixed_list_mode = 1; break;
2629 case oListOnly: opt.list_only=1; break;
2630 case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2631 case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2632 case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2633 case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2634 case oNoRandomSeedFile: use_random_seed = 0; break;
2635 case oAutoKeyRetrieve:
2636 case oNoAutoKeyRetrieve:
2637 if(pargs.r_opt==oAutoKeyRetrieve)
2638 opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2639 else
2640 opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2641
2642 deprecated_warning(configname,configlineno,
2643 pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2644 "--no-auto-key-retrieve","--keyserver-options ",
2645 pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2646 "no-auto-key-retrieve");
2647 break;
2648 case oShowSessionKey: opt.show_session_key = 1; break;
2649 case oOverrideSessionKey:
2650 opt.override_session_key = pargs.r.ret_str;
2651 break;
2652 case oMergeOnly:
2653 deprecated_warning(configname,configlineno,"--merge-only",
2654 "--import-options ","merge-only");
2655 opt.import_options|=IMPORT_MERGE_ONLY;
2656 break;
2657 case oAllowSecretKeyImport: /* obsolete */ break;
2658 case oTryAllSecrets: opt.try_all_secrets = 1; break;
2659 case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2660 case oEnableSpecialFilenames:
2661 iobuf_enable_special_filenames (1);
2662 break;
2663 case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2664 case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2665 case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2666 case oPreservePermissions: opt.preserve_permissions=1; break;
2667 case oDefaultPreferenceList:
2668 opt.def_preference_list = pargs.r.ret_str;
2669 break;
2670 case oDefaultKeyserverURL:
2671 {
2672 struct keyserver_spec *keyserver;
2673 keyserver=parse_keyserver_uri(pargs.r.ret_str,1,
2674 configname,configlineno);
2675 if(!keyserver)
2676 log_error(_("could not parse keyserver URL\n"));
2677 else
2678 free_keyserver_spec(keyserver);
2679
2680 opt.def_keyserver_url = pargs.r.ret_str;
2681 }
2682 break;
2683 case oPersonalCipherPreferences:
2684 pers_cipher_list=pargs.r.ret_str;
2685 break;
2686 case oPersonalDigestPreferences:
2687 pers_digest_list=pargs.r.ret_str;
2688 break;
2689 case oPersonalCompressPreferences:
2690 pers_compress_list=pargs.r.ret_str;
2691 break;
2692 case oAgentProgram: opt.agent_program = pargs.r.ret_str; break;
2693 case oDisplay: opt.display = pargs.r.ret_str; break;
2694 case oTTYname: opt.ttyname = pargs.r.ret_str; break;
2695 case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
2696 case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2697 case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2698 case oGroup: add_group(pargs.r.ret_str); break;
2699 case oUnGroup: rm_group(pargs.r.ret_str); break;
2700 case oNoGroups:
2701 while(opt.grouplist)
2702 {
2703 struct groupitem *iter=opt.grouplist;
2704 free_strlist(iter->values);
2705 opt.grouplist=opt.grouplist->next;
2706 xfree(iter);
2707 }
2708 break;
2709
2710 case oStrict:
2711 case oNoStrict:
2712 /* Not used */
2713 break;
2714
2715 case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2716 case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2717 case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2718 case oMultifile: multifile=1; break;
2719 case oKeyidFormat:
2720 if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2721 opt.keyid_format=KF_SHORT;
2722 else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2723 opt.keyid_format=KF_LONG;
2724 else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2725 opt.keyid_format=KF_0xSHORT;
2726 else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2727 opt.keyid_format=KF_0xLONG;
2728 else
2729 log_error("unknown keyid-format `%s'\n",pargs.r.ret_str);
2730 break;
2731
2732 case oExitOnStatusWriteError:
2733 opt.exit_on_status_write_error = 1;
2734 break;
2735
2736 case oLimitCardInsertTries:
2737 opt.limit_card_insert_tries = pargs.r.ret_int;
2738 break;
2739
2740 case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
2741 case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
2742
2743 case oAutoKeyLocate:
2744 if(!parse_auto_key_locate(pargs.r.ret_str))
2745 {
2746 if(configname)
2747 log_error(_("%s:%d: invalid auto-key-locate list\n"),
2748 configname,configlineno);
2749 else
2750 log_error(_("invalid auto-key-locate list\n"));
2751 }
2752 break;
2753 case oNoAutoKeyLocate:
2754 release_akl();
2755 break;
2756
2757 case oAllowMultisigVerification:
2758 opt.allow_multisig_verification = 1;
2759 break;
2760
2761 case oEnableDSA2: opt.flags.dsa2=1; break;
2762 case oDisableDSA2: opt.flags.dsa2=0; break;
2763
2764 case oNoop: break;
2765
2766 default : pargs.err = configfp? 1:2; break;
2767 }
2768 }
2769
2770
2771 if( configfp ) {
2772 fclose( configfp );
2773 configfp = NULL;
2774 /* Remember the first config file name. */
2775 if (!save_configname)
2776 save_configname = configname;
2777 else
2778 xfree(configname);
2779 configname = NULL;
2780 goto next_pass;
2781 }
2782 xfree( configname ); configname = NULL;
2783 if( log_get_errorcount(0) )
2784 g10_exit(2);
2785
2786 /* The command --gpgconf-list is pretty simple and may be called
2787 directly after the option parsing. */
2788 if (cmd == aGPGConfList)
2789 {
2790 gpgconf_list (save_configname);
2791 g10_exit (0);
2792 }
2793 xfree (save_configname);
2794
2795 if( nogreeting )
2796 greeting = 0;
2797
2798 if( greeting ) {
2799 fprintf(stderr, "%s %s; %s\n",
2800 strusage(11), strusage(13), strusage(14) );
2801 fprintf(stderr, "%s\n", strusage(15) );
2802 }
2803 #ifdef IS_DEVELOPMENT_VERSION
2804 if( !opt.batch )
2805 {
2806 const char *s;
2807
2808 if((s=strusage(20)))
2809 log_info("%s\n",s);
2810 if((s=strusage(21)))
2811 log_info("%s\n",s);
2812 if((s=strusage(22)))
2813 log_info("%s\n",s);
2814 }
2815 #endif
2816
2817 log_info ("WARNING: This version of gpg is not ready for use, use gpg 1.4.x\n");
2818
2819 /* FIXME: We should use logging to a file only in server mode;
2820 however we have not yet implemetyed that. Thus we try to get
2821 away with --batch as indication for logging to file
2822 required. */
2823 if (logfile && opt.batch)
2824 {
2825 log_set_file (logfile);
2826 log_set_prefix (NULL, 1|2|4);
2827 }
2828
2829 if (opt.verbose > 2)
2830 log_info ("using character set `%s'\n", get_native_charset ());
2831
2832 if( may_coredump && !opt.quiet )
2833 log_info(_("WARNING: program may create a core file!\n"));
2834
2835 if (eyes_only) {
2836 if (opt.set_filename)
2837 log_info(_("WARNING: %s overrides %s\n"),
2838 "--for-your-eyes-only","--set-filename");
2839
2840 opt.set_filename="_CONSOLE";
2841 }
2842
2843 if (opt.no_literal) {
2844 log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2845 if (opt.textmode)
2846 log_error(_("%s not allowed with %s!\n"),
2847 "--textmode", "--no-literal" );
2848 if (opt.set_filename)
2849 log_error(_("%s makes no sense with %s!\n"),
2850 eyes_only?"--for-your-eyes-only":"--set-filename",
2851 "--no-literal" );
2852 }
2853
2854
2855 if (opt.set_filesize)
2856 log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2857 if( opt.batch )
2858 tty_batchmode( 1 );
2859
2860 gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
2861
2862 if(require_secmem && !got_secmem)
2863 {
2864 log_info(_("will not run with insecure memory due to %s\n"),
2865 "--require-secmem");
2866 g10_exit(2);
2867 }
2868
2869 set_debug (debug_level);
2870
2871 /* Do these after the switch(), so they can override settings. */
2872 if(PGP2)
2873 {
2874 int unusable=0;
2875
2876 if(cmd==aSign && !detached_sig)
2877 {
2878 log_info(_("you can only make detached or clear signatures "
2879 "while in --pgp2 mode\n"));
2880 unusable=1;
2881 }
2882 else if(cmd==aSignEncr || cmd==aSignSym)
2883 {
2884 log_info(_("you can't sign and encrypt at the "
2885 "same time while in --pgp2 mode\n"));
2886 unusable=1;
2887 }
2888 else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2889 {
2890 log_info(_("you must use files (and not a pipe) when "
2891 "working with --pgp2 enabled.\n"));
2892 unusable=1;
2893 }
2894 else if(cmd==aEncr || cmd==aSym)
2895 {
2896 /* Everything else should work without IDEA (except using
2897 a secret key encrypted with IDEA and setting an IDEA
2898 preference, but those have their own error
2899 messages). */
2900
2901 if (openpgp_cipher_test_algo(CIPHER_ALGO_IDEA))
2902 {
2903 log_info(_("encrypting a message in --pgp2 mode requires "
2904 "the IDEA cipher\n"));
2905 idea_cipher_warn(1);
2906 unusable=1;
2907 }
2908 else if(cmd==aSym)
2909 {
2910 /* This only sets IDEA for symmetric encryption
2911 since it is set via select_algo_from_prefs for
2912 pk encryption. */
2913 xfree(def_cipher_string);
2914 def_cipher_string = xstrdup("idea");
2915 }
2916
2917 /* PGP2 can't handle the output from the textmode
2918 filter, so we disable it for anything that could
2919 create a literal packet (only encryption and
2920 symmetric encryption, since we disable signing
2921 above). */
2922 if(!unusable)
2923 opt.textmode=0;
2924 }
2925
2926 if(unusable)
2927 compliance_failure();
2928 else
2929 {
2930 opt.force_v4_certs = 0;
2931 opt.escape_from = 1;
2932 opt.force_v3_sigs = 1;
2933 opt.pgp2_workarounds = 1;
2934 opt.ask_sig_expire = 0;
2935 opt.ask_cert_expire = 0;
2936 xfree(def_digest_string);
2937 def_digest_string = xstrdup("md5");
2938 xfree(s2k_digest_string);
2939 s2k_digest_string = xstrdup("md5");
2940 opt.compress_algo = COMPRESS_ALGO_ZIP;
2941 }
2942 }
2943 else if(PGP6)
2944 {
2945 opt.escape_from=1;
2946 opt.force_v3_sigs=1;
2947 opt.ask_sig_expire=0;
2948 }
2949 else if(PGP7)
2950 {
2951 opt.escape_from=1;
2952 opt.force_v3_sigs=1;
2953 opt.ask_sig_expire=0;
2954 }
2955 else if(PGP8)
2956 {
2957 opt.escape_from=1;
2958 }
2959
2960
2961 if( def_cipher_string ) {
2962 opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
2963 if(opt.def_cipher_algo==0 &&
2964 (ascii_strcasecmp(def_cipher_string,"idea")==0
2965 || ascii_strcasecmp(def_cipher_string,"s1")==0))
2966 idea_cipher_warn(1);
2967 xfree(def_cipher_string); def_cipher_string = NULL;
2968 if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
2969 log_error(_("selected cipher algorithm is invalid\n"));
2970 }
2971 if( def_digest_string ) {
2972 opt.def_digest_algo = string_to_digest_algo (def_digest_string);
2973 xfree(def_digest_string); def_digest_string = NULL;
2974 if ( openpgp_md_test_algo (opt.def_digest_algo) )
2975 log_error(_("selected digest algorithm is invalid\n"));
2976 }
2977 if( compress_algo_string ) {
2978 opt.compress_algo = string_to_compress_algo(compress_algo_string);
2979 xfree(compress_algo_string); compress_algo_string = NULL;
2980 if( check_compress_algo(opt.compress_algo) )
2981 log_error(_("selected compression algorithm is invalid\n"));
2982 }
2983 if( cert_digest_string ) {
2984 opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
2985 xfree(cert_digest_string); cert_digest_string = NULL;
2986 if (openpgp_md_test_algo(opt.cert_digest_algo))
2987 log_error(_("selected certification digest algorithm is invalid\n"));
2988 }
2989 if( s2k_cipher_string ) {
2990 opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
2991 xfree(s2k_cipher_string); s2k_cipher_string = NULL;
2992 if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
2993 log_error(_("selected cipher algorithm is invalid\n"));
2994 }
2995 if( s2k_digest_string ) {
2996 opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
2997 xfree(s2k_digest_string); s2k_digest_string = NULL;
2998 if (openpgp_md_test_algo(opt.s2k_digest_algo))
2999 log_error(_("selected digest algorithm is invalid\n"));
3000 }
3001 if( opt.completes_needed < 1 )
3002 log_error(_("completes-needed must be greater than 0\n"));
3003 if( opt.marginals_needed < 2 )
3004 log_error(_("marginals-needed must be greater than 1\n"));
3005 if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3006 log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3007 if(opt.def_cert_level<0 || opt.def_cert_level>3)
3008 log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3009 if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3010 log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3011 switch( opt.s2k_mode ) {
3012 case 0:
3013 log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
3014 break;
3015 case 1: case 3: break;
3016 default:
3017 log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3018 }
3019
3020 /* This isn't actually needed, but does serve to error out if the
3021 string is invalid. */
3022 if(opt.def_preference_list &&
3023 keygen_set_std_prefs(opt.def_preference_list,0))
3024 log_error(_("invalid default preferences\n"));
3025
3026 /* We provide defaults for the personal digest list. This is
3027 SHA-1. */
3028 if(!pers_digest_list)
3029 pers_digest_list="h2";
3030
3031 if(pers_cipher_list &&
3032 keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3033 log_error(_("invalid personal cipher preferences\n"));
3034
3035 if(pers_digest_list &&
3036 keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3037 log_error(_("invalid personal digest preferences\n"));
3038
3039 if(pers_compress_list &&
3040 keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3041 log_error(_("invalid personal compress preferences\n"));
3042
3043 /* We don't support all possible commands with multifile yet */
3044 if(multifile)
3045 {
3046 char *cmdname;
3047
3048 switch(cmd)
3049 {
3050 case aSign:
3051 cmdname="--sign";
3052 break;
3053 case aClearsign:
3054 cmdname="--clearsign";
3055 break;
3056 case aDetachedSign:
3057 cmdname="--detach-sign";
3058 break;
3059 case aSym:
3060 cmdname="--symmetric";
3061 break;
3062 case aEncrSym:
3063 cmdname="--symmetric --encrypt";
3064 break;
3065 case aStore:
3066 cmdname="--store";
3067 break;
3068 default:
3069 cmdname=NULL;
3070 break;
3071 }
3072
3073 if(cmdname)
3074 log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3075 }
3076
3077 if( log_get_errorcount(0) )
3078 g10_exit(2);
3079
3080 if(opt.compress_level==0)
3081 opt.compress_algo=COMPRESS_ALGO_NONE;
3082
3083 /* Check our chosen algorithms against the list of legal
3084 algorithms. */
3085
3086 if(!GNUPG)
3087 {
3088 const char *badalg=NULL;
3089 preftype_t badtype=PREFTYPE_NONE;
3090
3091 if(opt.def_cipher_algo
3092 && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3093 {
3094 badalg = gcry_cipher_algo_name (opt.def_cipher_algo);
3095 badtype = PREFTYPE_SYM;
3096 }
3097 else if(opt.def_digest_algo
3098 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3099 {
3100 badalg = gcry_md_algo_name (opt.def_digest_algo);
3101 badtype = PREFTYPE_HASH;
3102 }
3103 else if(opt.cert_digest_algo
3104 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3105 {
3106 badalg = gcry_md_algo_name (opt.cert_digest_algo);
3107 badtype = PREFTYPE_HASH;
3108 }
3109 else if(opt.compress_algo!=-1
3110 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3111 {
3112 badalg = compress_algo_to_string(opt.compress_algo);
3113 badtype = PREFTYPE_ZIP;
3114 }
3115
3116 if(badalg)
3117 {
3118 switch(badtype)
3119 {
3120 case PREFTYPE_SYM:
3121 log_info(_("you may not use cipher algorithm `%s'"
3122 " while in %s mode\n"),
3123 badalg,compliance_option_string());
3124 break;
3125 case PREFTYPE_HASH:
3126 log_info(_("you may not use digest algorithm `%s'"
3127 " while in %s mode\n"),
3128 badalg,compliance_option_string());
3129 break;
3130 case PREFTYPE_ZIP:
3131 log_info(_("you may not use compression algorithm `%s'"
3132 " while in %s mode\n"),
3133 badalg,compliance_option_string());
3134 break;
3135 default:
3136 BUG();
3137 }
3138
3139 compliance_failure();
3140 }
3141 }
3142
3143 /* Set the random seed file. */
3144 if( use_random_seed ) {
3145 char *p = make_filename(opt.homedir, "random_seed", NULL );
3146 gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3147 if (!access (p, F_OK))
3148 register_secured_file (p);
3149 xfree(p);
3150 }
3151
3152 if( !cmd && opt.fingerprint && !with_fpr ) {
3153 set_cmd( &cmd, aListKeys);
3154 }
3155
3156 if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
3157 if( cmd == aKModeC ) {
3158 opt.fingerprint = 1;
3159 cmd = aKMode;
3160 }
3161 opt.list_sigs = 0;
3162 if( opt.verbose > 2 )
3163 opt.check_sigs++;
3164 if( opt.verbose > 1 )
3165 opt.list_sigs++;
3166
3167 opt.verbose = opt.verbose > 1;
3168 }
3169
3170 /* kludge to let -sat generate a clear text signature */
3171 if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
3172 cmd = aClearsign;
3173
3174 if( opt.verbose > 1 )
3175 set_packet_list_mode(1);
3176
3177 /* Add the keyrings, but not for some special commands and not in
3178 case of "-kvv userid keyring". Also avoid adding the secret
3179 keyring for a couple of commands to avoid unneeded access in
3180 case the secrings are stored on a floppy.
3181
3182 We always need to add the keyrings if we are running under
3183 SELinux, this is so that the rings are added to the list of
3184 secured files. */
3185 if( ALWAYS_ADD_KEYRINGS
3186 || (cmd != aDeArmor && cmd != aEnArmor
3187 && !(cmd == aKMode && argc == 2 )) )
3188 {
3189 if (ALWAYS_ADD_KEYRINGS
3190 || (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
3191 && cmd != aVerify && cmd != aSym))
3192 {
3193 if (!sec_nrings || default_keyring) /* add default secret rings */
3194 keydb_add_resource ("secring" EXTSEP_S "gpg", 4, 1);
3195 for (sl = sec_nrings; sl; sl = sl->next)
3196 keydb_add_resource ( sl->d, 0, 1 );
3197 }
3198 if( !nrings || default_keyring ) /* add default ring */
3199 keydb_add_resource ("pubring" EXTSEP_S "gpg", 4, 0);
3200 for(sl = nrings; sl; sl = sl->next )
3201 keydb_add_resource ( sl->d, sl->flags, 0 );
3202 }
3203 FREE_STRLIST(nrings);
3204 FREE_STRLIST(sec_nrings);
3205
3206
3207 if( pwfd != -1 ) /* read the passphrase now. */
3208 read_passphrase_from_fd( pwfd );
3209
3210 fname = argc? *argv : NULL;
3211
3212 if(fname && utf8_strings)
3213 opt.flags.utf8_filename=1;
3214
3215 switch( cmd ) {
3216 case aPrimegen:
3217 case aPrintMD:
3218 case aPrintMDs:
3219 case aGenRandom:
3220 case aDeArmor:
3221 case aEnArmor:
3222 case aFixTrustDB:
3223 break;
3224 case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
3225 case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
3226 default: rc = setup_trustdb(1, trustdb_name ); break;
3227 }
3228 if( rc )
3229 log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3230
3231
3232 switch (cmd)
3233 {
3234 case aStore:
3235 case aSym:
3236 case aSign:
3237 case aSignSym:
3238 case aClearsign:
3239 if (!opt.quiet && any_explicit_recipient)
3240 log_info (_("WARNING: recipients (-r) given "
3241 "without using public key encryption\n"));
3242 break;
3243 default:
3244 break;
3245 }
3246
3247 switch( cmd )
3248 {
3249 case aStore: /* only store the file */
3250 if( argc > 1 )
3251 wrong_args(_("--store [filename]"));
3252 if( (rc = encode_store(fname)) )
3253 log_error ("storing `%s' failed: %s\n",
3254 print_fname_stdin(fname),g10_errstr(rc) );
3255 break;
3256 case aSym: /* encrypt the given file only with the symmetric cipher */
3257 if( argc > 1 )
3258 wrong_args(_("--symmetric [filename]"));
3259 if( (rc = encode_symmetric(fname)) )
3260 log_error (_("symmetric encryption of `%s' failed: %s\n"),
3261 print_fname_stdin(fname),g10_errstr(rc) );
3262 break;
3263
3264 case aEncr: /* encrypt the given file */
3265 if(multifile)
3266 encode_crypt_files(argc, argv, remusr);
3267 else
3268 {
3269 if( argc > 1 )
3270 wrong_args(_("--encrypt [filename]"));
3271 if( (rc = encode_crypt(fname,remusr,0)) )
3272 log_error("%s: encryption failed: %s\n",
3273 print_fname_stdin(fname), g10_errstr(rc) );
3274 }
3275 break;
3276
3277 case aEncrSym:
3278 /* This works with PGP 8 in the sense that it acts just like a
3279 symmetric message. It doesn't work at all with 2 or 6. It
3280 might work with 7, but alas, I don't have a copy to test
3281 with right now. */
3282 if( argc > 1 )
3283 wrong_args(_("--symmetric --encrypt [filename]"));
3284 else if(opt.s2k_mode==0)
3285 log_error(_("you cannot use --symmetric --encrypt"
3286 " with --s2k-mode 0\n"));
3287 else if(PGP2 || PGP6 || PGP7 || RFC1991)
3288 log_error(_("you cannot use --symmetric --encrypt"
3289 " while in %s mode\n"),compliance_option_string());
3290 else
3291 {
3292 if( (rc = encode_crypt(fname,remusr,1)) )
3293 log_error("%s: encryption failed: %s\n",
3294 print_fname_stdin(fname), g10_errstr(rc) );
3295 }
3296 break;
3297
3298 case aSign: /* sign the given file */
3299 sl = NULL;
3300 if( detached_sig ) { /* sign all files */
3301 for( ; argc; argc--, argv++ )
3302 add_to_strlist( &sl, *argv );
3303 }
3304 else {
3305 if( argc > 1 )
3306 wrong_args(_("--sign [filename]"));
3307 if( argc ) {
3308 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3309 strcpy(sl->d, fname);
3310 }
3311 }
3312 if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
3313 log_error("signing failed: %s\n", g10_errstr(rc) );
3314 free_strlist(sl);
3315 break;
3316
3317 case aSignEncr: /* sign and encrypt the given file */
3318 if( argc > 1 )
3319 wrong_args(_("--sign --encrypt [filename]"));
3320 if( argc ) {
3321 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3322 strcpy(sl->d, fname);
3323 }
3324 else
3325 sl = NULL;
3326 if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
3327 log_error("%s: sign+encrypt failed: %s\n",
3328 print_fname_stdin(fname), g10_errstr(rc) );
3329 free_strlist(sl);
3330 break;
3331
3332 case aSignEncrSym: /* sign and encrypt the given file */
3333 if( argc > 1 )
3334 wrong_args(_("--symmetric --sign --encrypt [filename]"));
3335 else if(opt.s2k_mode==0)
3336 log_error(_("you cannot use --symmetric --sign --encrypt"
3337 " with --s2k-mode 0\n"));
3338 else if(PGP2 || PGP6 || PGP7 || RFC1991)
3339 log_error(_("you cannot use --symmetric --sign --encrypt"
3340 " while in %s mode\n"),compliance_option_string());
3341 else
3342 {
3343 if( argc )
3344 {
3345 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3346 strcpy(sl->d, fname);
3347 }
3348 else
3349 sl = NULL;
3350 if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
3351 log_error("%s: symmetric+sign+encrypt failed: %s\n",
3352 print_fname_stdin(fname), g10_errstr(rc) );
3353 free_strlist(sl);
3354 }
3355 break;
3356
3357 case aSignSym: /* sign and conventionally encrypt the given file */
3358 if (argc > 1)
3359 wrong_args(_("--sign --symmetric [filename]"));
3360 rc = sign_symencrypt_file (fname, locusr);
3361 if (rc)
3362 log_error("%s: sign+symmetric failed: %s\n",
3363 print_fname_stdin(fname), g10_errstr(rc) );
3364 break;
3365
3366 case aClearsign: /* make a clearsig */
3367 if( argc > 1 )
3368 wrong_args(_("--clearsign [filename]"));
3369 if( (rc = clearsign_file(fname, locusr, NULL)) )
3370 log_error("%s: clearsign failed: %s\n",
3371 print_fname_stdin(fname), g10_errstr(rc) );
3372 break;
3373
3374 case aVerify:
3375 if(multifile)
3376 {
3377 if( (rc = verify_files( argc, argv ) ))
3378 log_error("verify files failed: %s\n", g10_errstr(rc) );
3379 }
3380 else
3381 {
3382 if( (rc = verify_signatures( argc, argv ) ))
3383 log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3384 }
3385 break;
3386
3387 case aDecrypt:
3388 if(multifile)
3389 decrypt_messages(argc, argv);
3390 else
3391 {
3392 if( argc > 1 )
3393 wrong_args(_("--decrypt [filename]"));
3394 if( (rc = decrypt_message( fname ) ))
3395 log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3396 }
3397 break;
3398
3399 case aSignKey:
3400 if( argc != 1 )
3401 wrong_args(_("--sign-key user-id"));
3402 /* fall through */
3403 case aLSignKey:
3404 if( argc != 1 )
3405 wrong_args(_("--lsign-key user-id"));
3406 /* fall through */
3407
3408 sl=NULL;
3409
3410 if(cmd==aSignKey)
3411 append_to_strlist(&sl,"sign");
3412 else if(cmd==aLSignKey)
3413 append_to_strlist(&sl,"lsign");
3414 else
3415 BUG();
3416
3417 append_to_strlist( &sl, "save" );
3418 username = make_username( fname );
3419 keyedit_menu(fname, locusr, sl, 0, 0 );
3420 xfree(username);
3421 free_strlist(sl);
3422 break;
3423
3424 case aEditKey: /* Edit a key signature */
3425 if( !argc )
3426 wrong_args(_("--edit-key user-id [commands]"));
3427 username = make_username( fname );
3428 if( argc > 1 ) {
3429 sl = NULL;
3430 for( argc--, argv++ ; argc; argc--, argv++ )
3431 append_to_strlist( &sl, *argv );
3432 keyedit_menu( username, locusr, sl, 0, 1 );
3433 free_strlist(sl);
3434 }
3435 else
3436 keyedit_menu(username, locusr, NULL, 0, 1 );
3437 xfree(username);
3438 break;
3439
3440 case aDeleteKeys:
3441 case aDeleteSecretKeys:
3442 case aDeleteSecretAndPublicKeys:
3443 sl = NULL;
3444 /* I'm adding these in reverse order as add_to_strlist2
3445 reverses them again, and it's easier to understand in the
3446 proper order :) */
3447 for( ; argc; argc-- )
3448 add_to_strlist2( &sl, argv[argc-1], utf8_strings );
3449 delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
3450 free_strlist(sl);
3451 break;
3452
3453 case aCheckKeys:
3454 opt.check_sigs = 1;
3455 case aListSigs:
3456 opt.list_sigs = 1;
3457 case aListKeys:
3458 sl = NULL;
3459 for( ; argc; argc--, argv++ )
3460 add_to_strlist2( &sl, *argv, utf8_strings );
3461 public_key_list( sl );
3462 free_strlist(sl);
3463 break;
3464 case aListSecretKeys:
3465 sl = NULL;
3466 for( ; argc; argc--, argv++ )
3467 add_to_strlist2( &sl, *argv, utf8_strings );
3468 secret_key_list( sl );
3469 free_strlist(sl);
3470 break;
3471
3472 case aKMode: /* list keyring -- NOTE: This will be removed soon */
3473 if( argc < 2 ) { /* -kv [userid] */
3474 sl = NULL;
3475 if (argc && **argv)
3476 add_to_strlist2( &sl, *argv, utf8_strings );
3477 public_key_list( sl );
3478 free_strlist(sl);
3479 }
3480 else if( argc == 2 ) { /* -kv userid keyring */
3481 if( access( argv[1], R_OK ) ) {
3482 log_error(_("can't open `%s': %s\n"),
3483 print_fname_stdin(argv[1]), strerror(errno));
3484 }
3485 else {
3486 /* add keyring (default keyrings are not registered in this
3487 * special case */
3488 keydb_add_resource( argv[1], 0, 0 );
3489 sl = NULL;
3490 if (**argv)
3491 add_to_strlist2( &sl, *argv, utf8_strings );
3492 public_key_list( sl );
3493 free_strlist(sl);
3494 }
3495 }
3496 else
3497 wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
3498 break;
3499
3500 case aKeygen: /* generate a key */
3501 if( opt.batch ) {
3502 if( argc > 1 )
3503 wrong_args("--gen-key [parameterfile]");
3504 generate_keypair( argc? *argv : NULL, NULL, NULL );
3505 }
3506 else {
3507 if( argc )
3508 wrong_args("--gen-key");
3509 generate_keypair(NULL, NULL, NULL);
3510 }
3511 break;
3512
3513 case aFastImport:
3514 opt.import_options |= IMPORT_FAST;
3515 case aImport:
3516 import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
3517 break;
3518
3519 /* TODO: There are a number of command that use this same
3520 "make strlist, call function, report error, free strlist"
3521 pattern. Join them together here and avoid all that
3522 duplicated code. */
3523
3524 case aExport:
3525 case aSendKeys:
3526 case aRecvKeys:
3527 sl = NULL;
3528 for( ; argc; argc--, argv++ )
3529 append_to_strlist2( &sl, *argv, utf8_strings );
3530 if( cmd == aSendKeys )
3531 rc=keyserver_export( sl );
3532 else if( cmd == aRecvKeys )
3533 rc=keyserver_import( sl );
3534 else
3535 rc=export_pubkeys( sl, opt.export_options );
3536 if(rc)
3537 {
3538 if(cmd==aSendKeys)
3539 log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3540 else if(cmd==aRecvKeys)
3541 log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3542 else
3543 log_error(_("key export failed: %s\n"),g10_errstr(rc));
3544 }
3545 free_strlist(sl);
3546 break;
3547
3548 case aSearchKeys:
3549 sl = NULL;
3550 for( ; argc; argc--, argv++ )
3551 append_to_strlist2( &sl, *argv, utf8_strings );
3552 rc=keyserver_search( sl );
3553 if(rc)
3554 log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
3555 free_strlist(sl);
3556 break;
3557
3558 case aRefreshKeys:
3559 sl = NULL;
3560 for( ; argc; argc--, argv++ )
3561 append_to_strlist2( &sl, *argv, utf8_strings );
3562 rc=keyserver_refresh(sl);
3563 if(rc)
3564 log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3565 free_strlist(sl);
3566 break;
3567
3568 case aFetchKeys:
3569 sl = NULL;
3570 for( ; argc; argc--, argv++ )
3571 append_to_strlist2( &sl, *argv, utf8_strings );
3572 rc=keyserver_fetch(sl);
3573 if(rc)
3574 log_error("key fetch failed: %s\n",g10_errstr(rc));
3575 free_strlist(sl);
3576 break;
3577
3578 case aExportSecret:
3579 sl = NULL;
3580 for( ; argc; argc--, argv++ )
3581 add_to_strlist2( &sl, *argv, utf8_strings );
3582 export_seckeys( sl );
3583 free_strlist(sl);
3584 break;
3585
3586 case aExportSecretSub:
3587 sl = NULL;
3588 for( ; argc; argc--, argv++ )
3589 add_to_strlist2( &sl, *argv, utf8_strings );
3590 export_secsubkeys( sl );
3591 free_strlist(sl);
3592 break;
3593
3594 case aGenRevoke:
3595 if( argc != 1 )
3596 wrong_args("--gen-revoke user-id");
3597 username = make_username(*argv);
3598 gen_revoke( username );
3599 xfree( username );
3600 break;
3601
3602 case aDesigRevoke:
3603 if( argc != 1 )
3604 wrong_args("--desig-revoke user-id");
3605 username = make_username(*argv);
3606 gen_desig_revoke( username, locusr );
3607 xfree( username );
3608 break;
3609
3610 case aDeArmor:
3611 if( argc > 1 )
3612 wrong_args("--dearmor [file]");
3613 rc = dearmor_file( argc? *argv: NULL );
3614 if( rc )
3615 log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
3616 break;
3617
3618 case aEnArmor:
3619 if( argc > 1 )
3620 wrong_args("--enarmor [file]");
3621 rc = enarmor_file( argc? *argv: NULL );
3622 if( rc )
3623 log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
3624 break;
3625
3626
3627 case aPrimegen:
3628 #if 0 /*FIXME*/
3629 { int mode = argc < 2 ? 0 : atoi(*argv);
3630
3631 if( mode == 1 && argc == 2 ) {
3632 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
3633 }
3634 else if( mode == 2 && argc == 3 ) {
3635 mpi_print( stdout, generate_elg_prime(
3636 0, atoi(argv[1]),
3637 atoi(argv[2]), NULL,NULL ), 1);
3638 }
3639 else if( mode == 3 && argc == 3 ) {
3640 MPI *factors;
3641 mpi_print( stdout, generate_elg_prime(
3642 1, atoi(argv[1]),
3643 atoi(argv[2]), NULL,&factors ), 1);
3644 putchar('\n');
3645 mpi_print( stdout, factors[0], 1 ); /* print q */
3646 }
3647 else if( mode == 4 && argc == 3 ) {
3648 MPI g = mpi_alloc(1);
3649 mpi_print( stdout, generate_elg_prime(
3650 0, atoi(argv[1]),
3651 atoi(argv[2]), g, NULL ), 1);
3652 putchar('\n');
3653 mpi_print( stdout, g, 1 );
3654 mpi_free(g);
3655 }
3656 else
3657 wrong_args("--gen-prime mode bits [qbits] ");
3658 putchar('\n');
3659 }
3660 #endif
3661 wrong_args("--gen-prime not yet supported ");
3662 break;
3663
3664 case aGenRandom:
3665 {
3666 int level = argc ? atoi(*argv):0;
3667 int count = argc > 1 ? atoi(argv[1]): 0;
3668 int endless = !count;
3669
3670 if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
3671 wrong_args("--gen-random 0|1|2 [count]");
3672
3673 while( endless || count ) {
3674 byte *p;
3675 /* Wee need a multiple of 3, so that in case of
3676 armored output we get a correct string. No
3677 linefolding is done, as it is best to levae this to
3678 other tools */
3679 size_t n = !endless && count < 99? count : 99;
3680
3681 p = gcry_random_bytes (n, level);
3682 #ifdef HAVE_DOSISH_SYSTEM
3683 setmode ( fileno(stdout), O_BINARY );
3684 #endif
3685 if (opt.armor) {
3686 char *tmp = make_radix64_string (p, n);
3687 fputs (tmp, stdout);
3688 xfree (tmp);
3689 if (n%3 == 1)
3690 putchar ('=');
3691 if (n%3)
3692 putchar ('=');
3693 } else {
3694 fwrite( p, n, 1, stdout );
3695 }
3696 xfree(p);
3697 if( !endless )
3698 count -= n;
3699 }
3700 if (opt.armor)
3701 putchar ('\n');
3702 }
3703 break;
3704
3705 case aPrintMD:
3706 if( argc < 1)
3707 wrong_args("--print-md algo [files]");
3708 {
3709 int all_algos = (**argv=='*' && !(*argv)[1]);
3710 int algo = all_algos? 0 : gcry_md_map_name (*argv);
3711
3712 if( !algo && !all_algos )
3713 log_error(_("invalid hash algorithm `%s'\n"), *argv );
3714 else {
3715 argc--; argv++;
3716 if( !argc )
3717 print_mds(NULL, algo);
3718 else {
3719 for(; argc; argc--, argv++ )
3720 print_mds(*argv, algo);
3721 }
3722 }
3723 }
3724 break;
3725
3726 case aPrintMDs: /* old option */
3727 if( !argc )
3728 print_mds(NULL,0);
3729 else {
3730 for(; argc; argc--, argv++ )
3731 print_mds(*argv,0);
3732 }
3733 break;
3734
3735 case aListTrustDB:
3736 if( !argc )
3737 list_trustdb(NULL);
3738 else {
3739 for( ; argc; argc--, argv++ )
3740 list_trustdb( *argv );
3741 }
3742 break;
3743
3744 case aUpdateTrustDB:
3745 if( argc )
3746 wrong_args("--update-trustdb");
3747 update_trustdb();
3748 break;
3749
3750 case aCheckTrustDB:
3751 /* Old versions allowed for arguments - ignore them */
3752 check_trustdb();
3753 break;
3754
3755 case aFixTrustDB:
3756 log_error("this command is not yet implemented.\n");
3757 log_error("A workaround is to use \"--export-ownertrust\", remove\n");
3758 log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
3759 break;
3760
3761 case aListTrustPath:
3762 if( !argc )
3763 wrong_args("--list-trust-path <user-ids>");
3764 for( ; argc; argc--, argv++ ) {
3765 username = make_username( *argv );
3766 list_trust_path( username );
3767 xfree(username);
3768 }
3769 break;
3770
3771 case aExportOwnerTrust:
3772 if( argc )
3773 wrong_args("--export-ownertrust");
3774 export_ownertrust();
3775 break;
3776
3777 case aImportOwnerTrust:
3778 if( argc > 1 )
3779 wrong_args("--import-ownertrust [file]");
3780 import_ownertrust( argc? *argv:NULL );
3781 break;
3782
3783 case aRebuildKeydbCaches:
3784 if (argc)
3785 wrong_args ("--rebuild-keydb-caches");
3786 keydb_rebuild_caches (1);
3787 break;
3788
3789 #ifdef ENABLE_CARD_SUPPORT
3790 case aCardStatus:
3791 if (argc)
3792 wrong_args ("--card-status");
3793 card_status (stdout, NULL, 0);
3794 break;
3795
3796 case aCardEdit:
3797 if (argc) {
3798 sl = NULL;
3799 for (argc--, argv++ ; argc; argc--, argv++)
3800 append_to_strlist (&sl, *argv);
3801 card_edit (sl);
3802 free_strlist (sl);
3803 }
3804 else
3805 card_edit (NULL);
3806 break;
3807
3808 case aChangePIN:
3809 if (!argc)
3810 change_pin (0,1);
3811 else if (argc == 1)
3812 change_pin (atoi (*argv),1);
3813 else
3814 wrong_args ("--change-pin [no]");
3815 break;
3816 #endif /* ENABLE_CARD_SUPPORT*/
3817
3818 case aListConfig:
3819 {
3820 char *str=collapse_args(argc,argv);
3821 list_config(str);
3822 xfree(str);
3823 }
3824 break;
3825
3826 case aListPackets:
3827 opt.list_packets=2;
3828 default:
3829 if( argc > 1 )
3830 wrong_args(_("[filename]"));
3831 /* Issue some output for the unix newbie */
3832 if( !fname && !opt.outfile && isatty( fileno(stdin) )
3833 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
3834 log_info(_("Go ahead and type your message ...\n"));
3835
3836 a = iobuf_open(fname);
3837 if (a && is_secured_file (iobuf_get_fd (a)))
3838 {
3839 iobuf_close (a);
3840 a = NULL;
3841 errno = EPERM;
3842 }
3843 if( !a )
3844 log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
3845 else {
3846
3847 if( !opt.no_armor ) {
3848 if( use_armor_filter( a ) ) {
3849 memset( &afx, 0, sizeof afx);
3850 iobuf_push_filter( a, armor_filter, &afx );
3851 }
3852 }
3853 if( cmd == aListPackets ) {
3854 set_packet_list_mode(1);
3855 opt.list_packets=1;
3856 }
3857 rc = proc_packets(NULL, a );
3858 if( rc )
3859 log_error("processing message failed: %s\n", g10_errstr(rc) );
3860 iobuf_close(a);
3861 }
3862 break;
3863 }
3864
3865 /* cleanup */
3866 FREE_STRLIST(remusr);
3867 FREE_STRLIST(locusr);
3868 g10_exit(0);
3869 return 8; /*NEVER REACHED*/
3870 }
3871
3872
3873 /* Note: This function is used by signal handlers!. */
3874 static void
3875 emergency_cleanup (void)
3876 {
3877 gcry_control (GCRYCTL_TERM_SECMEM );
3878 }
3879
3880
3881 void
3882 g10_exit( int rc )
3883 {
3884 gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
3885 if ( (opt.debug & DBG_MEMSTAT_VALUE) )
3886 {
3887 gcry_control (GCRYCTL_DUMP_MEMORY_STATS);
3888 gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
3889 }
3890 if (opt.debug)
3891 gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
3892
3893 emergency_cleanup ();
3894
3895 rc = rc? rc : log_get_errorcount(0)? 2 : g10_errors_seen? 1 : 0;
3896 exit (rc);
3897 }
3898
3899
3900 /* Pretty-print hex hashes. This assumes at least an 80-character
3901 display, but there are a few other similar assumptions in the
3902 display code. */
3903 static void
3904 print_hex( gcry_md_hd_t md, int algo, const char *fname )
3905 {
3906 int i,n,count,indent=0;
3907 const byte *p;
3908
3909 if(fname)
3910 indent=printf("%s: ",fname);
3911
3912 if(indent>40)
3913 {
3914 printf("\n");
3915 indent=0;
3916 }
3917
3918 if(algo==DIGEST_ALGO_RMD160)
3919 indent+=printf("RMD160 = ");
3920 else if(algo>0)
3921 indent+=printf("%6s = ", gcry_md_algo_name (algo));
3922 else
3923 algo=abs(algo);
3924
3925 count=indent;
3926
3927 p = gcry_md_read (md, algo);
3928 n = gcry_md_get_algo_dlen (algo);
3929
3930 count += printf ("%02X",*p++);
3931
3932 for(i=1;i<n;i++,p++)
3933 {
3934 if(n==16)
3935 {
3936 if(count+2>79)
3937 {
3938 printf("\n%*s",indent," ");
3939 count=indent;
3940 }
3941 else
3942 count+=printf(" ");
3943
3944 if(!(i%8))
3945 count+=printf(" ");
3946 }
3947 else if (n==20)
3948 {
3949 if(!(i%2))
3950 {
3951 if(count+4>79)
3952 {
3953 printf("\n%*s",indent," ");
3954 count=indent;
3955 }
3956 else
3957 count+=printf(" ");
3958 }
3959
3960 if(!(i%10))
3961 count+=printf(" ");
3962 }
3963 else
3964 {
3965 if(!(i%4))
3966 {
3967 if(count+8>79)
3968 {
3969 printf("\n%*s",indent," ");
3970 count=indent;
3971 }
3972 else
3973 count+=printf(" ");
3974 }
3975 }
3976
3977 count+=printf("%02X",*p);
3978 }
3979
3980 printf("\n");
3981 }
3982
3983 static void
3984 print_hashline( gcry_md_hd_t md, int algo, const char *fname )
3985 {
3986 int i, n;
3987 const byte *p;
3988
3989 if ( fname ) {
3990 for (p = fname; *p; p++ ) {
3991 if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
3992 printf("%%%02X", *p );
3993 else
3994 putchar( *p );
3995 }
3996 }
3997 putchar(':');
3998 printf("%d:", algo );
3999 p = gcry_md_read (md, algo);
4000 n = gcry_md_get_algo_dlen (algo);
4001 for(i=0; i < n ; i++, p++ )
4002 printf("%02X", *p );
4003 putchar(':');
4004 putchar('\n');
4005 }
4006
4007 static void
4008 print_mds( const char *fname, int algo )
4009 {
4010 FILE *fp;
4011 char buf[1024];
4012 size_t n;
4013 gcry_md_hd_t md;
4014
4015 if( !fname ) {
4016 fp = stdin;
4017 #ifdef HAVE_DOSISH_SYSTEM
4018 setmode ( fileno(fp) , O_BINARY );
4019 #endif
4020 }
4021 else {
4022 fp = fopen( fname, "rb" );
4023 if (fp && is_secured_file (fileno (fp)))
4024 {
4025 fclose (fp);
4026 fp = NULL;
4027 errno = EPERM;
4028 }
4029 }
4030 if( !fp ) {
4031 log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
4032 return;
4033 }
4034
4035 gcry_md_open (&md, 0, 0);
4036 if( algo )
4037 gcry_md_enable (md, algo);
4038 else {
4039 gcry_md_enable (md, GCRY_MD_MD5);
4040 gcry_md_enable (md, GCRY_MD_SHA1);
4041 gcry_md_enable (md, GCRY_MD_RMD160);
4042 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA224))
4043 gcry_md_enable (md, DIGEST_ALGO_SHA224);
4044 if (!openpgp_md_test_algo (GCRY_MD_SHA256))
4045 gcry_md_enable (md, GCRY_MD_SHA256);
4046 if (!openpgp_md_test_algo (GCRY_MD_SHA384))
4047 gcry_md_enable (md, GCRY_MD_SHA384);
4048 if (!openpgp_md_test_algo (GCRY_MD_SHA512))
4049 gcry_md_enable (md, GCRY_MD_SHA512);
4050 }
4051
4052 while( (n=fread( buf, 1, DIM(buf), fp )) )
4053 gcry_md_write (md, buf, n);
4054 if( ferror(fp) )
4055 log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
4056 else {
4057 gcry_md_final (md);
4058 if ( opt.with_colons ) {
4059 if ( algo )
4060 print_hashline( md, algo, fname );
4061 else {
4062 print_hashline( md, GCRY_MD_MD5, fname );
4063 print_hashline( md, GCRY_MD_SHA1, fname );
4064 print_hashline( md, GCRY_MD_RMD160, fname );
4065 if (!gcry_md_test_algo (DIGEST_ALGO_SHA224))
4066 print_hashline (md, DIGEST_ALGO_SHA224, fname);
4067 if (!gcry_md_test_algo (GCRY_MD_SHA256))
4068 print_hashline( md, GCRY_MD_SHA256, fname );
4069 if (!gcry_md_test_algo (GCRY_MD_SHA384))
4070 print_hashline ( md, GCRY_MD_SHA384, fname );
4071 if (!gcry_md_test_algo (GCRY_MD_SHA512))
4072 print_hashline ( md, GCRY_MD_SHA512, fname );
4073 }
4074 }
4075 else {
4076 if( algo )
4077 print_hex(md,-algo,fname);
4078 else {
4079 print_hex( md, GCRY_MD_MD5, fname );
4080 print_hex( md, GCRY_MD_SHA1, fname );
4081 print_hex( md, GCRY_MD_RMD160, fname );
4082 if (!gcry_md_test_algo (DIGEST_ALGO_SHA224))
4083 print_hex (md, DIGEST_ALGO_SHA224, fname);
4084 if (!gcry_md_test_algo (GCRY_MD_SHA256))
4085 print_hex( md, GCRY_MD_SHA256, fname );
4086 if (!gcry_md_test_algo (GCRY_MD_SHA384))
4087 print_hex( md, GCRY_MD_SHA384, fname );
4088 if (!gcry_md_test_algo (GCRY_MD_SHA512))
4089 print_hex( md, GCRY_MD_SHA512, fname );
4090 }
4091 }
4092 }
4093 gcry_md_close(md);
4094
4095 if( fp != stdin )
4096 fclose(fp);
4097 }
4098
4099
4100 /****************
4101 * Check the supplied name,value string and add it to the notation
4102 * data to be used for signatures. which==0 for sig notations, and 1
4103 * for cert notations.
4104 */
4105 static void
4106 add_notation_data( const char *string, int which )
4107 {
4108 struct notation *notation;
4109
4110 notation=string_to_notation(string,utf8_strings);
4111 if(notation)
4112 {
4113 if(which)
4114 {
4115 notation->next=opt.cert_notations;
4116 opt.cert_notations=notation;
4117 }
4118 else
4119 {
4120 notation->next=opt.sig_notations;
4121 opt.sig_notations=notation;
4122 }
4123 }
4124 }
4125
4126 static void
4127 add_policy_url( const char *string, int which )
4128 {
4129 unsigned int i,critical=0;
4130 STRLIST sl;
4131
4132 if(*string=='!')
4133 {
4134 string++;
4135 critical=1;
4136 }
4137
4138 for(i=0;i<strlen(string);i++)
4139 if( !isascii (string[i]) || iscntrl(string[i]))
4140 break;
4141
4142 if(i==0 || i<strlen(string))
4143 {
4144 if(which)
4145 log_error(_("the given certification policy URL is invalid\n"));
4146 else
4147 log_error(_("the given signature policy URL is invalid\n"));
4148 }
4149
4150 if(which)
4151 sl=add_to_strlist( &opt.cert_policy_url, string );
4152 else
4153 sl=add_to_strlist( &opt.sig_policy_url, string );
4154
4155 if(critical)
4156 sl->flags |= 1;
4157 }
4158
4159 static void
4160 add_keyserver_url( const char *string, int which )
4161 {
4162 unsigned int i,critical=0;
4163 STRLIST sl;
4164
4165 if(*string=='!')
4166 {
4167 string++;
4168 critical=1;
4169 }
4170
4171 for(i=0;i<strlen(string);i++)
4172 if( !isascii (string[i]) || iscntrl(string[i]))
4173 break;
4174
4175 if(i==0 || i<strlen(string))
4176 {
4177 if(which)
4178 BUG();
4179 else
4180 log_error(_("the given preferred keyserver URL is invalid\n"));
4181 }
4182
4183 if(which)
4184 BUG();
4185 else
4186 sl=add_to_strlist( &opt.sig_keyserver_url, string );
4187
4188 if(critical)
4189 sl->flags |= 1;
4190 }
gnupg svn clone