2007-04-26 Marcus Brinkmann <marcus@g10code.de>
[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     {
381       log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
382       /* Due to limitations in the API of the upper layers they
383          consider an error as no passphrase entered.  This works in
384          most cases but not during key creation where this should
385          definitely not happen and let it continue without requiring a
386          passphrase.  Given that now all the upper layers handle a
387          cancel correctly, we simply set the cancel flag now for all
388          errors from the agent.  */ 
389       if (canceled)
390         *canceled = 1;
391     }
392       
393 #ifdef ENABLE_NLS
394   if (orig_codeset)
395     {
396       bind_textdomain_codeset (PACKAGE, orig_codeset);
397       xfree (orig_codeset);
398     }
399 #endif
400   if (pk)
401     free_public_key( pk );
402   if (rc)
403     {
404       xfree (pw);
405       return NULL;
406     }
407   return pw;
408 }
409
410
411 /*
412  * Clear the cached passphrase.  If CACHEID is not NULL, it will be
413  * used instead of a cache ID derived from KEYID.
414  */
415 void
416 passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
417 {
418   int rc;
419     
420   if (!cacheid)
421     {
422       PKT_public_key *pk;
423 #     if MAX_FINGERPRINT_LEN < 20
424 #       error agent needs a 20 byte fingerprint
425 #     endif
426       byte fpr[MAX_FINGERPRINT_LEN];
427       char hexfprbuf[2*20+1];
428       size_t dummy;
429       
430       pk = xcalloc (1, sizeof *pk);
431       if ( !keyid || get_pubkey( pk, keyid ) )
432         {
433           log_error ("key not found in passphrase_clear_cache\n");
434           free_public_key (pk);
435           return;
436         }
437       memset (fpr, 0, MAX_FINGERPRINT_LEN );
438       fingerprint_from_pk ( pk, fpr, &dummy );
439       bin2hex (fpr, 20, hexfprbuf);
440       rc = agent_clear_passphrase (hexfprbuf);
441       free_public_key ( pk );
442     }
443   else
444     rc = agent_clear_passphrase (cacheid);
445
446   if (rc)
447     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
448 }
449
450
451 /****************
452  * Ask for a passphrase and return that string.
453  */
454 char *
455 ask_passphrase (const char *description,
456                 const char *tryagain_text,
457                 const char *promptid,
458                 const char *prompt,
459                 const char *cacheid, int *canceled)
460 {
461   char *pw = NULL;
462   
463   if (canceled)
464     *canceled = 0;
465
466   if (!opt.batch && description)
467     {
468       if (strchr (description, '%'))
469         {
470           char *tmp = unescape_percent_string (description);
471           tty_printf ("\n%s\n", tmp);
472           xfree (tmp);
473         }
474       else
475         tty_printf ("\n%s\n",description);
476     }
477                
478   if (have_static_passphrase ()) 
479     {
480       pw = xmalloc_secure (strlen(fd_passwd)+1);
481       strcpy (pw, fd_passwd);
482     }
483   else
484     pw = passphrase_get (NULL, 0, cacheid,
485                          tryagain_text, description, prompt,
486                          canceled );
487
488   if (!pw || !*pw)
489     write_status( STATUS_MISSING_PASSPHRASE );
490
491   return pw;
492 }
493
494
495 /* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
496    KEYID and PUBKEY_ALGO to prompt the user.  Returns NULL is the user
497    selected to cancel the passphrase entry and if CANCELED is not
498    NULL, sets it to true.
499
500    MODE 0:  Allow cached passphrase
501         1:  Ignore cached passphrase 
502         2:  Ditto, but change the text to "repeat entry"
503 */
504 DEK *
505 passphrase_to_dek (u32 *keyid, int pubkey_algo,
506                    int cipher_algo, STRING2KEY *s2k, int mode,
507                    const char *tryagain_text, int *canceled)
508 {
509   char *pw = NULL;
510   DEK *dek;
511   STRING2KEY help_s2k;
512   int dummy_canceled;
513
514   if (!canceled)
515     canceled = &dummy_canceled;
516   *canceled = 0;
517   
518   if ( !s2k )
519     {
520       /* This is used for the old rfc1991 mode 
521        * Note: This must match the code in encode.c with opt.rfc1991 set */
522       s2k = &help_s2k;
523       s2k->mode = 0;
524       s2k->hash_algo = S2K_DIGEST_ALGO;
525     }
526
527   /* If we do not have a passphrase available in NEXT_PW and status
528      information are request, we print them now. */
529   if ( !next_pw && is_status_enabled() ) 
530     {
531       char buf[50];
532       
533       if ( keyid )
534         {
535           u32 used_kid[2];
536           char *us;
537           
538           if ( keyid[2] && keyid[3] ) 
539             {
540               used_kid[0] = keyid[2];
541               used_kid[1] = keyid[3];
542             }
543           else
544             {
545               used_kid[0] = keyid[0];
546               used_kid[1] = keyid[1];
547             }
548           
549           us = get_long_user_id_string ( keyid );
550           write_status_text ( STATUS_USERID_HINT, us );
551           xfree(us);
552           
553           snprintf (buf, sizeof buf -1, "%08lX%08lX %08lX%08lX %d 0",
554                     (ulong)keyid[0], (ulong)keyid[1],
555                     (ulong)used_kid[0], (ulong)used_kid[1],
556                     pubkey_algo );
557           
558           write_status_text ( STATUS_NEED_PASSPHRASE, buf );
559         }
560       else
561         {
562           snprintf (buf, sizeof buf -1, "%d %d %d",
563                     cipher_algo, s2k->mode, s2k->hash_algo );
564           write_status_text ( STATUS_NEED_PASSPHRASE_SYM, buf );
565         }
566     }
567
568   /* If we do have a keyID, we do not have a passphrase available in
569      NEXT_PW, we are not running in batch mode and we do not want to
570      ignore the passphrase cache (mode!=1), print a prompt with
571      information on that key. */
572   if ( keyid && !opt.batch && !next_pw && mode!=1 )
573     {
574       PKT_public_key *pk = xmalloc_clear( sizeof *pk );
575       char *p;
576       
577       p = get_user_id_native(keyid);
578       tty_printf ("\n");
579       tty_printf (_("You need a passphrase to unlock the secret key for\n"
580                     "user: \"%s\"\n"),p);
581       xfree(p);
582
583       if ( !get_pubkey( pk, keyid ) )
584         {
585           const char *s = gcry_pk_algo_name ( pk->pubkey_algo );
586           
587           tty_printf (_("%u-bit %s key, ID %s, created %s"),
588                       nbits_from_pk( pk ), s?s:"?", keystr(keyid),
589                       strtimestamp(pk->timestamp) );
590           if ( keyid[2] && keyid[3]
591                && keyid[0] != keyid[2] && keyid[1] != keyid[3] )
592             {
593               if ( keystrlen () > 10 )
594                 {
595                   tty_printf ("\n");
596                   tty_printf (_("         (subkey on main key ID %s)"),
597                               keystr(&keyid[2]) );
598                 }
599               else
600                 tty_printf ( _(" (main key ID %s)"), keystr(&keyid[2]) );
601             }
602           tty_printf("\n");
603         }
604
605       tty_printf("\n");
606       if (pk)
607         free_public_key( pk );
608     }
609
610   if ( next_pw ) 
611     {
612       /* Simply return the passphrase we already have in NEXT_PW. */
613       pw = next_pw;
614       next_pw = NULL;
615     }
616   else if ( have_static_passphrase () ) 
617     {
618       /* Return the passphrase we have stored in FD_PASSWD. */
619       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
620       strcpy ( pw, fd_passwd );
621     }
622   else 
623     {
624       /* Divert to the gpg-agent. */
625       pw = passphrase_get ( keyid, mode == 2? 1: 0, NULL,
626                             tryagain_text, NULL, NULL, canceled );
627       if (*canceled)
628         {
629           xfree (pw);
630           write_status( STATUS_MISSING_PASSPHRASE );
631           return NULL;
632         }
633       if (!pw)
634         pw = xstrdup ("");
635       if ( *pw && mode == 2 )
636         {
637           int i;
638           for(i=0;i<opt.passwd_repeat;i++)
639             {
640               char *pw2 = passphrase_get ( keyid, 2, NULL, NULL, NULL,
641                                            NULL, canceled );
642               if (*canceled)
643                 {
644                   xfree (pw);
645                   xfree (pw2);
646                   write_status( STATUS_MISSING_PASSPHRASE );
647                   return NULL;
648                 }
649               if (!pw2)
650                 pw2 = xstrdup ("");
651               if ( strcmp(pw, pw2) )
652                 {
653                   xfree(pw2);
654                   xfree(pw);
655                   return NULL;
656                 }
657               xfree(pw2);
658             }
659         }
660     }
661     
662   if ( !pw || !*pw )
663     write_status( STATUS_MISSING_PASSPHRASE );
664
665   /* Hash the passphrase and store it in a newly allocated DEK object.
666      Keep a copy of the passphrase in LAST_PW for use by
667      get_last_passphrase(). */
668   dek = xmalloc_secure_clear ( sizeof *dek );
669   dek->algo = cipher_algo;
670   if ( !*pw && mode == 2 )
671     dek->keylen = 0;
672   else
673     hash_passphrase( dek, pw, s2k, mode==2 );
674   xfree(last_pw);
675   last_pw = pw;
676   return dek;
677 }