Add titles in RSS for dumb aggregators
[blerg.git] / common / auth.c
1 /* Blerg is (C) 2011 The Dominion of Awesome, and is distributed under a
2  * BSD-style license.  Please see the COPYING file for details.
3  */
4 #include <sys/types.h>
5 #include <sys/stat.h>
6 #include <fcntl.h>
7 #include <string.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <unistd.h>
11 #include <crypto_scrypt.h>
12 #include "config.h"
13 #include "configuration.h"
14 #include "database.h"
15 #include "auth.h"
16 #include "util.h"
17 #include "md5.h"
18
19 int auth_set_password(const char *username, const char *password) {
20         char filename[FILENAME_MAX];
21         uint8_t pwhash[SCRYPT_OUTPUT_SIZE];
22         uint8_t salt[SCRYPT_SALT_SIZE];
23         int fd, n, r;
24
25         if (!valid_name(username) || !blerg_exists(username))
26                 return 0;
27
28         n = strlen(password);
29         if (n > MAX_PASSWORD_LENGTH)
30                 return 0;
31
32         /* Gather some salt */
33         fd = open("/dev/urandom", O_RDONLY);
34         if (fd == -1) {
35                 perror("Could not open /dev/urandom\n");
36                 return 0;
37         }
38         read(fd, salt, SCRYPT_SALT_SIZE);
39         close(fd);
40
41         r = crypto_scrypt((const uint8_t *)password, n, salt, SCRYPT_SALT_SIZE, SCRYPT_N, SCRYPT_r, SCRYPT_p, pwhash, SCRYPT_OUTPUT_SIZE);
42         if (r != 0) {
43                 fprintf(stderr, "Failure in scrypt for %s\n", username);
44                 return 0;
45         }
46
47         /* Write the password */
48         snprintf(filename, FILENAME_MAX, "%s/%s/password", blergconf.data_path, username);
49         fd = open(filename, O_WRONLY | O_CREAT, 0600);
50         write(fd, pwhash, SCRYPT_OUTPUT_SIZE);
51         close(fd);
52
53         /* Write the salt */
54         snprintf(filename, FILENAME_MAX, "%s/%s/password_salt", blergconf.data_path, username);
55         fd = open(filename, O_WRONLY | O_CREAT, 0600);
56         write(fd, salt, SCRYPT_SALT_SIZE);
57         close(fd);
58
59         /* Mark this as a version 1 password */
60         snprintf(filename, FILENAME_MAX, "%s/%s/password_version", blergconf.data_path, username);
61         fd = open(filename, O_WRONLY | O_CREAT, 0600);
62         write(fd, "1\n", 2);
63         close(fd);
64         
65         return 1;
66 }
67
68 int auth_get_password_version(const char *username) {
69         char filename[FILENAME_MAX];
70         int fd;
71         char str[4];
72         int len = 0;
73
74         snprintf(filename, FILENAME_MAX, "%s/%s/password_version", blergconf.data_path, username);
75         if (access(filename, F_OK) != 0) {
76                 return 0;
77         }
78
79         fd = open(filename, O_RDONLY);
80         if (fd == -1)
81                 return -1;
82         len = read(fd, str, 4);
83         close(fd);
84
85         if (len < -1) {
86                 perror("auth_get_password_version");
87                 return -1;
88         }
89
90         str[len] = 0;
91
92         /* strtol returns zero if there isn't a number */
93         return strtol(str, NULL, 10);
94 }
95
96 int auth_get_password(const char *username, char *password) {
97         char filename[FILENAME_MAX];
98         int fd;
99         int read_size;
100         int len = 0;
101
102         if (!valid_name(username))
103                 return 0;
104
105         switch(auth_get_password_version(username)) {
106         case 0:
107                 read_size = MD5_DIGEST_SIZE;
108                 break;
109         case 1:
110                 read_size = SCRYPT_OUTPUT_SIZE;
111                 break;
112         default:
113                 return 0;
114         }
115
116         snprintf(filename, FILENAME_MAX, "%s/%s/password", blergconf.data_path, username);
117         fd = open(filename, O_RDONLY);
118         if (fd == -1)
119                 return 0;
120         len = read(fd, password, read_size);
121         close(fd);
122
123         if (len < 0) {
124                 perror("auth_get_password");
125                 return 0;
126         } else if (len < read_size) {
127                 fprintf(stderr, "Short read getting password\n");
128                 return 0;
129         }
130
131         password[len] = 0;
132
133         return 1;
134 }
135
136 int auth_get_salt(const char *username, uint8_t *salt) {
137         char filename[FILENAME_MAX];
138         int fd;
139         int len = 0;
140
141         if (!valid_name(username))
142                 return 0;
143
144         snprintf(filename, FILENAME_MAX, "%s/%s/password_salt", blergconf.data_path, username);
145         fd = open(filename, O_RDONLY);
146         if (fd == -1)
147                 return 0;
148         len = read(fd, salt, SCRYPT_SALT_SIZE);
149         close(fd);
150
151         if (len < 0) {
152                 perror("auth_get_salt");
153                 return 0;
154         } else if (len < SCRYPT_SALT_SIZE) {
155                 fprintf(stderr, "Short read getting salt\n");
156                 return 0;
157         }
158
159         return 1;
160 }
161
162 int auth_check_password_v0(const char *username, const char *password) {
163         char epw[MD5_DIGEST_SIZE + 1];
164         char givenpw[MD5_DIGEST_SIZE];
165         struct MD5Context ctx;
166
167         if (auth_get_password(username, epw) == 0)
168                 return 0;
169
170         MD5Init(&ctx);
171         MD5Update(&ctx, username, strlen(username));
172         MD5Update(&ctx, password, strlen(password));
173         MD5Final((unsigned char *)givenpw, &ctx);
174
175         if (strncmp(givenpw, epw, MD5_DIGEST_SIZE) == 0)
176                 return 1;
177         else
178                 return 0;
179 }
180
181 int auth_check_password_v1(const char *username, const char *password) {
182         unsigned char epw[SCRYPT_OUTPUT_SIZE];
183         uint8_t esalt[SCRYPT_SALT_SIZE];
184         unsigned char givenpw[SCRYPT_OUTPUT_SIZE];
185         int r;
186
187         if (auth_get_password(username, (char *)epw) == 0)
188                 return 0;
189
190         if (auth_get_salt(username, esalt) == 0)
191                 return 0;
192
193         r = crypto_scrypt((const uint8_t *)password, strlen(password), esalt, SCRYPT_SALT_SIZE, SCRYPT_N, SCRYPT_r, SCRYPT_p, givenpw, SCRYPT_OUTPUT_SIZE);
194         if (r != 0) {
195                 fprintf(stderr, "Failure in scrypt for %s\n", username);
196                 return 0;
197         }
198
199         if (memcmp(givenpw, epw, SCRYPT_OUTPUT_SIZE) == 0)
200                 return 1;
201         else
202                 return 0;
203 }
204
205 int auth_check_password(const char *username, const char *password) {
206         int version = auth_get_password_version(username);
207
208         switch(version) {
209         case 0:
210                 if (auth_check_password_v0(username, password)) {
211                         /* Refresh to the newest version */
212                         auth_set_password(username, password);
213                         return 1;
214                 } else {
215                         return 0;
216                 }
217                 break;
218         case 1:
219                 return auth_check_password_v1(username, password);
220         }
221         fprintf(stderr, "auth_check_password fell through. Bad password version?\n");
222         return 0;
223 }
224
225 void hexify(char *dst, char *src, int len) {
226         static char hex[] = "0123456789abcdef";
227         int i;
228
229         for (i = 0; i < len; i++) {
230                 dst[i * 2]     = hex[(src[i] & 0xF0) >> 4];
231                 dst[i * 2 + 1] = hex[src[i] & 0xF];
232         }
233 }
234
235 char *create_random_token() {
236         char buf[TOKEN_SIZE];
237         char *token;
238         int rand_fd;
239
240         rand_fd = open("/dev/urandom", O_RDONLY);
241         if (rand_fd == -1) {
242                 perror("Could not open /dev/urandom\n");
243                 return 0;
244         }
245         read(rand_fd, buf, TOKEN_SIZE);
246         close(rand_fd);
247
248         token = malloc(TOKEN_SIZE * 2 + 1);
249         hexify(token, buf, TOKEN_SIZE);
250         token[TOKEN_SIZE * 2] = 0;
251
252         return token;
253 }
254
255 char * auth_login(const char *username, const char *password) {
256         char filename[FILENAME_MAX];
257         int token_fd;
258
259         if (!auth_check_password(username, password))
260                 return NULL;
261
262         char *token = create_random_token();
263
264         snprintf(filename, FILENAME_MAX, "%s/%s/tokens", blergconf.data_path, username);
265         if (access(filename, F_OK) != 0) {
266                 if (mkdir(filename, 0700) == -1) {
267                         perror("Could not create auth token dir");
268                         return NULL;
269                 }
270         }
271
272         snprintf(filename, FILENAME_MAX, "%s/%s/tokens/%s", blergconf.data_path, username, token);
273         token_fd = open(filename, O_WRONLY | O_CREAT, 0600);
274         if (token_fd == -1) {
275                 perror("Could not open token");
276                 return NULL;
277         }
278         close(token_fd);
279
280         return token;
281 }
282
283 int auth_logout(const char *username, const char *token) {
284         char filename[FILENAME_MAX];
285
286         if (!valid_name(username))
287                 return 0;
288
289         snprintf(filename, FILENAME_MAX, "%s/%s/tokens", blergconf.data_path, username);
290         if (access(filename, F_OK) != 0) {
291                 return 0;
292         }
293
294         snprintf(filename, FILENAME_MAX, "%s/%s/tokens/%s", blergconf.data_path, username, token);
295         if (unlink(filename) == -1)
296                 return 0;
297
298         return 1;
299 }
300
301 int auth_check_token(const char *username, const char *given_token) {
302         char filename[FILENAME_MAX];
303
304         snprintf(filename, FILENAME_MAX, "%s/%s/tokens/%s", blergconf.data_path, username, given_token);
305
306         return (access(filename, F_OK) == 0);
307 }