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