gpg: Auto-create revocation certificates.
[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 #define KEYIDSTRING _(" (main key ID %s)")
269
270       maink = xmalloc ( strlen (KEYIDSTRING) + keystrlen() + 20 );
271       if( keyid[2] && keyid[3] && keyid[0] != keyid[2]
272           && keyid[1] != keyid[3] )
273         sprintf( maink, KEYIDSTRING, keystr(&keyid[2]) );
274       else
275         *maink = 0;
276
277       uid = get_user_id ( keyid, &uidlen );
278       timestr = strtimestamp (pk->timestamp);
279
280 #undef KEYIDSTRING
281
282 #define PROMPTSTRING _("Please enter the passphrase to unlock the" \
283                        " secret key for the OpenPGP certificate:\n" \
284                        "\"%.*s\"\n" \
285                        "%u-bit %s key, ID %s,\n" \
286                        "created %s%s.\n" )
287
288       atext = xmalloc ( 100 + strlen (PROMPTSTRING)
289                         + uidlen + 15 + strlen(algo_name) + keystrlen()
290                         + strlen (timestr) + strlen (maink) );
291       sprintf (atext, PROMPTSTRING,
292                (int)uidlen, uid,
293                nbits_from_pk (pk), algo_name, keystr(&keyid[0]), timestr,
294                maink  );
295       xfree (uid);
296       xfree (maink);
297
298 #undef PROMPTSTRING
299
300       {
301         size_t dummy;
302         fingerprint_from_pk( pk, fpr, &dummy );
303         have_fpr = 1;
304       }
305
306     }
307   else
308     atext = xstrdup ( _("Enter passphrase\n") );
309
310
311   if (!mode && cacheid)
312     my_cacheid = cacheid;
313   else if (!mode && have_fpr)
314     my_cacheid = bin2hex (fpr, 20, hexfprbuf);
315   else
316     my_cacheid = NULL;
317
318   if (tryagain_text)
319     tryagain_text = _(tryagain_text);
320
321   my_prompt = custom_prompt ? native_to_utf8 (custom_prompt): NULL;
322
323   rc = agent_get_passphrase (my_cacheid, tryagain_text, my_prompt, atext,
324                              repeat, check, &pw);
325
326   xfree (my_prompt);
327   xfree (atext); atext = NULL;
328
329   i18n_switchback (orig_codeset);
330
331
332   if (!rc)
333     ;
334   else if (gpg_err_code (rc) == GPG_ERR_CANCELED
335             || gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
336     {
337       log_info (_("cancelled by user\n") );
338       if (canceled)
339         *canceled = 1;
340     }
341   else
342     {
343       log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
344       /* Due to limitations in the API of the upper layers they
345          consider an error as no passphrase entered.  This works in
346          most cases but not during key creation where this should
347          definitely not happen and let it continue without requiring a
348          passphrase.  Given that now all the upper layers handle a
349          cancel correctly, we simply set the cancel flag now for all
350          errors from the agent.  */
351       if (canceled)
352         *canceled = 1;
353
354       write_status_errcode ("get_passphrase", rc);
355     }
356
357   free_public_key (pk);
358   if (rc)
359     {
360       xfree (pw);
361       return NULL;
362     }
363   return pw;
364 }
365
366
367 /*
368  * Clear the cached passphrase.  If CACHEID is not NULL, it will be
369  * used instead of a cache ID derived from KEYID.
370  */
371 void
372 passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
373 {
374   int rc;
375
376   (void)algo;
377
378   if (!cacheid)
379     {
380       PKT_public_key *pk;
381 #     if MAX_FINGERPRINT_LEN < 20
382 #       error agent needs a 20 byte fingerprint
383 #     endif
384       byte fpr[MAX_FINGERPRINT_LEN];
385       char hexfprbuf[2*20+1];
386       size_t dummy;
387
388       pk = xcalloc (1, sizeof *pk);
389       if ( !keyid || get_pubkey( pk, keyid ) )
390         {
391           log_error ("key not found in passphrase_clear_cache\n");
392           free_public_key (pk);
393           return;
394         }
395       memset (fpr, 0, MAX_FINGERPRINT_LEN );
396       fingerprint_from_pk ( pk, fpr, &dummy );
397       bin2hex (fpr, 20, hexfprbuf);
398       rc = agent_clear_passphrase (hexfprbuf);
399       free_public_key ( pk );
400     }
401   else
402     rc = agent_clear_passphrase (cacheid);
403
404   if (rc)
405     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
406 }
407
408
409 /* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
410    KEYID and PUBKEY_ALGO to prompt the user.  Returns NULL is the user
411    selected to cancel the passphrase entry and if CANCELED is not
412    NULL, sets it to true.
413
414    MODE 0:  Allow cached passphrase
415         1:  Ignore cached passphrase
416         2:  Ditto, but create a new key
417         3:  Allow cached passphrase; use the S2K salt as the cache ID
418         4:  Ditto, but create a new key
419 */
420 DEK *
421 passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
422                        int cipher_algo, STRING2KEY *s2k, int mode,
423                        const char *tryagain_text,
424                        const char *custdesc, const char *custprompt,
425                        int *canceled)
426 {
427   char *pw = NULL;
428   DEK *dek;
429   STRING2KEY help_s2k;
430   int dummy_canceled;
431   char s2k_cacheidbuf[1+16+1], *s2k_cacheid = NULL;
432
433   if (!canceled)
434     canceled = &dummy_canceled;
435   *canceled = 0;
436
437   if ( !s2k )
438     {
439       assert (mode != 3 && mode != 4);
440       /* This is used for the old rfc1991 mode
441        * Note: This must match the code in encode.c with opt.rfc1991 set */
442       s2k = &help_s2k;
443       s2k->mode = 0;
444       s2k->hash_algo = S2K_DIGEST_ALGO;
445     }
446
447   /* Create a new salt or what else to be filled into the s2k for a
448      new key.  */
449   if ((mode == 2 || mode == 4) && (s2k->mode == 1 || s2k->mode == 3))
450     {
451       gcry_randomize (s2k->salt, 8, GCRY_STRONG_RANDOM);
452       if ( s2k->mode == 3 )
453         {
454           /* We delay the encoding until it is really needed.  This is
455              if we are going to dynamically calibrate it, we need to
456              call out to gpg-agent and that should not be done during
457              option processing in main().  */
458           if (!opt.s2k_count)
459             opt.s2k_count = encode_s2k_iterations (0);
460           s2k->count = opt.s2k_count;
461         }
462     }
463
464   /* If we do not have a passphrase available in NEXT_PW and status
465      information are request, we print them now. */
466   if ( !next_pw && is_status_enabled() )
467     {
468       char buf[50];
469
470       if ( keyid )
471         {
472           emit_status_need_passphrase (keyid,
473                                        keyid[2] && keyid[3]? keyid+2:NULL,
474                                        pubkey_algo);
475         }
476       else
477         {
478           snprintf (buf, sizeof buf -1, "%d %d %d",
479                     cipher_algo, s2k->mode, s2k->hash_algo );
480           write_status_text ( STATUS_NEED_PASSPHRASE_SYM, buf );
481         }
482     }
483
484   /* If we do have a keyID, we do not have a passphrase available in
485      NEXT_PW, we are not running in batch mode and we do not want to
486      ignore the passphrase cache (mode!=1), print a prompt with
487      information on that key. */
488   if ( keyid && !opt.batch && !next_pw && mode!=1 )
489     {
490       PKT_public_key *pk = xmalloc_clear( sizeof *pk );
491       char *p;
492
493       p = get_user_id_native(keyid);
494       tty_printf ("\n");
495       tty_printf (_("You need a passphrase to unlock the secret key for\n"
496                     "user: \"%s\"\n"),p);
497       xfree(p);
498
499       if ( !get_pubkey( pk, keyid ) )
500         {
501           const char *s = openpgp_pk_algo_name ( pk->pubkey_algo );
502
503           tty_printf (_("%u-bit %s key, ID %s, created %s"),
504                       nbits_from_pk( pk ), s?s:"?", keystr(keyid),
505                       strtimestamp(pk->timestamp) );
506           if ( keyid[2] && keyid[3]
507                && keyid[0] != keyid[2] && keyid[1] != keyid[3] )
508             {
509               if ( keystrlen () > 10 )
510                 {
511                   tty_printf ("\n");
512                   tty_printf (_("         (subkey on main key ID %s)"),
513                               keystr(&keyid[2]) );
514                 }
515               else
516                 tty_printf ( _(" (main key ID %s)"), keystr(&keyid[2]) );
517             }
518           tty_printf("\n");
519         }
520
521       tty_printf("\n");
522       free_public_key (pk);
523     }
524
525   if ( next_pw )
526     {
527       /* Simply return the passphrase we already have in NEXT_PW. */
528       pw = next_pw;
529       next_pw = NULL;
530     }
531   else if ( have_static_passphrase () )
532     {
533       /* Return the passphrase we have stored in FD_PASSWD. */
534       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
535       strcpy ( pw, fd_passwd );
536     }
537   else
538     {
539       if ((mode == 3 || mode == 4) && (s2k->mode == 1 || s2k->mode == 3))
540         {
541           memset (s2k_cacheidbuf, 0, sizeof s2k_cacheidbuf);
542           *s2k_cacheidbuf = 'S';
543           bin2hex (s2k->salt, 8, s2k_cacheidbuf + 1);
544           s2k_cacheid = s2k_cacheidbuf;
545         }
546
547       /* Divert to the gpg-agent. */
548       pw = passphrase_get (keyid, mode == 2, s2k_cacheid,
549                            (mode == 2 || mode == 4)? opt.passphrase_repeat : 0,
550                            tryagain_text, custdesc, custprompt, canceled);
551       if (*canceled)
552         {
553           xfree (pw);
554           write_status( STATUS_MISSING_PASSPHRASE );
555           return NULL;
556         }
557     }
558
559   if ( !pw || !*pw )
560     write_status( STATUS_MISSING_PASSPHRASE );
561
562   /* Hash the passphrase and store it in a newly allocated DEK object.
563      Keep a copy of the passphrase in LAST_PW for use by
564      get_last_passphrase(). */
565   dek = xmalloc_secure_clear ( sizeof *dek );
566   dek->algo = cipher_algo;
567   if ( (!pw || !*pw) && (mode == 2 || mode == 4))
568     dek->keylen = 0;
569   else
570     {
571       gpg_error_t err;
572
573       dek->keylen = openpgp_cipher_get_algo_keylen (dek->algo);
574       if (!(dek->keylen > 0 && dek->keylen <= DIM(dek->key)))
575         BUG ();
576       err = gcry_kdf_derive (pw, strlen (pw),
577                              s2k->mode == 3? GCRY_KDF_ITERSALTED_S2K :
578                              s2k->mode == 1? GCRY_KDF_SALTED_S2K :
579                              /* */           GCRY_KDF_SIMPLE_S2K,
580                              s2k->hash_algo, s2k->salt, 8,
581                              S2K_DECODE_COUNT(s2k->count),
582                              dek->keylen, dek->key);
583       if (err)
584         {
585           log_error ("gcry_kdf_derive failed: %s", gpg_strerror (err));
586           xfree (pw);
587           xfree (dek);
588           write_status( STATUS_MISSING_PASSPHRASE );
589           return NULL;
590         }
591     }
592   if (s2k_cacheid)
593     memcpy (dek->s2k_cacheid, s2k_cacheid, sizeof dek->s2k_cacheid);
594   xfree(last_pw);
595   last_pw = pw;
596   return dek;
597 }
598
599
600 DEK *
601 passphrase_to_dek (u32 *keyid, int pubkey_algo,
602                    int cipher_algo, STRING2KEY *s2k, int mode,
603                    const char *tryagain_text, int *canceled)
604 {
605   return passphrase_to_dek_ext (keyid, pubkey_algo, cipher_algo,
606                                 s2k, mode, tryagain_text, NULL, NULL,
607                                 canceled);
608 }
609
610
611 /* Emit the USERID_HINT and the NEED_PASSPHRASE status messages.
612    MAINKEYID may be NULL. */
613 void
614 emit_status_need_passphrase (u32 *keyid, u32 *mainkeyid, int pubkey_algo)
615 {
616   char buf[50];
617   char *us;
618
619   us = get_long_user_id_string (keyid);
620   write_status_text (STATUS_USERID_HINT, us);
621   xfree (us);
622
623   snprintf (buf, sizeof buf -1, "%08lX%08lX %08lX%08lX %d 0",
624             (ulong)keyid[0],
625             (ulong)keyid[1],
626             (ulong)(mainkeyid? mainkeyid[0]:keyid[0]),
627             (ulong)(mainkeyid? mainkeyid[1]:keyid[1]),
628             pubkey_algo);
629
630   write_status_text (STATUS_NEED_PASSPHRASE, buf);
631 }
632
633
634 /* Return an allocated utf-8 string describing the key PK.  If ESCAPED
635    is true spaces and control characters are percent or plus escaped.
636    MODE describes the use of the key description; use one of the
637    FORMAT_KEYDESC_ macros. */
638 char *
639 gpg_format_keydesc (PKT_public_key *pk, int mode, int escaped)
640 {
641   char *uid;
642   size_t uidlen;
643   const char *algo_name;
644   const char *timestr;
645   char *orig_codeset;
646   char *maink;
647   char *desc;
648   const char *prompt;
649   const char *trailer = "";
650   int is_subkey;
651
652   is_subkey = (pk->main_keyid[0] && pk->main_keyid[1]
653                && pk->keyid[0] != pk->main_keyid[0]
654                && pk->keyid[1] != pk->main_keyid[1]);
655   algo_name = openpgp_pk_algo_name (pk->pubkey_algo);
656   timestr = strtimestamp (pk->timestamp);
657   uid = get_user_id (is_subkey? pk->main_keyid:pk->keyid, &uidlen);
658
659   orig_codeset = i18n_switchto_utf8 ();
660
661   if (is_subkey)
662     maink = xtryasprintf (_(" (main key ID %s)"), keystr (pk->main_keyid));
663   else
664     maink = NULL;
665
666   switch (mode)
667     {
668     case FORMAT_KEYDESC_NORMAL:
669       prompt = _("Please enter the passphrase to unlock the"
670                  " OpenPGP secret key:");
671       break;
672     case FORMAT_KEYDESC_IMPORT:
673       prompt = _("Please enter the passphrase to import the"
674                  " OpenPGP secret key:");
675       break;
676     case FORMAT_KEYDESC_EXPORT:
677       if (is_subkey)
678         prompt = _("Please enter the passphrase to export the"
679                    " OpenPGP secret subkey:");
680       else
681         prompt = _("Please enter the passphrase to export the"
682                    " OpenPGP secret key:");
683       break;
684     case FORMAT_KEYDESC_DELKEY:
685       if (is_subkey)
686         prompt = _("Do you really want to permanently delete the"
687                    " OpenPGP secret subkey key:");
688       else
689         prompt = _("Do you really want to permanently delete the"
690                    " OpenPGP secret key:");
691       trailer = "?";
692       break;
693     default:
694       prompt = "?";
695       break;
696     }
697
698   desc = xtryasprintf (_("%s\n"
699                          "\"%.*s\"\n"
700                          "%u-bit %s key, ID %s,\n"
701                          "created %s%s.\n%s"),
702                        prompt,
703                        (int)uidlen, uid,
704                        nbits_from_pk (pk), algo_name,
705                        keystr (pk->keyid), timestr,
706                        maink?maink:"", trailer);
707   xfree (maink);
708   xfree (uid);
709
710   i18n_switchback (orig_codeset);
711
712   if (escaped)
713     {
714       char *tmp = percent_plus_escape (desc);
715       xfree (desc);
716       desc = tmp;
717     }
718
719   return desc;
720 }