chiark / gitweb /
70c809760539a0e0881b4cce3fd40651af4279b4
[disorder] / lib / cookies.c
1 /*
2  * This file is part of DisOrder
3  * Copyright (C) 2007 Richard Kettlewell
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program 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  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
18  * USA
19  */
20 /** @file lib/cookies.c
21  * @brief Cookie support
22  */
23
24 #include <config.h>
25 #include "types.h"
26
27 #include <stdlib.h>
28 #include <string.h>
29 #include <stdio.h>
30 #include <errno.h>
31 #include <time.h>
32 #include <gcrypt.h>
33 #include <pcre.h>
34
35 #include "rights.h"
36 #include "cookies.h"
37 #include "hash.h"
38 #include "mem.h"
39 #include "log.h"
40 #include "printf.h"
41 #include "base64.h"
42 #include "configuration.h"
43 #include "kvp.h"
44 #include "rights.h"
45 #include "trackdb.h"
46
47 /** @brief Hash function used in signing HMAC */
48 #define ALGO GCRY_MD_SHA1
49
50 /** @brief Size of key to use */
51 #define HASHSIZE 20
52
53 /** @brief Signing key */
54 static uint8_t signing_key[HASHSIZE];
55
56 /** @brief Previous signing key */
57 static uint8_t old_signing_key[HASHSIZE];
58
59 /** @brief Signing key validity limit or 0 if none */
60 static time_t signing_key_validity_limit;
61
62 /** @brief Hash of revoked cookies */
63 static hash *revoked;
64
65 /** @brief Callback to expire revocation list */
66 static int revoked_cleanup_callback(const char *key, void *value,
67                                     void *u) {
68   if(*(time_t *)value < *(time_t *)u)
69     hash_remove(revoked, key);
70   return 0;
71 }
72
73 /** @brief Generate a new key */
74 static void newkey(void) {
75   time_t now;
76
77   time(&now);
78   memcpy(old_signing_key, signing_key, HASHSIZE);
79   gcry_randomize(signing_key, HASHSIZE, GCRY_STRONG_RANDOM);
80   signing_key_validity_limit = now + config->cookie_key_lifetime;
81   /* Now is a good time to clean up the revocation list... */
82   if(revoked)
83     hash_foreach(revoked, revoked_cleanup_callback, &now);
84 }
85
86 /** @brief Base64 mapping table for cookies
87  *
88  * Stupid Safari cannot cope with quoted cookies, so cookies had better not
89  * need quoting.  We use $ to separate the parts of the cookie and +%# to where
90  * MIME uses +/=; see @ref base64.c.  See http_separator() for the characters
91  * to avoid.
92  */
93 static const char cookie_base64_table[] =
94   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+%#";
95
96 /** @brief Sign @p subject with @p key and return the base64 of the result
97  * @param key Key to sign with (@ref HASHSIZE bytes)
98  * @param subject Subject string
99  * @return Base64-encoded signature or NULL
100  */
101 static char *sign(const uint8_t *key,
102                   const char *subject) {
103   gcry_error_t e;
104   gcry_md_hd_t h;
105   uint8_t *sig;
106   char *sig64;
107
108   if((e = gcry_md_open(&h, ALGO, GCRY_MD_FLAG_HMAC))) {
109     error(0, "gcry_md_open: %s", gcry_strerror(e));
110     return 0;
111   }
112   if((e = gcry_md_setkey(h, key, HASHSIZE))) {
113     error(0, "gcry_md_setkey: %s", gcry_strerror(e));
114     gcry_md_close(h);
115     return 0;
116   }
117   gcry_md_write(h, subject, strlen(subject));
118   sig = gcry_md_read(h, ALGO);
119   sig64 = generic_to_base64(sig, HASHSIZE, cookie_base64_table);
120   gcry_md_close(h);
121   return sig64;
122 }
123
124 /** @brief Create a login cookie
125  * @param user Username
126  * @return Cookie or NULL
127  */
128 char *make_cookie(const char *user) {
129   const char *password;
130   time_t now;
131   char *b, *bp, *c, *g;
132
133   /* dollar signs aren't allowed in usernames */
134   if(strchr(user, '$')) {
135     error(0, "make_cookie for username with dollar sign");
136     return 0;
137   }
138   /* look up the password */
139   password = trackdb_get_password(user);
140   if(!password) {
141     error(0, "make_cookie for nonexistent user");
142     return 0;
143   }
144   /* make sure we have a valid signing key */
145   time(&now);
146   if(now >= signing_key_validity_limit)
147     newkey();
148   /* construct the subject */
149   byte_xasprintf(&b, "%jx$%s$", (intmax_t)now + config->cookie_login_lifetime,
150                  urlencodestring(user));
151   byte_xasprintf(&bp, "%s%s", b, password);
152   /* sign it */
153   if(!(g = sign(signing_key, bp)))
154     return 0;
155   /* put together the final cookie */
156   byte_xasprintf(&c, "%s%s", b, g);
157   return c;
158 }
159
160 /** @brief Verify a cookie
161  * @param cookie Cookie to verify
162  * @param rights Where to store rights value
163  * @return Verified user or NULL
164  */
165 char *verify_cookie(const char *cookie, rights_type *rights) {
166   char *c1, *c2;
167   intmax_t t;
168   time_t now;
169   char *user, *bp, *sig;
170   const char *password;
171   struct kvp *k;
172
173   /* check the revocation list */
174   if(revoked && hash_find(revoked, cookie)) {
175     error(0, "attempt to log in with revoked cookie");
176     return 0;
177   }
178   /* parse the cookie */
179   errno = 0;
180   t = strtoimax(cookie, &c1, 16);
181   if(errno) {
182     error(errno, "error parsing cookie timestamp");
183     return 0;
184   }
185   if(*c1 != '$') {
186     error(0, "invalid cookie timestamp");
187     return 0;
188   }
189   /* There'd better be two dollar signs */
190   c2 = strchr(c1 + 1, '$');
191   if(c2 == 0) {
192     error(0, "invalid cookie syntax");
193     return 0;
194   }
195   /* Extract the username */
196   user = xstrndup(c1 + 1, c2 - (c1 + 1));
197   /* check expiry */
198   time(&now);
199   if(now >= t) {
200     error(0, "cookie has expired");
201     return 0;
202   }
203   /* look up the password */
204   k = trackdb_getuserinfo(user);
205   if(!k) {
206     error(0, "verify_cookie for nonexistent user");
207     return 0;
208   }
209   password = kvp_get(k, "password");
210   if(!password) password = "";
211   if(parse_rights(kvp_get(k, "rights"), rights, 1))
212     return 0;
213   /* construct the expected subject.  We re-encode the timestamp and the
214    * password. */
215   byte_xasprintf(&bp, "%jx$%s$%s", t, urlencodestring(user), password);
216   /* Compute the expected signature.  NB we base64 the expected signature and
217    * compare that rather than exposing our base64 parser to the cookie. */
218   if(!(sig = sign(signing_key, bp)))
219     return 0;
220   if(!strcmp(sig, c2 + 1))
221     return user;
222   /* that didn't match, try the old key */
223   if(!(sig = sign(old_signing_key, bp)))
224     return 0;
225   if(!strcmp(sig, c2 + 1))
226     return user;
227   /* that didn't match either */
228   error(0, "cookie signature does not match");
229   return 0;
230 }
231
232 /** @brief Revoke a cookie
233  * @param cookie Cookie to revoke
234  *
235  * Further attempts to log in with @p cookie will fail.
236  */
237 void revoke_cookie(const char *cookie) {
238   time_t when;
239   char *ptr;
240
241   /* find the cookie's expiry time */
242   errno = 0;
243   when = (time_t)strtoimax(cookie, &ptr, 16);
244   /* reject bogus cookies */
245   if(errno)
246     return;
247   if(*ptr != '$')
248     return;
249   /* make sure the revocation list exists */
250   if(!revoked)
251     revoked = hash_new(sizeof(time_t));
252   /* add the cookie to it; its value is the expiry time */
253   hash_add(revoked, cookie, &when, HASH_INSERT);
254 }
255
256 /*
257 Local Variables:
258 c-basic-offset:2
259 comment-column:40
260 fill-column:79
261 indent-tabs-mode:nil
262 End:
263 */