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