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