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