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