gpg: Pass key origin values to import functions.
[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 "../common/util.h"
37 #include "options.h"
38 #include "../common/ttyio.h"
39 #include "keydb.h"
40 #include "main.h"
41 #include "../common/i18n.h"
42 #include "../common/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 (! gnupg_fd_valid (fd))
170     log_fatal ("passphrase-fd is invalid: %s\n", strerror (errno));
171
172   if ( !opt.batch && opt.pinentry_mode != PINENTRY_MODE_LOOPBACK)
173     { /* Not used but we have to do a dummy read, so that it won't end
174          up at the begin of the message if the quite usual trick to
175          prepend the passphtrase to the message is used. */
176       char buf[1];
177
178       while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
179         ;
180       *buf = 0;
181       return;
182     }
183
184   for (pw = NULL, i = len = 100; ; i++ )
185     {
186       if (i >= len-1 )
187         {
188           char *pw2 = pw;
189           len += 100;
190           pw = xmalloc_secure( len );
191           if( pw2 )
192             {
193               memcpy(pw, pw2, i );
194               xfree (pw2);
195             }
196           else
197             i=0;
198         }
199       if (read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
200         break;
201     }
202   pw[i] = 0;
203   if (!opt.batch && opt.pinentry_mode != PINENTRY_MODE_LOOPBACK)
204     tty_printf("\b\b\b   \n" );
205
206   xfree ( fd_passwd );
207   fd_passwd = pw;
208 }
209
210
211 /*
212  * Ask the GPG Agent for the passphrase.
213  * If NOCACHE is set the symmetric passpharse caching will not be used.
214  *
215  * Note that TRYAGAIN_TEXT must not be translated.  If CANCELED is not
216  * NULL, the function does set it to 1 if the user canceled the
217  * operation.  If CACHEID is not NULL, it will be used as the cacheID
218  * for the gpg-agent; if is NULL and a key fingerprint can be
219  * computed, this will be used as the cacheid.
220  */
221 static char *
222 passphrase_get (int nocache, const char *cacheid, int repeat,
223                 const char *tryagain_text, int *canceled)
224 {
225   int rc;
226   char *pw = NULL;
227   char *orig_codeset;
228   const char *my_cacheid;
229
230   if (canceled)
231     *canceled = 0;
232
233   orig_codeset = i18n_switchto_utf8 ();
234
235   if (!nocache && cacheid)
236     my_cacheid = cacheid;
237   else
238     my_cacheid = NULL;
239
240   if (tryagain_text)
241     tryagain_text = _(tryagain_text);
242
243   rc = agent_get_passphrase (my_cacheid, tryagain_text, NULL,
244                              _("Enter passphrase\n"),
245                              repeat, nocache, &pw);
246
247   i18n_switchback (orig_codeset);
248
249
250   if (!rc)
251     ;
252   else if (gpg_err_code (rc) == GPG_ERR_CANCELED
253             || gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
254     {
255       log_info (_("cancelled by user\n") );
256       if (canceled)
257         *canceled = 1;
258     }
259   else
260     {
261       log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
262       /* Due to limitations in the API of the upper layers they
263          consider an error as no passphrase entered.  This works in
264          most cases but not during key creation where this should
265          definitely not happen and let it continue without requiring a
266          passphrase.  Given that now all the upper layers handle a
267          cancel correctly, we simply set the cancel flag now for all
268          errors from the agent.  */
269       if (canceled)
270         *canceled = 1;
271
272       write_status_errcode ("get_passphrase", rc);
273     }
274
275   if (rc)
276     {
277       xfree (pw);
278       pw = NULL;
279     }
280   return pw;
281 }
282
283
284 /*
285  * Clear the cached passphrase with CACHEID.
286  */
287 void
288 passphrase_clear_cache (const char *cacheid)
289 {
290   int rc;
291
292   rc = agent_clear_passphrase (cacheid);
293   if (rc)
294     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
295 }
296
297
298 /* Return a new DEK object using the string-to-key specifier S2K.
299  * Returns NULL if the user canceled the passphrase entry and if
300  * CANCELED is not NULL, sets it to true.
301  *
302  * If CREATE is true a new passphrase sll be created.  If NOCACHE is
303  * true the symmetric key caching will not be used.  */
304 DEK *
305 passphrase_to_dek (int cipher_algo, STRING2KEY *s2k,
306                    int create, int nocache,
307                    const char *tryagain_text, int *canceled)
308 {
309   char *pw = NULL;
310   DEK *dek;
311   STRING2KEY help_s2k;
312   int dummy_canceled;
313   char s2k_cacheidbuf[1+16+1];
314   char *s2k_cacheid = NULL;
315
316   if (!canceled)
317     canceled = &dummy_canceled;
318   *canceled = 0;
319
320   if ( !s2k )
321     {
322       log_assert (create && !nocache);
323       /* This is used for the old rfc1991 mode
324        * Note: This must match the code in encode.c with opt.rfc1991 set */
325       memset (&help_s2k, 0, sizeof (help_s2k));
326       s2k = &help_s2k;
327       s2k->hash_algo = S2K_DIGEST_ALGO;
328     }
329
330   /* Create a new salt or what else to be filled into the s2k for a
331      new key.  */
332   if (create && (s2k->mode == 1 || s2k->mode == 3))
333     {
334       gcry_randomize (s2k->salt, 8, GCRY_STRONG_RANDOM);
335       if ( s2k->mode == 3 )
336         {
337           /* We delay the encoding until it is really needed.  This is
338              if we are going to dynamically calibrate it, we need to
339              call out to gpg-agent and that should not be done during
340              option processing in main().  */
341           if (!opt.s2k_count)
342             opt.s2k_count = encode_s2k_iterations (0);
343           s2k->count = opt.s2k_count;
344         }
345     }
346
347   /* If we do not have a passphrase available in NEXT_PW and status
348      information are request, we print them now. */
349   if ( !next_pw && is_status_enabled() )
350     {
351       char buf[50];
352
353       snprintf (buf, sizeof buf, "%d %d %d",
354                 cipher_algo, s2k->mode, s2k->hash_algo );
355       write_status_text ( STATUS_NEED_PASSPHRASE_SYM, buf );
356     }
357
358   if ( next_pw )
359     {
360       /* Simply return the passphrase we already have in NEXT_PW. */
361       pw = next_pw;
362       next_pw = NULL;
363     }
364   else if ( have_static_passphrase () )
365     {
366       /* Return the passphrase we have stored in FD_PASSWD. */
367       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
368       strcpy ( pw, fd_passwd );
369     }
370   else
371     {
372       if (!nocache && (s2k->mode == 1 || s2k->mode == 3))
373         {
374           memset (s2k_cacheidbuf, 0, sizeof s2k_cacheidbuf);
375           *s2k_cacheidbuf = 'S';
376           bin2hex (s2k->salt, 8, s2k_cacheidbuf + 1);
377           s2k_cacheid = s2k_cacheidbuf;
378         }
379
380       if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
381         {
382           char buf[32];
383
384           snprintf (buf, sizeof (buf), "%u", 100);
385           write_status_text (STATUS_INQUIRE_MAXLEN, buf);
386         }
387
388       /* Divert to the gpg-agent. */
389       pw = passphrase_get (create && nocache, s2k_cacheid,
390                            create? opt.passphrase_repeat : 0,
391                            tryagain_text, canceled);
392       if (*canceled)
393         {
394           xfree (pw);
395           write_status( STATUS_MISSING_PASSPHRASE );
396           return NULL;
397         }
398     }
399
400   if ( !pw || !*pw )
401     write_status( STATUS_MISSING_PASSPHRASE );
402
403   /* Hash the passphrase and store it in a newly allocated DEK object.
404      Keep a copy of the passphrase in LAST_PW for use by
405      get_last_passphrase(). */
406   dek = xmalloc_secure_clear ( sizeof *dek );
407   dek->algo = cipher_algo;
408   if ( (!pw || !*pw) && create)
409     dek->keylen = 0;
410   else
411     {
412       gpg_error_t err;
413
414       dek->keylen = openpgp_cipher_get_algo_keylen (dek->algo);
415       if (!(dek->keylen > 0 && dek->keylen <= DIM(dek->key)))
416         BUG ();
417       err = gcry_kdf_derive (pw, strlen (pw),
418                              s2k->mode == 3? GCRY_KDF_ITERSALTED_S2K :
419                              s2k->mode == 1? GCRY_KDF_SALTED_S2K :
420                              /* */           GCRY_KDF_SIMPLE_S2K,
421                              s2k->hash_algo, s2k->salt, 8,
422                              S2K_DECODE_COUNT(s2k->count),
423                              dek->keylen, dek->key);
424       if (err)
425         {
426           log_error ("gcry_kdf_derive failed: %s", gpg_strerror (err));
427           xfree (pw);
428           xfree (dek);
429           write_status( STATUS_MISSING_PASSPHRASE );
430           return NULL;
431         }
432     }
433   if (s2k_cacheid)
434     memcpy (dek->s2k_cacheid, s2k_cacheid, sizeof dek->s2k_cacheid);
435   xfree(last_pw);
436   last_pw = pw;
437   return dek;
438 }
439
440
441 /* Emit the USERID_HINT and the NEED_PASSPHRASE status messages.
442    MAINKEYID may be NULL. */
443 void
444 emit_status_need_passphrase (ctrl_t ctrl,
445                              u32 *keyid, u32 *mainkeyid, int pubkey_algo)
446 {
447   char buf[50];
448   char *us;
449
450   us = get_long_user_id_string (ctrl, keyid);
451   write_status_text (STATUS_USERID_HINT, us);
452   xfree (us);
453
454   snprintf (buf, sizeof buf, "%08lX%08lX %08lX%08lX %d 0",
455             (ulong)keyid[0],
456             (ulong)keyid[1],
457             (ulong)(mainkeyid? mainkeyid[0]:keyid[0]),
458             (ulong)(mainkeyid? mainkeyid[1]:keyid[1]),
459             pubkey_algo);
460
461   write_status_text (STATUS_NEED_PASSPHRASE, buf);
462 }
463
464
465 /* Return an allocated utf-8 string describing the key PK.  If ESCAPED
466    is true spaces and control characters are percent or plus escaped.
467    MODE describes the use of the key description; use one of the
468    FORMAT_KEYDESC_ macros. */
469 char *
470 gpg_format_keydesc (ctrl_t ctrl, PKT_public_key *pk, int mode, int escaped)
471 {
472   char *uid;
473   size_t uidlen;
474   const char *algo_name;
475   const char *timestr;
476   char *orig_codeset;
477   char *maink;
478   char *desc;
479   const char *prompt;
480   const char *trailer = "";
481   int is_subkey;
482
483   is_subkey = (pk->main_keyid[0] && pk->main_keyid[1]
484                && pk->keyid[0] != pk->main_keyid[0]
485                && pk->keyid[1] != pk->main_keyid[1]);
486   algo_name = openpgp_pk_algo_name (pk->pubkey_algo);
487   timestr = strtimestamp (pk->timestamp);
488   uid = get_user_id (ctrl, is_subkey? pk->main_keyid:pk->keyid, &uidlen);
489
490   orig_codeset = i18n_switchto_utf8 ();
491
492   if (is_subkey)
493     maink = xtryasprintf (_(" (main key ID %s)"), keystr (pk->main_keyid));
494   else
495     maink = NULL;
496
497   switch (mode)
498     {
499     case FORMAT_KEYDESC_NORMAL:
500       prompt = _("Please enter the passphrase to unlock the"
501                  " OpenPGP secret key:");
502       break;
503     case FORMAT_KEYDESC_IMPORT:
504       prompt = _("Please enter the passphrase to import the"
505                  " OpenPGP secret key:");
506       break;
507     case FORMAT_KEYDESC_EXPORT:
508       if (is_subkey)
509         prompt = _("Please enter the passphrase to export the"
510                    " OpenPGP secret subkey:");
511       else
512         prompt = _("Please enter the passphrase to export the"
513                    " OpenPGP secret key:");
514       break;
515     case FORMAT_KEYDESC_DELKEY:
516       if (is_subkey)
517         prompt = _("Do you really want to permanently delete the"
518                    " OpenPGP secret subkey key:");
519       else
520         prompt = _("Do you really want to permanently delete the"
521                    " OpenPGP secret key:");
522       trailer = "?";
523       break;
524     default:
525       prompt = "?";
526       break;
527     }
528
529   desc = xtryasprintf (_("%s\n"
530                          "\"%.*s\"\n"
531                          "%u-bit %s key, ID %s,\n"
532                          "created %s%s.\n%s"),
533                        prompt,
534                        (int)uidlen, uid,
535                        nbits_from_pk (pk), algo_name,
536                        keystr (pk->keyid), timestr,
537                        maink?maink:"", trailer);
538   xfree (maink);
539   xfree (uid);
540
541   i18n_switchback (orig_codeset);
542
543   if (escaped)
544     {
545       char *tmp = percent_plus_escape (desc);
546       xfree (desc);
547       desc = tmp;
548     }
549
550   return desc;
551 }