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