* g10.c (main), passphrase.c (set_passphrase_from_string): New
[gnupg.git] / g10 / passphrase.c
1 /* passphrase.c -  Get a passphrase
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2005 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 #if !defined(HAVE_DOSISH_SYSTEM) && !defined(__riscos__)
31 #include <sys/socket.h>
32 #include <sys/un.h>
33 #endif
34 #if defined (_WIN32)
35 #include <windows.h>
36 #endif
37 #include <errno.h>
38 #ifdef HAVE_LOCALE_H
39 #include <locale.h>
40 #endif
41 #ifdef HAVE_LANGINFO_CODESET
42 #include <langinfo.h>
43 #endif
44
45 #include "util.h"
46 #include "memory.h"
47 #include "options.h"
48 #include "ttyio.h"
49 #include "cipher.h"
50 #include "keydb.h"
51 #include "main.h"
52 #include "i18n.h"
53 #include "status.h"
54 #ifdef ENABLE_AGENT_SUPPORT
55 #include "assuan.h"
56 #endif /*ENABLE_AGENT_SUPPORT*/
57
58
59 #define buftou32( p )  ((*(byte*)(p) << 24) | (*((byte*)(p)+1)<< 16) | \
60                        (*((byte*)(p)+2) << 8) | (*((byte*)(p)+3)))
61 #define u32tobuf( p, a ) do {                                   \
62                             ((byte*)p)[0] = (byte)((a) >> 24);  \
63                             ((byte*)p)[1] = (byte)((a) >> 16);  \
64                             ((byte*)p)[2] = (byte)((a) >>  8);  \
65                             ((byte*)p)[3] = (byte)((a)      );  \
66                         } while(0)
67
68 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
69 #define hexdigitp(a) (digitp (a)                     \
70                       || (*(a) >= 'A' && *(a) <= 'F')  \
71                       || (*(a) >= 'a' && *(a) <= 'f'))
72 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
73                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
74 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
75
76 static char *fd_passwd = NULL;
77 static char *next_pw = NULL;
78 static char *last_pw = NULL;
79
80 static void hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create );
81
82 int
83 have_static_passphrase()
84 {
85     if ( opt.use_agent )
86         return 0;
87     return !!fd_passwd;
88 }
89
90 /****************
91  * Set the passphrase to be used for the next query and only for the next
92  * one.
93  */
94 void
95 set_next_passphrase( const char *s )
96 {
97     xfree(next_pw);
98     next_pw = NULL;
99     if( s ) {
100         next_pw = xmalloc_secure( strlen(s)+1 );
101         strcpy(next_pw, s );
102     }
103 }
104
105 /****************
106  * Get the last passphrase used in passphrase_to_dek.
107  * Note: This removes the passphrase from this modules and
108  * the caller must free the result.  May return NULL:
109  */
110 char *
111 get_last_passphrase()
112 {
113     char *p = last_pw;
114     last_pw = NULL;
115     return p;
116 }
117
118 /* Here's an interesting question: since this passphrase was passed in
119    on the command line, is there really any point in using secure
120    memory for it?  I'm going with 'yes', since it doesn't hurt, and
121    might help in some small way (swapping). */
122
123 void
124 set_passphrase_from_string(const char *pass)
125 {
126   xfree( fd_passwd );
127   fd_passwd = xmalloc_secure(strlen(pass)+1);
128   strcpy(fd_passwd,pass);
129 }
130
131
132 void
133 read_passphrase_from_fd( int fd )
134 {
135   int i, len;
136   char *pw;
137   
138   if ( opt.use_agent ) 
139     { /* Not used but we have to do a dummy read, so that it won't end
140          up at the begin of the message if the quite usual trick to
141          prepend the passphtrase to the message is used. */
142       char buf[1];
143
144       while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
145         ;
146       *buf = 0;
147       return; 
148     }
149
150   if (!opt.batch )
151         tty_printf("Reading passphrase from file descriptor %d ...", fd );
152   for (pw = NULL, i = len = 100; ; i++ ) 
153     {
154       if (i >= len-1 ) 
155         {
156           char *pw2 = pw;
157           len += 100;
158           pw = xmalloc_secure( len );
159           if( pw2 )
160             {
161               memcpy(pw, pw2, i );
162               xfree (pw2);
163             }
164           else
165             i=0;
166         }
167       if (read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
168         break;
169     }
170   pw[i] = 0;
171   if (!opt.batch)
172     tty_printf("\b\b\b   \n" );
173
174   xfree( fd_passwd );
175   fd_passwd = pw;
176 }
177
178
179
180 #ifdef ENABLE_AGENT_SUPPORT
181 /* Send one option to the gpg-agent.  */
182 static int
183 agent_send_option (assuan_context_t ctx, const char *name, const char *value)
184 {
185   char *line;
186   int rc; 
187   
188   if (!value || !*value)
189     return 0; /* Avoid sending empty option values. */
190
191   line = xmalloc (7 + strlen (name) + 1 + strlen (value) + 1);
192   strcpy (stpcpy (stpcpy (stpcpy (line, "OPTION "), name), "="), value);
193   rc = assuan_transact (ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
194   xfree (line);
195   return rc? -1 : 0;
196 }
197
198 /* Send all required options to the gpg-agent.  */
199 static int 
200 agent_send_all_options (assuan_context_t ctx)
201 {
202   char *dft_display = NULL;
203   const char *dft_ttyname = NULL;
204   char *dft_ttytype = NULL;
205   char *old_lc = NULL;
206   char *dft_lc = NULL;
207   int rc = 0;
208
209   dft_display = getenv ("DISPLAY");
210   if (opt.display || dft_display)
211     {
212       if (agent_send_option (ctx, "display",
213                              opt.display ? opt.display : dft_display))
214         return -1;
215     }
216
217   if (!opt.ttyname)
218     {
219       const char *tmp;
220
221       dft_ttyname = getenv ("GPG_TTY");
222       if ((!dft_ttyname || !*dft_ttyname) && (tmp=ttyname (0)))
223         dft_ttyname = tmp;
224       if ((!dft_ttyname || !*dft_ttyname) && (tmp=tty_get_ttyname ()))
225         dft_ttyname = tmp;
226     }
227   if (opt.ttyname || dft_ttyname)
228     {
229       if (agent_send_option (ctx, "ttyname",
230                              opt.ttyname ? opt.ttyname : dft_ttyname))
231         return -1;
232     }
233
234   dft_ttytype = getenv ("TERM");
235   if (opt.ttytype || (dft_ttyname && dft_ttytype))
236     {
237       if (agent_send_option (ctx, "ttytype",
238                              opt.ttyname ? opt.ttytype : dft_ttytype))
239         return -1;
240     }
241
242 #if defined(HAVE_SETLOCALE) && defined(LC_CTYPE)
243   old_lc = setlocale (LC_CTYPE, NULL);
244   if (old_lc)
245     old_lc = xstrdup (old_lc);
246   dft_lc = setlocale (LC_CTYPE, "");
247 #endif
248   if (opt.lc_ctype || (dft_ttyname && dft_lc))
249     {
250       rc = agent_send_option (ctx, "lc-ctype",
251                               opt.lc_ctype ? opt.lc_ctype : dft_lc);
252     }
253 #if defined(HAVE_SETLOCALE) && defined(LC_CTYPE)
254   if (old_lc)
255     {
256       setlocale (LC_CTYPE, old_lc);
257       xfree (old_lc);
258     }
259 #endif
260   if (rc)
261     return rc;
262
263 #if defined(HAVE_SETLOCALE) && defined(LC_MESSAGES)
264   old_lc = setlocale (LC_MESSAGES, NULL);
265   if (old_lc)
266     old_lc = xstrdup (old_lc);
267   dft_lc = setlocale (LC_MESSAGES, "");
268 #endif
269   if (opt.lc_messages || (dft_ttyname && dft_lc))
270     {
271       rc = agent_send_option (ctx, "lc-messages",
272                               opt.lc_messages ? opt.lc_messages : dft_lc);
273     }
274 #if defined(HAVE_SETLOCALE) && defined(LC_MESSAGES)
275   if (old_lc)
276     {
277       setlocale (LC_MESSAGES, old_lc);
278       xfree (old_lc);
279     }
280 #endif
281   return rc;
282 }
283 #endif /*ENABLE_AGENT_SUPPORT*/
284
285
286 /*
287  * Open a connection to the agent and initializes the connection.
288  * Returns: -1 on error; on success an Assuan context for that
289  * connection is returned.  With TRY set to true, no error messages
290  * are printed and the use of the agent won't get disabled on failure.
291  * If ORIG_CODESET is not NULL, the function will swithc the codeset
292  * back to that one before printing error messages.
293  */
294 #ifdef ENABLE_AGENT_SUPPORT
295 assuan_context_t
296 agent_open (int try, const char *orig_codeset)
297 {
298   int rc;
299   assuan_context_t ctx;
300   char *infostr, *p;
301   int prot;
302   int pid;
303
304   if (opt.gpg_agent_info)
305     infostr = xstrdup (opt.gpg_agent_info);
306   else
307     {
308       infostr = getenv ( "GPG_AGENT_INFO" );
309       if (!infostr || !*infostr) 
310         {
311           if (!try)
312             {
313 #ifdef ENABLE_NLS
314               if (orig_codeset)
315                 bind_textdomain_codeset (PACKAGE, orig_codeset);
316 #endif /*ENABLE_NLS*/
317               log_error (_("gpg-agent is not available in this session\n"));
318               opt.use_agent = 0;
319             }
320           return NULL;
321         }
322       infostr = xstrdup ( infostr );
323     }
324   
325   if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
326     {
327       if (!try)
328         {
329 #ifdef ENABLE_NLS
330           if (orig_codeset)
331             bind_textdomain_codeset (PACKAGE, orig_codeset);
332 #endif /*ENABLE_NLS*/
333           log_error ( _("malformed GPG_AGENT_INFO environment variable\n"));
334           opt.use_agent = 0;
335         }
336       xfree (infostr);
337       return NULL;
338     }
339   *p++ = 0;
340   pid = atoi (p);
341   while (*p && *p != PATHSEP_C)
342     p++;
343   prot = *p? atoi (p+1) : 0;
344   if (prot != 1)
345     {
346       if (!try)
347         {
348 #ifdef ENABLE_NLS
349           if (orig_codeset)
350             bind_textdomain_codeset (PACKAGE, orig_codeset);
351 #endif /*ENABLE_NLS*/
352           log_error (_("gpg-agent protocol version %d is not supported\n"),
353                      prot);
354           opt.use_agent = 0;
355         }
356       xfree (infostr);
357       return NULL;
358     }
359      
360   rc = assuan_socket_connect (&ctx, infostr, pid);
361   if (rc)
362     {
363       if (!try)
364         {
365 #ifdef ENABLE_NLS
366           if (orig_codeset)
367             bind_textdomain_codeset (PACKAGE, orig_codeset);
368 #endif /*ENABLE_NLS*/
369           log_error ( _("can't connect to `%s': %s\n"), 
370                       infostr, assuan_strerror (rc));
371           opt.use_agent = 0;
372         }
373       xfree (infostr );
374       return NULL;
375     }
376   xfree (infostr);
377
378   if (agent_send_all_options (ctx))
379     {
380       if (!try)
381         {
382 #ifdef ENABLE_NLS
383           if (orig_codeset)
384             bind_textdomain_codeset (PACKAGE, orig_codeset);
385 #endif /*ENABLE_NLS*/
386           log_error (_("problem with the agent - disabling agent use\n"));
387           opt.use_agent = 0;
388         }
389       assuan_disconnect (ctx);
390       return NULL;
391     }
392
393   return ctx;
394 }
395 #endif/*ENABLE_AGENT_SUPPORT*/
396
397
398 #ifdef ENABLE_AGENT_SUPPORT
399 void
400 agent_close (assuan_context_t ctx)
401 {
402   assuan_disconnect (ctx);
403 }
404 #endif /*ENABLE_AGENT_SUPPORT*/
405
406
407 /* Copy the text ATEXT into the buffer P and do plus '+' and percent
408    escaping.  Note that the provided buffer needs to be 3 times the
409    size of ATEXT plus 1.  Returns a pointer to the leading Nul in P. */
410 #ifdef ENABLE_AGENT_SUPPORT
411 static char *
412 percent_plus_escape (char *p, const char *atext)
413 {
414   const unsigned char *s;
415
416   for (s=atext; *s; s++)
417     {
418       if (*s < ' ' || *s == '+')
419         {
420           sprintf (p, "%%%02X", *s);
421           p += 3;
422         }
423       else if (*s == ' ')
424         *p++ = '+';
425       else
426         *p++ = *s;
427     }
428   *p = 0;
429   return p;
430 }
431 #endif /*ENABLE_AGENT_SUPPORT*/
432
433
434 #ifdef ENABLE_AGENT_SUPPORT
435
436 /* Object for the agent_okay_cb function.  */
437 struct agent_okay_cb_s {
438   char *pw;
439 };
440
441 /* A callback used to get the passphrase from the okay line.  See
442    agent-get_passphrase for details.  LINE is the rest of the OK
443    status line without leading white spaces. */
444 static assuan_error_t
445 agent_okay_cb (void *opaque, const char *line)
446
447   struct agent_okay_cb_s *parm = opaque;
448   int i;
449
450   /* Note: If the malloc below fails we won't be able to wipe the
451      memory at LINE given the current implementation of the Assuan
452      code. There is no easy ay around this w/o adding a lot of more
453      memory function code to allow wiping arbitrary stuff on memory
454      failure. */
455   parm->pw = xmalloc_secure (strlen (line)/2+2);
456   
457   for (i=0; hexdigitp (line) && hexdigitp (line+1); line += 2)
458     parm->pw[i++] = xtoi_2 (line);
459   parm->pw[i] = 0; 
460   return 0;
461 }
462 #endif /*ENABLE_AGENT_SUPPORT*/
463
464
465
466 /*
467  * Ask the GPG Agent for the passphrase.
468  * Mode 0:  Allow cached passphrase
469  *      1:  No cached passphrase FIXME: Not really implemented
470  *      2:  Ditto, but change the text to "repeat entry"
471  *
472  * Note that TRYAGAIN_TEXT must not be translated.  If canceled is not
473  * NULL, the function does set it to 1 if the user canceled the
474  * operation.  If CACHEID is not NULL, it will be used as the cacheID
475  * for the gpg-agent; if is NULL and a key fingerprint can be
476  * computed, this will be used as the cacheid.
477  */
478 static char *
479 agent_get_passphrase ( u32 *keyid, int mode, const char *cacheid,
480                        const char *tryagain_text,
481                        const char *custom_description,
482                        const char *custom_prompt, int *canceled)
483 {
484 #ifdef ENABLE_AGENT_SUPPORT
485   char *atext = NULL;
486   assuan_context_t ctx = NULL;
487   char *pw = NULL;
488   PKT_public_key *pk = xmalloc_clear( sizeof *pk );
489   byte fpr[MAX_FINGERPRINT_LEN];
490   int have_fpr = 0;
491   char *orig_codeset = NULL;
492
493   if (canceled)
494     *canceled = 0;
495
496 #if MAX_FINGERPRINT_LEN < 20
497 #error agent needs a 20 byte fingerprint
498 #endif
499
500   memset (fpr, 0, MAX_FINGERPRINT_LEN );
501   if( keyid && get_pubkey( pk, keyid ) )
502     {
503       if (pk)
504         free_public_key( pk );      
505       pk = NULL; /* oops: no key for some reason */
506     }
507   
508 #ifdef ENABLE_NLS
509   /* The Assuan agent protocol requires us to transmit utf-8 strings */
510   orig_codeset = bind_textdomain_codeset (PACKAGE, NULL);
511 #ifdef HAVE_LANGINFO_CODESET
512   if (!orig_codeset)
513     orig_codeset = nl_langinfo (CODESET);
514 #endif
515   if (orig_codeset)
516     { /* We only switch when we are able to restore the codeset later. */
517       orig_codeset = xstrdup (orig_codeset);
518       if (!bind_textdomain_codeset (PACKAGE, "utf-8"))
519         orig_codeset = NULL; 
520     }
521 #endif
522
523   if ( !(ctx = agent_open (0, orig_codeset)) ) 
524     goto failure;
525
526   if (custom_description)
527     atext = native_to_utf8 (custom_description);
528   else if ( !mode && pk && keyid )
529     { 
530       char *uid;
531       size_t uidlen;
532       const char *algo_name = pubkey_algo_to_string ( pk->pubkey_algo );
533       const char *timestr;
534       char *maink;
535       
536       if ( !algo_name )
537         algo_name = "?";
538
539 #define KEYIDSTRING _(" (main key ID %s)")
540
541       maink = xmalloc ( strlen (KEYIDSTRING) + keystrlen() + 20 );
542       if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
543           && keyid[1] != keyid[3] )
544         sprintf( maink, KEYIDSTRING, keystr(&keyid[2]) );
545       else
546         *maink = 0;
547       
548       uid = get_user_id ( keyid, &uidlen ); 
549       timestr = strtimestamp (pk->timestamp);
550
551 #undef KEYIDSTRING
552
553 #define PROMPTSTRING _("You need a passphrase to unlock the secret" \
554                        " key for user:\n" \
555                        "\"%.*s\"\n" \
556                        "%u-bit %s key, ID %s, created %s%s\n" )
557
558       atext = xmalloc ( 100 + strlen (PROMPTSTRING)  
559                         + uidlen + 15 + strlen(algo_name) + keystrlen()
560                         + strlen (timestr) + strlen (maink) );
561       sprintf (atext, PROMPTSTRING,
562                (int)uidlen, uid,
563                nbits_from_pk (pk), algo_name, keystr(&keyid[0]), timestr,
564                maink  );
565       xfree (uid);
566       xfree (maink);
567
568 #undef PROMPTSTRING
569
570       { 
571         size_t dummy;
572         fingerprint_from_pk( pk, fpr, &dummy );
573         have_fpr = 1;
574       }
575       
576     }
577   else if (mode == 2 ) 
578     atext = xstrdup ( _("Repeat passphrase\n") );
579   else
580     atext = xstrdup ( _("Enter passphrase\n") );
581                 
582   { 
583       char *line, *p;
584       int i, rc; 
585       struct agent_okay_cb_s okay_cb_parm;
586
587       if (!tryagain_text)
588         tryagain_text = "X";
589       else
590         tryagain_text = _(tryagain_text);
591
592       /* We allocate 23 times the needed space for thye texts so that
593          there is enough space for escaping. */
594       line = xmalloc (15 + 46 
595                       + 3*strlen (atext)
596                       + 3*strlen (custom_prompt? custom_prompt:"")
597                       + (cacheid? (3*strlen (cacheid)): 0)
598                       + 3*strlen (tryagain_text)
599                       + 1);
600       strcpy (line, "GET_PASSPHRASE ");
601       p = line+15;
602       if (!mode && cacheid)
603         {
604           p = percent_plus_escape (p, cacheid);
605         }
606       else if (!mode && have_fpr)
607         {
608           for (i=0; i < 20; i++, p +=2 )
609             sprintf (p, "%02X", fpr[i]);
610         }
611       else
612         *p++ = 'X'; /* No caching. */
613       *p++ = ' ';
614
615       p = percent_plus_escape (p, tryagain_text);
616       *p++ = ' ';
617
618       /* The prompt.  */
619       if (custom_prompt)
620         {
621           char *tmp = native_to_utf8 (custom_prompt);
622           p = percent_plus_escape (p, tmp);
623           xfree (tmp);
624         }
625       else
626         *p++ = 'X'; /* Use the standard prompt. */
627       *p++ = ' ';
628
629       /* Copy description. */
630       percent_plus_escape (p, atext);
631
632       /* Call gpg-agent.  */
633       memset (&okay_cb_parm, 0, sizeof okay_cb_parm);
634       rc = assuan_transact2 (ctx, line, NULL, NULL, NULL, NULL, NULL, NULL,
635                              agent_okay_cb, &okay_cb_parm);
636
637       xfree (line);
638       xfree (atext); atext = NULL;
639       if (!rc)
640         {
641           assert (okay_cb_parm.pw);
642           pw = okay_cb_parm.pw;
643           agent_close (ctx);
644           if (pk)
645             free_public_key( pk );
646 #ifdef ENABLE_NLS
647           if (orig_codeset)
648             bind_textdomain_codeset (PACKAGE, orig_codeset);
649 #endif
650           xfree (orig_codeset);
651           return pw;
652         }
653       else if (rc && (rc & 0xffff) == 99)
654         {
655           /* 99 is GPG_ERR_CANCELED. */
656           log_info (_("cancelled by user\n") );
657           if (canceled)
658             *canceled = 1;
659         }
660       else 
661         {
662           log_error (_("problem with the agent - disabling agent use\n"));
663           opt.use_agent = 0;
664         }
665   }
666       
667         
668  failure:
669 #ifdef ENABLE_NLS
670   if (orig_codeset)
671     {
672       bind_textdomain_codeset (PACKAGE, orig_codeset);
673       xfree (orig_codeset);
674     }
675 #endif
676   xfree (atext);
677   agent_close (ctx);
678   xfree (pw );
679   if (pk)
680     free_public_key( pk );
681
682 #endif /*ENABLE_AGENT_SUPPORT*/
683
684   return NULL;
685 }
686
687
688 /*
689  * Clear the cached passphrase.  If CACHEID is not NULL, it will be
690  * used instead of a cache ID derived from KEYID.
691  */
692 void
693 passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
694 {
695 #ifdef ENABLE_AGENT_SUPPORT
696   assuan_context_t ctx = NULL;
697   PKT_public_key *pk;
698   byte fpr[MAX_FINGERPRINT_LEN];
699   
700 #if MAX_FINGERPRINT_LEN < 20
701 #error agent needs a 20 byte fingerprint
702 #endif
703     
704   if (!opt.use_agent)
705     return;
706   
707   if (!cacheid)
708     {
709       pk = xcalloc (1, sizeof *pk);
710       memset (fpr, 0, MAX_FINGERPRINT_LEN );
711       if( !keyid || get_pubkey( pk, keyid ) )
712         {
713           goto failure; /* oops: no key for some reason */
714         }
715   
716       {
717         size_t dummy;
718         fingerprint_from_pk( pk, fpr, &dummy );
719       }
720     }
721   else
722     pk = NULL;
723     
724   if ( !(ctx = agent_open (0, NULL)) ) 
725     goto failure;
726
727   { 
728       char *line, *p;
729       int i, rc; 
730
731       if (cacheid)
732         {
733           line = xmalloc (17 + 3*strlen (cacheid) + 2);
734           strcpy (line, "CLEAR_PASSPHRASE ");
735           p = line+17;
736           p = percent_plus_escape (p, cacheid);
737         }
738       else
739         {
740           line = xmalloc (17 + 40 + 2);
741           strcpy (line, "CLEAR_PASSPHRASE ");
742           p = line+17;
743           for (i=0; i < 20; i++, p +=2 )
744             sprintf (p, "%02X", fpr[i]);
745         }
746       *p = 0;
747
748       rc = assuan_transact (ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
749       xfree (line);
750       if (rc)
751         {
752           log_error (_("problem with the agent - disabling agent use\n"));
753           opt.use_agent = 0;
754         }
755     }
756         
757  failure:
758   agent_close (ctx);
759   if (pk)
760     free_public_key( pk );
761 #endif /*ENABLE_AGENT_SUPPORT*/
762 }
763
764
765 /****************
766  * Ask for a passphrase and return that string.
767  */
768 char *
769 ask_passphrase (const char *description,
770                 const char *tryagain_text,
771                 const char *promptid,
772                 const char *prompt,
773                 const char *cacheid, int *canceled)
774 {
775   char *pw = NULL;
776   
777   if (canceled)
778     *canceled = 0;
779
780   if (!opt.batch && description)
781     {
782       if (strchr (description, '%'))
783         {
784           char *tmp = unescape_percent_string (description);
785           tty_printf ("\n%s\n", tmp);
786           xfree (tmp);
787         }
788       else
789         tty_printf ("\n%s\n",description);
790     }
791                
792  agent_died:
793   if ( opt.use_agent ) 
794     {
795       pw = agent_get_passphrase (NULL, 0, cacheid,
796                                  tryagain_text, description, prompt,
797                                  canceled );
798       if (!pw)
799         {
800           if (!opt.use_agent)
801             goto agent_died;
802           pw = NULL;
803         }
804     }
805   else if (fd_passwd) 
806     {
807       pw = xmalloc_secure (strlen(fd_passwd)+1);
808       strcpy (pw, fd_passwd);
809     }
810   else if (opt.batch)
811     {
812       log_error(_("can't query passphrase in batch mode\n"));
813       pw = NULL;
814     }
815   else {
816     if (tryagain_text)
817       tty_printf(_("%s.\n"), tryagain_text);
818     pw = cpr_get_hidden(promptid? promptid : "passphrase.ask",
819                         prompt?prompt : _("Enter passphrase: ") );
820     tty_kill_prompt();
821   }
822
823   if (!pw || !*pw)
824     write_status( STATUS_MISSING_PASSPHRASE );
825
826   return pw;
827 }
828
829
830 /* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
831  * KEYID and PUBKEY_ALGO to prompt the user.
832
833    MODE 0:  Allow cached passphrase
834         1:  Ignore cached passphrase 
835         2:  Ditto, but change the text to "repeat entry"
836 */
837 DEK *
838 passphrase_to_dek( u32 *keyid, int pubkey_algo,
839                    int cipher_algo, STRING2KEY *s2k, int mode,
840                    const char *tryagain_text, int *canceled)
841 {
842     char *pw = NULL;
843     DEK *dek;
844     STRING2KEY help_s2k;
845
846     if (canceled)
847       *canceled = 0;
848
849     if( !s2k ) {
850         /* This is used for the old rfc1991 mode 
851          * Note: This must match the code in encode.c with opt.rfc1991 set */
852         s2k = &help_s2k;
853         s2k->mode = 0;
854         s2k->hash_algo = S2K_DIGEST_ALGO;
855     }
856
857     /* If we do not have a passphrase available in NEXT_PW and status
858        information are request, we print them now. */
859     if( !next_pw && is_status_enabled() ) {
860         char buf[50];
861  
862         if( keyid ) {
863             u32 used_kid[2];
864             char *us;
865
866             if( keyid[2] && keyid[3] ) {
867                 used_kid[0] = keyid[2];
868                 used_kid[1] = keyid[3];
869             }
870             else {
871                 used_kid[0] = keyid[0];
872                 used_kid[1] = keyid[1];
873             }
874
875             us = get_long_user_id_string( keyid );
876             write_status_text( STATUS_USERID_HINT, us );
877             xfree(us);
878
879             sprintf( buf, "%08lX%08lX %08lX%08lX %d 0",
880                      (ulong)keyid[0], (ulong)keyid[1],
881                      (ulong)used_kid[0], (ulong)used_kid[1],
882                      pubkey_algo );
883                      
884             write_status_text( STATUS_NEED_PASSPHRASE, buf );
885         }
886         else {
887             sprintf( buf, "%d %d %d", cipher_algo, s2k->mode, s2k->hash_algo );
888             write_status_text( STATUS_NEED_PASSPHRASE_SYM, buf );
889         }
890     }
891
892     /* If we do have a keyID, we do not have a passphrase available in
893        NEXT_PW, we are not running in batch mode and we do not want to
894        ignore the passphrase cache (mode!=1), print a prompt with
895        information on that key. */
896     if( keyid && !opt.batch && !next_pw && mode!=1 ) {
897         PKT_public_key *pk = xmalloc_clear( sizeof *pk );
898         char *p;
899
900         p=get_user_id_native(keyid);
901         tty_printf("\n");
902         tty_printf(_("You need a passphrase to unlock the secret key for\n"
903                      "user: \"%s\"\n"),p);
904         xfree(p);
905
906         if( !get_pubkey( pk, keyid ) ) {
907             const char *s = pubkey_algo_to_string( pk->pubkey_algo );
908             tty_printf( _("%u-bit %s key, ID %s, created %s"),
909                        nbits_from_pk( pk ), s?s:"?", keystr(keyid),
910                        strtimestamp(pk->timestamp) );
911             if( keyid[2] && keyid[3] && keyid[0] != keyid[2]
912                                      && keyid[1] != keyid[3] )
913               {
914                 if(keystrlen()>10)
915                   {
916                     tty_printf("\n");
917                     tty_printf(_("         (subkey on main key ID %s)"),
918                                keystr(&keyid[2]) );
919                   }
920                 else
921                   tty_printf( _(" (main key ID %s)"), keystr(&keyid[2]) );
922               }
923             tty_printf("\n");
924         }
925
926         tty_printf("\n");
927         if (pk)
928           free_public_key( pk );
929     }
930
931  agent_died:
932     if( next_pw ) {
933         /* Simply return the passphrase we already have in NEXT_PW. */
934         pw = next_pw;
935         next_pw = NULL;
936     }
937     else if ( opt.use_agent ) {
938       /* Divert to the gpg-agent. */
939         pw = agent_get_passphrase ( keyid, mode == 2? 1: 0, NULL,
940                                     tryagain_text, NULL, NULL, canceled );
941         if (!pw)
942           {
943             if (!opt.use_agent)
944               goto agent_died;
945             pw = xstrdup ("");
946           }
947         if( *pw && mode == 2 ) {
948             char *pw2 = agent_get_passphrase ( keyid, 2, NULL, NULL, NULL,
949                                                NULL, canceled );
950             if (!pw2)
951               {
952                 if (!opt.use_agent)
953                   {
954                     xfree (pw);
955                     pw = NULL;
956                     goto agent_died;
957                   }
958                 pw2 = xstrdup ("");
959               }
960             if( strcmp(pw, pw2) ) {
961                 xfree(pw2);
962                 xfree(pw);
963                 return NULL;
964             }
965             xfree(pw2);
966         }
967     }
968     else if( fd_passwd ) {
969         /* Return the passphrase we have store in FD_PASSWD. */
970         pw = xmalloc_secure( strlen(fd_passwd)+1 );
971         strcpy( pw, fd_passwd );
972     }
973     else if( opt.batch )
974       {
975         log_error(_("can't query passphrase in batch mode\n"));
976         pw = xstrdup( "" ); /* return an empty passphrase */
977       }
978     else {
979         /* Read the passphrase from the tty or the command-fd. */
980         pw = cpr_get_hidden("passphrase.enter", _("Enter passphrase: ") );
981         tty_kill_prompt();
982         if( mode == 2 && !cpr_enabled() ) {
983             char *pw2 = cpr_get_hidden("passphrase.repeat",
984                                        _("Repeat passphrase: ") );
985             tty_kill_prompt();
986             if( strcmp(pw, pw2) ) {
987                 xfree(pw2);
988                 xfree(pw);
989                 return NULL;
990             }
991             xfree(pw2);
992         }
993     }
994
995     if( !pw || !*pw )
996         write_status( STATUS_MISSING_PASSPHRASE );
997
998     /* Hash the passphrase and store it in a newly allocated DEK
999        object.  Keep a copy of the passphrase in LAST_PW for use by
1000        get_last_passphrase(). */
1001     dek = xmalloc_secure_clear ( sizeof *dek );
1002     dek->algo = cipher_algo;
1003     if( !*pw && mode == 2 )
1004         dek->keylen = 0;
1005     else
1006         hash_passphrase( dek, pw, s2k, mode==2 );
1007     xfree(last_pw);
1008     last_pw = pw;
1009     return dek;
1010 }
1011
1012
1013 /****************
1014  * Hash a passphrase using the supplied s2k. If create is true, create
1015  * a new salt or what else must be filled into the s2k for a new key.
1016  * always needs: dek->algo, s2k->mode, s2k->hash_algo.
1017  */
1018 static void
1019 hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
1020 {
1021     MD_HANDLE md;
1022     int pass, i;
1023     int used = 0;
1024     int pwlen = strlen(pw);
1025
1026     assert( s2k->hash_algo );
1027     dek->keylen = cipher_get_keylen( dek->algo ) / 8;
1028     if( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
1029         BUG();
1030
1031     md = md_open( s2k->hash_algo, 1);
1032     for(pass=0; used < dek->keylen ; pass++ ) {
1033         if( pass ) {
1034             md_reset(md);
1035             for(i=0; i < pass; i++ ) /* preset the hash context */
1036                 md_putc(md, 0 );
1037         }
1038
1039         if( s2k->mode == 1 || s2k->mode == 3 ) {
1040             int len2 = pwlen + 8;
1041             ulong count = len2;
1042
1043             if( create && !pass ) {
1044                 randomize_buffer(s2k->salt, 8, 1);
1045                 if( s2k->mode == 3 )
1046                     s2k->count = 96; /* 65536 iterations */
1047             }
1048
1049             if( s2k->mode == 3 ) {
1050                 count = (16ul + (s2k->count & 15)) << ((s2k->count >> 4) + 6);
1051                 if( count < len2 )
1052                     count = len2;
1053             }
1054             /* a little bit complicated because we need a ulong for count */
1055             while( count > len2 ) { /* maybe iterated+salted */
1056                 md_write( md, s2k->salt, 8 );
1057                 md_write( md, pw, pwlen );
1058                 count -= len2;
1059             }
1060             if( count < 8 )
1061                 md_write( md, s2k->salt, count );
1062             else {
1063                 md_write( md, s2k->salt, 8 );
1064                 count -= 8;
1065                 md_write( md, pw, count );
1066             }
1067         }
1068         else
1069             md_write( md, pw, pwlen );
1070         md_final( md );
1071         i = md_digest_length( s2k->hash_algo );
1072         if( i > dek->keylen - used )
1073             i = dek->keylen - used;
1074         memcpy( dek->key+used, md_read(md, s2k->hash_algo), i );
1075         used += i;
1076     }
1077     md_close(md);
1078 }
1079