addnode=188.165.3.89
addnode=67.170.27.70
addnode=78.26.198.224
addnode=31.31.13.154
addnode=92.232.89.17

Better to stick to the higher range keys then. 130 and up.

Mining has nothing to do with obtaining the privkey, once its loaded and sent to a new address the next transaction in line will pick it up and you will obtain ownership. The alt coins however would be left intact and easily breakable for first come first serve. I know for a fact If I managed to break a puzzle I would not be worried about the small alt coin addresses, I am sure someone could sweep them all at once but I dont have time for that.

Again, Miners have nothing to do with solving the puzzle. If 2 people were to try to send the coins at the same time for some reason on the same block, 1 transaction would reject depending on that tx in the mempool, and the exact time it was sent. The miner speed would be the same for both of them as the blocks get solved 1 at a time. The network will attemp a target time "usually a minute" for each block to get solved by adjusting difficuilty based on current net hash rate, its not perfect but a sudden ramp up in hash rate will only solve a few blocks before the difficuilty adjusts to correct the solving speed.

Fair launch, layer 1. Yes although it make take some time.

Pepecoin layer 1 doge clone
Very active, fair launch. Available on xeggex but they are working on other exchanges

Pepecoin.ord

I am unsure if I modified his code at all, however it is original or very close.


#!/usr/bin/env python

# Bitcoin Core wallet.dat masterkey/privkey decrypter
#
# Coded by HCP 2021
#
# Donations: BTC - 33o4MoDSFrfKSznHLBzwKigpTQvMiWWsHr
#
# Borrows heavily from joric's PoC code here: https://bitcointalk.org/index.php?topic=34028.msg708668#msg708668
# Bitcoin wallet keys AES encryption / decryption (see http://github.com/joric/pywallet)
# Uses pycrypto or libssl or libeay32.dll or aes.py from http://code.google.com/p/slowaes

import argparse
import base58
import binascii
import ecdsa
import getpass
import hashlib
import struct
import sys

crypter = None

debug = 0

try:
    from Crypto.Cipher import AES
    crypter = 'pycrypto'
except:
    pass

class Crypter_pycrypto( object ):
    def SetKeyFromPassphrase(self, vKeyData, vSalt, nDerivIterations, nDerivationMethod):
        data = vKeyData + vSalt
        for i in range(nDerivIterations):
            data = hashlib.sha512(data).digest()
        self.SetKey(data[0:32])
        self.SetIV(data[32:32+16])
        return len(data)

    def SetKey(self, key):
        self.chKey = key

    def SetIV(self, iv):
        self.chIV = iv[0:16]

    def Encrypt(self, data):
        return AES.new(self.chKey,AES.MODE_CBC,self.chIV).encrypt(data)[0:32]
 
    def Decrypt(self, data):
        return AES.new(self.chKey,AES.MODE_CBC,self.chIV).decrypt(data)[0:32]

try:
    if not crypter:
        import ctypes
        import ctypes.util
        ssl = ctypes.cdll.LoadLibrary (ctypes.util.find_library ('ssl') or 'libeay32')
        crypter = 'ssl'
except:
    pass

class Crypter_ssl(object):
    def __init__(self):
        self.chKey = ctypes.create_string_buffer (32)
        self.chIV = ctypes.create_string_buffer (16)

    def SetKeyFromPassphrase(self, vKeyData, vSalt, nDerivIterations, nDerivationMethod):
        strKeyData = ctypes.create_string_buffer (vKeyData)
        chSalt = ctypes.create_string_buffer (vSalt)
        return ssl.EVP_BytesToKey(ssl.EVP_aes_256_cbc(), ssl.EVP_sha512(), chSalt, strKeyData,
            len(vKeyData), nDerivIterations, ctypes.byref(self.chKey), ctypes.byref(self.chIV))

    def SetKey(self, key):
        self.chKey = ctypes.create_string_buffer(key)

    def SetIV(self, iv):
        self.chIV = ctypes.create_string_buffer(iv)

    def Encrypt(self, data):
        buf = ctypes.create_string_buffer(len(data) + 16)
        written = ctypes.c_int(0)
        final = ctypes.c_int(0)
        ctx = ssl.EVP_CIPHER_CTX_new()
        ssl.EVP_CIPHER_CTX_init(ctx)
        ssl.EVP_EncryptInit_ex(ctx, ssl.EVP_aes_256_cbc(), None, self.chKey, self.chIV)
        ssl.EVP_EncryptUpdate(ctx, buf, ctypes.byref(written), data, len(data))
        output = buf.raw[:written.value]
        ssl.EVP_EncryptFinal_ex(ctx, buf, ctypes.byref(final))
        output += buf.raw[:final.value]
        return output

    def Decrypt(self, data):
        buf = ctypes.create_string_buffer(len(data) + 16)
        written = ctypes.c_int(0)
        final = ctypes.c_int(0)
        ctx = ssl.EVP_CIPHER_CTX_new()
        ssl.EVP_CIPHER_CTX_init(ctx)
        ssl.EVP_DecryptInit_ex(ctx, ssl.EVP_aes_256_cbc(), None, self.chKey, self.chIV)
        ssl.EVP_DecryptUpdate(ctx, buf, ctypes.byref(written), data, len(data))
        output = buf.raw[:written.value]
        ssl.EVP_DecryptFinal_ex(ctx, buf, ctypes.byref(final))
        output += buf.raw[:final.value]
        return output

