See ChangeLog: Mon Aug 21 17:59:17 CEST 2000 Werner Koch
[gnupg.git] / g10 / passphrase.c
1 /* passphrase.c -  Get a passphrase
2  *      Copyright (C) 1998, 1999, 2000 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 <stdio.h>
23 #include <stdlib.h>
24 #include <stddef.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <assert.h>
28 #include <sys/socket.h>
29 #include <sys/un.h>
30 #include <unistd.h>
31 #include <errno.h>
32
33 #include <gcrypt.h>
34 #include "util.h"
35 #include "options.h"
36 #include "ttyio.h"
37 #include "keydb.h"
38 #include "main.h"
39 #include "i18n.h"
40 #include "status.h"
41 #include "gpga-prot.h"
42
43 #define buftou32( p )  ((*(byte*)(p) << 24) | (*((byte*)(p)+1)<< 16) | \
44                        (*((byte*)(p)+2) << 8) | (*((byte*)(p)+3)))
45 #define u32tobuf( p, a ) do {                                   \
46                             ((byte*)p)[0] = (byte)((a) >> 24);  \
47                             ((byte*)p)[1] = (byte)((a) >> 16);  \
48                             ((byte*)p)[2] = (byte)((a) >>  8);  \
49                             ((byte*)p)[3] = (byte)((a)      );  \
50                         } while(0)
51
52
53 static char *fd_passwd = NULL;
54 static char *next_pw = NULL;
55 static char *last_pw = NULL;
56
57 static void hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create );
58
59 int
60 have_static_passphrase()
61 {
62     if ( opt.use_agent )
63         return 0;
64     return !!fd_passwd;
65 }
66
67 /****************
68  * Set the passphrase to be used for the next query and only for the next
69  * one.
70  */
71 void
72 set_next_passphrase( const char *s )
73 {
74     gcry_free(next_pw);
75     next_pw = NULL;
76     if( s ) {
77         next_pw = gcry_xmalloc_secure( strlen(s)+1 );
78         strcpy(next_pw, s );
79     }
80 }
81
82 /****************
83  * Get the last passphrase used in passphrase_to_dek.
84  * Note: This removes the passphrase from this modules and
85  * the caller must free the result.  May return NULL:
86  */
87 char *
88 get_last_passphrase()
89 {
90     char *p = last_pw;
91     last_pw = NULL;
92     return p;
93 }
94
95
96 void
97 read_passphrase_from_fd( int fd )
98 {
99     int i, len;
100     char *pw;
101
102     if ( opt.use_agent ) 
103         return;  /* not used here */
104         
105
106     if( !opt.batch )
107         tty_printf("Reading passphrase from file descriptor %d ...", fd );
108     for( pw = NULL, i = len = 100; ; i++ ) {
109         if( i >= len-1 ) {
110             char *pw2 = pw;
111             len += 100;
112             pw = gcry_xmalloc_secure( len );
113             if( pw2 )
114                 memcpy(pw, pw2, i );
115             else
116                 i=0;
117         }
118         if( read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
119             break;
120     }
121     pw[i] = 0;
122     if( !opt.batch )
123         tty_printf("\b\b\b   \n" );
124
125     gcry_free( fd_passwd );
126     fd_passwd = pw;
127 }
128
129
130 static int
131 writen ( int fd, const void *buf, size_t nbytes )
132 {
133     size_t nleft = nbytes;
134     ssize_t nwritten;
135
136     while( nleft > 0 ) {
137         nwritten = write( fd, buf, nleft );
138         if( nwritten < 0 ) {
139             if ( errno == EINTR )
140                 nwritten = 0;
141             else {
142                 log_error ( "writen() failed: %s\n", strerror (errno) );
143                 return -1;
144             }
145         }
146         nleft -= nwritten;
147         buf = (const char*)buf + nwritten;
148     }
149     return 0;
150 }
151
152
153 static int
154 readn ( int fd, void *buf, size_t buflen, size_t *ret_nread )
155 {
156     size_t nleft = buflen;
157     int nread;
158     char *p;
159
160     p = buf;
161     while( nleft > 0 ) {
162         nread = read ( fd, buf, nleft );
163         if( nread < 0 ) {
164             if (nread == EINTR)
165                 nread = 0;
166             else {
167                 log_error ( "read() error: %s\n", strerror (errno) );
168                 return -1;
169             }
170         }
171         else if( !nread )
172             break; /* EOF */
173         nleft -= nread;
174         buf = (char*)buf + nread;
175     }
176     if( ret_nread )
177         *ret_nread = buflen - nleft;
178     return 0;
179 }
180
181
182
183 /*
184  * Open a connection to the agent and send the magic string
185  * Returns: -1 on error or an filedescriptor for urther processing
186  */
187
188 static int
189 agent_open ()
190 {
191     int fd;
192     char *infostr, *p;
193     struct sockaddr_un client_addr;
194     size_t len;
195
196     infostr = getenv ( "GPG_AGENT_INFO" );
197     if ( !infostr ) {
198         log_error (_("gpg-agent is not available in this session\n"));
199         return -1;
200     }
201     infostr = gcry_xstrdup ( infostr );
202     if ( !(p = strchr ( infostr, ':')) || p == infostr
203          || (p-infostr)+1 >= sizeof client_addr.sun_path ) {
204         log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
205         gcry_free (infostr );
206         return -1;
207     }
208     *p = 0;
209         
210     if( (fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1 ) {
211         log_error ("can't create socket: %s\n", strerror(errno) );
212         gcry_free (infostr );
213         return -1;
214     }
215
216     memset( &client_addr, 0, sizeof client_addr );
217     client_addr.sun_family = AF_UNIX;
218     strcpy( client_addr.sun_path, infostr );
219     len = offsetof (struct sockaddr_un, sun_path)
220         + strlen(client_addr.sun_path) + 1;
221     
222     if( connect( fd, (struct sockaddr*)&client_addr, len ) == -1 ) {
223         log_error ( _("can't connect to `%s': %s\n"), 
224                     infostr, strerror (errno) );
225         gcry_free (infostr );
226         close (fd );
227         return -1;
228     }
229     gcry_free (infostr);
230
231     if ( writen ( fd, "GPGA\0\0\0\x01", 8 ) ) {
232         close (fd);
233         fd = -1;
234     }
235     return fd;
236 }
237
238 static void
239 agent_close ( int fd )
240 {
241     close (fd);
242 }
243
244
245
246 /*
247  * Ask the GPG Agent for the passphrase.
248  * Mode 0:  Allow cached passphrase
249  *      1:  No cached passphrase FIXME: Not really implemented
250  *      2:  Ditto, but change the text to "repeat entry"
251  */
252 static char *
253 agent_get_passphrase ( u32 *keyid, int mode )
254 {
255     size_t n;
256     char *atext;
257     char buf[50];
258     int fd = -1;
259     int nread;
260     u32 reply;
261     char *pw = NULL;
262     PKT_public_key *pk = gcry_xcalloc( 1, sizeof *pk );
263     byte fpr[MAX_FINGERPRINT_LEN];
264
265 #if MAX_FINGERPRINT_LEN < 20
266   #error agent needs a 20 byte fingerprint
267 #endif
268
269     memset (fpr, 0, MAX_FINGERPRINT_LEN );
270     if( keyid && get_pubkey( pk, keyid ) )
271         pk = NULL; /* oops: no key for some reason */
272
273     if ( !mode && pk ) { 
274         char *uid;
275         size_t uidlen;
276         const char *algo_name = gcry_pk_algo_name( pk->pubkey_algo );
277         const char *timestr;
278         char *maink;
279         const char *fmtstr;
280      
281         if ( !algo_name )
282             algo_name = "?";
283    
284         fmtstr = _(" (main key ID %08lX)");
285         maink = gcry_xmalloc ( strlen (fmtstr) + 20 );
286         if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
287             && keyid[1] != keyid[3] )
288             sprintf( maink, fmtstr, (ulong)keyid[3] );
289         else
290             *maink = 0;
291
292         uid = get_user_id( keyid, &uidlen ); 
293         timestr = strtimestamp (pk->timestamp);
294         fmtstr = _("You need a passphrase to unlock the"
295                    " secret key for user:\n"
296                    "\"%.*s\"\n"
297                    "%u-bit %s key, ID %08lX, created %s%s\n" );
298         atext = gcry_xmalloc ( 100 + strlen (fmtstr)  
299                                + uidlen + 15 + strlen(algo_name) + 8
300                                + strlen (timestr) + strlen (maink) );
301         sprintf (atext, fmtstr,
302                  uidlen, uid,
303                  nbits_from_pk (pk), algo_name, (ulong)keyid[1], timestr,
304                  maink  );
305         gcry_free (uid);
306         gcry_free (maink);
307
308         { 
309             size_t dummy;
310             fingerprint_from_pk( pk, fpr, &dummy );
311         }
312         
313     }
314     else if (mode == 1 ) 
315         atext = gcry_xstrdup ( _("Enter passphrase\n") );
316     else 
317         atext = gcry_xstrdup ( _("Repeat passphrase\n") );
318
319         
320         
321     if ( (fd = agent_open ()) == -1 ) 
322         goto failure;
323
324
325     n = 4 + 20 + strlen (atext);
326     u32tobuf (buf, n );
327     u32tobuf (buf+4, GPGA_PROT_GET_PASSPHRASE );
328     memcpy (buf+8, fpr, 20 );
329     if ( writen ( fd, buf, 28 ) || writen ( fd, atext, strlen (atext) ) ) 
330         goto failure;
331     gcry_free (atext); atext = NULL;
332
333     /* get response */
334     if ( readn ( fd, buf, 12, &nread ) ) 
335         goto failure;
336
337     if ( nread < 8 ) {
338         log_error ( _("response from agent too short\n") );
339         goto failure;
340     }
341     n = buftou32 ( buf );
342     reply = buftou32 ( buf + 4 );
343     if ( reply == GPGA_PROT_GOT_PASSPHRASE ) {
344         size_t pwlen;
345         size_t nn;
346
347         if ( nread < 12 || n < 8 ) {
348             log_error ( _("response from agent too short\n") );
349             goto failure;
350         }
351         pwlen = buftou32 ( buf + 8 );
352         nread -= 12;
353         n -= 8;
354         if ( pwlen > n || n > 1000 ) {
355             log_error (_("passphrase too long\n"));
356             /* or protocol error */
357             goto failure;
358         }
359         /* we read the whole block in one chunk to give no hints
360          * on how long the passhrase actually is - this wastes some bytes
361          * but because we already have this padding we should not loosen
362          * the by issuing 2 read calls */
363         pw = gcry_xmalloc_secure ( n+1 );
364         if ( readn ( fd, pw, n, &nn ) )
365             goto failure;
366         if ( n != nn ) {
367             log_error (_("invalid response from agent\n"));
368             goto failure;           
369         }
370         pw[pwlen] = 0; /* make a C String */
371         agent_close (fd);
372         free_public_key( pk );
373         return pw;
374     }
375     else if ( reply == GPGA_PROT_CANCELED ) {
376         log_info ( _("cancelled by user\n") );
377     }
378     else {
379         log_error ( _("problem with the agent: agent returns 0x%lx\n"),
380                       (ulong)reply );
381     }
382         
383         
384   failure:
385     gcry_free (atext);
386     if ( fd != -1 )
387         agent_close (fd);
388     gcry_free (pw );
389     free_public_key( pk );
390
391     return NULL;
392 }
393
394
395 /*
396  * Reste the cached passphrase
397  */
398 void
399 passphrase_clear_cache ( u32 *keyid, int algo )
400 {
401     size_t n;
402     char buf[50];
403     int fd = -1;
404     int nread;
405     u32 reply;
406     PKT_public_key *pk = gcry_xcalloc( 1, sizeof *pk );
407     byte fpr[MAX_FINGERPRINT_LEN];
408     
409 #if MAX_FINGERPRINT_LEN < 20
410 #error agent needs a 20 byte fingerprint
411 #endif
412     
413     memset (fpr, 0, MAX_FINGERPRINT_LEN );
414     if( !keyid || get_pubkey( pk, keyid ) ) {
415         log_debug ("oops, no key in passphrase_clear_cache\n");
416         goto failure; /* oops: no key for some reason */
417     }
418     
419     {
420         size_t dummy;
421         fingerprint_from_pk( pk, fpr, &dummy );
422     }
423     
424     if ( (fd = agent_open ()) == -1 ) 
425         goto failure;
426     
427     n = 4 + 20;
428     u32tobuf (buf, n );
429     u32tobuf (buf+4, GPGA_PROT_CLEAR_PASSPHRASE );
430     memcpy (buf+8, fpr, 20 );
431     if ( writen ( fd, buf, 28 ) )  
432         goto failure;
433     
434     /* get response */
435     if ( readn ( fd, buf, 8, &nread ) ) 
436         goto failure;
437     
438     if ( nread < 8 ) {
439         log_error ( _("response from agent too short\n") );
440         goto failure;
441     }
442     
443     reply = buftou32 ( buf + 4 );
444     if ( reply != GPGA_PROT_OKAY && reply != GPGA_PROT_NO_PASSPHRASE ) {
445         log_error ( _("problem with the agent: agent returns 0x%lx\n"),
446                     (ulong)reply );
447     }
448         
449         
450   failure:
451     if ( fd != -1 )
452         agent_close (fd);
453     free_public_key( pk );
454 }
455
456
457 /****************
458  * Get a passphrase for the secret key with KEYID, display TEXT
459  * if the user needs to enter the passphrase.
460  * mode 0 = standard, 2 = create new passphrase
461  * Returns: a DEK with a session key; caller must free
462  *          or NULL if the passphrase was not correctly repeated.
463  *          (only for mode 2)
464  *          a dek->keylen of 0 means: no passphrase entered.
465  *          (only for mode 2)
466  * pubkey_algo is only informational.
467  */
468 DEK *
469 passphrase_to_dek( u32 *keyid, int pubkey_algo,
470                    int cipher_algo, STRING2KEY *s2k, int mode )
471 {
472     char *pw = NULL;
473     DEK *dek;
474     STRING2KEY help_s2k;
475
476     if( !s2k ) {
477         s2k = &help_s2k;
478         s2k->mode = 0;
479         /* this should be MD5 if cipher is IDEA, but because we do
480          * not have IDEA, we use the default one, the user
481          * can select it from the commandline
482          */
483         s2k->hash_algo = opt.def_digest_algo?opt.def_digest_algo
484                                             :DEFAULT_DIGEST_ALGO;
485     }
486
487     if( !next_pw && is_status_enabled() ) {
488         char buf[50];
489         if( keyid ) {
490             sprintf( buf, "%08lX%08lX", (ulong)keyid[0], (ulong)keyid[1] );
491             if( keyid[2] && keyid[3] && keyid[0] != keyid[2]
492                                      && keyid[1] != keyid[3] )
493                 sprintf( buf+strlen(buf), " %08lX%08lX %d 0",
494                            (ulong)keyid[2], (ulong)keyid[3], pubkey_algo );
495             write_status_text( STATUS_NEED_PASSPHRASE, buf );
496         }
497         else {
498             sprintf( buf, "%d %d %d", cipher_algo, s2k->mode, s2k->hash_algo );
499             write_status_text( STATUS_NEED_PASSPHRASE_SYM, buf );
500         }
501     }
502
503     if( keyid && !opt.batch && !next_pw ) {
504         PKT_public_key *pk = gcry_xcalloc( 1, sizeof *pk );
505         size_t n;
506         char *p;
507
508         tty_printf(_("\nYou need a passphrase to unlock the secret key for\n"
509                      "user: \"") );
510         p = get_user_id( keyid, &n );
511         tty_print_utf8_string( p, n );
512         gcry_free(p);
513         tty_printf("\"\n");
514
515         if( !get_pubkey( pk, keyid ) ) {
516             const char *s = gcry_pk_algo_name( pk->pubkey_algo );
517             tty_printf( _("%u-bit %s key, ID %08lX, created %s"),
518                        nbits_from_pk( pk ), s?s:"?", (ulong)keyid[1],
519                        strtimestamp(pk->timestamp) );
520             if( keyid[2] && keyid[3] && keyid[0] != keyid[2]
521                                      && keyid[1] != keyid[3] )
522                 tty_printf( _(" (main key ID %08lX)"), (ulong)keyid[3] );
523             tty_printf("\n");
524         }
525
526         tty_printf("\n");
527         free_public_key( pk );
528     }
529
530     if( next_pw ) {
531         pw = next_pw;
532         next_pw = NULL;
533     }
534     else if ( opt.use_agent ) {
535         pw = agent_get_passphrase ( keyid, mode == 2? 1: 0 );
536         if ( !pw )
537             pw = gcry_xstrdup ("");
538         if( *pw && mode == 2 ) {
539             char *pw2 = agent_get_passphrase ( keyid, 2 );
540             if ( !pw2 )
541                 pw2 = gcry_xstrdup ("");
542             if( strcmp(pw, pw2) ) {
543                 gcry_free(pw2);
544                 gcry_free(pw);
545                 return NULL;
546             }
547             gcry_free(pw2);
548         }
549     }
550     else if( fd_passwd ) {
551         pw = gcry_xmalloc_secure( strlen(fd_passwd)+1 );
552         strcpy( pw, fd_passwd );
553     }
554     else if( opt.batch ) {
555         log_error(_("can't query password in batchmode\n"));
556         pw = gcry_xstrdup( "" ); /* return an empty passphrase */
557     }
558     else {
559         pw = cpr_get_hidden("passphrase.enter", _("Enter passphrase: ") );
560         tty_kill_prompt();
561         if( mode == 2 && !cpr_enabled() ) {
562             char *pw2 = cpr_get_hidden("passphrase.repeat",
563                                        _("Repeat passphrase: ") );
564             tty_kill_prompt();
565             if( strcmp(pw, pw2) ) {
566                 gcry_free(pw2);
567                 gcry_free(pw);
568                 return NULL;
569             }
570             gcry_free(pw2);
571         }
572     }
573
574     if( !pw || !*pw )
575         write_status( STATUS_MISSING_PASSPHRASE );
576
577     dek = gcry_xmalloc_secure( sizeof *dek );
578     dek->algo = cipher_algo;
579     if( !*pw && mode == 2 )
580         dek->keylen = 0;
581     else
582         hash_passphrase( dek, pw, s2k, mode==2 );
583     gcry_free(last_pw);
584     last_pw = pw;
585     return dek;
586 }
587
588
589 /****************
590  * Hash a passphrase using the supplied s2k. If create is true, create
591  * a new salt or what else must be filled into the s2k for a new key.
592  * always needs: dek->algo, s2k->mode, s2k->hash_algo.
593  */
594 static void
595 hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
596 {
597     GCRY_MD_HD md;
598     int pass, i;
599     int used = 0;
600     int pwlen = strlen(pw);
601
602     assert( s2k->hash_algo );
603     dek->keylen = gcry_cipher_get_algo_keylen( dek->algo );
604     if( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
605         BUG();
606
607     if( !(md = gcry_md_open( s2k->hash_algo, GCRY_MD_FLAG_SECURE )) )
608         BUG();
609
610     for(pass=0; used < dek->keylen ; pass++ ) {
611         if( pass ) {
612             gcry_md_reset(md);
613             for(i=0; i < pass; i++ ) /* preset the hash context */
614                 gcry_md_putc(md, 0 );
615         }
616
617         if( s2k->mode == 1 || s2k->mode == 3 ) {
618             int len2 = pwlen + 8;
619             ulong count = len2;
620
621             if( create && !pass ) {
622                 gcry_randomize(s2k->salt, 8, GCRY_STRONG_RANDOM );
623                 if( s2k->mode == 3 )
624                     s2k->count = 96; /* 65536 iterations */
625             }
626
627             if( s2k->mode == 3 ) {
628                 count = (16ul + (s2k->count & 15)) << ((s2k->count >> 4) + 6);
629                 if( count < len2 )
630                     count = len2;
631             }
632             /* a little bit complicated because we need a ulong for count */
633             while( count > len2 ) { /* maybe iterated+salted */
634                 gcry_md_write( md, s2k->salt, 8 );
635                 gcry_md_write( md, pw, pwlen );
636                 count -= len2;
637             }
638             if( count < 8 )
639                 gcry_md_write( md, s2k->salt, count );
640             else {
641                 gcry_md_write( md, s2k->salt, 8 );
642                 count -= 8;
643                 assert( count >= 0 );
644                 gcry_md_write( md, pw, count );
645             }
646         }
647         else
648             gcry_md_write( md, pw, pwlen );
649         gcry_md_final( md );
650         i = gcry_md_get_algo_dlen( s2k->hash_algo );
651         if( i > dek->keylen - used )
652             i = dek->keylen - used;
653         memcpy( dek->key+used, gcry_md_read(md, s2k->hash_algo), i );
654         used += i;
655     }
656     gcry_md_close(md);
657 }
658