Merge branch 'master' into ECC-INTEGRATION-2-1
[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 <http://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 <pth.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 protect the encryption.  This is required because
35    we use one context to do all encryption and decryption.  */
36 static pth_mutex_t encryption_lock;
37 /* The encryption context.  This is the only place where the
38    encryption key for all cached entries is available.  It would be nice
39    to keep this (or just the key) in some hardware device, for example
40    a TPM.  Libgcrypt could be extended to provide such a service.
41    With the current scheme it is easy to retrieve the cached entries
42    if access to Libgcrypt's memory is available.  The encryption
43    merely avoids grepping for clear texts in the memory.  Nevertheless
44    the encryption provides the necessary infrastructure to make it
45    more secure.  */
46 static gcry_cipher_hd_t encryption_handle;
47
48
49 struct secret_data_s {
50   int  totallen; /* This includes the padding and space for AESWRAP. */
51   char data[1];  /* A string.  */
52 };
53
54 typedef struct cache_item_s *ITEM;
55 struct cache_item_s {
56   ITEM next;
57   time_t created;
58   time_t accessed;
59   int ttl;  /* max. lifetime given in seconds, -1 one means infinite */
60   struct secret_data_s *pw;
61   cache_mode_t cache_mode;
62   char key[1];
63 };
64
65 /* The cache himself.  */
66 static ITEM thecache;
67
68
69 /* This function must be called once to initialize this module. It
70    has to be done before a second thread is spawned.  */
71 void
72 initialize_module_cache (void)
73 {
74   if (!pth_mutex_init (&encryption_lock))
75     {
76       gpg_error_t err = gpg_error_from_syserror ();
77       log_fatal ("error initializing cache module: %s\n", gpg_strerror (err));
78     }
79 }
80
81
82 void
83 deinitialize_module_cache (void)
84 {
85   gcry_cipher_close (encryption_handle);
86   encryption_handle = NULL;
87 }
88
89
90 /* We do the encryption init on the fly.  We can't do it in the module
91    init code because that is run before we listen for connections and
92    in case we are started on demand by gpg etc. it will only wait for
93    a few seconds to decide whether the agent may now accept
94    connections.  Thus we should get into listen state as soon as
95    possible.  */
96 static gpg_error_t
97 init_encryption (void)
98 {
99   gpg_error_t err;
100   void *key;
101
102   if (encryption_handle)
103     return 0; /* Shortcut - Already initialized.  */
104
105   if (!pth_mutex_acquire (&encryption_lock, 0, NULL))
106     log_fatal ("failed to acquire cache encryption mutex\n");
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   if (!pth_mutex_release (&encryption_lock))
131     log_fatal ("failed to release cache encryption mutex\n");
132
133   return err? gpg_error (GPG_ERR_NOT_INITIALIZED) : 0;
134 }
135
136
137
138 static void
139 release_data (struct secret_data_s *data)
140 {
141    xfree (data);
142 }
143
144 static gpg_error_t
145 new_data (const char *string, struct secret_data_s **r_data)
146 {
147   gpg_error_t err;
148   struct secret_data_s *d, *d_enc;
149   size_t length;
150   int total;
151   
152   *r_data = NULL;
153
154   err = init_encryption ();
155   if (err)
156     return err;
157
158   length = strlen (string) + 1;
159
160   /* We pad the data to 32 bytes so that it get more complicated
161      finding something out by watching allocation patterns.  This is
162      usally not possible but we better assume nothing about our secure
163      storage provider.  To support the AESWRAP mode we need to add 8
164      extra bytes as well. */
165   total = (length + 8) + 32 - ((length+8) % 32);
166
167   d = xtrymalloc_secure (sizeof *d + total - 1);
168   if (!d)
169     return gpg_error_from_syserror ();
170   memcpy (d->data, string, length);
171
172   d_enc = xtrymalloc (sizeof *d_enc + total - 1);
173   if (!d_enc)
174     {
175       err = gpg_error_from_syserror ();
176       xfree (d);
177       return err;
178     }
179
180   d_enc->totallen = total;
181   if (!pth_mutex_acquire (&encryption_lock, 0, NULL))
182     log_fatal ("failed to acquire cache encryption mutex\n");
183   err = gcry_cipher_encrypt (encryption_handle, d_enc->data, total,
184                              d->data, total - 8);
185   xfree (d);
186   if (!pth_mutex_release (&encryption_lock))
187     log_fatal ("failed to release cache encryption mutex\n");
188   if (err)
189     {
190       xfree (d_enc);
191       return err;
192     }
193   *r_data = d_enc;
194   return 0;
195 }
196
197
198
199 /* Check whether there are items to expire.  */
200 static void
201 housekeeping (void)
202 {
203   ITEM r, rprev;
204   time_t current = gnupg_get_time ();
205
206   /* First expire the actual data */
207   for (r=thecache; r; r = r->next)
208     {
209       if (r->pw && r->ttl >= 0 && r->accessed + r->ttl < current)
210         {
211           if (DBG_CACHE)
212             log_debug ("  expired `%s' (%ds after last access)\n",
213                        r->key, r->ttl);
214           release_data (r->pw);
215           r->pw = NULL;
216           r->accessed = current;
217         }
218     }
219
220   /* Second, make sure that we also remove them based on the created stamp so
221      that the user has to enter it from time to time. */
222   for (r=thecache; r; r = r->next)
223     {
224       unsigned long maxttl;
225       
226       switch (r->cache_mode)
227         {
228         case CACHE_MODE_SSH: maxttl = opt.max_cache_ttl_ssh; break;
229         default: maxttl = opt.max_cache_ttl; break;
230         }
231       if (r->pw && r->created + maxttl < current)
232         {
233           if (DBG_CACHE)
234             log_debug ("  expired `%s' (%lus after creation)\n",
235                        r->key, opt.max_cache_ttl);
236           release_data (r->pw);
237           r->pw = NULL;
238           r->accessed = current;
239         }
240     }
241
242   /* Third, make sure that we don't have too many items in the list.
243      Expire old and unused entries after 30 minutes */
244   for (rprev=NULL, r=thecache; r; )
245     {
246       if (!r->pw && r->ttl >= 0 && r->accessed + 60*30 < current)
247         {
248           ITEM r2 = r->next;
249           if (DBG_CACHE)
250             log_debug ("  removed `%s' (mode %d) (slot not used for 30m)\n",
251                        r->key, r->cache_mode);
252           xfree (r);
253           if (!rprev)
254             thecache = r2;
255           else
256             rprev->next = r2;
257           r = r2;
258         }
259       else
260         {
261           rprev = r;
262           r = r->next;
263         }
264     }
265 }
266
267
268 void
269 agent_flush_cache (void)
270 {
271   ITEM r;
272
273   if (DBG_CACHE)
274     log_debug ("agent_flush_cache\n");
275
276   for (r=thecache; r; r = r->next)
277     {
278       if (r->pw)
279         {
280           if (DBG_CACHE)
281             log_debug ("  flushing `%s'\n", r->key);
282           release_data (r->pw);
283           r->pw = NULL;
284           r->accessed = 0;
285         }
286     }
287 }
288
289
290
291 /* Store the string DATA in the cache under KEY and mark it with a
292    maximum lifetime of TTL seconds.  If there is already data under
293    this key, it will be replaced.  Using a DATA of NULL deletes the
294    entry.  A TTL of 0 is replaced by the default TTL and a TTL of -1
295    set infinite timeout.  CACHE_MODE is stored with the cache entry
296    and used to select different timeouts.  */
297 int
298 agent_put_cache (const char *key, cache_mode_t cache_mode,
299                  const char *data, int ttl)
300 {
301   gpg_error_t err = 0;
302   ITEM r;
303
304   if (DBG_CACHE)
305     log_debug ("agent_put_cache `%s' (mode %d) requested ttl=%d\n",
306                key, cache_mode, ttl);
307   housekeeping ();
308
309   if (!ttl)
310     {
311       switch(cache_mode)
312         {
313         case CACHE_MODE_SSH: ttl = opt.def_cache_ttl_ssh; break;
314         default: ttl = opt.def_cache_ttl; break;
315         }
316     }
317   if ((!ttl && data) || cache_mode == CACHE_MODE_IGNORE)
318     return 0;
319
320   for (r=thecache; r; r = r->next)
321     {
322       if (((cache_mode != CACHE_MODE_USER
323             && cache_mode != CACHE_MODE_NONCE)
324            || r->cache_mode == cache_mode)
325           && !strcmp (r->key, key))
326         break;
327     }
328   if (r) /* Replace.  */
329     {
330       if (r->pw)
331         {
332           release_data (r->pw);
333           r->pw = NULL;
334         }
335       if (data)
336         {
337           r->created = r->accessed = gnupg_get_time (); 
338           r->ttl = ttl;
339           r->cache_mode = cache_mode;
340           err = new_data (data, &r->pw);
341           if (err)
342             log_error ("error replacing cache item: %s\n", gpg_strerror (err));
343         }
344     }
345   else if (data) /* Insert.  */
346     {
347       r = xtrycalloc (1, sizeof *r + strlen (key));
348       if (!r)
349         err = gpg_error_from_syserror ();
350       else
351         {
352           strcpy (r->key, key);
353           r->created = r->accessed = gnupg_get_time (); 
354           r->ttl = ttl;
355           r->cache_mode = cache_mode;
356           err = new_data (data, &r->pw);
357           if (err)
358             xfree (r);
359           else
360             {
361               r->next = thecache;
362               thecache = r;
363             }
364         }
365       if (err)
366         log_error ("error inserting cache item: %s\n", gpg_strerror (err));
367     }
368   return err;
369 }
370
371
372 /* Try to find an item in the cache.  Note that we currently don't
373    make use of CACHE_MODE except for CACHE_MODE_NONCE and
374    CACHE_MODE_USER.  */
375 char *
376 agent_get_cache (const char *key, cache_mode_t cache_mode)
377 {
378   gpg_error_t err;
379   ITEM r;
380   char *value = NULL;
381
382   if (cache_mode == CACHE_MODE_IGNORE)
383     return NULL;
384
385   if (DBG_CACHE)
386     log_debug ("agent_get_cache `%s' (mode %d) ...\n", key, cache_mode);
387   housekeeping ();
388
389   for (r=thecache; r; r = r->next)
390     {
391       if (r->pw
392           && ((cache_mode != CACHE_MODE_USER
393                && cache_mode != CACHE_MODE_NONCE)
394               || r->cache_mode == cache_mode)
395           && !strcmp (r->key, key))
396         {
397           r->accessed = gnupg_get_time ();
398           if (DBG_CACHE)
399             log_debug ("... hit\n");
400           if (r->pw->totallen < 32)
401             err = gpg_error (GPG_ERR_INV_LENGTH);
402           else if ((err = init_encryption ()))
403             ;
404           else if (!(value = xtrymalloc_secure (r->pw->totallen - 8)))
405             err = gpg_error_from_syserror ();
406           else
407             {
408               if (!pth_mutex_acquire (&encryption_lock, 0, NULL))
409                 log_fatal ("failed to acquire cache encryption mutex\n");
410               err = gcry_cipher_decrypt (encryption_handle,
411                                          value, r->pw->totallen - 8,
412                                          r->pw->data, r->pw->totallen);
413               if (!pth_mutex_release (&encryption_lock))
414                 log_fatal ("failed to release cache encryption mutex\n");
415             }
416           if (err)
417             {
418               xfree (value);
419               value = NULL;
420               log_error ("retrieving cache entry `%s' failed: %s\n",
421                          key, gpg_strerror (err));
422             }
423           return value;
424         }
425     }
426   if (DBG_CACHE)
427     log_debug ("... miss\n");
428
429   return NULL;
430 }
431