try:
    if not crypter:
        from aes import *
        crypter = 'pure'
except:
    pass

class Crypter_pure(object):
    def __init__(self):
        self.m = AESModeOfOperation()
        self.cbc = self.m.modeOfOperation["CBC"]
        self.sz = self.m.aes.keySize["SIZE_256"]

    def SetKeyFromPassphrase(self, vKeyData, vSalt, nDerivIterations, nDerivationMethod):
        data = vKeyData + vSalt
        for i in range(nDerivIterations):
            data = hashlib.sha512(data).digest()
        self.SetKey(data[0:32])
        self.SetIV(data[32:32+16])
        return len(data)

    def SetKey(self, key):
        self.chKey = [ord(i) for i in key]

    def SetIV(self, iv):
        self.chIV = [ord(i) for i in iv]

    def Encrypt(self, data):
        mode, size, cypher = self.m.encrypt(data, self.cbc, self.chKey, self.sz, self.chIV)
        return ''.join(map(chr, cypher))
 
    def Decrypt(self, data):
        chData = [ord(i) for i in data]
        return self.m.decrypt(chData, self.sz, self.cbc, self.chKey, self.sz, self.chIV)

import hashlib

def Hash(data):
    return hashlib.sha256(hashlib.sha256(data).digest()).digest()

