* misc.c (is_secured_filename): New.
[gnupg.git] / g10 / keydb.c
1 /* keydb.c - key database dispatcher
2  * Copyright (C) 2001, 2002, 2003, 2004 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 2 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <unistd.h>
30
31 #include "util.h"
32 #include "options.h"
33 #include "main.h" /*try_make_homedir ()*/
34 #include "packet.h"
35 #include "keyring.h"
36 #include "keydb.h" 
37 #include "i18n.h"
38
39 static int active_handles;
40
41 typedef enum {
42     KEYDB_RESOURCE_TYPE_NONE = 0,
43     KEYDB_RESOURCE_TYPE_KEYRING
44 } KeydbResourceType;
45 #define MAX_KEYDB_RESOURCES 40
46
47 struct resource_item {
48   KeydbResourceType type;
49   union {
50     KEYRING_HANDLE kr;
51   } u;
52   void *token;
53   int secret;
54 };
55
56 static struct resource_item all_resources[MAX_KEYDB_RESOURCES];
57 static int used_resources;
58 static void *primary_keyring=NULL;
59
60 struct keydb_handle {
61   int locked;
62   int found;
63   int current;
64   int used; /* items in active */
65   struct resource_item active[MAX_KEYDB_RESOURCES];
66 };
67
68
69 static int lock_all (KEYDB_HANDLE hd);
70 static void unlock_all (KEYDB_HANDLE hd);
71
72
73 /* Handle the creation of a keyring if it does not yet exist.  Take
74    into acount that other processes might have the keyring already
75    locked.  This lock check does not work if the directory itself is
76    not yet available. */
77 static int
78 maybe_create_keyring (char *filename, int force)
79 {
80   DOTLOCK lockhd = NULL;
81   IOBUF iobuf;
82   int rc;
83   mode_t oldmask;
84   char *last_slash_in_filename;
85
86   /* A quick test whether the filename already exists. */
87   if (!access (filename, F_OK))
88     return 0;
89
90   /* If we don't want to create a new file at all, there is no need to
91      go any further - bail out right here.  */
92   if (!force) 
93     return G10ERR_OPEN_FILE;
94
95   /* First of all we try to create the home directory.  Note, that we
96      don't do any locking here because any sane application of gpg
97      would create the home directory by itself and not rely on gpg's
98      tricky auto-creation which is anyway only done for some home
99      directory name patterns. */
100   last_slash_in_filename = strrchr (filename, DIRSEP_C);
101   *last_slash_in_filename = 0;
102   if (access(filename, F_OK))
103     { 
104       static int tried;
105       
106       if (!tried)
107         {
108           tried = 1;
109           try_make_homedir (filename);
110         }
111       if (access (filename, F_OK))
112         {
113           rc = G10ERR_OPEN_FILE;
114           *last_slash_in_filename = DIRSEP_C;
115           goto leave;
116         }
117     }
118   *last_slash_in_filename = DIRSEP_C;
119
120
121   /* To avoid races with other instances of gpg trying to create or
122      update the keyring (it is removed during an update for a short
123      time), we do the next stuff in a locked state. */
124   lockhd = create_dotlock (filename);
125   if (!lockhd)
126     {
127       /* A reason for this to fail is that the directory is not
128          writable. However, this whole locking stuff does not make
129          sense if this is the case. An empty non-writable directory
130          with no keyring is not really useful at all. */
131       if (opt.verbose)
132         log_info ("can't allocate lock for `%s'\n", filename );
133
134       if (!force) 
135         return G10ERR_OPEN_FILE; 
136       else
137         return G10ERR_GENERAL;
138     }
139
140   if ( make_dotlock (lockhd, -1) )
141     {
142       /* This is something bad.  Probably a stale lockfile.  */
143       log_info ("can't lock `%s'\n", filename );
144       rc = G10ERR_GENERAL;
145       goto leave;
146     }
147
148   /* Now the real test while we are locked. */
149   if (!access(filename, F_OK))
150     {
151       rc = 0;  /* Okay, we may access the file now.  */
152       goto leave;
153     }
154
155   /* The file does not yet exist, create it now. */
156   oldmask = umask (077);
157   if (is_secured_filename (filename))
158     {
159       iobuf = NULL;
160       errno = EPERM;
161     }
162   else
163     iobuf = iobuf_create (filename);
164   umask (oldmask);
165   if (!iobuf) 
166     {
167       log_error ( _("error creating keyring `%s': %s\n"),
168                   filename, strerror(errno));
169       rc = G10ERR_OPEN_FILE;
170       goto leave;
171     }
172
173   if (!opt.quiet)
174     log_info (_("keyring `%s' created\n"), filename);
175
176   iobuf_close (iobuf);
177   /* Must invalidate that ugly cache */
178   iobuf_ioctl (NULL, 2, 0, filename);
179   rc = 0;
180
181  leave:
182   if (lockhd)
183     {
184       release_dotlock (lockhd);
185       destroy_dotlock (lockhd);
186     }
187   return rc;
188 }
189
190
191 /*
192  * Register a resource (which currently may only be a keyring file).
193  * The first keyring which is added by this function is
194  * created if it does not exist.
195  * Note: this function may be called before secure memory is
196  * available.
197  * Flag 1 == force
198  * Flag 2 == default
199  */
200 int
201 keydb_add_resource (const char *url, int flags, int secret)
202 {
203     static int any_secret, any_public;
204     const char *resname = url;
205     char *filename = NULL;
206     int force=(flags&1);
207     int rc = 0;
208     KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
209     void *token;
210
211     /* Do we have an URL?
212      *  gnupg-ring:filename  := this is a plain keyring
213      *  filename := See what is is, but create as plain keyring.
214      */
215     if (strlen (resname) > 11) {
216         if (!strncmp( resname, "gnupg-ring:", 11) ) {
217             rt = KEYDB_RESOURCE_TYPE_KEYRING;
218             resname += 11;
219         }
220 #if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
221         else if (strchr (resname, ':')) {
222             log_error ("invalid key resource URL `%s'\n", url );
223             rc = G10ERR_GENERAL;
224             goto leave;
225         }
226 #endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
227     }
228
229     if (*resname != DIRSEP_C ) { /* do tilde expansion etc */
230         if (strchr(resname, DIRSEP_C) )
231             filename = make_filename (resname, NULL);
232         else
233             filename = make_filename (opt.homedir, resname, NULL);
234     }
235     else
236         filename = m_strdup (resname);
237
238     if (!force)
239         force = secret? !any_secret : !any_public;
240
241     /* see whether we can determine the filetype */
242     if (rt == KEYDB_RESOURCE_TYPE_NONE) {
243         FILE *fp = fopen( filename, "rb" );
244
245         if (fp) {
246             u32 magic;
247
248             if (fread( &magic, 4, 1, fp) == 1 ) {
249                 if (magic == 0x13579ace || magic == 0xce9a5713)
250                     ; /* GDBM magic - no more support */
251                 else
252                     rt = KEYDB_RESOURCE_TYPE_KEYRING;
253             }
254             else /* maybe empty: assume ring */
255                 rt = KEYDB_RESOURCE_TYPE_KEYRING;
256             fclose( fp );
257         }
258         else /* no file yet: create ring */
259             rt = KEYDB_RESOURCE_TYPE_KEYRING;
260     }
261
262     switch (rt) {
263       case KEYDB_RESOURCE_TYPE_NONE:
264         log_error ("unknown type of key resource `%s'\n", url );
265         rc = G10ERR_GENERAL;
266         goto leave;
267
268       case KEYDB_RESOURCE_TYPE_KEYRING:
269         rc = maybe_create_keyring (filename, force);
270         if (rc)
271           goto leave;
272
273         if(keyring_register_filename (filename, secret, &token))
274           {
275             if (used_resources >= MAX_KEYDB_RESOURCES)
276               rc = G10ERR_RESOURCE_LIMIT;
277             else 
278               {
279                 if(flags&2)
280                   primary_keyring=token;
281                 all_resources[used_resources].type = rt;
282                 all_resources[used_resources].u.kr = NULL; /* Not used here */
283                 all_resources[used_resources].token = token;
284                 all_resources[used_resources].secret = secret;
285                 used_resources++;
286               }
287           }
288         else
289           {
290             /* This keyring was already registered, so ignore it.
291                However, we can still mark it as primary even if it was
292                already registered. */
293             if(flags&2)
294               primary_keyring=token;
295           }
296         break;
297
298       default:
299         log_error ("resource type of `%s' not supported\n", url);
300         rc = G10ERR_GENERAL;
301         goto leave;
302     }
303
304     /* fixme: check directory permissions and print a warning */
305
306   leave:
307     if (rc)
308         log_error ("keyblock resource `%s': %s\n", filename, g10_errstr(rc));
309     else if (secret)
310         any_secret = 1;
311     else
312         any_public = 1;
313     m_free (filename);
314     return rc;
315 }
316
317
318
319
320 KEYDB_HANDLE
321 keydb_new (int secret)
322 {
323   KEYDB_HANDLE hd;
324   int i, j;
325   
326   hd = m_alloc_clear (sizeof *hd);
327   hd->found = -1;
328   
329   assert (used_resources <= MAX_KEYDB_RESOURCES);
330   for (i=j=0; i < used_resources; i++)
331     {
332       if (!all_resources[i].secret != !secret)
333         continue;
334       switch (all_resources[i].type)
335         {
336         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
337           break;
338         case KEYDB_RESOURCE_TYPE_KEYRING:
339           hd->active[j].type   = all_resources[i].type;
340           hd->active[j].token  = all_resources[i].token;
341           hd->active[j].secret = all_resources[i].secret;
342           hd->active[j].u.kr = keyring_new (all_resources[i].token, secret);
343           if (!hd->active[j].u.kr) {
344             m_free (hd);
345             return NULL; /* fixme: release all previously allocated handles*/
346           }
347           j++;
348           break;
349         }
350     }
351   hd->used = j;
352   
353   active_handles++;
354   return hd;
355 }
356
357 void 
358 keydb_release (KEYDB_HANDLE hd)
359 {
360     int i;
361
362     if (!hd)
363         return;
364     assert (active_handles > 0);
365     active_handles--;
366
367     unlock_all (hd);
368     for (i=0; i < hd->used; i++) {
369         switch (hd->active[i].type) {
370           case KEYDB_RESOURCE_TYPE_NONE:
371             break;
372           case KEYDB_RESOURCE_TYPE_KEYRING:
373             keyring_release (hd->active[i].u.kr);
374             break;
375         }
376     }
377
378     m_free (hd);
379 }
380
381
382 /*
383  * Return the name of the current resource.  This is function first
384  * looks for the last found found, then for the current search
385  * position, and last returns the first available resource.  The
386  * returned string is only valid as long as the handle exists.  This
387  * function does only return NULL if no handle is specified, in all
388  * other error cases an empty string is returned.
389  */
390 const char *
391 keydb_get_resource_name (KEYDB_HANDLE hd)
392 {
393     int idx;
394     const char *s = NULL;
395
396     if (!hd) 
397         return NULL;
398
399     if ( hd->found >= 0 && hd->found < hd->used) 
400         idx = hd->found;
401     else if ( hd->current >= 0 && hd->current < hd->used) 
402         idx = hd->current;
403     else
404         idx = 0;
405
406     switch (hd->active[idx].type) {
407       case KEYDB_RESOURCE_TYPE_NONE:
408         s = NULL; 
409         break;
410       case KEYDB_RESOURCE_TYPE_KEYRING:
411         s = keyring_get_resource_name (hd->active[idx].u.kr);
412         break;
413     }
414
415     return s? s: "";
416 }
417
418
419
420 static int 
421 lock_all (KEYDB_HANDLE hd)
422 {
423     int i, rc = 0;
424
425     for (i=0; !rc && i < hd->used; i++) {
426         switch (hd->active[i].type) {
427           case KEYDB_RESOURCE_TYPE_NONE:
428             break;
429           case KEYDB_RESOURCE_TYPE_KEYRING:
430             rc = keyring_lock (hd->active[i].u.kr, 1);
431             break;
432         }
433     }
434
435     if (rc) {
436         /* revert the already set locks */
437         for (i--; i >= 0; i--) {
438             switch (hd->active[i].type) {
439               case KEYDB_RESOURCE_TYPE_NONE:
440                 break;
441               case KEYDB_RESOURCE_TYPE_KEYRING:
442                 keyring_lock (hd->active[i].u.kr, 0);
443                 break;
444             }
445         }
446     }
447     else
448         hd->locked = 1;
449
450     return rc;
451 }
452
453 static void
454 unlock_all (KEYDB_HANDLE hd)
455 {
456     int i;
457
458     if (!hd->locked)
459         return;
460
461     for (i=hd->used-1; i >= 0; i--) {
462         switch (hd->active[i].type) {
463           case KEYDB_RESOURCE_TYPE_NONE:
464             break;
465           case KEYDB_RESOURCE_TYPE_KEYRING:
466             keyring_lock (hd->active[i].u.kr, 0);
467             break;
468         }
469     }
470     hd->locked = 0;
471 }
472
473
474 /*
475  * Return the last found keyring.  Caller must free it.
476  * The returned keyblock has the kbode flag bit 0 set for the node with
477  * the public key used to locate the keyblock or flag bit 1 set for 
478  * the user ID node.
479  */
480 int
481 keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
482 {
483     int rc = 0;
484
485     if (!hd)
486         return G10ERR_INV_ARG;
487
488     if ( hd->found < 0 || hd->found >= hd->used) 
489         return -1; /* nothing found */
490
491     switch (hd->active[hd->found].type) {
492       case KEYDB_RESOURCE_TYPE_NONE:
493         rc = G10ERR_GENERAL; /* oops */
494         break;
495       case KEYDB_RESOURCE_TYPE_KEYRING:
496         rc = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
497         break;
498     }
499
500     return rc;
501 }
502
503 /* 
504  * update the current keyblock with KB
505  */
506 int
507 keydb_update_keyblock (KEYDB_HANDLE hd, KBNODE kb)
508 {
509     int rc = 0;
510
511     if (!hd)
512         return G10ERR_INV_ARG;
513
514     if ( hd->found < 0 || hd->found >= hd->used) 
515         return -1; /* nothing found */
516
517     if( opt.dry_run )
518         return 0;
519
520     rc = lock_all (hd);
521     if (rc)
522         return rc;
523
524     switch (hd->active[hd->found].type) {
525       case KEYDB_RESOURCE_TYPE_NONE:
526         rc = G10ERR_GENERAL; /* oops */
527         break;
528       case KEYDB_RESOURCE_TYPE_KEYRING:
529         rc = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
530         break;
531     }
532
533     unlock_all (hd);
534     return rc;
535 }
536
537
538 /* 
539  * Insert a new KB into one of the resources. 
540  */
541 int
542 keydb_insert_keyblock (KEYDB_HANDLE hd, KBNODE kb)
543 {
544     int rc = -1;
545     int idx;
546
547     if (!hd) 
548         return G10ERR_INV_ARG;
549
550     if( opt.dry_run )
551         return 0;
552
553     if ( hd->found >= 0 && hd->found < hd->used) 
554         idx = hd->found;
555     else if ( hd->current >= 0 && hd->current < hd->used) 
556         idx = hd->current;
557     else
558         return G10ERR_GENERAL;
559
560     rc = lock_all (hd);
561     if (rc)
562         return rc;
563
564     switch (hd->active[idx].type) {
565       case KEYDB_RESOURCE_TYPE_NONE:
566         rc = G10ERR_GENERAL; /* oops */
567         break;
568       case KEYDB_RESOURCE_TYPE_KEYRING:
569         rc = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
570         break;
571     }
572
573     unlock_all (hd);
574     return rc;
575 }
576
577
578 /* 
579  * The current keyblock will be deleted.
580  */
581 int
582 keydb_delete_keyblock (KEYDB_HANDLE hd)
583 {
584     int rc = -1;
585
586     if (!hd)
587         return G10ERR_INV_ARG;
588
589     if ( hd->found < 0 || hd->found >= hd->used) 
590         return -1; /* nothing found */
591
592     if( opt.dry_run )
593         return 0;
594
595     rc = lock_all (hd);
596     if (rc)
597         return rc;
598
599     switch (hd->active[hd->found].type) {
600       case KEYDB_RESOURCE_TYPE_NONE:
601         rc = G10ERR_GENERAL; /* oops */
602         break;
603       case KEYDB_RESOURCE_TYPE_KEYRING:
604         rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
605         break;
606     }
607
608     unlock_all (hd);
609     return rc;
610 }
611
612 \f
613 /*
614  * Locate the default writable key resource, so that the next
615  * operation (which is only relevant for inserts) will be done on this
616  * resource.  
617  */
618 int
619 keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
620 {
621   int rc;
622   
623   if (!hd)
624     return G10ERR_INV_ARG;
625   
626   rc = keydb_search_reset (hd); /* this does reset hd->current */
627   if (rc)
628     return rc;
629
630   /* If we have a primary set, try that one first */
631   if(primary_keyring)
632     {
633       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
634         {
635           if(hd->active[hd->current].token==primary_keyring)
636             {
637               if(keyring_is_writable (hd->active[hd->current].token))
638                 return 0;
639               else
640                 break;
641             }
642         }
643
644       rc = keydb_search_reset (hd); /* this does reset hd->current */
645       if (rc)
646         return rc;
647     }
648
649   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++) 
650     {
651       switch (hd->active[hd->current].type) 
652         {
653         case KEYDB_RESOURCE_TYPE_NONE:
654           BUG();
655           break;
656         case KEYDB_RESOURCE_TYPE_KEYRING:
657           if (keyring_is_writable (hd->active[hd->current].token))
658             return 0; /* found (hd->current is set to it) */
659           break;
660         }
661     }
662   
663   return -1;
664 }
665
666 /*
667  * Rebuild the caches of all key resources.
668  */
669 void
670 keydb_rebuild_caches (int noisy)
671 {
672   int i, rc;
673   
674   for (i=0; i < used_resources; i++)
675     {
676       if (all_resources[i].secret)
677         continue;
678       switch (all_resources[i].type)
679         {
680         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
681           break;
682         case KEYDB_RESOURCE_TYPE_KEYRING:
683           rc = keyring_rebuild_cache (all_resources[i].token,noisy);
684           if (rc)
685             log_error (_("failed to rebuild keyring cache: %s\n"),
686                        g10_errstr (rc));
687           break;
688         }
689     }
690 }
691
692
693
694 /* 
695  * Start the next search on this handle right at the beginning
696  */
697 int 
698 keydb_search_reset (KEYDB_HANDLE hd)
699 {
700     int i, rc = 0;
701
702     if (!hd)
703         return G10ERR_INV_ARG;
704
705     hd->current = 0; 
706     hd->found = -1;
707     /* and reset all resources */
708     for (i=0; !rc && i < hd->used; i++) {
709         switch (hd->active[i].type) {
710           case KEYDB_RESOURCE_TYPE_NONE:
711             break;
712           case KEYDB_RESOURCE_TYPE_KEYRING:
713             rc = keyring_search_reset (hd->active[i].u.kr);
714             break;
715         }
716     }
717     return rc; 
718 }
719
720
721 /* 
722  * Search through all keydb resources, starting at the current position,
723  * for a keyblock which contains one of the keys described in the DESC array.
724  */
725 int 
726 keydb_search2 (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
727                size_t ndesc, size_t *descindex)
728 {
729     int rc = -1;
730
731     if (!hd)
732         return G10ERR_INV_ARG;
733
734     while (rc == -1 && hd->current >= 0 && hd->current < hd->used) {
735         switch (hd->active[hd->current].type) {
736           case KEYDB_RESOURCE_TYPE_NONE:
737             BUG(); /* we should never see it here */
738             break;
739           case KEYDB_RESOURCE_TYPE_KEYRING:
740             rc = keyring_search (hd->active[hd->current].u.kr, desc,
741                                  ndesc, descindex);
742             break;
743         }
744         if (rc == -1) /* EOF -> switch to next resource */
745             hd->current++; 
746         else if (!rc)
747             hd->found = hd->current;
748     }
749
750     return rc; 
751 }
752
753 int
754 keydb_search_first (KEYDB_HANDLE hd)
755 {
756     KEYDB_SEARCH_DESC desc;
757
758     memset (&desc, 0, sizeof desc);
759     desc.mode = KEYDB_SEARCH_MODE_FIRST;
760     return keydb_search (hd, &desc, 1);
761 }
762
763 int
764 keydb_search_next (KEYDB_HANDLE hd)
765 {
766     KEYDB_SEARCH_DESC desc;
767
768     memset (&desc, 0, sizeof desc);
769     desc.mode = KEYDB_SEARCH_MODE_NEXT;
770     return keydb_search (hd, &desc, 1);
771 }
772
773 int
774 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
775 {
776     KEYDB_SEARCH_DESC desc;
777
778     memset (&desc, 0, sizeof desc);
779     desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
780     desc.u.kid[0] = kid[0];
781     desc.u.kid[1] = kid[1];
782     return keydb_search (hd, &desc, 1);
783 }
784
785 int
786 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
787 {
788     KEYDB_SEARCH_DESC desc;
789
790     memset (&desc, 0, sizeof desc);
791     desc.mode = KEYDB_SEARCH_MODE_FPR;
792     memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
793     return keydb_search (hd, &desc, 1);
794 }