#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sha1.h"
#include "sha1passwd.h"
#include "base64.h"

#define SALT_GEN_SIZE 8

static int ssha1_getdata(const char *ciphertext, size_t data_len, unsigned char *data) {
	int len;

	ciphertext+=SSHA1_MAGIC_LENGTH;
	len=base64_decode(strlen(ciphertext), ciphertext, data_len, data);
	if(len<=SHA1_DIGEST_SIZE) return 0; /* failure */
	if(len>data_len) return 0; /* failure */
	return len;
}

static int ssha1_cryptdata(const char *cleartext, size_t salt_len, const void *salt, size_t out_len, void *out) {
	SHA1_CTX ctx;
	int len;
	len=(SHA1_DIGEST_SIZE+salt_len);
	if(out_len<len) return 0;

	SHA1_Init(&ctx);
	SHA1_Update(&ctx, (const unsigned char*)cleartext, strlen(cleartext));
	SHA1_Update(&ctx, salt, salt_len);
	SHA1_Final(&ctx, out);
	memcpy((char*)out+SHA1_DIGEST_SIZE, salt, salt_len);
	return len;
}

static int ssha1_crypt(const char *cleartext, size_t salt_len, const unsigned char *salt, size_t out_len, char *out) {
	unsigned char cipher[SHA1_DIGEST_SIZE + SSHA1_SALT_MAX];
	int len;
	len=ssha1_cryptdata(cleartext, salt_len, salt, sizeof cipher, cipher);
	strcpy(out, SSHA1_MAGIC);
	len=base64_encode(SHA1_DIGEST_SIZE + salt_len, cipher, out_len-SSHA1_MAGIC_LENGTH, out+SSHA1_MAGIC_LENGTH);
	return len;
}

static void ssha1_gensalt(size_t salt_len, void *salt) {
	size_t i;
	for(i=0;i<salt_len;i++) {
		/* TODO: use better random salt */
		((unsigned char*)salt)[i]=(rand()%96)+' ';
	}
}

int ssha1_newpass(const char *cleartext, size_t out_len, char *out) {
	int len;
	unsigned char salt[SALT_GEN_SIZE];
	ssha1_gensalt(sizeof salt, salt);
	len=ssha1_crypt(cleartext, sizeof salt, salt, out_len, out);
	return 0;
}

int ssha1_checkpass(const char *cleartext, const char *crypttext) {
	unsigned char data[SHA1_DIGEST_SIZE + SSHA1_SALT_MAX];
	size_t data_len;
	unsigned char check[SHA1_DIGEST_SIZE + SSHA1_SALT_MAX];
	size_t check_len;

	data_len=ssha1_getdata(crypttext, sizeof data, data);
	if(!data_len) return 0;
	
	check_len=ssha1_cryptdata(cleartext, data_len - SHA1_DIGEST_SIZE, data+SHA1_DIGEST_SIZE, sizeof check, check);
	if(!check_len) return 0;
	if(check_len!=data_len) return 0;
	return memcmp(data, check, check_len)==0;
}

/* UNTESTED */
int ssha1_isvalid(const char *ciphertext) 
{
	return !strncmp(ciphertext, SSHA1_MAGIC, SSHA1_MAGIC_LENGTH);
}

/* utility function */
int ssha1_getsalt(const char *ciphertext, size_t salt_len, unsigned char *salt) {
	int len;

	unsigned char res[SHA1_DIGEST_SIZE+SSHA1_SALT_MAX];

	if(!ssha1_isvalid(ciphertext)) return 0;

	ciphertext+=SSHA1_MAGIC_LENGTH;
	len=base64_decode(strlen(ciphertext), ciphertext, sizeof res, res);
	/* TODO: check result */
	if(len<=SHA1_DIGEST_SIZE) return 0; /* failure */
	len-=SHA1_DIGEST_SIZE;
	if(len>salt_len) return 0; /* failure */
	if(len>SSHA1_SALT_MAX) len=SSHA1_SALT_MAX;
	memcpy(salt, res+SHA1_DIGEST_SIZE, len<salt_len?len:salt_len);
	return len;
}

/* Testing code */
#ifdef STAND_ALONE

static void do_test(void) {
	static const struct {
		char *sha1passwd;
		char *cleartext;
	} tests[] = {  
		{"$ssha1$/EExmSfmhQSPHDJaTxwQSdb/uPpzYWx0ZXI=", "secret"},
		{"$ssha1$gVK8WC9YyFT1gMsQHTGCgT3sSv5zYWx0", "secret"},
		{"$ssha1$W3ipFGmzS3+j6/FhT7ZC39MIfqFcct9Ep0KEGA==", "asddsa123"},
		{"$ssha1$YbB2R1D2AlzYc9wk/YPtslG7NoiOWaoMOztLHA==", "ripthispassword"},
		{"$ssha1$0jVwy2q3GhzwzqAPTLzsWqGJEOsnZikzMT8qLA==", "foo"},
		{NULL}
	};

	int i;
	for(i=0;tests[i].sha1passwd;i++) {
		unsigned char salt[SSHA1_SALT_MAX];
		int salt_len;
		char bleh[SSHA1_CRYPTTEXT_MAX];
		printf("orig : %s\n", tests[i].sha1passwd);
		if(!(salt_len=ssha1_getsalt(tests[i].sha1passwd, sizeof salt, salt))) {
			fprintf(stderr, "failure\n");
		}
		ssha1_crypt(tests[i].cleartext, salt_len, salt, sizeof bleh, bleh);
		fprintf(stderr, "check: %s\n", bleh);

	}
}

static void usage() {
	printf(
	"usage: sha1passwd [-ht] [-c hash] [-s hash] [passwords...]\n"
	"  -c    check password(s) against hash. return success if any match.\n"
	"  -s    get salt from hashed password\n"
	"  -h    help\n"
	"  -v    verbose\n"
	"  -t    perform tests\n"
	);
}

int main(int argc, char **argv) {
	do_test();
	return 0;
}
#endif /* testing code */