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