Fixed agent access for gpg.
[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 = 96; /* 65536 iterations. */
92             }
93
94           if ( s2k->mode == 3 )
95             {
96               count = (16ul + (s2k->count & 15)) << ((s2k->count >> 4) + 6);
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 0;
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   /* Not used but we have to do a dummy read, so that it won't end up
197      at the begin of the message if the quite usual trick to prepend
198      the passphtrase to the message is used. */
199   char buf[1];
200   
201   while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
202     ;
203   *buf = 0;
204   return; 
205 }
206
207
208 /*
209  * Ask the GPG Agent for the passphrase.
210  * Mode 0:  Allow cached passphrase
211  *      1:  No cached passphrase FIXME: Not really implemented
212  *      2:  Ditto, but change the text to "repeat entry"
213  *
214  * Note that TRYAGAIN_TEXT must not be translated.  If CANCELED is not
215  * NULL, the function does set it to 1 if the user canceled the
216  * operation.  If CACHEID is not NULL, it will be used as the cacheID
217  * for the gpg-agent; if is NULL and a key fingerprint can be
218  * computed, this will be used as the cacheid.
219  */
220 static char *
221 passphrase_get ( u32 *keyid, int mode, const char *cacheid,
222                  const char *tryagain_text,
223                  const char *custom_description,
224                  const char *custom_prompt, int *canceled)
225 {
226   int rc;
227   char *atext = NULL;
228   char *pw = NULL;
229   PKT_public_key *pk = xmalloc_clear( sizeof *pk );
230   byte fpr[MAX_FINGERPRINT_LEN];
231   int have_fpr = 0;
232   char *orig_codeset = NULL;
233   char *my_prompt;
234   char hexfprbuf[20*2+1];
235   const char *my_cacheid;
236
237   if (canceled)
238     *canceled = 0;
239
240 #if MAX_FINGERPRINT_LEN < 20
241 #error agent needs a 20 byte fingerprint
242 #endif
243
244   memset (fpr, 0, MAX_FINGERPRINT_LEN );
245   if( keyid && get_pubkey( pk, keyid ) )
246     {
247       if (pk)
248         free_public_key( pk );      
249       pk = NULL; /* oops: no key for some reason */
250     }
251   
252 #ifdef ENABLE_NLS
253   /* The Assuan agent protocol requires us to transmit utf-8 strings */
254   orig_codeset = bind_textdomain_codeset (PACKAGE, NULL);
255 #ifdef HAVE_LANGINFO_CODESET
256   if (!orig_codeset)
257     orig_codeset = nl_langinfo (CODESET);
258 #endif
259   if (orig_codeset)
260     { /* We only switch when we are able to restore the codeset later. */
261       orig_codeset = xstrdup (orig_codeset);
262       if (!bind_textdomain_codeset (PACKAGE, "utf-8"))
263         orig_codeset = NULL; 
264     }
265 #endif
266
267   if (custom_description)
268     atext = native_to_utf8 (custom_description);
269   else if ( !mode && pk && keyid )
270     { 
271       char *uid;
272       size_t uidlen;
273       const char *algo_name = gcry_pk_algo_name ( pk->pubkey_algo );
274       const char *timestr;
275       char *maink;
276       
277       if ( !algo_name )
278         algo_name = "?";
279
280 #define KEYIDSTRING _(" (main key ID %s)")
281
282       maink = xmalloc ( strlen (KEYIDSTRING) + keystrlen() + 20 );
283       if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
284           && keyid[1] != keyid[3] )
285         sprintf( maink, KEYIDSTRING, keystr(&keyid[2]) );
286       else
287         *maink = 0;
288       
289       uid = get_user_id ( keyid, &uidlen ); 
290       timestr = strtimestamp (pk->timestamp);
291
292 #undef KEYIDSTRING
293
294 #define PROMPTSTRING _("You need a passphrase to unlock the secret" \
295                        " key for user:\n" \
296                        "\"%.*s\"\n" \
297                        "%u-bit %s key, ID %s, created %s%s\n" )
298
299       atext = xmalloc ( 100 + strlen (PROMPTSTRING)  
300                         + uidlen + 15 + strlen(algo_name) + keystrlen()
301                         + strlen (timestr) + strlen (maink) );
302       sprintf (atext, PROMPTSTRING,
303                (int)uidlen, uid,
304                nbits_from_pk (pk), algo_name, keystr(&keyid[0]), timestr,
305                maink  );
306       xfree (uid);
307       xfree (maink);
308
309 #undef PROMPTSTRING
310
311       { 
312         size_t dummy;
313         fingerprint_from_pk( pk, fpr, &dummy );
314         have_fpr = 1;
315       }
316       
317     }
318   else if (mode == 2 ) 
319     atext = xstrdup ( _("Repeat passphrase\n") );
320   else
321     atext = xstrdup ( _("Enter passphrase\n") );
322                 
323
324   if (!mode && cacheid)
325     my_cacheid = cacheid;
326   else if (!mode && have_fpr)
327     my_cacheid = bin2hex (fpr, 20, hexfprbuf);
328   else
329     my_cacheid = NULL;
330
331   if (tryagain_text)
332     tryagain_text = _(tryagain_text);
333
334   my_prompt = custom_prompt ? native_to_utf8 (custom_prompt): NULL;
335
336   rc = agent_get_passphrase (my_cacheid, tryagain_text, my_prompt, atext, &pw);
337   
338   xfree (my_prompt);
339   xfree (atext); atext = NULL;
340
341   if (!rc)
342     ;
343   else if ( gpg_err_code (rc) == GPG_ERR_CANCELED )
344     {
345       log_info (_("cancelled by user\n") );
346       if (canceled)
347         *canceled = 1;
348     }
349   else 
350     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
351       
352 #ifdef ENABLE_NLS
353   if (orig_codeset)
354     {
355       bind_textdomain_codeset (PACKAGE, orig_codeset);
356       xfree (orig_codeset);
357     }
358 #endif
359   if (pk)
360     free_public_key( pk );
361   if (rc)
362     {
363       xfree (pw);
364       return NULL;
365     }
366   return pw;
367 }
368
369
370 /*
371  * Clear the cached passphrase.  If CACHEID is not NULL, it will be
372  * used instead of a cache ID derived from KEYID.
373  */
374 void
375 passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
376 {
377   int rc;
378     
379   if (!cacheid)
380     {
381       PKT_public_key *pk;
382 #     if MAX_FINGERPRINT_LEN < 20
383 #       error agent needs a 20 byte fingerprint
384 #     endif
385       byte fpr[MAX_FINGERPRINT_LEN];
386       char hexfprbuf[2*20+1];
387       size_t dummy;
388       
389       pk = xcalloc (1, sizeof *pk);
390       if ( !keyid || get_pubkey( pk, keyid ) )
391         {
392           log_error ("key not found in passphrase_clear_cache\n");
393           free_public_key (pk);
394           return;
395         }
396       memset (fpr, 0, MAX_FINGERPRINT_LEN );
397       fingerprint_from_pk ( pk, fpr, &dummy );
398       bin2hex (fpr, 20, hexfprbuf);
399       rc = agent_clear_passphrase (hexfprbuf);
400       free_public_key ( pk );
401     }
402   else
403     rc = agent_clear_passphrase (cacheid);
404
405   if (rc)
406     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
407 }
408
409
410 /****************
411  * Ask for a passphrase and return that string.
412  */
413 char *
414 ask_passphrase (const char *description,
415                 const char *tryagain_text,
416                 const char *promptid,
417                 const char *prompt,
418                 const char *cacheid, int *canceled)
419 {
420   char *pw = NULL;
421   
422   if (canceled)
423     *canceled = 0;
424
425   if (!opt.batch && description)
426     {
427       if (strchr (description, '%'))
428         {
429           char *tmp = unescape_percent_string (description);
430           tty_printf ("\n%s\n", tmp);
431           xfree (tmp);
432         }
433       else
434         tty_printf ("\n%s\n",description);
435     }
436                
437   pw = passphrase_get (NULL, 0, cacheid,
438                        tryagain_text, description, prompt,
439                        canceled );
440
441   if (!pw || !*pw)
442     write_status( STATUS_MISSING_PASSPHRASE );
443
444   return pw;
445 }
446
447
448 /* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
449  * KEYID and PUBKEY_ALGO to prompt the user.
450
451    MODE 0:  Allow cached passphrase
452         1:  Ignore cached passphrase 
453         2:  Ditto, but change the text to "repeat entry"
454 */
455 DEK *
456 passphrase_to_dek (u32 *keyid, int pubkey_algo,
457                    int cipher_algo, STRING2KEY *s2k, int mode,
458                    const char *tryagain_text, int *canceled)
459 {
460   char *pw = NULL;
461   DEK *dek;
462   STRING2KEY help_s2k;
463   
464   if (canceled)
465     *canceled = 0;
466   
467   if ( !s2k )
468     {
469       /* This is used for the old rfc1991 mode 
470        * Note: This must match the code in encode.c with opt.rfc1991 set */
471       s2k = &help_s2k;
472       s2k->mode = 0;
473       s2k->hash_algo = S2K_DIGEST_ALGO;
474     }
475
476   /* If we do not have a passphrase available in NEXT_PW and status
477      information are request, we print them now. */
478   if ( !next_pw && is_status_enabled() ) 
479     {
480       char buf[50];
481       
482       if ( keyid )
483         {
484           u32 used_kid[2];
485           char *us;
486           
487           if ( keyid[2] && keyid[3] ) 
488             {
489               used_kid[0] = keyid[2];
490               used_kid[1] = keyid[3];
491             }
492           else
493             {
494               used_kid[0] = keyid[0];
495               used_kid[1] = keyid[1];
496             }
497           
498           us = get_long_user_id_string ( keyid );
499           write_status_text ( STATUS_USERID_HINT, us );
500           xfree(us);
501           
502           snprintf (buf, sizeof buf -1, "%08lX%08lX %08lX%08lX %d 0",
503                     (ulong)keyid[0], (ulong)keyid[1],
504                     (ulong)used_kid[0], (ulong)used_kid[1],
505                     pubkey_algo );
506           
507           write_status_text ( STATUS_NEED_PASSPHRASE, buf );
508         }
509       else
510         {
511           snprintf (buf, sizeof buf -1, "%d %d %d",
512                     cipher_algo, s2k->mode, s2k->hash_algo );
513           write_status_text ( STATUS_NEED_PASSPHRASE_SYM, buf );
514         }
515     }
516
517   /* If we do have a keyID, we do not have a passphrase available in
518      NEXT_PW, we are not running in batch mode and we do not want to
519      ignore the passphrase cache (mode!=1), print a prompt with
520      information on that key. */
521   if ( keyid && !opt.batch && !next_pw && mode!=1 )
522     {
523       PKT_public_key *pk = xmalloc_clear( sizeof *pk );
524       char *p;
525       
526       p = get_user_id_native(keyid);
527       tty_printf ("\n");
528       tty_printf (_("You need a passphrase to unlock the secret key for\n"
529                     "user: \"%s\"\n"),p);
530       xfree(p);
531
532       if ( !get_pubkey( pk, keyid ) )
533         {
534           const char *s = gcry_pk_algo_name ( pk->pubkey_algo );
535           
536           tty_printf (_("%u-bit %s key, ID %s, created %s"),
537                       nbits_from_pk( pk ), s?s:"?", keystr(keyid),
538                       strtimestamp(pk->timestamp) );
539           if ( keyid[2] && keyid[3]
540                && keyid[0] != keyid[2] && keyid[1] != keyid[3] )
541             {
542               if ( keystrlen () > 10 )
543                 {
544                   tty_printf ("\n");
545                   tty_printf (_("         (subkey on main key ID %s)"),
546                               keystr(&keyid[2]) );
547                 }
548               else
549                 tty_printf ( _(" (main key ID %s)"), keystr(&keyid[2]) );
550             }
551           tty_printf("\n");
552         }
553
554       tty_printf("\n");
555       if (pk)
556         free_public_key( pk );
557     }
558
559   if ( next_pw ) 
560     {
561       /* Simply return the passphrase we already have in NEXT_PW. */
562       pw = next_pw;
563       next_pw = NULL;
564     }
565   else 
566     {
567       /* Divert to the gpg-agent. */
568       pw = passphrase_get ( keyid, mode == 2? 1: 0, NULL,
569                             tryagain_text, NULL, NULL, canceled );
570       if (!pw)
571         pw = xstrdup ("");
572       if ( *pw && mode == 2 )
573         {
574           char *pw2 = passphrase_get ( keyid, 2, NULL, NULL, NULL,
575                                        NULL, canceled );
576           if (!pw2)
577             pw2 = xstrdup ("");
578           if ( strcmp(pw, pw2) )
579             {
580               xfree(pw2);
581               xfree(pw);
582               return NULL;
583             }
584           xfree(pw2);
585         }
586     }
587     
588   if ( !pw || !*pw )
589     write_status( STATUS_MISSING_PASSPHRASE );
590
591   /* Hash the passphrase and store it in a newly allocated DEK object.
592      Keep a copy of the passphrase in LAST_PW for use by
593      get_last_passphrase(). */
594   dek = xmalloc_secure_clear ( sizeof *dek );
595   dek->algo = cipher_algo;
596   if ( !*pw && mode == 2 )
597     dek->keylen = 0;
598   else
599     hash_passphrase( dek, pw, s2k, mode==2 );
600   xfree(last_pw);
601   last_pw = pw;
602   return dek;
603 }