gpg: Improve 'General key info' line of --card-status.
[gnupg.git] / g10 / passphrase.c
1 /* passphrase.c -  Get a passphrase
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2005, 2006, 2007, 2009, 2011 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stddef.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <assert.h>
28 #include <errno.h>
29 #ifdef HAVE_LOCALE_H
30 #include <locale.h>
31 #endif
32 #ifdef HAVE_LANGINFO_CODESET
33 #include <langinfo.h>
34 #endif
35
36 #include "gpg.h"
37 #include "util.h"
38 #include "options.h"
39 #include "ttyio.h"
40 #include "keydb.h"
41 #include "main.h"
42 #include "i18n.h"
43 #include "status.h"
44 #include "call-agent.h"
45 #include "../common/shareddefs.h"
46
47 static char *fd_passwd = NULL;
48 static char *next_pw = NULL;
49 static char *last_pw = NULL;
50
51
52
53 /* Pack an s2k iteration count into the form specified in 2440.  If
54    we're in between valid values, round up.  With value 0 return the
55    old default.  */
56 unsigned char
57 encode_s2k_iterations (int iterations)
58 {
59   gpg_error_t err;
60   unsigned char c=0;
61   unsigned char result;
62   unsigned int count;
63
64   if (!iterations)
65     {
66       unsigned long mycnt;
67
68       /* Ask the gpg-agent for a useful iteration count.  */
69       err = agent_get_s2k_count (&mycnt);
70       if (err || mycnt < 65536)
71         {
72           /* Don't print an error if an older agent is used.  */
73           if (err && gpg_err_code (err) != GPG_ERR_ASS_PARAMETER)
74             log_error (_("problem with the agent: %s\n"), gpg_strerror (err));
75           /* Default to 65536 which we used up to 2.0.13.  */
76           return 96;
77         }
78       else if (mycnt >= 65011712)
79         return 255; /* Largest possible value.  */
80       else
81         return encode_s2k_iterations ((int)mycnt);
82     }
83
84   if (iterations <= 1024)
85     return 0;  /* Command line arg compatibility.  */
86
87   if (iterations >= 65011712)
88     return 255;
89
90   /* Need count to be in the range 16-31 */
91   for (count=iterations>>6; count>=32; count>>=1)
92     c++;
93
94   result = (c<<4)|(count-16);
95
96   if (S2K_DECODE_COUNT(result) < iterations)
97     result++;
98
99   return result;
100 }
101
102
103 int
104 have_static_passphrase()
105 {
106   return (!!fd_passwd
107           && (opt.batch || opt.pinentry_mode == PINENTRY_MODE_LOOPBACK));
108 }
109
110 /* Return a static passphrase.  The returned value is only valid as
111    long as no other passphrase related function is called.  NULL may
112    be returned if no passphrase has been set; better use
113    have_static_passphrase first.  */
114 const char *
115 get_static_passphrase (void)
116 {
117   return fd_passwd;
118 }
119
120
121 /****************
122  * Set the passphrase to be used for the next query and only for the next
123  * one.
124  */
125 void
126 set_next_passphrase( const char *s )
127 {
128   xfree(next_pw);
129   next_pw = NULL;
130   if ( s )
131     {
132       next_pw = xmalloc_secure( strlen(s)+1 );
133       strcpy (next_pw, s );
134     }
135 }
136
137 /****************
138  * Get the last passphrase used in passphrase_to_dek.
139  * Note: This removes the passphrase from this modules and
140  * the caller must free the result.  May return NULL:
141  */
142 char *
143 get_last_passphrase()
144 {
145   char *p = last_pw;
146   last_pw = NULL;
147   return p;
148 }
149
150 /* Here's an interesting question: since this passphrase was passed in
151    on the command line, is there really any point in using secure
152    memory for it?  I'm going with 'yes', since it doesn't hurt, and
153    might help in some small way (swapping). */
154
155 void
156 set_passphrase_from_string(const char *pass)
157 {
158   xfree (fd_passwd);
159   fd_passwd = xmalloc_secure(strlen(pass)+1);
160   strcpy (fd_passwd, pass);
161 }
162
163
164 void
165 read_passphrase_from_fd( int fd )
166 {
167   int i, len;
168   char *pw;
169
170   if ( !opt.batch && opt.pinentry_mode != PINENTRY_MODE_LOOPBACK)
171     { /* Not used but we have to do a dummy read, so that it won't end
172          up at the begin of the message if the quite usual trick to
173          prepend the passphtrase to the message is used. */
174       char buf[1];
175
176       while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
177         ;
178       *buf = 0;
179       return;
180     }
181
182   for (pw = NULL, i = len = 100; ; i++ )
183     {
184       if (i >= len-1 )
185         {
186           char *pw2 = pw;
187           len += 100;
188           pw = xmalloc_secure( len );
189           if( pw2 )
190             {
191               memcpy(pw, pw2, i );
192               xfree (pw2);
193             }
194           else
195             i=0;
196         }
197       if (read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
198         break;
199     }
200   pw[i] = 0;
201   if (!opt.batch && opt.pinentry_mode != PINENTRY_MODE_LOOPBACK)
202     tty_printf("\b\b\b   \n" );
203
204   xfree ( fd_passwd );
205   fd_passwd = pw;
206 }
207
208
209 /*
210  * Ask the GPG Agent for the passphrase.
211  * Mode 0:  Allow cached passphrase
212  *      1:  No cached passphrase; that is we are asking for a new passphrase
213  *          FIXME: Only partially implemented
214  *
215  * Note that TRYAGAIN_TEXT must not be translated.  If CANCELED is not
216  * NULL, the function does set it to 1 if the user canceled the
217  * operation.  If CACHEID is not NULL, it will be used as the cacheID
218  * for the gpg-agent; if is NULL and a key fingerprint can be
219  * computed, this will be used as the cacheid.
220  */
221 static char *
222 passphrase_get ( u32 *keyid, int mode, const char *cacheid, int repeat,
223                  const char *tryagain_text,
224                  const char *custom_description,
225                  const char *custom_prompt, int *canceled)
226 {
227   int rc;
228   char *atext = NULL;
229   char *pw = NULL;
230   PKT_public_key *pk = xmalloc_clear( sizeof *pk );
231   byte fpr[MAX_FINGERPRINT_LEN];
232   int have_fpr = 0;
233   char *orig_codeset;
234   char *my_prompt;
235   char hexfprbuf[20*2+1];
236   const char *my_cacheid;
237   int check = (mode == 1);
238
239   if (canceled)
240     *canceled = 0;
241
242 #if MAX_FINGERPRINT_LEN < 20
243 #error agent needs a 20 byte fingerprint
244 #endif
245
246   memset (fpr, 0, MAX_FINGERPRINT_LEN );
247   if( keyid && get_pubkey( pk, keyid ) )
248     {
249       free_public_key (pk);
250       pk = NULL; /* oops: no key for some reason */
251     }
252
253   orig_codeset = i18n_switchto_utf8 ();
254
255   if (custom_description)
256     atext = native_to_utf8 (custom_description);
257   else if ( !mode && pk && keyid )
258     {
259       char *uid;
260       size_t uidlen;
261       const char *algo_name = openpgp_pk_algo_name ( pk->pubkey_algo );
262       const char *timestr;
263       char *maink;
264
265       if ( !algo_name )
266         algo_name = "?";
267
268       if (keyid[2] && keyid[3]
269           && keyid[0] != keyid[2]
270           && keyid[1] != keyid[3] )
271         maink = xasprintf (_(" (main key ID %s)"), keystr (&keyid[2]));
272       else
273         maink = xstrdup ("");
274
275       uid = get_user_id ( keyid, &uidlen );
276       timestr = strtimestamp (pk->timestamp);
277
278       atext = xasprintf (_("Please enter the passphrase to unlock the"
279                            " secret key for the OpenPGP certificate:\n"
280                            "\"%.*s\"\n"
281                            "%u-bit %s key, ID %s,\n"
282                            "created %s%s.\n"),
283                          (int)uidlen, uid,
284                          nbits_from_pk (pk), algo_name, keystr(&keyid[0]),
285                          timestr, maink);
286       xfree (uid);
287       xfree (maink);
288
289       {
290         size_t dummy;
291         fingerprint_from_pk( pk, fpr, &dummy );
292         have_fpr = 1;
293       }
294
295     }
296   else
297     atext = xstrdup ( _("Enter passphrase\n") );
298
299
300   if (!mode && cacheid)
301     my_cacheid = cacheid;
302   else if (!mode && have_fpr)
303     my_cacheid = bin2hex (fpr, 20, hexfprbuf);
304   else
305     my_cacheid = NULL;
306
307   if (tryagain_text)
308     tryagain_text = _(tryagain_text);
309
310   my_prompt = custom_prompt ? native_to_utf8 (custom_prompt): NULL;
311
312   rc = agent_get_passphrase (my_cacheid, tryagain_text, my_prompt, atext,
313                              repeat, check, &pw);
314
315   xfree (my_prompt);
316   xfree (atext); atext = NULL;
317
318   i18n_switchback (orig_codeset);
319
320
321   if (!rc)
322     ;
323   else if (gpg_err_code (rc) == GPG_ERR_CANCELED
324             || gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
325     {
326       log_info (_("cancelled by user\n") );
327       if (canceled)
328         *canceled = 1;
329     }
330   else
331     {
332       log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
333       /* Due to limitations in the API of the upper layers they
334          consider an error as no passphrase entered.  This works in
335          most cases but not during key creation where this should
336          definitely not happen and let it continue without requiring a
337          passphrase.  Given that now all the upper layers handle a
338          cancel correctly, we simply set the cancel flag now for all
339          errors from the agent.  */
340       if (canceled)
341         *canceled = 1;
342
343       write_status_errcode ("get_passphrase", rc);
344     }
345
346   free_public_key (pk);
347   if (rc)
348     {
349       xfree (pw);
350       return NULL;
351     }
352   return pw;
353 }
354
355
356 /*
357  * Clear the cached passphrase.  If CACHEID is not NULL, it will be
358  * used instead of a cache ID derived from KEYID.
359  */
360 void
361 passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
362 {
363   int rc;
364
365   (void)algo;
366
367   if (!cacheid)
368     {
369       PKT_public_key *pk;
370 #     if MAX_FINGERPRINT_LEN < 20
371 #       error agent needs a 20 byte fingerprint
372 #     endif
373       byte fpr[MAX_FINGERPRINT_LEN];
374       char hexfprbuf[2*20+1];
375       size_t dummy;
376
377       pk = xcalloc (1, sizeof *pk);
378       if ( !keyid || get_pubkey( pk, keyid ) )
379         {
380           log_error ("key not found in passphrase_clear_cache\n");
381           free_public_key (pk);
382           return;
383         }
384       memset (fpr, 0, MAX_FINGERPRINT_LEN );
385       fingerprint_from_pk ( pk, fpr, &dummy );
386       bin2hex (fpr, 20, hexfprbuf);
387       rc = agent_clear_passphrase (hexfprbuf);
388       free_public_key ( pk );
389     }
390   else
391     rc = agent_clear_passphrase (cacheid);
392
393   if (rc)
394     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
395 }
396
397
398 /* Return a new DEK object using the string-to-key specifier S2K.  Use
399    KEYID and PUBKEY_ALGO to prompt the user.  Returns NULL is the user
400    selected to cancel the passphrase entry and if CANCELED is not
401    NULL, sets it to true.
402
403    MODE 0:  Allow cached passphrase
404         1:  Ignore cached passphrase
405         2:  Ditto, but create a new key
406         3:  Allow cached passphrase; use the S2K salt as the cache ID
407         4:  Ditto, but create a new key
408 */
409 DEK *
410 passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
411                        int cipher_algo, STRING2KEY *s2k, int mode,
412                        const char *tryagain_text,
413                        const char *custdesc, const char *custprompt,
414                        int *canceled)
415 {
416   char *pw = NULL;
417   DEK *dek;
418   STRING2KEY help_s2k;
419   int dummy_canceled;
420   char s2k_cacheidbuf[1+16+1], *s2k_cacheid = NULL;
421
422   if (!canceled)
423     canceled = &dummy_canceled;
424   *canceled = 0;
425
426   if ( !s2k )
427     {
428       assert (mode != 3 && mode != 4);
429       /* This is used for the old rfc1991 mode
430        * Note: This must match the code in encode.c with opt.rfc1991 set */
431       s2k = &help_s2k;
432       s2k->mode = 0;
433       s2k->hash_algo = S2K_DIGEST_ALGO;
434     }
435
436   /* Create a new salt or what else to be filled into the s2k for a
437      new key.  */
438   if ((mode == 2 || mode == 4) && (s2k->mode == 1 || s2k->mode == 3))
439     {
440       gcry_randomize (s2k->salt, 8, GCRY_STRONG_RANDOM);
441       if ( s2k->mode == 3 )
442         {
443           /* We delay the encoding until it is really needed.  This is
444              if we are going to dynamically calibrate it, we need to
445              call out to gpg-agent and that should not be done during
446              option processing in main().  */
447           if (!opt.s2k_count)
448             opt.s2k_count = encode_s2k_iterations (0);
449           s2k->count = opt.s2k_count;
450         }
451     }
452
453   /* If we do not have a passphrase available in NEXT_PW and status
454      information are request, we print them now. */
455   if ( !next_pw && is_status_enabled() )
456     {
457       char buf[50];
458
459       if ( keyid )
460         {
461           emit_status_need_passphrase (keyid,
462                                        keyid[2] && keyid[3]? keyid+2:NULL,
463                                        pubkey_algo);
464         }
465       else
466         {
467           snprintf (buf, sizeof buf -1, "%d %d %d",
468                     cipher_algo, s2k->mode, s2k->hash_algo );
469           write_status_text ( STATUS_NEED_PASSPHRASE_SYM, buf );
470         }
471     }
472
473   /* If we do have a keyID, we do not have a passphrase available in
474      NEXT_PW, we are not running in batch mode and we do not want to
475      ignore the passphrase cache (mode!=1), print a prompt with
476      information on that key. */
477   if ( keyid && !opt.batch && !next_pw && mode!=1 )
478     {
479       PKT_public_key *pk = xmalloc_clear( sizeof *pk );
480       char *p;
481
482       p = get_user_id_native(keyid);
483       tty_printf ("\n");
484       tty_printf (_("You need a passphrase to unlock the secret key for\n"
485                     "user: \"%s\"\n"),p);
486       xfree(p);
487
488       if ( !get_pubkey( pk, keyid ) )
489         {
490           const char *s = openpgp_pk_algo_name ( pk->pubkey_algo );
491
492           tty_printf (_("%u-bit %s key, ID %s, created %s"),
493                       nbits_from_pk( pk ), s?s:"?", keystr(keyid),
494                       strtimestamp(pk->timestamp) );
495           if ( keyid[2] && keyid[3]
496                && keyid[0] != keyid[2] && keyid[1] != keyid[3] )
497             {
498               if ( keystrlen () > 10 )
499                 {
500                   tty_printf ("\n");
501                   tty_printf (_("         (subkey on main key ID %s)"),
502                               keystr(&keyid[2]) );
503                 }
504               else
505                 tty_printf ( _(" (main key ID %s)"), keystr(&keyid[2]) );
506             }
507           tty_printf("\n");
508         }
509
510       tty_printf("\n");
511       free_public_key (pk);
512     }
513
514   if ( next_pw )
515     {
516       /* Simply return the passphrase we already have in NEXT_PW. */
517       pw = next_pw;
518       next_pw = NULL;
519     }
520   else if ( have_static_passphrase () )
521     {
522       /* Return the passphrase we have stored in FD_PASSWD. */
523       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
524       strcpy ( pw, fd_passwd );
525     }
526   else
527     {
528       if ((mode == 3 || mode == 4) && (s2k->mode == 1 || s2k->mode == 3))
529         {
530           memset (s2k_cacheidbuf, 0, sizeof s2k_cacheidbuf);
531           *s2k_cacheidbuf = 'S';
532           bin2hex (s2k->salt, 8, s2k_cacheidbuf + 1);
533           s2k_cacheid = s2k_cacheidbuf;
534         }
535
536       /* Divert to the gpg-agent. */
537       pw = passphrase_get (keyid, mode == 2, s2k_cacheid,
538                            (mode == 2 || mode == 4)? opt.passphrase_repeat : 0,
539                            tryagain_text, custdesc, custprompt, canceled);
540       if (*canceled)
541         {
542           xfree (pw);
543           write_status( STATUS_MISSING_PASSPHRASE );
544           return NULL;
545         }
546     }
547
548   if ( !pw || !*pw )
549     write_status( STATUS_MISSING_PASSPHRASE );
550
551   /* Hash the passphrase and store it in a newly allocated DEK object.
552      Keep a copy of the passphrase in LAST_PW for use by
553      get_last_passphrase(). */
554   dek = xmalloc_secure_clear ( sizeof *dek );
555   dek->algo = cipher_algo;
556   if ( (!pw || !*pw) && (mode == 2 || mode == 4))
557     dek->keylen = 0;
558   else
559     {
560       gpg_error_t err;
561
562       dek->keylen = openpgp_cipher_get_algo_keylen (dek->algo);
563       if (!(dek->keylen > 0 && dek->keylen <= DIM(dek->key)))
564         BUG ();
565       err = gcry_kdf_derive (pw, strlen (pw),
566                              s2k->mode == 3? GCRY_KDF_ITERSALTED_S2K :
567                              s2k->mode == 1? GCRY_KDF_SALTED_S2K :
568                              /* */           GCRY_KDF_SIMPLE_S2K,
569                              s2k->hash_algo, s2k->salt, 8,
570                              S2K_DECODE_COUNT(s2k->count),
571                              dek->keylen, dek->key);
572       if (err)
573         {
574           log_error ("gcry_kdf_derive failed: %s", gpg_strerror (err));
575           xfree (pw);
576           xfree (dek);
577           write_status( STATUS_MISSING_PASSPHRASE );
578           return NULL;
579         }
580     }
581   if (s2k_cacheid)
582     memcpy (dek->s2k_cacheid, s2k_cacheid, sizeof dek->s2k_cacheid);
583   xfree(last_pw);
584   last_pw = pw;
585   return dek;
586 }
587
588
589 DEK *
590 passphrase_to_dek (u32 *keyid, int pubkey_algo,
591                    int cipher_algo, STRING2KEY *s2k, int mode,
592                    const char *tryagain_text, int *canceled)
593 {
594   return passphrase_to_dek_ext (keyid, pubkey_algo, cipher_algo,
595                                 s2k, mode, tryagain_text, NULL, NULL,
596                                 canceled);
597 }
598
599
600 /* Emit the USERID_HINT and the NEED_PASSPHRASE status messages.
601    MAINKEYID may be NULL. */
602 void
603 emit_status_need_passphrase (u32 *keyid, u32 *mainkeyid, int pubkey_algo)
604 {
605   char buf[50];
606   char *us;
607
608   us = get_long_user_id_string (keyid);
609   write_status_text (STATUS_USERID_HINT, us);
610   xfree (us);
611
612   snprintf (buf, sizeof buf -1, "%08lX%08lX %08lX%08lX %d 0",
613             (ulong)keyid[0],
614             (ulong)keyid[1],
615             (ulong)(mainkeyid? mainkeyid[0]:keyid[0]),
616             (ulong)(mainkeyid? mainkeyid[1]:keyid[1]),
617             pubkey_algo);
618
619   write_status_text (STATUS_NEED_PASSPHRASE, buf);
620 }
621
622
623 /* Return an allocated utf-8 string describing the key PK.  If ESCAPED
624    is true spaces and control characters are percent or plus escaped.
625    MODE describes the use of the key description; use one of the
626    FORMAT_KEYDESC_ macros. */
627 char *
628 gpg_format_keydesc (PKT_public_key *pk, int mode, int escaped)
629 {
630   char *uid;
631   size_t uidlen;
632   const char *algo_name;
633   const char *timestr;
634   char *orig_codeset;
635   char *maink;
636   char *desc;
637   const char *prompt;
638   const char *trailer = "";
639   int is_subkey;
640
641   is_subkey = (pk->main_keyid[0] && pk->main_keyid[1]
642                && pk->keyid[0] != pk->main_keyid[0]
643                && pk->keyid[1] != pk->main_keyid[1]);
644   algo_name = openpgp_pk_algo_name (pk->pubkey_algo);
645   timestr = strtimestamp (pk->timestamp);
646   uid = get_user_id (is_subkey? pk->main_keyid:pk->keyid, &uidlen);
647
648   orig_codeset = i18n_switchto_utf8 ();
649
650   if (is_subkey)
651     maink = xtryasprintf (_(" (main key ID %s)"), keystr (pk->main_keyid));
652   else
653     maink = NULL;
654
655   switch (mode)
656     {
657     case FORMAT_KEYDESC_NORMAL:
658       prompt = _("Please enter the passphrase to unlock the"
659                  " OpenPGP secret key:");
660       break;
661     case FORMAT_KEYDESC_IMPORT:
662       prompt = _("Please enter the passphrase to import the"
663                  " OpenPGP secret key:");
664       break;
665     case FORMAT_KEYDESC_EXPORT:
666       if (is_subkey)
667         prompt = _("Please enter the passphrase to export the"
668                    " OpenPGP secret subkey:");
669       else
670         prompt = _("Please enter the passphrase to export the"
671                    " OpenPGP secret key:");
672       break;
673     case FORMAT_KEYDESC_DELKEY:
674       if (is_subkey)
675         prompt = _("Do you really want to permanently delete the"
676                    " OpenPGP secret subkey key:");
677       else
678         prompt = _("Do you really want to permanently delete the"
679                    " OpenPGP secret key:");
680       trailer = "?";
681       break;
682     default:
683       prompt = "?";
684       break;
685     }
686
687   desc = xtryasprintf (_("%s\n"
688                          "\"%.*s\"\n"
689                          "%u-bit %s key, ID %s,\n"
690                          "created %s%s.\n%s"),
691                        prompt,
692                        (int)uidlen, uid,
693                        nbits_from_pk (pk), algo_name,
694                        keystr (pk->keyid), timestr,
695                        maink?maink:"", trailer);
696   xfree (maink);
697   xfree (uid);
698
699   i18n_switchback (orig_codeset);
700
701   if (escaped)
702     {
703       char *tmp = percent_plus_escape (desc);
704       xfree (desc);
705       desc = tmp;
706     }
707
708   return desc;
709 }