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