agent: Re-introduce --enable-extended-key-format.
[gnupg.git] / agent / cache.c
1 /* cache.c - keep a cache of passphrases
2  * Copyright (C) 2002, 2010 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <time.h>
26 #include <assert.h>
27 #include <npth.h>
28
29 #include "agent.h"
30
31 /* The default TTL for DATA items.  This has no configure
32  * option because it is expected that clients provide a TTL.  */
33 #define DEF_CACHE_TTL_DATA  (10 * 60)  /* 10 minutes.  */
34
35 /* The size of the encryption key in bytes.  */
36 #define ENCRYPTION_KEYSIZE (128/8)
37
38 /* A mutex used to serialize access to the cache.  */
39 static npth_mutex_t cache_lock;
40 /* The encryption context.  This is the only place where the
41    encryption key for all cached entries is available.  It would be nice
42    to keep this (or just the key) in some hardware device, for example
43    a TPM.  Libgcrypt could be extended to provide such a service.
44    With the current scheme it is easy to retrieve the cached entries
45    if access to Libgcrypt's memory is available.  The encryption
46    merely avoids grepping for clear texts in the memory.  Nevertheless
47    the encryption provides the necessary infrastructure to make it
48    more secure.  */
49 static gcry_cipher_hd_t encryption_handle;
50
51
52 struct secret_data_s {
53   int  totallen; /* This includes the padding and space for AESWRAP. */
54   char data[1];  /* A string.  */
55 };
56
57 /* The cache object.  */
58 typedef struct cache_item_s *ITEM;
59 struct cache_item_s {
60   ITEM next;
61   time_t created;
62   time_t accessed;  /* Not updated for CACHE_MODE_DATA */
63   int ttl;  /* max. lifetime given in seconds, -1 one means infinite */
64   struct secret_data_s *pw;
65   cache_mode_t cache_mode;
66   int restricted;  /* The value of ctrl->restricted is part of the key.  */
67   char key[1];
68 };
69
70 /* The cache himself.  */
71 static ITEM thecache;
72
73 /* NULL or the last cache key stored by agent_store_cache_hit.  */
74 static char *last_stored_cache_key;
75
76
77 /* This function must be called once to initialize this module. It
78    has to be done before a second thread is spawned.  */
79 void
80 initialize_module_cache (void)
81 {
82   int err;
83
84   err = npth_mutex_init (&cache_lock, NULL);
85
86   if (err)
87     log_fatal ("error initializing cache module: %s\n", strerror (err));
88 }
89
90
91 void
92 deinitialize_module_cache (void)
93 {
94   gcry_cipher_close (encryption_handle);
95   encryption_handle = NULL;
96 }
97
98
99 /* We do the encryption init on the fly.  We can't do it in the module
100    init code because that is run before we listen for connections and
101    in case we are started on demand by gpg etc. it will only wait for
102    a few seconds to decide whether the agent may now accept
103    connections.  Thus we should get into listen state as soon as
104    possible.  */
105 static gpg_error_t
106 init_encryption (void)
107 {
108   gpg_error_t err;
109   void *key;
110
111   if (encryption_handle)
112     return 0; /* Shortcut - Already initialized.  */
113
114   err = gcry_cipher_open (&encryption_handle, GCRY_CIPHER_AES128,
115                           GCRY_CIPHER_MODE_AESWRAP, GCRY_CIPHER_SECURE);
116   if (!err)
117     {
118       key = gcry_random_bytes (ENCRYPTION_KEYSIZE, GCRY_STRONG_RANDOM);
119       if (!key)
120         err = gpg_error_from_syserror ();
121       else
122         {
123           err = gcry_cipher_setkey (encryption_handle, key, ENCRYPTION_KEYSIZE);
124           xfree (key);
125         }
126       if (err)
127         {
128           gcry_cipher_close (encryption_handle);
129           encryption_handle = NULL;
130         }
131     }
132   if (err)
133     log_error ("error initializing cache encryption context: %s\n",
134                gpg_strerror (err));
135
136   return err? gpg_error (GPG_ERR_NOT_INITIALIZED) : 0;
137 }
138
139
140
141 static void
142 release_data (struct secret_data_s *data)
143 {
144    xfree (data);
145 }
146
147 static gpg_error_t
148 new_data (const char *string, struct secret_data_s **r_data)
149 {
150   gpg_error_t err;
151   struct secret_data_s *d, *d_enc;
152   size_t length;
153   int total;
154
155   *r_data = NULL;
156
157   err = init_encryption ();
158   if (err)
159     return err;
160
161   length = strlen (string) + 1;
162
163   /* We pad the data to 32 bytes so that it get more complicated
164      finding something out by watching allocation patterns.  This is
165      usually not possible but we better assume nothing about our secure
166      storage provider.  To support the AESWRAP mode we need to add 8
167      extra bytes as well. */
168   total = (length + 8) + 32 - ((length+8) % 32);
169
170   d = xtrymalloc_secure (sizeof *d + total - 1);
171   if (!d)
172     return gpg_error_from_syserror ();
173   memcpy (d->data, string, length);
174
175   d_enc = xtrymalloc (sizeof *d_enc + total - 1);
176   if (!d_enc)
177     {
178       err = gpg_error_from_syserror ();
179       xfree (d);
180       return err;
181     }
182
183   d_enc->totallen = total;
184   err = gcry_cipher_encrypt (encryption_handle, d_enc->data, total,
185                              d->data, total - 8);
186   xfree (d);
187   if (err)
188     {
189       xfree (d_enc);
190       return err;
191     }
192   *r_data = d_enc;
193   return 0;
194 }
195
196
197
198 /* Check whether there are items to expire.  */
199 static void
200 housekeeping (void)
201 {
202   ITEM r, rprev;
203   time_t current = gnupg_get_time ();
204
205   /* First expire the actual data */
206   for (r=thecache; r; r = r->next)
207     {
208       if (r->pw && r->ttl >= 0 && r->accessed + r->ttl < current)
209         {
210           if (DBG_CACHE)
211             log_debug ("  expired '%s'.%d (%ds after last access)\n",
212                        r->key, r->restricted, r->ttl);
213           release_data (r->pw);
214           r->pw = NULL;
215           r->accessed = current;
216         }
217     }
218
219   /* Second, make sure that we also remove them based on the created
220    * stamp so that the user has to enter it from time to time.  We
221    * don't do this for data items which are used to storage secrets in
222    * meory and are not user entered passphrases etc.  */
223   for (r=thecache; r; r = r->next)
224     {
225       unsigned long maxttl;
226
227       switch (r->cache_mode)
228         {
229         case CACHE_MODE_DATA:
230           continue;  /* No MAX TTL here.  */
231         case CACHE_MODE_SSH: maxttl = opt.max_cache_ttl_ssh; break;
232         default: maxttl = opt.max_cache_ttl; break;
233         }
234       if (r->pw && r->created + maxttl < current)
235         {
236           if (DBG_CACHE)
237             log_debug ("  expired '%s'.%d (%lus after creation)\n",
238                        r->key, r->restricted, opt.max_cache_ttl);
239           release_data (r->pw);
240           r->pw = NULL;
241           r->accessed = current;
242         }
243     }
244
245   /* Third, make sure that we don't have too many items in the list.
246    * Expire old and unused entries after 30 minutes.  */
247   for (rprev=NULL, r=thecache; r; )
248     {
249       if (!r->pw && r->ttl >= 0 && r->accessed + 60*30 < current)
250         {
251           ITEM r2 = r->next;
252           if (DBG_CACHE)
253             log_debug ("  removed '%s'.%d (mode %d) (slot not used for 30m)\n",
254                        r->key, r->restricted, r->cache_mode);
255           xfree (r);
256           if (!rprev)
257             thecache = r2;
258           else
259             rprev->next = r2;
260           r = r2;
261         }
262       else
263         {
264           rprev = r;
265           r = r->next;
266         }
267     }
268 }
269
270
271 void
272 agent_cache_housekeeping (void)
273 {
274   int res;
275
276   if (DBG_CACHE)
277     log_debug ("agent_cache_housekeeping\n");
278
279   res = npth_mutex_lock (&cache_lock);
280   if (res)
281     log_fatal ("failed to acquire cache mutex: %s\n", strerror (res));
282
283   housekeeping ();
284
285   res = npth_mutex_unlock (&cache_lock);
286   if (res)
287     log_fatal ("failed to release cache mutex: %s\n", strerror (res));
288 }
289
290
291 void
292 agent_flush_cache (void)
293 {
294   ITEM r;
295   int res;
296
297   if (DBG_CACHE)
298     log_debug ("agent_flush_cache\n");
299
300   res = npth_mutex_lock (&cache_lock);
301   if (res)
302     log_fatal ("failed to acquire cache mutex: %s\n", strerror (res));
303
304   for (r=thecache; r; r = r->next)
305     {
306       if (r->pw)
307         {
308           if (DBG_CACHE)
309             log_debug ("  flushing '%s'.%d\n", r->key, r->restricted);
310           release_data (r->pw);
311           r->pw = NULL;
312           r->accessed = 0;
313         }
314     }
315
316   res = npth_mutex_unlock (&cache_lock);
317   if (res)
318     log_fatal ("failed to release cache mutex: %s\n", strerror (res));
319 }
320
321
322 /* Compare two cache modes.  */
323 static int
324 cache_mode_equal (cache_mode_t a, cache_mode_t b)
325 {
326   /* CACHE_MODE_ANY matches any mode other than CACHE_MODE_IGNORE.  */
327   return ((a == CACHE_MODE_ANY
328            && !(b == CACHE_MODE_IGNORE || b == CACHE_MODE_DATA))
329           || (b == CACHE_MODE_ANY
330               && !(a == CACHE_MODE_IGNORE || a == CACHE_MODE_DATA))
331           || a == b);
332 }
333
334
335 /* Store the string DATA in the cache under KEY and mark it with a
336    maximum lifetime of TTL seconds.  If there is already data under
337    this key, it will be replaced.  Using a DATA of NULL deletes the
338    entry.  A TTL of 0 is replaced by the default TTL and a TTL of -1
339    set infinite timeout.  CACHE_MODE is stored with the cache entry
340    and used to select different timeouts.  */
341 int
342 agent_put_cache (ctrl_t ctrl, const char *key, cache_mode_t cache_mode,
343                  const char *data, int ttl)
344 {
345   gpg_error_t err = 0;
346   ITEM r;
347   int res;
348   int restricted = ctrl? ctrl->restricted : -1;
349
350   res = npth_mutex_lock (&cache_lock);
351   if (res)
352     log_fatal ("failed to acquire cache mutex: %s\n", strerror (res));
353
354   if (DBG_CACHE)
355     log_debug ("agent_put_cache '%s'.%d (mode %d) requested ttl=%d\n",
356                key, restricted, cache_mode, ttl);
357   housekeeping ();
358
359   if (!ttl)
360     {
361       switch(cache_mode)
362         {
363         case CACHE_MODE_SSH: ttl = opt.def_cache_ttl_ssh; break;
364         case CACHE_MODE_DATA: ttl = DEF_CACHE_TTL_DATA; break;
365         default: ttl = opt.def_cache_ttl; break;
366         }
367     }
368   if ((!ttl && data) || cache_mode == CACHE_MODE_IGNORE)
369     goto out;
370
371   for (r=thecache; r; r = r->next)
372     {
373       if (((cache_mode != CACHE_MODE_USER
374             && cache_mode != CACHE_MODE_NONCE)
375            || cache_mode_equal (r->cache_mode, cache_mode))
376           && r->restricted == restricted
377           && !strcmp (r->key, key))
378         break;
379     }
380   if (r) /* Replace.  */
381     {
382       if (r->pw)
383         {
384           release_data (r->pw);
385           r->pw = NULL;
386         }
387       if (data)
388         {
389           r->created = r->accessed = gnupg_get_time ();
390           r->ttl = ttl;
391           r->cache_mode = cache_mode;
392           err = new_data (data, &r->pw);
393           if (err)
394             log_error ("error replacing cache item: %s\n", gpg_strerror (err));
395         }
396     }
397   else if (data) /* Insert.  */
398     {
399       r = xtrycalloc (1, sizeof *r + strlen (key));
400       if (!r)
401         err = gpg_error_from_syserror ();
402       else
403         {
404           strcpy (r->key, key);
405           r->restricted = restricted;
406           r->created = r->accessed = gnupg_get_time ();
407           r->ttl = ttl;
408           r->cache_mode = cache_mode;
409           err = new_data (data, &r->pw);
410           if (err)
411             xfree (r);
412           else
413             {
414               r->next = thecache;
415               thecache = r;
416             }
417         }
418       if (err)
419         log_error ("error inserting cache item: %s\n", gpg_strerror (err));
420     }
421
422  out:
423   res = npth_mutex_unlock (&cache_lock);
424   if (res)
425     log_fatal ("failed to release cache mutex: %s\n", strerror (res));
426
427   return err;
428 }
429
430
431 /* Try to find an item in the cache.  */
432 char *
433 agent_get_cache (ctrl_t ctrl, const char *key, cache_mode_t cache_mode)
434 {
435   gpg_error_t err;
436   ITEM r;
437   char *value = NULL;
438   int res;
439   int last_stored = 0;
440   int restricted = ctrl? ctrl->restricted : -1;
441
442   if (cache_mode == CACHE_MODE_IGNORE)
443     return NULL;
444
445   res = npth_mutex_lock (&cache_lock);
446   if (res)
447     log_fatal ("failed to acquire cache mutex: %s\n", strerror (res));
448
449   if (!key)
450     {
451       key = last_stored_cache_key;
452       if (!key)
453         goto out;
454       last_stored = 1;
455     }
456
457   if (DBG_CACHE)
458     log_debug ("agent_get_cache '%s'.%d (mode %d)%s ...\n",
459                key, ctrl->restricted, cache_mode,
460                last_stored? " (stored cache key)":"");
461   housekeeping ();
462
463   for (r=thecache; r; r = r->next)
464     {
465       if (r->pw
466           && ((cache_mode != CACHE_MODE_USER
467                && cache_mode != CACHE_MODE_NONCE)
468               || cache_mode_equal (r->cache_mode, cache_mode))
469           && r->restricted == restricted
470           && !strcmp (r->key, key))
471         {
472           /* Note: To avoid races KEY may not be accessed anymore
473            * below.  Note also that we don't update the accessed time
474            * for data items.  */
475           if (r->cache_mode != CACHE_MODE_DATA)
476             r->accessed = gnupg_get_time ();
477           if (DBG_CACHE)
478             log_debug ("... hit\n");
479           if (r->pw->totallen < 32)
480             err = gpg_error (GPG_ERR_INV_LENGTH);
481           else if ((err = init_encryption ()))
482             ;
483           else if (!(value = xtrymalloc_secure (r->pw->totallen - 8)))
484             err = gpg_error_from_syserror ();
485           else
486             {
487               err = gcry_cipher_decrypt (encryption_handle,
488                                          value, r->pw->totallen - 8,
489                                          r->pw->data, r->pw->totallen);
490             }
491           if (err)
492             {
493               xfree (value);
494               value = NULL;
495               log_error ("retrieving cache entry '%s'.%d failed: %s\n",
496                          key, restricted, gpg_strerror (err));
497             }
498           break;
499         }
500     }
501   if (DBG_CACHE && value == NULL)
502     log_debug ("... miss\n");
503
504  out:
505   res = npth_mutex_unlock (&cache_lock);
506   if (res)
507     log_fatal ("failed to release cache mutex: %s\n", strerror (res));
508
509   return value;
510 }
511
512
513 /* Store the key for the last successful cache hit.  That value is
514    used by agent_get_cache if the requested KEY is given as NULL.
515    NULL may be used to remove that key. */
516 void
517 agent_store_cache_hit (const char *key)
518 {
519   char *new;
520   char *old;
521
522   /* To make sure the update is atomic under the non-preemptive thread
523    * model, we must make sure not to surrender control to a different
524    * thread.  Therefore, we avoid calling the allocator during the
525    * update.
526    *
527    * Background: xtrystrdup uses gcry_strdup which may use the secure
528    * memory allocator of Libgcrypt.  That allocator takes locks and
529    * since version 1.14 libgpg-error is nPth aware and thus taking a
530    * lock may now lead to thread switch.  Note that this only happens
531    * when secure memory is _allocated_ (the standard allocator uses
532    * malloc which is not nPth aware) but not when calling _xfree_
533    * because gcry_free needs to check whether the pointer is in secure
534    * memory and thus needs to take a lock.
535    */
536   new = key ? xtrystrdup (key) : NULL;
537
538   /* Atomic update.  */
539   old = last_stored_cache_key;
540   last_stored_cache_key = new;
541   /* Done.  */
542
543   xfree (old);
544 }