agent: Stop scdaemon after reload when disable_scdaemon.
[gnupg.git] / agent / protect-tool.c
1 /* protect-tool.c - A tool to test the secret key protection
2  * Copyright (C) 2002, 2003, 2004, 2006 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 #include <config.h>
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <stddef.h>
25 #include <stdarg.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <sys/stat.h>
29 #include <unistd.h>
30 #ifdef HAVE_LOCALE_H
31 #include <locale.h>
32 #endif
33 #ifdef HAVE_LANGINFO_CODESET
34 #include <langinfo.h>
35 #endif
36 #ifdef HAVE_DOSISH_SYSTEM
37 #include <fcntl.h> /* for setmode() */
38 #endif
39
40 #include "agent.h"
41 #include "../common/i18n.h"
42 #include "../common/get-passphrase.h"
43 #include "../common/sysutils.h"
44 #include "../common/init.h"
45
46
47 enum cmd_and_opt_values
48 {
49   aNull = 0,
50   oVerbose        = 'v',
51   oArmor          = 'a',
52   oPassphrase     = 'P',
53
54   oProtect        = 'p',
55   oUnprotect      = 'u',
56
57   oNoVerbose = 500,
58   oShadow,
59   oShowShadowInfo,
60   oShowKeygrip,
61   oS2Kcalibration,
62   oCanonical,
63
64   oStore,
65   oForce,
66   oHaveCert,
67   oNoFailOnExist,
68   oHomedir,
69   oPrompt,
70   oStatusMsg,
71   oDebugUseOCB,
72
73   oAgentProgram
74 };
75
76
77 struct rsa_secret_key_s
78 {
79   gcry_mpi_t n;     /* public modulus */
80   gcry_mpi_t e;     /* public exponent */
81   gcry_mpi_t d;     /* exponent */
82   gcry_mpi_t p;     /* prime  p. */
83   gcry_mpi_t q;     /* prime  q. */
84   gcry_mpi_t u;     /* inverse of p mod q. */
85 };
86
87
88 static int opt_armor;
89 static int opt_canonical;
90 static int opt_store;
91 static int opt_force;
92 static int opt_no_fail_on_exist;
93 static int opt_have_cert;
94 static const char *opt_passphrase;
95 static char *opt_prompt;
96 static int opt_status_msg;
97 static const char *opt_agent_program;
98 static int opt_debug_use_ocb;
99
100 static char *get_passphrase (int promptno);
101 static void release_passphrase (char *pw);
102
103
104 static ARGPARSE_OPTS opts[] = {
105   ARGPARSE_group (300, N_("@Commands:\n ")),
106
107   ARGPARSE_c (oProtect,   "protect",   "protect a private key"),
108   ARGPARSE_c (oUnprotect, "unprotect", "unprotect a private key"),
109   ARGPARSE_c (oShadow,    "shadow", "create a shadow entry for a public key"),
110   ARGPARSE_c (oShowShadowInfo,  "show-shadow-info", "return the shadow info"),
111   ARGPARSE_c (oShowKeygrip, "show-keygrip", "show the \"keygrip\""),
112   ARGPARSE_c (oS2Kcalibration, "s2k-calibration", "@"),
113
114   ARGPARSE_group (301, N_("@\nOptions:\n ")),
115
116   ARGPARSE_s_n (oVerbose, "verbose", "verbose"),
117   ARGPARSE_s_n (oArmor, "armor", "write output in advanced format"),
118   ARGPARSE_s_n (oCanonical, "canonical", "write output in canonical format"),
119
120   ARGPARSE_s_s (oPassphrase, "passphrase", "|STRING|use passphrase STRING"),
121   ARGPARSE_s_n (oHaveCert, "have-cert",
122                 "certificate to export provided on STDIN"),
123   ARGPARSE_s_n (oStore,    "store",
124                 "store the created key in the appropriate place"),
125   ARGPARSE_s_n (oForce,    "force",
126                 "force overwriting"),
127   ARGPARSE_s_n (oNoFailOnExist, "no-fail-on-exist", "@"),
128   ARGPARSE_s_s (oHomedir, "homedir", "@"),
129   ARGPARSE_s_s (oPrompt,  "prompt",
130                 "|ESCSTRING|use ESCSTRING as prompt in pinentry"),
131   ARGPARSE_s_n (oStatusMsg, "enable-status-msg", "@"),
132
133   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
134
135   ARGPARSE_s_n (oDebugUseOCB,  "debug-use-ocb", "@"), /* For hacking only.  */
136
137   ARGPARSE_end ()
138 };
139
140 static const char *
141 my_strusage (int level)
142 {
143   const char *p;
144   switch (level)
145     {
146     case 11: p = "gpg-protect-tool (" GNUPG_NAME ")";
147       break;
148     case 13: p = VERSION; break;
149     case 17: p = PRINTABLE_OS_NAME; break;
150     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
151
152     case 1:
153     case 40: p =  _("Usage: gpg-protect-tool [options] (-h for help)\n");
154       break;
155     case 41: p =  _("Syntax: gpg-protect-tool [options] [args]\n"
156                     "Secret key maintenance tool\n");
157     break;
158
159     default: p = NULL;
160     }
161   return p;
162 }
163
164
165 /*  static void */
166 /*  print_mpi (const char *text, gcry_mpi_t a) */
167 /*  { */
168 /*    char *buf; */
169 /*    void *bufaddr = &buf; */
170 /*    int rc; */
171
172 /*    rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a); */
173 /*    if (rc) */
174 /*      log_info ("%s: [error printing number: %s]\n", text, gpg_strerror (rc)); */
175 /*    else */
176 /*      { */
177 /*        log_info ("%s: %s\n", text, buf); */
178 /*        gcry_free (buf); */
179 /*      } */
180 /*  } */
181
182
183 \f
184 static unsigned char *
185 make_canonical (const char *fname, const char *buf, size_t buflen)
186 {
187   int rc;
188   size_t erroff, len;
189   gcry_sexp_t sexp;
190   unsigned char *result;
191
192   rc = gcry_sexp_sscan (&sexp, &erroff, buf, buflen);
193   if (rc)
194     {
195       log_error ("invalid S-Expression in '%s' (off=%u): %s\n",
196                  fname, (unsigned int)erroff, gpg_strerror (rc));
197       return NULL;
198     }
199   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, NULL, 0);
200   log_assert (len);
201   result = xmalloc (len);
202   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, result, len);
203   log_assert (len);
204   gcry_sexp_release (sexp);
205   return result;
206 }
207
208 static char *
209 make_advanced (const unsigned char *buf, size_t buflen)
210 {
211   int rc;
212   size_t erroff, len;
213   gcry_sexp_t sexp;
214   char *result;
215
216   rc = gcry_sexp_sscan (&sexp, &erroff, (const char*)buf, buflen);
217   if (rc)
218     {
219       log_error ("invalid canonical S-Expression (off=%u): %s\n",
220                  (unsigned int)erroff, gpg_strerror (rc));
221       return NULL;
222     }
223   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, NULL, 0);
224   log_assert (len);
225   result = xmalloc (len);
226   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, result, len);
227   log_assert (len);
228   gcry_sexp_release (sexp);
229   return result;
230 }
231
232
233 static char *
234 read_file (const char *fname, size_t *r_length)
235 {
236   FILE *fp;
237   char *buf;
238   size_t buflen;
239
240   if (!strcmp (fname, "-"))
241     {
242       size_t nread, bufsize = 0;
243
244       fp = stdin;
245 #ifdef HAVE_DOSISH_SYSTEM
246       setmode ( fileno(fp) , O_BINARY );
247 #endif
248       buf = NULL;
249       buflen = 0;
250 #define NCHUNK 8192
251       do
252         {
253           bufsize += NCHUNK;
254           if (!buf)
255             buf = xmalloc (bufsize);
256           else
257             buf = xrealloc (buf, bufsize);
258
259           nread = fread (buf+buflen, 1, NCHUNK, fp);
260           if (nread < NCHUNK && ferror (fp))
261             {
262               log_error ("error reading '[stdin]': %s\n", strerror (errno));
263               xfree (buf);
264               return NULL;
265             }
266           buflen += nread;
267         }
268       while (nread == NCHUNK);
269 #undef NCHUNK
270
271     }
272   else
273     {
274       struct stat st;
275
276       fp = fopen (fname, "rb");
277       if (!fp)
278         {
279           log_error ("can't open '%s': %s\n", fname, strerror (errno));
280           return NULL;
281         }
282
283       if (fstat (fileno(fp), &st))
284         {
285           log_error ("can't stat '%s': %s\n", fname, strerror (errno));
286           fclose (fp);
287           return NULL;
288         }
289
290       buflen = st.st_size;
291       buf = xmalloc (buflen+1);
292       if (fread (buf, buflen, 1, fp) != 1)
293         {
294           log_error ("error reading '%s': %s\n", fname, strerror (errno));
295           fclose (fp);
296           xfree (buf);
297           return NULL;
298         }
299       fclose (fp);
300     }
301
302   *r_length = buflen;
303   return buf;
304 }
305
306
307 static unsigned char *
308 read_key (const char *fname)
309 {
310   char *buf;
311   size_t buflen;
312   unsigned char *key;
313
314   buf = read_file (fname, &buflen);
315   if (!buf)
316     return NULL;
317   key = make_canonical (fname, buf, buflen);
318   xfree (buf);
319   return key;
320 }
321
322
323 \f
324 static void
325 read_and_protect (const char *fname)
326 {
327   int  rc;
328   unsigned char *key;
329   unsigned char *result;
330   size_t resultlen;
331   char *pw;
332
333   key = read_key (fname);
334   if (!key)
335     return;
336
337   pw = get_passphrase (1);
338   rc = agent_protect (key, pw, &result, &resultlen, 0,
339                       opt_debug_use_ocb? 1 : -1);
340   release_passphrase (pw);
341   xfree (key);
342   if (rc)
343     {
344       log_error ("protecting the key failed: %s\n", gpg_strerror (rc));
345       return;
346     }
347
348   if (opt_armor)
349     {
350       char *p = make_advanced (result, resultlen);
351       xfree (result);
352       if (!p)
353         return;
354       result = (unsigned char*)p;
355       resultlen = strlen (p);
356     }
357
358   fwrite (result, resultlen, 1, stdout);
359   xfree (result);
360 }
361
362
363 static void
364 read_and_unprotect (ctrl_t ctrl, const char *fname)
365 {
366   int  rc;
367   unsigned char *key;
368   unsigned char *result;
369   size_t resultlen;
370   char *pw;
371   gnupg_isotime_t protected_at;
372
373   key = read_key (fname);
374   if (!key)
375     return;
376
377   rc = agent_unprotect (ctrl, key, (pw=get_passphrase (1)),
378                         protected_at, &result, &resultlen);
379   release_passphrase (pw);
380   xfree (key);
381   if (rc)
382     {
383       if (opt_status_msg)
384         log_info ("[PROTECT-TOOL:] bad-passphrase\n");
385       log_error ("unprotecting the key failed: %s\n", gpg_strerror (rc));
386       return;
387     }
388   if (opt.verbose)
389     {
390       if (*protected_at)
391         log_info ("key protection done at %.4s-%.2s-%.2s %.2s:%.2s:%s\n",
392                   protected_at, protected_at+4, protected_at+6,
393                   protected_at+9, protected_at+11, protected_at+13);
394       else
395         log_info ("key protection done at [unknown]\n");
396     }
397
398   if (opt_armor)
399     {
400       char *p = make_advanced (result, resultlen);
401       xfree (result);
402       if (!p)
403         return;
404       result = (unsigned char*)p;
405       resultlen = strlen (p);
406     }
407
408   fwrite (result, resultlen, 1, stdout);
409   xfree (result);
410 }
411
412
413 \f
414 static void
415 read_and_shadow (const char *fname)
416 {
417   int  rc;
418   unsigned char *key;
419   unsigned char *result;
420   size_t resultlen;
421   unsigned char dummy_info[] = "(8:313233342:43)";
422
423   key = read_key (fname);
424   if (!key)
425     return;
426
427   rc = agent_shadow_key (key, dummy_info, &result);
428   xfree (key);
429   if (rc)
430     {
431       log_error ("shadowing the key failed: %s\n", gpg_strerror (rc));
432       return;
433     }
434   resultlen = gcry_sexp_canon_len (result, 0, NULL,NULL);
435   log_assert (resultlen);
436
437   if (opt_armor)
438     {
439       char *p = make_advanced (result, resultlen);
440       xfree (result);
441       if (!p)
442         return;
443       result = (unsigned char*)p;
444       resultlen = strlen (p);
445     }
446
447   fwrite (result, resultlen, 1, stdout);
448   xfree (result);
449 }
450
451 static void
452 show_shadow_info (const char *fname)
453 {
454   int  rc;
455   unsigned char *key;
456   const unsigned char *info;
457   size_t infolen;
458
459   key = read_key (fname);
460   if (!key)
461     return;
462
463   rc = agent_get_shadow_info (key, &info);
464   xfree (key);
465   if (rc)
466     {
467       log_error ("get_shadow_info failed: %s\n", gpg_strerror (rc));
468       return;
469     }
470   infolen = gcry_sexp_canon_len (info, 0, NULL,NULL);
471   log_assert (infolen);
472
473   if (opt_armor)
474     {
475       char *p = make_advanced (info, infolen);
476       if (!p)
477         return;
478       fwrite (p, strlen (p), 1, stdout);
479       xfree (p);
480     }
481   else
482     fwrite (info, infolen, 1, stdout);
483 }
484
485
486 static void
487 show_file (const char *fname)
488 {
489   unsigned char *key;
490   size_t keylen;
491   char *p;
492
493   key = read_key (fname);
494   if (!key)
495     return;
496
497   keylen = gcry_sexp_canon_len (key, 0, NULL,NULL);
498   log_assert (keylen);
499
500   if (opt_canonical)
501     {
502       fwrite (key, keylen, 1, stdout);
503     }
504   else
505     {
506       p = make_advanced (key, keylen);
507       if (p)
508         {
509           fwrite (p, strlen (p), 1, stdout);
510           xfree (p);
511         }
512     }
513   xfree (key);
514 }
515
516 static void
517 show_keygrip (const char *fname)
518 {
519   unsigned char *key;
520   gcry_sexp_t private;
521   unsigned char grip[20];
522   int i;
523
524   key = read_key (fname);
525   if (!key)
526     return;
527
528   if (gcry_sexp_new (&private, key, 0, 0))
529     {
530       log_error ("gcry_sexp_new failed\n");
531       return;
532     }
533   xfree (key);
534
535   if (!gcry_pk_get_keygrip (private, grip))
536     {
537       log_error ("can't calculate keygrip\n");
538       return;
539     }
540   gcry_sexp_release (private);
541
542   for (i=0; i < 20; i++)
543     printf ("%02X", grip[i]);
544   putchar ('\n');
545 }
546
547 \f
548
549
550 \f
551 int
552 main (int argc, char **argv )
553 {
554   ARGPARSE_ARGS pargs;
555   int cmd = 0;
556   const char *fname;
557   ctrl_t ctrl;
558
559   early_system_init ();
560   set_strusage (my_strusage);
561   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
562   log_set_prefix ("gpg-protect-tool", GPGRT_LOG_WITH_PREFIX);
563
564   /* Make sure that our subsystems are ready.  */
565   i18n_init ();
566   init_common_subsystems (&argc, &argv);
567
568   setup_libgcrypt_logging ();
569   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
570
571   pargs.argc = &argc;
572   pargs.argv = &argv;
573   pargs.flags=  1;  /* (do not remove the args) */
574   while (arg_parse (&pargs, opts) )
575     {
576       switch (pargs.r_opt)
577         {
578         case oVerbose: opt.verbose++; break;
579         case oArmor:   opt_armor=1; break;
580         case oCanonical: opt_canonical=1; break;
581         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
582
583         case oAgentProgram: opt_agent_program = pargs.r.ret_str; break;
584
585         case oProtect: cmd = oProtect; break;
586         case oUnprotect: cmd = oUnprotect; break;
587         case oShadow: cmd = oShadow; break;
588         case oShowShadowInfo: cmd = oShowShadowInfo; break;
589         case oShowKeygrip: cmd = oShowKeygrip; break;
590         case oS2Kcalibration: cmd = oS2Kcalibration; break;
591
592         case oPassphrase: opt_passphrase = pargs.r.ret_str; break;
593         case oStore: opt_store = 1; break;
594         case oForce: opt_force = 1; break;
595         case oNoFailOnExist: opt_no_fail_on_exist = 1; break;
596         case oHaveCert: opt_have_cert = 1; break;
597         case oPrompt: opt_prompt = pargs.r.ret_str; break;
598         case oStatusMsg: opt_status_msg = 1; break;
599         case oDebugUseOCB: opt_debug_use_ocb = 1; break;
600
601         default: pargs.err = ARGPARSE_PRINT_ERROR; break;
602         }
603     }
604   if (log_get_errorcount (0))
605     exit (2);
606
607   fname = "-";
608   if (argc == 1)
609     fname = *argv;
610   else if (argc > 1)
611     usage (1);
612
613   /* Allocate an CTRL object.  An empty object should be sufficient.  */
614   ctrl = xtrycalloc (1, sizeof *ctrl);
615   if (!ctrl)
616     {
617       log_error ("error allocating connection control data: %s\n",
618                  strerror (errno));
619       agent_exit (1);
620     }
621
622   /* Set the information which can't be taken from envvars.  */
623   gnupg_prepare_get_passphrase (GPG_ERR_SOURCE_DEFAULT,
624                                 opt.verbose,
625                                 opt_agent_program,
626                                 NULL, NULL, NULL);
627
628   if (opt_prompt)
629     opt_prompt = percent_plus_unescape (opt_prompt, 0);
630
631   if (cmd == oProtect)
632     read_and_protect (fname);
633   else if (cmd == oUnprotect)
634     read_and_unprotect (ctrl, fname);
635   else if (cmd == oShadow)
636     read_and_shadow (fname);
637   else if (cmd == oShowShadowInfo)
638     show_shadow_info (fname);
639   else if (cmd == oShowKeygrip)
640     show_keygrip (fname);
641   else if (cmd == oS2Kcalibration)
642     {
643       if (!opt.verbose)
644         opt.verbose++; /* We need to see something.  */
645       get_standard_s2k_count ();
646     }
647   else
648     show_file (fname);
649
650   xfree (ctrl);
651
652   agent_exit (0);
653   return 8; /*NOTREACHED*/
654 }
655
656 void
657 agent_exit (int rc)
658 {
659   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
660   exit (rc);
661 }
662
663
664 /* Return the passphrase string and ask the agent if it has not been
665    set from the command line  PROMPTNO select the prompt to display:
666      0 = default
667      1 = taken from the option --prompt
668      2 = for unprotecting a pkcs#12 object
669      3 = for protecting a new pkcs#12 object
670      4 = for protecting an imported pkcs#12 in our system
671 */
672 static char *
673 get_passphrase (int promptno)
674 {
675   char *pw;
676   int err;
677   const char *desc;
678   char *orig_codeset;
679   int repeat = 0;
680
681   if (opt_passphrase)
682     return xstrdup (opt_passphrase);
683
684   orig_codeset = i18n_switchto_utf8 ();
685
686   if (promptno == 1 && opt_prompt)
687     {
688       desc = opt_prompt;
689     }
690   else if (promptno == 2)
691     {
692       desc = _("Please enter the passphrase to unprotect the "
693                "PKCS#12 object.");
694     }
695   else if (promptno == 3)
696     {
697       desc = _("Please enter the passphrase to protect the "
698                "new PKCS#12 object.");
699       repeat = 1;
700     }
701   else if (promptno == 4)
702     {
703       desc = _("Please enter the passphrase to protect the "
704                "imported object within the GnuPG system.");
705       repeat = 1;
706     }
707   else
708     desc = _("Please enter the passphrase or the PIN\n"
709              "needed to complete this operation.");
710
711   i18n_switchback (orig_codeset);
712
713   err = gnupg_get_passphrase (NULL, NULL, _("Passphrase:"), desc,
714                               repeat, repeat, 1, &pw);
715   if (err)
716     {
717       if (gpg_err_code (err) == GPG_ERR_CANCELED
718           || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
719         log_info (_("cancelled\n"));
720       else
721         log_error (_("error while asking for the passphrase: %s\n"),
722                    gpg_strerror (err));
723       agent_exit (0);
724     }
725   log_assert (pw);
726
727   return pw;
728 }
729
730
731 static void
732 release_passphrase (char *pw)
733 {
734   if (pw)
735     {
736       wipememory (pw, strlen (pw));
737       xfree (pw);
738     }
739 }
740
741
742 /* Stub function.  */
743 int
744 agent_key_available (const unsigned char *grip)
745 {
746   (void)grip;
747   return -1;  /* Not available.  */
748 }
749
750 char *
751 agent_get_cache (ctrl_t ctrl, const char *key, cache_mode_t cache_mode)
752 {
753   (void)ctrl;
754   (void)key;
755   (void)cache_mode;
756   return NULL;
757 }
758
759 gpg_error_t
760 agent_askpin (ctrl_t ctrl,
761               const char *desc_text, const char *prompt_text,
762               const char *initial_errtext,
763               struct pin_entry_info_s *pininfo,
764               const char *keyinfo, cache_mode_t cache_mode)
765 {
766   gpg_error_t err;
767   unsigned char *passphrase;
768   size_t size;
769
770   (void)ctrl;
771   (void)desc_text;
772   (void)prompt_text;
773   (void)initial_errtext;
774   (void)keyinfo;
775   (void)cache_mode;
776
777   *pininfo->pin = 0; /* Reset the PIN. */
778   passphrase = get_passphrase (0);
779   size = strlen (passphrase);
780   if (size >= pininfo->max_length)
781     return gpg_error (GPG_ERR_TOO_LARGE);
782
783   memcpy (&pininfo->pin, passphrase, size);
784   xfree (passphrase);
785   pininfo->pin[size] = 0;
786   if (pininfo->check_cb)
787     {
788       /* More checks by utilizing the optional callback. */
789       pininfo->cb_errtext = NULL;
790       err = pininfo->check_cb (pininfo);
791     }
792   else
793     err = 0;
794   return err;
795 }
796
797 /* Replacement for the function in findkey.c.  Here we write the key
798  * to stdout. */
799 int
800 agent_write_private_key (const unsigned char *grip,
801                          const void *buffer, size_t length, int force,
802                          const char *serialno, const char *keyref)
803 {
804   char hexgrip[40+4+1];
805   char *p;
806
807   (void)force;
808   (void)serialno;
809   (void)keyref;
810
811   bin2hex (grip, 20, hexgrip);
812   strcpy (hexgrip+40, ".key");
813   p = make_advanced (buffer, length);
814   if (p)
815     {
816       printf ("# Begin dump of %s\n%s%s# End dump of %s\n",
817               hexgrip, p, (*p && p[strlen(p)-1] == '\n')? "":"\n", hexgrip);
818       xfree (p);
819     }
820
821   return 0;
822 }