def main():

    parser = argparse.ArgumentParser(description="Bitcoin Core wallet.dat masterkey/privkey decrypter")
   
    parser.add_argument("--enc_mkey", action="store_true", default=False,
                        help="required if Master Key is Encrypted")
    parser.add_argument("mkey", action="store",
                        help="Master Key (can be encrypted or decrypted)")
    parser.add_argument("privkey", action="store",
                        help="Encrypted Private Key")
    parser.add_argument("pub", action="store",
                        help="Public Key of privkey (compressed or uncompressed)")

   
    results = parser.parse_args()
   
    if (results.enc_mkey):
        encrypted_master_key = binascii.unhexlify(results.mkey)
        encrypted_mkey, salt, method, iterations = struct.unpack_from("< 49p 9p I I", encrypted_master_key)
       
        if (debug):
            print("--------------------------------------------------------------")
            print "Successfully parsed encrypted master key\n"
            print "enc mkey: ", binascii.hexlify(encrypted_mkey)
            print "salt    : ", binascii.hexlify(salt)
            print "method  : ", method
            print "#iters  : ", iterations
            print("--------------------------------------------------------------")
       
        wallet_pass_phrase = getpass.getpass("\nEnter wallet passphrase: ")
    else:
        decrypted_master_key = binascii.unhexlify(results.mkey)
   
    enc_priv_key = binascii.unhexlify(results.privkey)
    pub_key = binascii.unhexlify(results.pub)
   
    global crypter

    if crypter == 'pycrypto':
        crypter = Crypter_pycrypto()
    elif crypter == 'ssl':
        crypter = Crypter_ssl()
        print "using ssl"
    elif crypter == 'pure':
        crypter = Crypter_pure()
        print "using slowaes"
    else:
        print("Need pycrypto of libssl or libeay32.dll or http://code.google.com/p/slowaes")
        exit(1)

    if (results.enc_mkey):
        crypter.SetKeyFromPassphrase(wallet_pass_phrase, salt, iterations, method)
        masterkey = crypter.Decrypt(encrypted_mkey)
        if (debug):
            print "Decrypted Master Key as:"
            print "dec mkey   : ", binascii.hexlify(masterkey)
            print("--------------------------------------------------------------")
    else:
        masterkey = binascii.unhexlify(results.mkey)
       
    crypter.SetKey(masterkey)
    crypter.SetIV(Hash(pub_key))
   
    d = crypter.Decrypt(enc_priv_key)
    e = crypter.Encrypt(d)

    if (debug):
        print 'dec privkey: ', binascii.hexlify(d)
        print("--------------------------------------------------------------")
   
    # Private key to public key (ecdsa transformation)
    private_key = ecdsa.SigningKey.from_string(d, curve = ecdsa.SECP256k1)
    verifying_key = private_key.get_verifying_key()
    uncomp_public_key = getPubKey(verifying_key.pubkey, False)
    if (debug):
        print 'calc pubkey: ', binascii.hexlify(uncomp_public_key)
        print 'orig pubkey: ', binascii.hexlify(pub_key)
       
    # hash sha 256 of pubkey
    sha256_1 = hashlib.sha256(uncomp_public_key)

    # hash ripemd of sha of pubkey
    ripemd160 = hashlib.new("ripemd160")
    ripemd160.update(sha256_1.digest())

    # checksum
    hashed_public_key = binascii.unhexlify("00") + ripemd160.digest()
    checksum_full = hashlib.sha256(hashlib.sha256(hashed_public_key).digest()).digest()
    checksum = checksum_full[:4]
    uncomp_bin_addr = hashed_public_key + checksum

    # encode address to base58 and print
    uncomp_result_address = base58.b58encode(uncomp_bin_addr)
    if (debug):
        print "\nuncomp addr: ", uncomp_result_address
   
    network_byte_key = binascii.unhexlify("80") + d
    priv_checksum_full = hashlib.sha256(hashlib.sha256(network_byte_key).digest()).digest()
    priv_checksum = priv_checksum_full[:4]
    uncomp_full_priv = network_byte_key + priv_checksum
   
    uncomp_wif = base58.b58encode(uncomp_full_priv)
    if (debug):
        print "uncomp WIF : ", uncomp_wif       
        print("--------------------------------------------------------------")
       
    # now do compressed
    comppub_key = getPubKey(verifying_key.pubkey, True)
    if (debug):
        print 'comp pubkey: ', binascii.hexlify(comppub_key)
        print 'orig pubkey: ', binascii.hexlify(pub_key)
       
    # hash sha 256 of pubkey
    sha256_1 = hashlib.sha256(comppub_key)

    # hash ripemd of sha of pubkey
    ripemd160 = hashlib.new("ripemd160")
    ripemd160.update(sha256_1.digest())

    # checksum
    hashed_public_key = binascii.unhexlify("00") + ripemd160.digest()
    checksum_full = hashlib.sha256(hashlib.sha256(hashed_public_key).digest()).digest()
    checksum = checksum_full[:4]
    comp_bin_addr = hashed_public_key + checksum

    # encode address to base58 and print
    comp_result_address = base58.b58encode(comp_bin_addr)
    if (debug):
        print "\ncomp addr  : ", comp_result_address

    network_byte_key = binascii.unhexlify("80") + d + binascii.unhexlify("01")
    priv_checksum_full = hashlib.sha256(hashlib.sha256(network_byte_key).digest()).digest()
    priv_checksum = priv_checksum_full[:4]
    comp_full_priv = network_byte_key + priv_checksum
   
    comp_wif = base58.b58encode(comp_full_priv)
    if (debug):
        print "comp WIF   : ", comp_wif
        print("--------------------------------------------------------------")
       
    if (pub_key != comppub_key) and (pub_key != uncomp_public_key):
        print "\n\nWARNING!!!"
        print "WARNING!!! - computed public keys DO NOT match, passphrase is probably incorrect or hex data is corrupt"
        print "WARNING!!!"
        exit()
    else:
        print "\nKeys successfully decrypted:\n"
        print "decrypted mkey: ", binascii.hexlify(masterkey)
        print("--------------------------------------------------------------")
        print "uncomp addr: ", uncomp_result_address
        print "uncomp WIF : ", uncomp_wif       
        print("--------------------------------------------------------------")
        print "comp addr  : ", comp_result_address
        print "comp WIF   : ", comp_wif
        print("--------------------------------------------------------------")
       

# pywallet openssl private key implementation

def getPubKey(pubkey, compressed=False):
    # public keys are 65 bytes long (520 bits)
    # 0x04 + 32-byte X-coordinate + 32-byte Y-coordinate
    # 0x00 = point at infinity, 0x02 and 0x03 = compressed, 0x04 = uncompressed
    # compressed keys: <sign> <x> where <sign> is 0x02 if y is even and 0x03 if y is odd
    if compressed:
        if pubkey.point.y() & 1:
            key = '03' + '%064x' % pubkey.point.x()
        else:
            key = '02' + '%064x' % pubkey.point.x()
    else:
        key = '04' + \
              '%064x' % pubkey.point.x() + \
              '%064x' % pubkey.point.y()

    return key.decode('hex')

