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