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