* packet.h, main.h, sig-check.c (signature_check2, check_key_signature2,
[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 (__MINGW32__) || 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 (__MINGW32__)
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 (__MINGW32__)
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 (__MINGW32__)
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 (__MINGW32__)
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     dft_ttyname = tty_get_ttyname ();
379   if (opt.ttyname || dft_ttyname)
380     {
381       if (agent_send_option (fd, "ttyname",
382                              opt.ttyname ? opt.ttyname : dft_ttyname))
383         return -1;
384     }
385
386   dft_ttytype = getenv ("TERM");
387   if (opt.ttytype || (dft_ttyname && dft_ttytype))
388     {
389       if (agent_send_option (fd, "ttytype",
390                              opt.ttyname ? opt.ttytype : dft_ttytype))
391         return -1;
392     }
393
394 #if defined(HAVE_SETLOCALE) && defined(LC_CTYPE)
395   old_lc = setlocale (LC_CTYPE, NULL);
396   if (old_lc)
397     old_lc = m_strdup (old_lc);
398   dft_lc = setlocale (LC_CTYPE, "");
399 #endif
400   if (opt.lc_ctype || (dft_ttyname && dft_lc))
401     {
402       rc = agent_send_option (fd, "lc-ctype",
403                               opt.lc_ctype ? opt.lc_ctype : dft_lc);
404     }
405 #if defined(HAVE_SETLOCALE) && defined(LC_CTYPE)
406   if (old_lc)
407     {
408       setlocale (LC_CTYPE, old_lc);
409       m_free (old_lc);
410     }
411 #endif
412   if (rc)
413     return rc;
414
415 #if defined(HAVE_SETLOCALE) && defined(LC_MESSAGES)
416   old_lc = setlocale (LC_MESSAGES, NULL);
417   if (old_lc)
418     old_lc = m_strdup (old_lc);
419   dft_lc = setlocale (LC_MESSAGES, "");
420 #endif
421   if (opt.lc_messages || (dft_ttyname && dft_lc))
422     {
423       rc = agent_send_option (fd, "lc-messages",
424                               opt.lc_messages ? opt.lc_messages : dft_lc);
425     }
426 #if defined(HAVE_SETLOCALE) && defined(LC_MESSAGES)
427   if (old_lc)
428     {
429       setlocale (LC_MESSAGES, old_lc);
430       m_free (old_lc);
431     }
432 #endif
433   return rc;
434 }
435 #endif /*!__MINGW32__*/
436
437
438 /*
439  * Open a connection to the agent and send the magic string
440  * Returns: -1 on error or an filedescriptor for urther processing
441  */
442
443 static int
444 agent_open (int *ret_prot)
445 {
446 #if defined (__MINGW32__)
447     int fd;
448     char *infostr, *p;
449     HANDLE h;
450     char pidstr[128];
451
452     *ret_prot = 0;
453     if ( !(infostr = read_w32_registry_string(NULL, "Software\\GNU\\GnuPG",
454                                               "agentPID")) 
455          || *infostr == '0') {
456         log_error( _("gpg-agent is not available in this session\n"));
457         return -1;
458     }
459     free(infostr);
460     
461     sprintf(pidstr, "%u", (unsigned int)GetCurrentProcessId());
462     if (write_w32_registry_string(NULL, "Software\\GNU\\GnuPG",
463                                   "agentCID", pidstr)) {
464         log_error( _("can't set client pid for the agent\n") );
465         return -1;
466     }
467     h = OpenEvent(EVENT_ALL_ACCESS, FALSE, "gpg_agent");
468     SetEvent(h);
469     Sleep(50); /* some time for the server */ 
470     if ( !(p = read_w32_registry_string(NULL, "Software\\GNU\\GnuPG",
471                                         "agentReadFD")) ) {
472         log_error( _("can't get server read FD for the agent\n") );
473         return -1;
474     }
475     read_fd = atol(p);
476     free(p);    
477     if ( !(p = read_w32_registry_string(NULL, "Software\\GNU\\GnuPG",
478                                         "agentWriteFD")) ) {
479         log_error ( _("can't get server write FD for the agent\n") );
480         return -1;
481     }
482     write_fd = atol(p);
483     free(p);
484     fd = 0;
485
486     if ( writen ( fd, "GPGA\0\0\0\x01", 8 ) ) {
487         fd = -1;
488     }
489 #else /* Posix */
490
491     int fd;
492     char *infostr, *p;
493     struct sockaddr_un client_addr;
494     size_t len;
495     int prot;
496
497     if (opt.gpg_agent_info)
498       infostr = m_strdup (opt.gpg_agent_info);
499     else
500       {
501         infostr = getenv ( "GPG_AGENT_INFO" );
502         if ( !infostr ) {
503           log_error (_("gpg-agent is not available in this session\n"));
504           opt.use_agent = 0;
505           return -1;
506         }
507         infostr = m_strdup ( infostr );
508       }
509
510     if ( !(p = strchr ( infostr, ':')) || p == infostr
511          || (p-infostr)+1 >= sizeof client_addr.sun_path ) {
512         log_error( _("malformed GPG_AGENT_INFO environment variable\n"));
513         m_free (infostr );
514         opt.use_agent = 0;
515         return -1;
516     }
517     *p++ = 0;
518     /* See whether this is the new gpg-agent using the Assuna protocl.
519        This agent identifies itself by have an info string with a
520        version number in the 3rd field. */
521     while (*p && *p != ':')
522       p++;
523     prot = *p? atoi (p+1) : 0;
524     if ( prot < 0 || prot > 1) {
525         log_error (_("gpg-agent protocol version %d is not supported\n"),prot);
526         m_free (infostr );
527         opt.use_agent = 0;
528         return -1;
529     }
530     *ret_prot = prot;
531        
532     if( (fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1 ) {
533         log_error ("can't create socket: %s\n", strerror(errno) );
534         m_free (infostr );
535         opt.use_agent = 0;
536         return -1;
537     }
538     
539     memset( &client_addr, 0, sizeof client_addr );
540     client_addr.sun_family = AF_UNIX;
541     strcpy( client_addr.sun_path, infostr );
542     len = offsetof (struct sockaddr_un, sun_path)
543         + strlen(client_addr.sun_path) + 1;
544     
545     if( connect( fd, (struct sockaddr*)&client_addr, len ) == -1 ) {
546         log_error ( _("can't connect to `%s': %s\n"), 
547                     infostr, strerror (errno) );
548         m_free (infostr );
549         close (fd );
550         opt.use_agent = 0;
551         return -1;
552     }
553     m_free (infostr);
554
555     if (!prot) {
556         if ( writen ( fd, "GPGA\0\0\0\x01", 8 ) ) {
557           close (fd);
558           fd = -1;
559         }
560     }
561     else { /* assuan based gpg-agent */
562       char line[200];
563       int nread;
564
565       nread = readline (fd, line, DIM(line));
566       if (nread < 3 || !(line[0] == 'O' && line[1] == 'K'
567                          && (line[2] == '\n' || line[2] == ' ')) ) {
568         log_error ( _("communication problem with gpg-agent\n"));
569         close (fd );
570         opt.use_agent = 0;
571         return -1;
572       }
573
574       if (agent_send_all_options (fd)) {
575         log_error (_("problem with the agent - disabling agent use\n"));
576         close (fd);
577         opt.use_agent = 0;
578         return -1;
579       }
580         
581     }
582 #endif
583
584     return fd;
585 }
586
587
588 static void
589 agent_close ( int fd )
590 {
591 #if defined (__MINGW32__)
592     HANDLE h = OpenEvent(EVENT_ALL_ACCESS, FALSE, "gpg_agent");
593     ResetEvent(h);
594 #else
595     close (fd);
596 #endif
597 }
598 #endif /* !__riscos__ */
599
600
601
602 /*
603  * Ask the GPG Agent for the passphrase.
604  * Mode 0:  Allow cached passphrase
605  *      1:  No cached passphrase FIXME: Not really implemented
606  *      2:  Ditto, but change the text to "repeat entry"
607  *
608  * Note that TRYAGAIN_TEXT must not be translated.  If canceled is not
609  * NULL, the function does set it to 1 if the user canceled the
610  * operation.
611  */
612 static char *
613 agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text,
614                        int *canceled)
615 {
616 #if defined(__riscos__)
617   return NULL;
618 #else
619   size_t n;
620   char *atext = NULL;
621   char buf[50];
622   int fd = -1;
623   int nread;
624   u32 reply;
625   char *pw = NULL;
626   PKT_public_key *pk = m_alloc_clear( sizeof *pk );
627   byte fpr[MAX_FINGERPRINT_LEN];
628   int have_fpr = 0;
629   int prot;
630   char *orig_codeset = NULL;
631
632   if (canceled)
633     *canceled = 0;
634
635 #if MAX_FINGERPRINT_LEN < 20
636 #error agent needs a 20 byte fingerprint
637 #endif
638
639   memset (fpr, 0, MAX_FINGERPRINT_LEN );
640   if( keyid && get_pubkey( pk, keyid ) )
641     {
642       free_public_key( pk );      
643       pk = NULL; /* oops: no key for some reason */
644     }
645   
646 #ifdef ENABLE_NLS
647   /* The Assuan agent protol requires us to trasnmit utf-8 strings */
648   orig_codeset = bind_textdomain_codeset (PACKAGE, NULL);
649 #ifdef HAVE_LANGINFO_CODESET
650   if (!orig_codeset)
651     orig_codeset = nl_langinfo (CODESET);
652 #endif
653   if (orig_codeset)
654     { /* We only switch when we are able to restore the codeset later. */
655       orig_codeset = m_strdup (orig_codeset);
656       if (!bind_textdomain_codeset (PACKAGE, "utf-8"))
657         orig_codeset = NULL; 
658     }
659 #endif
660
661   if ( (fd = agent_open (&prot)) == -1 ) 
662     goto failure;
663
664   if ( !mode && pk && keyid )
665     { 
666       char *uid;
667       size_t uidlen;
668       const char *algo_name = pubkey_algo_to_string ( pk->pubkey_algo );
669       const char *timestr;
670       char *maink;
671       const char *fmtstr;
672       
673       if ( !algo_name )
674         algo_name = "?";
675       
676       fmtstr = _(" (main key ID %08lX)");
677       maink = m_alloc ( strlen (fmtstr) + 20 );
678       if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
679           && keyid[1] != keyid[3] )
680         sprintf( maink, fmtstr, (ulong)keyid[3] );
681       else
682         *maink = 0;
683       
684       uid = get_user_id ( keyid, &uidlen ); 
685       timestr = strtimestamp (pk->timestamp);
686       fmtstr = _("You need a passphrase to unlock the"
687                  " secret key for user:\n"
688                  "\"%.*s\"\n"
689                  "%u-bit %s key, ID %08lX, created %s%s\n" );
690       atext = m_alloc ( 100 + strlen (fmtstr)  
691                         + uidlen + 15 + strlen(algo_name) + 8
692                         + strlen (timestr) + strlen (maink) );
693       sprintf (atext, fmtstr,
694                uidlen, uid,
695                nbits_from_pk (pk), algo_name, (ulong)keyid[1], timestr,
696                maink  );
697       m_free (uid);
698       m_free (maink);
699       
700       { 
701         size_t dummy;
702         fingerprint_from_pk( pk, fpr, &dummy );
703         have_fpr = 1;
704       }
705       
706     }
707   else if (mode == 2 ) 
708     atext = m_strdup ( _("Repeat passphrase\n") );
709   else
710     atext = m_strdup ( _("Enter passphrase\n") );
711                 
712   if (!prot)
713     { /* old style protocol */
714       n = 4 + 20 + strlen (atext);
715       u32tobuf (buf, n );
716       u32tobuf (buf+4, GPGA_PROT_GET_PASSPHRASE );
717       memcpy (buf+8, fpr, 20 );
718       if ( writen ( fd, buf, 28 ) || writen ( fd, atext, strlen (atext) ) ) 
719         goto failure;
720       m_free (atext); atext = NULL;
721       
722       /* get response */
723       if ( readn ( fd, buf, 12, &nread ) ) 
724         goto failure;
725       
726       if ( nread < 8 ) 
727         {
728           log_error ( "response from agent too short\n" );
729           goto failure;
730         }
731       n = buftou32 ( buf );
732       reply = buftou32 ( buf + 4 );
733       if ( reply == GPGA_PROT_GOT_PASSPHRASE ) 
734         {
735           size_t pwlen;
736           size_t nn;
737           
738           if ( nread < 12 || n < 8 ) 
739             {
740               log_error ( "response from agent too short\n" );
741               goto failure;
742             }
743           pwlen = buftou32 ( buf + 8 );
744           nread -= 12;
745           n -= 8;
746           if ( pwlen > n || n > 1000 ) 
747             {
748               log_error (_("passphrase too long\n"));
749               /* or protocol error */
750               goto failure;
751             }
752           /* we read the whole block in one chunk to give no hints
753            * on how long the passhrase actually is - this wastes some bytes
754            * but because we already have this padding we should not loosen
755            * this by issuing 2 read calls */
756           pw = m_alloc_secure ( n+1 );
757           if ( readn ( fd, pw, n, &nn ) )
758             goto failure;
759           if ( n != nn ) 
760             {
761               log_error (_("invalid response from agent\n"));
762               goto failure;           
763             }
764           pw[pwlen] = 0; /* make a C String */
765           agent_close (fd);
766           free_public_key( pk );
767 #ifdef ENABLE_NLS
768           if (orig_codeset)
769             bind_textdomain_codeset (PACKAGE, orig_codeset);
770 #endif
771           m_free (orig_codeset);
772           return pw;
773         }
774       else if ( reply == GPGA_PROT_CANCELED ) 
775         {
776           log_info ( _("cancelled by user\n") );
777           if (canceled)
778             *canceled = 1;
779         }
780       else 
781         log_error ( _("problem with the agent: agent returns 0x%lx\n"),
782                     (ulong)reply );
783     }
784   else
785     { /* The new Assuan protocol */
786       char *line, *p;
787       const unsigned char *s;
788       int i; 
789
790       if (!tryagain_text)
791         tryagain_text = "X";
792       else
793         tryagain_text = _(tryagain_text);
794
795       /* We allocate 2 time the needed space for atext so that there
796          is nenough space for escaping */
797       line = m_alloc (15 + 46 
798                       +  3*strlen (tryagain_text) + 3*strlen (atext) + 2);
799       strcpy (line, "GET_PASSPHRASE ");
800       p = line+15;
801       if (!mode && have_fpr)
802         {
803           for (i=0; i < 20; i++, p +=2 )
804             sprintf (p, "%02X", fpr[i]);
805         }
806       else
807         *p++ = 'X'; /* no caching */
808       *p++ = ' ';
809       for (i=0, s=tryagain_text; *s; s++)
810         {
811           if (*s < ' ' || *s == '+')
812             {
813               sprintf (p, "%%%02X", *s);
814               p += 3;
815             }
816           else if (*s == ' ')
817             *p++ = '+';
818           else
819             *p++ = *s;
820         }
821       *p++ = ' ';
822       *p++ = 'X'; /* Use the standard prompt */
823       *p++ = ' ';
824       /* copy description */
825       for (i=0, s= atext; *s; s++)
826         {
827           if (*s < ' ' || *s == '+')
828             {
829               sprintf (p, "%%%02X", *s);
830               p += 3;
831             }
832           else if (*s == ' ')
833             *p++ = '+';
834           else
835             *p++ = *s;
836         }
837       *p++ = '\n';
838       i = writen (fd, line, p - line);
839       m_free (line);
840       if (i)
841         goto failure;
842       m_free (atext); atext = NULL;
843       
844       /* get response */
845       pw = m_alloc_secure (500);
846       nread = readline (fd, pw, 499);
847       if (nread < 3)
848         goto failure;
849       
850       if (pw[0] == 'O' && pw[1] == 'K' && pw[2] == ' ') 
851         { /* we got a passphrase - convert it back from hex */
852           size_t pwlen = 0;
853
854           for (i=3; i < nread && hexdigitp (pw+i); i+=2)
855             pw[pwlen++] = xtoi_2 (pw+i);
856           pw[pwlen] = 0; /* make a C String */
857           agent_close (fd);
858           free_public_key( pk );
859 #ifdef ENABLE_NLS
860           if (orig_codeset)
861             bind_textdomain_codeset (PACKAGE, orig_codeset);
862 #endif
863           m_free (orig_codeset);
864           return pw;
865         }
866       else if (nread > 7 && !memcmp (pw, "ERR 111", 7)
867                && (pw[7] == ' ' || pw[7] == '\n') ) 
868         {
869           log_info (_("cancelled by user\n") );
870           if (canceled)
871             *canceled = 1;
872         }
873       else 
874         {
875           log_error (_("problem with the agent - disabling agent use\n"));
876           opt.use_agent = 0;
877         }
878     }
879       
880         
881  failure:
882 #ifdef ENABLE_NLS
883   if (orig_codeset)
884     bind_textdomain_codeset (PACKAGE, orig_codeset);
885 #endif
886   m_free (atext);
887   if ( fd != -1 )
888     agent_close (fd);
889   m_free (pw );
890   free_public_key( pk );
891   
892   return NULL;
893 #endif /* Posix or W32 */
894 }
895
896 /*
897  * Clear the cached passphrase
898  */
899 void
900 passphrase_clear_cache ( u32 *keyid, int algo )
901 {
902 #if defined(__riscos__)
903   return ;
904 #else
905   size_t n;
906   char buf[200];
907   int fd = -1;
908   size_t nread;
909   u32 reply;
910   PKT_public_key *pk;
911   byte fpr[MAX_FINGERPRINT_LEN];
912   int prot;
913   
914 #if MAX_FINGERPRINT_LEN < 20
915 #error agent needs a 20 byte fingerprint
916 #endif
917     
918   if (!opt.use_agent)
919     return;
920   
921   pk = m_alloc_clear ( sizeof *pk );
922   memset (fpr, 0, MAX_FINGERPRINT_LEN );
923   if( !keyid || get_pubkey( pk, keyid ) )
924     {
925       log_debug ("oops, no key in passphrase_clear_cache\n");
926       goto failure; /* oops: no key for some reason */
927     }
928   
929   {
930     size_t dummy;
931     fingerprint_from_pk( pk, fpr, &dummy );
932   }
933     
934   if ( (fd = agent_open (&prot)) == -1 ) 
935     goto failure;
936
937   if (!prot)
938     {
939       n = 4 + 20;
940       u32tobuf (buf, n );
941       u32tobuf (buf+4, GPGA_PROT_CLEAR_PASSPHRASE );
942       memcpy (buf+8, fpr, 20 );
943       if ( writen ( fd, buf, 28 ) )  
944         goto failure;
945       
946       /* get response */
947       if ( readn ( fd, buf, 8, &nread ) ) 
948         goto failure;
949       
950       if ( nread < 8 ) {
951         log_error ( "response from agent too short\n" );
952         goto failure;
953       }
954       
955       reply = buftou32 ( buf + 4 );
956       if ( reply != GPGA_PROT_OKAY && reply != GPGA_PROT_NO_PASSPHRASE )
957         {
958           log_error ( _("problem with the agent: agent returns 0x%lx\n"),
959                       (ulong)reply );
960         }
961     }
962   else 
963     { /* The assuan protocol */
964       char *line, *p;
965       int i; 
966
967       line = m_alloc (17 + 40 + 2);
968       strcpy (line, "CLEAR_PASSPHRASE ");
969       p = line+17;
970       for (i=0; i < 20; i++, p +=2 )
971         sprintf (p, "%02X", fpr[i]);
972       *p++ = '\n';
973       i = writen (fd, line, p - line);
974       m_free (line);
975       if (i)
976         goto failure;
977       
978       /* get response */
979       nread = readline (fd, buf, DIM(buf)-1);
980       if (nread < 3)
981         goto failure;
982       
983       if (buf[0] == 'O' && buf[1] == 'K' && (buf[2] == ' ' || buf[2] == '\n')) 
984         ;
985       else 
986         {
987           log_error (_("problem with the agent - disabling agent use\n"));
988           opt.use_agent = 0;
989         }
990     }
991         
992  failure:
993   if (fd != -1)
994     agent_close (fd);
995   free_public_key( pk );
996 #endif /* Posix or W32 */
997 }
998
999
1000
1001
1002 /****************
1003  * Get a passphrase for the secret key with KEYID, display TEXT
1004  * if the user needs to enter the passphrase.
1005  * mode 0 = standard, 1 = same but don't show key info,
1006  *      2 = create new passphrase
1007  * Returns: a DEK with a session key; caller must free
1008  *          or NULL if the passphrase was not correctly repeated.
1009  *          (only for mode 2)
1010  *          a dek->keylen of 0 means: no passphrase entered.
1011  *          (only for mode 2)
1012  *
1013  * pubkey_algo is only informational.  Note that TRYAGAIN_TEXT must
1014  * not be translated as this is done within this function (required to
1015  * switch to utf-8 when the agent is in use).  If CANCELED is not
1016  * NULL, it is set to 1 if the user choosed to cancel the operation,
1017  * otherwise it will be set to 0.
1018  */
1019 DEK *
1020 passphrase_to_dek( u32 *keyid, int pubkey_algo,
1021                    int cipher_algo, STRING2KEY *s2k, int mode,
1022                    const char *tryagain_text, int *canceled)
1023 {
1024     char *pw = NULL;
1025     DEK *dek;
1026     STRING2KEY help_s2k;
1027
1028     if (canceled)
1029       *canceled = 0;
1030
1031     if( !s2k ) {
1032         /* This is used for the old rfc1991 mode 
1033          * Note: This must match the code in encode.c with opt.rfc1991 set */
1034         s2k = &help_s2k;
1035         s2k->mode = 0;
1036         s2k->hash_algo = opt.s2k_digest_algo;
1037     }
1038
1039     if( !next_pw && is_status_enabled() ) {
1040         char buf[50];
1041
1042         if( keyid ) {
1043             u32 used_kid[2];
1044             char *us;
1045
1046             if( keyid[2] && keyid[3] ) {
1047                 used_kid[0] = keyid[2];
1048                 used_kid[1] = keyid[3];
1049             }
1050             else {
1051                 used_kid[0] = keyid[0];
1052                 used_kid[1] = keyid[1];
1053             }
1054
1055             us = get_long_user_id_string( keyid );
1056             write_status_text( STATUS_USERID_HINT, us );
1057             m_free(us);
1058
1059             sprintf( buf, "%08lX%08lX %08lX%08lX %d 0",
1060                      (ulong)keyid[0], (ulong)keyid[1],
1061                      (ulong)used_kid[0], (ulong)used_kid[1],
1062                      pubkey_algo );
1063                      
1064             write_status_text( STATUS_NEED_PASSPHRASE, buf );
1065         }
1066         else {
1067             sprintf( buf, "%d %d %d", cipher_algo, s2k->mode, s2k->hash_algo );
1068             write_status_text( STATUS_NEED_PASSPHRASE_SYM, buf );
1069         }
1070     }
1071
1072     if( keyid && !opt.batch && !next_pw && mode!=1 ) {
1073         PKT_public_key *pk = m_alloc_clear( sizeof *pk );
1074         size_t n;
1075         char *p;
1076
1077         tty_printf(_("\nYou need a passphrase to unlock the secret key for\n"
1078                      "user: \"") );
1079         p = get_user_id( keyid, &n );
1080         tty_print_utf8_string( p, n );
1081         m_free(p);
1082         tty_printf("\"\n");
1083
1084         if( !get_pubkey( pk, keyid ) ) {
1085             const char *s = pubkey_algo_to_string( pk->pubkey_algo );
1086             tty_printf( _("%u-bit %s key, ID %08lX, created %s"),
1087                        nbits_from_pk( pk ), s?s:"?", (ulong)keyid[1],
1088                        strtimestamp(pk->timestamp) );
1089             if( keyid[2] && keyid[3] && keyid[0] != keyid[2]
1090                                      && keyid[1] != keyid[3] )
1091                 tty_printf( _(" (main key ID %08lX)"), (ulong)keyid[3] );
1092             tty_printf("\n");
1093         }
1094
1095         tty_printf("\n");
1096         free_public_key( pk );
1097     }
1098
1099  agent_died:
1100     if( next_pw ) {
1101         pw = next_pw;
1102         next_pw = NULL;
1103     }
1104     else if ( opt.use_agent ) {
1105         pw = agent_get_passphrase ( keyid, mode == 2? 1: 0,
1106                                     tryagain_text, canceled );
1107         if (!pw)
1108           {
1109             if (!opt.use_agent)
1110               goto agent_died;
1111             pw = m_strdup ("");
1112           }
1113         if( *pw && mode == 2 ) {
1114             char *pw2 = agent_get_passphrase ( keyid, 2, NULL, canceled );
1115             if (!pw2)
1116               {
1117                 if (!opt.use_agent)
1118                   {
1119                     m_free (pw);
1120                     pw = NULL;
1121                     goto agent_died;
1122                   }
1123                 pw2 = m_strdup ("");
1124               }
1125             if( strcmp(pw, pw2) ) {
1126                 m_free(pw2);
1127                 m_free(pw);
1128                 return NULL;
1129             }
1130             m_free(pw2);
1131         }
1132     }
1133     else if( fd_passwd ) {
1134         pw = m_alloc_secure( strlen(fd_passwd)+1 );
1135         strcpy( pw, fd_passwd );
1136     }
1137     else if( opt.batch ) {
1138         log_error(_("can't query password in batchmode\n"));
1139         pw = m_strdup( "" ); /* return an empty passphrase */
1140     }
1141     else {
1142         pw = cpr_get_hidden("passphrase.enter", _("Enter passphrase: ") );
1143         tty_kill_prompt();
1144         if( mode == 2 && !cpr_enabled() ) {
1145             char *pw2 = cpr_get_hidden("passphrase.repeat",
1146                                        _("Repeat passphrase: ") );
1147             tty_kill_prompt();
1148             if( strcmp(pw, pw2) ) {
1149                 m_free(pw2);
1150                 m_free(pw);
1151                 return NULL;
1152             }
1153             m_free(pw2);
1154         }
1155     }
1156
1157     if( !pw || !*pw )
1158         write_status( STATUS_MISSING_PASSPHRASE );
1159
1160     dek = m_alloc_secure_clear ( sizeof *dek );
1161     dek->algo = cipher_algo;
1162     if( !*pw && mode == 2 )
1163         dek->keylen = 0;
1164     else
1165         hash_passphrase( dek, pw, s2k, mode==2 );
1166     m_free(last_pw);
1167     last_pw = pw;
1168     return dek;
1169 }
1170
1171
1172 /****************
1173  * Hash a passphrase using the supplied s2k. If create is true, create
1174  * a new salt or what else must be filled into the s2k for a new key.
1175  * always needs: dek->algo, s2k->mode, s2k->hash_algo.
1176  */
1177 static void
1178 hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
1179 {
1180     MD_HANDLE md;
1181     int pass, i;
1182     int used = 0;
1183     int pwlen = strlen(pw);
1184
1185     assert( s2k->hash_algo );
1186     dek->keylen = cipher_get_keylen( dek->algo ) / 8;
1187     if( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
1188         BUG();
1189
1190     md = md_open( s2k->hash_algo, 1);
1191     for(pass=0; used < dek->keylen ; pass++ ) {
1192         if( pass ) {
1193             md_reset(md);
1194             for(i=0; i < pass; i++ ) /* preset the hash context */
1195                 md_putc(md, 0 );
1196         }
1197
1198         if( s2k->mode == 1 || s2k->mode == 3 ) {
1199             int len2 = pwlen + 8;
1200             ulong count = len2;
1201
1202             if( create && !pass ) {
1203                 randomize_buffer(s2k->salt, 8, 1);
1204                 if( s2k->mode == 3 )
1205                     s2k->count = 96; /* 65536 iterations */
1206             }
1207
1208             if( s2k->mode == 3 ) {
1209                 count = (16ul + (s2k->count & 15)) << ((s2k->count >> 4) + 6);
1210                 if( count < len2 )
1211                     count = len2;
1212             }
1213             /* a little bit complicated because we need a ulong for count */
1214             while( count > len2 ) { /* maybe iterated+salted */
1215                 md_write( md, s2k->salt, 8 );
1216                 md_write( md, pw, pwlen );
1217                 count -= len2;
1218             }
1219             if( count < 8 )
1220                 md_write( md, s2k->salt, count );
1221             else {
1222                 md_write( md, s2k->salt, 8 );
1223                 count -= 8;
1224                 md_write( md, pw, count );
1225             }
1226         }
1227         else
1228             md_write( md, pw, pwlen );
1229         md_final( md );
1230         i = md_digest_length( s2k->hash_algo );
1231         if( i > dek->keylen - used )
1232             i = dek->keylen - used;
1233         memcpy( dek->key+used, md_read(md, s2k->hash_algo), i );
1234         used += i;
1235     }
1236     md_close(md);
1237 }
1238