9d303f43d41f5ba77e440092e3dd8a9ebf5047a6
[gnupg.git] / g10 / passphrase.c
1 /* passphrase.c -  Get a passphrase
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004 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) || defined (__CYGWIN32__)
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
54
55 enum gpga_protocol_codes {
56     /* Request codes */
57     GPGA_PROT_GET_VERSION     = 1,
58     GPGA_PROT_GET_PASSPHRASE  = 2,
59     GPGA_PROT_CLEAR_PASSPHRASE= 3,
60     GPGA_PROT_SHUTDOWN        = 4,
61     GPGA_PROT_FLUSH           = 5,
62
63     /* Reply codes */
64     GPGA_PROT_REPLY_BASE     = 0x10000,
65     GPGA_PROT_OKAY           = 0x10001,
66     GPGA_PROT_GOT_PASSPHRASE = 0x10002,
67
68     /* Error codes */
69     GPGA_PROT_ERROR_BASE     = 0x20000,
70     GPGA_PROT_PROTOCOL_ERROR = 0x20001,
71     GPGA_PROT_INVALID_REQUEST= 0x20002,
72     GPGA_PROT_CANCELED       = 0x20003,    
73     GPGA_PROT_NO_PASSPHRASE  = 0x20004,    
74     GPGA_PROT_BAD_PASSPHRASE = 0x20005,
75     GPGA_PROT_INVALID_DATA   = 0x20006,
76     GPGA_PROT_NOT_IMPLEMENTED= 0x20007,
77     GPGA_PROT_UI_PROBLEM     = 0x20008
78 };
79
80
81 #define buftou32( p )  ((*(byte*)(p) << 24) | (*((byte*)(p)+1)<< 16) | \
82                        (*((byte*)(p)+2) << 8) | (*((byte*)(p)+3)))
83 #define u32tobuf( p, a ) do {                                   \
84                             ((byte*)p)[0] = (byte)((a) >> 24);  \
85                             ((byte*)p)[1] = (byte)((a) >> 16);  \
86                             ((byte*)p)[2] = (byte)((a) >>  8);  \
87                             ((byte*)p)[3] = (byte)((a)      );  \
88                         } while(0)
89
90 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
91 #define hexdigitp(a) (digitp (a)                     \
92                       || (*(a) >= 'A' && *(a) <= 'F')  \
93                       || (*(a) >= 'a' && *(a) <= 'f'))
94 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
95                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
96 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
97
98
99
100 static char *fd_passwd = NULL;
101 static char *next_pw = NULL;
102 static char *last_pw = NULL;
103
104 #if defined (_WIN32)
105 static int read_fd = 0;
106 static int write_fd = 0;
107 #endif
108
109 static void hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create );
110
111 int
112 have_static_passphrase()
113 {
114     if ( opt.use_agent )
115         return 0;
116     return !!fd_passwd;
117 }
118
119 /****************
120  * Set the passphrase to be used for the next query and only for the next
121  * one.
122  */
123 void
124 set_next_passphrase( const char *s )
125 {
126     m_free(next_pw);
127     next_pw = NULL;
128     if( s ) {
129         next_pw = m_alloc_secure( strlen(s)+1 );
130         strcpy(next_pw, s );
131     }
132 }
133
134 /****************
135  * Get the last passphrase used in passphrase_to_dek.
136  * Note: This removes the passphrase from this modules and
137  * the caller must free the result.  May return NULL:
138  */
139 char *
140 get_last_passphrase()
141 {
142     char *p = last_pw;
143     last_pw = NULL;
144     return p;
145 }
146
147
148 void
149 read_passphrase_from_fd( int fd )
150 {
151   int i, len;
152   char *pw;
153   
154   if ( opt.use_agent ) 
155     { /* Not used but we have to do a dummy read, so that it won't end
156          up at the begin of the message if the quite usual trick to
157          prepend the passphtrase to the message is used. */
158       char buf[1];
159
160       while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
161         ;
162       *buf = 0;
163       return; 
164     }
165
166   if (!opt.batch )
167         tty_printf("Reading passphrase from file descriptor %d ...", fd );
168   for (pw = NULL, i = len = 100; ; i++ ) 
169     {
170       if (i >= len-1 ) 
171         {
172           char *pw2 = pw;
173           len += 100;
174           pw = m_alloc_secure( len );
175           if( pw2 )
176             {
177               memcpy(pw, pw2, i );
178               m_free (pw2);
179             }
180           else
181             i=0;
182         }
183       if (read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
184         break;
185     }
186   pw[i] = 0;
187   if (!opt.batch)
188     tty_printf("\b\b\b   \n" );
189
190   m_free( fd_passwd );
191   fd_passwd = pw;
192 }
193
194 static int
195 writen (int fd, const void *buf, size_t nbytes)
196 {
197 #if defined (_WIN32)
198   DWORD nwritten, nleft = nbytes;
199     
200   while (nleft > 0)
201     {
202       if (!WriteFile ((HANDLE)write_fd, buf, nleft, &nwritten, NULL))
203         {
204           log_error ("write failed: %s\n", w32_strerror (0));
205           return -1;
206         }
207       /*log_info ("** WriteFile fd=%d nytes=%d nwritten=%d\n",
208         write_fd, nbytes, (int)nwritten);*/
209       Sleep (100);
210         
211       nleft -= nwritten;
212       buf = (const BYTE *)buf + nwritten;
213     }
214 #elif defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
215   /* not implemented */
216 #else
217   size_t nleft = nbytes;
218   int nwritten;
219
220   while (nleft > 0)
221     {
222       nwritten = write (fd, buf, nleft);
223       if (nwritten < 0)
224         {
225           if (errno == EINTR)
226             nwritten = 0;
227           else
228             {
229               log_error ("write() failed: %s\n", strerror (errno));
230               return -1;
231             }
232         }
233       nleft -= nwritten;
234       buf = (const char*)buf + nwritten;
235     }
236 #endif
237     
238   return 0;
239 }
240
241
242 static int
243 readn (int fd, void *buf, size_t buflen, size_t *ret_nread)
244 {
245 #if defined (_WIN32)
246   DWORD nread, nleft = buflen;
247     
248   while (nleft > 0)
249     {
250       if (!ReadFile ((HANDLE)read_fd, buf, nleft, &nread, NULL))
251         {
252           log_error ("read() error: %s\n", w32_strerror (0));
253           return -1;
254         }
255       if (!nread || GetLastError() == ERROR_BROKEN_PIPE)
256         break;
257       /*log_info ("** ReadFile fd=%d buflen=%d nread=%d\n",
258         read_fd, buflen, (int)nread);*/
259       Sleep (100);
260         
261       nleft -= nread;
262       buf = (BYTE *)buf + nread;
263     }           
264   if (ret_nread)
265     *ret_nread = buflen - nleft;
266
267 #elif defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
268   /* not implemented */
269 #else
270   size_t nleft = buflen;
271   int nread;
272   char *p;
273   
274   p = buf;
275   while( nleft > 0 )
276     {
277       nread = read ( fd, buf, nleft );
278       if( nread < 0 ) 
279         {
280           if (errno == EINTR)
281             nread = 0;
282           else 
283             {
284               log_error ( "read() error: %s\n", strerror (errno) );
285               return -1;
286             }
287         }
288       else if (!nread)
289         break; /* EOF */
290       nleft -= nread;
291       buf = (char*)buf + nread;
292     }
293   if (ret_nread)
294     *ret_nread = buflen - nleft;
295 #endif
296     
297   return 0;
298 }
299
300 /* read an entire line */
301 static int
302 readline (int fd, char *buf, size_t buflen)
303 {
304   size_t nleft = buflen;
305   char *p;
306   int nread = 0;
307
308   while (nleft > 0)
309     {
310       int n = read (fd, buf, nleft);
311       if (n < 0)
312         {
313           if (errno == EINTR)
314             continue;
315           return -1; /* read error */
316         }
317       else if (!n)
318         {
319           return -1; /* incomplete line */
320         }
321       p = buf;
322       nleft -= n;
323       buf += n;
324       nread += n;
325       
326       for (; n && *p != '\n'; n--, p++)
327         ;
328       if (n)
329         {
330           break; /* at least one full line available - that's enough.
331                     This function is just a temporary hack until we use
332                     the assuna lib in gpg.  So it is okay to forget
333                     about pending bytes */
334         }
335     }
336
337   return nread; 
338 }
339
340
341
342 #if !defined (__riscos__)
343
344 #if !defined (_WIN32)
345 /* For the new Assuan protocol we may have to send options */
346 static int
347 agent_send_option (int fd, const char *name, const char *value)
348 {
349   char buf[200];
350   int nread;
351   char *line;
352   int i; 
353   
354   line = m_alloc (7 + strlen (name) + 1 + strlen (value) + 2);
355   strcpy (stpcpy (stpcpy (stpcpy (
356                      stpcpy (line, "OPTION "), name), "="), value), "\n");
357   i = writen (fd, line, strlen (line));
358   m_free (line);
359   if (i)
360     return -1;
361   
362   /* get response */
363   nread = readline (fd, buf, DIM(buf)-1);
364   if (nread < 3)
365     return -1;
366   
367   if (buf[0] == 'O' && buf[1] == 'K' && (buf[2] == ' ' || buf[2] == '\n')) 
368     return 0; /* okay */
369
370   return -1;
371 }
372
373 static int 
374 agent_send_all_options (int fd)
375 {
376   char *dft_display = NULL;
377   const char *dft_ttyname = NULL;
378   char *dft_ttytype = NULL;
379   char *old_lc = NULL;
380   char *dft_lc = NULL;
381   int rc = 0;
382
383   dft_display = getenv ("DISPLAY");
384   if (opt.display || dft_display)
385     {
386       if (agent_send_option (fd, "display",
387                              opt.display ? opt.display : dft_display))
388         return -1;
389     }
390
391   if (!opt.ttyname)
392     {
393       const char *tmp;
394
395       dft_ttyname = getenv ("GPG_TTY");
396       if ((!dft_ttyname || !*dft_ttyname) && (tmp=ttyname (0)))
397         dft_ttyname = tmp;
398       if ((!dft_ttyname || !*dft_ttyname) && (tmp=tty_get_ttyname ()))
399         dft_ttyname = tmp;
400     }
401   if (opt.ttyname || dft_ttyname)
402     {
403       if (agent_send_option (fd, "ttyname",
404                              opt.ttyname ? opt.ttyname : dft_ttyname))
405         return -1;
406     }
407
408   dft_ttytype = getenv ("TERM");
409   if (opt.ttytype || (dft_ttyname && dft_ttytype))
410     {
411       if (agent_send_option (fd, "ttytype",
412                              opt.ttyname ? opt.ttytype : dft_ttytype))
413         return -1;
414     }
415
416 #if defined(HAVE_SETLOCALE) && defined(LC_CTYPE)
417   old_lc = setlocale (LC_CTYPE, NULL);
418   if (old_lc)
419     old_lc = m_strdup (old_lc);
420   dft_lc = setlocale (LC_CTYPE, "");
421 #endif
422   if (opt.lc_ctype || (dft_ttyname && dft_lc))
423     {
424       rc = agent_send_option (fd, "lc-ctype",
425                               opt.lc_ctype ? opt.lc_ctype : dft_lc);
426     }
427 #if defined(HAVE_SETLOCALE) && defined(LC_CTYPE)
428   if (old_lc)
429     {
430       setlocale (LC_CTYPE, old_lc);
431       m_free (old_lc);
432     }
433 #endif
434   if (rc)
435     return rc;
436
437 #if defined(HAVE_SETLOCALE) && defined(LC_MESSAGES)
438   old_lc = setlocale (LC_MESSAGES, NULL);
439   if (old_lc)
440     old_lc = m_strdup (old_lc);
441   dft_lc = setlocale (LC_MESSAGES, "");
442 #endif
443   if (opt.lc_messages || (dft_ttyname && dft_lc))
444     {
445       rc = agent_send_option (fd, "lc-messages",
446                               opt.lc_messages ? opt.lc_messages : dft_lc);
447     }
448 #if defined(HAVE_SETLOCALE) && defined(LC_MESSAGES)
449   if (old_lc)
450     {
451       setlocale (LC_MESSAGES, old_lc);
452       m_free (old_lc);
453     }
454 #endif
455   return rc;
456 }
457 #endif /*!_WIN32*/
458
459
460 /*
461  * Open a connection to the agent and send the magic string
462  * Returns: -1 on error or an filedescriptor for urther processing
463  */
464
465 static int
466 agent_open (int *ret_prot)
467 {
468 #if defined (_WIN32)
469     int fd;
470     char *infostr, *p;
471     HANDLE h;
472     char pidstr[128];
473
474     *ret_prot = 0;
475     if ( !(infostr = read_w32_registry_string(NULL, "Software\\GNU\\GnuPG",
476                                               "agentPID")) 
477          || *infostr == '0') {
478         log_error( _("gpg-agent is not available in this session\n"));
479         return -1;
480     }
481     free(infostr);
482     
483     sprintf(pidstr, "%u", (unsigned int)GetCurrentProcessId());
484     if (write_w32_registry_string(NULL, "Software\\GNU\\GnuPG",
485                                   "agentCID", pidstr)) {
486         log_error( _("can't set client pid for the agent\n") );
487         return -1;
488     }
489     h = OpenEvent(EVENT_ALL_ACCESS, FALSE, "gpg_agent");
490     SetEvent(h);
491     Sleep(50); /* some time for the server */ 
492     if ( !(p = read_w32_registry_string(NULL, "Software\\GNU\\GnuPG",
493                                         "agentReadFD")) ) {
494         log_error( _("can't get server read FD for the agent\n") );
495         return -1;
496     }
497     read_fd = atol(p);
498     free(p);    
499     if ( !(p = read_w32_registry_string(NULL, "Software\\GNU\\GnuPG",
500                                         "agentWriteFD")) ) {
501         log_error ( _("can't get server write FD for the agent\n") );
502         return -1;
503     }
504     write_fd = atol(p);
505     free(p);
506     fd = 0;
507
508     if ( writen ( fd, "GPGA\0\0\0\x01", 8 ) ) {
509         fd = -1;
510     }
511 #else /* Posix */
512
513     int fd;
514     char *infostr, *p;
515     struct sockaddr_un client_addr;
516     size_t len;
517     int prot;
518
519     if (opt.gpg_agent_info)
520       infostr = m_strdup (opt.gpg_agent_info);
521     else
522       {
523         infostr = getenv ( "GPG_AGENT_INFO" );
524         if ( !infostr ) {
525           log_error (_("gpg-agent is not available in this session\n"));
526           opt.use_agent = 0;
527           return -1;
528         }
529         infostr = m_strdup ( infostr );
530       }
531
532     if ( !(p = strchr ( infostr, ':')) || p == infostr
533          || (p-infostr)+1 >= sizeof client_addr.sun_path ) {
534         log_error( _("malformed GPG_AGENT_INFO environment variable\n"));
535         m_free (infostr );
536         opt.use_agent = 0;
537         return -1;
538     }
539     *p++ = 0;
540     /* See whether this is the new gpg-agent using the Assuna protocl.
541        This agent identifies itself by have an info string with a
542        version number in the 3rd field. */
543     while (*p && *p != ':')
544       p++;
545     prot = *p? atoi (p+1) : 0;
546     if ( prot < 0 || prot > 1) {
547         log_error (_("gpg-agent protocol version %d is not supported\n"),prot);
548         m_free (infostr );
549         opt.use_agent = 0;
550         return -1;
551     }
552     *ret_prot = prot;
553        
554     if( (fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1 ) {
555         log_error ("can't create socket: %s\n", strerror(errno) );
556         m_free (infostr );
557         opt.use_agent = 0;
558         return -1;
559     }
560     
561     memset( &client_addr, 0, sizeof client_addr );
562     client_addr.sun_family = AF_UNIX;
563     strcpy( client_addr.sun_path, infostr );
564     len = offsetof (struct sockaddr_un, sun_path)
565         + strlen(client_addr.sun_path) + 1;
566     
567     if( connect( fd, (struct sockaddr*)&client_addr, len ) == -1 ) {
568         log_error ( _("can't connect to `%s': %s\n"), 
569                     infostr, strerror (errno) );
570         m_free (infostr );
571         close (fd );
572         opt.use_agent = 0;
573         return -1;
574     }
575     m_free (infostr);
576
577     if (!prot) {
578         if ( writen ( fd, "GPGA\0\0\0\x01", 8 ) ) {
579           close (fd);
580           fd = -1;
581         }
582     }
583     else { /* assuan based gpg-agent */
584       char line[200];
585       int nread;
586
587       nread = readline (fd, line, DIM(line));
588       if (nread < 3 || !(line[0] == 'O' && line[1] == 'K'
589                          && (line[2] == '\n' || line[2] == ' ')) ) {
590         log_error ( _("communication problem with gpg-agent\n"));
591         close (fd );
592         opt.use_agent = 0;
593         return -1;
594       }
595
596       if (agent_send_all_options (fd)) {
597         log_error (_("problem with the agent - disabling agent use\n"));
598         close (fd);
599         opt.use_agent = 0;
600         return -1;
601       }
602         
603     }
604 #endif
605
606     return fd;
607 }
608
609
610 static void
611 agent_close ( int fd )
612 {
613 #if defined (_WIN32)
614     HANDLE h = OpenEvent(EVENT_ALL_ACCESS, FALSE, "gpg_agent");
615     ResetEvent(h);
616 #else
617     close (fd);
618 #endif
619 }
620 #endif /* !__riscos__ */
621
622
623
624 /*
625  * Ask the GPG Agent for the passphrase.
626  * Mode 0:  Allow cached passphrase
627  *      1:  No cached passphrase FIXME: Not really implemented
628  *      2:  Ditto, but change the text to "repeat entry"
629  *
630  * Note that TRYAGAIN_TEXT must not be translated.  If canceled is not
631  * NULL, the function does set it to 1 if the user canceled the
632  * operation.
633  */
634 static char *
635 agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text,
636                        const char *custom_description,
637                        const char *custom_prompt, int *canceled)
638 {
639 #if defined(__riscos__)
640   return NULL;
641 #else
642   size_t n;
643   char *atext = NULL;
644   char buf[50];
645   int fd = -1;
646   int nread;
647   u32 reply;
648   char *pw = NULL;
649   PKT_public_key *pk = m_alloc_clear( sizeof *pk );
650   byte fpr[MAX_FINGERPRINT_LEN];
651   int have_fpr = 0;
652   int prot;
653   char *orig_codeset = NULL;
654
655   log_debug ("agent_get_passphrase tryagin='%s' prompt='%s'\n", tryagain_text, custom_prompt);
656   if (canceled)
657     *canceled = 0;
658
659 #if MAX_FINGERPRINT_LEN < 20
660 #error agent needs a 20 byte fingerprint
661 #endif
662
663   memset (fpr, 0, MAX_FINGERPRINT_LEN );
664   if( keyid && get_pubkey( pk, keyid ) )
665     {
666       free_public_key( pk );      
667       pk = NULL; /* oops: no key for some reason */
668     }
669   
670 #ifdef ENABLE_NLS
671   /* The Assuan agent protol requires us to transmit utf-8 strings */
672   orig_codeset = bind_textdomain_codeset (PACKAGE, NULL);
673 #ifdef HAVE_LANGINFO_CODESET
674   if (!orig_codeset)
675     orig_codeset = nl_langinfo (CODESET);
676 #endif
677   if (orig_codeset)
678     { /* We only switch when we are able to restore the codeset later. */
679       orig_codeset = m_strdup (orig_codeset);
680       if (!bind_textdomain_codeset (PACKAGE, "utf-8"))
681         orig_codeset = NULL; 
682     }
683 #endif
684
685   if ( (fd = agent_open (&prot)) == -1 ) 
686     goto failure;
687
688   if (custom_description)
689     atext = native_to_utf8 (custom_description);
690   else if ( !mode && pk && keyid )
691     { 
692       char *uid;
693       size_t uidlen;
694       const char *algo_name = pubkey_algo_to_string ( pk->pubkey_algo );
695       const char *timestr;
696       char *maink;
697       
698       if ( !algo_name )
699         algo_name = "?";
700
701 #define KEYIDSTRING _(" (main key ID %s)")
702
703       maink = m_alloc ( strlen (KEYIDSTRING) + keystrlen() + 20 );
704       if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
705           && keyid[1] != keyid[3] )
706         sprintf( maink, KEYIDSTRING, keystr(&keyid[2]) );
707       else
708         *maink = 0;
709       
710       uid = get_user_id ( keyid, &uidlen ); 
711       timestr = strtimestamp (pk->timestamp);
712
713 #undef KEYIDSTRING
714
715 #define PROMPTSTRING _("You need a passphrase to unlock the secret" \
716                        " key for user:\n" \
717                        "\"%.*s\"\n" \
718                        "%u-bit %s key, ID %s, created %s%s\n" )
719
720       atext = m_alloc ( 100 + strlen (PROMPTSTRING)  
721                         + uidlen + 15 + strlen(algo_name) + keystrlen()
722                         + strlen (timestr) + strlen (maink) );
723       sprintf (atext, PROMPTSTRING,
724                (int)uidlen, uid,
725                nbits_from_pk (pk), algo_name, keystr(&keyid[0]), timestr,
726                maink  );
727       m_free (uid);
728       m_free (maink);
729
730 #undef PROMPTSTRING
731
732       { 
733         size_t dummy;
734         fingerprint_from_pk( pk, fpr, &dummy );
735         have_fpr = 1;
736       }
737       
738     }
739   else if (mode == 2 ) 
740     atext = m_strdup ( _("Repeat passphrase\n") );
741   else
742     atext = m_strdup ( _("Enter passphrase\n") );
743                 
744   if (!prot)
745     { /* old style protocol */
746       n = 4 + 20 + strlen (atext);
747       u32tobuf (buf, n );
748       u32tobuf (buf+4, GPGA_PROT_GET_PASSPHRASE );
749       memcpy (buf+8, fpr, 20 );
750       if ( writen ( fd, buf, 28 ) || writen ( fd, atext, strlen (atext) ) ) 
751         goto failure;
752       m_free (atext); atext = NULL;
753       
754       /* get response */
755       if ( readn ( fd, buf, 12, &nread ) ) 
756         goto failure;
757       
758       if ( nread < 8 ) 
759         {
760           log_error ( "response from agent too short\n" );
761           goto failure;
762         }
763       n = buftou32 ( buf );
764       reply = buftou32 ( buf + 4 );
765       if ( reply == GPGA_PROT_GOT_PASSPHRASE ) 
766         {
767           size_t pwlen;
768           size_t nn;
769           
770           if ( nread < 12 || n < 8 ) 
771             {
772               log_error ( "response from agent too short\n" );
773               goto failure;
774             }
775           pwlen = buftou32 ( buf + 8 );
776           nread -= 12;
777           n -= 8;
778           if ( pwlen > n || n > 1000 ) 
779             {
780               log_error (_("passphrase too long\n"));
781               /* or protocol error */
782               goto failure;
783             }
784           /* we read the whole block in one chunk to give no hints
785            * on how long the passhrase actually is - this wastes some bytes
786            * but because we already have this padding we should not loosen
787            * this by issuing 2 read calls */
788           pw = m_alloc_secure ( n+1 );
789           if ( readn ( fd, pw, n, &nn ) )
790             goto failure;
791           if ( n != nn ) 
792             {
793               log_error (_("invalid response from agent\n"));
794               goto failure;           
795             }
796           pw[pwlen] = 0; /* make a C String */
797           agent_close (fd);
798           free_public_key( pk );
799 #ifdef ENABLE_NLS
800           if (orig_codeset)
801             bind_textdomain_codeset (PACKAGE, orig_codeset);
802 #endif
803           m_free (orig_codeset);
804           return pw;
805         }
806       else if ( reply == GPGA_PROT_CANCELED ) 
807         {
808           log_info ( _("cancelled by user\n") );
809           if (canceled)
810             *canceled = 1;
811         }
812       else 
813         log_error ( _("problem with the agent: agent returns 0x%lx\n"),
814                     (ulong)reply );
815     }
816   else
817     { /* The new Assuan protocol */
818       char *line, *p;
819       const unsigned char *s;
820       int i; 
821
822       if (!tryagain_text)
823         tryagain_text = "X";
824       else
825         tryagain_text = _(tryagain_text);
826
827       /* We allocate 2 time the needed space for atext so that there
828          is enough space for escaping */
829       line = m_alloc (15 + 46 
830                       + 3*strlen (tryagain_text)
831                       + 3*strlen (atext)
832                       + 3*strlen (custom_prompt? custom_prompt:"")
833                       + 2);
834       strcpy (line, "GET_PASSPHRASE ");
835       p = line+15;
836       if (!mode && have_fpr)
837         {
838           for (i=0; i < 20; i++, p +=2 )
839             sprintf (p, "%02X", fpr[i]);
840         }
841       else
842         *p++ = 'X'; /* no caching */
843       *p++ = ' ';
844       for (i=0, s=tryagain_text; *s; s++)
845         {
846           if (*s < ' ' || *s == '+')
847             {
848               sprintf (p, "%%%02X", *s);
849               p += 3;
850             }
851           else if (*s == ' ')
852             *p++ = '+';
853           else
854             *p++ = *s;
855         }
856       *p++ = ' ';
857
858       /* The prompt.  */
859       if (custom_prompt)
860         {
861           char *tmp = native_to_utf8 (custom_prompt);
862           for (i=0, s=tmp; *s; s++)
863             {
864               if (*s < ' ' || *s == '+')
865                 {
866                   sprintf (p, "%%%02X", *s);
867                   p += 3;
868                 }
869               else if (*s == ' ')
870                 *p++ = '+';
871               else
872                 *p++ = *s;
873             }
874           xfree (tmp);
875         }
876       else
877         *p++ = 'X'; /* Use the standard prompt */
878
879       *p++ = ' ';
880       /* copy description */
881       for (i=0, s= atext; *s; s++)
882         {
883           if (*s < ' ' || *s == '+')
884             {
885               sprintf (p, "%%%02X", *s);
886               p += 3;
887             }
888           else if (*s == ' ')
889             *p++ = '+';
890           else
891             *p++ = *s;
892         }
893       *p++ = '\n';
894       i = writen (fd, line, p - line);
895       m_free (line);
896       if (i)
897         goto failure;
898       m_free (atext); atext = NULL;
899       
900       /* get response */
901       pw = m_alloc_secure (500);
902       nread = readline (fd, pw, 499);
903       if (nread < 3)
904         goto failure;
905       
906       if (pw[0] == 'O' && pw[1] == 'K' && pw[2] == ' ') 
907         { /* we got a passphrase - convert it back from hex */
908           size_t pwlen = 0;
909
910           for (i=3; i < nread && hexdigitp (pw+i); i+=2)
911             pw[pwlen++] = xtoi_2 (pw+i);
912           pw[pwlen] = 0; /* make a C String */
913           agent_close (fd);
914           free_public_key( pk );
915 #ifdef ENABLE_NLS
916           if (orig_codeset)
917             bind_textdomain_codeset (PACKAGE, orig_codeset);
918 #endif
919           m_free (orig_codeset);
920           return pw;
921         }
922       else if (nread > 4 && !memcmp (pw, "ERR ", 4)
923                && (0xffff & strtoul (&pw[4], NULL, 0)) == 99)
924         {
925           /* 99 is GPG_ERR_CANCELED.  FIXME: Check tail and overflow,
926              and use gpg-error.  */
927           log_info (_("cancelled by user\n") );
928           if (canceled)
929             *canceled = 1;
930         }
931       else 
932         {
933           log_error (_("problem with the agent - disabling agent use\n"));
934           opt.use_agent = 0;
935         }
936     }
937       
938         
939  failure:
940 #ifdef ENABLE_NLS
941   if (orig_codeset)
942     bind_textdomain_codeset (PACKAGE, orig_codeset);
943 #endif
944   m_free (atext);
945   if ( fd != -1 )
946     agent_close (fd);
947   m_free (pw );
948   free_public_key( pk );
949   
950   return NULL;
951 #endif /* Posix or W32 */
952 }
953
954 /*
955  * Clear the cached passphrase
956  */
957 void
958 passphrase_clear_cache ( u32 *keyid, int algo )
959 {
960 #if defined(__riscos__)
961   return ;
962 #else
963   size_t n;
964   char buf[200];
965   int fd = -1;
966   size_t nread;
967   u32 reply;
968   PKT_public_key *pk;
969   byte fpr[MAX_FINGERPRINT_LEN];
970   int prot;
971   
972 #if MAX_FINGERPRINT_LEN < 20
973 #error agent needs a 20 byte fingerprint
974 #endif
975     
976   if (!opt.use_agent)
977     return;
978   
979   pk = m_alloc_clear ( sizeof *pk );
980   memset (fpr, 0, MAX_FINGERPRINT_LEN );
981   if( !keyid || get_pubkey( pk, keyid ) )
982     {
983       log_debug ("oops, no key in passphrase_clear_cache\n");
984       goto failure; /* oops: no key for some reason */
985     }
986   
987   {
988     size_t dummy;
989     fingerprint_from_pk( pk, fpr, &dummy );
990   }
991     
992   if ( (fd = agent_open (&prot)) == -1 ) 
993     goto failure;
994
995   if (!prot)
996     {
997       n = 4 + 20;
998       u32tobuf (buf, n );
999       u32tobuf (buf+4, GPGA_PROT_CLEAR_PASSPHRASE );
1000       memcpy (buf+8, fpr, 20 );
1001       if ( writen ( fd, buf, 28 ) )  
1002         goto failure;
1003       
1004       /* get response */
1005       if ( readn ( fd, buf, 8, &nread ) ) 
1006         goto failure;
1007       
1008       if ( nread < 8 ) {
1009         log_error ( "response from agent too short\n" );
1010         goto failure;
1011       }
1012       
1013       reply = buftou32 ( buf + 4 );
1014       if ( reply != GPGA_PROT_OKAY && reply != GPGA_PROT_NO_PASSPHRASE )
1015         {
1016           log_error ( _("problem with the agent: agent returns 0x%lx\n"),
1017                       (ulong)reply );
1018         }
1019     }
1020   else 
1021     { /* The assuan protocol */
1022       char *line, *p;
1023       int i; 
1024
1025       line = m_alloc (17 + 40 + 2);
1026       strcpy (line, "CLEAR_PASSPHRASE ");
1027       p = line+17;
1028       for (i=0; i < 20; i++, p +=2 )
1029         sprintf (p, "%02X", fpr[i]);
1030       *p++ = '\n';
1031       i = writen (fd, line, p - line);
1032       m_free (line);
1033       if (i)
1034         goto failure;
1035       
1036       /* get response */
1037       nread = readline (fd, buf, DIM(buf)-1);
1038       if (nread < 3)
1039         goto failure;
1040       
1041       if (buf[0] == 'O' && buf[1] == 'K' && (buf[2] == ' ' || buf[2] == '\n')) 
1042         ;
1043       else 
1044         {
1045           log_error (_("problem with the agent - disabling agent use\n"));
1046           opt.use_agent = 0;
1047         }
1048     }
1049         
1050  failure:
1051   if (fd != -1)
1052     agent_close (fd);
1053   free_public_key( pk );
1054 #endif /* Posix or W32 */
1055 }
1056
1057
1058
1059
1060 /****************
1061  * Ask for a passphrase and return that string.
1062  */
1063 char *
1064 ask_passphrase (const char *description,
1065                 const char *tryagain_text,
1066                 const char *promptid,
1067                 const char *prompt, int *canceled)
1068 {
1069   char *pw = NULL;
1070   
1071   if (canceled)
1072     *canceled = 0;
1073
1074   if (!opt.batch && description)
1075     tty_printf ("\n%s\n",description);
1076                
1077  agent_died:
1078   if ( opt.use_agent ) 
1079     {
1080       pw = agent_get_passphrase (NULL, 0,
1081                                  tryagain_text, description, prompt,
1082                                  canceled );
1083       if (!pw)
1084         {
1085           if (!opt.use_agent)
1086             goto agent_died;
1087           pw = NULL;
1088         }
1089     }
1090   else if (fd_passwd) 
1091     {
1092       pw = m_alloc_secure (strlen(fd_passwd)+1);
1093       strcpy (pw, fd_passwd);
1094     }
1095   else if (opt.batch)
1096     {
1097       log_error(_("can't query passphrase in batch mode\n"));
1098       pw = NULL;
1099     }
1100   else {
1101     if (tryagain_text)
1102       tty_printf(_("%s.\n"), tryagain_text);
1103     pw = cpr_get_hidden(promptid? promptid : "passphrase.ask",
1104                         prompt?prompt : _("Enter passphrase: ") );
1105     tty_kill_prompt();
1106   }
1107
1108   if (!pw || !*pw)
1109     write_status( STATUS_MISSING_PASSPHRASE );
1110
1111   return pw;
1112 }
1113
1114
1115 /* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
1116  * KEYID and PUBKEY_ALGO to prompt the user.
1117
1118    MODE 0:  Allow cached passphrase
1119         1:  Ignore cached passphrase 
1120         2:  Ditto, but change the text to "repeat entry"
1121 */
1122 DEK *
1123 passphrase_to_dek( u32 *keyid, int pubkey_algo,
1124                    int cipher_algo, STRING2KEY *s2k, int mode,
1125                    const char *tryagain_text, int *canceled)
1126 {
1127     char *pw = NULL;
1128     DEK *dek;
1129     STRING2KEY help_s2k;
1130
1131     if (canceled)
1132       *canceled = 0;
1133
1134     if( !s2k ) {
1135         /* This is used for the old rfc1991 mode 
1136          * Note: This must match the code in encode.c with opt.rfc1991 set */
1137         s2k = &help_s2k;
1138         s2k->mode = 0;
1139         s2k->hash_algo = S2K_DIGEST_ALGO;
1140     }
1141
1142     /* If we do not have a passphrase available in NEXT_PW and status
1143        information are request, we print them now. */
1144     if( !next_pw && is_status_enabled() ) {
1145         char buf[50];
1146  
1147         if( keyid ) {
1148             u32 used_kid[2];
1149             char *us;
1150
1151             if( keyid[2] && keyid[3] ) {
1152                 used_kid[0] = keyid[2];
1153                 used_kid[1] = keyid[3];
1154             }
1155             else {
1156                 used_kid[0] = keyid[0];
1157                 used_kid[1] = keyid[1];
1158             }
1159
1160             us = get_long_user_id_string( keyid );
1161             write_status_text( STATUS_USERID_HINT, us );
1162             m_free(us);
1163
1164             sprintf( buf, "%08lX%08lX %08lX%08lX %d 0",
1165                      (ulong)keyid[0], (ulong)keyid[1],
1166                      (ulong)used_kid[0], (ulong)used_kid[1],
1167                      pubkey_algo );
1168                      
1169             write_status_text( STATUS_NEED_PASSPHRASE, buf );
1170         }
1171         else {
1172             sprintf( buf, "%d %d %d", cipher_algo, s2k->mode, s2k->hash_algo );
1173             write_status_text( STATUS_NEED_PASSPHRASE_SYM, buf );
1174         }
1175     }
1176
1177     /* If we do have a keyID, we do not have a passphrase available in
1178        NEXT_PW, we are not running in batch mode and we do not want to
1179        ignore the passphrase cache (mode!=1), print a prompt with
1180        information on that key. */
1181     if( keyid && !opt.batch && !next_pw && mode!=1 ) {
1182         PKT_public_key *pk = m_alloc_clear( sizeof *pk );
1183         char *p;
1184
1185         p=get_user_id_native(keyid);
1186         tty_printf("\n");
1187         tty_printf(_("You need a passphrase to unlock the secret key for\n"
1188                      "user: \"%s\"\n"),p);
1189         m_free(p);
1190
1191         if( !get_pubkey( pk, keyid ) ) {
1192             const char *s = pubkey_algo_to_string( pk->pubkey_algo );
1193             tty_printf( _("%u-bit %s key, ID %s, created %s"),
1194                        nbits_from_pk( pk ), s?s:"?", keystr(keyid),
1195                        strtimestamp(pk->timestamp) );
1196             if( keyid[2] && keyid[3] && keyid[0] != keyid[2]
1197                                      && keyid[1] != keyid[3] )
1198               {
1199                 if(keystrlen()>10)
1200                   {
1201                     tty_printf("\n");
1202                     tty_printf(_("         (subkey on main key ID %s)"),
1203                                keystr(&keyid[2]) );
1204                   }
1205                 else
1206                   tty_printf( _(" (main key ID %s)"), keystr(&keyid[2]) );
1207               }
1208             tty_printf("\n");
1209         }
1210
1211         tty_printf("\n");
1212         free_public_key( pk );
1213     }
1214
1215  agent_died:
1216     if( next_pw ) {
1217         /* Simply return the passphrase we already have in NEXT_PW. */
1218         pw = next_pw;
1219         next_pw = NULL;
1220     }
1221     else if ( opt.use_agent ) {
1222       /* Divert to the gpg-agent. */
1223         pw = agent_get_passphrase ( keyid, mode == 2? 1: 0,
1224                                     tryagain_text, NULL, NULL, canceled );
1225         if (!pw)
1226           {
1227             if (!opt.use_agent)
1228               goto agent_died;
1229             pw = m_strdup ("");
1230           }
1231         if( *pw && mode == 2 ) {
1232           char *pw2 = agent_get_passphrase ( keyid, 2, NULL, NULL,
1233                                                NULL, canceled );
1234             if (!pw2)
1235               {
1236                 if (!opt.use_agent)
1237                   {
1238                     m_free (pw);
1239                     pw = NULL;
1240                     goto agent_died;
1241                   }
1242                 pw2 = m_strdup ("");
1243               }
1244             if( strcmp(pw, pw2) ) {
1245                 m_free(pw2);
1246                 m_free(pw);
1247                 return NULL;
1248             }
1249             m_free(pw2);
1250         }
1251     }
1252     else if( fd_passwd ) {
1253         /* Return the passphrase we have store in FD_PASSWD. */
1254         pw = m_alloc_secure( strlen(fd_passwd)+1 );
1255         strcpy( pw, fd_passwd );
1256     }
1257     else if( opt.batch )
1258       {
1259         log_error(_("can't query passphrase in batch mode\n"));
1260         pw = m_strdup( "" ); /* return an empty passphrase */
1261       }
1262     else {
1263         /* Read the passphrase from the tty or the command-fd. */
1264         pw = cpr_get_hidden("passphrase.enter", _("Enter passphrase: ") );
1265         tty_kill_prompt();
1266         if( mode == 2 && !cpr_enabled() ) {
1267             char *pw2 = cpr_get_hidden("passphrase.repeat",
1268                                        _("Repeat passphrase: ") );
1269             tty_kill_prompt();
1270             if( strcmp(pw, pw2) ) {
1271                 m_free(pw2);
1272                 m_free(pw);
1273                 return NULL;
1274             }
1275             m_free(pw2);
1276         }
1277     }
1278
1279     if( !pw || !*pw )
1280         write_status( STATUS_MISSING_PASSPHRASE );
1281
1282     /* Hash the passphrase and store it in a newly allocated DEK
1283        object.  Keep a copy of the passphrase in LAST_PW for use by
1284        get_last_passphrase(). */
1285     dek = m_alloc_secure_clear ( sizeof *dek );
1286     dek->algo = cipher_algo;
1287     if( !*pw && mode == 2 )
1288         dek->keylen = 0;
1289     else
1290         hash_passphrase( dek, pw, s2k, mode==2 );
1291     m_free(last_pw);
1292     last_pw = pw;
1293     return dek;
1294 }
1295
1296
1297 /****************
1298  * Hash a passphrase using the supplied s2k. If create is true, create
1299  * a new salt or what else must be filled into the s2k for a new key.
1300  * always needs: dek->algo, s2k->mode, s2k->hash_algo.
1301  */
1302 static void
1303 hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
1304 {
1305     MD_HANDLE md;
1306     int pass, i;
1307     int used = 0;
1308     int pwlen = strlen(pw);
1309
1310     assert( s2k->hash_algo );
1311     dek->keylen = cipher_get_keylen( dek->algo ) / 8;
1312     if( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
1313         BUG();
1314
1315     md = md_open( s2k->hash_algo, 1);
1316     for(pass=0; used < dek->keylen ; pass++ ) {
1317         if( pass ) {
1318             md_reset(md);
1319             for(i=0; i < pass; i++ ) /* preset the hash context */
1320                 md_putc(md, 0 );
1321         }
1322
1323         if( s2k->mode == 1 || s2k->mode == 3 ) {
1324             int len2 = pwlen + 8;
1325             ulong count = len2;
1326
1327             if( create && !pass ) {
1328                 randomize_buffer(s2k->salt, 8, 1);
1329                 if( s2k->mode == 3 )
1330                     s2k->count = 96; /* 65536 iterations */
1331             }
1332
1333             if( s2k->mode == 3 ) {
1334                 count = (16ul + (s2k->count & 15)) << ((s2k->count >> 4) + 6);
1335                 if( count < len2 )
1336                     count = len2;
1337             }
1338             /* a little bit complicated because we need a ulong for count */
1339             while( count > len2 ) { /* maybe iterated+salted */
1340                 md_write( md, s2k->salt, 8 );
1341                 md_write( md, pw, pwlen );
1342                 count -= len2;
1343             }
1344             if( count < 8 )
1345                 md_write( md, s2k->salt, count );
1346             else {
1347                 md_write( md, s2k->salt, 8 );
1348                 count -= 8;
1349                 md_write( md, pw, count );
1350             }
1351         }
1352         else
1353             md_write( md, pw, pwlen );
1354         md_final( md );
1355         i = md_digest_length( s2k->hash_algo );
1356         if( i > dek->keylen - used )
1357             i = dek->keylen - used;
1358         memcpy( dek->key+used, md_read(md, s2k->hash_algo), i );
1359         used += i;
1360     }
1361     md_close(md);
1362 }
1363