Latest posts of: Kontakt

I'm making a Vanity address miner that generates compressed addresses, mostly because I'm bored, took an intro C++ course, and think cryptography is nifty. Feel free to call me an idiot, or encourage me. Tips and advice appreciated.

I'm using CryptoPP because VanityGen uses OpenSSL, and I wanted to make mine different. No particular reason other than that.

I'll post source code for interesting bits here, and give an idea of my progress.

Goals:
Create a working CPU miner
Create a working GPU miner
Implement getwork
Implement shares system
Huh

Profit

Progress to make:
Comparison
Modular add/multiply
Getwork
Shares/proof of work

Nifty codes:
Base58 to Hex, returns cryptopp Integer

Code:

Integer base58decode(string input)
{
   int parse;
   Integer key;
   for(int i = 0; i < input.length(); i++)
   {
   parse = 0;
   while(true)
   {
   if(input[i] == b58[parse])
   {
   key = (key + parse)*58;
   break;
   }
   else
   parse++;
   }
   }
   key = key/58;
   return key;
}

Integer and leading zeroes to Base58

Code:

string base58encode(Integer plain, int zeros)
{
   string adr;
   Integer remainder, temp;
   while(plain != 0)
   {
   plain.Divide(remainder, temp, plain, 58);
   plain = temp;
   adr = b58[remainder.ConvertToLong()] + adr;
   }
   while(zeros)
   {
   adr = "1" + adr;
   zeros--;
   }
   return adr;
}

The whole program, messy as it is.

Code:

#include <iostream>
#include <iomanip>

// CryptoPP includes
#include <cryptopp\cryptlib.h>
#include <cryptopp\filters.h>
#include <cryptopp\eccrypto.h>
#include <cryptopp\hex.h>
#include <cryptopp\osrng.h>
#include <cryptopp\sha.h>
#include <cryptopp\ripemd.h>
#include <cryptopp\integer.h>
#include <cryptopp\oids.h>

using namespace std;
using namespace CryptoPP;

string b58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
byte odd[] = {0x03};
byte eve[] = {0x02};
AutoSeededRandomPool prng;
ECDSA<ECP, SHA256>::PrivateKey Priv;
ECDSA<ECP, SHA256>::PublicKey Pub;

bool loop(byte* goal);
string digest2hex(byte* digest, int len);
byte* str2hexarr(char* in, int len);
byte* step(string raw);
string base58encode(Integer plain, int zeros);
Integer base58decode(string input);
string process(string raw);

int
main()
{
Integer loops;
byte goal[] = {0x01};
while(loop(goal) == false && loops < 800)
{
loops++;
cout << "\r" << std::dec << loops;
}

}

bool
loop(byte* goal)
{
string temp;
byte x[32];
Priv.Initialize( prng, CryptoPP::ASN1::secp256k1());
Priv.MakePublicKey(Pub);
SHA256 crunchy;
if(Pub.GetPublicElement().y.IsEven() == 0)
crunchy.Update(odd, 1);
else
crunchy.Update(eve, 1);
Pub.GetPublicElement().x.Encode(x, 32);
crunchy.Update(x,32);
byte digestA[32];
crunchy.Final(digestA);
byte digestB[20];
RIPEMD160().CalculateDigest(digestB, digestA, 32);
if(digestB[0] == goal[0])
{
cout << endl << std::hex << Priv.GetPrivateExponent();
return true;
}
else
return false;
}

string
digest2hex(byte* digest, int len)
{
string output;
HexEncoder encoder;
StringSink *SS = new StringSink(output);
encoder.Attach(SS);
encoder.Put(digest,len);
encoder.MessageEnd();
return output;
}

byte*
str2hexarr(char* in, int len)
{
for(int i = 0; in[i]; i++)
in[i] = toupper(in[i]);
byte part2[len/2];
unsigned int i, t, hn, ln;
for (t = 0,i = 0; i < len; i+=2,++t)
{
hn = in[i] > '9' ? in[i] - 'A' + 10 : in[i] - '0';
ln = in[i+1] > '9' ? in[i+1] - 'A' + 10 : in[i+1] - '0';
part2[t] = (hn << 4 ) | ln;
}
return part2;
}

byte*
step(string raw)
{
SHA256 hash;
RIPEMD160 more_hash;
byte digest[SHA256::DIGESTSIZE];
byte digest2[RIPEMD160::DIGESTSIZE];
hash.CalculateDigest(digest,(const byte *)raw.c_str(),raw.size());
more_hash.CalculateDigest(digest2, digest, SHA256::DIGESTSIZE);
Integer d = Integer(digest2, RIPEMD160::DIGESTSIZE+4);
cout << endl << std::hex << d;
cout << endl << base58encode(d, 0);
return digest2;
}

string
base58encode(Integer plain, int zeros)
{
string adr;
Integer remainder, temp;
while(plain != 0)
{
plain.Divide(remainder, temp, plain, 58);
plain = temp;
adr = b58[remainder.ConvertToLong()] + adr;
}
while(zeros)
{
adr = "1" + adr;
zeros--;
}
return adr;
}

Integer
base58decode(string input)
{
int parse;
Integer key;
for(int i = 0; i < input.length(); i++)
{
parse = 0;
while(true)
{
if(input[i] == b58[parse])
{
key = (key + parse)*58;
break;
}
else
parse++;
}
}
key = key/58;
return key;
}

string
process(string raw)
{
SHA256 hash;
RIPEMD160 more_hash;
byte digest[SHA256::DIGESTSIZE];
byte digest2[RIPEMD160::DIGESTSIZE];
byte digest2_mod[RIPEMD160::DIGESTSIZE+5];
hash.CalculateDigest(digest,(const byte *)raw.c_str(),raw.size());
more_hash.CalculateDigest(digest2, digest, SHA256::DIGESTSIZE);
digest2_mod[0]=0x00;
for(int i = 0; i<= RIPEMD160::DIGESTSIZE; i++)
digest2_mod[i+1] = digest2[i];
hash.CalculateDigest(digest,digest2_mod,RIPEMD160::DIGESTSIZE+1);
hash.CalculateDigest(digest,digest,SHA256::DIGESTSIZE);
for(int i = 0; i< 4; i++)
digest2_mod[i+RIPEMD160::DIGESTSIZE+1] = digest[i];
Integer out = Integer(digest2_mod, RIPEMD160::DIGESTSIZE+5);
int lead;
for(lead = 0; digest2_mod[lead] == 0; lead++);
string ret = base58encode(out, lead);
return ret;
}