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