chiark / gitweb /
make-secnet-sites: New --pubkeys-install option
[secnet.git] / privcache.c
1 /*
2  * This file is part of secnet.
3  * See README for full list of copyright holders.
4  *
5  * secnet is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 3 of the License, or
8  * (at your option) any later version.
9  * 
10  * secnet is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  * 
15  * You should have received a copy of the GNU General Public License
16  * version 3 along with secnet; if not, see
17  * https://www.gnu.org/licenses/gpl.html.
18  */
19
20 #include "secnet.h"
21 #include "util.h"
22
23 #define DEFAULT_SIZE 5
24
25 struct ent {
26     struct sigkeyid id;
27     struct sigprivkey_if *sigpriv; /* 0 means none such */
28 };
29
30 struct privcache {
31     closure_t cl;
32     struct privcache_if ops;
33     int used, alloc;
34     struct pathprefix_template path;
35     struct ent *ents;
36     struct buffer_if databuf;
37     struct hash_if *defhash;
38 };
39
40 static struct sigprivkey_if *uncached_get(struct privcache *st,
41                            const struct sigkeyid *id, struct log_if *log)
42 {
43     bool_t ok=False;
44     FILE *f=0;
45
46     sprintf(st->path.write_here, SIGKEYID_PR_FMT, SIGKEYID_PR_VAL(id));
47
48     f = fopen(st->path.buffer,"rb");
49     if (!f) {
50         if (errno == ENOENT) {
51             slilog(log,M_DEBUG,"private key %s not found",
52                    st->path.buffer);
53         } else {
54             slilog(log,M_ERR,"failed to open private key file %s",
55                    st->path.buffer);
56         }
57         goto out;
58     }
59
60     setbuf(f,0);
61     buffer_init(&st->databuf,0);
62     ssize_t got=fread(st->databuf.base,1,st->databuf.alloclen,f);
63     if (ferror(f)) {
64         slilog(log,M_ERR,"failed to read private-key file %s",
65                st->path.buffer);
66         goto out;
67     }
68     if (!feof(f)) {
69         slilog(log,M_ERR,"private key file %s longer than max %d",
70                st->path.buffer, (int)st->databuf.alloclen);
71         goto out;
72     }
73     fclose(f); f=0;
74
75     struct sigprivkey_if *sigpriv=0;
76     const struct sigscheme_info *scheme;
77     for (scheme=sigschemes;
78          scheme->name;
79          scheme++)
80         if (scheme->algid == id->b[GRPIDSZ])
81             goto found;
82
83     slilog(log,M_ERR,"private key file %s not loaded (unknown algid)",
84            st->path.buffer);
85     goto out;
86
87  found:
88     st->databuf.start=st->databuf.base;
89     st->databuf.size=got;
90     struct cloc loc = { .file=st->path.buffer, .line=0 };
91     ok=scheme->loadpriv(scheme, &st->databuf, &sigpriv, log, loc);
92     if (!ok) goto out; /* loadpriv will have logged */
93
94     if (sigpriv->sethash) {
95         if (!st->defhash) {
96             slilog(log,M_ERR,
97  "private key %s requires `hash' config key for privcache to load",
98                    st->path.buffer);
99             sigpriv->dispose(sigpriv->st);
100             sigpriv=0;
101             goto out;
102         }
103         sigpriv->sethash(sigpriv->st,st->defhash);
104     }
105
106   out:
107     if (f) fclose(f);
108     return ok ? sigpriv : 0;
109 }
110
111 static struct sigprivkey_if *privcache_lookup(void *sst,
112                                               const struct sigkeyid *id,
113                                               struct log_if *log) {
114     struct privcache *st = sst;
115     int was;
116     struct ent result;
117
118     for (was=0; was<st->used; was++) {
119         if (sigkeyid_equal(id, &st->ents[was].id)) {
120             result = st->ents[was];
121             goto found;
122         }
123     }
124
125     if (st->used < st->alloc) {
126         was = st->used;
127         st->used++;
128     } else {
129         was = st->used-1;
130         if (st->ents[was].sigpriv) {
131             st->ents[was].sigpriv->dispose(st->ents[was].sigpriv->st);
132         }
133     }
134
135     COPY_OBJ(result.id, *id);
136     result.sigpriv=uncached_get(st,id,log);
137
138  found:
139     memmove(&st->ents[1], &st->ents[0], sizeof(st->ents[0]) * was);
140     st->ents[0] = result;
141     return result.sigpriv;
142 }
143
144 static list_t *privcache_apply(closure_t *self, struct cloc loc,
145                                dict_t *context, list_t *args)
146 {
147     struct privcache *st;
148     item_t *item;
149     dict_t *dict;
150
151     NEW(st);
152     st->cl.description="privcache";
153     st->cl.type=CL_PRIVCACHE;
154     st->cl.apply=NULL;
155     st->cl.interface=&st->ops;
156     st->ops.st=st;
157     st->ops.lookup=privcache_lookup;
158     st->ents=0;
159     st->path.buffer=0;
160     st->used=st->alloc=0;
161     st->defhash=0;
162
163     item=list_elem(args,0);
164     if (!item || item->type!=t_dict)
165         cfgfatal(loc,"privcache","parameter must be a dictionary\n");
166     
167     dict=item->data.dict;
168
169     st->alloc=dict_read_number(dict,"privcache-size",False,"privcache",loc,
170                                DEFAULT_SIZE);
171     NEW_ARY(st->ents,st->alloc);
172     st->used=0;
173
174     int32_t buflen=dict_read_number(dict,"privkey-max",False,"privcache",loc,
175                                     4095);
176     buffer_new(&st->databuf,buflen+1);
177
178     const char *path=dict_read_string(dict,"privkeys",True,"privcache",loc);
179     pathprefix_template_init(&st->path,path,KEYIDSZ*2);
180
181     st->defhash=find_cl_if(dict,"hash",CL_HASH,False,"site",loc);
182
183     return new_closure(&st->cl);
184 }
185
186 void privcache_module(dict_t *dict)
187 {
188     add_closure(dict,"priv-cache",privcache_apply);
189 }