scd:piv: Implement import of private keys for Yubikeys.
[gnupg.git] / tools / gpgtar.c
1 /* gpgtar.c - A simple TAR implementation mainly useful for Windows.
2  * Copyright (C) 2010 Free Software Foundation, Inc.
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 /* GnuPG comes with a shell script gpg-zip which creates archive files
21    in the same format as PGP Zip, which is actually a USTAR format.
22    That is fine and works nicely on all Unices but for Windows we
23    don't have a compatible shell and the supply of tar programs is
24    limited.  Given that we need just a few tar option and it is an
25    open question how many Unix concepts are to be mapped to Windows,
26    we might as well write our own little tar customized for use with
27    gpg.  So here we go.  */
28
29 #include <config.h>
30 #include <ctype.h>
31 #include <errno.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <assert.h>
36
37 #include "../common/util.h"
38 #include "../common/i18n.h"
39 #include "../common/sysutils.h"
40 #include "../common/openpgpdefs.h"
41 #include "../common/init.h"
42 #include "../common/strlist.h"
43
44 #include "gpgtar.h"
45
46
47 /* Constants to identify the commands and options. */
48 enum cmd_and_opt_values
49   {
50     aNull = 0,
51     aCreate = 600,
52     aExtract,
53     aEncrypt    = 'e',
54     aDecrypt    = 'd',
55     aSign       = 's',
56     aList       = 't',
57
58     oSymmetric  = 'c',
59     oRecipient  = 'r',
60     oUser       = 'u',
61     oOutput     = 'o',
62     oDirectory  = 'C',
63     oQuiet      = 'q',
64     oVerbose    = 'v',
65     oFilesFrom  = 'T',
66     oNoVerbose  = 500,
67
68     aSignEncrypt,
69     oGpgProgram,
70     oSkipCrypto,
71     oOpenPGP,
72     oCMS,
73     oSetFilename,
74     oNull,
75
76     /* Compatibility with gpg-zip.  */
77     oGpgArgs,
78     oTarArgs,
79
80     /* Debugging.  */
81     oDryRun,
82   };
83
84
85 /* The list of commands and options. */
86 static ARGPARSE_OPTS opts[] = {
87   ARGPARSE_group (300, N_("@Commands:\n ")),
88
89   ARGPARSE_c (aCreate,    "create",  N_("create an archive")),
90   ARGPARSE_c (aExtract,   "extract", N_("extract an archive")),
91   ARGPARSE_c (aEncrypt,   "encrypt", N_("create an encrypted archive")),
92   ARGPARSE_c (aDecrypt,   "decrypt", N_("extract an encrypted archive")),
93   ARGPARSE_c (aSign,      "sign",    N_("create a signed archive")),
94   ARGPARSE_c (aList,      "list-archive", N_("list an archive")),
95
96   ARGPARSE_group (301, N_("@\nOptions:\n ")),
97
98   ARGPARSE_s_n (oSymmetric, "symmetric", N_("use symmetric encryption")),
99   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
100   ARGPARSE_s_s (oUser, "local-user",
101                 N_("|USER-ID|use USER-ID to sign or decrypt")),
102   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
103   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
104   ARGPARSE_s_n (oQuiet, "quiet",  N_("be somewhat more quiet")),
105   ARGPARSE_s_s (oGpgProgram, "gpg", "@"),
106   ARGPARSE_s_n (oSkipCrypto, "skip-crypto", N_("skip the crypto processing")),
107   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
108   ARGPARSE_s_s (oSetFilename, "set-filename", "@"),
109   ARGPARSE_s_n (oOpenPGP, "openpgp", "@"),
110   ARGPARSE_s_n (oCMS, "cms", "@"),
111
112   ARGPARSE_group (302, N_("@\nTar options:\n ")),
113
114   ARGPARSE_s_s (oDirectory, "directory",
115                 N_("|DIRECTORY|extract files into DIRECTORY")),
116   ARGPARSE_s_s (oFilesFrom, "files-from",
117                 N_("|FILE|get names to create from FILE")),
118   ARGPARSE_s_n (oNull, "null", N_("-T reads null-terminated names")),
119
120   ARGPARSE_s_s (oGpgArgs, "gpg-args", "@"),
121   ARGPARSE_s_s (oTarArgs, "tar-args", "@"),
122
123   ARGPARSE_end ()
124 };
125
126
127 /* The list of commands and options for tar that we understand. */
128 static ARGPARSE_OPTS tar_opts[] = {
129   ARGPARSE_s_s (oDirectory, "directory",
130                 N_("|DIRECTORY|extract files into DIRECTORY")),
131   ARGPARSE_s_s (oFilesFrom, "files-from",
132                 N_("|FILE|get names to create from FILE")),
133   ARGPARSE_s_n (oNull, "null", N_("-T reads null-terminated names")),
134
135   ARGPARSE_end ()
136 };
137
138
139 \f
140 /* Print usage information and provide strings for help. */
141 static const char *
142 my_strusage( int level )
143 {
144   const char *p;
145
146   switch (level)
147     {
148     case 11: p = "@GPGTAR@ (@GNUPG@)";
149       break;
150     case 13: p = VERSION; break;
151     case 17: p = PRINTABLE_OS_NAME; break;
152     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
153
154     case 1:
155     case 40:
156       p = _("Usage: gpgtar [options] [files] [directories] (-h for help)");
157       break;
158     case 41:
159       p = _("Syntax: gpgtar [options] [files] [directories]\n"
160             "Encrypt or sign files into an archive\n");
161       break;
162
163     default: p = NULL; break;
164     }
165   return p;
166 }
167
168
169 static void
170 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
171 {
172   enum cmd_and_opt_values cmd = *ret_cmd;
173
174   if (!cmd || cmd == new_cmd)
175     cmd = new_cmd;
176   else if (cmd == aSign && new_cmd == aEncrypt)
177     cmd = aSignEncrypt;
178   else if (cmd == aEncrypt && new_cmd == aSign)
179     cmd = aSignEncrypt;
180   else
181     {
182       log_error (_("conflicting commands\n"));
183       exit (2);
184     }
185
186   *ret_cmd = cmd;
187 }
188 \f
189 /* Shell-like argument splitting.
190
191    For compatibility with gpg-zip we accept arguments for GnuPG and
192    tar given as a string argument to '--gpg-args' and '--tar-args'.
193    gpg-zip was implemented as a Bourne Shell script, and therefore, we
194    need to split the string the same way the shell would.  */
195 static int
196 shell_parse_stringlist (const char *str, strlist_t *r_list)
197 {
198   strlist_t list = NULL;
199   const char *s = str;
200   char quoted = 0;
201   char arg[1024];
202   char *p = arg;
203 #define addchar(c) \
204   do { if (p - arg + 2 < sizeof arg) *p++ = (c); else return 1; } while (0)
205 #define addargument()                           \
206   do {                                          \
207     if (p > arg)                                \
208       {                                         \
209         *p = 0;                                 \
210         append_to_strlist (&list, arg);         \
211         p = arg;                                \
212       }                                         \
213   } while (0)
214
215 #define unquoted        0
216 #define singlequote     '\''
217 #define doublequote     '"'
218
219   for (; *s; s++)
220     {
221       switch (quoted)
222         {
223         case unquoted:
224           if (isspace (*s))
225             addargument ();
226           else if (*s == singlequote || *s == doublequote)
227             quoted = *s;
228           else
229             addchar (*s);
230           break;
231
232         case singlequote:
233           if (*s == singlequote)
234             quoted = unquoted;
235           else
236             addchar (*s);
237           break;
238
239         case doublequote:
240           assert (s > str || !"cannot be quoted at first char");
241           if (*s == doublequote && *(s - 1) != '\\')
242             quoted = unquoted;
243           else
244             addchar (*s);
245           break;
246
247         default:
248           assert (! "reached");
249         }
250     }
251
252   /* Append the last argument.  */
253   addargument ();
254
255 #undef doublequote
256 #undef singlequote
257 #undef unquoted
258 #undef addargument
259 #undef addchar
260   *r_list = list;
261   return 0;
262 }
263
264
265 /* Like shell_parse_stringlist, but returns an argv vector
266    instead of a strlist.  */
267 static int
268 shell_parse_argv (const char *s, int *r_argc, char ***r_argv)
269 {
270   int i;
271   strlist_t list;
272
273   if (shell_parse_stringlist (s, &list))
274     return 1;
275
276   *r_argc = strlist_length (list);
277   *r_argv = xtrycalloc (*r_argc, sizeof **r_argv);
278   if (*r_argv == NULL)
279     return 1;
280
281   for (i = 0; list; i++)
282     {
283       gpgrt_annotate_leaked_object (list);
284       (*r_argv)[i] = list->d;
285       list = list->next;
286     }
287   gpgrt_annotate_leaked_object (*r_argv);
288   return 0;
289 }
290 \f
291 /* Global flags.  */
292 enum cmd_and_opt_values cmd = 0;
293 int skip_crypto = 0;
294 const char *files_from = NULL;
295 int null_names = 0;
296
297
298 /* Command line parsing.  */
299 static void
300 parse_arguments (ARGPARSE_ARGS *pargs, ARGPARSE_OPTS *popts)
301 {
302   int no_more_options = 0;
303
304   while (!no_more_options && optfile_parse (NULL, NULL, NULL, pargs, popts))
305     {
306       switch (pargs->r_opt)
307         {
308         case oOutput:    opt.outfile = pargs->r.ret_str; break;
309         case oDirectory: opt.directory = pargs->r.ret_str; break;
310         case oSetFilename: opt.filename = pargs->r.ret_str; break;
311         case oQuiet:     opt.quiet = 1; break;
312         case oVerbose:   opt.verbose++; break;
313         case oNoVerbose: opt.verbose = 0; break;
314         case oFilesFrom: files_from = pargs->r.ret_str; break;
315         case oNull: null_names = 1; break;
316
317         case aList:
318         case aDecrypt:
319         case aEncrypt:
320         case aSign:
321           set_cmd (&cmd, pargs->r_opt);
322           break;
323
324         case aCreate:
325           set_cmd (&cmd, aEncrypt);
326           skip_crypto = 1;
327           break;
328
329         case aExtract:
330           set_cmd (&cmd, aDecrypt);
331           skip_crypto = 1;
332           break;
333
334         case oRecipient:
335           add_to_strlist (&opt.recipients, pargs->r.ret_str);
336           break;
337
338         case oUser:
339           opt.user = pargs->r.ret_str;
340           break;
341
342         case oSymmetric:
343           set_cmd (&cmd, aEncrypt);
344           opt.symmetric = 1;
345           break;
346
347         case oGpgProgram:
348           opt.gpg_program = pargs->r.ret_str;
349           break;
350
351         case oSkipCrypto:
352           skip_crypto = 1;
353           break;
354
355         case oOpenPGP: /* Dummy option for now.  */ break;
356         case oCMS:     /* Dummy option for now.  */ break;
357
358         case oGpgArgs:;
359           {
360             strlist_t list;
361             if (shell_parse_stringlist (pargs->r.ret_str, &list))
362               log_error ("failed to parse gpg arguments '%s'\n",
363                          pargs->r.ret_str);
364             else
365               {
366                 if (opt.gpg_arguments)
367                   strlist_last (opt.gpg_arguments)->next = list;
368                 else
369                   opt.gpg_arguments = list;
370               }
371           }
372           break;
373
374         case oTarArgs:;
375           {
376             int tar_argc;
377             char **tar_argv;
378
379             if (shell_parse_argv (pargs->r.ret_str, &tar_argc, &tar_argv))
380               log_error ("failed to parse tar arguments '%s'\n",
381                          pargs->r.ret_str);
382             else
383               {
384                 ARGPARSE_ARGS tar_args;
385                 tar_args.argc = &tar_argc;
386                 tar_args.argv = &tar_argv;
387                 tar_args.flags = ARGPARSE_FLAG_ARG0;
388                 parse_arguments (&tar_args, tar_opts);
389                 if (tar_args.err)
390                   log_error ("unsupported tar arguments '%s'\n",
391                              pargs->r.ret_str);
392                 pargs->err = tar_args.err;
393               }
394           }
395           break;
396
397         case oDryRun:
398           opt.dry_run = 1;
399           break;
400
401         default: pargs->err = 2; break;
402         }
403     }
404 }
405
406 \f
407 /* gpgtar main. */
408 int
409 main (int argc, char **argv)
410 {
411   gpg_error_t err;
412   const char *fname;
413   ARGPARSE_ARGS pargs;
414
415   assert (sizeof (struct ustar_raw_header) == 512);
416
417   gnupg_reopen_std (GPGTAR_NAME);
418   set_strusage (my_strusage);
419   log_set_prefix (GPGTAR_NAME, GPGRT_LOG_WITH_PREFIX);
420
421   /* Make sure that our subsystems are ready.  */
422   i18n_init();
423   init_common_subsystems (&argc, &argv);
424
425   /* Parse the command line. */
426   pargs.argc  = &argc;
427   pargs.argv  = &argv;
428   pargs.flags = ARGPARSE_FLAG_KEEP;
429   parse_arguments (&pargs, opts);
430
431   if ((files_from && !null_names) || (!files_from && null_names))
432     log_error ("--files-from and --null may only be used in conjunction\n");
433   if (files_from && strcmp (files_from, "-"))
434     log_error ("--files-from only supports argument \"-\"\n");
435
436   if (log_get_errorcount (0))
437     exit (2);
438
439   /* Print a warning if an argument looks like an option.  */
440   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
441     {
442       int i;
443
444       for (i=0; i < argc; i++)
445         if (argv[i][0] == '-' && argv[i][1] == '-')
446           log_info (_("NOTE: '%s' is not considered an option\n"), argv[i]);
447     }
448
449   if (! opt.gpg_program)
450     opt.gpg_program = gnupg_module_name (GNUPG_MODULE_NAME_GPG);
451
452   if (opt.verbose > 1)
453     opt.debug_level = 1024;
454
455   switch (cmd)
456     {
457     case aList:
458       if (argc > 1)
459         usage (1);
460       fname = argc ? *argv : NULL;
461       if (opt.filename)
462         log_info ("note: ignoring option --set-filename\n");
463       if (files_from)
464         log_info ("note: ignoring option --files-from\n");
465       err = gpgtar_list (fname, !skip_crypto);
466       if (err && log_get_errorcount (0) == 0)
467         log_error ("listing archive failed: %s\n", gpg_strerror (err));
468       break;
469
470     case aEncrypt:
471     case aSign:
472     case aSignEncrypt:
473       if ((!argc && !null_names)
474           || (argc && null_names))
475         usage (1);
476       if (opt.filename)
477         log_info ("note: ignoring option --set-filename\n");
478       err = gpgtar_create (null_names? NULL :argv,
479                            !skip_crypto
480                            && (cmd == aEncrypt || cmd == aSignEncrypt),
481                            cmd == aSign || cmd == aSignEncrypt);
482       if (err && log_get_errorcount (0) == 0)
483         log_error ("creating archive failed: %s\n", gpg_strerror (err));
484       break;
485
486     case aDecrypt:
487       if (argc != 1)
488         usage (1);
489       if (opt.outfile)
490         log_info ("note: ignoring option --output\n");
491       if (files_from)
492         log_info ("note: ignoring option --files-from\n");
493       fname = argc ? *argv : NULL;
494       err = gpgtar_extract (fname, !skip_crypto);
495       if (err && log_get_errorcount (0) == 0)
496         log_error ("extracting archive failed: %s\n", gpg_strerror (err));
497       break;
498
499     default:
500       log_error (_("invalid command (there is no implicit command)\n"));
501       break;
502     }
503
504   return log_get_errorcount (0)? 1:0;
505 }
506
507
508 /* Read the next record from STREAM.  RECORD is a buffer provided by
509    the caller and must be at leadt of size RECORDSIZE.  The function
510    return 0 on success and error code on failure; a diagnostic
511    printed as well.  Note that there is no need for an EOF indicator
512    because a tarball has an explicit EOF record. */
513 gpg_error_t
514 read_record (estream_t stream, void *record)
515 {
516   gpg_error_t err;
517   size_t nread;
518
519   nread = es_fread (record, 1, RECORDSIZE, stream);
520   if (nread != RECORDSIZE)
521     {
522       err = gpg_error_from_syserror ();
523       if (es_ferror (stream))
524         log_error ("error reading '%s': %s\n",
525                    es_fname_get (stream), gpg_strerror (err));
526       else
527         log_error ("error reading '%s': premature EOF "
528                    "(size of last record: %zu)\n",
529                    es_fname_get (stream), nread);
530     }
531   else
532     err = 0;
533
534   return err;
535 }
536
537
538 /* Write the RECORD of size RECORDSIZE to STREAM.  FILENAME is the
539    name of the file used for diagnostics.  */
540 gpg_error_t
541 write_record (estream_t stream, const void *record)
542 {
543   gpg_error_t err;
544   size_t nwritten;
545
546   nwritten = es_fwrite (record, 1, RECORDSIZE, stream);
547   if (nwritten != RECORDSIZE)
548     {
549       err = gpg_error_from_syserror ();
550       log_error ("error writing '%s': %s\n",
551                  es_fname_get (stream), gpg_strerror (err));
552     }
553   else
554     err = 0;
555
556   return err;
557 }
558
559
560 /* Return true if FP is an unarmored OpenPGP message.  Note that this
561    function reads a few bytes from FP but pushes them back.  */
562 #if 0
563 static int
564 openpgp_message_p (estream_t fp)
565 {
566   int ctb;
567
568   ctb = es_getc (fp);
569   if (ctb != EOF)
570     {
571       if (es_ungetc (ctb, fp))
572         log_fatal ("error ungetting first byte: %s\n",
573                    gpg_strerror (gpg_error_from_syserror ()));
574
575       if ((ctb & 0x80))
576         {
577           switch ((ctb & 0x40) ? (ctb & 0x3f) : ((ctb>>2)&0xf))
578             {
579             case PKT_MARKER:
580             case PKT_SYMKEY_ENC:
581             case PKT_ONEPASS_SIG:
582             case PKT_PUBKEY_ENC:
583             case PKT_SIGNATURE:
584             case PKT_COMMENT:
585             case PKT_OLD_COMMENT:
586             case PKT_PLAINTEXT:
587             case PKT_COMPRESSED:
588             case PKT_ENCRYPTED:
589               return 1; /* Yes, this seems to be an OpenPGP message.  */
590             default:
591               break;
592             }
593         }
594     }
595   return 0;
596 }
597 #endif