Pth tweaks and improved estream.c
[gnupg.git] / g10 / passphrase.c
1 /* passphrase.c -  Get a passphrase
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2005, 2006 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   char *orig_codeset = NULL;
263   char *my_prompt;
264   char hexfprbuf[20*2+1];
265   const char *my_cacheid;
266
267   if (canceled)
268     *canceled = 0;
269
270 #if MAX_FINGERPRINT_LEN < 20
271 #error agent needs a 20 byte fingerprint
272 #endif
273
274   memset (fpr, 0, MAX_FINGERPRINT_LEN );
275   if( keyid && get_pubkey( pk, keyid ) )
276     {
277       if (pk)
278         free_public_key( pk );      
279       pk = NULL; /* oops: no key for some reason */
280     }
281   
282 #ifdef ENABLE_NLS
283   /* The Assuan agent protocol requires us to transmit utf-8 strings */
284   orig_codeset = bind_textdomain_codeset (PACKAGE, NULL);
285 #ifdef HAVE_LANGINFO_CODESET
286   if (!orig_codeset)
287     orig_codeset = nl_langinfo (CODESET);
288 #endif
289   if (orig_codeset)
290     { /* We only switch when we are able to restore the codeset later. */
291       orig_codeset = xstrdup (orig_codeset);
292       if (!bind_textdomain_codeset (PACKAGE, "utf-8"))
293         orig_codeset = NULL; 
294     }
295 #endif
296
297   if (custom_description)
298     atext = native_to_utf8 (custom_description);
299   else if ( !mode && pk && keyid )
300     { 
301       char *uid;
302       size_t uidlen;
303       const char *algo_name = gcry_pk_algo_name ( pk->pubkey_algo );
304       const char *timestr;
305       char *maink;
306       
307       if ( !algo_name )
308         algo_name = "?";
309
310 #define KEYIDSTRING _(" (main key ID %s)")
311
312       maink = xmalloc ( strlen (KEYIDSTRING) + keystrlen() + 20 );
313       if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
314           && keyid[1] != keyid[3] )
315         sprintf( maink, KEYIDSTRING, keystr(&keyid[2]) );
316       else
317         *maink = 0;
318       
319       uid = get_user_id ( keyid, &uidlen ); 
320       timestr = strtimestamp (pk->timestamp);
321
322 #undef KEYIDSTRING
323
324 #define PROMPTSTRING _("You need a passphrase to unlock the secret" \
325                        " key for user:\n" \
326                        "\"%.*s\"\n" \
327                        "%u-bit %s key, ID %s, created %s%s\n" )
328
329       atext = xmalloc ( 100 + strlen (PROMPTSTRING)  
330                         + uidlen + 15 + strlen(algo_name) + keystrlen()
331                         + strlen (timestr) + strlen (maink) );
332       sprintf (atext, PROMPTSTRING,
333                (int)uidlen, uid,
334                nbits_from_pk (pk), algo_name, keystr(&keyid[0]), timestr,
335                maink  );
336       xfree (uid);
337       xfree (maink);
338
339 #undef PROMPTSTRING
340
341       { 
342         size_t dummy;
343         fingerprint_from_pk( pk, fpr, &dummy );
344         have_fpr = 1;
345       }
346       
347     }
348   else if (mode == 2 ) 
349     atext = xstrdup ( _("Repeat passphrase\n") );
350   else
351     atext = xstrdup ( _("Enter passphrase\n") );
352                 
353
354   if (!mode && cacheid)
355     my_cacheid = cacheid;
356   else if (!mode && have_fpr)
357     my_cacheid = bin2hex (fpr, 20, hexfprbuf);
358   else
359     my_cacheid = NULL;
360
361   if (tryagain_text)
362     tryagain_text = _(tryagain_text);
363
364   my_prompt = custom_prompt ? native_to_utf8 (custom_prompt): NULL;
365
366   rc = agent_get_passphrase (my_cacheid, tryagain_text, my_prompt, atext, &pw);
367   
368   xfree (my_prompt);
369   xfree (atext); atext = NULL;
370
371   if (!rc)
372     ;
373   else if ( gpg_err_code (rc) == GPG_ERR_CANCELED )
374     {
375       log_info (_("cancelled by user\n") );
376       if (canceled)
377         *canceled = 1;
378     }
379   else 
380     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
381       
382 #ifdef ENABLE_NLS
383   if (orig_codeset)
384     {
385       bind_textdomain_codeset (PACKAGE, orig_codeset);
386       xfree (orig_codeset);
387     }
388 #endif
389   if (pk)
390     free_public_key( pk );
391   if (rc)
392     {
393       xfree (pw);
394       return NULL;
395     }
396   return pw;
397 }
398
399
400 /*
401  * Clear the cached passphrase.  If CACHEID is not NULL, it will be
402  * used instead of a cache ID derived from KEYID.
403  */
404 void
405 passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
406 {
407   int rc;
408     
409   if (!cacheid)
410     {
411       PKT_public_key *pk;
412 #     if MAX_FINGERPRINT_LEN < 20
413 #       error agent needs a 20 byte fingerprint
414 #     endif
415       byte fpr[MAX_FINGERPRINT_LEN];
416       char hexfprbuf[2*20+1];
417       size_t dummy;
418       
419       pk = xcalloc (1, sizeof *pk);
420       if ( !keyid || get_pubkey( pk, keyid ) )
421         {
422           log_error ("key not found in passphrase_clear_cache\n");
423           free_public_key (pk);
424           return;
425         }
426       memset (fpr, 0, MAX_FINGERPRINT_LEN );
427       fingerprint_from_pk ( pk, fpr, &dummy );
428       bin2hex (fpr, 20, hexfprbuf);
429       rc = agent_clear_passphrase (hexfprbuf);
430       free_public_key ( pk );
431     }
432   else
433     rc = agent_clear_passphrase (cacheid);
434
435   if (rc)
436     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
437 }
438
439
440 /****************
441  * Ask for a passphrase and return that string.
442  */
443 char *
444 ask_passphrase (const char *description,
445                 const char *tryagain_text,
446                 const char *promptid,
447                 const char *prompt,
448                 const char *cacheid, int *canceled)
449 {
450   char *pw = NULL;
451   
452   if (canceled)
453     *canceled = 0;
454
455   if (!opt.batch && description)
456     {
457       if (strchr (description, '%'))
458         {
459           char *tmp = unescape_percent_string (description);
460           tty_printf ("\n%s\n", tmp);
461           xfree (tmp);
462         }
463       else
464         tty_printf ("\n%s\n",description);
465     }
466                
467   if (have_static_passphrase ()) 
468     {
469       pw = xmalloc_secure (strlen(fd_passwd)+1);
470       strcpy (pw, fd_passwd);
471     }
472   else
473     pw = passphrase_get (NULL, 0, cacheid,
474                          tryagain_text, description, prompt,
475                          canceled );
476
477   if (!pw || !*pw)
478     write_status( STATUS_MISSING_PASSPHRASE );
479
480   return pw;
481 }
482
483
484 /* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
485  * KEYID and PUBKEY_ALGO to prompt the user.
486
487    MODE 0:  Allow cached passphrase
488         1:  Ignore cached passphrase 
489         2:  Ditto, but change the text to "repeat entry"
490 */
491 DEK *
492 passphrase_to_dek (u32 *keyid, int pubkey_algo,
493                    int cipher_algo, STRING2KEY *s2k, int mode,
494                    const char *tryagain_text, int *canceled)
495 {
496   char *pw = NULL;
497   DEK *dek;
498   STRING2KEY help_s2k;
499   
500   if (canceled)
501     *canceled = 0;
502   
503   if ( !s2k )
504     {
505       /* This is used for the old rfc1991 mode 
506        * Note: This must match the code in encode.c with opt.rfc1991 set */
507       s2k = &help_s2k;
508       s2k->mode = 0;
509       s2k->hash_algo = S2K_DIGEST_ALGO;
510     }
511
512   /* If we do not have a passphrase available in NEXT_PW and status
513      information are request, we print them now. */
514   if ( !next_pw && is_status_enabled() ) 
515     {
516       char buf[50];
517       
518       if ( keyid )
519         {
520           u32 used_kid[2];
521           char *us;
522           
523           if ( keyid[2] && keyid[3] ) 
524             {
525               used_kid[0] = keyid[2];
526               used_kid[1] = keyid[3];
527             }
528           else
529             {
530               used_kid[0] = keyid[0];
531               used_kid[1] = keyid[1];
532             }
533           
534           us = get_long_user_id_string ( keyid );
535           write_status_text ( STATUS_USERID_HINT, us );
536           xfree(us);
537           
538           snprintf (buf, sizeof buf -1, "%08lX%08lX %08lX%08lX %d 0",
539                     (ulong)keyid[0], (ulong)keyid[1],
540                     (ulong)used_kid[0], (ulong)used_kid[1],
541                     pubkey_algo );
542           
543           write_status_text ( STATUS_NEED_PASSPHRASE, buf );
544         }
545       else
546         {
547           snprintf (buf, sizeof buf -1, "%d %d %d",
548                     cipher_algo, s2k->mode, s2k->hash_algo );
549           write_status_text ( STATUS_NEED_PASSPHRASE_SYM, buf );
550         }
551     }
552
553   /* If we do have a keyID, we do not have a passphrase available in
554      NEXT_PW, we are not running in batch mode and we do not want to
555      ignore the passphrase cache (mode!=1), print a prompt with
556      information on that key. */
557   if ( keyid && !opt.batch && !next_pw && mode!=1 )
558     {
559       PKT_public_key *pk = xmalloc_clear( sizeof *pk );
560       char *p;
561       
562       p = get_user_id_native(keyid);
563       tty_printf ("\n");
564       tty_printf (_("You need a passphrase to unlock the secret key for\n"
565                     "user: \"%s\"\n"),p);
566       xfree(p);
567
568       if ( !get_pubkey( pk, keyid ) )
569         {
570           const char *s = gcry_pk_algo_name ( pk->pubkey_algo );
571           
572           tty_printf (_("%u-bit %s key, ID %s, created %s"),
573                       nbits_from_pk( pk ), s?s:"?", keystr(keyid),
574                       strtimestamp(pk->timestamp) );
575           if ( keyid[2] && keyid[3]
576                && keyid[0] != keyid[2] && keyid[1] != keyid[3] )
577             {
578               if ( keystrlen () > 10 )
579                 {
580                   tty_printf ("\n");
581                   tty_printf (_("         (subkey on main key ID %s)"),
582                               keystr(&keyid[2]) );
583                 }
584               else
585                 tty_printf ( _(" (main key ID %s)"), keystr(&keyid[2]) );
586             }
587           tty_printf("\n");
588         }
589
590       tty_printf("\n");
591       if (pk)
592         free_public_key( pk );
593     }
594
595   if ( next_pw ) 
596     {
597       /* Simply return the passphrase we already have in NEXT_PW. */
598       pw = next_pw;
599       next_pw = NULL;
600     }
601   else if ( have_static_passphrase () ) 
602     {
603       /* Return the passphrase we have store in FD_PASSWD. */
604       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
605       strcpy ( pw, fd_passwd );
606     }
607   else 
608     {
609       /* Divert to the gpg-agent. */
610       pw = passphrase_get ( keyid, mode == 2? 1: 0, NULL,
611                             tryagain_text, NULL, NULL, canceled );
612       if (!pw)
613         pw = xstrdup ("");
614       if ( *pw && mode == 2 )
615         {
616           char *pw2 = passphrase_get ( keyid, 2, NULL, NULL, NULL,
617                                        NULL, canceled );
618           if (!pw2)
619             pw2 = xstrdup ("");
620           if ( strcmp(pw, pw2) )
621             {
622               xfree(pw2);
623               xfree(pw);
624               return NULL;
625             }
626           xfree(pw2);
627         }
628     }
629     
630   if ( !pw || !*pw )
631     write_status( STATUS_MISSING_PASSPHRASE );
632
633   /* Hash the passphrase and store it in a newly allocated DEK object.
634      Keep a copy of the passphrase in LAST_PW for use by
635      get_last_passphrase(). */
636   dek = xmalloc_secure_clear ( sizeof *dek );
637   dek->algo = cipher_algo;
638   if ( !*pw && mode == 2 )
639     dek->keylen = 0;
640   else
641     hash_passphrase( dek, pw, s2k, mode==2 );
642   xfree(last_pw);
643   last_pw = pw;
644   return dek;
645 }