scrypty 0.0.2 → 0.0.3

data/.gitignore

@@ -20,3 +20,5 @@ ext/*.so
 ext/extconf.h
 ext/mkmf.log
 ext/Makefile
+lib/*.so
+.rbenv-version

data/Rakefile

@@ -13,8 +13,24 @@ file "ext/scrypty_ext.so" => FileList["ext/*.c", "ext/*.h", "ext/Makefile"] do
   end
 end
 
+file "lib/scrypty_ext.so" => "ext/scrypty_ext.so" do
+  cp 'ext/scrypty_ext.so', 'lib/scrypty_ext.so'
+end
+
 desc "Compile the scrypty extension"
-task :compile => "ext/scrypty_ext.so"
+task :compile => "lib/scrypty_ext.so"
+
+desc "Prefix C function names"
+task :prefix do
+  names = %w{SHA256Context SHA256_CTX HMAC_SHA256Context HMAC_SHA256_CTX SHA256_Init SHA256_Update SHA256_Final HMAC_SHA256_Init HMAC_SHA256_Update HMAC_SHA256_Final PBKDF2_SHA256 crypto_aesctr_init crypto_aesctr_stream crypto_aesctr_free crypto_scrypt memtouse scryptenc_cpuperf scryptenc_buf scryptdec_buf scryptenc_file scryptdec_file}
+  `git ls-files ext`.chomp.split(/\s+/).each do |filename|
+    data = File.read(filename)
+    names.each do |name|
+      data.gsub!(/(?<!")\b#{name}\b(?!")/m, "scrypty_#{name}")
+    end
+    File.open(filename, "w") { |f| f.write(data) }
+  end
+end
 
 CLEAN.clear
-CLEAN.include(["ext/*.o", "ext/*.so", "ext/extconf.h", "ext/Makefile"])
+CLEAN.include(["ext/*.o", "ext/*.so", "lib/*.so", "ext/extconf.h", "ext/Makefile"])

data/ext/crypto_aesctr.c

@@ -45,13 +45,13 @@ struct crypto_aesctr {
 };
 
 /**
- * crypto_aesctr_init(key, nonce):
+ * scrypty_crypto_aesctr_init(key, nonce):
  * Prepare to encrypt/decrypt data with AES in CTR mode, using the provided
  * expanded key and nonce.  The key provided must remain valid for the
  * lifetime of the stream.
  */
 struct crypto_aesctr *
-crypto_aesctr_init(AES_KEY * key, uint64_t nonce)
+scrypty_crypto_aesctr_init(AES_KEY * key, uint64_t nonce)
 {
 	struct crypto_aesctr * stream;
 
@@ -73,13 +73,13 @@ err0:
 }
 
 /**
- * crypto_aesctr_stream(stream, inbuf, outbuf, buflen):
+ * scrypty_crypto_aesctr_stream(stream, inbuf, outbuf, buflen):
  * Generate the next ${buflen} bytes of the AES-CTR stream and xor them with
  * bytes from ${inbuf}, writing the result into ${outbuf}.  If the buffers
  * ${inbuf} and ${outbuf} overlap, they must be identical.
  */
 void
