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