* keygen.c (do_add_key_flags, parse_parameter_usage): Add support
[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  * Ask for a passphrase and return that string.
1008  */
1009 char *
1010 ask_passphrase (const char *description, const char *prompt, int *canceled)
1011 {
1012   char *pw = NULL;
1013   
1014   if (canceled)
1015     *canceled = 0;
1016
1017   if (is_status_enabled())
1018     write_status_text( STATUS_NEED_PASSPHRASE_SYM, "0 0 0");
1019
1020   if (!opt.batch && description)
1021     tty_printf ("\n%s\n",description);
1022                
1023  agent_died:
1024   if ( opt.use_agent ) 
1025     {
1026       pw = agent_get_passphrase (NULL, 0,  description, canceled );
1027       if (!pw)
1028         {
1029           if (!opt.use_agent)
1030             goto agent_died;
1031           pw = NULL;
1032         }
1033     }
1034   else if (fd_passwd) 
1035     {
1036       pw = m_alloc_secure (strlen(fd_passwd)+1);
1037       strcpy (pw, fd_passwd);
1038     }
1039   else if (opt.batch)
1040     {
1041       log_error(_("can't query password in batchmode\n"));
1042       pw = NULL;
1043     }
1044   else {
1045     pw = cpr_get_hidden("passphrase.ask",
1046                         prompt?prompt : _("Enter passphrase: ") );
1047     tty_kill_prompt();
1048   }
1049
1050   if (!pw || !*pw)
1051     write_status( STATUS_MISSING_PASSPHRASE );
1052
1053   return pw;
1054 }
1055
1056
1057
1058 DEK *
1059 passphrase_to_dek( u32 *keyid, int pubkey_algo,
1060                    int cipher_algo, STRING2KEY *s2k, int mode,
1061                    const char *tryagain_text, int *canceled)
1062 {
1063     char *pw = NULL;
1064     DEK *dek;
1065     STRING2KEY help_s2k;
1066
1067     if (canceled)
1068       *canceled = 0;
1069
1070     if( !s2k ) {
1071         /* This is used for the old rfc1991 mode 
1072          * Note: This must match the code in encode.c with opt.rfc1991 set */
1073         s2k = &help_s2k;
1074         s2k->mode = 0;
1075         s2k->hash_algo = opt.s2k_digest_algo;
1076     }
1077
1078     if( !next_pw && is_status_enabled() ) {
1079         char buf[50];
1080
1081         if( keyid ) {
1082             u32 used_kid[2];
1083             char *us;
1084
1085             if( keyid[2] && keyid[3] ) {
1086                 used_kid[0] = keyid[2];
1087                 used_kid[1] = keyid[3];
1088             }
1089             else {
1090                 used_kid[0] = keyid[0];
1091                 used_kid[1] = keyid[1];
1092             }
1093
1094             us = get_long_user_id_string( keyid );
1095             write_status_text( STATUS_USERID_HINT, us );
1096             m_free(us);
1097
1098             sprintf( buf, "%08lX%08lX %08lX%08lX %d 0",
1099                      (ulong)keyid[0], (ulong)keyid[1],
1100                      (ulong)used_kid[0], (ulong)used_kid[1],
1101                      pubkey_algo );
1102                      
1103             write_status_text( STATUS_NEED_PASSPHRASE, buf );
1104         }
1105         else {
1106             sprintf( buf, "%d %d %d", cipher_algo, s2k->mode, s2k->hash_algo );
1107             write_status_text( STATUS_NEED_PASSPHRASE_SYM, buf );
1108         }
1109     }
1110
1111     if( keyid && !opt.batch && !next_pw && mode!=1 ) {
1112         PKT_public_key *pk = m_alloc_clear( sizeof *pk );
1113         size_t n;
1114         char *p;
1115
1116         tty_printf(_("\nYou need a passphrase to unlock the secret key for\n"
1117                      "user: \"") );
1118         p = get_user_id( keyid, &n );
1119         tty_print_utf8_string( p, n );
1120         m_free(p);
1121         tty_printf("\"\n");
1122
1123         if( !get_pubkey( pk, keyid ) ) {
1124             const char *s = pubkey_algo_to_string( pk->pubkey_algo );
1125             tty_printf( _("%u-bit %s key, ID %08lX, created %s"),
1126                        nbits_from_pk( pk ), s?s:"?", (ulong)keyid[1],
1127                        strtimestamp(pk->timestamp) );
1128             if( keyid[2] && keyid[3] && keyid[0] != keyid[2]
1129                                      && keyid[1] != keyid[3] )
1130                 tty_printf( _(" (main key ID %08lX)"), (ulong)keyid[3] );
1131             tty_printf("\n");
1132         }
1133
1134         tty_printf("\n");
1135         free_public_key( pk );
1136     }
1137
1138  agent_died:
1139     if( next_pw ) {
1140         pw = next_pw;
1141         next_pw = NULL;
1142     }
1143     else if ( opt.use_agent ) {
1144         pw = agent_get_passphrase ( keyid, mode == 2? 1: 0,
1145                                     tryagain_text, canceled );
1146         if (!pw)
1147           {
1148             if (!opt.use_agent)
1149               goto agent_died;
1150             pw = m_strdup ("");
1151           }
1152         if( *pw && mode == 2 ) {
1153             char *pw2 = agent_get_passphrase ( keyid, 2, NULL, canceled );
1154             if (!pw2)
1155               {
1156                 if (!opt.use_agent)
1157                   {
1158                     m_free (pw);
1159                     pw = NULL;
1160                     goto agent_died;
1161                   }
1162                 pw2 = m_strdup ("");
1163               }
1164             if( strcmp(pw, pw2) ) {
1165                 m_free(pw2);
1166                 m_free(pw);
1167                 return NULL;
1168             }
1169             m_free(pw2);
1170         }
1171     }
1172     else if( fd_passwd ) {
1173         pw = m_alloc_secure( strlen(fd_passwd)+1 );
1174         strcpy( pw, fd_passwd );
1175     }
1176     else if( opt.batch ) {
1177         log_error(_("can't query password in batchmode\n"));
1178         pw = m_strdup( "" ); /* return an empty passphrase */
1179     }
1180     else {
1181         pw = cpr_get_hidden("passphrase.enter", _("Enter passphrase: ") );
1182         tty_kill_prompt();
1183         if( mode == 2 && !cpr_enabled() ) {
1184             char *pw2 = cpr_get_hidden("passphrase.repeat",
1185                                        _("Repeat passphrase: ") );
1186             tty_kill_prompt();
1187             if( strcmp(pw, pw2) ) {
1188                 m_free(pw2);
1189                 m_free(pw);
1190                 return NULL;
1191             }
1192             m_free(pw2);
1193         }
1194     }
1195
1196     if( !pw || !*pw )
1197         write_status( STATUS_MISSING_PASSPHRASE );
1198
1199     dek = m_alloc_secure_clear ( sizeof *dek );
1200     dek->algo = cipher_algo;
1201     if( !*pw && mode == 2 )
1202         dek->keylen = 0;
1203     else
1204         hash_passphrase( dek, pw, s2k, mode==2 );
1205     m_free(last_pw);
1206     last_pw = pw;
1207     return dek;
1208 }
1209
1210
1211 /****************
1212  * Hash a passphrase using the supplied s2k. If create is true, create
1213  * a new salt or what else must be filled into the s2k for a new key.
1214  * always needs: dek->algo, s2k->mode, s2k->hash_algo.
1215  */
1216 static void
1217 hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
1218 {
1219     MD_HANDLE md;
1220     int pass, i;
1221     int used = 0;
1222     int pwlen = strlen(pw);
1223
1224     assert( s2k->hash_algo );
1225     dek->keylen = cipher_get_keylen( dek->algo ) / 8;
1226     if( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
1227         BUG();
1228
1229     md = md_open( s2k->hash_algo, 1);
1230     for(pass=0; used < dek->keylen ; pass++ ) {
1231         if( pass ) {
1232             md_reset(md);
1233             for(i=0; i < pass; i++ ) /* preset the hash context */
1234                 md_putc(md, 0 );
1235         }
1236
1237         if( s2k->mode == 1 || s2k->mode == 3 ) {
1238             int len2 = pwlen + 8;
1239             ulong count = len2;
1240
1241             if( create && !pass ) {
1242                 randomize_buffer(s2k->salt, 8, 1);
1243                 if( s2k->mode == 3 )
1244                     s2k->count = 96; /* 65536 iterations */
1245             }
1246
1247             if( s2k->mode == 3 ) {
1248                 count = (16ul + (s2k->count & 15)) << ((s2k->count >> 4) + 6);
1249                 if( count < len2 )
1250                     count = len2;
1251             }
1252             /* a little bit complicated because we need a ulong for count */
1253             while( count > len2 ) { /* maybe iterated+salted */
1254                 md_write( md, s2k->salt, 8 );
1255                 md_write( md, pw, pwlen );
1256                 count -= len2;
1257             }
1258             if( count < 8 )
1259                 md_write( md, s2k->salt, count );
1260             else {
1261                 md_write( md, s2k->salt, 8 );
1262                 count -= 8;
1263                 md_write( md, pw, count );
1264             }
1265         }
1266         else
1267             md_write( md, pw, pwlen );
1268         md_final( md );
1269         i = md_digest_length( s2k->hash_algo );
1270         if( i > dek->keylen - used )
1271             i = dek->keylen - used;
1272         memcpy( dek->key+used, md_read(md, s2k->hash_algo), i );
1273         used += i;
1274     }
1275     md_close(md);
1276 }
1277