-crypto_aesctr_stream(struct crypto_aesctr * stream, const uint8_t * inbuf,
+scrypty_crypto_aesctr_stream(struct crypto_aesctr * stream, const uint8_t * inbuf,
     uint8_t * outbuf, size_t buflen)
 {
 	uint8_t pblk[16];
@@ -106,11 +106,11 @@ crypto_aesctr_stream(struct crypto_aesctr * stream, const uint8_t * inbuf,
 }
 
 /**
- * crypto_aesctr_free(stream):
+ * scrypty_crypto_aesctr_free(stream):
  * Free the provided stream object.
  */
 void
-crypto_aesctr_free(struct crypto_aesctr * stream)
+scrypty_crypto_aesctr_free(struct crypto_aesctr * stream)
 {
 	int i;
 

data/ext/crypto_aesctr.h

@@ -34,26 +34,26 @@
 #include <openssl/aes.h>
 
 /**
- * crypto_aesctr_init(key, nonce):
+ * scrypty_crypto_aesctr_init(key, nonce):
  * Prepare to encrypt/decrypt data with AES in CTR mode, using the provided
  * expanded key and nonce.  The key provided must remain valid for the
  * lifetime of the stream.
  */
-struct crypto_aesctr * crypto_aesctr_init(AES_KEY *, uint64_t);
+struct crypto_aesctr * scrypty_crypto_aesctr_init(AES_KEY *, uint64_t);
 
 /**
- * crypto_aesctr_stream(stream, inbuf, outbuf, buflen):
+ * scrypty_crypto_aesctr_stream(stream, inbuf, outbuf, buflen):
  * Generate the next ${buflen} bytes of the AES-CTR stream and xor them with
  * bytes from ${inbuf}, writing the result into ${outbuf}.  If the buffers
  * ${inbuf} and ${outbuf} overlap, they must be identical.
  */
-void crypto_aesctr_stream(struct crypto_aesctr *, const uint8_t *,
+void scrypty_crypto_aesctr_stream(struct crypto_aesctr *, const uint8_t *,
     uint8_t *, size_t);
 
 /**
- * crypto_aesctr_free(stream):
+ * scrypty_crypto_aesctr_free(stream):
  * Free the provided stream object.
  */
-void crypto_aesctr_free(struct crypto_aesctr *);
+void scrypty_crypto_aesctr_free(struct crypto_aesctr *);
 
 #endif /* !_CRYPTO_AESCTR_H_ */

data/ext/crypto_scrypt-nosse.c.orig

@@ -222,7 +222,7 @@ smix(uint8_t * B, size_t r, uint64_t N, uint32_t * V, uint32_t * XY)
 }
 
 /**
- * crypto_scrypt(passwd, passwdlen, salt, saltlen, N, r, p, buf, buflen):
+ * scrypty_crypto_scrypt(passwd, passwdlen, salt, saltlen, N, r, p, buf, buflen):
  * Compute scrypt(passwd[0 .. passwdlen - 1], salt[0 .. saltlen - 1], N, r,
  * p, buflen) and write the result into buf.  The parameters r, p, and buflen
  * must satisfy r * p < 2^30 and buflen <= (2^32 - 1) * 32.  The parameter N
@@ -231,7 +231,7 @@ smix(uint8_t * B, size_t r, uint64_t N, uint32_t * V, uint32_t * XY)
  * Return 0 on success; or -1 on error.
  */
 int
-crypto_scrypt(const uint8_t * passwd, size_t passwdlen,
+scrypty_crypto_scrypt(const uint8_t * passwd, size_t passwdlen,
     const uint8_t * salt, size_t saltlen, uint64_t N, uint32_t r, uint32_t p,
     uint8_t * buf, size_t buflen)
 {
@@ -304,7 +304,7 @@ crypto_scrypt(const uint8_t * passwd, size_t passwdlen,
 #endif
 
 	/* 1: (B_0 ... B_{p-1}) <-- PBKDF2(P, S, 1, p * MFLen) */
-	PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, 1, B, p * 128 * r);
+	scrypty_PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, 1, B, p * 128 * r);
 
 	/* 2: for i = 0 to p - 1 do */
 	for (i = 0; i < p; i++) {
@@ -313,7 +313,7 @@ crypto_scrypt(const uint8_t * passwd, size_t passwdlen,
 	}
 
 	/* 5: DK <-- PBKDF2(P, B, 1, dkLen) */
-	PBKDF2_SHA256(passwd, passwdlen, B, p * 128 * r, 1, buf, buflen);
+	scrypty_PBKDF2_SHA256(passwd, passwdlen, B, p * 128 * r, 1, buf, buflen);
 
 	/* Free memory. */
 #ifdef MAP_ANON

data/ext/crypto_scrypt-ref.c

@@ -204,7 +204,7 @@ smix(uint8_t * B, size_t r, uint64_t N, uint8_t * V, uint8_t * XY)
 }
 
 /**
- * crypto_scrypt(passwd, passwdlen, salt, saltlen, N, r, p, buf, buflen):
+ * scrypty_crypto_scrypt(passwd, passwdlen, salt, saltlen, N, r, p, buf, buflen):
  * Compute scrypt(passwd[0 .. passwdlen - 1], salt[0 .. saltlen - 1], N, r,
  * p, buflen) and write the result into buf.  The parameters r, p, and buflen
  * must satisfy r * p < 2^30 and buflen <= (2^32 - 1) * 32.  The parameter N
@@ -213,7 +213,7 @@ smix(uint8_t * B, size_t r, uint64_t N, uint8_t * V, uint8_t * XY)
  * Return 0 on success; or -1 on error.
  */
 int
-crypto_scrypt(const uint8_t * passwd, size_t passwdlen,
+scrypty_crypto_scrypt(const uint8_t * passwd, size_t passwdlen,
     const uint8_t * salt, size_t saltlen, uint64_t N, uint32_t r, uint32_t p,
     uint8_t * buf, size_t buflen)
 {
@@ -255,7 +255,7 @@ crypto_scrypt(const uint8_t * passwd, size_t passwdlen,
 		goto err2;
 
 	/* 1: (B_0 ... B_{p-1}) <-- PBKDF2(P, S, 1, p * MFLen) */
-	PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, 1, B, p * 128 * r);
+	scrypty_PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, 1, B, p * 128 * r);
 
 	/* 2: for i = 0 to p - 1 do */
 	for (i = 0; i < p; i++) {
@@ -264,7 +264,7 @@ crypto_scrypt(const uint8_t * passwd, size_t passwdlen,
 	}
 
 	/* 5: DK <-- PBKDF2(P, B, 1, dkLen) */
-	PBKDF2_SHA256(passwd, passwdlen, B, p * 128 * r, 1, buf, buflen);
+	scrypty_PBKDF2_SHA256(passwd, passwdlen, B, p * 128 * r, 1, buf, buflen);
 
 	/* Free memory. */
 	free(V);

data/ext/crypto_scrypt-sse.c.orig

@@ -250,7 +250,7 @@ smix(uint8_t * B, size_t r, uint64_t N, void * V, void * XY)
 }
 
 /**
- * crypto_scrypt(passwd, passwdlen, salt, saltlen, N, r, p, buf, buflen):
+ * scrypty_crypto_scrypt(passwd, passwdlen, salt, saltlen, N, r, p, buf, buflen):
  * Compute scrypt(passwd[0 .. passwdlen - 1], salt[0 .. saltlen - 1], N, r,
  * p, buflen) and write the result into buf.  The parameters r, p, and buflen
  * must satisfy r * p < 2^30 and buflen <= (2^32 - 1) * 32.  The parameter N
@@ -259,7 +259,7 @@ smix(uint8_t * B, size_t r, uint64_t N, void * V, void * XY)
  * Return 0 on success; or -1 on error.
  */
 int
-crypto_scrypt(const uint8_t * passwd, size_t passwdlen,
+scrypty_crypto_scrypt(const uint8_t * passwd, size_t passwdlen,
     const uint8_t * salt, size_t saltlen, uint64_t N, uint32_t r, uint32_t p,
     uint8_t * buf, size_t buflen)
 {
@@ -332,7 +332,7 @@ crypto_scrypt(const uint8_t * passwd, size_t passwdlen,
 #endif
 
 	/* 1: (B_0 ... B_{p-1}) <-- PBKDF2(P, S, 1, p * MFLen) */
-	PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, 1, B, p * 128 * r);
+	scrypty_PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, 1, B, p * 128 * r);
 
 	/* 2: for i = 0 to p - 1 do */
 	for (i = 0; i < p; i++) {
@@ -341,7 +341,7 @@ crypto_scrypt(const uint8_t * passwd, size_t passwdlen,
 	}
 
 	/* 5: DK <-- PBKDF2(P, B, 1, dkLen) */
-	PBKDF2_SHA256(passwd, passwdlen, B, p * 128 * r, 1, buf, buflen);
+	scrypty_PBKDF2_SHA256(passwd, passwdlen, B, p * 128 * r, 1, buf, buflen);
 
 	/* Free memory. */
 #ifdef MAP_ANON

data/ext/crypto_scrypt.h

@@ -32,7 +32,7 @@
 #include <stdint.h>
 
 /**
- * crypto_scrypt(passwd, passwdlen, salt, saltlen, N, r, p, buf, buflen):
+ * scrypty_crypto_scrypt(passwd, passwdlen, salt, saltlen, N, r, p, buf, buflen):
  * Compute scrypt(passwd[0 .. passwdlen - 1], salt[0 .. saltlen - 1], N, r,
  * p, buflen) and write the result into buf.  The parameters r, p, and buflen
  * must satisfy r * p < 2^30 and buflen <= (2^32 - 1) * 32.  The parameter N
@@ -40,7 +40,7 @@
  *
  * Return 0 on success; or -1 on error.
  */
-int crypto_scrypt(const uint8_t *, size_t, const uint8_t *, size_t, uint64_t,
+int scrypty_crypto_scrypt(const uint8_t *, size_t, const uint8_t *, size_t, uint64_t,
     uint32_t, uint32_t, uint8_t *, size_t);
 
 #endif /* !_CRYPTO_SCRYPT_H_ */

data/ext/memlimit.c

@@ -233,7 +233,7 @@ memlimit_sysconf(size_t * memlimit)
 #endif
 
 int
-memtouse(size_t maxmem, double maxmemfrac, size_t * memlimit)
+scrypty_memtouse(size_t maxmem, double maxmemfrac, size_t * memlimit)
 {
 	size_t sysctl_memlimit, sysinfo_memlimit, rlimit_memlimit;
 	size_t sysconf_memlimit;

data/ext/memlimit.h

@@ -32,11 +32,11 @@
 #include <stddef.h>
 
 /**
- * memtouse(maxmem, maxmemfrac, memlimit):
+ * scrypty_memtouse(maxmem, maxmemfrac, memlimit):
  * Examine the system and return via memlimit the amount of RAM which should
  * be used -- the specified fraction of the available RAM, but no more than
  * maxmem, and no less than 1MiB.
  */
-int memtouse(size_t, double, size_t *);
+int scrypty_memtouse(size_t, double, size_t *);
 
 #endif /* !_MEMLIMIT_H_ */

data/ext/ruby_ext.c

@@ -142,7 +142,7 @@ scrypty_buffer(rb_obj, rb_data, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxtim
     rb_out = rb_str_new(NULL, out_len);
     out = RSTRING_PTR(rb_out);
 
-    errorcode = scryptenc_buf((const uint8_t *) data, data_len,
+    errorcode = scrypty_scryptenc_buf((const uint8_t *) data, data_len,
         (uint8_t *) out, (const uint8_t *) password, password_len,
         maxmem, maxmemfrac, maxtime);
   }
@@ -150,7 +150,7 @@ scrypty_buffer(rb_obj, rb_data, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxtim
     rb_out = rb_str_new(NULL, data_len);
     out = RSTRING_PTR(rb_out);
 
-    errorcode = scryptdec_buf((const uint8_t *) data, data_len,
+    errorcode = scrypty_scryptdec_buf((const uint8_t *) data, data_len,
         (uint8_t *) out, &out_len, (const uint8_t *) password, password_len,
         maxmem, maxmemfrac, maxtime);
   }
@@ -246,11 +246,11 @@ scrypty_file(rb_obj, rb_infn, rb_outfn, rb_password, rb_maxmem, rb_maxmemfrac, r
   out = rb_io_stdio_file(out_p);
 
   if (encrypt) {
-    errorcode = scryptenc_file(in, out, (const uint8_t *) password,
+    errorcode = scrypty_scryptenc_file(in, out, (const uint8_t *) password,
         password_len, maxmem, maxmemfrac, maxtime);
   }
   else {
-    errorcode = scryptdec_file(in, out, (const uint8_t *) password,
+    errorcode = scrypty_scryptdec_file(in, out, (const uint8_t *) password,
         password_len, maxmem, maxmemfrac, maxtime);
   }
   rb_io_close(rb_infile);

data/ext/scryptenc.c

@@ -64,11 +64,11 @@ pickparams(size_t maxmem, double maxmemfrac, double maxtime,
 	int rc;
 
 	/* Figure out how much memory to use. */
-	if (memtouse(maxmem, maxmemfrac, &memlimit))
+	if (scrypty_memtouse(maxmem, maxmemfrac, &memlimit))
 		return (1);
 
 	/* Figure out how fast the CPU is. */
-	if ((rc = scryptenc_cpuperf(&opps)) != 0)
+	if ((rc = scrypty_scryptenc_cpuperf(&opps)) != 0)
 		return (rc);
 	opslimit = opps * maxtime;
 
@@ -131,11 +131,11 @@ checkparams(size_t maxmem, double maxmemfrac, double maxtime,
 	int rc;
 
 	/* Figure out the maximum amount of memory we can use. */
-	if (memtouse(maxmem, maxmemfrac, &memlimit))
+	if (scrypty_memtouse(maxmem, maxmemfrac, &memlimit))
 		return (1);
 
 	/* Figure out how fast the CPU is. */
-	if ((rc = scryptenc_cpuperf(&opps)) != 0)
+	if ((rc = scrypty_scryptenc_cpuperf(&opps)) != 0)
 		return (rc);
 	opslimit = opps * maxtime;
 
@@ -209,9 +209,9 @@ scryptenc_setup(uint8_t header[96], uint8_t dk[64],
 	uint64_t N;
 	uint32_t r;
 	uint32_t p;
-	SHA256_CTX ctx;
+	scrypty_SHA256_CTX ctx;
 	uint8_t * key_hmac = &dk[32];
-	HMAC_SHA256_CTX hctx;
+	scrypty_HMAC_SHA256_CTX hctx;
 	int rc;
 
 	/* Pick values for N, r, p. */
@@ -225,7 +225,7 @@ scryptenc_setup(uint8_t header[96], uint8_t dk[64],
 		return (rc);
 
 	/* Generate the derived keys. */
-	if (crypto_scrypt(passwd, passwdlen, salt, 32, N, r, p, dk, 64))
+	if (scrypty_crypto_scrypt(passwd, passwdlen, salt, 32, N, r, p, dk, 64))
 		return (3);
 
 	/* Construct the file header. */
@@ -237,15 +237,15 @@ scryptenc_setup(uint8_t header[96], uint8_t dk[64],
 	memcpy(&header[16], salt, 32);
 
 	/* Add header checksum. */
-	SHA256_Init(&ctx);
-	SHA256_Update(&ctx, header, 48);
-	SHA256_Final(hbuf, &ctx);
+	scrypty_SHA256_Init(&ctx);
+	scrypty_SHA256_Update(&ctx, header, 48);
+	scrypty_SHA256_Final(hbuf, &ctx);
 	memcpy(&header[48], hbuf, 16);
 
 	/* Add header signature (used for verifying password). */
-	HMAC_SHA256_Init(&hctx, key_hmac, 32);
-	HMAC_SHA256_Update(&hctx, header, 64);
-	HMAC_SHA256_Final(hbuf, &hctx);
+	scrypty_HMAC_SHA256_Init(&hctx, key_hmac, 32);
+	scrypty_HMAC_SHA256_Update(&hctx, header, 64);
+	scrypty_HMAC_SHA256_Final(hbuf, &hctx);
 	memcpy(&header[64], hbuf, 32);
 
 	/* Success! */
@@ -263,9 +263,9 @@ scryptdec_setup(const uint8_t header[96], uint8_t dk[64],
 	uint32_t r;
 	uint32_t p;
 	uint64_t N;
-	SHA256_CTX ctx;
+	scrypty_SHA256_CTX ctx;
 	uint8_t * key_hmac = &dk[32];
-	HMAC_SHA256_CTX hctx;
+	scrypty_HMAC_SHA256_CTX hctx;
 	int rc;
 
 	/* Parse N, r, p, salt. */
@@ -275,9 +275,9 @@ scryptdec_setup(const uint8_t header[96], uint8_t dk[64],
 	memcpy(salt, &header[16], 32);
 
 	/* Verify header checksum. */
-	SHA256_Init(&ctx);
-	SHA256_Update(&ctx, header, 48);
-	SHA256_Final(hbuf, &ctx);
+	scrypty_SHA256_Init(&ctx);
+	scrypty_SHA256_Update(&ctx, header, 48);
+	scrypty_SHA256_Final(hbuf, &ctx);
 	if (memcmp(&header[48], hbuf, 16))
 		return (7);
 
@@ -291,13 +291,13 @@ scryptdec_setup(const uint8_t header[96], uint8_t dk[64],
 
 	/* Compute the derived keys. */
 	N = (uint64_t)(1) << logN;
-	if (crypto_scrypt(passwd, passwdlen, salt, 32, N, r, p, dk, 64))
+	if (scrypty_crypto_scrypt(passwd, passwdlen, salt, 32, N, r, p, dk, 64))
 		return (3);
 
 	/* Check header signature (i.e., verify password). */
-	HMAC_SHA256_Init(&hctx, key_hmac, 32);
-	HMAC_SHA256_Update(&hctx, header, 64);
-	HMAC_SHA256_Final(hbuf, &hctx);
+	scrypty_HMAC_SHA256_Init(&hctx, key_hmac, 32);
+	scrypty_HMAC_SHA256_Update(&hctx, header, 64);
+	scrypty_HMAC_SHA256_Final(hbuf, &hctx);
 	if (memcmp(hbuf, &header[64], 32))
 		return (11);
 
@@ -306,13 +306,13 @@ scryptdec_setup(const uint8_t header[96], uint8_t dk[64],
 }
 
 /**
- * scryptenc_buf(inbuf, inbuflen, outbuf, passwd, passwdlen,
+ * scrypty_scryptenc_buf(inbuf, inbuflen, outbuf, passwd, passwdlen,
  *     maxmem, maxmemfrac, maxtime):
  * Encrypt inbuflen bytes from inbuf, writing the resulting inbuflen + 128
  * bytes to outbuf.
  */
 int
-scryptenc_buf(const uint8_t * inbuf, size_t inbuflen, uint8_t * outbuf,
+scrypty_scryptenc_buf(const uint8_t * inbuf, size_t inbuflen, uint8_t * outbuf,
     const uint8_t * passwd, size_t passwdlen,
     size_t maxmem, double maxmemfrac, double maxtime)
 {
@@ -322,7 +322,7 @@ scryptenc_buf(const uint8_t * inbuf, size_t inbuflen, uint8_t * outbuf,
 	uint8_t * key_enc = dk;
 	uint8_t * key_hmac = &dk[32];
 	int rc;
-	HMAC_SHA256_CTX hctx;
+	scrypty_HMAC_SHA256_CTX hctx;
 	AES_KEY key_enc_exp;
 	struct crypto_aesctr * AES;
 
@@ -337,15 +337,15 @@ scryptenc_buf(const uint8_t * inbuf, size_t inbuflen, uint8_t * outbuf,
 	/* Encrypt data. */
 	if (AES_set_encrypt_key(key_enc, 256, &key_enc_exp))
 		return (5);
-	if ((AES = crypto_aesctr_init(&key_enc_exp, 0)) == NULL)
+	if ((AES = scrypty_crypto_aesctr_init(&key_enc_exp, 0)) == NULL)
 		return (6);
-	crypto_aesctr_stream(AES, inbuf, &outbuf[96], inbuflen);
-	crypto_aesctr_free(AES);
+	scrypty_crypto_aesctr_stream(AES, inbuf, &outbuf[96], inbuflen);
+	scrypty_crypto_aesctr_free(AES);
 
 	/* Add signature. */
-	HMAC_SHA256_Init(&hctx, key_hmac, 32);
-	HMAC_SHA256_Update(&hctx, outbuf, 96 + inbuflen);
-	HMAC_SHA256_Final(hbuf, &hctx);
+	scrypty_HMAC_SHA256_Init(&hctx, key_hmac, 32);
+	scrypty_HMAC_SHA256_Update(&hctx, outbuf, 96 + inbuflen);
+	scrypty_HMAC_SHA256_Final(hbuf, &hctx);
 	memcpy(&outbuf[96 + inbuflen], hbuf, 32);
 
 	/* Zero sensitive data. */
@@ -357,14 +357,14 @@ scryptenc_buf(const uint8_t * inbuf, size_t inbuflen, uint8_t * outbuf,
 }
 
 /**
- * scryptdec_buf(inbuf, inbuflen, outbuf, outlen, passwd, passwdlen,
+ * scrypty_scryptdec_buf(inbuf, inbuflen, outbuf, outlen, passwd, passwdlen,
  *     maxmem, maxmemfrac, maxtime):
  * Decrypt inbuflen bytes fro inbuf, writing the result into outbuf and the
  * decrypted data length to outlen.  The allocated length of outbuf must
  * be at least inbuflen.
  */
 int
-scryptdec_buf(const uint8_t * inbuf, size_t inbuflen, uint8_t * outbuf,
+scrypty_scryptdec_buf(const uint8_t * inbuf, size_t inbuflen, uint8_t * outbuf,
     size_t * outlen, const uint8_t * passwd, size_t passwdlen,
     size_t maxmem, double maxmemfrac, double maxtime)
 {
@@ -373,7 +373,7 @@ scryptdec_buf(const uint8_t * inbuf, size_t inbuflen, uint8_t * outbuf,
 	uint8_t * key_enc = dk;
 	uint8_t * key_hmac = &dk[32];
 	int rc;
-	HMAC_SHA256_CTX hctx;
+	scrypty_HMAC_SHA256_CTX hctx;
 	AES_KEY key_enc_exp;
 	struct crypto_aesctr * AES;
 
@@ -400,16 +400,16 @@ scryptdec_buf(const uint8_t * inbuf, size_t inbuflen, uint8_t * outbuf,
 	/* Decrypt data. */
 	if (AES_set_encrypt_key(key_enc, 256, &key_enc_exp))
 		return (5);
-	if ((AES = crypto_aesctr_init(&key_enc_exp, 0)) == NULL)
+	if ((AES = scrypty_crypto_aesctr_init(&key_enc_exp, 0)) == NULL)
 		return (6);
-	crypto_aesctr_stream(AES, &inbuf[96], outbuf, inbuflen - 128);
-	crypto_aesctr_free(AES);
+	scrypty_crypto_aesctr_stream(AES, &inbuf[96], outbuf, inbuflen - 128);
+	scrypty_crypto_aesctr_free(AES);
 	*outlen = inbuflen - 128;
 
 	/* Verify signature. */
-	HMAC_SHA256_Init(&hctx, key_hmac, 32);
-	HMAC_SHA256_Update(&hctx, inbuf, inbuflen - 32);
-	HMAC_SHA256_Final(hbuf, &hctx);
+	scrypty_HMAC_SHA256_Init(&hctx, key_hmac, 32);
+	scrypty_HMAC_SHA256_Update(&hctx, inbuf, inbuflen - 32);
+	scrypty_HMAC_SHA256_Final(hbuf, &hctx);
 	if (memcmp(hbuf, &inbuf[inbuflen - 32], 32))
 		return (7);
 
@@ -422,13 +422,13 @@ scryptdec_buf(const uint8_t * inbuf, size_t inbuflen, uint8_t * outbuf,
 }
 
 /**
- * scryptenc_file(infile, outfile, passwd, passwdlen,
+ * scrypty_scryptenc_file(infile, outfile, passwd, passwdlen,
  *     maxmem, maxmemfrac, maxtime):
  * Read a stream from infile and encrypt it, writing the resulting stream to
  * outfile.
  */
 int
-scryptenc_file(FILE * infile, FILE * outfile,
+scrypty_scryptenc_file(FILE * infile, FILE * outfile,
     const uint8_t * passwd, size_t passwdlen,
     size_t maxmem, double maxmemfrac, double maxtime)
 {
@@ -439,7 +439,7 @@ scryptenc_file(FILE * infile, FILE * outfile,
 	uint8_t * key_enc = dk;
 	uint8_t * key_hmac = &dk[32];
 	size_t readlen;
-	HMAC_SHA256_CTX hctx;
+	scrypty_HMAC_SHA256_CTX hctx;
 	AES_KEY key_enc_exp;
 	struct crypto_aesctr * AES;
 	int rc;
@@ -450,8 +450,8 @@ scryptenc_file(FILE * infile, FILE * outfile,
 		return (rc);
 
 	/* Hash and write the header. */
-	HMAC_SHA256_Init(&hctx, key_hmac, 32);
-	HMAC_SHA256_Update(&hctx, header, 96);
+	scrypty_HMAC_SHA256_Init(&hctx, key_hmac, 32);
+	scrypty_HMAC_SHA256_Update(&hctx, header, 96);
 	if (fwrite(header, 96, 1, outfile) != 1)
 		return (12);
 
@@ -461,24 +461,24 @@ scryptenc_file(FILE * infile, FILE * outfile,
 	 */
 	if (AES_set_encrypt_key(key_enc, 256, &key_enc_exp))
 		return (5);
-	if ((AES = crypto_aesctr_init(&key_enc_exp, 0)) == NULL)
+	if ((AES = scrypty_crypto_aesctr_init(&key_enc_exp, 0)) == NULL)
 		return (6);
 	do {
 		if ((readlen = fread(buf, 1, ENCBLOCK, infile)) == 0)
 			break;
-		crypto_aesctr_stream(AES, buf, buf, readlen);
-		HMAC_SHA256_Update(&hctx, buf, readlen);
+		scrypty_crypto_aesctr_stream(AES, buf, buf, readlen);
+		scrypty_HMAC_SHA256_Update(&hctx, buf, readlen);
 		if (fwrite(buf, 1, readlen, outfile) < readlen)
 			return (12);
 	} while (1);
-	crypto_aesctr_free(AES);
+	scrypty_crypto_aesctr_free(AES);
 
 	/* Did we exit the loop due to a read error? */
 	if (ferror(infile))
 		return (13);
 
 	/* Compute the final HMAC and output it. */
-	HMAC_SHA256_Final(hbuf, &hctx);
+	scrypty_HMAC_SHA256_Final(hbuf, &hctx);
 	if (fwrite(hbuf, 32, 1, outfile) != 1)
 		return (12);
 
@@ -491,13 +491,13 @@ scryptenc_file(FILE * infile, FILE * outfile,
 }
 
 /**
- * scryptdec_file(infile, outfile, passwd, passwdlen,
+ * scrypty_scryptdec_file(infile, outfile, passwd, passwdlen,
  *     maxmem, maxmemfrac, maxtime):
  * Read a stream from infile and decrypt it, writing the resulting stream to
  * outfile.
  */
 int
-scryptdec_file(FILE * infile, FILE * outfile,
+scrypty_scryptdec_file(FILE * infile, FILE * outfile,
     const uint8_t * passwd, size_t passwdlen,
     size_t maxmem, double maxmemfrac, double maxtime)
 {
@@ -509,7 +509,7 @@ scryptdec_file(FILE * infile, FILE * outfile,
 	uint8_t * key_hmac = &dk[32];
 	size_t buflen = 0;
 	size_t readlen;
-	HMAC_SHA256_CTX hctx;
+	scrypty_HMAC_SHA256_CTX hctx;
 	AES_KEY key_enc_exp;
 	struct crypto_aesctr * AES;
 	int rc;
@@ -548,8 +548,8 @@ scryptdec_file(FILE * infile, FILE * outfile,
 		return (rc);
 
 	/* Start hashing with the header. */
-	HMAC_SHA256_Init(&hctx, key_hmac, 32);
-	HMAC_SHA256_Update(&hctx, header, 96);
+	scrypty_HMAC_SHA256_Init(&hctx, key_hmac, 32);
+	scrypty_HMAC_SHA256_Update(&hctx, header, 96);
 
 	/*
 	 * We don't know how long the encrypted data block is (we can't know,
@@ -559,7 +559,7 @@ scryptdec_file(FILE * infile, FILE * outfile,
 	 */
 	if (AES_set_encrypt_key(key_enc, 256, &key_enc_exp))
 		return (5);
-	if ((AES = crypto_aesctr_init(&key_enc_exp, 0)) == NULL)
+	if ((AES = scrypty_crypto_aesctr_init(&key_enc_exp, 0)) == NULL)
 		return (6);
 	do {
 		/* Read data until we have more than 32 bytes of it. */
@@ -574,8 +574,8 @@ scryptdec_file(FILE * infile, FILE * outfile,
 		 * Decrypt, hash, and output everything except the last 32
 		 * bytes out of what we have in our buffer.
 		 */
-		HMAC_SHA256_Update(&hctx, buf, buflen - 32);
-		crypto_aesctr_stream(AES, buf, buf, buflen - 32);
+		scrypty_HMAC_SHA256_Update(&hctx, buf, buflen - 32);
+		scrypty_crypto_aesctr_stream(AES, buf, buf, buflen - 32);
 		if (fwrite(buf, 1, buflen - 32, outfile) < buflen - 32)
 			return (12);
 
@@ -583,7 +583,7 @@ scryptdec_file(FILE * infile, FILE * outfile,
 		memmove(buf, &buf[buflen - 32], 32);
 		buflen = 32;
 	} while (1);
-	crypto_aesctr_free(AES);
+	scrypty_crypto_aesctr_free(AES);
 
 	/* Did we exit the loop due to a read error? */
 	if (ferror(infile))
@@ -594,7 +594,7 @@ scryptdec_file(FILE * infile, FILE * outfile,
 		return (7);
 
 	/* Verify signature. */
-	HMAC_SHA256_Final(hbuf, &hctx);
+	scrypty_HMAC_SHA256_Final(hbuf, &hctx);
 	if (memcmp(hbuf, buf, 32))
 		return (7);
 

data/ext/scryptenc.h

@@ -73,40 +73,40 @@
  */
 
 /**
- * scryptenc_buf(inbuf, inbuflen, outbuf, passwd, passwdlen,
+ * scrypty_scryptenc_buf(inbuf, inbuflen, outbuf, passwd, passwdlen,
  *     maxmem, maxmemfrac, maxtime):
  * Encrypt inbuflen bytes from inbuf, writing the resulting inbuflen + 128
  * bytes to outbuf.
  */
-int scryptenc_buf(const uint8_t *, size_t, uint8_t *,
+int scrypty_scryptenc_buf(const uint8_t *, size_t, uint8_t *,
     const uint8_t *, size_t, size_t, double, double);
 
 /**
- * scryptdec_buf(inbuf, inbuflen, outbuf, outlen, passwd, passwdlen,
+ * scrypty_scryptdec_buf(inbuf, inbuflen, outbuf, outlen, passwd, passwdlen,
  *     maxmem, maxmemfrac, maxtime):
  * Decrypt inbuflen bytes from inbuf, writing the result into outbuf and the
  * decrypted data length to outlen.  The allocated length of outbuf must
  * be at least inbuflen.
  */
-int scryptdec_buf(const uint8_t *, size_t, uint8_t *, size_t *,
+int scrypty_scryptdec_buf(const uint8_t *, size_t, uint8_t *, size_t *,
     const uint8_t *, size_t, size_t, double, double);
 
 /**
- * scryptenc_file(infile, outfile, passwd, passwdlen,
+ * scrypty_scryptenc_file(infile, outfile, passwd, passwdlen,
  *     maxmem, maxmemfrac, maxtime):
  * Read a stream from infile and encrypt it, writing the resulting stream to
  * outfile.
  */
-int scryptenc_file(FILE *, FILE *, const uint8_t *, size_t,
+int scrypty_scryptenc_file(FILE *, FILE *, const uint8_t *, size_t,
     size_t, double, double);
 
 /**
- * scryptdec_file(infile, outfile, passwd, passwdlen,
+ * scrypty_scryptdec_file(infile, outfile, passwd, passwdlen,
  *     maxmem, maxmemfrac, maxtime):
  * Read a stream from infile and decrypt it, writing the resulting stream to
  * outfile.
  */
-int scryptdec_file(FILE *, FILE *, const uint8_t *, size_t,
+int scrypty_scryptdec_file(FILE *, FILE *, const uint8_t *, size_t,
     size_t, double, double);
 
 #endif /* !_SCRYPTENC_H_ */

data/ext/scryptenc_cpuperf.c

@@ -122,12 +122,12 @@ getclockdiff(struct timespec * st, double * diffd)
 }
 
 /**
- * scryptenc_cpuperf(opps):
+ * scrypty_scryptenc_cpuperf(opps):
  * Estimate the number of salsa20/8 cores which can be executed per second,
  * and return the value via opps.
  */
 int
-scryptenc_cpuperf(double * opps)
+scrypty_scryptenc_cpuperf(double * opps)
 {
 	struct timespec st;
 	double resd, diffd;
@@ -146,7 +146,7 @@ scryptenc_cpuperf(double * opps)
 		return (2);
 	do {
 		/* Do an scrypt. */
-		if (crypto_scrypt(NULL, 0, NULL, 0, 16, 1, 1, NULL, 0))
+		if (scrypty_crypto_scrypt(NULL, 0, NULL, 0, 16, 1, 1, NULL, 0))
 			return (3);
 
 		/* Has the clock ticked? */
@@ -161,7 +161,7 @@ scryptenc_cpuperf(double * opps)
 		return (2);
 	do {
 		/* Do an scrypt. */
-		if (crypto_scrypt(NULL, 0, NULL, 0, 128, 1, 1, NULL, 0))
+		if (scrypty_crypto_scrypt(NULL, 0, NULL, 0, 128, 1, 1, NULL, 0))
 			return (3);
 
 		/* We invoked the salsa20/8 core 512 times. */

data/ext/scryptenc_cpuperf.h

@@ -30,10 +30,10 @@
 #define _SCRYPTENC_CPUPERF_H_
 
 /**
- * scryptenc_cpuperf(opps):
+ * scrypty_scryptenc_cpuperf(opps):
  * Estimate the number of salsa20/8 cores which can be executed per second,
  * and return the value via opps.
  */
-int scryptenc_cpuperf(double *);
+int scrypty_scryptenc_cpuperf(double *);
 
 #endif /* !_SCRYPTENC_CPUPERF_H_ */

data/ext/sha256.c

@@ -190,7 +190,7 @@ static unsigned char PAD[64] = {
 
 /* Add padding and terminating bit-count. */
 static void
-SHA256_Pad(SHA256_CTX * ctx)
+SHA256_Pad(scrypty_SHA256_CTX * ctx)
 {
 	unsigned char len[8];
 	uint32_t r, plen;
@@ -204,15 +204,15 @@ SHA256_Pad(SHA256_CTX * ctx)
 	/* Add 1--64 bytes so that the resulting length is 56 mod 64 */
 	r = (ctx->count[1] >> 3) & 0x3f;
 	plen = (r < 56) ? (56 - r) : (120 - r);
-	SHA256_Update(ctx, PAD, (size_t)plen);
+	scrypty_SHA256_Update(ctx, PAD, (size_t)plen);
 
 	/* Add the terminating bit-count */
-	SHA256_Update(ctx, len, 8);
+	scrypty_SHA256_Update(ctx, len, 8);
 }
 
 /* SHA-256 initialization.  Begins a SHA-256 operation. */
 void
-SHA256_Init(SHA256_CTX * ctx)
+scrypty_SHA256_Init(scrypty_SHA256_CTX * ctx)
 {
 
 	/* Zero bits processed so far */
@@ -231,7 +231,7 @@ SHA256_Init(SHA256_CTX * ctx)
 
 /* Add bytes into the hash */
 void
-SHA256_Update(SHA256_CTX * ctx, const void *in, size_t len)
+scrypty_SHA256_Update(scrypty_SHA256_CTX * ctx, const void *in, size_t len)
 {
 	uint32_t bitlen[2];
 	uint32_t r;
@@ -277,7 +277,7 @@ SHA256_Update(SHA256_CTX * ctx, const void *in, size_t len)
  * and clears the context state.
  */
 void
-SHA256_Final(unsigned char digest[32], SHA256_CTX * ctx)
+scrypty_SHA256_Final(unsigned char digest[32], scrypty_SHA256_CTX * ctx)
 {
 
 	/* Add padding */
@@ -292,7 +292,7 @@ SHA256_Final(unsigned char digest[32], SHA256_CTX * ctx)
 
 /* Initialize an HMAC-SHA256 operation with the given key. */
 void
-HMAC_SHA256_Init(HMAC_SHA256_CTX * ctx, const void * _K, size_t Klen)
+scrypty_HMAC_SHA256_Init(scrypty_HMAC_SHA256_CTX * ctx, const void * _K, size_t Klen)
 {
 	unsigned char pad[64];
 	unsigned char khash[32];
@@ -301,26 +301,26 @@ HMAC_SHA256_Init(HMAC_SHA256_CTX * ctx, const void * _K, size_t Klen)
 
 	/* If Klen > 64, the key is really SHA256(K). */
 	if (Klen > 64) {
-		SHA256_Init(&ctx->ictx);
-		SHA256_Update(&ctx->ictx, K, Klen);
-		SHA256_Final(khash, &ctx->ictx);
+		scrypty_SHA256_Init(&ctx->ictx);
+		scrypty_SHA256_Update(&ctx->ictx, K, Klen);
+		scrypty_SHA256_Final(khash, &ctx->ictx);
 		K = khash;
 		Klen = 32;
 	}
 
 	/* Inner SHA256 operation is SHA256(K xor [block of 0x36] || data). */
-	SHA256_Init(&ctx->ictx);
+	scrypty_SHA256_Init(&ctx->ictx);
 	memset(pad, 0x36, 64);
 	for (i = 0; i < Klen; i++)
 		pad[i] ^= K[i];
-	SHA256_Update(&ctx->ictx, pad, 64);
+	scrypty_SHA256_Update(&ctx->ictx, pad, 64);
 
 	/* Outer SHA256 operation is SHA256(K xor [block of 0x5c] || hash). */
-	SHA256_Init(&ctx->octx);
+	scrypty_SHA256_Init(&ctx->octx);
 	memset(pad, 0x5c, 64);
 	for (i = 0; i < Klen; i++)
 		pad[i] ^= K[i];
-	SHA256_Update(&ctx->octx, pad, 64);
+	scrypty_SHA256_Update(&ctx->octx, pad, 64);
 
 	/* Clean the stack. */
 	memset(khash, 0, 32);
@@ -328,42 +328,42 @@ HMAC_SHA256_Init(HMAC_SHA256_CTX * ctx, const void * _K, size_t Klen)
 
 /* Add bytes to the HMAC-SHA256 operation. */
 void
-HMAC_SHA256_Update(HMAC_SHA256_CTX * ctx, const void *in, size_t len)
+scrypty_HMAC_SHA256_Update(scrypty_HMAC_SHA256_CTX * ctx, const void *in, size_t len)
 {
 
 	/* Feed data to the inner SHA256 operation. */
-	SHA256_Update(&ctx->ictx, in, len);
+	scrypty_SHA256_Update(&ctx->ictx, in, len);
 }
 
 /* Finish an HMAC-SHA256 operation. */
 void
-HMAC_SHA256_Final(unsigned char digest[32], HMAC_SHA256_CTX * ctx)
+scrypty_HMAC_SHA256_Final(unsigned char digest[32], scrypty_HMAC_SHA256_CTX * ctx)
 {
 	unsigned char ihash[32];
 
 	/* Finish the inner SHA256 operation. */
-	SHA256_Final(ihash, &ctx->ictx);
+	scrypty_SHA256_Final(ihash, &ctx->ictx);
 
 	/* Feed the inner hash to the outer SHA256 operation. */
-	SHA256_Update(&ctx->octx, ihash, 32);
+	scrypty_SHA256_Update(&ctx->octx, ihash, 32);
 
 	/* Finish the outer SHA256 operation. */
-	SHA256_Final(digest, &ctx->octx);
+	scrypty_SHA256_Final(digest, &ctx->octx);
 
 	/* Clean the stack. */
 	memset(ihash, 0, 32);
 }
 
 /**
- * PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, c, buf, dkLen):
+ * scrypty_PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, c, buf, dkLen):
  * Compute PBKDF2(passwd, salt, c, dkLen) using HMAC-SHA256 as the PRF, and
  * write the output to buf.  The value dkLen must be at most 32 * (2^32 - 1).
  */
 void
-PBKDF2_SHA256(const uint8_t * passwd, size_t passwdlen, const uint8_t * salt,
+scrypty_PBKDF2_SHA256(const uint8_t * passwd, size_t passwdlen, const uint8_t * salt,
     size_t saltlen, uint64_t c, uint8_t * buf, size_t dkLen)
 {
-	HMAC_SHA256_CTX PShctx, hctx;
+	scrypty_HMAC_SHA256_CTX PShctx, hctx;
 	size_t i;
 	uint8_t ivec[4];
 	uint8_t U[32];
@@ -373,8 +373,8 @@ PBKDF2_SHA256(const uint8_t * passwd, size_t passwdlen, const uint8_t * salt,
 	size_t clen;
 
 	/* Compute HMAC state after processing P and S. */
-	HMAC_SHA256_Init(&PShctx, passwd, passwdlen);
-	HMAC_SHA256_Update(&PShctx, salt, saltlen);
+	scrypty_HMAC_SHA256_Init(&PShctx, passwd, passwdlen);
+	scrypty_HMAC_SHA256_Update(&PShctx, salt, saltlen);
 
 	/* Iterate through the blocks. */
 	for (i = 0; i * 32 < dkLen; i++) {
@@ -382,18 +382,18 @@ PBKDF2_SHA256(const uint8_t * passwd, size_t passwdlen, const uint8_t * salt,
 		be32enc(ivec, (uint32_t)(i + 1));
 
 		/* Compute U_1 = PRF(P, S || INT(i)). */
-		memcpy(&hctx, &PShctx, sizeof(HMAC_SHA256_CTX));
-		HMAC_SHA256_Update(&hctx, ivec, 4);
-		HMAC_SHA256_Final(U, &hctx);
+		memcpy(&hctx, &PShctx, sizeof(scrypty_HMAC_SHA256_CTX));
+		scrypty_HMAC_SHA256_Update(&hctx, ivec, 4);
+		scrypty_HMAC_SHA256_Final(U, &hctx);
 
 		/* T_i = U_1 ... */
 		memcpy(T, U, 32);
 
 		for (j = 2; j <= c; j++) {
 			/* Compute U_j. */
-			HMAC_SHA256_Init(&hctx, passwd, passwdlen);
-			HMAC_SHA256_Update(&hctx, U, 32);
-			HMAC_SHA256_Final(U, &hctx);
+			scrypty_HMAC_SHA256_Init(&hctx, passwd, passwdlen);
+			scrypty_HMAC_SHA256_Update(&hctx, U, 32);
+			scrypty_HMAC_SHA256_Final(U, &hctx);
 
 			/* ... xor U_j ... */
 			for (k = 0; k < 32; k++)
@@ -408,5 +408,5 @@ PBKDF2_SHA256(const uint8_t * passwd, size_t passwdlen, const uint8_t * salt,
 	}
 
 	/* Clean PShctx, since we never called _Final on it. */
-	memset(&PShctx, 0, sizeof(HMAC_SHA256_CTX));
+	memset(&PShctx, 0, sizeof(scrypty_HMAC_SHA256_CTX));
 }

data/ext/sha256.h

@@ -33,30 +33,30 @@
 
 #include <stdint.h>
 
-typedef struct SHA256Context {
+typedef struct scrypty_SHA256Context {
 	uint32_t state[8];
 	uint32_t count[2];
 	unsigned char buf[64];
-} SHA256_CTX;
+} scrypty_SHA256_CTX;
 
-typedef struct HMAC_SHA256Context {
-	SHA256_CTX ictx;
-	SHA256_CTX octx;
-} HMAC_SHA256_CTX;
+typedef struct scrypty_HMAC_SHA256Context {
+	scrypty_SHA256_CTX ictx;
+	scrypty_SHA256_CTX octx;
+} scrypty_HMAC_SHA256_CTX;
 
-void	SHA256_Init(SHA256_CTX *);
-void	SHA256_Update(SHA256_CTX *, const void *, size_t);
-void	SHA256_Final(unsigned char [32], SHA256_CTX *);
-void	HMAC_SHA256_Init(HMAC_SHA256_CTX *, const void *, size_t);
-void	HMAC_SHA256_Update(HMAC_SHA256_CTX *, const void *, size_t);
-void	HMAC_SHA256_Final(unsigned char [32], HMAC_SHA256_CTX *);
+void	scrypty_SHA256_Init(scrypty_SHA256_CTX *);
+void	scrypty_SHA256_Update(scrypty_SHA256_CTX *, const void *, size_t);
+void	scrypty_SHA256_Final(unsigned char [32], scrypty_SHA256_CTX *);
+void	scrypty_HMAC_SHA256_Init(scrypty_HMAC_SHA256_CTX *, const void *, size_t);
+void	scrypty_HMAC_SHA256_Update(scrypty_HMAC_SHA256_CTX *, const void *, size_t);
+void	scrypty_HMAC_SHA256_Final(unsigned char [32], scrypty_HMAC_SHA256_CTX *);
 
 /**
- * PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, c, buf, dkLen):
+ * scrypty_PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, c, buf, dkLen):
  * Compute PBKDF2(passwd, salt, c, dkLen) using HMAC-SHA256 as the PRF, and
  * write the output to buf.  The value dkLen must be at most 32 * (2^32 - 1).
  */
-void	PBKDF2_SHA256(const uint8_t *, size_t, const uint8_t *, size_t,
+void	scrypty_PBKDF2_SHA256(const uint8_t *, size_t, const uint8_t *, size_t,
     uint64_t, uint8_t *, size_t);
 
 #endif /* !_SHA256_H_ */

data/lib/scrypty/version.rb

@@ -1,3 +1,3 @@
 module Scrypty
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scrypty
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-05 00:00:00.000000000 Z
+date: 2012-12-10 00:00:00.000000000 Z
 dependencies: []
 description: Uses the scrypt algorithm by Colin Percival to encrypt/decrypt data
 email: