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