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