bcrypt

bcrypt.c (4893B)

---

 /*
  * bcrypt wrapper library
  *
  * Written by Remy.
  * No copyright is claimed, and the software is hereby placed in the public
  * domain.  In case this attempt to disclaim copyright and place the software
  * in the public domain is deemed null and void, then the software is
  * Copyright (c) 2000-2014 Solar Designer and it is hereby released to the
  * general public under the following terms:
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted.
  *
  * There's ABSOLUTELY NO WARRANTY, express or implied.
  *
  * Original code: https://github.com/rg3/bcrypt
  */
 
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <errno.h>
 
 #include "libsheepyObject.h"
 #include "bcrypt.h"
 #include "wrapper.h"
 
 
 #define RANDBYTES (16)
 
 internal int try_close(int fd)
 {
 	int r;
 	for (;;) {
 		errno = 0;
 		r = close(fd);
 		if (r == -1 && errno == EINTR)
 			continue;
 		break;
 	}
 	return r;
 }
 
 internal int try_read(int fd, char *out, size_t count)
 {
 	size_t total;
 	ssize_t partial;
 
 	total = 0;
 	while (total < count)
 	{
 		for (;;) {
 			errno = 0;
 			partial = read(fd, out + total, count - total);
 			if (partial == -1 && errno == EINTR)
 				continue;
 			break;
 		}
 
 		if (partial < 1)
 			return -1;
 
 		total += partial;
 	}
 
 	return 0;
 }
 
 /*
  * This is a best effort implementation. Nothing prevents a compiler from
  * optimizing this function and making it vulnerable to timing attacks, but
  * this method is commonly used in crypto libraries like NaCl.
  *
  * Return value is nonzero if both strings are equal and zero otherwise.
 */
 internal int timing_safe_strcmp(const char *str1, const char *str2)
 {
 	const unsigned char *u1;
 	const unsigned char *u2;
 	int r;
 	int i;
 
 	int len1 = strlen(str1);
 	int len2 = strlen(str2);
 
 	/* In our context both strings should always have the same length
 	 * because they will be hashed passwords. */
 	if (len1 != len2)
 		return 1;
 
 	/* Force unsigned for bitwise operations. */
 	u1 = (const unsigned char *)str1;
 	u2 = (const unsigned char *)str2;
 
 	r = 0;
 	for (i = 0; i < len1; ++i)
 		r |= (u1[i] ^ u2[i]);
 
 	return !r;
 }
 
 
 int bcryptGensaltSync(int workfactor, char salt[BCRYPT_HASHSIZE])
 {
 	int fd;
 	char input[RANDBYTES];
 	int workf;
 	char *aux;
 
 	fd = open("/dev/urandom", O_RDONLY);
 	if (fd == -1) {
 		u64 *in = (u64*) input;
 		*(in++) = randomWordFromHW();
 		*(in++) = randomWordFromHW();
 		goto gensalt;
 	}
 
 	if (try_read(fd, input, RANDBYTES) != 0) {
 		if (try_close(fd) != 0)
 			return 4;
 		return 2;
 	}
 
 	if (try_close(fd) != 0)
 		return 3;
 
 	/* Generate salt. */
 	gensalt:
 	workf = (workfactor < 4 || workfactor > 31)?12:workfactor;
 	aux = crypt_gensalt_rn("$2b$", workf, input, RANDBYTES,
 			       salt, BCRYPT_HASHSIZE);
 	return (aux == NULL)?0:1;
 }
 
 int bcryptHashSync(const char *passwd, const char salt[BCRYPT_HASHSIZE], char hash[BCRYPT_HASHSIZE])
 {
 	char *aux;
 	aux = crypt_rn(passwd, salt, hash, BCRYPT_HASHSIZE);
 	return (aux == NULL)?0:1;
 }
 
 int bcryptCheckSync(const char *passwd, const char hash[BCRYPT_HASHSIZE])
 {
 	int r;
 	char outhash[BCRYPT_HASHSIZE];
 
 	r = bcryptHashSync(passwd, hash, outhash);
 	if (!r)
 		return 0;
 
 	return timing_safe_strcmp(hash, outhash);
 }
 
 typedef struct {
 	const char *passwd;
 	u8 saltRounds;
 	bcryptHashCallbackt callback;
 	void *callbackEnv;
 } bcryptHashArgs;
 
 internal void hash(void *AG) {
 
 	cast(bcryptHashArgs *, args, AG);
 
 	char salt[BCRYPT_HASHSIZE];
 	char hash[BCRYPT_HASHSIZE];
 	int r;
 
 	r = bcryptGensaltSync(args->saltRounds, salt);
 	r = bcryptHashSync(args->passwd, salt, hash);
 
 	args->callback(r, hash, args->callbackEnv);
 	free(AG);
 }
 
 int bcryptHash(const char *passwd, u8 saltRounds, bcryptHashCallbackt callback, void *callbackEnv) {
 
 	int r = 0;
 	bcryptHashArgs *args;
 
 	if (!callback || !passwd) return 0;
 
 	args = malloc(sizeof(bcryptHashArgs));
 
 	args->passwd      = passwd;
 	args->saltRounds  = saltRounds;
 	args->callback    = callback;
 	args->callbackEnv = callbackEnv;
 
 	tpoolAdd(hash, args);
 
 	return r;
 }
 
 typedef struct {
 	const char *passwd;
 	char *hash;
 	bcryptCheckCallbackt callback;
 	void *callbackEnv;
 } bcryptCheckArgs;
 
 internal void check(void *AG) {
 
 	cast(bcryptCheckArgs *, args, AG);
 
 	int r;
 
 	r = bcryptCheckSync(args->passwd, args->hash);
 
 	args->callback(0, r, args->callbackEnv);
 	free(args->hash);
 	free(AG);
 }
 
 
 int bcryptCheck(const char *passwd, char hash[BCRYPT_HASHSIZE], bcryptCheckCallbackt callback, void *callbackEnv) {
 
 	int r = 0;
 	bcryptCheckArgs *args;
 
 	if (!callback || !passwd) return 0;
 
 	args = malloc(sizeof(bcryptCheckArgs));
 
 	args->passwd      = passwd;
 	args->hash        = strdup(hash);
 	args->callback    = callback;
 	args->callbackEnv = callbackEnv;
 
 	tpoolAdd(check, args);
 
 	return r;
 }
 
 bool checkLibsheepyVersionBcrypt(const char *currentLibsheepyVersion) {
   return eqG(currentLibsheepyVersion, LIBSHEEPY_VERSION);
 }