Merge pull request #31 from SOUx4cx4fx56x69/master

sha256

README.md

@@ -93,8 +93,18 @@ Vanity generation adress.
 
 #### Usage
 
-./vain privatekey.dat prefix <signature>
+./vain privatekey.dat prefix <threads> <signature>
-
+
+#### Time to Generate on a 2.70GHz Processor
+| characters| time to generate (approx.) |
+| -------------------- | --------------- |
+|         1 	       | ~0.082s	 |
+|         2	       | ~0.075s	 |
+|         3	       | ~0.100s	 |
+|         4	       | ~0.394s	 |
+|         5	       | ~6.343s	 |
+|         6	       | ~1m-5m	 	 |
+|         7	       | ~30m	 	 |
 
 ### keyinfo
 

vanity.hpp

@@ -9,9 +9,31 @@
 #include <thread>
 #include <unistd.h>
 #include <vector>
-#include <mutex>
 
-static std::mutex thread_mutex;
+// sha256
+#define Ch(x, y, z)	((x & (y ^ z)) ^ z)
+#define Maj(x, y, z)	((x & (y | z)) | (y & z))
+#define SHR(x, n)	(x >> n)
+#define ROTR(x, n)	((x >> n) | (x << (32 - n)))
+#define S0(x)		(ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
+#define S1(x)		(ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
+#define s0(x)		(ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3))
+#define s1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10))
+
+#define RND(a, b, c, d, e, f, g, h, k) \
+	t0 = h + S1(e) + Ch(e, f, g) + k; \
+	t1 = S0(a) + Maj(a, b, c); \
+	d += t0; \
+	h = t0 + t1;
+
+#define RNDr(S, W, i, k) \
+	RND(S[(64 - i) % 8], S[(65 - i) % 8], \
+	S[(66 - i) % 8], S[(67 - i) % 8], \
+	S[(68 - i) % 8], S[(69 - i) % 8], \
+	S[(70 - i) % 8], S[(71 - i) % 8], \
+	W[i] + k)
+
+
 static i2p::data::SigningKeyType type;
 //static i2p::data::PrivateKeys keys;
 static bool found=false;
@@ -26,3 +48,15 @@ static uint8_t * KeyBuf;
 static unsigned long long hashescounter;
 unsigned int count_cpu;
 
+const uint8_t lastBlock[64] =
+	{
+		0x05, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x80, // 7 bytes EdDSA certificate 
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x38  // 3128 bits (391 bytes)	
+	};
+

vanitygen.cpp

@@ -1,6 +1,59 @@
 #include "vanity.hpp"
 #define CPU_ONLY
 
+static void inline CalculateW (const uint8_t block[64], uint32_t W[64])
+{
+/*
+implementation of orignal
+*/
+	for (int i = 0; i < 16; i++)
+		W[i] = be32toh (((uint32_t *)(block))[i]);
+	for (int i = 16; i < 64; i++)
+		W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16];
+}
+ 
+static void inline TransformBlock (uint32_t state[8], const uint32_t W[64])
+{
+/*
+implementation of orignal
+*/
+	uint32_t S[8];
+	memcpy(S, state, 32);
+
+	uint32_t t0, t1;
+	RNDr(S, W, 0, 0x428a2f98); RNDr(S, W, 1, 0x71374491); RNDr(S, W, 2, 0xb5c0fbcf); RNDr(S, W, 3, 0xe9b5dba5);
+	RNDr(S, W, 4, 0x3956c25b); RNDr(S, W, 5, 0x59f111f1); RNDr(S, W, 6, 0x923f82a4); RNDr(S, W, 7, 0xab1c5ed5);
+	RNDr(S, W, 8, 0xd807aa98); RNDr(S, W, 9, 0x12835b01); RNDr(S, W, 10, 0x243185be); RNDr(S, W, 11, 0x550c7dc3);
+	RNDr(S, W, 12, 0x72be5d74); RNDr(S, W, 13, 0x80deb1fe); RNDr(S, W, 14, 0x9bdc06a7); RNDr(S, W, 15, 0xc19bf174);
+	RNDr(S, W, 16, 0xe49b69c1); RNDr(S, W, 17, 0xefbe4786); RNDr(S, W, 18, 0x0fc19dc6); RNDr(S, W, 19, 0x240ca1cc);
+	RNDr(S, W, 20, 0x2de92c6f); RNDr(S, W, 21, 0x4a7484aa); RNDr(S, W, 22, 0x5cb0a9dc); RNDr(S, W, 23, 0x76f988da);
+	RNDr(S, W, 24, 0x983e5152); RNDr(S, W, 25, 0xa831c66d); RNDr(S, W, 26, 0xb00327c8); RNDr(S, W, 27, 0xbf597fc7);
+	RNDr(S, W, 28, 0xc6e00bf3); RNDr(S, W, 29, 0xd5a79147); RNDr(S, W, 30, 0x06ca6351); RNDr(S, W, 31, 0x14292967);
+	RNDr(S, W, 32, 0x27b70a85); RNDr(S, W, 33, 0x2e1b2138); RNDr(S, W, 34, 0x4d2c6dfc); RNDr(S, W, 35, 0x53380d13);
+	RNDr(S, W, 36, 0x650a7354); RNDr(S, W, 37, 0x766a0abb); RNDr(S, W, 38, 0x81c2c92e); RNDr(S, W, 39, 0x92722c85);
+	RNDr(S, W, 40, 0xa2bfe8a1); RNDr(S, W, 41, 0xa81a664b); RNDr(S, W, 42, 0xc24b8b70); RNDr(S, W, 43, 0xc76c51a3);
+	RNDr(S, W, 44, 0xd192e819); RNDr(S, W, 45, 0xd6990624); RNDr(S, W, 46, 0xf40e3585); RNDr(S, W, 47, 0x106aa070);
+	RNDr(S, W, 48, 0x19a4c116); RNDr(S, W, 49, 0x1e376c08); RNDr(S, W, 50, 0x2748774c); RNDr(S, W, 51, 0x34b0bcb5);
+	RNDr(S, W, 52, 0x391c0cb3); RNDr(S, W, 53, 0x4ed8aa4a); RNDr(S, W, 54, 0x5b9cca4f); RNDr(S, W, 55, 0x682e6ff3);
+	RNDr(S, W, 56, 0x748f82ee); RNDr(S, W, 57, 0x78a5636f); RNDr(S, W, 58, 0x84c87814); RNDr(S, W, 59, 0x8cc70208);
+	RNDr(S, W, 60, 0x90befffa); RNDr(S, W, 61, 0xa4506ceb); RNDr(S, W, 62, 0xbef9a3f7); RNDr(S, W, 63, 0xc67178f2);
+	
+	for (int i = 0; i < 8; i++)	state[i] += S[i];		
+}
+
+void inline HashNextBlock (uint32_t state[8], const uint8_t * block)
+{
+/*
+implementation of orignal
+*/
+	uint32_t W[64];
+	CalculateW (block, W);
+	TransformBlock (state, W);
+}
+
+
+
+
 static bool check_prefix(const char * buf){
 unsigned short size_str=0;
 while(*buf)
@@ -21,7 +74,7 @@ return true;
 }
 
 
