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