Updates by fabiogm

binding.gyp

@@ -58,6 +58,14 @@
             "cflags_cc": [
                 "-std=c++0x"
             ],
+            'conditions': [
+                ['OS == "mac"', {
+	            'xcode_settings': {
+                      'OTHER_CFLAGS': ['-no-integrated-as']
+	             }
+	          }
+                ]
+            ],
         }
     ]
 }

crypto/oaes_lib.c

@@ -34,7 +34,9 @@ static const char _NR[] = {
 #include <stddef.h>
 #include <time.h> 
 #include <sys/timeb.h>
+#ifdef __linux__
 #include <malloc.h>
+#endif
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>

package.json

@@ -16,7 +16,7 @@
     },
     "dependencies": {
         "bindings": "*",
-        "nan": "^2.6.2"
+        "nan": "^2.8.0"
     },
     "keywords": [
         "scrypt",

scryptjane.c

@@ -12,8 +12,7 @@
 #include "scryptjane/scrypt-jane-romix.h"
 #include "scryptjane/scrypt-jane-test-vectors.h"
 
-
-#define scrypt_maxN 30  /* (1 << (30 + 1)) = ~2 billion */
+#define scrypt_maxNfactor 30  /* (1 << (30 + 1)) = ~2 billion */
 #if (SCRYPT_BLOCK_BYTES == 64)
 #define scrypt_r_32kb 8 /* (1 << 8) = 256 * 2 blocks in a chunk * 64 bytes = Max of 32kb in a chunk */
 #elif (SCRYPT_BLOCK_BYTES == 128)
@@ -23,64 +22,64 @@
 #elif (SCRYPT_BLOCK_BYTES == 512)
 #define scrypt_r_32kb 5 /* (1 << 5) = 32 * 2 blocks in a chunk * 512 bytes = Max of 32kb in a chunk */
 #endif
-#define scrypt_maxr scrypt_r_32kb /* 32kb */
-#define scrypt_maxp 25  /* (1 << 25) = ~33 million */
+#define scrypt_maxrfactor scrypt_r_32kb /* 32kb */
+#define scrypt_maxpfactor 25  /* (1 << 25) = ~33 million */
 
 #include <stdio.h>
-#include <stdlib.h>
+//#include <malloc.h>
 
-static void
+static void NORETURN
 scrypt_fatal_error_default(const char *msg) {
-	fprintf(stderr, "%s\n", msg);
-	exit(1);
+    fprintf(stderr, "%s\n", msg);
+    exit(1);
 }
 
 static scrypt_fatal_errorfn scrypt_fatal_error = scrypt_fatal_error_default;
 
 void
-scrypt_set_fatal_error_default(scrypt_fatal_errorfn fn) {
-	scrypt_fatal_error = fn;
+scrypt_set_fatal_error(scrypt_fatal_errorfn fn) {
+    scrypt_fatal_error = fn;
 }
 
 static int
-scrypt_power_on_self_test() {
-	const scrypt_test_setting *t;
-	uint8_t test_digest[64];
-	uint32_t i;
-	int res = 7, scrypt_valid;
+scrypt_power_on_self_test(void) {
+    const scrypt_test_setting *t;
+    uint8_t test_digest[64];
+    uint32_t i;
+    int res = 7, scrypt_valid;
 
-	if (!scrypt_test_mix()) {
+    if (!scrypt_test_mix()) {
 #if !defined(SCRYPT_TEST)
-		scrypt_fatal_error("scrypt: mix function power-on-self-test failed");
+        scrypt_fatal_error("scrypt: mix function power-on-self-test failed");
 #endif
-		res &= ~1;
-	}
+        res &= ~1;
+    }
 
-	if (!scrypt_test_hash()) {
+    if (!scrypt_test_hash()) {
 #if !defined(SCRYPT_TEST)
-		scrypt_fatal_error("scrypt: hash function power-on-self-test failed");
+        scrypt_fatal_error("scrypt: hash function power-on-self-test failed");
 #endif
-		res &= ~2;
-	}
-
-	for (i = 0, scrypt_valid = 1; post_settings[i].pw; i++) {
-		t = post_settings + i;
-		scrypt((uint8_t *)t->pw, strlen(t->pw), (uint8_t *)t->salt, strlen(t->salt), t->Nfactor, t->rfactor, t->pfactor, test_digest, sizeof(test_digest));
-		scrypt_valid &= scrypt_verify(post_vectors[i], test_digest, sizeof(test_digest));
-	}
-	
-	if (!scrypt_valid) {
+        res &= ~2;
+    }
+
+    for (i = 0, scrypt_valid = 1; post_settings[i].pw; i++) {
+        t = post_settings + i;
+        scrypt((uint8_t *)t->pw, strlen(t->pw), (uint8_t *)t->salt, strlen(t->salt), t->Nfactor, t->rfactor, t->pfactor, test_digest, sizeof(test_digest));
+        scrypt_valid &= scrypt_verify(post_vectors[i], test_digest, sizeof(test_digest));
+    }
+    
+    if (!scrypt_valid) {
 #if !defined(SCRYPT_TEST)
-		scrypt_fatal_error("scrypt: scrypt power-on-self-test failed");
+        scrypt_fatal_error("scrypt: scrypt power-on-self-test failed");
 #endif
-		res &= ~4;
-	}
+        res &= ~4;
+    }
 
-	return res;
+    return res;
 }
 
 typedef struct scrypt_aligned_alloc_t {
-	uint8_t *mem, *ptr;
+    uint8_t *mem, *ptr;
 } scrypt_aligned_alloc;
 
 #if defined(SCRYPT_TEST_SPEED)
@@ -90,95 +89,95 @@ static size_t mem_bump = 0;
 /* allocations are assumed to be multiples of 64 bytes and total allocations not to exceed ~1.01gb */
 static scrypt_aligned_alloc
 scrypt_alloc(uint64_t size) {
-	scrypt_aligned_alloc aa;
-	if (!mem_base) {
-		mem_base = (uint8_t *)malloc((1024 * 1024 * 1024) + (1024 * 1024) + (SCRYPT_BLOCK_BYTES - 1));
-		if (!mem_base)
-			scrypt_fatal_error("scrypt: out of memory");
-		mem_base = (uint8_t *)(((size_t)mem_base + (SCRYPT_BLOCK_BYTES - 1)) & ~(SCRYPT_BLOCK_BYTES - 1));
-	}
-	aa.mem = mem_base + mem_bump;
-	aa.ptr = aa.mem;
-	mem_bump += (size_t)size;
-	return aa;
+    scrypt_aligned_alloc aa;
+    if (!mem_base) {
+        mem_base = (uint8_t *)malloc((1024 * 1024 * 1024) + (1024 * 1024) + (SCRYPT_BLOCK_BYTES - 1));
+        if (!mem_base)
+            scrypt_fatal_error("scrypt: out of memory");
+        mem_base = (uint8_t *)(((size_t)mem_base + (SCRYPT_BLOCK_BYTES - 1)) & ~(SCRYPT_BLOCK_BYTES - 1));
+    }
+    aa.mem = mem_base + mem_bump;
+    aa.ptr = aa.mem;
+    mem_bump += (size_t)size;
+    return aa;
 }
 
 static void
 scrypt_free(scrypt_aligned_alloc *aa) {
-	mem_bump = 0;
+    mem_bump = 0;
 }
 #else
 static scrypt_aligned_alloc
 scrypt_alloc(uint64_t size) {
-	static const size_t max_alloc = (size_t)-1;
-	scrypt_aligned_alloc aa;
-	size += (SCRYPT_BLOCK_BYTES - 1);
-	if (size > max_alloc)
-		scrypt_fatal_error("scrypt: not enough address space on this CPU to allocate required memory");
-	aa.mem = (uint8_t *)malloc((size_t)size);
-	aa.ptr = (uint8_t *)(((size_t)aa.mem + (SCRYPT_BLOCK_BYTES - 1)) & ~(SCRYPT_BLOCK_BYTES - 1));
-	if (!aa.mem)
-		scrypt_fatal_error("scrypt: out of memory");
-	return aa;
+    static const size_t max_alloc = (size_t)-1;
+    scrypt_aligned_alloc aa;
+    size += (SCRYPT_BLOCK_BYTES - 1);
+    if (size > max_alloc)
+        scrypt_fatal_error("scrypt: not enough address space on this CPU to allocate required memory");
+    aa.mem = (uint8_t *)malloc((size_t)size);
+    aa.ptr = (uint8_t *)(((size_t)aa.mem + (SCRYPT_BLOCK_BYTES - 1)) & ~(SCRYPT_BLOCK_BYTES - 1));
+    if (!aa.mem)
+        scrypt_fatal_error("scrypt: out of memory");
+    return aa;
 }
 
 static void
 scrypt_free(scrypt_aligned_alloc *aa) {
-	free(aa->mem);
+    free(aa->mem);
 }
 #endif
 
 
 void
 scrypt(const uint8_t *password, size_t password_len, const uint8_t *salt, size_t salt_len, uint8_t Nfactor, uint8_t rfactor, uint8_t pfactor, uint8_t *out, size_t bytes) {
-	scrypt_aligned_alloc YX, V;
-	uint8_t *X, *Y;
-	uint32_t N, r, p, chunk_bytes, i;
+    scrypt_aligned_alloc YX, V;
+    uint8_t *X, *Y;
+    uint32_t N, r, p, chunk_bytes, i;
 
 #if !defined(SCRYPT_CHOOSE_COMPILETIME)
-	scrypt_ROMixfn scrypt_ROMix = scrypt_getROMix();
+    scrypt_ROMixfn scrypt_ROMix = scrypt_getROMix();
 #endif
 
 #if !defined(SCRYPT_TEST)
-	static int power_on_self_test = 0;
-	if (!power_on_self_test) {
-		power_on_self_test = 1;
-		if (!scrypt_power_on_self_test())
-			scrypt_fatal_error("scrypt: power on self test failed");
-	}
+    static int power_on_self_test = 0;
+    if (!power_on_self_test) {
+        power_on_self_test = 1;
+        if (!scrypt_power_on_self_test())
+            scrypt_fatal_error("scrypt: power on self test failed");
+    }
 #endif
 
-	if (Nfactor > scrypt_maxN)
-		scrypt_fatal_error("scrypt: N out of range");
-	if (rfactor > scrypt_maxr)
-		scrypt_fatal_error("scrypt: r out of range");
-	if (pfactor > scrypt_maxp)
-		scrypt_fatal_error("scrypt: p out of range");
+    if (Nfactor > scrypt_maxNfactor)
+        scrypt_fatal_error("scrypt: N out of range");
+    if (rfactor > scrypt_maxrfactor)
+        scrypt_fatal_error("scrypt: r out of range");
+    if (pfactor > scrypt_maxpfactor)
+        scrypt_fatal_error("scrypt: p out of range");
 
-	N = (1 << (Nfactor + 1));
-	r = (1 << rfactor);
-	p = (1 << pfactor);
+    N = (1 << (Nfactor + 1));
+    r = (1 << rfactor);
+    p = (1 << pfactor);
 
-	chunk_bytes = SCRYPT_BLOCK_BYTES * r * 2;
-	V = scrypt_alloc((uint64_t)N * chunk_bytes);
-	YX = scrypt_alloc((p + 1) * chunk_bytes);
+    chunk_bytes = SCRYPT_BLOCK_BYTES * r * 2;
+    V = scrypt_alloc((uint64_t)N * chunk_bytes);
+    YX = scrypt_alloc((p + 1) * chunk_bytes);
 
-	/* 1: X = PBKDF2(password, salt) */
-	Y = YX.ptr;
-	X = Y + chunk_bytes;
-	scrypt_pbkdf2(password, password_len, salt, salt_len, 1, X, chunk_bytes * p);
+    /* 1: X = PBKDF2(password, salt) */
+    Y = YX.ptr;
+    X = Y + chunk_bytes;
+    scrypt_pbkdf2(password, password_len, salt, salt_len, 1, X, chunk_bytes * p);
 
-	/* 2: X = ROMix(X) */
-	for (i = 0; i < p; i++)
-		scrypt_ROMix((scrypt_mix_word_t *)(X + (chunk_bytes * i)), (scrypt_mix_word_t *)Y, (scrypt_mix_word_t *)V.ptr, N, r);
+    /* 2: X = ROMix(X) */
+    for (i = 0; i < p; i++)
+        scrypt_ROMix((scrypt_mix_word_t *)(X + (chunk_bytes * i)), (scrypt_mix_word_t *)Y, (scrypt_mix_word_t *)V.ptr, N, r);
 
-	/* 3: Out = PBKDF2(password, X) */
-	scrypt_pbkdf2(password, password_len, X, chunk_bytes * p, 1, out, bytes);
+    /* 3: Out = PBKDF2(password, X) */
+    scrypt_pbkdf2(password, password_len, X, chunk_bytes * p, 1, out, bytes);
 
-	scrypt_ensure_zero(YX.ptr, (p + 1) * chunk_bytes);
+    scrypt_ensure_zero(YX.ptr, (p + 1) * chunk_bytes);
 
-	scrypt_free(&V);
-	scrypt_free(&YX);
+    scrypt_free(&V);
+    scrypt_free(&YX);
 }
 
 #define max(a,b)            (((a) > (b)) ? (a) : (b))

scryptjane/scrypt-conf.h

@@ -0,0 +1,28 @@
+/*
+	pick the best algo at runtime or compile time?
+	----------------------------------------------
+	SCRYPT_CHOOSE_COMPILETIME (gcc only!)
+	SCRYPT_CHOOSE_RUNTIME
+*/
+#define SCRYPT_CHOOSE_RUNTIME
+
+
+/*
+	hash function to use
+	-------------------------------
+	SCRYPT_BLAKE256
+	SCRYPT_BLAKE512
+	SCRYPT_SHA256
+	SCRYPT_SHA512
+	SCRYPT_SKEIN512
+*/
+//#define SCRYPT_SHA256
+
+
+/*
+	block mixer to use
+	-----------------------------
+	SCRYPT_CHACHA
+	SCRYPT_SALSA
+*/
+//#define SCRYPT_SALSA