Made card key generate with backup key work for 2048 bit.
[gnupg.git] / g10 / passphrase.c
1 /* passphrase.c -  Get a passphrase
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2005, 2006, 2007 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 3 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, see <http://www.gnu.org/licenses/>.
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 #include <errno.h>
29 #ifdef HAVE_LOCALE_H
30 #include <locale.h>
31 #endif
32 #ifdef HAVE_LANGINFO_CODESET
33 #include <langinfo.h>
34 #endif
35
36 #include "gpg.h"
37 #include "util.h"
38 #include "options.h"
39 #include "ttyio.h"
40 #include "cipher.h"
41 #include "keydb.h"
42 #include "main.h"
43 #include "i18n.h"
44 #include "status.h"
45 #include "call-agent.h"
46
47
48 static char *fd_passwd = NULL;
49 static char *next_pw = NULL;
50 static char *last_pw = NULL;
51
52
53 /* Hash a passphrase using the supplied s2k. If create is true, create
54    a new salt or what else must be filled into the s2k for a new key.
55    always needs: dek->algo, s2k->mode, s2k->hash_algo.  */
56 static void
57 hash_passphrase ( DEK *dek, char *pw, STRING2KEY *s2k, int create )
58 {
59   gcry_md_hd_t md;
60   int pass, i;
61   int used = 0;
62   int pwlen = strlen(pw);
63
64   assert ( s2k->hash_algo );
65   dek->keylen = gcry_cipher_get_algo_keylen (dek->algo);
66   if ( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
67     BUG();
68
69   if (gcry_md_open (&md, s2k->hash_algo, 1))
70     BUG ();
71   for (pass=0; used < dek->keylen ; pass++ ) 
72     {
73       if ( pass ) 
74         {
75           gcry_md_reset (md);
76           for (i=0; i < pass; i++ ) /* Preset the hash context.  */
77             gcry_md_putc (md, 0 );
78         }
79
80       if ( s2k->mode == 1 || s2k->mode == 3 ) 
81         {
82           int len2 = pwlen + 8;
83           ulong count = len2;
84           
85           if ( create && !pass )
86             {
87               gcry_randomize (s2k->salt, 8, GCRY_STRONG_RANDOM);
88               if ( s2k->mode == 3 )
89                 s2k->count = opt.s2k_count;
90             }
91
92           if ( s2k->mode == 3 )
93             {
94               count = S2K_DECODE_COUNT(s2k->count);
95               if ( count < len2 )
96                 count = len2;
97             }
98
99           /* A little bit complicated because we need a ulong for count. */
100           while ( count > len2 )  /* maybe iterated+salted */
101             { 
102               gcry_md_write ( md, s2k->salt, 8 );
103               gcry_md_write ( md, pw, pwlen );
104               count -= len2;
105             }
106           if ( count < 8 )
107             gcry_md_write ( md, s2k->salt, count );
108           else
109             {
110               gcry_md_write ( md, s2k->salt, 8 );
111               count -= 8;
112               gcry_md_write ( md, pw, count );
113             }
114         }
115       else
116         gcry_md_write ( md, pw, pwlen );
117       gcry_md_final( md );
118
119       i = gcry_md_get_algo_dlen ( s2k->hash_algo );
120       if ( i > dek->keylen - used )
121         i = dek->keylen - used;
122
123       memcpy (dek->key+used, gcry_md_read (md, s2k->hash_algo), i);
124       used += i;
125     }
126   gcry_md_close(md);
127 }
128
129
130
131 int
132 have_static_passphrase()
133 {
134   return !!fd_passwd && opt.batch;
135 }
136
137 /****************
138  * Set the passphrase to be used for the next query and only for the next
139  * one.
140  */
141 void
142 set_next_passphrase( const char *s )
143 {
144   xfree(next_pw);
145   next_pw = NULL;
146   if ( s )
147     {
148       next_pw = xmalloc_secure( strlen(s)+1 );
149       strcpy (next_pw, s );
150     }
151 }
152
153 /****************
154  * Get the last passphrase used in passphrase_to_dek.
155  * Note: This removes the passphrase from this modules and
156  * the caller must free the result.  May return NULL:
157  */
158 char *
159 get_last_passphrase()
160 {
161   char *p = last_pw;
162   last_pw = NULL;
163   return p;
164 }
165
166 /* As if we had used the passphrase - make it the last_pw. */
167 void
168 next_to_last_passphrase(void)
169 {
170   if (next_pw)
171     {
172       last_pw=next_pw;
173       next_pw=NULL;
174     }
175 }
176
177 /* Here's an interesting question: since this passphrase was passed in
178    on the command line, is there really any point in using secure
179    memory for it?  I'm going with 'yes', since it doesn't hurt, and
180    might help in some small way (swapping). */
181
182 void
183 set_passphrase_from_string(const char *pass)
184 {
185   xfree (fd_passwd);
186   fd_passwd = xmalloc_secure(strlen(pass)+1);
187   strcpy (fd_passwd, pass);
188 }
189
190
191 void
192 read_passphrase_from_fd( int fd )
193 {
194   int i, len;
195   char *pw;
196
197   if ( !opt.batch ) 
198     { /* Not used but we have to do a dummy read, so that it won't end
199          up at the begin of the message if the quite usual trick to
200          prepend the passphtrase to the message is used. */
201       char buf[1];
202
203       while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
204         ;
205       *buf = 0;
206       return; 
207     }
208
209   for (pw = NULL, i = len = 100; ; i++ ) 
210     {
211       if (i >= len-1 ) 
212         {
213           char *pw2 = pw;
214           len += 100;
215           pw = xmalloc_secure( len );
216           if( pw2 )
217             {
218               memcpy(pw, pw2, i );
219               xfree (pw2);
220             }
221           else
222             i=0;
223         }
224       if (read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
225         break;
226     }
227   pw[i] = 0;
228   if (!opt.batch)
229     tty_printf("\b\b\b   \n" );
230
231   xfree ( fd_passwd );
232   fd_passwd = pw;
233 }
234
235
236 /*
237  * Ask the GPG Agent for the passphrase.
238  * Mode 0:  Allow cached passphrase
239  *      1:  No cached passphrase; that is we are asking for a new passphrase
240  *          FIXME: Only partially implemented
241  *
242  * Note that TRYAGAIN_TEXT must not be translated.  If CANCELED is not
243  * NULL, the function does set it to 1 if the user canceled the
244  * operation.  If CACHEID is not NULL, it will be used as the cacheID
245  * for the gpg-agent; if is NULL and a key fingerprint can be
246  * computed, this will be used as the cacheid.
247  */
248 static char *
249 passphrase_get ( u32 *keyid, int mode, const char *cacheid, int repeat,
250                  const char *tryagain_text,
251                  const char *custom_description,
252                  const char *custom_prompt, int *canceled)
253 {
254   int rc;
255   char *atext = NULL;
256   char *pw = NULL;
257   PKT_public_key *pk = xmalloc_clear( sizeof *pk );
258   byte fpr[MAX_FINGERPRINT_LEN];
259   int have_fpr = 0;
260   char *orig_codeset;
261   char *my_prompt;
262   char hexfprbuf[20*2+1];
263   const char *my_cacheid;
264   int check = (mode == 1);
265
266   if (canceled)
267     *canceled = 0;
268
269 #if MAX_FINGERPRINT_LEN < 20
270 #error agent needs a 20 byte fingerprint
271 #endif
272
273   memset (fpr, 0, MAX_FINGERPRINT_LEN );
274   if( keyid && get_pubkey( pk, keyid ) )
275     {
276       if (pk)
277         free_public_key( pk );      
278       pk = NULL; /* oops: no key for some reason */
279     }
280   
281   orig_codeset = i18n_switchto_utf8 ();
282
283   if (custom_description)
284     atext = native_to_utf8 (custom_description);
285   else if ( !mode && pk && keyid )
286     { 
287       char *uid;
288       size_t uidlen;
289       const char *algo_name = gcry_pk_algo_name ( pk->pubkey_algo );
290       const char *timestr;
291       char *maink;
292       
293       if ( !algo_name )
294         algo_name = "?";
295
296 #define KEYIDSTRING _(" (main key ID %s)")
297
298       maink = xmalloc ( strlen (KEYIDSTRING) + keystrlen() + 20 );
299       if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
300           && keyid[1] != keyid[3] )
301         sprintf( maink, KEYIDSTRING, keystr(&keyid[2]) );
302       else
303         *maink = 0;
304       
305       uid = get_user_id ( keyid, &uidlen ); 
306       timestr = strtimestamp (pk->timestamp);
307
308 #undef KEYIDSTRING
309
310 #define PROMPTSTRING _("Please enter the passphrase to unlock the" \
311                        " secret key for the OpenPGP certificate:\n" \
312                        "\"%.*s\"\n" \
313                        "%u-bit %s key, ID %s,\n" \
314                        "created %s%s.\n" )
315
316       atext = xmalloc ( 100 + strlen (PROMPTSTRING)  
317                         + uidlen + 15 + strlen(algo_name) + keystrlen()
318                         + strlen (timestr) + strlen (maink) );
319       sprintf (atext, PROMPTSTRING,
320                (int)uidlen, uid,
321                nbits_from_pk (pk), algo_name, keystr(&keyid[0]), timestr,
322                maink  );
323       xfree (uid);
324       xfree (maink);
325
326 #undef PROMPTSTRING
327
328       { 
329         size_t dummy;
330         fingerprint_from_pk( pk, fpr, &dummy );
331         have_fpr = 1;
332       }
333       
334     }
335   else
336     atext = xstrdup ( _("Enter passphrase\n") );
337                 
338
339   if (!mode && cacheid)
340     my_cacheid = cacheid;
341   else if (!mode && have_fpr)
342     my_cacheid = bin2hex (fpr, 20, hexfprbuf);
343   else
344     my_cacheid = NULL;
345
346   if (tryagain_text)
347     tryagain_text = _(tryagain_text);
348
349   my_prompt = custom_prompt ? native_to_utf8 (custom_prompt): NULL;
350
351   rc = agent_get_passphrase (my_cacheid, tryagain_text, my_prompt, atext,
352                              repeat, check, &pw);
353   
354   xfree (my_prompt);
355   xfree (atext); atext = NULL;
356
357   i18n_switchback (orig_codeset);
358
359
360   if (!rc)
361     ;
362   else if ( gpg_err_code (rc) == GPG_ERR_CANCELED )
363     {
364       log_info (_("cancelled by user\n") );
365       if (canceled)
366         *canceled = 1;
367     }
368   else 
369     {
370       log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
371       /* Due to limitations in the API of the upper layers they
372          consider an error as no passphrase entered.  This works in
373          most cases but not during key creation where this should
374          definitely not happen and let it continue without requiring a
375          passphrase.  Given that now all the upper layers handle a
376          cancel correctly, we simply set the cancel flag now for all
377          errors from the agent.  */ 
378       if (canceled)
379         *canceled = 1;
380
381       write_status_error ("get_passphrase", rc);
382     }
383
384   if (pk)
385     free_public_key( pk );
386   if (rc)
387     {
388       xfree (pw);
389       return NULL;
390     }
391   return pw;
392 }
393
394
395 /*
396  * Clear the cached passphrase.  If CACHEID is not NULL, it will be
397  * used instead of a cache ID derived from KEYID.
398  */
399 void
400 passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
401 {
402   int rc;
403
404   (void)algo;
405     
406   if (!cacheid)
407     {
408       PKT_public_key *pk;
409 #     if MAX_FINGERPRINT_LEN < 20
410 #       error agent needs a 20 byte fingerprint
411 #     endif
412       byte fpr[MAX_FINGERPRINT_LEN];
413       char hexfprbuf[2*20+1];
414       size_t dummy;
415       
416       pk = xcalloc (1, sizeof *pk);
417       if ( !keyid || get_pubkey( pk, keyid ) )
418         {
419           log_error ("key not found in passphrase_clear_cache\n");
420           free_public_key (pk);
421           return;
422         }
423       memset (fpr, 0, MAX_FINGERPRINT_LEN );
424       fingerprint_from_pk ( pk, fpr, &dummy );
425       bin2hex (fpr, 20, hexfprbuf);
426       rc = agent_clear_passphrase (hexfprbuf);
427       free_public_key ( pk );
428     }
429   else
430     rc = agent_clear_passphrase (cacheid);
431
432   if (rc)
433     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
434 }
435
436
437 /* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
438    KEYID and PUBKEY_ALGO to prompt the user.  Returns NULL is the user
439    selected to cancel the passphrase entry and if CANCELED is not
440    NULL, sets it to true.
441
442    MODE 0:  Allow cached passphrase
443         1:  Ignore cached passphrase 
444         2:  Ditto, but change the text to "repeat entry"
445 */
446 DEK *
447 passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
448                        int cipher_algo, STRING2KEY *s2k, int mode,
449                        const char *tryagain_text, 
450                        const char *custdesc, const char *custprompt,
451                        int *canceled)
452 {
453   char *pw = NULL;
454   DEK *dek;
455   STRING2KEY help_s2k;
456   int dummy_canceled;
457
458   if (!canceled)
459     canceled = &dummy_canceled;
460   *canceled = 0;
461   
462   if ( !s2k )
463     {
464       /* This is used for the old rfc1991 mode 
465        * Note: This must match the code in encode.c with opt.rfc1991 set */
466       s2k = &help_s2k;
467       s2k->mode = 0;
468       s2k->hash_algo = S2K_DIGEST_ALGO;
469     }
470
471   /* If we do not have a passphrase available in NEXT_PW and status
472      information are request, we print them now. */
473   if ( !next_pw && is_status_enabled() ) 
474     {
475       char buf[50];
476       
477       if ( keyid )
478         {
479           u32 used_kid[2];
480           char *us;
481           
482           if ( keyid[2] && keyid[3] ) 
483             {
484               used_kid[0] = keyid[2];
485               used_kid[1] = keyid[3];
486             }
487           else
488             {
489               used_kid[0] = keyid[0];
490               used_kid[1] = keyid[1];
491             }
492           
493           us = get_long_user_id_string ( keyid );
494           write_status_text ( STATUS_USERID_HINT, us );
495           xfree(us);
496           
497           snprintf (buf, sizeof buf -1, "%08lX%08lX %08lX%08lX %d 0",
498                     (ulong)keyid[0], (ulong)keyid[1],
499                     (ulong)used_kid[0], (ulong)used_kid[1],
500                     pubkey_algo );
501           
502           write_status_text ( STATUS_NEED_PASSPHRASE, buf );
503         }
504       else
505         {
506           snprintf (buf, sizeof buf -1, "%d %d %d",
507                     cipher_algo, s2k->mode, s2k->hash_algo );
508           write_status_text ( STATUS_NEED_PASSPHRASE_SYM, buf );
509         }
510     }
511
512   /* If we do have a keyID, we do not have a passphrase available in
513      NEXT_PW, we are not running in batch mode and we do not want to
514      ignore the passphrase cache (mode!=1), print a prompt with
515      information on that key. */
516   if ( keyid && !opt.batch && !next_pw && mode!=1 )
517     {
518       PKT_public_key *pk = xmalloc_clear( sizeof *pk );
519       char *p;
520       
521       p = get_user_id_native(keyid);
522       tty_printf ("\n");
523       tty_printf (_("You need a passphrase to unlock the secret key for\n"
524                     "user: \"%s\"\n"),p);
525       xfree(p);
526
527       if ( !get_pubkey( pk, keyid ) )
528         {
529           const char *s = gcry_pk_algo_name ( pk->pubkey_algo );
530           
531           tty_printf (_("%u-bit %s key, ID %s, created %s"),
532                       nbits_from_pk( pk ), s?s:"?", keystr(keyid),
533                       strtimestamp(pk->timestamp) );
534           if ( keyid[2] && keyid[3]
535                && keyid[0] != keyid[2] && keyid[1] != keyid[3] )
536             {
537               if ( keystrlen () > 10 )
538                 {
539                   tty_printf ("\n");
540                   tty_printf (_("         (subkey on main key ID %s)"),
541                               keystr(&keyid[2]) );
542                 }
543               else
544                 tty_printf ( _(" (main key ID %s)"), keystr(&keyid[2]) );
545             }
546           tty_printf("\n");
547         }
548
549       tty_printf("\n");
550       if (pk)
551         free_public_key( pk );
552     }
553
554   if ( next_pw ) 
555     {
556       /* Simply return the passphrase we already have in NEXT_PW. */
557       pw = next_pw;
558       next_pw = NULL;
559     }
560   else if ( have_static_passphrase () ) 
561     {
562       /* Return the passphrase we have stored in FD_PASSWD. */
563       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
564       strcpy ( pw, fd_passwd );
565     }
566   else 
567     {
568       /* Divert to the gpg-agent. */
569       pw = passphrase_get ( keyid, mode == 2, NULL,
570                             mode == 2? opt.passwd_repeat: 0,
571                             tryagain_text, custdesc, custprompt, canceled);
572       if (*canceled)
573         {
574           xfree (pw);
575           write_status( STATUS_MISSING_PASSPHRASE );
576           return NULL;
577         }
578     }
579     
580   if ( !pw || !*pw )
581     write_status( STATUS_MISSING_PASSPHRASE );
582
583   /* Hash the passphrase and store it in a newly allocated DEK object.
584      Keep a copy of the passphrase in LAST_PW for use by
585      get_last_passphrase(). */
586   dek = xmalloc_secure_clear ( sizeof *dek );
587   dek->algo = cipher_algo;
588   if ( !*pw && mode == 2 )
589     dek->keylen = 0;
590   else
591     hash_passphrase( dek, pw, s2k, mode==2 );
592   xfree(last_pw);
593   last_pw = pw;
594   return dek;
595 }
596
597
598 DEK *
599 passphrase_to_dek (u32 *keyid, int pubkey_algo,
600                    int cipher_algo, STRING2KEY *s2k, int mode,
601                    const char *tryagain_text, int *canceled)
602 {
603   return passphrase_to_dek_ext (keyid, pubkey_algo, cipher_algo,
604                                 s2k, mode, tryagain_text, NULL, NULL,
605                                 canceled);
606 }