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         struct auth_v2 auth;
  22         int fd, n, r;
  23
  24         if (!valid_name(username) || !blerg_exists(username))
  25                 return 0;
  26
  27         n = strlen(password);
  28         if (n > MAX_PASSWORD_LENGTH)
  29                 return 0;
  30
  31         /* Clear the auth structure */
  32         memset(&auth, 0, sizeof(struct auth_v2));
  33
  34         /* Set the auth version */
  35         auth.header.version = 2;
  36
  37         /* Gather some salt */
  38         fd = open("/dev/urandom", O_RDONLY);
  39         if (fd == -1) {
  40                 perror("Could not open /dev/urandom");
  41                 return 0;
  42         }
  43         read(fd, auth.salt, SCRYPT_SALT_SIZE);
  44         close(fd);
  45
  46         r = crypto_scrypt((const uint8_t *)password, n, auth.salt, SCRYPT_SALT_SIZE, SCRYPT_N, SCRYPT_r, SCRYPT_p, auth.password, SCRYPT_OUTPUT_SIZE);
  47         if (r != 0) {
  48                 fprintf(stderr, "Failure in scrypt for %s\n", username);
  49                 return 0;
  50         }
  51
  52         /* Write the data */
  53         snprintf(filename, FILENAME_MAX, "%s/%s/auth", blergconf.data_path, username);
  54         fd = open(filename, O_WRONLY | O_CREAT, 0600);
  55         flock(fd, LOCK_EX);
  56         write(fd, &auth, sizeof(struct auth_v2));
  57         flock(fd, LOCK_UN);
  58         close(fd);
  59
  60         return 1;
  61 }
  62
  63 int auth_get_password_version(const char *username) {
  64         char filename[FILENAME_MAX];
  65         int fd;
  66         char str[4];
  67         struct auth_header ah;
  68         int len = 0;
  69
  70         snprintf(filename, FILENAME_MAX, "%s/%s/auth", blergconf.data_path, username);
  71         if (access(filename, F_OK) == 0) {
  72                 fd = open(filename, O_RDONLY);
  73                 if (fd == -1)
  74                         return -1;
  75                 len = read(fd, &ah, sizeof(struct auth_header));
  76                 close(fd);
  77
  78                 if (len < 0) {
  79                         perror("reading auth file");
  80                         return -1;
  81                 } else if (len < sizeof(struct auth_header)) {
  82                         fprintf(stderr, "Short read on while determining auth version for %s", username);
  83                         return -1;
  84                 }
  85
  86                 return ah.version;
  87         }
  88
  89         snprintf(filename, FILENAME_MAX, "%s/%s/password_version", blergconf.data_path, username);
  90         if (access(filename, F_OK) != 0) {
  91                 return 0;
  92         }
  93
  94         fd = open(filename, O_RDONLY);
  95         if (fd == -1)
  96                 return -1;
  97         len = read(fd, str, 4);
  98         close(fd);
  99
 100         if (len < 0) {
 101                 perror("auth_get_password_version");
 102                 return -1;
 103         }
 104
 105         str[len] = 0;
 106
 107         /* strtol returns zero if there isn't a number */
 108         return strtol(str, NULL, 10);
 109 }
 110
 111 int auth_get_password(const char *username, char *password) {
 112         char filename[FILENAME_MAX];
 113         int fd;
 114         int read_size;
 115         int len = 0;
 116
 117         if (!valid_name(username))
 118                 return 0;
 119
 120         switch(auth_get_password_version(username)) {
 121         case 0:
 122                 read_size = MD5_DIGEST_SIZE;
 123                 break;
 124         case 1:
 125                 read_size = SCRYPT_OUTPUT_SIZE;
 126                 break;
 127         default:
 128                 return 0;
 129         }
 130
 131         snprintf(filename, FILENAME_MAX, "%s/%s/password", blergconf.data_path, username);
 132         fd = open(filename, O_RDONLY);
 133         if (fd == -1)
 134                 return 0;
 135         len = read(fd, password, read_size);
 136         close(fd);
 137
 138         if (len < 0) {
 139                 perror("auth_get_password");
 140                 return 0;
 141         } else if (len < read_size) {
 142                 fprintf(stderr, "Short read getting password\n");
 143                 return 0;
 144         }
 145
 146         password[len] = 0;
 147
 148         return 1;
 149 }
 150
 151 int auth_get_salt(const char *username, uint8_t *salt) {
 152         char filename[FILENAME_MAX];
 153         int fd;
 154         int len = 0;
 155
 156         if (!valid_name(username))
 157                 return 0;
 158
 159         snprintf(filename, FILENAME_MAX, "%s/%s/password_salt", blergconf.data_path, username);
 160         fd = open(filename, O_RDONLY);
 161         if (fd == -1)
 162                 return 0;
 163         len = read(fd, salt, SCRYPT_SALT_SIZE);
 164         close(fd);
 165
 166         if (len < 0) {
 167                 perror("auth_get_salt");
 168                 return 0;
 169         } else if (len < SCRYPT_SALT_SIZE) {
 170                 fprintf(stderr, "Short read getting salt\n");
 171                 return 0;
 172         }
 173
 174         return 1;
 175 }
 176
 177 int auth_check_password_v0(const char *username, const char *password) {
 178         char epw[MD5_DIGEST_SIZE + 1];
 179         char givenpw[MD5_DIGEST_SIZE];
 180         struct MD5Context ctx;
 181
 182         if (auth_get_password(username, epw) == 0)
 183                 return 0;
 184
 185         MD5Init(&ctx);
 186         MD5Update(&ctx, username, strlen(username));
 187         MD5Update(&ctx, password, strlen(password));
 188         MD5Final((unsigned char *)givenpw, &ctx);
 189
 190         if (strncmp(givenpw, epw, MD5_DIGEST_SIZE) == 0)
 191                 return 1;
 192         else
 193                 return 0;
 194 }
 195
 196 int auth_get_data(const char *username, void *data, size_t data_len) {
 197         char filename[FILENAME_MAX];
 198         int fd;
 199         int len = 0;
 200
 201         if (!valid_name(username))
 202                 return 0;
 203
 204         snprintf(filename, FILENAME_MAX, "%s/%s/auth", blergconf.data_path, username);
 205         fd = open(filename, O_RDONLY);
 206         if (fd == -1)
 207                 return 0;
 208         flock(fd, LOCK_SH);
 209         len = read(fd, data, data_len);
 210         flock(fd, LOCK_UN);
 211         close(fd);
 212
 213         if (len < 0) {
 214                 perror("auth_get_data");
 215                 return 0;
 216         } else if (len < data_len) {
 217                 fprintf(stderr, "Short read getting auth data\n");
 218                 return 0;
 219         }
 220
 221         return 1;
 222 }
 223
 224 int auth_check_scrypt(struct auth_v2 *auth, const char *username, const char *password) {
 225         unsigned char givenpw[SCRYPT_OUTPUT_SIZE];
 226         int r;
 227
 228         r = crypto_scrypt(password, strlen(password), auth->salt, SCRYPT_SALT_SIZE, SCRYPT_N, SCRYPT_r, SCRYPT_p, givenpw, SCRYPT_OUTPUT_SIZE);
 229         if (r != 0) {
 230                 fprintf(stderr, "Failure in scrypt for %s\n", username);
 231                 return 0;
 232         }
 233
 234         if (memcmp(givenpw, auth->password, SCRYPT_OUTPUT_SIZE) == 0)
 235                 return 1;
 236         else
 237                 return 0;
 238 }
 239
 240 int auth_check_password_v1(const char *username, const char *password) {
 241         struct auth_v2 auth;
 242         int r;
 243
 244         if (auth_get_password(username, (char *)auth.password) == 0)
 245                 return 0;
 246
 247         if (auth_get_salt(username, auth.salt) == 0)
 248                 return 0;
 249
 250         return auth_check_scrypt(&auth, username, password);
 251 }
 252
 253 int auth_check_password_v2(const char *username, const char *password) {
 254         struct auth_v2 auth;
 255         int r;
 256
 257         if (auth_get_data(username, (void *) &auth, sizeof(struct auth_v2)) == 0)
 258                 return 0;
 259
 260         return auth_check_scrypt(&auth, username, password);
 261 }
 262
 263 int auth_check_password(const char *username, const char *password) {
 264         int version = auth_get_password_version(username);
 265
 266         switch(version) {
 267         case 0:
 268                 if (auth_check_password_v0(username, password)) {
 269                         /* Refresh to the newest version */
 270                         auth_set_password(username, password);
 271                         return 1;
 272                 } else {
 273                         return 0;
 274                 }
 275                 break;
 276         case 1:
 277                 if (auth_check_password_v1(username, password)) {
 278                         /* Refresh to the newest version */
 279                         auth_set_password(username, password);
 280                         return 1;
 281                 } else {
 282                         return 0;
 283                 }
 284                 break;
 285         case 2:
 286                 return auth_check_password_v2(username, password);
 287         }
 288         fprintf(stderr, "auth_check_password fell through. Bad password version?\n");
 289         return 0;
 290 }
 291
 292 void hexify(char *dst, char *src, int len) {
 293         static char hex[] = "0123456789abcdef";
 294         int i;
 295
 296         for (i = 0; i < len; i++) {
 297                 dst[i * 2]     = hex[(src[i] & 0xF0) >> 4];
 298                 dst[i * 2 + 1] = hex[src[i] & 0xF];
 299         }
 300 }
 301
 302 char *create_random_token() {
 303         char buf[TOKEN_SIZE];
 304         char *token;
 305         int rand_fd;
 306
 307         rand_fd = open("/dev/urandom", O_RDONLY);
 308         if (rand_fd == -1) {
 309                 perror("Could not open /dev/urandom\n");
 310                 return 0;
 311         }
 312         read(rand_fd, buf, TOKEN_SIZE);
 313         close(rand_fd);
 314
 315         token = malloc(TOKEN_SIZE * 2 + 1);
 316         hexify(token, buf, TOKEN_SIZE);
 317         token[TOKEN_SIZE * 2] = 0;
 318
 319         return token;
 320 }
 321
 322 char * auth_login(const char *username, const char *password) {
 323         char filename[FILENAME_MAX];
 324         int token_fd;
 325
 326         if (!auth_check_password(username, password))
 327                 return NULL;
 328
 329         char *token = create_random_token();
 330
 331         snprintf(filename, FILENAME_MAX, "%s/%s/tokens", blergconf.data_path, username);
 332         if (access(filename, F_OK) != 0) {
 333                 if (mkdir(filename, 0700) == -1) {
 334                         perror("Could not create auth token dir");
 335                         return NULL;
 336                 }
 337         }
 338
 339         snprintf(filename, FILENAME_MAX, "%s/%s/tokens/%s", blergconf.data_path, username, token);
 340         token_fd = open(filename, O_WRONLY | O_CREAT, 0600);
 341         if (token_fd == -1) {
 342                 perror("Could not open token");
 343                 return NULL;
 344         }
 345         close(token_fd);
 346
 347         return token;
 348 }
 349
 350 int auth_logout(const char *username, const char *token) {
 351         char filename[FILENAME_MAX];
 352
 353         if (!valid_name(username))
 354                 return 0;
 355
 356         snprintf(filename, FILENAME_MAX, "%s/%s/tokens", blergconf.data_path, username);
 357         if (access(filename, F_OK) != 0) {
 358                 return 0;
 359         }
 360
 361         snprintf(filename, FILENAME_MAX, "%s/%s/tokens/%s", blergconf.data_path, username, token);
 362         if (unlink(filename) == -1)
 363                 return 0;
 364
 365         return 1;
 366 }
 367
 368 int auth_check_token(const char *username, const char *given_token) {
 369         char filename[FILENAME_MAX];
 370
 371         snprintf(filename, FILENAME_MAX, "%s/%s/tokens/%s", blergconf.data_path, username, given_token);
 372
 373         return (access(filename, F_OK) == 0);
 374 }