Hi Bitcointalk!
I'm not good at java and crypto algorithms, but I wanted to check how the author's code works and in addition .EXE the file looks suspicious.
Maybe because I'm not so lazy, sorry about that.
I didn't change anything in the original code just added (System.out.println) the output of some information to the console, that's all, becauce I want to see what the values genereting code.
Source:import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.security.Security;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Random;
import java.util.Scanner;
import org.spongycastle.asn1.sec.SECNamedCurves;
import org.spongycastle.asn1.x9.X9ECParameters;
import org.spongycastle.crypto.digests.RIPEMD160Digest;
import org.spongycastle.crypto.params.ECDomainParameters;
import org.spongycastle.math.ec.ECPoint;
public class BitcoinLottery {
private static File BitcoinAddressen = new File("./Addys.txt");
private static String genPrivateKey;
private static BigInteger privateKeyNumber;
private static byte[] publicKey;
private static String genAddy;
private static final ECDomainParameters EC_PARAMS;
private static final BigInteger BASE58_CHUNK_MOD = BigInteger.valueOf(0x5fa8624c7fba400L);
private static final int BASE58_CHUNK_DIGITS = 10;
private static final char[] BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".toCharArray();
private static int Counter = 0;
//Generate Curve for Eliptic Curve Algo:
static {
X9ECParameters params = SECNamedCurves.getByName("secp256k1");
EC_PARAMS = new ECDomainParameters(params.getCurve(), params.getG(), params.getN(), params.getH());
}
public static void main(String[] args) throws FileNotFoundException {
System.out.println("Let`s start!!!");
while(true) {
System.out.println("Iteration no: " + Counter);
Counter = Counter + 1;
Scanner AddressStream = new Scanner(BitcoinAddressen);
//Generate new privatekey and convert it to hex
privateKeyNumber = new BigInteger(256, new Random()); //random generation
System.out.println("Private Key Number: " + privateKeyNumber);
//Generate PublicKey to calculate Address from:
ECPoint uncompressed = EC_PARAMS.getG().multiply(privateKeyNumber);
publicKey = uncompressed.getEncoded(false);
System.out.println("Public Key: " + publicKey);
//Generate Bitcoin-Address:
try {
byte[] hashedPublicKey = sha256ripemd160(publicKey);
byte[] addressBytes = new byte[1 + hashedPublicKey.length + 4];
addressBytes[0] = (byte) (0);
System.arraycopy(hashedPublicKey, 0, addressBytes, 1, hashedPublicKey.length);
MessageDigest digestSha = MessageDigest.getInstance("SHA-256");
digestSha.update(addressBytes, 0, addressBytes.length - 4);
byte[] check = digestSha.digest(digestSha.digest());
System.arraycopy(check, 0, addressBytes, hashedPublicKey.length + 1, 4);
genAddy = encodeBase58(addressBytes);
System.out.println("Gen Bitcoin-Address: " + genAddy);
}
catch (NoSuchAlgorithmException e) {
}
//Check if Address is in our List:
while(AddressStream.hasNextLine()){
if(AddressStream.nextLine().equals(genAddy)){
System.out.println("!!!!SUCCESS!!!!");
//Convert PrivateKey to Wallet Input Format:
genPrivateKey = privateKeyNumber.toString(16);
System.out.println("Convert PK to Wallet: " + genPrivateKey);
genPrivateKey = "80"+genPrivateKey;
System.out.println("Convert PK to Wallet +80 (magic): " + genPrivateKey);
try {
MessageDigest digestSha = MessageDigest.getInstance("SHA-256");
byte[] hash = digestSha.digest(genPrivateKey.getBytes(StandardCharsets.UTF_8));
hash = digestSha.digest(hash);
String checksum = "";
for(int i=1; i < 5; i++) {
checksum = checksum + hash[i];
}
genPrivateKey = genPrivateKey + checksum;
genPrivateKey = encodeBase58(genPrivateKey.getBytes(StandardCharsets.UTF_8));
System.out.println("Final Private Key: " + genPrivateKey);
writeStuffToFile();
} catch (NoSuchAlgorithmException e) {
writeStuffToFile();
}
}
}
AddressStream.close();
}
}
public static void writeStuffToFile() {
try {
String Info = "Private Key: "+ privateKeyNumber + " HEX: " + privateKeyNumber.toString(16) + " WIF: "+ genPrivateKey;
Files.write(Paths.get("PrivateKeys.txt"), Info.getBytes(), StandardOpenOption.APPEND);
}catch (IOException e) {
System.out.println("KEY FOUND BUT THERE WAS A PROBLEM WRITING TO FILE!:");
System.out.println("Private Key: "+ privateKeyNumber + " HEX: " + privateKeyNumber.toString(16));
System.out.println("WIF: "+ genPrivateKey);
System.out.println();
}
}
public static String encodeBase58(byte[] input) {
if (input == null) {
return null;
}
StringBuilder str = new StringBuilder((input.length * 350) / 256 + 1);
BigInteger bn = new BigInteger(1, input);
long rem;
while (true) {
BigInteger[] divideAndRemainder = bn.divideAndRemainder(BASE58_CHUNK_MOD);
bn = divideAndRemainder[0];
rem = divideAndRemainder[1].longValue();
if (bn.compareTo(BigInteger.ZERO) == 0) {
break;
}
for (int i = 0; i < BASE58_CHUNK_DIGITS; i++) {
str.append(BASE58[(int) (rem % 58)]);
rem /= 58;
}
}
while (rem != 0) {
str.append(BASE58[(int) (rem % 58)]);
rem /= 58;
}
str.reverse();
int nLeadingZeros = 0;
while (nLeadingZeros < input.length && input[nLeadingZeros] == 0) {
str.insert(0, BASE58[0]);
nLeadingZeros++;
}
return str.toString();
}
public static byte[] sha256ripemd160(byte[] publicKey) {
try {
MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
byte[] sha256hash = sha256.digest(publicKey);
RIPEMD160Digest ripemd160Digest = new RIPEMD160Digest();
ripemd160Digest.update(sha256hash, 0, sha256hash.length);
byte[] hashedPublicKey = new byte[20];
ripemd160Digest.doFinal(hashedPublicKey, 0);
return hashedPublicKey;
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e);
}
}
}
- compile the Source
-- downloaded and installed
JDK -- downloaded
Spongy Castle and copied jar(s) to the ..\Java\jdk1.8.0\jre\lib\ext\ directory
-- created folder BitcoinLottery (on desktop for example) containing 2 files within "BitcoinLottery.java" and "Manifest.txt", into the "BitcoinLottery.java" file pasted code from top, into the "Manifest.txt" pasted
Main-class: BitcoinLottery
-- started cmd.exe and tried run command:
javac C:\Users\USER_NAME\Desktop\BitcoinLottery\BitcoinLottery.java
-- run next command:
jar cfvm C:\Users\USER_NAME\Desktop\BitcoinLottery\BitcoinLottery.jar C:\Users\USER_NAME\Desktop\BitcoinLottery\Manifest.txt C:\Users\USER_NAME\Desktop\BitcoinLottery\BitcoinLottery.class
-- created empty text file called "PrivateKeys.txt", download list with the addresses for crack and name it "
Addys.txt" and saved both into the BitcoinLottery folder
-- run the last commnad into console: java -jar C:\Users\USER_NAME\Desktop\BitcoinLottery\BitcoinLottery.jar
If everythings all right you could see something like that:
http://i67.tinypic.com/9uqagk.jpgI don't know is that correctly works, i mean methods and algorithms, but generation values happen.
It somehow works.
Note: - The zip file blelow does contain all components for start. Before run "BitcoinLottery.jar" in console, computer need to has
JREDownload:
https://sundryfiles.com/3wgReferences:
http://www.bouncycastle.org/documentation.htmlTutorial on how to make a Java JAR file with the command promptP.S.: I'm not native English speaker and hope you'll not have any problems with reading and running.
Hi,
I was converted the BitcoinLottery.java to BitcoinLottery.py as bellow. It was found some error massage; somebody help to modify for working accurately.
#!/usr/bin/env python
""" generated source for module HelloWorld """
from __future__ import print_function
class BitcoinLottery(object):
""" generated source for class BitcoinLottery """
BitcoinAddressen = File("Addys.txt")
genPrivateKey = None
privateKeyNumber = None
publicKey = []
genAddy = None
EC_PARAMS = None
BASE58_CHUNK_MOD = BigInteger.valueOf(0x5fa8624c7fba400L)
BASE58_CHUNK_DIGITS = 10
BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".toCharArray()
# private static int Counter = 0;
# Generate Curve for Eliptic Curve Algo:
params = SECNamedCurves.getByName("secp256k1")
@classmethod
def main(cls, args):
""" generated source for method main """
while True:
# print("Iteration no:" + Counter);
AddressStream = Scanner(cls.BitcoinAddressen)
# Generate new privatekey and convert it to hex
cls.privateKeyNumber = BigInteger(256, Random())
# random generation
# Generate PublicKey to calculate Address from:
uncompressed = cls.EC_PARAMS.getG().multiply(cls.privateKeyNumber)
cls.publicKey = uncompressed.getEncoded(False)
# Generate Bitcoin-Address:
try:
hashedPublicKey = sha256ripemd160(cls.publicKey)
addressBytes = [None] * 4 + len(hashedPublicKey)
addressBytes[0] = int((0))
System.arraycopy(hashedPublicKey, 0, addressBytes, 1, )
digestSha = MessageDigest.getInstance("SHA-256")
digestSha.update(addressBytes, 0, len(addressBytes))
check = digestSha.digest(digestSha.digest())
System.arraycopy(check, 0, addressBytes, len(hashedPublicKey), 4)
cls.genAddy = encodeBase58(addressBytes)
except NoSuchAlgorithmException as e:
pass
# Check if Address is in our List:
while AddressStream.hasNextLine():
if AddressStream.nextLine() == cls.genAddy:
print("!!!!SUCCESS!!!!")
# Convert PrivateKey to Wallet Input Format:
cls.genPrivateKey = cls.privateKeyNumber.toString(16)
cls.genPrivateKey = "80" + cls.genPrivateKey
try:
digestSha = MessageDigest.getInstance("SHA-256")
hash = digestSha.digest(cls.genPrivateKey.getBytes(StandardCharsets.UTF_8))
hash = digestSha.digest(hash)
checksum = ""
i = 1
while i < 5:
checksum = checksum + hash
i += 1
cls.genPrivateKey = cls.genPrivateKey + checksum
cls.genPrivateKey = encodeBase58(cls.genPrivateKey.getBytes(StandardCharsets.UTF_8))
writeStuffToFile()
except NoSuchAlgorithmException as e:
writeStuffToFile()
AddressStream.close()
@classmethod
def writeStuffToFile(cls):
""" generated source for method writeStuffToFile """
try:
Info = "Private Key: " + cls.privateKeyNumber + " HEX: " + cls.privateKeyNumber.toString(16) + " WIF: " + cls.genPrivateKey
Files.write(Paths.get("PrivateKeys.txt"), Info.getBytes(), StandardOpenOption.APPEND)
except IOError as e:
print("KEY FOUND BUT THERE WAS A PROBLEM WRITING TO FILE!:")
print("Private Key: " + cls.privateKeyNumber + " HEX: " + cls.privateKeyNumber.toString(16))
print("WIF: " + cls.genPrivateKey)
print()
@classmethod
def encodeBase58(cls, input):
""" generated source for method encodeBase58 """
if input == None:
return None
str_ = StringBuilder((len(input)) / 256 + 1)
bn = BigInteger(1, input)
rem = long()
while True:
divideAndRemainder = bn.divideAndRemainder(cls.BASE58_CHUNK_MOD)
bn = divideAndRemainder[0]
rem = divideAndRemainder[1].longValue()
if bn.compareTo(BigInteger.ZERO) == 0:
break
i = 0
while i < cls.BASE58_CHUNK_DIGITS:
str_.append(cls.BASE58[int((rem % 58))])
rem /= 58
i += 1
while rem != 0:
str_.append(cls.BASE58[int((rem % 58))])
rem /= 58
str_.reverse()
nLeadingZeros = 0
while input[nLeadingZeros] == 0 and len(input):
str_.insert(0, cls.BASE58[0])
nLeadingZeros += 1
return str_.__str__()
@classmethod
def sha256ripemd160(cls, publicKey):
""" generated source for method sha256ripemd160 """
try:
sha256 = MessageDigest.getInstance("SHA-256")
sha256hash = sha256.digest(publicKey)
ripemd160Digest = RIPEMD160Digest()
ripemd160Digest.update(sha256hash, 0, )
hashedPublicKey = [None] * 20
ripemd160Digest.doFinal(hashedPublicKey, 0)
return hashedPublicKey
except NoSuchAlgorithmException as e:
raise RuntimeException(e)
