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