* passphrase.c (agent_get_passphrase): Make sure to release the
[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  * If ORIG_CODESET is not NULL, the function will swithc the codeset
279  * back to that one before printing error messages.
280  */
281 #ifdef ENABLE_AGENT_SUPPORT
282 assuan_context_t
283 agent_open (int try, const char *orig_codeset)
284 {
285   int rc;
286   assuan_context_t ctx;
287   char *infostr, *p;
288   int prot;
289   int pid;
290
291   if (opt.gpg_agent_info)
292     infostr = xstrdup (opt.gpg_agent_info);
293   else
294     {
295       infostr = getenv ( "GPG_AGENT_INFO" );
296       if (!infostr || !*infostr) 
297         {
298           if (!try)
299             {
300 #ifdef ENABLE_NLS
301               if (orig_codeset)
302                 bind_textdomain_codeset (PACKAGE, orig_codeset);
303 #endif /*ENABLE_NLS*/
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 #ifdef ENABLE_NLS
317           if (orig_codeset)
318             bind_textdomain_codeset (PACKAGE, orig_codeset);
319 #endif /*ENABLE_NLS*/
320           log_error ( _("malformed GPG_AGENT_INFO environment variable\n"));
321           opt.use_agent = 0;
322         }
323       xfree (infostr);
324       return NULL;
325     }
326   *p++ = 0;
327   pid = atoi (p);
328   while (*p && *p != PATHSEP_C)
329     p++;
330   prot = *p? atoi (p+1) : 0;
331   if (prot != 1)
332     {
333       if (!try)
334         {
335 #ifdef ENABLE_NLS
336           if (orig_codeset)
337             bind_textdomain_codeset (PACKAGE, orig_codeset);
338 #endif /*ENABLE_NLS*/
339           log_error (_("gpg-agent protocol version %d is not supported\n"),
340                      prot);
341           opt.use_agent = 0;
342         }
343       xfree (infostr);
344       return NULL;
345     }
346      
347   rc = assuan_socket_connect (&ctx, infostr, pid);
348   if (rc)
349     {
350       if (!try)
351         {
352 #ifdef ENABLE_NLS
353           if (orig_codeset)
354             bind_textdomain_codeset (PACKAGE, orig_codeset);
355 #endif /*ENABLE_NLS*/
356           log_error ( _("can't connect to `%s': %s\n"), 
357                       infostr, assuan_strerror (rc));
358           opt.use_agent = 0;
359         }
360       xfree (infostr );
361       return NULL;
362     }
363   xfree (infostr);
364
365   if (agent_send_all_options (ctx))
366     {
367       if (!try)
368         {
369 #ifdef ENABLE_NLS
370           if (orig_codeset)
371             bind_textdomain_codeset (PACKAGE, orig_codeset);
372 #endif /*ENABLE_NLS*/
373           log_error (_("problem with the agent - disabling agent use\n"));
374           opt.use_agent = 0;
375         }
376       assuan_disconnect (ctx);
377       return NULL;
378     }
379
380   return ctx;
381 }
382 #endif/*ENABLE_AGENT_SUPPORT*/
383
384
385 #ifdef ENABLE_AGENT_SUPPORT
386 void
387 agent_close (assuan_context_t ctx)
388 {
389   assuan_disconnect (ctx);
390 }
391 #endif /*ENABLE_AGENT_SUPPORT*/
392
393
394 /* Copy the text ATEXT into the buffer P and do plus '+' and percent
395    escaping.  Note that the provided buffer needs to be 3 times the
396    size of ATEXT plus 1.  Returns a pointer to the leading Nul in P. */
397 #ifdef ENABLE_AGENT_SUPPORT
398 static char *
399 percent_plus_escape (char *p, const char *atext)
400 {
401   const unsigned char *s;
402
403   for (s=atext; *s; s++)
404     {
405       if (*s < ' ' || *s == '+')
406         {
407           sprintf (p, "%%%02X", *s);
408           p += 3;
409         }
410       else if (*s == ' ')
411         *p++ = '+';
412       else
413         *p++ = *s;
414     }
415   *p = 0;
416   return p;
417 }
418 #endif /*ENABLE_AGENT_SUPPORT*/
419
420
421 #ifdef ENABLE_AGENT_SUPPORT
422
423 /* Object for the agent_okay_cb function.  */
424 struct agent_okay_cb_s {
425   char *pw;
426 };
427
428 /* A callback used to get the passphrase from the okay line.  See
429    agent-get_passphrase for details.  LINE is the rest of the OK
430    status line without leading white spaces. */
431 static assuan_error_t
432 agent_okay_cb (void *opaque, const char *line)
433
434   struct agent_okay_cb_s *parm = opaque;
435   int i;
436
437   /* Note: If the malloc below fails we won't be able to wipe the
438      memory at LINE given the current implementation of the Assuan
439      code. There is no easy ay around this w/o adding a lot of more
440      memory function code to allow wiping arbitrary stuff on memory
441      failure. */
442   parm->pw = xmalloc_secure (strlen (line)/2+2);
443   
444   for (i=0; hexdigitp (line) && hexdigitp (line+1); line += 2)
445     parm->pw[i++] = xtoi_2 (line);
446   parm->pw[i] = 0; 
447   return 0;
448 }
449 #endif /*ENABLE_AGENT_SUPPORT*/
450
451
452
453 /*
454  * Ask the GPG Agent for the passphrase.
455  * Mode 0:  Allow cached passphrase
456  *      1:  No cached passphrase FIXME: Not really implemented
457  *      2:  Ditto, but change the text to "repeat entry"
458  *
459  * Note that TRYAGAIN_TEXT must not be translated.  If canceled is not
460  * NULL, the function does set it to 1 if the user canceled the
461  * operation.  If CACHEID is not NULL, it will be used as the cacheID
462  * for the gpg-agent; if is NULL and a key fingerprint can be
463  * computed, this will be used as the cacheid.
464  */
465 static char *
466 agent_get_passphrase ( u32 *keyid, int mode, const char *cacheid,
467                        const char *tryagain_text,
468                        const char *custom_description,
469                        const char *custom_prompt, int *canceled)
470 {
471 #ifdef ENABLE_AGENT_SUPPORT
472   char *atext = NULL;
473   assuan_context_t ctx = NULL;
474   char *pw = NULL;
475   PKT_public_key *pk = m_alloc_clear( sizeof *pk );
476   byte fpr[MAX_FINGERPRINT_LEN];
477   int have_fpr = 0;
478   char *orig_codeset = NULL;
479
480   if (canceled)
481     *canceled = 0;
482
483 #if MAX_FINGERPRINT_LEN < 20
484 #error agent needs a 20 byte fingerprint
485 #endif
486
487   memset (fpr, 0, MAX_FINGERPRINT_LEN );
488   if( keyid && get_pubkey( pk, keyid ) )
489     {
490       if (pk)
491         free_public_key( pk );      
492       pk = NULL; /* oops: no key for some reason */
493     }
494   
495 #ifdef ENABLE_NLS
496   /* The Assuan agent protocol requires us to transmit utf-8 strings */
497   orig_codeset = bind_textdomain_codeset (PACKAGE, NULL);
498 #ifdef HAVE_LANGINFO_CODESET
499   if (!orig_codeset)
500     orig_codeset = nl_langinfo (CODESET);
501 #endif
502   if (orig_codeset)
503     { /* We only switch when we are able to restore the codeset later. */
504       orig_codeset = m_strdup (orig_codeset);
505       if (!bind_textdomain_codeset (PACKAGE, "utf-8"))
506         orig_codeset = NULL; 
507     }
508 #endif
509
510   if ( !(ctx = agent_open (0, orig_codeset)) ) 
511     goto failure;
512
513   if (custom_description)
514     atext = native_to_utf8 (custom_description);
515   else if ( !mode && pk && keyid )
516     { 
517       char *uid;
518       size_t uidlen;
519       const char *algo_name = pubkey_algo_to_string ( pk->pubkey_algo );
520       const char *timestr;
521       char *maink;
522       
523       if ( !algo_name )
524         algo_name = "?";
525
526 #define KEYIDSTRING _(" (main key ID %s)")
527
528       maink = m_alloc ( strlen (KEYIDSTRING) + keystrlen() + 20 );
529       if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
530           && keyid[1] != keyid[3] )
531         sprintf( maink, KEYIDSTRING, keystr(&keyid[2]) );
532       else
533         *maink = 0;
534       
535       uid = get_user_id ( keyid, &uidlen ); 
536       timestr = strtimestamp (pk->timestamp);
537
538 #undef KEYIDSTRING
539
540 #define PROMPTSTRING _("You need a passphrase to unlock the secret" \
541                        " key for user:\n" \
542                        "\"%.*s\"\n" \
543                        "%u-bit %s key, ID %s, created %s%s\n" )
544
545       atext = m_alloc ( 100 + strlen (PROMPTSTRING)  
546                         + uidlen + 15 + strlen(algo_name) + keystrlen()
547                         + strlen (timestr) + strlen (maink) );
548       sprintf (atext, PROMPTSTRING,
549                (int)uidlen, uid,
550                nbits_from_pk (pk), algo_name, keystr(&keyid[0]), timestr,
551                maink  );
552       m_free (uid);
553       m_free (maink);
554
555 #undef PROMPTSTRING
556
557       { 
558         size_t dummy;
559         fingerprint_from_pk( pk, fpr, &dummy );
560         have_fpr = 1;
561       }
562       
563     }
564   else if (mode == 2 ) 
565     atext = m_strdup ( _("Repeat passphrase\n") );
566   else
567     atext = m_strdup ( _("Enter passphrase\n") );
568                 
569   { 
570       char *line, *p;
571       int i, rc; 
572       struct agent_okay_cb_s okay_cb_parm;
573
574       if (!tryagain_text)
575         tryagain_text = "X";
576       else
577         tryagain_text = _(tryagain_text);
578
579       /* We allocate 23 times the needed space for thye texts so that
580          there is enough space for escaping. */
581       line = xmalloc (15 + 46 
582                       + 3*strlen (atext)
583                       + 3*strlen (custom_prompt? custom_prompt:"")
584                       + (cacheid? (3*strlen (cacheid)): 0)
585                       + 3*strlen (tryagain_text)
586                       + 1);
587       strcpy (line, "GET_PASSPHRASE ");
588       p = line+15;
589       if (!mode && cacheid)
590         {
591           p = percent_plus_escape (p, cacheid);
592         }
593       else if (!mode && have_fpr)
594         {
595           for (i=0; i < 20; i++, p +=2 )
596             sprintf (p, "%02X", fpr[i]);
597         }
598       else
599         *p++ = 'X'; /* No caching. */
600       *p++ = ' ';
601
602       p = percent_plus_escape (p, tryagain_text);
603       *p++ = ' ';
604
605       /* The prompt.  */
606       if (custom_prompt)
607         {
608           char *tmp = native_to_utf8 (custom_prompt);
609           p = percent_plus_escape (p, tmp);
610           xfree (tmp);
611         }
612       else
613         *p++ = 'X'; /* Use the standard prompt. */
614       *p++ = ' ';
615
616       /* Copy description. */
617       percent_plus_escape (p, atext);
618
619       /* Call gpg-agent.  */
620       memset (&okay_cb_parm, 0, sizeof okay_cb_parm);
621       rc = assuan_transact2 (ctx, line, NULL, NULL, NULL, NULL, NULL, NULL,
622                              agent_okay_cb, &okay_cb_parm);
623
624       xfree (line);
625       xfree (atext); atext = NULL;
626       if (!rc)
627         {
628           assert (okay_cb_parm.pw);
629           pw = okay_cb_parm.pw;
630           agent_close (ctx);
631           if (pk)
632             free_public_key( pk );
633 #ifdef ENABLE_NLS
634           if (orig_codeset)
635             bind_textdomain_codeset (PACKAGE, orig_codeset);
636 #endif
637           xfree (orig_codeset);
638           return pw;
639         }
640       else if (rc && (rc & 0xffff) == 99)
641         {
642           /* 99 is GPG_ERR_CANCELED. */
643           log_info (_("cancelled by user\n") );
644           if (canceled)
645             *canceled = 1;
646         }
647       else 
648         {
649           log_error (_("problem with the agent - disabling agent use\n"));
650           opt.use_agent = 0;
651         }
652   }
653       
654         
655  failure:
656 #ifdef ENABLE_NLS
657   if (orig_codeset)
658     {
659       bind_textdomain_codeset (PACKAGE, orig_codeset);
660       xfree (orig_codeset);
661     }
662 #endif
663   xfree (atext);
664   agent_close (ctx);
665   xfree (pw );
666   if (pk)
667     free_public_key( pk );
668
669 #endif /*ENABLE_AGENT_SUPPORT*/
670
671   return NULL;
672 }
673
674
675 /*
676  * Clear the cached passphrase.  If CACHEID is not NULL, it will be
677  * used instead of a cache ID derived from KEYID.
678  */
679 void
680 passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
681 {
682 #ifdef ENABLE_AGENT_SUPPORT
683   assuan_context_t ctx = NULL;
684   PKT_public_key *pk;
685   byte fpr[MAX_FINGERPRINT_LEN];
686   
687 #if MAX_FINGERPRINT_LEN < 20
688 #error agent needs a 20 byte fingerprint
689 #endif
690     
691   if (!opt.use_agent)
692     return;
693   
694   if (!cacheid)
695     {
696       pk = xcalloc (1, sizeof *pk);
697       memset (fpr, 0, MAX_FINGERPRINT_LEN );
698       if( !keyid || get_pubkey( pk, keyid ) )
699         {
700           goto failure; /* oops: no key for some reason */
701         }
702   
703       {
704         size_t dummy;
705         fingerprint_from_pk( pk, fpr, &dummy );
706       }
707     }
708   else
709     pk = NULL;
710     
711   if ( !(ctx = agent_open (0, NULL)) ) 
712     goto failure;
713
714   { 
715       char *line, *p;
716       int i, rc; 
717
718       if (cacheid)
719         {
720           line = xmalloc (17 + 3*strlen (cacheid) + 2);
721           strcpy (line, "CLEAR_PASSPHRASE ");
722           p = line+17;
723           p = percent_plus_escape (p, cacheid);
724         }
725       else
726         {
727           line = xmalloc (17 + 40 + 2);
728           strcpy (line, "CLEAR_PASSPHRASE ");
729           p = line+17;
730           for (i=0; i < 20; i++, p +=2 )
731             sprintf (p, "%02X", fpr[i]);
732         }
733       *p = 0;
734
735       rc = assuan_transact (ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
736       xfree (line);
737       if (rc)
738         {
739           log_error (_("problem with the agent - disabling agent use\n"));
740           opt.use_agent = 0;
741         }
742     }
743         
744  failure:
745   agent_close (ctx);
746   if (pk)
747     free_public_key( pk );
748 #endif /*ENABLE_AGENT_SUPPORT*/
749 }
750
751
752 /****************
753  * Ask for a passphrase and return that string.
754  */
755 char *
756 ask_passphrase (const char *description,
757                 const char *tryagain_text,
758                 const char *promptid,
759                 const char *prompt,
760                 const char *cacheid, int *canceled)
761 {
762   char *pw = NULL;
763   
764   if (canceled)
765     *canceled = 0;
766
767   if (!opt.batch && description)
768     {
769       if (strchr (description, '%'))
770         {
771           char *tmp = unescape_percent_string (description);
772           tty_printf ("\n%s\n", tmp);
773           xfree (tmp);
774         }
775       else
776         tty_printf ("\n%s\n",description);
777     }
778                
779  agent_died:
780   if ( opt.use_agent ) 
781     {
782       pw = agent_get_passphrase (NULL, 0, cacheid,
783                                  tryagain_text, description, prompt,
784                                  canceled );
785       if (!pw)
786         {
787           if (!opt.use_agent)
788             goto agent_died;
789           pw = NULL;
790         }
791     }
792   else if (fd_passwd) 
793     {
794       pw = m_alloc_secure (strlen(fd_passwd)+1);
795       strcpy (pw, fd_passwd);
796     }
797   else if (opt.batch)
798     {
799       log_error(_("can't query passphrase in batch mode\n"));
800       pw = NULL;
801     }
802   else {
803     if (tryagain_text)
804       tty_printf(_("%s.\n"), tryagain_text);
805     pw = cpr_get_hidden(promptid? promptid : "passphrase.ask",
806                         prompt?prompt : _("Enter passphrase: ") );
807     tty_kill_prompt();
808   }
809
810   if (!pw || !*pw)
811     write_status( STATUS_MISSING_PASSPHRASE );
812
813   return pw;
814 }
815
816
817 /* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
818  * KEYID and PUBKEY_ALGO to prompt the user.
819
820    MODE 0:  Allow cached passphrase
821         1:  Ignore cached passphrase 
822         2:  Ditto, but change the text to "repeat entry"
823 */
824 DEK *
825 passphrase_to_dek( u32 *keyid, int pubkey_algo,
826                    int cipher_algo, STRING2KEY *s2k, int mode,
827                    const char *tryagain_text, int *canceled)
828 {
829     char *pw = NULL;
830     DEK *dek;
831     STRING2KEY help_s2k;
832
833     if (canceled)
834       *canceled = 0;
835
836     if( !s2k ) {
837         /* This is used for the old rfc1991 mode 
838          * Note: This must match the code in encode.c with opt.rfc1991 set */
839         s2k = &help_s2k;
840         s2k->mode = 0;
841         s2k->hash_algo = S2K_DIGEST_ALGO;
842     }
843
844     /* If we do not have a passphrase available in NEXT_PW and status
845        information are request, we print them now. */
846     if( !next_pw && is_status_enabled() ) {
847         char buf[50];
848  
849         if( keyid ) {
850             u32 used_kid[2];
851             char *us;
852
853             if( keyid[2] && keyid[3] ) {
854                 used_kid[0] = keyid[2];
855                 used_kid[1] = keyid[3];
856             }
857             else {
858                 used_kid[0] = keyid[0];
859                 used_kid[1] = keyid[1];
860             }
861
862             us = get_long_user_id_string( keyid );
863             write_status_text( STATUS_USERID_HINT, us );
864             m_free(us);
865
866             sprintf( buf, "%08lX%08lX %08lX%08lX %d 0",
867                      (ulong)keyid[0], (ulong)keyid[1],
868                      (ulong)used_kid[0], (ulong)used_kid[1],
869                      pubkey_algo );
870                      
871             write_status_text( STATUS_NEED_PASSPHRASE, buf );
872         }
873         else {
874             sprintf( buf, "%d %d %d", cipher_algo, s2k->mode, s2k->hash_algo );
875             write_status_text( STATUS_NEED_PASSPHRASE_SYM, buf );
876         }
877     }
878
879     /* If we do have a keyID, we do not have a passphrase available in
880        NEXT_PW, we are not running in batch mode and we do not want to
881        ignore the passphrase cache (mode!=1), print a prompt with
882        information on that key. */
883     if( keyid && !opt.batch && !next_pw && mode!=1 ) {
884         PKT_public_key *pk = m_alloc_clear( sizeof *pk );
885         char *p;
886
887         p=get_user_id_native(keyid);
888         tty_printf("\n");
889         tty_printf(_("You need a passphrase to unlock the secret key for\n"
890                      "user: \"%s\"\n"),p);
891         m_free(p);
892
893         if( !get_pubkey( pk, keyid ) ) {
894             const char *s = pubkey_algo_to_string( pk->pubkey_algo );
895             tty_printf( _("%u-bit %s key, ID %s, created %s"),
896                        nbits_from_pk( pk ), s?s:"?", keystr(keyid),
897                        strtimestamp(pk->timestamp) );
898             if( keyid[2] && keyid[3] && keyid[0] != keyid[2]
899                                      && keyid[1] != keyid[3] )
900               {
901                 if(keystrlen()>10)
902                   {
903                     tty_printf("\n");
904                     tty_printf(_("         (subkey on main key ID %s)"),
905                                keystr(&keyid[2]) );
906                   }
907                 else
908                   tty_printf( _(" (main key ID %s)"), keystr(&keyid[2]) );
909               }
910             tty_printf("\n");
911         }
912
913         tty_printf("\n");
914         if (pk)
915           free_public_key( pk );
916     }
917
918  agent_died:
919     if( next_pw ) {
920         /* Simply return the passphrase we already have in NEXT_PW. */
921         pw = next_pw;
922         next_pw = NULL;
923     }
924     else if ( opt.use_agent ) {
925       /* Divert to the gpg-agent. */
926         pw = agent_get_passphrase ( keyid, mode == 2? 1: 0, NULL,
927                                     tryagain_text, NULL, NULL, canceled );
928         if (!pw)
929           {
930             if (!opt.use_agent)
931               goto agent_died;
932             pw = m_strdup ("");
933           }
934         if( *pw && mode == 2 ) {
935             char *pw2 = agent_get_passphrase ( keyid, 2, NULL, NULL, NULL,
936                                                NULL, canceled );
937             if (!pw2)
938               {
939                 if (!opt.use_agent)
940                   {
941                     m_free (pw);
942                     pw = NULL;
943                     goto agent_died;
944                   }
945                 pw2 = m_strdup ("");
946               }
947             if( strcmp(pw, pw2) ) {
948                 m_free(pw2);
949                 m_free(pw);
950                 return NULL;
951             }
952             m_free(pw2);
953         }
954     }
955     else if( fd_passwd ) {
956         /* Return the passphrase we have store in FD_PASSWD. */
957         pw = m_alloc_secure( strlen(fd_passwd)+1 );
958         strcpy( pw, fd_passwd );
959     }
960     else if( opt.batch )
961       {
962         log_error(_("can't query passphrase in batch mode\n"));
963         pw = m_strdup( "" ); /* return an empty passphrase */
964       }
965     else {
966         /* Read the passphrase from the tty or the command-fd. */
967         pw = cpr_get_hidden("passphrase.enter", _("Enter passphrase: ") );
968         tty_kill_prompt();
969         if( mode == 2 && !cpr_enabled() ) {
970             char *pw2 = cpr_get_hidden("passphrase.repeat",
971                                        _("Repeat passphrase: ") );
972             tty_kill_prompt();
973             if( strcmp(pw, pw2) ) {
974                 m_free(pw2);
975                 m_free(pw);
976                 return NULL;
977             }
978             m_free(pw2);
979         }
980     }
981
982     if( !pw || !*pw )
983         write_status( STATUS_MISSING_PASSPHRASE );
984
985     /* Hash the passphrase and store it in a newly allocated DEK
986        object.  Keep a copy of the passphrase in LAST_PW for use by
987        get_last_passphrase(). */
988     dek = m_alloc_secure_clear ( sizeof *dek );
989     dek->algo = cipher_algo;
990     if( !*pw && mode == 2 )
991         dek->keylen = 0;
992     else
993         hash_passphrase( dek, pw, s2k, mode==2 );
994     m_free(last_pw);
995     last_pw = pw;
996     return dek;
997 }
998
999
1000 /****************
1001  * Hash a passphrase using the supplied s2k. If create is true, create
1002  * a new salt or what else must be filled into the s2k for a new key.
1003  * always needs: dek->algo, s2k->mode, s2k->hash_algo.
1004  */
1005 static void
1006 hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
1007 {
1008     MD_HANDLE md;
1009     int pass, i;
1010     int used = 0;
1011     int pwlen = strlen(pw);
1012
1013     assert( s2k->hash_algo );
1014     dek->keylen = cipher_get_keylen( dek->algo ) / 8;
1015     if( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
1016         BUG();
1017
1018     md = md_open( s2k->hash_algo, 1);
1019     for(pass=0; used < dek->keylen ; pass++ ) {
1020         if( pass ) {
1021             md_reset(md);
1022             for(i=0; i < pass; i++ ) /* preset the hash context */
1023                 md_putc(md, 0 );
1024         }
1025
1026         if( s2k->mode == 1 || s2k->mode == 3 ) {
1027             int len2 = pwlen + 8;
1028             ulong count = len2;
1029
1030             if( create && !pass ) {
1031                 randomize_buffer(s2k->salt, 8, 1);
1032                 if( s2k->mode == 3 )
1033                     s2k->count = 96; /* 65536 iterations */
1034             }
1035
1036             if( s2k->mode == 3 ) {
1037                 count = (16ul + (s2k->count & 15)) << ((s2k->count >> 4) + 6);
1038                 if( count < len2 )
1039                     count = len2;
1040             }
1041             /* a little bit complicated because we need a ulong for count */
1042             while( count > len2 ) { /* maybe iterated+salted */
1043                 md_write( md, s2k->salt, 8 );
1044                 md_write( md, pw, pwlen );
1045                 count -= len2;
1046             }
1047             if( count < 8 )
1048                 md_write( md, s2k->salt, count );
1049             else {
1050                 md_write( md, s2k->salt, 8 );
1051                 count -= 8;
1052                 md_write( md, pw, count );
1053             }
1054         }
1055         else
1056             md_write( md, pw, pwlen );
1057         md_final( md );
1058         i = md_digest_length( s2k->hash_algo );
1059         if( i > dek->keylen - used )
1060             i = dek->keylen - used;
1061         memcpy( dek->key+used, md_read(md, s2k->hash_algo), i );
1062         used += i;
1063     }
1064     md_close(md);
1065 }
1066