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