gpg: Remove dead code.
[gnupg.git] / g10 / gpgcompose.c
1 /* gpgcompose.c - Maintainer tool to create OpenPGP messages by hand.
2  * Copyright (C) 2016 g10 Code GmbH
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <errno.h>
22
23 #include "gpg.h"
24 #include "packet.h"
25 #include "keydb.h"
26 #include "main.h"
27 #include "options.h"
28
29 static int do_debug;
30 #define debug(fmt, ...) \
31   do { if (do_debug) log_debug (fmt, ##__VA_ARGS__); } while (0)
32 \f
33 /* --encryption, for instance, adds a filter in front of out.  There
34    is an operator (--encryption-pop) to end this.  We use the
35    following infrastructure to make it easy to pop the state.  */
36 struct filter
37 {
38   void *func;
39   void *context;
40   int pkttype;
41   int partial_block_mode;
42   struct filter *next;
43 };
44
45
46 /* Hack to ass CTRL to some functions.  */
47 static ctrl_t global_ctrl;
48
49
50 static struct filter *filters;
51
52 static void
53 filter_push (iobuf_t out, void *func, void *context,
54              int type, int partial_block_mode)
55 {
56   gpg_error_t err;
57   struct filter *f = xmalloc_clear (sizeof (*f));
58   f->next = filters;
59   f->func = func;
60   f->context = context;
61   f->pkttype = type;
62   f->partial_block_mode = partial_block_mode;
63
64   filters = f;
65
66   err = iobuf_push_filter (out, func, context);
67   if (err)
68     log_fatal ("Adding filter: %s\n", gpg_strerror (err));
69 }
70
71 static void
72 filter_pop (iobuf_t out, int expected_type)
73 {
74   gpg_error_t err;
75   struct filter *f = filters;
76
77   log_assert (f);
78
79   if (f->pkttype != expected_type)
80     log_fatal ("Attempted to pop a %s container, "
81                "but current container is a %s container.\n",
82                pkttype_str (f->pkttype), pkttype_str (expected_type));
83
84   if (f->pkttype == PKT_ENCRYPTED)
85     {
86       err = iobuf_pop_filter (out, f->func, f->context);
87       if (err)
88         log_fatal ("Popping encryption filter: %s\n", gpg_strerror (err));
89     }
90   else
91     log_fatal ("FILTERS appears to be corrupted.\n");
92
93   if (f->partial_block_mode)
94     iobuf_set_partial_body_length_mode (out, 0);
95
96   filters = f->next;
97   xfree (f);
98 }
99 \f
100 /* Return if CIPHER_ID is a valid cipher.  */
101 static int
102 valid_cipher (int cipher_id)
103 {
104   return (cipher_id == CIPHER_ALGO_IDEA
105           || cipher_id == CIPHER_ALGO_3DES
106           || cipher_id == CIPHER_ALGO_CAST5
107           || cipher_id == CIPHER_ALGO_BLOWFISH
108           || cipher_id == CIPHER_ALGO_AES
109           || cipher_id == CIPHER_ALGO_AES192
110           || cipher_id == CIPHER_ALGO_AES256
111           || cipher_id == CIPHER_ALGO_TWOFISH
112           || cipher_id == CIPHER_ALGO_CAMELLIA128
113           || cipher_id == CIPHER_ALGO_CAMELLIA192
114           || cipher_id == CIPHER_ALGO_CAMELLIA256);
115 }
116 \f
117 /* Parse a session key encoded as a string of the form x:HEXDIGITS
118    where x is the algorithm id.  (This is the format emitted by gpg
119    --show-session-key.)  */
120 struct session_key
121 {
122   int algo;
123   int keylen;
124   char *key;
125 };
126
127 static struct session_key
128 parse_session_key (const char *option, char *p, int require_algo)
129 {
130   char *tail;
131   struct session_key sk;
132
133   memset (&sk, 0, sizeof (sk));
134
135   /* Check for the optional "cipher-id:" at the start of the
136      string.  */
137   errno = 0;
138   sk.algo = strtol (p, &tail, 10);
139   if (! errno && tail && *tail == ':')
140     {
141       if (! valid_cipher (sk.algo))
142         log_info ("%s: %d is not a known cipher (but using anyways)\n",
143                   option, sk.algo);
144       p = tail + 1;
145     }
146   else if (require_algo)
147     log_fatal ("%s: Session key must have the form algo:HEXCHARACTERS.\n",
148                option);
149   else
150     sk.algo = 0;
151
152   /* Ignore a leading 0x.  */
153   if (p[0] == '0' && p[1] == 'x')
154     p += 2;
155
156   if (strlen (p) % 2 != 0)
157     log_fatal ("%s: session key must consist of an even number of hexadecimal characters.\n",
158                option);
159
160   sk.keylen = strlen (p) / 2;
161   sk.key = xmalloc (sk.keylen);
162
163   if (hex2bin (p, sk.key, sk.keylen) == -1)
164     log_fatal ("%s: Session key must only contain hexadecimal characters\n",
165                option);
166
167   return sk;
168 }
169 \f
170 /* A callback.
171
172    OPTION_STR is the option that was matched.  ARGC is the number of
173    arguments following the option and ARGV are those arguments.
174    (Thus, argv[0] is the first string following the option and
175    argv[-1] is the option.)
176
177    COOKIE is the opaque value passed to process_options.  */
178 typedef int (*option_prcessor_t) (const char *option_str,
179                                   int argc, char *argv[],
180                                   void *cookie);
181
182 struct option
183 {
184   /* The option that this matches.  This must start with "--" or be
185      the empty string.  The empty string matches bare arguments.  */
186   const char *option;
187   /* The function to call to process this option.  */
188   option_prcessor_t func;
189   /* Documentation.  */
190   const char *help;
191 };
192
193 /* Merge two lists of options.  Note: this makes a shallow copy!  The
194    caller must xfree() the result.  */
195 static struct option *
196 merge_options (struct option a[], struct option b[])
197 {
198   int i, j;
199   struct option *c;
200
201   for (i = 0; a[i].option; i ++)
202     ;
203   for (j = 0; b[j].option; j ++)
204     ;
205
206   c = xmalloc ((i + j + 1) * sizeof (struct option));
207   memcpy (c, a, i * sizeof (struct option));
208   memcpy (&c[i], b, j * sizeof (struct option));
209   c[i + j].option = NULL;
210
211   if (a[i].help && b[j].help)
212     c[i + j].help = xasprintf ("%s\n\n%s", a[i].help, b[j].help);
213   else if (a[i].help)
214     c[i + j].help = a[i].help;
215   else if (b[j].help)
216     c[i + j].help = b[j].help;
217
218   return c;
219 }
220
221 /* Returns whether ARG is an option.  All options start with --.  */
222 static int
223 is_option (const char *arg)
224 {
225   return arg[0] == '-' && arg[1] == '-';
226 }
227
228 /* OPTIONS is a NULL terminated array of struct option:s.  Finds the
229    entry that is the same as ARG.  Returns -1 if no entry is found.
230    The empty string option matches bare arguments.  */
231 static int
232 match_option (const struct option options[], const char *arg)
233 {
234   int i;
235   int bare_arg = ! is_option (arg);
236
237   for (i = 0; options[i].option; i ++)
238     if ((! bare_arg && strcmp (options[i].option, arg) == 0)
239         /* Non-options match the empty string.  */
240         || (bare_arg && options[i].option[0] == '\0'))
241       return i;
242
243   return -1;
244 }
245
246 static void
247 show_help (struct option options[])
248 {
249   int i;
250   int max_length = 0;
251   int space;
252
253   for (i = 0; options[i].option; i ++)
254     {
255       const char *option = options[i].option[0] ? options[i].option : "ARG";
256       int l = strlen (option);
257       if (l > max_length)
258         max_length = l;
259     }
260
261   space = 72 - (max_length + 2);
262   if (space < 40)
263     space = 40;
264
265   for (i = 0; ; i ++)
266     {
267       const char *option = options[i].option;
268       const char *help = options[i].help;
269
270       int l;
271       int j;
272       char *tmp;
273       char *formatted;
274       char *p;
275       char *newline;
276
277       if (! option && ! help)
278         break;
279
280       if (option)
281         {
282           const char *o = option[0] ? option : "ARG";
283           l = strlen (o);
284           fprintf (stderr, "%s", o);
285         }
286
287       if (! help)
288         {
289           fputc ('\n', stderr);
290           continue;
291         }
292
293       if (option)
294         for (j = l; j < max_length + 2; j ++)
295           fputc (' ', stderr);
296
297 #define BOLD_START "\033[1m"
298 #define NORMAL_RESTORE "\033[0m"
299 #define BOLD(x) BOLD_START x NORMAL_RESTORE
300
301       if (! option || options[i].func)
302         tmp = (char *) help;
303       else
304         tmp = xasprintf ("%s " BOLD("(Unimplemented.)"), help);
305
306       if (! option)
307         space = 72;
308       formatted = format_text (tmp, space, space + 4);
309       if (!formatted)
310         abort ();
311
312       if (tmp != help)
313         xfree (tmp);
314
315       if (! option)
316         {
317           fprintf (stderr, "\n%s\n", formatted);
318           break;
319         }
320
321       for (p = formatted;
322            p && *p;
323            p = (*newline == '\0') ? newline : newline + 1)
324         {
325           newline = strchr (p, '\n');
326           if (! newline)
327             newline = &p[strlen (p)];
328
329           l = (size_t) newline - (size_t) p;
330
331           if (p != formatted)
332             for (j = 0; j < max_length + 2; j ++)
333               fputc (' ', stderr);
334
335           fwrite (p, l, 1, stderr);
336           fputc ('\n', stderr);
337         }
338
339       xfree (formatted);
340   }
341 }
342
343 /* Return value is number of consumed argv elements.  */
344 static int
345 process_options (const char *parent_option,
346                  struct option break_options[],
347                  struct option local_options[], void *lcookie,
348                  struct option global_options[], void *gcookie,
349                  int argc, char *argv[])
350 {
351   int i;
352   for (i = 0; i < argc; i ++)
353     {
354       int j;
355       struct option *option;
356       void *cookie;
357       int bare_arg;
358       option_prcessor_t func;
359       int consumed;
360
361       if (break_options)
362         {
363           j = match_option (break_options, argv[i]);
364           if (j != -1)
365             /* Match.  Break out.  */
366             return i;
367         }
368
369       j = match_option (local_options, argv[i]);
370       if (j == -1)
371         {
372           if (global_options)
373             j = match_option (global_options, argv[i]);
374           if (j == -1)
375             {
376               if (strcmp (argv[i], "--help") == 0)
377                 {
378                   if (! global_options)
379                     show_help (local_options);
380                   else
381                     {
382                       struct option *combined
383                         = merge_options (local_options, global_options);
384                       show_help (combined);
385                       xfree (combined);
386                     }
387                   g10_exit (0);
388                 }
389
390               if (parent_option)
391                 log_fatal ("%s: Unknown option: %s\n", parent_option, argv[i]);
392               else
393                 log_fatal ("Unknown option: %s\n", argv[i]);
394             }
395
396           option = &global_options[j];
397           cookie = gcookie;
398         }
399       else
400         {
401           option = &local_options[j];
402           cookie = lcookie;
403         }
404
405       bare_arg = strcmp (option->option, "") == 0;
406
407       func = option->func;
408       if (! func)
409         {
410           if (bare_arg)
411             log_fatal ("Bare arguments unimplemented.\n");
412           else
413             log_fatal ("Unimplemented option: %s\n",
414                        option->option);
415         }
416
417       consumed = func (bare_arg ? parent_option : argv[i],
418                        argc - i - !bare_arg, &argv[i + !bare_arg],
419                        cookie);
420       i += consumed;
421       if (bare_arg)
422         i --;
423     }
424
425   return i;
426 }
427 \f
428 /* The keys, subkeys, user ids and user attributes in the order that
429    they were added.  */
430 PACKET components[20];
431 /* The number of components.  */
432 int ncomponents;
433
434 static int
435 add_component (int pkttype, void *component)
436 {
437   int i = ncomponents ++;
438
439   log_assert (i < sizeof (components) / sizeof (components[0]));
440   log_assert (pkttype == PKT_PUBLIC_KEY
441               || pkttype == PKT_PUBLIC_SUBKEY
442               || pkttype == PKT_SECRET_KEY
443               || pkttype == PKT_SECRET_SUBKEY
444               || pkttype == PKT_USER_ID
445               || pkttype == PKT_ATTRIBUTE);
446
447   components[i].pkttype = pkttype;
448   components[i].pkt.generic = component;
449
450   return i;
451 }
452
453 static void
454 dump_component (PACKET *pkt)
455 {
456   struct kbnode_struct kbnode;
457
458   if (! do_debug)
459     return;
460
461   memset (&kbnode, 0, sizeof (kbnode));
462   kbnode.pkt = pkt;
463   dump_kbnode (&kbnode);
464 }
465
466 /* Returns the first primary key in COMPONENTS or NULL if there is
467    none.  */
468 static PKT_public_key *
469 primary_key (void)
470 {
471   int i;
472   for (i = 0; i < ncomponents; i ++)
473     if (components[i].pkttype == PKT_PUBLIC_KEY)
474       return components[i].pkt.public_key;
475   return NULL;
476 }
477 \f
478 /* The last session key (updated when adding a SK-ESK, PK-ESK or SED
479    packet.  */
480 static DEK session_key;
481 \f
482 static int user_id (const char *option, int argc, char *argv[],
483                     void *cookie);
484 static int public_key (const char *option, int argc, char *argv[],
485                        void *cookie);
486 static int sk_esk (const char *option, int argc, char *argv[],
487                    void *cookie);
488 static int pk_esk (const char *option, int argc, char *argv[],
489                    void *cookie);
490 static int encrypted (const char *option, int argc, char *argv[],
491                       void *cookie);
492 static int encrypted_pop (const char *option, int argc, char *argv[],
493                           void *cookie);
494 static int literal (const char *option, int argc, char *argv[],
495                     void *cookie);
496 static int signature (const char *option, int argc, char *argv[],
497                       void *cookie);
498 static int copy (const char *option, int argc, char *argv[],
499                  void *cookie);
500
501 static struct option major_options[] = {
502   { "--user-id", user_id, "Create a user id packet." },
503   { "--public-key", public_key, "Create a public key packet." },
504   { "--private-key", NULL, "Create a private key packet." },
505   { "--public-subkey", public_key, "Create a subkey packet." },
506   { "--private-subkey", NULL, "Create a private subkey packet." },
507   { "--sk-esk", sk_esk,
508     "Create a symmetric-key encrypted session key packet." },
509   { "--pk-esk", pk_esk,
510     "Create a public-key encrypted session key packet." },
511   { "--encrypted", encrypted, "Create a symmetrically encrypted data packet." },
512   { "--encrypted-mdc", encrypted,
513     "Create a symmetrically encrypted and integrity protected data packet." },
514   { "--encrypted-pop", encrypted_pop,
515     "Pop an encryption container." },
516   { "--compressed", NULL, "Create a compressed data packet." },
517   { "--literal", literal, "Create a literal (plaintext) data packet." },
518   { "--signature", signature, "Create a signature packet." },
519   { "--onepass-sig", NULL, "Create a one-pass signature packet." },
520   { "--copy", copy, "Copy the specified file." },
521   { NULL, NULL,
522     "To get more information about a given command, use:\n\n"
523     "  $ gpgcompose --command --help to list a command's options."},
524 };
525 \f
526 static struct option global_options[] = {
527   { NULL, NULL, NULL },
528 };
529 \f
530 /* Make our lives easier and use a static limit for the user name.
531    10k is way more than enough anyways... */
532 const int user_id_max_len = 10 * 1024;
533
534 static int
535 user_id_name (const char *option, int argc, char *argv[], void *cookie)
536 {
537   PKT_user_id *uid = cookie;
538   int l;
539
540   if (argc == 0)
541     log_fatal ("Usage: %s USER_ID\n", option);
542
543   if (uid->len)
544     log_fatal ("Attempt to set user id multiple times.\n");
545
546   l = strlen (argv[0]);
547   if (l > user_id_max_len)
548     log_fatal ("user id too long (max: %d)\n", user_id_max_len);
549
550   memcpy (uid->name, argv[0], l);
551   uid->name[l] = 0;
552   uid->len = l;
553
554   return 1;
555 }
556
557 static struct option user_id_options[] = {
558   { "", user_id_name,
559     "Set the user id.  This is usually in the format "
560     "\"Name (comment) <email@example.org>\"" },
561   { NULL, NULL,
562     "Example:\n\n"
563     "  $ gpgcompose --user-id \"USERID\" | " GPG_NAME " --list-packets" }
564 };
565
566 static int
567 user_id (const char *option, int argc, char *argv[], void *cookie)
568 {
569   iobuf_t out = cookie;
570   gpg_error_t err;
571   PKT_user_id *uid = xmalloc_clear (sizeof (*uid) + user_id_max_len);
572   int c = add_component (PKT_USER_ID, uid);
573   int processed;
574
575   processed = process_options (option,
576                                major_options,
577                                user_id_options, uid,
578                                global_options, NULL,
579                                argc, argv);
580
581   if (! uid->len)
582     log_fatal ("%s: user id not given", option);
583
584   err = build_packet (out, &components[c]);
585   if (err)
586     log_fatal ("Serializing user id packet: %s\n", gpg_strerror (err));
587
588   debug ("Wrote user id packet:\n");
589   dump_component (&components[c]);
590
591   return processed;
592 }
593 \f
594 static int
595 pk_search_terms (const char *option, int argc, char *argv[], void *cookie)
596 {
597   gpg_error_t err;
598   KEYDB_HANDLE hd;
599   KEYDB_SEARCH_DESC desc;
600   kbnode_t kb;
601   PKT_public_key *pk = cookie;
602   PKT_public_key *pk_ref;
603   int i;
604
605   if (argc == 0)
606     log_fatal ("Usage: %s KEYID\n", option);
607
608   if (pk->pubkey_algo)
609     log_fatal ("%s: multiple keys provided\n", option);
610
611   err = classify_user_id (argv[0], &desc, 0);
612   if (err)
613     log_fatal ("search terms '%s': %s\n", argv[0], gpg_strerror (err));
614
615   hd = keydb_new ();
616
617   err = keydb_search (hd, &desc, 1, NULL);
618   if (err)
619     log_fatal ("looking up '%s': %s\n", argv[0], gpg_strerror (err));
620
621   err = keydb_get_keyblock (hd, &kb);
622   if (err)
623     log_fatal ("retrieving keyblock for '%s': %s\n",
624                argv[0], gpg_strerror (err));
625
626   keydb_release (hd);
627
628   pk_ref = kb->pkt->pkt.public_key;
629
630   /* Copy the timestamp (if not already set), algo and public key
631      parameters.  */
632   if (! pk->timestamp)
633     pk->timestamp = pk_ref->timestamp;
634   pk->pubkey_algo = pk_ref->pubkey_algo;
635   for (i = 0; i < pubkey_get_npkey (pk->pubkey_algo); i ++)
636     pk->pkey[i] = gcry_mpi_copy (pk_ref->pkey[i]);
637
638   release_kbnode (kb);
639
640   return 1;
641 }
642
643 static int
644 pk_timestamp (const char *option, int argc, char *argv[], void *cookie)
645 {
646   PKT_public_key *pk = cookie;
647   char *tail = NULL;
648
649   if (argc == 0)
650     log_fatal ("Usage: %s TIMESTAMP\n", option);
651
652   errno = 0;
653   pk->timestamp = parse_timestamp (argv[0], &tail);
654   if (errno || (tail && *tail))
655     log_fatal ("Invalid value passed to %s (%s)\n", option, argv[0]);
656
657   return 1;
658 }
659
660 #define TIMESTAMP_HELP \
661   "Either as seconds since the epoch or as an ISO 8601 formatted " \
662   "string (yyyymmddThhmmss, where the T is a literal)."
663
664 static struct option pk_options[] = {
665   { "--timestamp", pk_timestamp,
666     "The creation time.  " TIMESTAMP_HELP },
667   { "", pk_search_terms,
668     "The key to copy the creation time and public key parameters from."  },
669   { NULL, NULL,
670     "Example:\n\n"
671     "  $ gpgcompose --public-key $KEYID --user-id \"USERID\" \\\n"
672     "  | " GPG_NAME " --list-packets" }
673 };
674
675 static int
676 public_key (const char *option, int argc, char *argv[], void *cookie)
677 {
678   gpg_error_t err;
679   iobuf_t out = cookie;
680   PKT_public_key *pk;
681   int c;
682   int processed;
683   int t = (strcmp (option, "--public-key") == 0
684            ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY);
685
686   (void) option;
687
688   pk = xmalloc_clear (sizeof (*pk));
689   pk->version = 4;
690
691   c = add_component (t, pk);
692
693   processed = process_options (option,
694                                major_options,
695                                pk_options, pk,
696                                global_options, NULL,
697                                argc, argv);
698
699   if (! pk->pubkey_algo)
700     log_fatal ("%s: key to extract public key parameters from not given",
701                option);
702
703   /* Clear the keyid in case we updated one of the relevant fields
704      after accessing it.  */
705   pk->keyid[0] = pk->keyid[1] = 0;
706
707   err = build_packet (out, &components[c]);
708   if (err)
709     log_fatal ("serializing %s packet: %s\n",
710                t == PKT_PUBLIC_KEY ? "public key" : "subkey",
711                gpg_strerror (err));
712
713   debug ("Wrote %s packet:\n",
714          t == PKT_PUBLIC_KEY ? "public key" : "subkey");
715   dump_component (&components[c]);
716
717   return processed;
718 }
719 \f
720 struct signinfo
721 {
722   /* Key with which to sign.  */
723   kbnode_t issuer_kb;
724   PKT_public_key *issuer_pk;
725
726   /* Overrides the issuer's key id.  */
727   u32 issuer_keyid[2];
728   /* Sets the issuer's keyid to the primary key's key id.  */
729   int issuer_keyid_self;
730
731   /* Key to sign.  */
732   PKT_public_key *pk;
733   /* Subkey to sign.  */
734   PKT_public_key *sk;
735   /* User id to sign.  */
736   PKT_user_id *uid;
737
738   int class;
739   int digest_algo;
740   u32 timestamp;
741   u32 key_expiration;
742
743   byte *cipher_algorithms;
744   int cipher_algorithms_len;
745   byte *digest_algorithms;
746   int digest_algorithms_len;
747   byte *compress_algorithms;
748   int compress_algorithms_len;
749
750   u32 expiration;
751
752   int exportable_set;
753   int exportable;
754
755   int revocable_set;
756   int revocable;
757
758   int trust_level_set;
759   byte trust_args[2];
760
761   char *trust_scope;
762
763   struct revocation_key *revocation_key;
764   int nrevocation_keys;
765
766   struct notation *notations;
767
768   byte *key_server_preferences;
769   int key_server_preferences_len;
770
771   char *key_server;
772
773   int primary_user_id_set;
774   int primary_user_id;
775
776   char *policy_uri;
777
778   byte *key_flags;
779   int key_flags_len;
780
781   char *signers_user_id;
782
783   byte reason_for_revocation_code;
784   char *reason_for_revocation;
785
786   byte *features;
787   int features_len;
788
789   /* Whether to corrupt the signature.  */
790   int corrupt;
791 };
792
793 static int
794 sig_issuer (const char *option, int argc, char *argv[], void *cookie)
795 {
796   gpg_error_t err;
797   KEYDB_HANDLE hd;
798   KEYDB_SEARCH_DESC desc;
799   struct signinfo *si = cookie;
800
801   if (argc == 0)
802     log_fatal ("Usage: %s KEYID\n", option);
803
804   if (si->issuer_pk)
805     log_fatal ("%s: multiple keys provided\n", option);
806
807   err = classify_user_id (argv[0], &desc, 0);
808   if (err)
809     log_fatal ("search terms '%s': %s\n", argv[0], gpg_strerror (err));
810
811   hd = keydb_new ();
812
813   err = keydb_search (hd, &desc, 1, NULL);
814   if (err)
815     log_fatal ("looking up '%s': %s\n", argv[0], gpg_strerror (err));
816
817   err = keydb_get_keyblock (hd, &si->issuer_kb);
818   if (err)
819     log_fatal ("retrieving keyblock for '%s': %s\n",
820                argv[0], gpg_strerror (err));
821
822   keydb_release (hd);
823
824   si->issuer_pk = si->issuer_kb->pkt->pkt.public_key;
825
826   return 1;
827 }
828
829 static int
830 sig_issuer_keyid (const char *option, int argc, char *argv[], void *cookie)
831 {
832   gpg_error_t err;
833   KEYDB_SEARCH_DESC desc;
834   struct signinfo *si = cookie;
835
836   if (argc == 0)
837     log_fatal ("Usage: %s KEYID|self\n", option);
838
839   if (si->issuer_keyid[0] || si->issuer_keyid[1] || si->issuer_keyid_self)
840     log_fatal ("%s given multiple times.\n", option);
841
842   if (strcasecmp (argv[0], "self") == 0)
843     {
844       si->issuer_keyid_self = 1;
845       return 1;
846     }
847
848   err = classify_user_id (argv[0], &desc, 0);
849   if (err)
850     log_fatal ("search terms '%s': %s\n", argv[0], gpg_strerror (err));
851
852   if (desc.mode != KEYDB_SEARCH_MODE_LONG_KID)
853     log_fatal ("%s is not a valid long key id.\n", argv[0]);
854
855   keyid_copy (si->issuer_keyid, desc.u.kid);
856
857   return 1;
858 }
859
860 static int
861 sig_pk (const char *option, int argc, char *argv[], void *cookie)
862 {
863   struct signinfo *si = cookie;
864   int i;
865   char *tail = NULL;
866
867   if (argc == 0)
868     log_fatal ("Usage: %s COMPONENT_INDEX\n", option);
869
870   errno = 0;
871   i = strtoul (argv[0], &tail, 10);
872   if (errno || (tail && *tail))
873     log_fatal ("Invalid value passed to %s (%s)\n", option, argv[0]);
874
875   if (i >= ncomponents)
876     log_fatal ("%d: No such component (have %d components so far)\n",
877                i, ncomponents);
878   if (! (components[i].pkttype == PKT_PUBLIC_KEY
879          || components[i].pkttype == PKT_PUBLIC_SUBKEY))
880     log_fatal ("Component %d is not a public key or a subkey.", i);
881
882   if (strcmp (option, "--pk") == 0)
883     {
884       if (si->pk)
885         log_fatal ("%s already given.\n", option);
886       si->pk = components[i].pkt.public_key;
887     }
888   else if (strcmp (option, "--sk") == 0)
889     {
890       if (si->sk)
891         log_fatal ("%s already given.\n", option);
892       si->sk = components[i].pkt.public_key;
893     }
894   else
895     log_fatal ("Cannot handle %s\n", option);
896
897   return 1;
898 }
899
900 static int
901 sig_user_id (const char *option, int argc, char *argv[], void *cookie)
902 {
903   struct signinfo *si = cookie;
904   int i;
905   char *tail = NULL;
906
907   if (argc == 0)
908     log_fatal ("Usage: %s COMPONENT_INDEX\n", option);
909   if (si->uid)
910     log_fatal ("%s already given.\n", option);
911
912   errno = 0;
913   i = strtoul (argv[0], &tail, 10);
914   if (errno || (tail && *tail))
915     log_fatal ("Invalid value passed to %s (%s)\n", option, argv[0]);
916
917   if (i >= ncomponents)
918     log_fatal ("%d: No such component (have %d components so far)\n",
919                i, ncomponents);
920   if (! (components[i].pkttype != PKT_USER_ID
921          || components[i].pkttype == PKT_ATTRIBUTE))
922     log_fatal ("Component %d is not a public key or a subkey.", i);
923
924   si->uid = components[i].pkt.user_id;
925
926   return 1;
927 }
928
929 static int
930 sig_class (const char *option, int argc, char *argv[], void *cookie)
931 {
932   struct signinfo *si = cookie;
933   int i;
934   char *tail = NULL;
935
936   if (argc == 0)
937     log_fatal ("Usage: %s CLASS\n", option);
938
939   errno = 0;
940   i = strtoul (argv[0], &tail, 0);
941   if (errno || (tail && *tail))
942     log_fatal ("Invalid value passed to %s (%s)\n", option, argv[0]);
943
944   si->class = i;
945
946   return 1;
947 }
948
949 static int
950 sig_digest (const char *option, int argc, char *argv[], void *cookie)
951 {
952   struct signinfo *si = cookie;
953   int i;
954   char *tail = NULL;
955
956   if (argc == 0)
957     log_fatal ("Usage: %s DIGEST_ALGO\n", option);
958
959   errno = 0;
960   i = strtoul (argv[0], &tail, 10);
961   if (errno || (tail && *tail))
962     log_fatal ("Invalid value passed to %s (%s)\n", option, argv[0]);
963
964   si->digest_algo = i;
965
966   return 1;
967 }
968
969 static int
970 sig_timestamp (const char *option, int argc, char *argv[], void *cookie)
971 {
972   struct signinfo *si = cookie;
973   char *tail = NULL;
974
975   if (argc == 0)
976     log_fatal ("Usage: %s TIMESTAMP\n", option);
977
978   errno = 0;
979   si->timestamp = parse_timestamp (argv[0], &tail);
980   if (errno || (tail && *tail))
981     log_fatal ("Invalid value passed to %s (%s)\n", option, argv[0]);
982
983   return 1;
984 }
985
986 static int
987 sig_expiration (const char *option, int argc, char *argv[], void *cookie)
988 {
989   struct signinfo *si = cookie;
990   int is_expiration = strcmp (option, "--expiration") == 0;
991   u32 *i = is_expiration ? &si->expiration : &si->key_expiration;
992
993   if (! is_expiration)
994     log_assert (strcmp (option, "--key-expiration") == 0);
995
996   if (argc == 0)
997     log_fatal ("Usage: %s DURATION\n", option);
998
999   *i = parse_expire_string (argv[0]);
1000   if (*i == (u32)-1)
1001     log_fatal ("Invalid value passed to %s (%s)\n", option, argv[0]);
1002
1003   return 1;
1004 }
1005
1006 static int
1007 sig_int_list (const char *option, int argc, char *argv[], void *cookie)
1008 {
1009   struct signinfo *si = cookie;
1010   int nvalues = 1;
1011   char *values = xmalloc (nvalues * sizeof (values[0]));
1012   char *tail = argv[0];
1013   int i;
1014   byte **a;
1015   int *n;
1016
1017   if (argc == 0)
1018     log_fatal ("Usage: %s VALUE[,VALUE...]\n", option);
1019
1020   for (i = 0; tail && *tail; i ++)
1021     {
1022       int v;
1023       char *old_tail = tail;
1024
1025       errno = 0;
1026       v = strtol (tail, &tail, 0);
1027       if (errno || old_tail == tail || (tail && !(*tail == ',' || *tail == 0)))
1028         log_fatal ("Invalid value passed to %s (%s).  "
1029                    "Expected a list of comma separated numbers\n",
1030                    option, argv[0]);
1031
1032       if (! (0 <= v && v <= 255))
1033         log_fatal ("%s: %d is out of range (Expected: 0-255)\n", option, v);
1034
1035       if (i == nvalues)
1036         {
1037           nvalues *= 2;
1038           values = xrealloc (values, nvalues * sizeof (values[0]));
1039         }
1040
1041       values[i] = v;
1042
1043       if (*tail == ',')
1044         tail ++;
1045       else
1046         log_assert (*tail == 0);
1047     }
1048
1049   if (strcmp ("--cipher-algos", option) == 0)
1050     {
1051       a = &si->cipher_algorithms;
1052       n = &si->cipher_algorithms_len;
1053     }
1054   else if (strcmp ("--digest-algos", option) == 0)
1055     {
1056       a = &si->digest_algorithms;
1057       n = &si->digest_algorithms_len;
1058     }
1059   else if (strcmp ("--compress-algos", option) == 0)
1060     {
1061       a = &si->compress_algorithms;
1062       n = &si->compress_algorithms_len;
1063     }
1064   else
1065     log_fatal ("Cannot handle %s\n", option);
1066
1067   if (*a)
1068     log_fatal ("Option %s given multiple times.\n", option);
1069
1070   *a = values;
1071   *n = i;
1072
1073   return 1;
1074 }
1075
1076 static int
1077 sig_flag (const char *option, int argc, char *argv[], void *cookie)
1078 {
1079   struct signinfo *si = cookie;
1080   int range[2] = {0, 255};
1081   char *tail;
1082   int v;
1083
1084   if (strcmp (option, "--primary-user-id") == 0)
1085     range[1] = 1;
1086
1087   if (argc <= 1)
1088     {
1089       if (range[0] == 0 && range[1] == 1)
1090         log_fatal ("Usage: %s 0|1\n", option);
1091       else
1092         log_fatal ("Usage: %s %d-%d\n", option, range[0], range[1]);
1093     }
1094
1095   errno = 0;
1096   v = strtol (argv[0], &tail, 0);
1097   if (errno || (tail && *tail) || !(range[0] <= v && v <= range[1]))
1098     log_fatal ("Invalid value passed to %s (%s).  Expected %d-%d\n",
1099                option, argv[0], range[0], range[1]);
1100
1101   if (strcmp (option, "--exportable") == 0)
1102     {
1103       si->exportable_set = 1;
1104       si->exportable = v;
1105     }
1106   else if (strcmp (option, "--revocable") == 0)
1107     {
1108       si->revocable_set = 1;
1109       si->revocable = v;
1110     }
1111   else if (strcmp (option, "--primary-user-id") == 0)
1112     {
1113       si->primary_user_id_set = 1;
1114       si->primary_user_id = v;
1115     }
1116   else
1117     log_fatal ("Cannot handle %s\n", option);
1118
1119   return 1;
1120 }
1121
1122 static int
1123 sig_trust_level (const char *option, int argc, char *argv[], void *cookie)
1124 {
1125   struct signinfo *si = cookie;
1126   int i;
1127   char *tail;
1128
1129   if (argc <= 1)
1130     log_fatal ("Usage: %s DEPTH TRUST_AMOUNT\n", option);
1131
1132   for (i = 0; i < sizeof (si->trust_args) / sizeof (si->trust_args[0]); i ++)
1133     {
1134       int v;
1135
1136       errno = 0;
1137       v = strtol (argv[i], &tail, 0);
1138       if (errno || (tail && *tail) || !(0 <= v && v <= 255))
1139         log_fatal ("Invalid value passed to %s (%s).  Expected 0-255\n",
1140                    option, argv[i]);
1141
1142       si->trust_args[i] = v;
1143     }
1144
1145   si->trust_level_set = 1;
1146
1147   return 2;
1148 }
1149
1150 static int
1151 sig_string_arg (const char *option, int argc, char *argv[], void *cookie)
1152 {
1153   struct signinfo *si = cookie;
1154   char *p = argv[0];
1155   char **s;
1156
1157   if (argc == 0)
1158     log_fatal ("Usage: %s STRING\n", option);
1159
1160   if (strcmp (option, "--trust-scope") == 0)
1161     s = &si->trust_scope;
1162   else if (strcmp (option, "--key-server") == 0)
1163     s = &si->key_server;
1164   else if (strcmp (option, "--signers-user-id") == 0)
1165     s = &si->signers_user_id;
1166   else if (strcmp (option, "--policy-uri") == 0)
1167     s = &si->policy_uri;
1168   else
1169     log_fatal ("Cannot handle %s\n", option);
1170
1171   if (*s)
1172     log_fatal ("%s already given.\n", option);
1173
1174   *s = xstrdup (p);
1175
1176   return 1;
1177 }
1178
1179 static int
1180 sig_revocation_key (const char *option, int argc, char *argv[], void *cookie)
1181 {
1182   gpg_error_t err;
1183   struct signinfo *si = cookie;
1184   int v;
1185   char *tail;
1186   PKT_public_key pk;
1187   struct revocation_key *revkey;
1188
1189   if (argc < 2)
1190     log_fatal ("Usage: %s CLASS KEYID\n", option);
1191
1192   memset (&pk, 0, sizeof (pk));
1193
1194   errno = 0;
1195   v = strtol (argv[0], &tail, 16);
1196   if (errno || (tail && *tail) || !(0 <= v && v <= 255))
1197     log_fatal ("%s: Invalid class value (%s).  Expected 0-255\n",
1198                option, argv[0]);
1199
1200   pk.req_usage = PUBKEY_USAGE_SIG;
1201   err = get_pubkey_byname (NULL, NULL, &pk, argv[1], NULL, NULL, 1, 1);
1202   if (err)
1203     log_fatal ("looking up key %s: %s\n", argv[1], gpg_strerror (err));
1204
1205   si->nrevocation_keys ++;
1206   si->revocation_key = xrealloc (si->revocation_key,
1207                                  si->nrevocation_keys
1208                                  * sizeof (*si->revocation_key));
1209   revkey = &si->revocation_key[si->nrevocation_keys - 1];
1210
1211   revkey->class = v;
1212   revkey->algid = pk.pubkey_algo;
1213   fingerprint_from_pk (&pk, revkey->fpr, NULL);
1214
1215   release_public_key_parts (&pk);
1216
1217   return 2;
1218 }
1219
1220 static int
1221 sig_notation (const char *option, int argc, char *argv[], void *cookie)
1222 {
1223   struct signinfo *si = cookie;
1224   int is_blob = strcmp (option, "--notation") != 0;
1225   struct notation *notation;
1226   char *p = argv[0];
1227   int p_free = 0;
1228   char *data;
1229   int data_size;
1230   int data_len;
1231
1232   if (argc == 0)
1233     log_fatal ("Usage: %s [!<]name=value\n", option);
1234
1235   if ((p[0] == '!' && p[1] == '<') || p[0] == '<')
1236     /* Read from a file.  */
1237     {
1238       char *filename = NULL;
1239       iobuf_t in;
1240       int prefix;
1241
1242       if (p[0] == '<')
1243         p ++;
1244       else
1245         {
1246           /* Remove the '<', which string_to_notation does not
1247              understand, and preserve the '!'.  */
1248           p = xstrdup (&p[1]);
1249           p_free = 1;
1250           p[0] = '!';
1251         }
1252
1253       filename = strchr (p, '=');
1254       if (! filename)
1255         log_fatal ("No value specified.  Usage: %s [!<]name=value\n",
1256                    option);
1257       filename ++;
1258
1259       prefix = (size_t) filename - (size_t) p;
1260
1261       errno = 0;
1262       in = iobuf_open (filename);
1263       if (! in)
1264         log_fatal ("Opening '%s': %s\n",
1265                    filename, errno ? strerror (errno): "unknown error");
1266
1267       /* A notation can be at most about a few dozen bytes short of
1268          64k.  Since this is relatively small, we just allocate that
1269          much instead of trying to dynamically size a buffer.  */
1270       data_size = 64 * 1024;
1271       data = xmalloc (data_size);
1272       log_assert (prefix <= data_size);
1273       memcpy (data, p, prefix);
1274
1275       data_len = iobuf_read (in, &data[prefix], data_size - prefix - 1);
1276       if (data_len == -1)
1277         /* EOF => 0 bytes read.  */
1278         data_len = 0;
1279
1280       if (data_len == data_size - prefix - 1)
1281         /* Technically, we should do another read and check for EOF,
1282            but what's one byte more or less?  */
1283         log_fatal ("Notation data doesn't fit in the packet.\n");
1284
1285       iobuf_close (in);
1286
1287       /* NUL terminate it.  */
1288       data[prefix + data_len] = 0;
1289
1290       if (p_free)
1291         xfree (p);
1292       p = data;
1293       p_free = 1;
1294       data = &p[prefix];
1295
1296       if (is_blob)
1297         p[prefix - 1] = 0;
1298     }
1299   else if (is_blob)
1300     {
1301       data = strchr (p, '=');
1302       if (! data)
1303         {
1304           data = p;
1305           data_len = 0;
1306         }
1307       else
1308         {
1309           p = xstrdup (p);
1310           p_free = 1;
1311
1312           data = strchr (p, '=');
1313           log_assert (data);
1314
1315           /* NUL terminate the name.  */
1316           *data = 0;
1317           data ++;
1318           data_len = strlen (data);
1319         }
1320     }
1321
1322   if (is_blob)
1323     notation = blob_to_notation (p, data, data_len);
1324   else
1325     notation = string_to_notation (p, 1);
1326   if (! notation)
1327     log_fatal ("creating notation: an unknown error occurred.\n");
1328   notation->next = si->notations;
1329   si->notations = notation;
1330
1331   if (p_free)
1332     xfree (p);
1333
1334   return 1;
1335 }
1336
1337 static int
1338 sig_big_endian_arg (const char *option, int argc, char *argv[], void *cookie)
1339 {
1340   struct signinfo *si = cookie;
1341   char *p = argv[0];
1342   int i;
1343   int l;
1344   char *bytes;
1345
1346   if (argc == 0)
1347     log_fatal ("Usage: %s HEXDIGITS\n", option);
1348
1349   /* Skip a leading "0x".  */
1350   if (p[0] == '0' && p[1] == 'x')
1351     p += 2;
1352
1353   for (i = 0; i < strlen (p); i ++)
1354     if (!hexdigitp (&p[i]))
1355       log_fatal ("%s: argument ('%s') must consist of hex digits.\n",
1356                  option, p);
1357   if (strlen (p) % 2 != 0)
1358       log_fatal ("%s: argument ('%s') must contain an even number of hex digits.\n",
1359                  option, p);
1360
1361   l = strlen (p) / 2;
1362   bytes = xmalloc (l);
1363   hex2bin (p, bytes, l);
1364
1365   if (strcmp (option, "--key-server-preferences") == 0)
1366     {
1367       if (si->key_server_preferences)
1368         log_fatal ("%s given multiple times.\n", option);
1369       si->key_server_preferences = bytes;
1370       si->key_server_preferences_len = l;
1371     }
1372   else if (strcmp (option, "--key-flags") == 0)
1373     {
1374       if (si->key_flags)
1375         log_fatal ("%s given multiple times.\n", option);
1376       si->key_flags = bytes;
1377       si->key_flags_len = l;
1378     }
1379   else if (strcmp (option, "--features") == 0)
1380     {
1381       if (si->features)
1382         log_fatal ("%s given multiple times.\n", option);
1383       si->features = bytes;
1384       si->features_len = l;
1385     }
1386   else
1387     log_fatal ("Cannot handle %s\n", option);
1388
1389   return 1;
1390 }
1391
1392 static int
1393 sig_reason_for_revocation (const char *option, int argc, char *argv[], void *cookie)
1394 {
1395   struct signinfo *si = cookie;
1396   int v;
1397   char *tail;
1398
1399   if (argc < 2)
1400     log_fatal ("Usage: %s REASON_CODE REASON_STRING\n", option);
1401
1402   errno = 0;
1403   v = strtol (argv[0], &tail, 16);
1404   if (errno || (tail && *tail) || !(0 <= v && v <= 255))
1405     log_fatal ("%s: Invalid reason code (%s).  Expected 0-255\n",
1406                option, argv[0]);
1407
1408   if (si->reason_for_revocation)
1409     log_fatal ("%s given multiple times.\n", option);
1410
1411   si->reason_for_revocation_code = v;
1412   si->reason_for_revocation = xstrdup (argv[1]);
1413
1414   return 2;
1415 }
1416
1417 static int
1418 sig_corrupt (const char *option, int argc, char *argv[], void *cookie)
1419 {
1420   struct signinfo *si = cookie;
1421
1422   (void) option;
1423   (void) argc;
1424   (void) argv;
1425   (void) cookie;
1426
1427   si->corrupt = 1;
1428
1429   return 0;
1430 }
1431
1432 static struct option sig_options[] = {
1433   { "--issuer", sig_issuer,
1434     "The key to use to generate the signature."},
1435   { "--issuer-keyid", sig_issuer_keyid,
1436     "Set the issuer's key id.  This is useful for creating a "
1437     "self-signature.  As a special case, the value \"self\" refers "
1438     "to the primary key's key id.  "
1439     "(RFC 4880, Section 5.2.3.5)" },
1440   { "--pk", sig_pk,
1441     "The primary keyas an index into the components (keys and uids) "
1442     "created so far where the first component has the index 0." },
1443   { "--sk", sig_pk,
1444     "The subkey as an index into the components (keys and uids) created "
1445     "so far where the first component has the index 0.  Only needed for "
1446     "0x18, 0x19, and 0x28 signatures." },
1447   { "--user-id", sig_user_id,
1448     "The user id as an index into the components (keys and uids) created "
1449     "so far where the first component has the index 0.  Only needed for "
1450     "0x10-0x13 and 0x30 signatures." },
1451   { "--class", sig_class,
1452     "The signature's class.  Valid values are "
1453     "0x10-0x13 (user id and primary-key certification), "
1454     "0x18 (subkey binding), "
1455     "0x19 (primary key binding), "
1456     "0x1f (direct primary key signature), "
1457     "0x20 (key revocation), "
1458     "0x28 (subkey revocation), and "
1459     "0x30 (certification revocation)."
1460   },
1461   { "--digest", sig_digest, "The digest algorithm" },
1462   { "--timestamp", sig_timestamp,
1463     "The signature's creation time.  " TIMESTAMP_HELP "  0 means now.  "
1464     "(RFC 4880, Section 5.2.3.4)" },
1465   { "--key-expiration", sig_expiration,
1466     "The number of days until the associated key expires.  To specify "
1467     "seconds, prefix the value with \"seconds=\".  It is also possible "
1468     "to use 'y', 'm' and 'w' as simple multipliers.  For instance, 2y "
1469     "means 2 years, etc.  "
1470     "(RFC 4880, Section 5.2.3.6)" },
1471   { "--cipher-algos", sig_int_list,
1472     "A comma separated list of the preferred cipher algorithms (identified by "
1473     "their number, see RFC 4880, Section 9).  "
1474     "(RFC 4880, Section 5.2.3.7)" },
1475   { "--digest-algos", sig_int_list,
1476     "A comma separated list of the preferred algorithms (identified by "
1477     "their number, see RFC 4880, Section 9).  "
1478     "(RFC 4880, Section 5.2.3.8)" },
1479   { "--compress-algos", sig_int_list,
1480     "A comma separated list of the preferred algorithms (identified by "
1481     "their number, see RFC 4880, Section 9)."
1482     "(RFC 4880, Section 5.2.3.9)" },
1483   { "--expiration", sig_expiration,
1484     "The number of days until the signature expires.  To specify seconds, "
1485     "prefix the value with \"seconds=\".  It is also possible to use 'y', "
1486     "'m' and 'w' as simple multipliers.  For instance, 2y means 2 years, "
1487     "etc.  "
1488     "(RFC 4880, Section 5.2.3.10)" },
1489   { "--exportable", sig_flag,
1490     "Mark this signature as exportable (1) or local (0).  "
1491     "(RFC 4880, Section 5.2.3.11)" },
1492   { "--revocable", sig_flag,
1493     "Mark this signature as revocable (1, revocations are ignored) "
1494     "or non-revocable (0).  "
1495     "(RFC 4880, Section 5.2.3.12)" },
1496   { "--trust-level", sig_trust_level,
1497     "Set the trust level.  This takes two integer arguments (0-255): "
1498     "the trusted-introducer level and the degree of trust.  "
1499     "(RFC 4880, Section 5.2.3.13.)" },
1500   { "--trust-scope", sig_string_arg,
1501     "A regular expression that limits the scope of --trust-level.  "
1502     "(RFC 4880, Section 5.2.3.14.)" },
1503   { "--revocation-key", sig_revocation_key,
1504     "Specify a designated revoker.  Takes two arguments: the class "
1505     "(normally 0x80 or 0xC0 (sensitive)) and the key id of the "
1506     "designatured revoker.  May be given multiple times.  "
1507     "(RFC 4880, Section 5.2.3.15)" },
1508   { "--notation", sig_notation,
1509     "Add a human-readable notation of the form \"[!<]name=value\" where "
1510     "\"!\" means that the critical flag should be set and \"<\" means "
1511     "that VALUE is a file to read the data from.  "
1512     "(RFC 4880, Section 5.2.3.16)" },
1513   { "--notation-binary", sig_notation,
1514     "Add a binary notation of the form \"[!<]name=value\" where "
1515     "\"!\" means that the critical flag should be set and \"<\" means "
1516     "that VALUE is a file to read the data from.  "
1517     "(RFC 4880, Section 5.2.3.16)" },
1518   { "--key-server-preferences", sig_big_endian_arg,
1519     "Big-endian number encoding the keyserver preferences. "
1520     "(RFC 4880, Section 5.2.3.17)" },
1521   { "--key-server", sig_string_arg,
1522     "The preferred keyserver.  (RFC 4880, Section 5.2.3.18)" },
1523   { "--primary-user-id", sig_flag,
1524     "Sets the primary user id flag.  (RFC 4880, Section 5.2.3.19)" },
1525   { "--policy-uri", sig_string_arg,
1526     "URI of a document that describes the issuer's signing policy.  "
1527     "(RFC 4880, Section 5.2.3.20)" },
1528   { "--key-flags", sig_big_endian_arg,
1529     "Big-endian number encoding the key flags. "
1530     "(RFC 4880, Section 5.2.3.21)" },
1531   { "--signers-user-id", sig_string_arg,
1532     "The user id (as a string) responsible for the signing.  "
1533     "(RFC 4880, Section 5.2.3.22)" },
1534   { "--reason-for-revocation", sig_reason_for_revocation,
1535     "Takes two arguments: a reason for revocation code and a "
1536     "user-provided string.  "
1537     "(RFC 4880, Section 5.2.3.23)" },
1538   { "--features", sig_big_endian_arg,
1539     "Big-endian number encoding the feature flags. "
1540     "(RFC 4880, Section 5.2.3.24)" },
1541   { "--signature-target", NULL,
1542     "Takes three arguments: the target signature's public key algorithm "
1543     " (as an integer), the hash algorithm (as an integer) and the hash "
1544     " (as a hexadecimal string).  "
1545     "(RFC 4880, Section 5.2.3.25)" },
1546   { "--embedded-signature", NULL,
1547     "An embedded signature.  This must be immediately followed by a "
1548     "signature packet (created using --signature ...) or a filename "
1549     "containing the packet."
1550     "(RFC 4880, Section 5.2.3.26)" },
1551   { "--hashed", NULL,
1552     "The following attributes will be placed in the hashed area of "
1553     "the signature.  (This is the default and it reset at the end of"
1554     "each signature.)" },
1555   { "--unhashed", NULL,
1556     "The following attributes will be placed in the unhashed area of "
1557     "the signature (and thus not integrity protected)." },
1558   { "--corrupt", sig_corrupt,
1559     "Corrupt the signature." },
1560   { NULL, NULL,
1561     "Example:\n\n"
1562     "  $ gpgcompose --public-key $KEYID --user-id USERID \\\n"
1563     "  --signature --class 0x10 --issuer $KEYID --issuer-keyid self \\\n"
1564     "  | " GPG_NAME " --list-packets"}
1565 };
1566
1567 static int
1568 mksubpkt_callback (PKT_signature *sig, void *cookie)
1569 {
1570   struct signinfo *si = cookie;
1571   int i;
1572
1573   if (si->key_expiration)
1574     {
1575       char buf[4];
1576       buf[0] = (si->key_expiration >> 24) & 0xff;
1577       buf[1] = (si->key_expiration >> 16) & 0xff;
1578       buf[2] = (si->key_expiration >>  8) & 0xff;
1579       buf[3] = si->key_expiration & 0xff;
1580       build_sig_subpkt (sig, SIGSUBPKT_KEY_EXPIRE, buf, 4);
1581     }
1582
1583   if (si->cipher_algorithms)
1584     build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM,
1585                       si->cipher_algorithms,
1586                       si->cipher_algorithms_len);
1587
1588   if (si->digest_algorithms)
1589     build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH,
1590                       si->digest_algorithms,
1591                       si->digest_algorithms_len);
1592
1593   if (si->compress_algorithms)
1594     build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR,
1595                       si->compress_algorithms,
1596                       si->compress_algorithms_len);
1597
1598   if (si->exportable_set)
1599     {
1600       char buf = si->exportable;
1601       build_sig_subpkt (sig, SIGSUBPKT_EXPORTABLE, &buf, 1);
1602     }
1603
1604   if (si->trust_level_set)
1605     build_sig_subpkt (sig, SIGSUBPKT_TRUST,
1606                       si->trust_args, sizeof (si->trust_args));
1607
1608   if (si->trust_scope)
1609     build_sig_subpkt (sig, SIGSUBPKT_REGEXP,
1610                       si->trust_scope, strlen (si->trust_scope));
1611
1612   for (i = 0; i < si->nrevocation_keys; i ++)
1613     {
1614       struct revocation_key *revkey = &si->revocation_key[i];
1615       gpg_error_t err = keygen_add_revkey (sig, revkey);
1616       if (err)
1617         {
1618           u32 keyid[2];
1619           keyid_from_fingerprint (global_ctrl, revkey->fpr, 20, keyid);
1620           log_fatal ("adding revocation key %s: %s\n",
1621                      keystr (keyid), gpg_strerror (err));
1622         }
1623     }
1624
1625   /* keygen_add_revkey sets revocable=0 so be sure to do this after
1626      adding the rev keys.  */
1627   if (si->revocable_set)
1628     {
1629       char buf = si->revocable;
1630       build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, &buf, 1);
1631     }
1632
1633   keygen_add_notations (sig, si->notations);
1634
1635   if (si->key_server_preferences)
1636     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS,
1637                       si->key_server_preferences,
1638                       si->key_server_preferences_len);
1639
1640   if (si->key_server)
1641     build_sig_subpkt (sig, SIGSUBPKT_PREF_KS,
1642                       si->key_server, strlen (si->key_server));
1643
1644   if (si->primary_user_id_set)
1645     {
1646       char buf = si->primary_user_id;
1647       build_sig_subpkt (sig, SIGSUBPKT_PRIMARY_UID, &buf, 1);
1648     }
1649
1650   if (si->policy_uri)
1651     build_sig_subpkt (sig, SIGSUBPKT_POLICY,
1652                       si->policy_uri, strlen (si->policy_uri));
1653
1654   if (si->key_flags)
1655     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS,
1656                       si->key_flags, si->key_flags_len);
1657
1658   if (si->signers_user_id)
1659     build_sig_subpkt (sig, SIGSUBPKT_SIGNERS_UID,
1660                       si->signers_user_id, strlen (si->signers_user_id));
1661
1662   if (si->reason_for_revocation)
1663     {
1664       int len = 1 + strlen (si->reason_for_revocation);
1665       char *buf;
1666
1667       buf = xmalloc (len);
1668
1669       buf[0] = si->reason_for_revocation_code;
1670       memcpy (&buf[1], si->reason_for_revocation, len - 1);
1671
1672       build_sig_subpkt (sig, SIGSUBPKT_REVOC_REASON, buf, len);
1673
1674       xfree (buf);
1675     }
1676
1677   if (si->features)
1678     build_sig_subpkt (sig, SIGSUBPKT_FEATURES,
1679                       si->features, si->features_len);
1680
1681   return 0;
1682 }
1683
1684 static int
1685 signature (const char *option, int argc, char *argv[], void *cookie)
1686 {
1687   gpg_error_t err;
1688   iobuf_t out = cookie;
1689   struct signinfo si;
1690   int processed;
1691   PKT_public_key *pk;
1692   PKT_signature *sig;
1693   PACKET pkt;
1694   u32 keyid_orig[2], keyid[2];
1695
1696   (void) option;
1697
1698   memset (&si, 0, sizeof (si));
1699   memset (&pkt, 0, sizeof (pkt));
1700
1701   processed = process_options (option,
1702                                major_options,
1703                                sig_options, &si,
1704                                global_options, NULL,
1705                                argc, argv);
1706
1707   if (ncomponents)
1708     {
1709       int pkttype = components[ncomponents - 1].pkttype;
1710
1711       if (pkttype == PKT_PUBLIC_KEY)
1712         {
1713           if (! si.class)
1714             /* Direct key sig.  */
1715             si.class = 0x1F;
1716         }
1717       else if (pkttype == PKT_PUBLIC_SUBKEY)
1718         {
1719           if (! si.sk)
1720             si.sk = components[ncomponents - 1].pkt.public_key;
1721           if (! si.class)
1722             /* Subkey binding sig.  */
1723             si.class = 0x18;
1724         }
1725       else if (pkttype == PKT_USER_ID)
1726         {
1727           if (! si.uid)
1728             si.uid = components[ncomponents - 1].pkt.user_id;
1729           if (! si.class)
1730             /* Certification of a user id and public key packet.  */
1731             si.class = 0x10;
1732         }
1733     }
1734
1735   pk = NULL;
1736   if (! si.pk || ! si.issuer_pk)
1737     /* No primary key specified.  Default to the first one that we
1738        find.  */
1739     {
1740       int i;
1741       for (i = 0; i < ncomponents; i ++)
1742         if (components[i].pkttype == PKT_PUBLIC_KEY)
1743           {
1744             pk = components[i].pkt.public_key;
1745             break;
1746           }
1747     }
1748
1749   if (! si.pk)
1750     {
1751       if (! pk)
1752         log_fatal ("%s: no primary key given and no primary key available",
1753                    "--pk");
1754       si.pk = pk;
1755     }
1756   if (! si.issuer_pk)
1757     {
1758       if (! pk)
1759         log_fatal ("%s: no issuer key given and no primary key available",
1760                    "--issuer");
1761       si.issuer_pk = pk;
1762     }
1763
1764   if (si.class == 0x18 || si.class == 0x19 || si.class == 0x28)
1765     /* Requires the primary key and a subkey.  */
1766     {
1767       if (! si.sk)
1768         log_fatal ("sig class 0x%x requires a subkey (--sk)\n", si.class);
1769     }
1770   else if (si.class == 0x10
1771            || si.class == 0x11
1772            || si.class == 0x12
1773            || si.class == 0x13
1774            || si.class == 0x30)
1775     /* Requires the primary key and a user id.  */
1776     {
1777       if (! si.uid)
1778         log_fatal ("sig class 0x%x requires a uid (--uid)\n", si.class);
1779     }
1780   else if (si.class == 0x1F || si.class == 0x20)
1781     /* Just requires the primary key.  */
1782     ;
1783   else
1784     log_fatal ("Unsupported signature class: 0x%x\n", si.class);
1785
1786   sig = xmalloc_clear (sizeof (*sig));
1787
1788   /* Save SI.ISSUER_PK->KEYID.  */
1789   keyid_copy (keyid_orig, pk_keyid (si.issuer_pk));
1790   if (si.issuer_keyid[0] || si.issuer_keyid[1])
1791     keyid_copy (si.issuer_pk->keyid, si.issuer_keyid);
1792   else if (si.issuer_keyid_self)
1793     {
1794       PKT_public_key *pripk = primary_key();
1795       if (! pripk)
1796         log_fatal ("--issuer-keyid self given, but no primary key available.\n");
1797       keyid_copy (si.issuer_pk->keyid, pk_keyid (pripk));
1798     }
1799
1800   /* Changing the issuer's key id is fragile.  Check to make sure
1801      make_keysig_packet didn't recompute the keyid.  */
1802   keyid_copy (keyid, si.issuer_pk->keyid);
1803   err = make_keysig_packet (global_ctrl,
1804                             &sig, si.pk, si.uid, si.sk, si.issuer_pk,
1805                             si.class, si.digest_algo,
1806                             si.timestamp, si.expiration,
1807                             mksubpkt_callback, &si, NULL);
1808   log_assert (keyid_cmp (keyid, si.issuer_pk->keyid) == 0);
1809   if (err)
1810     log_fatal ("Generating signature: %s\n", gpg_strerror (err));
1811
1812   /* Restore SI.PK->KEYID.  */
1813   keyid_copy (si.issuer_pk->keyid, keyid_orig);
1814
1815   if (si.corrupt)
1816     {
1817       /* Set the top 32-bits to 0xBAD0DEAD.  */
1818       int bits = gcry_mpi_get_nbits (sig->data[0]);
1819       gcry_mpi_t x = gcry_mpi_new (0);
1820       gcry_mpi_add_ui (x, x, 0xBAD0DEAD);
1821       gcry_mpi_lshift (x, x, bits > 32 ? bits - 32 : bits);
1822       gcry_mpi_clear_highbit (sig->data[0], bits > 32 ? bits - 32 : 0);
1823       gcry_mpi_add (sig->data[0], sig->data[0], x);
1824       gcry_mpi_release (x);
1825     }
1826
1827   pkt.pkttype = PKT_SIGNATURE;
1828   pkt.pkt.signature = sig;
1829
1830   err = build_packet (out, &pkt);
1831   if (err)
1832     log_fatal ("serializing public key packet: %s\n", gpg_strerror (err));
1833
1834   debug ("Wrote signature packet:\n");
1835   dump_component (&pkt);
1836
1837   xfree (sig);
1838   release_kbnode (si.issuer_kb);
1839   xfree (si.revocation_key);
1840
1841   return processed;
1842 }
1843 \f
1844 struct sk_esk_info
1845 {
1846   /* The cipher used for encrypting the session key (when a session
1847      key is used).  */
1848   int cipher;
1849   /* The cipher used for encryping the SED packet.  */
1850   int sed_cipher;
1851
1852   /* S2K related data.  */
1853   int hash;
1854   int mode;
1855   int mode_set;
1856   byte salt[8];
1857   int salt_set;
1858   int iterations;
1859
1860   /* If applying the S2K function to the passphrase is the session key
1861      or if it is the decryption key for the session key.  */
1862   int s2k_is_session_key;
1863   /* Generate a new, random session key.  */
1864   int new_session_key;
1865
1866   /* The unencrypted session key.  */
1867   int session_key_len;
1868   char *session_key;
1869
1870   char *password;
1871 };
1872
1873 static int
1874 sk_esk_cipher (const char *option, int argc, char *argv[], void *cookie)
1875 {
1876   struct sk_esk_info *si = cookie;
1877   char *usage = "integer|IDEA|3DES|CAST5|BLOWFISH|AES|AES192|AES256|CAMELLIA128|CAMELLIA192|CAMELLIA256";
1878   int cipher;
1879
1880   if (argc == 0)
1881     log_fatal ("Usage: %s %s\n", option, usage);
1882
1883   if (strcasecmp (argv[0], "IDEA") == 0)
1884     cipher = CIPHER_ALGO_IDEA;
1885   else if (strcasecmp (argv[0], "3DES") == 0)
1886     cipher = CIPHER_ALGO_3DES;
1887   else if (strcasecmp (argv[0], "CAST5") == 0)
1888     cipher = CIPHER_ALGO_CAST5;
1889   else if (strcasecmp (argv[0], "BLOWFISH") == 0)
1890     cipher = CIPHER_ALGO_BLOWFISH;
1891   else if (strcasecmp (argv[0], "AES") == 0)
1892     cipher = CIPHER_ALGO_AES;
1893   else if (strcasecmp (argv[0], "AES192") == 0)
1894     cipher = CIPHER_ALGO_AES192;
1895   else if (strcasecmp (argv[0], "TWOFISH") == 0)
1896     cipher = CIPHER_ALGO_TWOFISH;
1897   else if (strcasecmp (argv[0], "CAMELLIA128") == 0)
1898     cipher = CIPHER_ALGO_CAMELLIA128;
1899   else if (strcasecmp (argv[0], "CAMELLIA192") == 0)
1900     cipher = CIPHER_ALGO_CAMELLIA192;
1901   else if (strcasecmp (argv[0], "CAMELLIA256") == 0)
1902     cipher = CIPHER_ALGO_CAMELLIA256;
1903   else
1904     {
1905       char *tail;
1906       int v;
1907
1908       errno = 0;
1909       v = strtol (argv[0], &tail, 0);
1910       if (errno || (tail && *tail) || ! valid_cipher (v))
1911         log_fatal ("Invalid or unsupported value.  Usage: %s %s\n",
1912                    option, usage);
1913
1914       cipher = v;
1915     }
1916
1917   if (strcmp (option, "--cipher") == 0)
1918     {
1919       if (si->cipher)
1920         log_fatal ("%s given multiple times.", option);
1921       si->cipher = cipher;
1922     }
1923   else if (strcmp (option, "--sed-cipher") == 0)
1924     {
1925       if (si->sed_cipher)
1926         log_fatal ("%s given multiple times.", option);
1927       si->sed_cipher = cipher;
1928     }
1929
1930   return 1;
1931 }
1932
1933 static int
1934 sk_esk_mode (const char *option, int argc, char *argv[], void *cookie)
1935 {
1936   struct sk_esk_info *si = cookie;
1937   char *usage = "integer|simple|salted|iterated";
1938
1939   if (argc == 0)
1940     log_fatal ("Usage: %s %s\n", option, usage);
1941
1942   if (si->mode)
1943     log_fatal ("%s given multiple times.", option);
1944
1945   if (strcasecmp (argv[0], "simple") == 0)
1946     si->mode = 0;
1947   else if (strcasecmp (argv[0], "salted") == 0)
1948     si->mode = 1;
1949   else if (strcasecmp (argv[0], "iterated") == 0)
1950     si->mode = 3;
1951   else
1952     {
1953       char *tail;
1954       int v;
1955
1956       errno = 0;
1957       v = strtol (argv[0], &tail, 0);
1958       if (errno || (tail && *tail) || ! (v == 0 || v == 1 || v == 3))
1959         log_fatal ("Invalid or unsupported value.  Usage: %s %s\n",
1960                    option, usage);
1961
1962       si->mode = v;
1963     }
1964
1965   si->mode_set = 1;
1966
1967   return 1;
1968 }
1969
1970 static int
1971 sk_esk_hash_algorithm (const char *option, int argc, char *argv[], void *cookie)
1972 {
1973   struct sk_esk_info *si = cookie;
1974   char *usage = "integer|MD5|SHA1|RMD160|SHA256|SHA384|SHA512|SHA224";
1975
1976   if (argc == 0)
1977     log_fatal ("Usage: %s %s\n", option, usage);
1978
1979   if (si->hash)
1980     log_fatal ("%s given multiple times.", option);
1981
1982   if (strcasecmp (argv[0], "MD5") == 0)
1983     si->hash = DIGEST_ALGO_MD5;
1984   else if (strcasecmp (argv[0], "SHA1") == 0)
1985     si->hash = DIGEST_ALGO_SHA1;
1986   else if (strcasecmp (argv[0], "RMD160") == 0)
1987     si->hash = DIGEST_ALGO_RMD160;
1988   else if (strcasecmp (argv[0], "SHA256") == 0)
1989     si->hash = DIGEST_ALGO_SHA256;
1990   else if (strcasecmp (argv[0], "SHA384") == 0)
1991     si->hash = DIGEST_ALGO_SHA384;
1992   else if (strcasecmp (argv[0], "SHA512") == 0)
1993     si->hash = DIGEST_ALGO_SHA512;
1994   else if (strcasecmp (argv[0], "SHA224") == 0)
1995     si->hash = DIGEST_ALGO_SHA224;
1996   else
1997     {
1998       char *tail;
1999       int v;
2000
2001       errno = 0;
2002       v = strtol (argv[0], &tail, 0);
2003       if (errno || (tail && *tail)
2004           || ! (v == DIGEST_ALGO_MD5
2005                 || v == DIGEST_ALGO_SHA1
2006                 || v == DIGEST_ALGO_RMD160
2007                 || v == DIGEST_ALGO_SHA256
2008                 || v == DIGEST_ALGO_SHA384
2009                 || v == DIGEST_ALGO_SHA512
2010                 || v == DIGEST_ALGO_SHA224))
2011         log_fatal ("Invalid or unsupported value.  Usage: %s %s\n",
2012                    option, usage);
2013
2014       si->hash = v;
2015     }
2016
2017   return 1;
2018 }
2019
2020 static int
2021 sk_esk_salt (const char *option, int argc, char *argv[], void *cookie)
2022 {
2023   struct sk_esk_info *si = cookie;
2024   char *usage = "16-HEX-CHARACTERS";
2025   char *p = argv[0];
2026
2027   if (argc == 0)
2028     log_fatal ("Usage: %s %s\n", option, usage);
2029
2030   if (si->salt_set)
2031     log_fatal ("%s given multiple times.", option);
2032
2033   if (p[0] == '0' && p[1] == 'x')
2034     p += 2;
2035
2036   if (strlen (p) != 16)
2037     log_fatal ("%s: Salt must be exactly 16 hexadecimal characters (have: %zd)\n",
2038                option, strlen (p));
2039
2040   if (hex2bin (p, si->salt, sizeof (si->salt)) == -1)
2041     log_fatal ("%s: Salt must only contain hexadecimal characters\n",
2042                option);
2043
2044   si->salt_set = 1;
2045
2046   return 1;
2047 }
2048
2049 static int
2050 sk_esk_iterations (const char *option, int argc, char *argv[], void *cookie)
2051 {
2052   struct sk_esk_info *si = cookie;
2053   char *usage = "ITERATION-COUNT";
2054   char *tail;
2055   int v;
2056
2057   if (argc == 0)
2058     log_fatal ("Usage: %s %s\n", option, usage);
2059
2060   errno = 0;
2061   v = strtol (argv[0], &tail, 0);
2062   if (errno || (tail && *tail) || v < 0)
2063     log_fatal ("%s: Non-negative integer expected.\n", option);
2064
2065   si->iterations = v;
2066
2067   return 1;
2068 }
2069
2070 static int
2071 sk_esk_session_key (const char *option, int argc, char *argv[], void *cookie)
2072 {
2073   struct sk_esk_info *si = cookie;
2074   char *usage = "HEX-CHARACTERS|auto|none";
2075   char *p = argv[0];
2076   struct session_key sk;
2077
2078   if (argc == 0)
2079     log_fatal ("Usage: %s %s\n", option, usage);
2080
2081   if (si->session_key || si->s2k_is_session_key
2082       || si->new_session_key)
2083     log_fatal ("%s given multiple times.", option);
2084
2085   if (strcasecmp (p, "none") == 0)
2086     {
2087       si->s2k_is_session_key = 1;
2088       return 1;
2089     }
2090   if (strcasecmp (p, "new") == 0)
2091     {
2092       si->new_session_key = 1;
2093       return 1;
2094     }
2095   if (strcasecmp (p, "auto") == 0)
2096     return 1;
2097
2098   sk = parse_session_key (option, p, 0);
2099
2100   if (si->session_key)
2101     log_fatal ("%s given multiple times.", option);
2102
2103   if (sk.algo)
2104     si->sed_cipher = sk.algo;
2105
2106   si->session_key_len = sk.keylen;
2107   si->session_key = sk.key;
2108
2109   return 1;
2110 }
2111
2112 static int
2113 sk_esk_password (const char *option, int argc, char *argv[], void *cookie)
2114 {
2115   struct sk_esk_info *si = cookie;
2116   char *usage = "PASSWORD";
2117
2118   if (argc == 0)
2119     log_fatal ("Usage: --sk-esk %s\n", usage);
2120
2121   if (si->password)
2122     log_fatal ("%s given multiple times.", option);
2123
2124   si->password = xstrdup (argv[0]);
2125
2126   return 1;
2127 }
2128
2129 static struct option sk_esk_options[] = {
2130   { "--cipher", sk_esk_cipher,
2131     "The encryption algorithm for encrypting the session key.  "
2132     "One of IDEA, 3DES, CAST5, BLOWFISH, AES (default), AES192, "
2133     "AES256, TWOFISH, CAMELLIA128, CAMELLIA192, or CAMELLIA256." },
2134   { "--sed-cipher", sk_esk_cipher,
2135     "The encryption algorithm for encrypting the SED packet.  "
2136     "One of IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, "
2137     "AES256 (default), TWOFISH, CAMELLIA128, CAMELLIA192, or CAMELLIA256." },
2138   { "--mode", sk_esk_mode,
2139     "The S2K mode.  Either one of the strings \"simple\", \"salted\" "
2140     "or \"iterated\" or an integer." },
2141   { "--hash", sk_esk_hash_algorithm,
2142     "The hash algorithm to used to derive the key.  One of "
2143     "MD5, SHA1 (default), RMD160, SHA256, SHA384, SHA512, or SHA224." },
2144   { "--salt", sk_esk_salt,
2145     "The S2K salt encoded as 16 hexadecimal characters.  One needed "
2146     "if the S2K function is in salted or iterated mode." },
2147   { "--iterations", sk_esk_iterations,
2148     "The iteration count.  If not provided, a reasonable value is chosen.  "
2149     "Note: due to the encoding scheme, not every value is valid.  For "
2150     "convenience, the provided value will be rounded appropriately.  "
2151     "Only needed if the S2K function is in iterated mode." },
2152   { "--session-key", sk_esk_session_key,
2153     "The session key to be encrypted by the S2K function as a hexadecimal "
2154     "string.  If this is \"new\", then a new session key is generated."
2155     "If this is \"auto\", then either the last session key is "
2156     "used, if the was none, one is generated.  If this is \"none\", then "
2157     "the session key is the result of applying the S2K algorithms to the "
2158     "password.  The session key may be prefaced with an integer and a colon "
2159     "to indicate the cipher to use for the SED packet (making --sed-cipher "
2160     "unnecessary and allowing the direct use of the result of "
2161     "\"" GPG_NAME " --show-session-key\")." },
2162   { "", sk_esk_password, "The password." },
2163   { NULL, NULL,
2164     "Example:\n\n"
2165     "  $ gpgcompose --sk-esk foobar --encrypted \\\n"
2166     "  --literal --value foo | " GPG_NAME " --list-packets" }
2167 };
2168
2169 static int
2170 sk_esk (const char *option, int argc, char *argv[], void *cookie)
2171 {
2172   iobuf_t out = cookie;
2173   gpg_error_t err;
2174   int processed;
2175   struct sk_esk_info si;
2176   DEK sesdek;
2177   DEK s2kdek;
2178   PKT_symkey_enc *ske;
2179   PACKET pkt;
2180
2181   memset (&si, 0, sizeof (si));
2182
2183   processed = process_options (option,
2184                                major_options,
2185                                sk_esk_options, &si,
2186                                global_options, NULL,
2187                                argc, argv);
2188
2189   if (! si.password)
2190     log_fatal ("%s: missing password.  Usage: %s PASSWORD", option, option);
2191
2192   /* Fill in defaults, if appropriate.  */
2193   if (! si.cipher)
2194     si.cipher = CIPHER_ALGO_AES;
2195
2196   if (! si.sed_cipher)
2197     si.sed_cipher = CIPHER_ALGO_AES256;
2198
2199   if (! si.hash)
2200     si.hash = DIGEST_ALGO_SHA1;
2201
2202   if (! si.mode_set)
2203     /* Salted and iterated.  */
2204     si.mode = 3;
2205
2206   if (si.mode != 0 && ! si.salt_set)
2207     /* Generate a salt.  */
2208     gcry_randomize (si.salt, 8, GCRY_STRONG_RANDOM);
2209
2210   if (si.mode == 0)
2211     {
2212       if (si.iterations)
2213         log_info ("%s: --iterations provided, but not used for mode=0\n",
2214                   option);
2215       si.iterations = 0;
2216     }
2217   else if (! si.iterations)
2218     si.iterations = 10000;
2219
2220   memset (&sesdek, 0, sizeof (sesdek));
2221   /* The session key is used to encrypt the SED packet.  */
2222   sesdek.algo = si.sed_cipher;
2223   if (si.session_key)
2224     /* Copy the unencrypted session key into SESDEK.  */
2225     {
2226       sesdek.keylen = openpgp_cipher_get_algo_keylen (sesdek.algo);
2227       if (sesdek.keylen != si.session_key_len)
2228         log_fatal ("%s: Cipher algorithm requires a %d byte session key, but provided session key is %d bytes.",
2229                    option, sesdek.keylen, si.session_key_len);
2230
2231       log_assert (sesdek.keylen <= sizeof (sesdek.key));
2232       memcpy (sesdek.key, si.session_key, sesdek.keylen);
2233     }
2234   else if (! si.s2k_is_session_key || si.new_session_key)
2235     /* We need a session key, but one wasn't provided.  Generate it.  */
2236     make_session_key (&sesdek);
2237
2238   /* The encrypted session key needs 1 + SESDEK.KEYLEN bytes of
2239      space.  */
2240   ske = xmalloc_clear (sizeof (*ske) + sesdek.keylen);
2241
2242   ske->version = 4;
2243   ske->cipher_algo = si.cipher;
2244
2245   ske->s2k.mode = si.mode;
2246   ske->s2k.hash_algo = si.hash;
2247   log_assert (sizeof (si.salt) == sizeof (ske->s2k.salt));
2248   memcpy (ske->s2k.salt, si.salt, sizeof (ske->s2k.salt));
2249   if (! si.s2k_is_session_key)
2250     /* 0 means get the default.  */
2251     ske->s2k.count = encode_s2k_iterations (si.iterations);
2252
2253
2254   /* Derive the symmetric key that is either the session key or the
2255      key used to encrypt the session key.  */
2256   memset (&s2kdek, 0, sizeof (s2kdek));
2257
2258   s2kdek.algo = si.cipher;
2259   s2kdek.keylen = openpgp_cipher_get_algo_keylen (s2kdek.algo);
2260
2261   err = gcry_kdf_derive (si.password, strlen (si.password),
2262                          ske->s2k.mode == 3 ? GCRY_KDF_ITERSALTED_S2K
2263                          : ske->s2k.mode == 1 ? GCRY_KDF_SALTED_S2K
2264                          : GCRY_KDF_SIMPLE_S2K,
2265                          ske->s2k.hash_algo, ske->s2k.salt, 8,
2266                          S2K_DECODE_COUNT (ske->s2k.count),
2267                          /* The size of the desired key and its
2268                             buffer.  */
2269                          s2kdek.keylen, s2kdek.key);
2270   if (err)
2271     log_fatal ("gcry_kdf_derive failed: %s", gpg_strerror (err));
2272
2273
2274   if (si.s2k_is_session_key)
2275     {
2276       ske->seskeylen = 0;
2277       session_key = s2kdek;
2278     }
2279   else
2280     /* Encrypt the session key using the s2k specifier.  */
2281     {
2282       DEK *sesdekp = &sesdek;
2283
2284       /* Now encrypt the session key (or rather, the algorithm used to
2285          encrypt the SED plus the session key) using ENCKEY.  */
2286       ske->seskeylen = 1 + sesdek.keylen;
2287       encrypt_seskey (&s2kdek, &sesdekp, ske->seskey);
2288
2289       /* Save the session key for later.  */
2290       session_key = sesdek;
2291     }
2292
2293   pkt.pkttype = PKT_SYMKEY_ENC;
2294   pkt.pkt.symkey_enc = ske;
2295
2296   err = build_packet (out, &pkt);
2297   if (err)
2298     log_fatal ("Serializing sym-key encrypted packet: %s\n",
2299                gpg_strerror (err));
2300
2301   debug ("Wrote sym-key encrypted packet:\n");
2302   dump_component (&pkt);
2303
2304   xfree (si.session_key);
2305   xfree (si.password);
2306   xfree (ske);
2307
2308   return processed;
2309 }
2310 \f
2311 struct pk_esk_info
2312 {
2313   int session_key_set;
2314
2315   int new_session_key;
2316
2317   int sed_cipher;
2318   int session_key_len;
2319   char *session_key;
2320
2321   int throw_keyid;
2322
2323   char *keyid;
2324 };
2325
2326 static int
2327 pk_esk_session_key (const char *option, int argc, char *argv[], void *cookie)
2328 {
2329   struct pk_esk_info *pi = cookie;
2330   char *usage = "HEX-CHARACTERS|auto|none";
2331   char *p = argv[0];
2332   struct session_key sk;
2333
2334   if (argc == 0)
2335     log_fatal ("Usage: %s %s\n", option, usage);
2336
2337   if (pi->session_key_set)
2338     log_fatal ("%s given multiple times.", option);
2339   pi->session_key_set = 1;
2340
2341   if (strcasecmp (p, "new") == 0)
2342     {
2343       pi->new_session_key = 1;
2344       return 1;
2345     }
2346
2347   if (strcasecmp (p, "auto") == 0)
2348     return 1;
2349
2350   sk = parse_session_key (option, p, 0);
2351
2352   if (pi->session_key)
2353     log_fatal ("%s given multiple times.", option);
2354
2355   if (sk.algo)
2356     pi->sed_cipher = sk.algo;
2357
2358   pi->session_key_len = sk.keylen;
2359   pi->session_key = sk.key;
2360
2361   return 1;
2362 }
2363
2364 static int
2365 pk_esk_throw_keyid (const char *option, int argc, char *argv[], void *cookie)
2366 {
2367   struct pk_esk_info *pi = cookie;
2368
2369   (void) option;
2370   (void) argc;
2371   (void) argv;
2372
2373   pi->throw_keyid = 1;
2374
2375   return 0;
2376 }
2377
2378 static int
2379 pk_esk_keyid (const char *option, int argc, char *argv[], void *cookie)
2380 {
2381   struct pk_esk_info *pi = cookie;
2382   char *usage = "KEYID";
2383
2384   if (argc == 0)
2385     log_fatal ("Usage: %s %s\n", option, usage);
2386
2387   if (pi->keyid)
2388     log_fatal ("Multiple key ids given, but only one is allowed.");
2389
2390   pi->keyid = xstrdup (argv[0]);
2391
2392   return 1;
2393 }
2394
2395 static struct option pk_esk_options[] = {
2396   { "--session-key", pk_esk_session_key,
2397     "The session key to be encrypted by the S2K function as a hexadecimal "
2398     "string.  If this is not given or is \"auto\", then the current "
2399     "session key is used.  If there is no session key or this is \"new\", "
2400     "then a new session key is generated.  The session key may be "
2401     "prefaced with an integer and a colon to indicate the cipher to use "
2402     "for the SED packet (making --sed-cipher unnecessary and allowing the "
2403     "direct use of the result of \"" GPG_NAME " --show-session-key\")." },
2404   { "--throw-keyid", pk_esk_throw_keyid,
2405     "Throw the keyid." },
2406   { "", pk_esk_keyid, "The key id." },
2407   { NULL, NULL,
2408     "Example:\n\n"
2409     "  $ gpgcompose --pk-esk $KEYID --encrypted --literal --value foo \\\n"
2410     "  | " GPG_NAME " --list-packets"}
2411 };
2412
2413 static int
2414 pk_esk (const char *option, int argc, char *argv[], void *cookie)
2415 {
2416   iobuf_t out = cookie;
2417   gpg_error_t err;
2418   int processed;
2419   struct pk_esk_info pi;
2420   PKT_public_key pk;
2421
2422   memset (&pi, 0, sizeof (pi));
2423
2424   processed = process_options (option,
2425                                major_options,
2426                                pk_esk_options, &pi,
2427                                global_options, NULL,
2428                                argc, argv);
2429
2430   if (! pi.keyid)
2431     log_fatal ("%s: missing keyid.  Usage: %s KEYID", option, option);
2432
2433   memset (&pk, 0, sizeof (pk));
2434   pk.req_usage = PUBKEY_USAGE_ENC;
2435   err = get_pubkey_byname (NULL, NULL, &pk, pi.keyid, NULL, NULL, 1, 1);
2436   if (err)
2437     log_fatal ("%s: looking up key %s: %s\n",
2438                option, pi.keyid, gpg_strerror (err));
2439
2440   if (pi.sed_cipher)
2441     /* Have a session key.  */
2442     {
2443       session_key.algo = pi.sed_cipher;
2444       session_key.keylen = pi.session_key_len;
2445       log_assert (session_key.keylen <= sizeof (session_key.key));
2446       memcpy (session_key.key, pi.session_key, session_key.keylen);
2447     }
2448
2449   if (pi.new_session_key || ! session_key.algo)
2450     {
2451       if (! pi.new_session_key)
2452         /* Default to AES256.  */
2453         session_key.algo = CIPHER_ALGO_AES256;
2454       make_session_key (&session_key);
2455     }
2456
2457   err = write_pubkey_enc (global_ctrl, &pk, pi.throw_keyid, &session_key, out);
2458   if (err)
2459     log_fatal ("%s: writing pk_esk packet for %s: %s\n",
2460                option, pi.keyid, gpg_strerror (err));
2461
2462   debug ("Wrote pk_esk packet for %s\n", pi.keyid);
2463
2464   xfree (pi.keyid);
2465   xfree (pi.session_key);
2466
2467   return processed;
2468 }
2469 \f
2470 struct encinfo
2471 {
2472   int saw_session_key;
2473 };
2474
2475 static int
2476 encrypted_session_key (const char *option, int argc, char *argv[], void *cookie)
2477 {
2478   struct encinfo *ei = cookie;
2479   char *usage = "HEX-CHARACTERS|auto";
2480   char *p = argv[0];
2481   struct session_key sk;
2482
2483   if (argc == 0)
2484     log_fatal ("Usage: %s %s\n", option, usage);
2485
2486   if (ei->saw_session_key)
2487     log_fatal ("%s given multiple times.", option);
2488   ei->saw_session_key = 1;
2489
2490   if (strcasecmp (p, "auto") == 0)
2491     return 1;
2492
2493   sk = parse_session_key (option, p, 1);
2494
2495   session_key.algo = sk.algo;
2496   log_assert (sk.keylen <= sizeof (session_key.key));
2497   memcpy (session_key.key, sk.key, sk.keylen);
2498   xfree (sk.key);
2499
2500   return 1;
2501 }
2502
2503 static struct option encrypted_options[] = {
2504   { "--session-key", encrypted_session_key,
2505     "The session key to be encrypted by the S2K function as a hexadecimal "
2506     "string.  If this is not given or is \"auto\", then the last session key "
2507     "is used.  If there was none, then an error is raised.  The session key "
2508     "must be prefaced with an integer and a colon to indicate the cipher "
2509     "to use (this is format used by \"" GPG_NAME " --show-session-key\")." },
2510   { NULL, NULL,
2511     "After creating the packet, this command clears the current "
2512     "session key.\n\n"
2513     "Example: nested encryption packets:\n\n"
2514     "  $ gpgcompose --sk-esk foo --encrypted-mdc \\\n"
2515     "  --sk-esk bar --encrypted-mdc \\\n"
2516     "  --literal --value 123 --encrypted-pop --encrypted-pop | " GPG_NAME" -d" }
2517 };
2518
2519 static int
2520 encrypted (const char *option, int argc, char *argv[], void *cookie)
2521 {
2522   iobuf_t out = cookie;
2523   int processed;
2524   struct encinfo ei;
2525   PKT_encrypted e;
2526   cipher_filter_context_t *cfx;
2527
2528   memset (&ei, 0, sizeof (ei));
2529
2530   processed = process_options (option,
2531                                major_options,
2532                                encrypted_options, &ei,
2533                                global_options, NULL,
2534                                argc, argv);
2535
2536   if (! session_key.algo)
2537     log_fatal ("%s: no session key configured.\n", option);
2538
2539   memset (&e, 0, sizeof (e));
2540   /* We only need to set E->LEN, E->EXTRALEN (if E->LEN is not
2541      0), and E->NEW_CTB.  */
2542   e.len = 0;
2543   e.new_ctb = 1;
2544
2545   /* Register the cipher filter. */
2546
2547   cfx = xmalloc_clear (sizeof (*cfx));
2548
2549   /* Copy the session key.  */
2550   cfx->dek = xmalloc (sizeof (*cfx->dek));
2551   *cfx->dek = session_key;
2552
2553   if (do_debug)
2554     {
2555       char *buf;
2556
2557       buf = xmalloc (2 * session_key.keylen + 1);
2558       debug ("session key: algo: %d; keylen: %d; key: %s\n",
2559              session_key.algo, session_key.keylen,
2560              bin2hex (session_key.key, session_key.keylen, buf));
2561       xfree (buf);
2562     }
2563
2564   if (strcmp (option, "--encrypted-mdc") == 0)
2565     cfx->dek->use_mdc = 1;
2566   else if (strcmp (option, "--encrypted") == 0)
2567     cfx->dek->use_mdc = 0;
2568   else
2569     log_fatal ("%s: option not handled by this function!\n", option);
2570
2571   cfx->datalen = 0;
2572
2573   filter_push (out, cipher_filter, cfx, PKT_ENCRYPTED, cfx->datalen == 0);
2574
2575   debug ("Wrote encrypted packet:\n");
2576
2577   /* Clear the current session key.  */
2578   memset (&session_key, 0, sizeof (session_key));
2579
2580   return processed;
2581 }
2582 \f
2583 static int
2584 encrypted_pop (const char *option, int argc, char *argv[], void *cookie)
2585 {
2586   iobuf_t out = cookie;
2587
2588   (void) argc;
2589   (void) argv;
2590
2591
2592   debug ("Popped encryption container.\n");
2593
2594   return 0;
2595 }
2596 \f
2597 struct data
2598 {
2599   int file;
2600   union
2601   {
2602     char *data;
2603     char *filename;
2604   };
2605   struct data *next;
2606 };
2607
2608 /* This must be the first member of the struct to be able to use
2609    add_value!  */
2610 struct datahead
2611 {
2612   struct data *head;
2613   struct data **last_next;
2614 };
2615
2616 static int
2617 add_value (const char *option, int argc, char *argv[], void *cookie)
2618 {
2619   struct datahead *dh = cookie;
2620   struct data *d = xmalloc_clear (sizeof (struct data));
2621
2622   d->file = strcmp ("--file", option) == 0;
2623   if (! d->file)
2624     log_assert (strcmp ("--value", option) == 0);
2625
2626   if (argc == 0)
2627     {
2628       if (d->file)
2629         log_fatal ("Usage: %s FILENAME\n", option);
2630       else
2631         log_fatal ("Usage: %s STRING\n", option);
2632     }
2633
2634   if (! dh->last_next)
2635     /* First time through.  Initialize DH->LAST_NEXT.  */
2636     {
2637       log_assert (! dh->head);
2638       dh->last_next = &dh->head;
2639     }
2640
2641   if (d->file)
2642     d->filename = argv[0];
2643   else
2644     d->data = argv[0];
2645
2646   /* Append it.  */
2647   *dh->last_next = d;
2648   dh->last_next = &d->next;
2649
2650   return 1;
2651 }
2652 \f
2653 struct litinfo
2654 {
2655   /* This must be the first element for add_value to work!  */
2656   struct datahead data;
2657
2658   int timestamp_set;
2659   u32 timestamp;
2660   char mode;
2661   int partial_body_length_encoding;
2662   char *name;
2663 };
2664
2665 static int
2666 literal_timestamp (const char *option, int argc, char *argv[], void *cookie)
2667 {
2668   struct litinfo *li = cookie;
2669
2670   char *tail = NULL;
2671
2672   if (argc == 0)
2673     log_fatal ("Usage: %s TIMESTAMP\n", option);
2674
2675   errno = 0;
2676   li->timestamp = parse_timestamp (argv[0], &tail);
2677   if (errno || (tail && *tail))
2678     log_fatal ("Invalid value passed to %s (%s)\n", option, argv[0]);
2679   li->timestamp_set = 1;
2680
2681   return 1;
2682 }
2683
2684 static int
2685 literal_mode (const char *option, int argc, char *argv[], void *cookie)
2686 {
2687   struct litinfo *li = cookie;
2688
2689   if (argc == 0
2690       || ! (strcmp (argv[0], "b") == 0
2691             || strcmp (argv[0], "t") == 0
2692             || strcmp (argv[0], "u") == 0))
2693     log_fatal ("Usage: %s [btu]\n", option);
2694
2695   li->mode = argv[0][0];
2696
2697   return 1;
2698 }
2699
2700 static int
2701 literal_partial_body_length (const char *option, int argc, char *argv[],
2702                              void *cookie)
2703 {
2704   struct litinfo *li = cookie;
2705   char *tail;
2706   int v;
2707   int range[2] = {0, 1};
2708
2709   if (argc <= 1)
2710     log_fatal ("Usage: %s [0|1]\n", option);
2711
2712   errno = 0;
2713   v = strtol (argv[0], &tail, 0);
2714   if (errno || (tail && *tail) || !(range[0] <= v && v <= range[1]))
2715     log_fatal ("Invalid value passed to %s (%s).  Expected %d-%d\n",
2716                option, argv[0], range[0], range[1]);
2717
2718   li->partial_body_length_encoding = v;
2719
2720   return 1;
2721 }
2722
2723 static int
2724 literal_name (const char *option, int argc, char *argv[], void *cookie)
2725 {
2726   struct litinfo *li = cookie;
2727
2728   if (argc <= 1)
2729     log_fatal ("Usage: %s NAME\n", option);
2730
2731   if (strlen (argv[0]) > 255)
2732     log_fatal ("%s: name is too long (%zd > 255 characters).\n",
2733                option, strlen (argv[0]));
2734
2735   li->name = argv[0];
2736
2737   return 1;
2738 }
2739
2740 static struct option literal_options[] = {
2741   { "--value", add_value,
2742     "A string to store in the literal packet." },
2743   { "--file", add_value,
2744     "A file to copy into the literal packet." },
2745   { "--timestamp", literal_timestamp,
2746     "The literal packet's time stamp.  This defaults to the current time." },
2747   { "--mode", literal_mode,
2748     "The content's mode (normally 'b' (default), 't' or 'u')." },
2749   { "--partial-body-length", literal_partial_body_length,
2750     "Force partial body length encoding." },
2751   { "--name", literal_name,
2752     "The literal's name." },
2753   { NULL, NULL,
2754     "Example:\n\n"
2755     "  $ gpgcompose --literal --value foobar | " GPG_NAME " -d"}
2756 };
2757
2758 static int
2759 literal (const char *option, int argc, char *argv[], void *cookie)
2760 {
2761   iobuf_t out = cookie;
2762   gpg_error_t err;
2763   int processed;
2764   struct litinfo li;
2765   PKT_plaintext *pt;
2766   PACKET pkt;
2767   struct data *data;
2768
2769   memset (&li, 0, sizeof (li));
2770
2771   processed = process_options (option,
2772                                major_options,
2773                                literal_options, &li,
2774                                global_options, NULL,
2775                                argc, argv);
2776
2777   if (! li.data.head)
2778     log_fatal ("%s: no data provided (use --value or --file)", option);
2779
2780   pt = xmalloc_clear (sizeof (*pt) + (li.name ? strlen (li.name) : 0));
2781   pt->new_ctb = 1;
2782
2783   if (li.timestamp_set)
2784     pt->timestamp = li.timestamp;
2785   else
2786     /* Default to the current time.  */
2787     pt->timestamp = make_timestamp ();
2788
2789   pt->mode = li.mode;
2790   if (! pt->mode)
2791     /* Default to binary.  */
2792     pt->mode = 'b';
2793
2794   if (li.name)
2795     {
2796       strcpy (pt->name, li.name);
2797       pt->namelen = strlen (pt->name);
2798     }
2799
2800   pkt.pkttype = PKT_PLAINTEXT;
2801   pkt.pkt.plaintext = pt;
2802
2803   if (! li.partial_body_length_encoding)
2804     /* Compute the amount of data.  */
2805     {
2806       pt->len = 0;
2807       for (data = li.data.head; data; data = data->next)
2808         {
2809           if (data->file)
2810             {
2811               iobuf_t in;
2812               int overflow;
2813               off_t off;
2814
2815               in = iobuf_open (data->filename);
2816               if (! in)
2817                 /* An error opening the file.  We do error handling
2818                    below so just break here.  */
2819                 {
2820                   pt->len = 0;
2821                   break;
2822                 }
2823
2824               off = iobuf_get_filelength (in, &overflow);
2825               iobuf_close (in);
2826
2827               if (overflow || off == 0)
2828                 /* Length is unknown or there was an error
2829                    (unfortunately, iobuf_get_filelength doesn't
2830                    distinguish between 0 length files and an error!).
2831                    Fall back to partial body mode.  */
2832                 {
2833                   pt->len = 0;
2834                   break;
2835                 }
2836
2837               pt->len += off;
2838             }
2839           else
2840             pt->len += strlen (data->data);
2841         }
2842     }
2843
2844   err = build_packet (out, &pkt);
2845   if (err)
2846     log_fatal ("Serializing literal packet: %s\n", gpg_strerror (err));
2847
2848   /* Write out the data.  */
2849   for (data = li.data.head; data; data = data->next)
2850     {
2851       if (data->file)
2852         {
2853           iobuf_t in;
2854           errno = 0;
2855           in = iobuf_open (data->filename);
2856           if (! in)
2857             log_fatal ("Opening '%s': %s\n",
2858                        data->filename,
2859                        errno ? strerror (errno): "unknown error");
2860
2861           iobuf_copy (out, in);
2862           if (iobuf_error (in))
2863             log_fatal ("Reading from %s: %s\n",
2864                        data->filename,
2865                        gpg_strerror (iobuf_error (in)));
2866           if (iobuf_error (out))
2867             log_fatal ("Writing literal data from %s: %s\n",
2868                        data->filename,
2869                        gpg_strerror (iobuf_error (out)));
2870
2871           iobuf_close (in);
2872         }
2873       else
2874         {
2875           err = iobuf_write (out, data->data, strlen (data->data));
2876           if (err)
2877             log_fatal ("Writing literal data: %s\n", gpg_strerror (err));
2878         }
2879     }
2880
2881   if (! pt->len)
2882     {
2883       /* Disable partial body length mode.  */
2884       log_assert (pt->new_ctb == 1);
2885       iobuf_set_partial_body_length_mode (out, 0);
2886     }
2887
2888   debug ("Wrote literal packet:\n");
2889   dump_component (&pkt);
2890
2891   while (li.data.head)
2892     {
2893       data = li.data.head->next;
2894       xfree (li.data.head);
2895       li.data.head = data;
2896     }
2897   xfree (pt);
2898
2899   return processed;
2900 }
2901 \f
2902 static int
2903 copy_file (const char *option, int argc, char *argv[], void *cookie)
2904 {
2905   char **filep = cookie;
2906
2907   if (argc == 0)
2908     log_fatal ("Usage: %s FILENAME\n", option);
2909
2910   *filep = argv[0];
2911
2912   return 1;
2913 }
2914
2915 static struct option copy_options[] = {
2916   { "", copy_file, "Copy the specified file to stdout." },
2917   { NULL, NULL,
2918     "Example:\n\n"
2919     "  $ gpgcompose --copy /etc/hostname\n\n"
2920     "This is particularly useful when combined with gpgsplit." }
2921 };
2922
2923 static int
2924 copy (const char *option, int argc, char *argv[], void *cookie)
2925 {
2926   iobuf_t out = cookie;
2927   char *file = NULL;
2928   iobuf_t in;
2929
2930   int processed;
2931
2932   processed = process_options (option,
2933                                major_options,
2934                                copy_options, &file,
2935                                global_options, NULL,
2936                                argc, argv);
2937   if (! file)
2938     log_fatal ("Usage: %s FILE\n", option);
2939
2940   errno = 0;
2941   in = iobuf_open (file);
2942   if (! in)
2943     log_fatal ("Error opening %s: %s.\n",
2944                file, errno ? strerror (errno): "unknown error");
2945
2946   iobuf_copy (out, in);
2947   if (iobuf_error (out))
2948     log_fatal ("Copying data to destination: %s\n",
2949                gpg_strerror (iobuf_error (out)));
2950   if (iobuf_error (in))
2951     log_fatal ("Reading data from %s: %s\n",
2952                argv[0], gpg_strerror (iobuf_error (in)));
2953
2954   iobuf_close (in);
2955
2956   return processed;
2957 }
2958 \f
2959 int
2960 main (int argc, char *argv[])
2961 {
2962   const char *filename = "-";
2963   iobuf_t out;
2964   int preprocessed = 1;
2965   int processed;
2966   ctrl_t ctrl;
2967
2968   opt.ignore_time_conflict = 1;
2969   /* Allow notations in the IETF space, for instance.  */
2970   opt.expert = 1;
2971
2972   global_ctrl = ctrl = xcalloc (1, sizeof *ctrl);
2973
2974   keydb_add_resource ("pubring" EXTSEP_S GPGEXT_GPG,
2975                       KEYDB_RESOURCE_FLAG_DEFAULT);
2976
2977   if (argc == 1)
2978     /* Nothing to do.  */
2979     return 0;
2980
2981   if (strcmp (argv[1], "--output") == 0
2982       || strcmp (argv[1], "-o") == 0)
2983     {
2984       filename = argv[2];
2985       log_info ("Writing to %s\n", filename);
2986       preprocessed += 2;
2987     }
2988
2989   out = iobuf_create (filename, 0);
2990   if (! out)
2991     log_fatal ("Failed to open stdout for writing\n");
2992
2993   processed = process_options (NULL, NULL,
2994                                major_options, out,
2995                                global_options, NULL,
2996                                argc - preprocessed, &argv[preprocessed]);
2997   if (processed != argc - preprocessed)
2998     log_fatal ("Didn't process %d options.\n", argc - preprocessed - processed);
2999
3000   iobuf_close (out);
3001
3002   return 0;
3003 }
3004 \f
3005 /* Stubs duplicated from gpg.c.  */
3006
3007 int g10_errors_seen = 0;
3008
3009 /* Note: This function is used by signal handlers!. */
3010 static void
3011 emergency_cleanup (void)
3012 {
3013   gcry_control (GCRYCTL_TERM_SECMEM );
3014 }
3015
3016 void
3017 g10_exit( int rc )
3018 {
3019   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
3020
3021   emergency_cleanup ();
3022
3023   rc = rc? rc : log_get_errorcount(0)? 2 : g10_errors_seen? 1 : 0;
3024   exit (rc);
3025 }
3026
3027 void
3028 keyedit_menu (ctrl_t ctrl, const char *username, strlist_t locusr,
3029               strlist_t commands, int quiet, int seckey_check)
3030 {
3031   (void) ctrl;
3032   (void) username;
3033   (void) locusr;
3034   (void) commands;
3035   (void) quiet;
3036   (void) seckey_check;
3037 }
3038
3039 void
3040 show_basic_key_info (ctrl_t ctrl, KBNODE keyblock)
3041 {
3042   (void)ctrl;
3043   (void) keyblock;
3044 }