030d801b2dd344cc3a74d94629cbb13924a2af34
[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     tty_printf ("\n%s\n",description);
750                
751  agent_died:
752   if ( opt.use_agent ) 
753     {
754       pw = agent_get_passphrase (NULL, 0, cacheid,
755                                  tryagain_text, description, prompt,
756                                  canceled );
757       if (!pw)
758         {
759           if (!opt.use_agent)
760             goto agent_died;
761           pw = NULL;
762         }
763     }
764   else if (fd_passwd) 
765     {
766       pw = m_alloc_secure (strlen(fd_passwd)+1);
767       strcpy (pw, fd_passwd);
768     }
769   else if (opt.batch)
770     {
771       log_error(_("can't query passphrase in batch mode\n"));
772       pw = NULL;
773     }
774   else {
775     if (tryagain_text)
776       tty_printf(_("%s.\n"), tryagain_text);
777     pw = cpr_get_hidden(promptid? promptid : "passphrase.ask",
778                         prompt?prompt : _("Enter passphrase: ") );
779     tty_kill_prompt();
780   }
781
782   if (!pw || !*pw)
783     write_status( STATUS_MISSING_PASSPHRASE );
784
785   return pw;
786 }
787
788
789 /* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
790  * KEYID and PUBKEY_ALGO to prompt the user.
791
792    MODE 0:  Allow cached passphrase
793         1:  Ignore cached passphrase 
794         2:  Ditto, but change the text to "repeat entry"
795 */
796 DEK *
797 passphrase_to_dek( u32 *keyid, int pubkey_algo,
798                    int cipher_algo, STRING2KEY *s2k, int mode,
799                    const char *tryagain_text, int *canceled)
800 {
801     char *pw = NULL;
802     DEK *dek;
803     STRING2KEY help_s2k;
804
805     if (canceled)
806       *canceled = 0;
807
808     if( !s2k ) {
809         /* This is used for the old rfc1991 mode 
810          * Note: This must match the code in encode.c with opt.rfc1991 set */
811         s2k = &help_s2k;
812         s2k->mode = 0;
813         s2k->hash_algo = S2K_DIGEST_ALGO;
814     }
815
816     /* If we do not have a passphrase available in NEXT_PW and status
817        information are request, we print them now. */
818     if( !next_pw && is_status_enabled() ) {
819         char buf[50];
820  
821         if( keyid ) {
822             u32 used_kid[2];
823             char *us;
824
825             if( keyid[2] && keyid[3] ) {
826                 used_kid[0] = keyid[2];
827                 used_kid[1] = keyid[3];
828             }
829             else {
830                 used_kid[0] = keyid[0];
831                 used_kid[1] = keyid[1];
832             }
833
834             us = get_long_user_id_string( keyid );
835             write_status_text( STATUS_USERID_HINT, us );
836             m_free(us);
837
838             sprintf( buf, "%08lX%08lX %08lX%08lX %d 0",
839                      (ulong)keyid[0], (ulong)keyid[1],
840                      (ulong)used_kid[0], (ulong)used_kid[1],
841                      pubkey_algo );
842                      
843             write_status_text( STATUS_NEED_PASSPHRASE, buf );
844         }
845         else {
846             sprintf( buf, "%d %d %d", cipher_algo, s2k->mode, s2k->hash_algo );
847             write_status_text( STATUS_NEED_PASSPHRASE_SYM, buf );
848         }
849     }
850
851     /* If we do have a keyID, we do not have a passphrase available in
852        NEXT_PW, we are not running in batch mode and we do not want to
853        ignore the passphrase cache (mode!=1), print a prompt with
854        information on that key. */
855     if( keyid && !opt.batch && !next_pw && mode!=1 ) {
856         PKT_public_key *pk = m_alloc_clear( sizeof *pk );
857         char *p;
858
859         p=get_user_id_native(keyid);
860         tty_printf("\n");
861         tty_printf(_("You need a passphrase to unlock the secret key for\n"
862                      "user: \"%s\"\n"),p);
863         m_free(p);
864
865         if( !get_pubkey( pk, keyid ) ) {
866             const char *s = pubkey_algo_to_string( pk->pubkey_algo );
867             tty_printf( _("%u-bit %s key, ID %s, created %s"),
868                        nbits_from_pk( pk ), s?s:"?", keystr(keyid),
869                        strtimestamp(pk->timestamp) );
870             if( keyid[2] && keyid[3] && keyid[0] != keyid[2]
871                                      && keyid[1] != keyid[3] )
872               {
873                 if(keystrlen()>10)
874                   {
875                     tty_printf("\n");
876                     tty_printf(_("         (subkey on main key ID %s)"),
877                                keystr(&keyid[2]) );
878                   }
879                 else
880                   tty_printf( _(" (main key ID %s)"), keystr(&keyid[2]) );
881               }
882             tty_printf("\n");
883         }
884
885         tty_printf("\n");
886         if (pk)
887           free_public_key( pk );
888     }
889
890  agent_died:
891     if( next_pw ) {
892         /* Simply return the passphrase we already have in NEXT_PW. */
893         pw = next_pw;
894         next_pw = NULL;
895     }
896     else if ( opt.use_agent ) {
897       /* Divert to the gpg-agent. */
898         pw = agent_get_passphrase ( keyid, mode == 2? 1: 0, NULL,
899                                     tryagain_text, NULL, NULL, canceled );
900         if (!pw)
901           {
902             if (!opt.use_agent)
903               goto agent_died;
904             pw = m_strdup ("");
905           }
906         if( *pw && mode == 2 ) {
907             char *pw2 = agent_get_passphrase ( keyid, 2, NULL, NULL, NULL,
908                                                NULL, canceled );
909             if (!pw2)
910               {
911                 if (!opt.use_agent)
912                   {
913                     m_free (pw);
914                     pw = NULL;
915                     goto agent_died;
916                   }
917                 pw2 = m_strdup ("");
918               }
919             if( strcmp(pw, pw2) ) {
920                 m_free(pw2);
921                 m_free(pw);
922                 return NULL;
923             }
924             m_free(pw2);
925         }
926     }
927     else if( fd_passwd ) {
928         /* Return the passphrase we have store in FD_PASSWD. */
929         pw = m_alloc_secure( strlen(fd_passwd)+1 );
930         strcpy( pw, fd_passwd );
931     }
932     else if( opt.batch )
933       {
934         log_error(_("can't query passphrase in batch mode\n"));
935         pw = m_strdup( "" ); /* return an empty passphrase */
936       }
937     else {
938         /* Read the passphrase from the tty or the command-fd. */
939         pw = cpr_get_hidden("passphrase.enter", _("Enter passphrase: ") );
940         tty_kill_prompt();
941         if( mode == 2 && !cpr_enabled() ) {
942             char *pw2 = cpr_get_hidden("passphrase.repeat",
943                                        _("Repeat passphrase: ") );
944             tty_kill_prompt();
945             if( strcmp(pw, pw2) ) {
946                 m_free(pw2);
947                 m_free(pw);
948                 return NULL;
949             }
950             m_free(pw2);
951         }
952     }
953
954     if( !pw || !*pw )
955         write_status( STATUS_MISSING_PASSPHRASE );
956
957     /* Hash the passphrase and store it in a newly allocated DEK
958        object.  Keep a copy of the passphrase in LAST_PW for use by
959        get_last_passphrase(). */
960     dek = m_alloc_secure_clear ( sizeof *dek );
961     dek->algo = cipher_algo;
962     if( !*pw && mode == 2 )
963         dek->keylen = 0;
964     else
965         hash_passphrase( dek, pw, s2k, mode==2 );
966     m_free(last_pw);
967     last_pw = pw;
968     return dek;
969 }
970
971
972 /****************
973  * Hash a passphrase using the supplied s2k. If create is true, create
974  * a new salt or what else must be filled into the s2k for a new key.
975  * always needs: dek->algo, s2k->mode, s2k->hash_algo.
976  */
977 static void
978 hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
979 {
980     MD_HANDLE md;
981     int pass, i;
982     int used = 0;
983     int pwlen = strlen(pw);
984
985     assert( s2k->hash_algo );
986     dek->keylen = cipher_get_keylen( dek->algo ) / 8;
987     if( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
988         BUG();
989
990     md = md_open( s2k->hash_algo, 1);
991     for(pass=0; used < dek->keylen ; pass++ ) {
992         if( pass ) {
993             md_reset(md);
994             for(i=0; i < pass; i++ ) /* preset the hash context */
995                 md_putc(md, 0 );
996         }
997
998         if( s2k->mode == 1 || s2k->mode == 3 ) {
999             int len2 = pwlen + 8;
1000             ulong count = len2;
1001
1002             if( create && !pass ) {
1003                 randomize_buffer(s2k->salt, 8, 1);
1004                 if( s2k->mode == 3 )
1005                     s2k->count = 96; /* 65536 iterations */
1006             }
1007
1008             if( s2k->mode == 3 ) {
1009                 count = (16ul + (s2k->count & 15)) << ((s2k->count >> 4) + 6);
1010                 if( count < len2 )
1011                     count = len2;
1012             }
1013             /* a little bit complicated because we need a ulong for count */
1014             while( count > len2 ) { /* maybe iterated+salted */
1015                 md_write( md, s2k->salt, 8 );
1016                 md_write( md, pw, pwlen );
1017                 count -= len2;
1018             }
1019             if( count < 8 )
1020                 md_write( md, s2k->salt, count );
1021             else {
1022                 md_write( md, s2k->salt, 8 );
1023                 count -= 8;
1024                 md_write( md, pw, count );
1025             }
1026         }
1027         else
1028             md_write( md, pw, pwlen );
1029         md_final( md );
1030         i = md_digest_length( s2k->hash_algo );
1031         if( i > dek->keylen - used )
1032             i = dek->keylen - used;
1033         memcpy( dek->key+used, md_read(md, s2k->hash_algo), i );
1034         used += i;
1035     }
1036     md_close(md);
1037 }
1038