if __name__ == '__main__':
    main()

I think it was a attempt, work in progress. Does not function correctly. That got me started on attempting to display the current key it was working on as it was running. As well as attempting to modifiy it to start with the fisrt 20 or so known keys for tests. I know of no current Pubkey search program for the puzzles with GPU. The upside of GPU searching is the speed for video cards seems to be x2 the speed with more then 20 hash160 addresses. More fun right now then anything, always trying to learn.

I was trying to figure out a way if PubHunt even works. It is not easy to test on lower complexity keys. Would also be nice to see current key being worked on. So far I have.

https://github.com/Chail35/PubHuntRange

PubHunt.cpp
Line 330

         printf("\r[%s] [GPU: %.2f MK/s] [T: %s (%d bit)] [F: %d] %02hhx %016llx %llu  ",

%016llx should be the starting key. However it looks like this. and only upldates every few trillion keys.

00007fffb46dd420

bx sha256 1234 - hash 1234
3a103a4e5729ad68c02a678ae39accfbc0ae208096437401b7ceab63cca0622f - Produced EC key from hash
bx ec-to-public 3a103a4e5729ad68c02a678ae39accfbc0ae208096437401b7ceab63cca0622f
03b57de06f5c674af0d789530249bb658b0e317d4d179e1b1b1b0aa2ba668bb5f5 - Public key
bx ec-to-public 3a103a4e5729ad68c02a678ae39accfbc0ae208096437401b7ceab63cca0622a - Only last digit of public key has been changed
02e70d3902ef877ba400f15ec109e1933956da79b14d6d33054f50cad9c30e5d5d - Public key

Changing f to a on the EC key resulted in two very different pub keys.
03b57de06f5c674af0d789530249bb658b0e317d4d179e1b1b1b0aa2ba668bb5f5
02e70d3902ef877ba400f15ec109e1933956da79b14d6d33054f50cad9c30e5d5d

So your saying theres a chance?

wheew you had me going there!

Still a chance, and this is what this puzzle is about.

Are you suggesting I stop searching?

Btw I will also be donating to Alberto if I find any.

Just uped my ram to 512 gig

51 Exa keys/s

My rig will hold up to 2 terrabtes of ram. Just $$$

I figured it out. But not sure what was going on. I reinstalled ubuntu from usb, stared fresh. Bsgs is now holding 17 exa keys/s stable. All 80 cpu threads loaded around 50-60 percent. Appears my ram can now not keep up. But the speed drop out is gone.

2 cpus at 40 threads, 80 total. CPU info shows 80 possible. Ubuntu shows 80 threads. But you may be correct. Strange as bios reports 40 however its not clear if its reporting for 1 cpu or 2.

Again thank you for all the hard work!

Ubuntu 23.04

I have tried 78, 50, 55 all the same results. Anything over 40 decreases the speed by half with twice the threads. Maybe a Kernel issue?

BSGS Dual CPU support? Running 2x intel gold 6148 40 threads each 256gig ram.

At 40 threads I get 15 Exa keys/s

At 80 threads I get 6-12 Exa keys/s

All threads are fully loaded when 80 is requested. Bottle neck somewhere?

I am still fine with 40, but 80 would be nice.

Thank you for all the great work Alberto!

Assuming

The creator made a wallet with random keys

The creator then added zeros to the front of all those keys. Increasing in complexity each key after the previous key. Making them solvable.

I agree there's a pattern. But even distance from keys seems to shift at times.

What I know.  I ran btc client 0.2 really early on. I downloaded the old 0.2 client and remember it. Noted how it only generates 1 address.

Sometime in 2013 I was messing with the wallet and clearly did something I shouldn't have. Like loading that wallet into the ltc client.

If I was looking for 1 key it would be a single uncompressed key and address.

The ltc client obviously shows a different timestamp for a key.

The bdict data may contain something. The data does not match most of the data if that same wallet is dumped with dbdump in human readable format

The bdict data is similar to the human readable format. I am trying to convert that back to strait hex. The / in the data is confusing to me.

Thank you all again

Gave it a shot, Btcrecover does not support dumping legacy core wallets. At least that is what the script told me once I had it up.

All EC keys have been converted and checked uncompressed. No value. Unless the data is in the wallet and not dumped with the scripts.

I am willing to try whatever scripts you have.

Thank you!