Update password storage to a more compact form

Instead of using three files to store version, password, and salt, pack
it all into a struct and write it as a single file.  Also added locking
for password updates, and removed raw password get functions from the
exposed functions in common/auth.h.

diff --git a/common/auth.c b/common/auth.c
index ef548ec..6638748 100644 (file)
--- a/common/auth.c
+++ b/common/auth.c
@@ -18,8 +18,7 @@
 
 int auth_set_password(const char *username, const char *password) {
        char filename[FILENAME_MAX];
-       uint8_t pwhash[SCRYPT_OUTPUT_SIZE];
-       uint8_t salt[SCRYPT_SALT_SIZE];
+       struct auth_v2 auth;
        int fd, n, r;
 
        if (!valid_name(username) || !blerg_exists(username))
@@ -29,39 +28,35 @@ int auth_set_password(const char *username, const char *password) {
        if (n > MAX_PASSWORD_LENGTH)
                return 0;
 
+       /* Clear the auth structure */
+       memset(&auth, 0, sizeof(struct auth_v2));
+
+       /* Set the auth version */
+       auth.header.version = 2;
+
        /* Gather some salt */
        fd = open("/dev/urandom", O_RDONLY);
        if (fd == -1) {
-               perror("Could not open /dev/urandom\n");
+               perror("Could not open /dev/urandom");
                return 0;
        }
-       read(fd, salt, SCRYPT_SALT_SIZE);
+       read(fd, auth.salt, SCRYPT_SALT_SIZE);
        close(fd);
 
-       r = crypto_scrypt((const uint8_t *)password, n, salt, SCRYPT_SALT_SIZE, SCRYPT_N, SCRYPT_r, SCRYPT_p, pwhash, SCRYPT_OUTPUT_SIZE);
+       r = crypto_scrypt((const uint8_t *)password, n, auth.salt, SCRYPT_SALT_SIZE, SCRYPT_N, SCRYPT_r, SCRYPT_p, auth.password, SCRYPT_OUTPUT_SIZE);
        if (r != 0) {
                fprintf(stderr, "Failure in scrypt for %s\n", username);
                return 0;
        }
 
-       /* Write the password */
-       snprintf(filename, FILENAME_MAX, "%s/%s/password", blergconf.data_path, username);
-       fd = open(filename, O_WRONLY | O_CREAT, 0600);
-       write(fd, pwhash, SCRYPT_OUTPUT_SIZE);
-       close(fd);
-
-       /* Write the salt */
-       snprintf(filename, FILENAME_MAX, "%s/%s/password_salt", blergconf.data_path, username);
+       /* Write the data */
+       snprintf(filename, FILENAME_MAX, "%s/%s/auth", blergconf.data_path, username);
        fd = open(filename, O_WRONLY | O_CREAT, 0600);
-       write(fd, salt, SCRYPT_SALT_SIZE);
+       flock(fd, LOCK_EX);
+       write(fd, &auth, sizeof(struct auth_v2));
+       flock(fd, LOCK_UN);
        close(fd);
 
-       /* Mark this as a version 1 password */
-       snprintf(filename, FILENAME_MAX, "%s/%s/password_version", blergconf.data_path, username);
-       fd = open(filename, O_WRONLY | O_CREAT, 0600);
-       write(fd, "1\n", 2);
-       close(fd);
-       
        return 1;
 }
 
@@ -69,8 +64,28 @@ int auth_get_password_version(const char *username) {
        char filename[FILENAME_MAX];
        int fd;
        char str[4];
+       struct auth_header ah;
        int len = 0;
 
+       snprintf(filename, FILENAME_MAX, "%s/%s/auth", blergconf.data_path, username);
+       if (access(filename, F_OK) == 0) {
+               fd = open(filename, O_RDONLY);
+               if (fd == -1)
+                       return -1;
+               len = read(fd, &ah, sizeof(struct auth_header));
+               close(fd);
+
+               if (len < 0) {
+                       perror("reading auth file");
+                       return -1;
+               } else if (len < sizeof(struct auth_header)) {
+                       fprintf(stderr, "Short read on while determining auth version for %s", username);
+                       return -1;
+               }
+
+               return ah.version;
+       }
+
        snprintf(filename, FILENAME_MAX, "%s/%s/password_version", blergconf.data_path, username);
        if (access(filename, F_OK) != 0) {
                return 0;
@@ -82,7 +97,7 @@ int auth_get_password_version(const char *username) {
        len = read(fd, str, 4);
        close(fd);
 
-       if (len < -1) {
+       if (len < 0) {
                perror("auth_get_password_version");
                return -1;
        }
@@ -178,30 +193,73 @@ int auth_check_password_v0(const char *username, const char *password) {
                return 0;
 }
 
-int auth_check_password_v1(const char *username, const char *password) {
-       unsigned char epw[SCRYPT_OUTPUT_SIZE];
-       uint8_t esalt[SCRYPT_SALT_SIZE];
-       unsigned char givenpw[SCRYPT_OUTPUT_SIZE];
-       int r;
+int auth_get_data(const char *username, void *data, size_t data_len) {
+       char filename[FILENAME_MAX];
+       int fd;
+       int len = 0;
 
-       if (auth_get_password(username, (char *)epw) == 0)
+       if (!valid_name(username))
                return 0;
 
-       if (auth_get_salt(username, esalt) == 0)
+       snprintf(filename, FILENAME_MAX, "%s/%s/auth", blergconf.data_path, username);
+       fd = open(filename, O_RDONLY);
+       if (fd == -1)
                return 0;
+       flock(fd, LOCK_SH);
+       len = read(fd, data, data_len);
+       flock(fd, LOCK_UN);
+       close(fd);
 
-       r = crypto_scrypt((const uint8_t *)password, strlen(password), esalt, SCRYPT_SALT_SIZE, SCRYPT_N, SCRYPT_r, SCRYPT_p, givenpw, SCRYPT_OUTPUT_SIZE);
+       if (len < 0) {
+               perror("auth_get_data");
+               return 0;
+       } else if (len < data_len) {
+               fprintf(stderr, "Short read getting auth data\n");
+               return 0;
+       }
+
+       return 1;
+}
+
+int auth_check_scrypt(struct auth_v2 *auth, const char *username, const char *password) {
+       unsigned char givenpw[SCRYPT_OUTPUT_SIZE];
+       int r;
+
+       r = crypto_scrypt(password, strlen(password), auth->salt, SCRYPT_SALT_SIZE, SCRYPT_N, SCRYPT_r, SCRYPT_p, givenpw, SCRYPT_OUTPUT_SIZE);
        if (r != 0) {
                fprintf(stderr, "Failure in scrypt for %s\n", username);
                return 0;
        }
 
-       if (memcmp(givenpw, epw, SCRYPT_OUTPUT_SIZE) == 0)
+       if (memcmp(givenpw, auth->password, SCRYPT_OUTPUT_SIZE) == 0)
                return 1;
        else
                return 0;
 }
 
+int auth_check_password_v1(const char *username, const char *password) {
+       struct auth_v2 auth;
+       int r;
+
+       if (auth_get_password(username, (char *)auth.password) == 0)
+               return 0;
+
+       if (auth_get_salt(username, auth.salt) == 0)
+               return 0;
+
+       return auth_check_scrypt(&auth, username, password);
+}
+
+int auth_check_password_v2(const char *username, const char *password) {
+       struct auth_v2 auth;
+       int r;
+
+       if (auth_get_data(username, (void *) &auth, sizeof(struct auth_v2)) == 0)
+               return 0;
+
+       return auth_check_scrypt(&auth, username, password);
+}
+
 int auth_check_password(const char *username, const char *password) {
        int version = auth_get_password_version(username);
 
@@ -216,7 +274,16 @@ int auth_check_password(const char *username, const char *password) {
                }
                break;
        case 1:
-               return auth_check_password_v1(username, password);
+               if (auth_check_password_v1(username, password)) {
+                       /* Refresh to the newest version */
+                       auth_set_password(username, password);
+                       return 1;
+               } else {
+                       return 0;
+               }
+               break;
+       case 2:
+               return auth_check_password_v2(username, password);
        }
        fprintf(stderr, "auth_check_password fell through. Bad password version?\n");
        return 0;

diff --git a/common/auth.h b/common/auth.h
index 9d3fe49..4a16776 100644 (file)
--- a/common/auth.h
+++ b/common/auth.h
@@ -14,10 +14,19 @@
 #define SCRYPT_r 8
 #define SCRYPT_p 1
 
+struct auth_header {
+       uint8_t version;
+       uint8_t reserved1;
+       uint16_t reserved2;
+};
+
+struct auth_v2 {
+       struct auth_header header;
+       uint8_t password[SCRYPT_OUTPUT_SIZE];
+       uint8_t salt[SCRYPT_SALT_SIZE];
+};
+
 int auth_set_password(const char *username, const char *password);
-int auth_get_password_version(const char *username);
-int auth_get_password(const char *username, char *password);
-int auth_get_salt(const char *username, uint8_t *salt);
 int auth_check_password(const char *username, const char *password);
 char * auth_login(const char *username, const char *password);
 int auth_logout(const char *username, const char *token);