g10: On a TOFU conflict, write the conflicting keys to the status fd
[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, 2011 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 <https://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 <errno.h>
28 #ifdef HAVE_LOCALE_H
29 #include <locale.h>
30 #endif
31 #ifdef HAVE_LANGINFO_CODESET
32 #include <langinfo.h>
33 #endif
34
35 #include "gpg.h"
36 #include "util.h"
37 #include "options.h"
38 #include "ttyio.h"
39 #include "keydb.h"
40 #include "main.h"
41 #include "i18n.h"
42 #include "status.h"
43 #include "call-agent.h"
44 #include "../common/shareddefs.h"
45
46 static char *fd_passwd = NULL;
47 static char *next_pw = NULL;
48 static char *last_pw = NULL;
49
50
51
52 /* Pack an s2k iteration count into the form specified in 2440.  If
53    we're in between valid values, round up.  With value 0 return the
54    old default.  */
55 unsigned char
56 encode_s2k_iterations (int iterations)
57 {
58   gpg_error_t err;
59   unsigned char c=0;
60   unsigned char result;
61   unsigned int count;
62
63   if (!iterations)
64     {
65       unsigned long mycnt;
66
67       /* Ask the gpg-agent for a useful iteration count.  */
68       err = agent_get_s2k_count (&mycnt);
69       if (err || mycnt < 65536)
70         {
71           /* Don't print an error if an older agent is used.  */
72           if (err && gpg_err_code (err) != GPG_ERR_ASS_PARAMETER)
73             log_error (_("problem with the agent: %s\n"), gpg_strerror (err));
74           /* Default to 65536 which we used up to 2.0.13.  */
75           return 96;
76         }
77       else if (mycnt >= 65011712)
78         return 255; /* Largest possible value.  */
79       else
80         return encode_s2k_iterations ((int)mycnt);
81     }
82
83   if (iterations <= 1024)
84     return 0;  /* Command line arg compatibility.  */
85
86   if (iterations >= 65011712)
87     return 255;
88
89   /* Need count to be in the range 16-31 */
90   for (count=iterations>>6; count>=32; count>>=1)
91     c++;
92
93   result = (c<<4)|(count-16);
94
95   if (S2K_DECODE_COUNT(result) < iterations)
96     result++;
97
98   return result;
99 }
100
101
102 int
103 have_static_passphrase()
104 {
105   return (!!fd_passwd
106           && (opt.batch || opt.pinentry_mode == PINENTRY_MODE_LOOPBACK));
107 }
108
109 /* Return a static passphrase.  The returned value is only valid as
110    long as no other passphrase related function is called.  NULL may
111    be returned if no passphrase has been set; better use
112    have_static_passphrase first.  */
113 const char *
114 get_static_passphrase (void)
115 {
116   return fd_passwd;
117 }
118
119
120 /****************
121  * Set the passphrase to be used for the next query and only for the next
122  * one.
123  */
124 void
125 set_next_passphrase( const char *s )
126 {
127   xfree(next_pw);
128   next_pw = NULL;
129   if ( s )
130     {
131       next_pw = xmalloc_secure( strlen(s)+1 );
132       strcpy (next_pw, s );
133     }
134 }
135
136 /****************
137  * Get the last passphrase used in passphrase_to_dek.
138  * Note: This removes the passphrase from this modules and
139  * the caller must free the result.  May return NULL:
140  */
141 char *
142 get_last_passphrase()
143 {
144   char *p = last_pw;
145   last_pw = NULL;
146   return p;
147 }
148
149 /* Here's an interesting question: since this passphrase was passed in
150    on the command line, is there really any point in using secure
151    memory for it?  I'm going with 'yes', since it doesn't hurt, and
152    might help in some small way (swapping). */
153
154 void
155 set_passphrase_from_string(const char *pass)
156 {
157   xfree (fd_passwd);
158   fd_passwd = xmalloc_secure(strlen(pass)+1);
159   strcpy (fd_passwd, pass);
160 }
161
162
163 void
164 read_passphrase_from_fd( int fd )
165 {
166   int i, len;
167   char *pw;
168
169   if ( !opt.batch && opt.pinentry_mode != PINENTRY_MODE_LOOPBACK)
170     { /* Not used but we have to do a dummy read, so that it won't end
171          up at the begin of the message if the quite usual trick to
172          prepend the passphtrase to the message is used. */
173       char buf[1];
174
175       while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
176         ;
177       *buf = 0;
178       return;
179     }
180
181   for (pw = NULL, i = len = 100; ; i++ )
182     {
183       if (i >= len-1 )
184         {
185           char *pw2 = pw;
186           len += 100;
187           pw = xmalloc_secure( len );
188           if( pw2 )
189             {
190               memcpy(pw, pw2, i );
191               xfree (pw2);
192             }
193           else
194             i=0;
195         }
196       if (read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
197         break;
198     }
199   pw[i] = 0;
200   if (!opt.batch && opt.pinentry_mode != PINENTRY_MODE_LOOPBACK)
201     tty_printf("\b\b\b   \n" );
202
203   xfree ( fd_passwd );
204   fd_passwd = pw;
205 }
206
207
208 /*
209  * Ask the GPG Agent for the passphrase.
210  * If NOCACHE is set the symmetric passpharse caching will not be used.
211  *
212  * Note that TRYAGAIN_TEXT must not be translated.  If CANCELED is not
213  * NULL, the function does set it to 1 if the user canceled the
214  * operation.  If CACHEID is not NULL, it will be used as the cacheID
215  * for the gpg-agent; if is NULL and a key fingerprint can be
216  * computed, this will be used as the cacheid.
217  */
218 static char *
219 passphrase_get (int nocache, const char *cacheid, int repeat,
220                 const char *tryagain_text, int *canceled)
221 {
222   int rc;
223   char *pw = NULL;
224   char *orig_codeset;
225   const char *my_cacheid;
226
227   if (canceled)
228     *canceled = 0;
229
230   orig_codeset = i18n_switchto_utf8 ();
231
232   if (!nocache && cacheid)
233     my_cacheid = cacheid;
234   else
235     my_cacheid = NULL;
236
237   if (tryagain_text)
238     tryagain_text = _(tryagain_text);
239
240   rc = agent_get_passphrase (my_cacheid, tryagain_text, NULL,
241                              _("Enter passphrase\n"),
242                              repeat, nocache, &pw);
243
244   i18n_switchback (orig_codeset);
245
246
247   if (!rc)
248     ;
249   else if (gpg_err_code (rc) == GPG_ERR_CANCELED
250             || gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
251     {
252       log_info (_("cancelled by user\n") );
253       if (canceled)
254         *canceled = 1;
255     }
256   else
257     {
258       log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
259       /* Due to limitations in the API of the upper layers they
260          consider an error as no passphrase entered.  This works in
261          most cases but not during key creation where this should
262          definitely not happen and let it continue without requiring a
263          passphrase.  Given that now all the upper layers handle a
264          cancel correctly, we simply set the cancel flag now for all
265          errors from the agent.  */
266       if (canceled)
267         *canceled = 1;
268
269       write_status_errcode ("get_passphrase", rc);
270     }
271
272   if (rc)
273     {
274       xfree (pw);
275       pw = NULL;
276     }
277   return pw;
278 }
279
280
281 /*
282  * Clear the cached passphrase with CACHEID.
283  */
284 void
285 passphrase_clear_cache (const char *cacheid)
286 {
287   int rc;
288
289   rc = agent_clear_passphrase (cacheid);
290   if (rc)
291     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
292 }
293
294
295 /* Return a new DEK object using the string-to-key specifier S2K.
296  * Returns NULL if the user canceled the passphrase entry and if
297  * CANCELED is not NULL, sets it to true.
298  *
299  * If CREATE is true a new passphrase sll be created.  If NOCACHE is
300  * true the symmetric key caching will not be used.  */
301 DEK *
302 passphrase_to_dek (int cipher_algo, STRING2KEY *s2k,
303                    int create, int nocache,
304                    const char *tryagain_text, int *canceled)
305 {
306   char *pw = NULL;
307   DEK *dek;
308   STRING2KEY help_s2k;
309   int dummy_canceled;
310   char s2k_cacheidbuf[1+16+1];
311   char *s2k_cacheid = NULL;
312
313   if (!canceled)
314     canceled = &dummy_canceled;
315   *canceled = 0;
316
317   if ( !s2k )
318     {
319       log_assert (create && !nocache);
320       /* This is used for the old rfc1991 mode
321        * Note: This must match the code in encode.c with opt.rfc1991 set */
322       memset (&help_s2k, 0, sizeof (help_s2k));
323       s2k = &help_s2k;
324       s2k->hash_algo = S2K_DIGEST_ALGO;
325     }
326
327   /* Create a new salt or what else to be filled into the s2k for a
328      new key.  */
329   if (create && (s2k->mode == 1 || s2k->mode == 3))
330     {
331       gcry_randomize (s2k->salt, 8, GCRY_STRONG_RANDOM);
332       if ( s2k->mode == 3 )
333         {
334           /* We delay the encoding until it is really needed.  This is
335              if we are going to dynamically calibrate it, we need to
336              call out to gpg-agent and that should not be done during
337              option processing in main().  */
338           if (!opt.s2k_count)
339             opt.s2k_count = encode_s2k_iterations (0);
340           s2k->count = opt.s2k_count;
341         }
342     }
343
344   /* If we do not have a passphrase available in NEXT_PW and status
345      information are request, we print them now. */
346   if ( !next_pw && is_status_enabled() )
347     {
348       char buf[50];
349
350       snprintf (buf, sizeof buf, "%d %d %d",
351                 cipher_algo, s2k->mode, s2k->hash_algo );
352       write_status_text ( STATUS_NEED_PASSPHRASE_SYM, buf );
353     }
354
355   if ( next_pw )
356     {
357       /* Simply return the passphrase we already have in NEXT_PW. */
358       pw = next_pw;
359       next_pw = NULL;
360     }
361   else if ( have_static_passphrase () )
362     {
363       /* Return the passphrase we have stored in FD_PASSWD. */
364       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
365       strcpy ( pw, fd_passwd );
366     }
367   else
368     {
369       if (!nocache && (s2k->mode == 1 || s2k->mode == 3))
370         {
371           memset (s2k_cacheidbuf, 0, sizeof s2k_cacheidbuf);
372           *s2k_cacheidbuf = 'S';
373           bin2hex (s2k->salt, 8, s2k_cacheidbuf + 1);
374           s2k_cacheid = s2k_cacheidbuf;
375         }
376
377       if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
378         {
379           char buf[32];
380
381           snprintf (buf, sizeof (buf), "%u", 100);
382           write_status_text (STATUS_INQUIRE_MAXLEN, buf);
383         }
384
385       /* Divert to the gpg-agent. */
386       pw = passphrase_get (create && nocache, s2k_cacheid,
387                            create? opt.passphrase_repeat : 0,
388                            tryagain_text, canceled);
389       if (*canceled)
390         {
391           xfree (pw);
392           write_status( STATUS_MISSING_PASSPHRASE );
393           return NULL;
394         }
395     }
396
397   if ( !pw || !*pw )
398     write_status( STATUS_MISSING_PASSPHRASE );
399
400   /* Hash the passphrase and store it in a newly allocated DEK object.
401      Keep a copy of the passphrase in LAST_PW for use by
402      get_last_passphrase(). */
403   dek = xmalloc_secure_clear ( sizeof *dek );
404   dek->algo = cipher_algo;
405   if ( (!pw || !*pw) && create)
406     dek->keylen = 0;
407   else
408     {
409       gpg_error_t err;
410
411       dek->keylen = openpgp_cipher_get_algo_keylen (dek->algo);
412       if (!(dek->keylen > 0 && dek->keylen <= DIM(dek->key)))
413         BUG ();
414       err = gcry_kdf_derive (pw, strlen (pw),
415                              s2k->mode == 3? GCRY_KDF_ITERSALTED_S2K :
416                              s2k->mode == 1? GCRY_KDF_SALTED_S2K :
417                              /* */           GCRY_KDF_SIMPLE_S2K,
418                              s2k->hash_algo, s2k->salt, 8,
419                              S2K_DECODE_COUNT(s2k->count),
420                              dek->keylen, dek->key);
421       if (err)
422         {
423           log_error ("gcry_kdf_derive failed: %s", gpg_strerror (err));
424           xfree (pw);
425           xfree (dek);
426           write_status( STATUS_MISSING_PASSPHRASE );
427           return NULL;
428         }
429     }
430   if (s2k_cacheid)
431     memcpy (dek->s2k_cacheid, s2k_cacheid, sizeof dek->s2k_cacheid);
432   xfree(last_pw);
433   last_pw = pw;
434   return dek;
435 }
436
437
438 /* Emit the USERID_HINT and the NEED_PASSPHRASE status messages.
439    MAINKEYID may be NULL. */
440 void
441 emit_status_need_passphrase (u32 *keyid, u32 *mainkeyid, int pubkey_algo)
442 {
443   char buf[50];
444   char *us;
445
446   us = get_long_user_id_string (keyid);
447   write_status_text (STATUS_USERID_HINT, us);
448   xfree (us);
449
450   snprintf (buf, sizeof buf, "%08lX%08lX %08lX%08lX %d 0",
451             (ulong)keyid[0],
452             (ulong)keyid[1],
453             (ulong)(mainkeyid? mainkeyid[0]:keyid[0]),
454             (ulong)(mainkeyid? mainkeyid[1]:keyid[1]),
455             pubkey_algo);
456
457   write_status_text (STATUS_NEED_PASSPHRASE, buf);
458 }
459
460
461 /* Return an allocated utf-8 string describing the key PK.  If ESCAPED
462    is true spaces and control characters are percent or plus escaped.
463    MODE describes the use of the key description; use one of the
464    FORMAT_KEYDESC_ macros. */
465 char *
466 gpg_format_keydesc (PKT_public_key *pk, int mode, int escaped)
467 {
468   char *uid;
469   size_t uidlen;
470   const char *algo_name;
471   const char *timestr;
472   char *orig_codeset;
473   char *maink;
474   char *desc;
475   const char *prompt;
476   const char *trailer = "";
477   int is_subkey;
478
479   is_subkey = (pk->main_keyid[0] && pk->main_keyid[1]
480                && pk->keyid[0] != pk->main_keyid[0]
481                && pk->keyid[1] != pk->main_keyid[1]);
482   algo_name = openpgp_pk_algo_name (pk->pubkey_algo);
483   timestr = strtimestamp (pk->timestamp);
484   uid = get_user_id (is_subkey? pk->main_keyid:pk->keyid, &uidlen);
485
486   orig_codeset = i18n_switchto_utf8 ();
487
488   if (is_subkey)
489     maink = xtryasprintf (_(" (main key ID %s)"), keystr (pk->main_keyid));
490   else
491     maink = NULL;
492
493   switch (mode)
494     {
495     case FORMAT_KEYDESC_NORMAL:
496       prompt = _("Please enter the passphrase to unlock the"
497                  " OpenPGP secret key:");
498       break;
499     case FORMAT_KEYDESC_IMPORT:
500       prompt = _("Please enter the passphrase to import the"
501                  " OpenPGP secret key:");
502       break;
503     case FORMAT_KEYDESC_EXPORT:
504       if (is_subkey)
505         prompt = _("Please enter the passphrase to export the"
506                    " OpenPGP secret subkey:");
507       else
508         prompt = _("Please enter the passphrase to export the"
509                    " OpenPGP secret key:");
510       break;
511     case FORMAT_KEYDESC_DELKEY:
512       if (is_subkey)
513         prompt = _("Do you really want to permanently delete the"
514                    " OpenPGP secret subkey key:");
515       else
516         prompt = _("Do you really want to permanently delete the"
517                    " OpenPGP secret key:");
518       trailer = "?";
519       break;
520     default:
521       prompt = "?";
522       break;
523     }
524
525   desc = xtryasprintf (_("%s\n"
526                          "\"%.*s\"\n"
527                          "%u-bit %s key, ID %s,\n"
528                          "created %s%s.\n%s"),
529                        prompt,
530                        (int)uidlen, uid,
531                        nbits_from_pk (pk), algo_name,
532                        keystr (pk->keyid), timestr,
533                        maink?maink:"", trailer);
534   xfree (maink);
535   xfree (uid);
536
537   i18n_switchback (orig_codeset);
538
539   if (escaped)
540     {
541       char *tmp = percent_plus_escape (desc);
542       xfree (desc);
543       desc = tmp;
544     }
545
546   return desc;
547 }