Topic: [Release][Source] BitcoinLottery (Bitcoin Brute Force Cracking Tool in Java) - page 2. (Read 598 times)

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.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 {
     while(true) {
    //System.out.println("Iteration no:" + Counter);
    Scanner AddressStream = new Scanner(BitcoinAddressen);
   
    //Generate new privatekey and convert it to hex
    privateKeyNumber = new BigInteger(256, new Random()); //random generation
   
    //Generate PublicKey to calculate Address from:
    ECPoint uncompressed = EC_PARAMS.getG().multiply(privateKeyNumber);
    publicKey = uncompressed.getEncoded(false);
   
   
       
    //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);
         }
    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);
       genPrivateKey = "80"+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));

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);
         }
     }
}