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