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