Include release information from 2.2.17 to 2.2.19
[gnupg.git] / agent / genkey.c
1 /* genkey.c - Generate a keypair
2  * Copyright (C) 2002, 2003, 2004, 2007, 2010 Free Software Foundation, Inc.
3  * Copyright (C) 2015 g10 Code GmbH.
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 <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27
28 #include "agent.h"
29 #include "../common/i18n.h"
30 #include "../common/exechelp.h"
31 #include "../common/sysutils.h"
32
33 static int
34 store_key (gcry_sexp_t private, const char *passphrase, int force,
35         unsigned long s2k_count)
36 {
37   int rc;
38   unsigned char *buf;
39   size_t len;
40   unsigned char grip[20];
41
42   if ( !gcry_pk_get_keygrip (private, grip) )
43     {
44       log_error ("can't calculate keygrip\n");
45       return gpg_error (GPG_ERR_GENERAL);
46     }
47
48   len = gcry_sexp_sprint (private, GCRYSEXP_FMT_CANON, NULL, 0);
49   log_assert (len);
50   buf = gcry_malloc_secure (len);
51   if (!buf)
52       return out_of_core ();
53   len = gcry_sexp_sprint (private, GCRYSEXP_FMT_CANON, buf, len);
54   log_assert (len);
55
56   if (passphrase)
57     {
58       unsigned char *p;
59
60       rc = agent_protect (buf, passphrase, &p, &len, s2k_count, -1);
61       if (rc)
62         {
63           xfree (buf);
64           return rc;
65         }
66       xfree (buf);
67       buf = p;
68     }
69
70   rc = agent_write_private_key (grip, buf, len, force, NULL, NULL);
71   xfree (buf);
72   return rc;
73 }
74
75
76 /* Count the number of non-alpha characters in S.  Control characters
77    and non-ascii characters are not considered.  */
78 static size_t
79 nonalpha_count (const char *s)
80 {
81   size_t n;
82
83   for (n=0; *s; s++)
84     if (isascii (*s) && ( isdigit (*s) || ispunct (*s) ))
85       n++;
86
87   return n;
88 }
89
90
91 /* Check PW against a list of pattern.  Return 0 if PW does not match
92    these pattern.  */
93 static int
94 check_passphrase_pattern (ctrl_t ctrl, const char *pw)
95 {
96   gpg_error_t err = 0;
97   const char *pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CHECK_PATTERN);
98   FILE *infp;
99   const char *argv[10];
100   pid_t pid;
101   int result, i;
102
103   (void)ctrl;
104
105   infp = gnupg_tmpfile ();
106   if (!infp)
107     {
108       err = gpg_error_from_syserror ();
109       log_error (_("error creating temporary file: %s\n"), gpg_strerror (err));
110       return 1; /* Error - assume password should not be used.  */
111     }
112
113   if (fwrite (pw, strlen (pw), 1, infp) != 1)
114     {
115       err = gpg_error_from_syserror ();
116       log_error (_("error writing to temporary file: %s\n"),
117                  gpg_strerror (err));
118       fclose (infp);
119       return 1; /* Error - assume password should not be used.  */
120     }
121   fseek (infp, 0, SEEK_SET);
122   clearerr (infp);
123
124   i = 0;
125   argv[i++] = "--null";
126   argv[i++] = "--",
127   argv[i++] = opt.check_passphrase_pattern,
128   argv[i] = NULL;
129   log_assert (i < sizeof argv);
130
131   if (gnupg_spawn_process_fd (pgmname, argv, fileno (infp), -1, -1, &pid))
132     result = 1; /* Execute error - assume password should no be used.  */
133   else if (gnupg_wait_process (pgmname, pid, 1, NULL))
134     result = 1; /* Helper returned an error - probably a match.  */
135   else
136     result = 0; /* Success; i.e. no match.  */
137   gnupg_release_process (pid);
138
139   /* Overwrite our temporary file. */
140   fseek (infp, 0, SEEK_SET);
141   clearerr (infp);
142   for (i=((strlen (pw)+99)/100)*100; i > 0; i--)
143     putc ('\xff', infp);
144   fflush (infp);
145   fclose (infp);
146   return result;
147 }
148
149
150 static int
151 take_this_one_anyway (ctrl_t ctrl, const char *desc, const char *anyway_btn)
152 {
153   return agent_get_confirmation (ctrl, desc,
154                                  anyway_btn, L_("Enter new passphrase"), 0);
155 }
156
157
158 /* Check whether the passphrase PW is suitable. Returns 0 if the
159    passphrase is suitable and true if it is not and the user should be
160    asked to provide a different one.  If FAILED_CONSTRAINT is set, a
161    message describing the problem is returned in
162    *FAILED_CONSTRAINT.  */
163 int
164 check_passphrase_constraints (ctrl_t ctrl, const char *pw,
165                               char **failed_constraint)
166 {
167   gpg_error_t err = 0;
168   unsigned int minlen = opt.min_passphrase_len;
169   unsigned int minnonalpha = opt.min_passphrase_nonalpha;
170   char *msg1 = NULL;
171   char *msg2 = NULL;
172   char *msg3 = NULL;
173
174   if (ctrl && ctrl->pinentry_mode == PINENTRY_MODE_LOOPBACK)
175     return 0;
176
177   if (!pw)
178     pw = "";
179
180   /* The first check is to warn about an empty passphrase. */
181   if (!*pw)
182     {
183       const char *desc = (opt.enforce_passphrase_constraints?
184                           L_("You have not entered a passphrase!%0A"
185                              "An empty passphrase is not allowed.") :
186                           L_("You have not entered a passphrase - "
187                              "this is in general a bad idea!%0A"
188                              "Please confirm that you do not want to "
189                              "have any protection on your key."));
190
191       err = 1;
192       if (failed_constraint)
193         {
194           if (opt.enforce_passphrase_constraints)
195             *failed_constraint = xstrdup (desc);
196           else
197             err = take_this_one_anyway (ctrl, desc,
198                                         L_("Yes, protection is not needed"));
199         }
200
201       goto leave;
202     }
203
204   /* Now check the constraints and collect the error messages unless
205      in silent mode which returns immediately.  */
206   if (utf8_charcount (pw, -1) < minlen )
207     {
208       if (!failed_constraint)
209         {
210           err = gpg_error (GPG_ERR_INV_PASSPHRASE);
211           goto leave;
212         }
213
214       msg1 = xtryasprintf
215         ( ngettext ("A passphrase should be at least %u character long.",
216                     "A passphrase should be at least %u characters long.",
217                     minlen), minlen );
218       if (!msg1)
219         {
220           err = gpg_error_from_syserror ();
221           goto leave;
222         }
223     }
224
225   if (nonalpha_count (pw) < minnonalpha )
226     {
227       if (!failed_constraint)
228         {
229           err = gpg_error (GPG_ERR_INV_PASSPHRASE);
230           goto leave;
231         }
232
233       msg2 = xtryasprintf
234         ( ngettext ("A passphrase should contain at least %u digit or%%0A"
235                     "special character.",
236                     "A passphrase should contain at least %u digits or%%0A"
237                     "special characters.",
238                     minnonalpha), minnonalpha );
239       if (!msg2)
240         {
241           err = gpg_error_from_syserror ();
242           goto leave;
243         }
244     }
245
246   /* If configured check the passphrase against a list of known words
247      and pattern.  The actual test is done by an external program.
248      The warning message is generic to give the user no hint on how to
249      circumvent this list.  */
250   if (*pw && opt.check_passphrase_pattern &&
251       check_passphrase_pattern (ctrl, pw))
252     {
253       if (!failed_constraint)
254         {
255           err = gpg_error (GPG_ERR_INV_PASSPHRASE);
256           goto leave;
257         }
258
259       msg3 = xtryasprintf
260         (L_("A passphrase may not be a known term or match%%0A"
261             "certain pattern."));
262       if (!msg3)
263         {
264           err = gpg_error_from_syserror ();
265           goto leave;
266         }
267     }
268
269   if (failed_constraint && (msg1 || msg2 || msg3))
270     {
271       char *msg;
272       size_t n;
273
274       msg = strconcat
275         (L_("Warning: You have entered an insecure passphrase."),
276          "%0A%0A",
277          msg1? msg1 : "", msg1? "%0A" : "",
278          msg2? msg2 : "", msg2? "%0A" : "",
279          msg3? msg3 : "", msg3? "%0A" : "",
280          NULL);
281       if (!msg)
282         {
283           err = gpg_error_from_syserror ();
284           goto leave;
285         }
286       /* Strip a trailing "%0A".  */
287       n = strlen (msg);
288       if (n > 3 && !strcmp (msg + n - 3, "%0A"))
289         msg[n-3] = 0;
290
291       err = 1;
292       if (opt.enforce_passphrase_constraints)
293         *failed_constraint = msg;
294       else
295         {
296           err = take_this_one_anyway (ctrl, msg, L_("Take this one anyway"));
297           xfree (msg);
298         }
299     }
300
301  leave:
302   xfree (msg1);
303   xfree (msg2);
304   xfree (msg3);
305   return err;
306 }
307
308
309 /* Callback function to compare the first entered PIN with the one
310    currently being entered. */
311 static gpg_error_t
312 reenter_compare_cb (struct pin_entry_info_s *pi)
313 {
314   const char *pin1 = pi->check_cb_arg;
315
316   if (!strcmp (pin1, pi->pin))
317     return 0; /* okay */
318   return gpg_error (GPG_ERR_BAD_PASSPHRASE);
319 }
320
321
322 /* Ask the user for a new passphrase using PROMPT.  On success the
323    function returns 0 and store the passphrase at R_PASSPHRASE; if the
324    user opted not to use a passphrase NULL will be stored there.  The
325    user needs to free the returned string.  In case of an error and
326    error code is returned and NULL stored at R_PASSPHRASE.  */
327 gpg_error_t
328 agent_ask_new_passphrase (ctrl_t ctrl, const char *prompt,
329                           char **r_passphrase)
330 {
331   gpg_error_t err;
332   const char *text1 = prompt;
333   const char *text2 = L_("Please re-enter this passphrase");
334   char *initial_errtext = NULL;
335   struct pin_entry_info_s *pi, *pi2;
336
337   *r_passphrase = NULL;
338
339   if (ctrl->pinentry_mode == PINENTRY_MODE_LOOPBACK)
340     {
341         size_t size;
342         unsigned char *buffer;
343
344         err = pinentry_loopback (ctrl, "NEW_PASSPHRASE", &buffer, &size,
345                                  MAX_PASSPHRASE_LEN);
346         if (!err)
347           {
348             if (size)
349               {
350                 buffer[size] = 0;
351                 *r_passphrase = buffer;
352               }
353             else
354                 *r_passphrase = NULL;
355           }
356         return err;
357     }
358
359   pi = gcry_calloc_secure (1, sizeof (*pi) + MAX_PASSPHRASE_LEN + 1);
360   if (!pi)
361     return gpg_error_from_syserror ();
362   pi2 = gcry_calloc_secure (1, sizeof (*pi2) + MAX_PASSPHRASE_LEN + 1);
363   if (!pi2)
364     {
365       err = gpg_error_from_syserror ();
366       xfree (pi2);
367       return err;
368     }
369   pi->max_length = MAX_PASSPHRASE_LEN + 1;
370   pi->max_tries = 3;
371   pi->with_qualitybar = 1;
372   pi->with_repeat = 1;
373   pi2->max_length = MAX_PASSPHRASE_LEN + 1;
374   pi2->max_tries = 3;
375   pi2->check_cb = reenter_compare_cb;
376   pi2->check_cb_arg = pi->pin;
377
378  next_try:
379   err = agent_askpin (ctrl, text1, NULL, initial_errtext, pi, NULL, 0);
380   xfree (initial_errtext);
381   initial_errtext = NULL;
382   if (!err)
383     {
384       if (check_passphrase_constraints (ctrl, pi->pin, &initial_errtext))
385         {
386           pi->failed_tries = 0;
387           pi2->failed_tries = 0;
388           goto next_try;
389         }
390       /* Unless the passphrase is empty or the pinentry told us that
391          it already did the repetition check, ask to confirm it.  */
392       if (*pi->pin && !pi->repeat_okay)
393         {
394           err = agent_askpin (ctrl, text2, NULL, NULL, pi2, NULL, 0);
395           if (gpg_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
396             { /* The re-entered one did not match and the user did not
397                  hit cancel. */
398               initial_errtext = xtrystrdup (L_("does not match - try again"));
399               if (initial_errtext)
400                 goto next_try;
401               err = gpg_error_from_syserror ();
402             }
403         }
404     }
405
406   if (!err && *pi->pin)
407     {
408       /* User wants a passphrase. */
409       *r_passphrase = xtrystrdup (pi->pin);
410       if (!*r_passphrase)
411         err = gpg_error_from_syserror ();
412     }
413
414   xfree (initial_errtext);
415   xfree (pi2);
416   xfree (pi);
417   return err;
418 }
419
420
421
422 /* Generate a new keypair according to the parameters given in
423    KEYPARAM.  If CACHE_NONCE is given first try to lookup a passphrase
424    using the cache nonce.  If NO_PROTECTION is true the key will not
425    be protected by a passphrase.  If OVERRIDE_PASSPHRASE is true that
426    passphrase will be used for the new key.  */
427 int
428 agent_genkey (ctrl_t ctrl, const char *cache_nonce,
429               const char *keyparam, size_t keyparamlen, int no_protection,
430               const char *override_passphrase, int preset, membuf_t *outbuf)
431 {
432   gcry_sexp_t s_keyparam, s_key, s_private, s_public;
433   char *passphrase_buffer = NULL;
434   const char *passphrase;
435   int rc;
436   size_t len;
437   char *buf;
438
439   rc = gcry_sexp_sscan (&s_keyparam, NULL, keyparam, keyparamlen);
440   if (rc)
441     {
442       log_error ("failed to convert keyparam: %s\n", gpg_strerror (rc));
443       return gpg_error (GPG_ERR_INV_DATA);
444     }
445
446   /* Get the passphrase now, cause key generation may take a while. */
447   if (override_passphrase)
448     passphrase = override_passphrase;
449   else if (no_protection || !cache_nonce)
450     passphrase = NULL;
451   else
452     {
453       passphrase_buffer = agent_get_cache (ctrl, cache_nonce, CACHE_MODE_NONCE);
454       passphrase = passphrase_buffer;
455     }
456
457   if (passphrase || no_protection)
458     ;
459   else
460     {
461       rc = agent_ask_new_passphrase (ctrl,
462                                      L_("Please enter the passphrase to%0A"
463                                         "protect your new key"),
464                                      &passphrase_buffer);
465       if (rc)
466         return rc;
467       passphrase = passphrase_buffer;
468     }
469
470   rc = gcry_pk_genkey (&s_key, s_keyparam );
471   gcry_sexp_release (s_keyparam);
472   if (rc)
473     {
474       log_error ("key generation failed: %s\n", gpg_strerror (rc));
475       xfree (passphrase_buffer);
476       return rc;
477     }
478
479   /* break out the parts */
480   s_private = gcry_sexp_find_token (s_key, "private-key", 0);
481   if (!s_private)
482     {
483       log_error ("key generation failed: invalid return value\n");
484       gcry_sexp_release (s_key);
485       xfree (passphrase_buffer);
486       return gpg_error (GPG_ERR_INV_DATA);
487     }
488   s_public = gcry_sexp_find_token (s_key, "public-key", 0);
489   if (!s_public)
490     {
491       log_error ("key generation failed: invalid return value\n");
492       gcry_sexp_release (s_private);
493       gcry_sexp_release (s_key);
494       xfree (passphrase_buffer);
495       return gpg_error (GPG_ERR_INV_DATA);
496     }
497   gcry_sexp_release (s_key); s_key = NULL;
498
499   /* store the secret key */
500   if (DBG_CRYPTO)
501     log_debug ("storing private key\n");
502   rc = store_key (s_private, passphrase, 0, ctrl->s2k_count);
503   if (!rc)
504     {
505       if (!cache_nonce)
506         {
507           char tmpbuf[12];
508           gcry_create_nonce (tmpbuf, 12);
509           cache_nonce = bin2hex (tmpbuf, 12, NULL);
510         }
511       if (cache_nonce
512           && !no_protection
513           && !agent_put_cache (ctrl, cache_nonce, CACHE_MODE_NONCE,
514                                passphrase, ctrl->cache_ttl_opt_preset))
515         agent_write_status (ctrl, "CACHE_NONCE", cache_nonce, NULL);
516       if (preset && !no_protection)
517         {
518           unsigned char grip[20];
519           char hexgrip[40+1];
520           if (gcry_pk_get_keygrip (s_private, grip))
521             {
522               bin2hex(grip, 20, hexgrip);
523               rc = agent_put_cache (ctrl, hexgrip, CACHE_MODE_ANY, passphrase,
524                                     ctrl->cache_ttl_opt_preset);
525             }
526         }
527     }
528   xfree (passphrase_buffer);
529   passphrase_buffer = NULL;
530   passphrase = NULL;
531   gcry_sexp_release (s_private);
532   if (rc)
533     {
534       gcry_sexp_release (s_public);
535       return rc;
536     }
537
538   /* return the public key */
539   if (DBG_CRYPTO)
540     log_debug ("returning public key\n");
541   len = gcry_sexp_sprint (s_public, GCRYSEXP_FMT_CANON, NULL, 0);
542   log_assert (len);
543   buf = xtrymalloc (len);
544   if (!buf)
545     {
546       gpg_error_t tmperr = out_of_core ();
547       gcry_sexp_release (s_private);
548       gcry_sexp_release (s_public);
549       return tmperr;
550     }
551   len = gcry_sexp_sprint (s_public, GCRYSEXP_FMT_CANON, buf, len);
552   log_assert (len);
553   put_membuf (outbuf, buf, len);
554   gcry_sexp_release (s_public);
555   xfree (buf);
556
557   return 0;
558 }
559
560
561 \f
562 /* Apply a new passphrase to the key S_SKEY and store it.  If
563    PASSPHRASE_ADDR and *PASSPHRASE_ADDR are not NULL, use that
564    passphrase.  If PASSPHRASE_ADDR is not NULL store a newly entered
565    passphrase at that address. */
566 gpg_error_t
567 agent_protect_and_store (ctrl_t ctrl, gcry_sexp_t s_skey,
568                          char **passphrase_addr)
569 {
570   gpg_error_t err;
571
572   if (passphrase_addr && *passphrase_addr)
573     {
574       /* Take an empty string as request not to protect the key.  */
575       err = store_key (s_skey, **passphrase_addr? *passphrase_addr:NULL, 1,
576               ctrl->s2k_count);
577     }
578   else
579     {
580       char *pass = NULL;
581
582       if (passphrase_addr)
583         {
584           xfree (*passphrase_addr);
585           *passphrase_addr = NULL;
586         }
587       err = agent_ask_new_passphrase (ctrl,
588                                       L_("Please enter the new passphrase"),
589                                       &pass);
590       if (!err)
591         err = store_key (s_skey, pass, 1, ctrl->s2k_count);
592       if (!err && passphrase_addr)
593         *passphrase_addr = pass;
594       else
595         xfree (pass);
596     }
597
598   return err;
599 }