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