-static size_t ByteStreamToBase32 (const uint8_t * inBuf, size_t len, char * outBuf, size_t outLen)
+static inline size_t ByteStreamToBase32 (const uint8_t * inBuf, size_t len, char * outBuf, size_t outLen)
 {
 	size_t ret = 0, pos = 1;
 	int bits = 8, tmp = inBuf[0];
@@ -67,44 +120,81 @@ For idea and example ^-^
 Orignal is sensei of crypto ;)
 */
 	std::cout << "Thread " << id_thread << " binded" << std::endl;
-
+/*
-	union{
+	union
+	{
 		uint8_t b[391];
 		uint32_t ll;
 	} local;	
-	
+	union
-	memcpy (local.b, buf, 391);
+	{
-
+		uint8_t b[32];
-	int len = strlen (prefix);
+		uint32_t ll[8];
-
+	} hash; 
-	SHA256_CTX ctx, ctx1;
+*/
-	SHA256_Init(&ctx);
+	uint8_t * b = (uint8_t*)aligned_alloc(4,sizeof(uint8_t)*391);
-	SHA256_Update(&ctx, local.b, MutateByte);
+	uint32_t * hash = (uint32_t*)aligned_alloc(4,sizeof(uint32_t)*8);
-
+
-	uint32_t * nonce = (uint32_t *)(local.b+MutateByte); // in nonce copy of MutateByte of b;
+	memcpy (b, buf, 391);
+
+	auto len = strlen (prefix);
+	// precalculate first 5 blocks (320 bytes)
+	uint32_t state[8] = 
+		{ 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 
+		  0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19 };
+	HashNextBlock (state, b);
+	HashNextBlock (state, b + 64);
+	HashNextBlock (state, b + 128);
+	HashNextBlock (state, b + 192);
+	HashNextBlock (state, b + 256);	
+
+	// pre-calculate last W
+	uint32_t lastW[64];
+	CalculateW (lastBlock, lastW); 
+
+	uint32_t * nonce = (uint32_t *)(b+320);
 	(*nonce) += id_thread*throughput; 
+/*
 
-	uint8_t hash[32];
+*/
 	char addr[53];
+	uint32_t state1[8];
 
 while(throughput-- and !found){
 
-	memcpy (&ctx1, &ctx, sizeof (SHA256_CTX));
-	SHA256_Update(&ctx1, local.b + MutateByte, 71);
-	SHA256_Final(hash, &ctx1);
-	ByteStreamToBase32 (hash, 32, addr, len);
 
+	memcpy (state1, state, 32);
+	// calculate hash of block with nonce	
+	HashNextBlock (state1, b + 320);
+	// apply last block	
+	TransformBlock (state1, lastW);		
+	// get final hash
+	for (int j = 8; j--;)
+		hash[j] = htobe32 (state1[j]);
+
+/*
+
+*/
+	ByteStreamToBase32 ((uint8_t*)hash, 32, addr, len);
+//	std::cout << addr << std::endl;
 	if(	!NotThat(addr,prefix)	){
-		ByteStreamToBase32 (hash, 32, addr, 52);
+		ByteStreamToBase32 ((uint8_t*)hash, 32, addr, 52);
 		std::cout << "Address found " << addr << " in " << id_thread << std::endl;
 		found=true;
 		FoundNonce=*nonce;
+		free(hash);
+		free(b);
 		return true;
 	}
 
 	(*nonce)++;
 	hashescounter++;
-	if (found) break;	
+	if (found){
+	free(hash);
+	free(b);
+	break;	
+	}
+
 	}//while
 }