I am trying to compile this code
https://github.com/iceland2k14/KeyHunt-Cuda

but it will only compile without cuda support the error message is

 ./KeyHunt -l
GPU code not compiled, use -DWITHGPU when compiling.

However I can see it happening. A lot of output ending with

g++ -DWITHGPU -m64 -mssse3 -Wno-write-strings -O2 -I. -I/usr/local/cuda/include -o obj/GmpUtil.o -c GmpUtil.cpp
g++ -DWITHGPU -m64 -mssse3 -Wno-write-strings -O2 -I. -I/usr/local/cuda/include -o obj/CmdParse.o -c CmdParse.cpp
Making KeyHunt...

It works in cpu mode.

VanitySearch and kangaroo from JLP both compile with gpu support.

Any ideas please??

Alice wants to send Bob some Bitcoin so he creates an address 1BOB.... which he sends to Alice.
Alice sends the Bitcoin and the transaction proceeds.

My understanding is that 1BOB.... is a more readable version of the X,Y co ordinates of the public key obtained after a 1 way hash function. (ripemd160)
So given that the co ordinates X,Y have been hashed, How does the blockchain work out X,Y (the full public key) in order to create the transaction ?

I am obviously missing something

I mined some of these years ago but cannot get the blockchain to sync.

Is this project dead? 

I would like to compile a list of passwords used for the fake wallets on page 1 of this thread

https://bitcointalk.org/index.php?topic=5242967.0

Why? to have an exclusion list so that every time a new wallet appears it can be checked against the list.
(if one happens to be your real password you might want to change it!)

Here are some I know:-

mypassword
kingsman
Hunnibear9
Abcde12345
31247590635abe
12aVP18cd5XsbcGQy8u6eywQ6UuA6Q319s (more than 1 wallet)
1111 (more than 1 wallet)
1

I will leave you the fun of matching them to the wallet.
If  you don't want to leave them here you can PM me.

There was a post a few days ago which has since disappeared, where someone said 'give me a random public key and I'll tell you the one adjacent to it.

So,  I generated a random private key, and posted the public key (only) on the forum.

I got a reply which I briefly checked (as it was late) and sure enough the returned public key was my private +1

Neither private keys were divulged but of course as I knew what I had generated I could confirm it was correct.

How was it done??

I have been using this parser. Source code at
https://github.com/ragestack/blockchain-parser

which is very good. It runs happily for about 24 hours then I get the following error which I do not understand.

Code:

TX AE3F3F8D299D9A15479901FA776536D42C868E8CEDD1EC2DB27FC5B4CD3F71A2 
TX A9A02B7FC93B9747918BBE0A96BCC2416895B4FD497C3B6C343B317C105134B4 
Traceback (most recent call last):
  File "/media/blockchain-parseroriginal.py", line 294, in <module>
    tmpHex = merkle_root(tx_hashes).hex().upper()
  File "/media/blockchain-parseroriginal.py", line 34, in merkle_root
    return merkle_root([hash_pair(x, y) for x, y in zip(*[iter(lst)]*2)])
  File "/media/blockchain-parseroriginal.py", line 34, in merkle_root
    return merkle_root([hash_pair(x, y) for x, y in zip(*[iter(lst)]*2)])
  File "/media/blockchain-parseroriginal.py", line 34, in merkle_root
    return merkle_root([hash_pair(x, y) for x, y in zip(*[iter(lst)]*2)])
  [Previous line repeated 995 more times]
  File "/media/blockchain-parseroriginal.py", line 30, in merkle_root
    if len(lst) == 1:
RecursionError: maximum recursion depth exceeded while calling a Python object

Perhaps the program has reached the end of the blocks and has not exited gracefully or perhaps something else?
Can anyone point me in the right direction to fix this? Thank you

Hello,

As an experiment, I have downloaded and built this miner.
https://github.com/tmrlvi/kaspa-miner
It starts but when I run it i get an error:

2023-03-31T23:14:51Z INFO  kaspa_miner] Found plugins: []
[2023-03-31T23:14:51Z INFO  kaspa_miner] Plugins found 0 workers
[2023-03-31T23:14:51Z ERROR kaspa_miner] No workers specified
Error: "No workers specified"

How do I specify a worker?? What am I doing wrong??

Thanks

Hello, I am trying to learn and I am confused by this transaction
b7ca4adad64a5c8a57258d3943002ce3f9ffa543d794bfc9eba34f22905ded1c

for this already compromised and empty address from years ago 1PYwTzZZhMdaCh1QtU8LY61taUnFhuUMkX

It has a duplicate R value, 2c64be172f697261c08f9a9ede4f1359cd5a6a75f9c4bc60d359640acd2722b1
with different S values,
2575266b294a19029ac41b8f998ef883d8be2d38994932e493b0d6354034aa30 and
55fe0b499af7f2c376a2f4e3fc960cd7402c05c8b9b821543244bb39ccc623be

The Z values are
12f47c9f1d683e991e4d9d38e8dca9c55df7fc4a346e7b747fe882f7a7a64f4d and
82c2725f6fd394d544bc8532ce3b68116be8466006d04764d4d5b1d65dcb9459

I have tried several different programs online and offline which give a consistent result,
k = 0xa8ebe295be40b9b6363494de5844d8cc2003e45a39e8b398f714c832df1b2855
x = 0x91c405583bb95ba30c9fde2d8ef5a9b79c0cdada4ee97710874bf0a217c3c06c

But this key (x) does not match 1PYw....   

What am I missing??
Thank you

I had been wondering about the process of encrypting a wallet but could not find a simple enough explanation of how it works (I am a newbie!) So I thought I would do some investigating. The result was that I put together a little python script which explains it to me. I thought I would post it here in case it is of use to others. The base code came from
https://stackoverflow.com/questions/61378005/decrypting-aes-256-cbc-cipher-with-a-passcode-built-using-pbkdf2-in-python. The rest of the information I pieced together from various places on the internet. The explanation is in the code. Install the dependencies, run it, look at the results and then read through the heavily commented code to understand the process. If I have made any mistakes, please let me know.

Code:

from base64 import b64encode
import hashlib
import binascii
import pyaes
import os
import random

# Wallet software generates a random 32 byte master key. (How this is done is well documented and is not
# explained here). The master key needs to be encrypted to protect your funds. The one below is made up.
# You can substitute your own key below to try the software but DO NOT publish your own key anywhere.
mkey = binascii.unhexlify("5c5692da0f165d3d32e5c05a56dde9b2d0ebc05f100f8d0616941e9abe7e0fb0")

# Wallet software will ask you for a password to encrypt the master key.
# You can change the password below for your own, but don't lose the b in front.
password = b'password123'

# Also needed is some 'randomness' in the form of a salt and an iteration count. These are generated by the wallet.
# Use the # to comment out the salt and iteration count below if testing your own values.

# create a random 8 byte salt and iteration count.
salt = os.urandom(8)
iterationcount = random.randint(2500, 50000)
# These two values are saved in wallet.dat so that the wallet key can be recreated (not decrypted) if you know the password.

# here you can substitute your own salt and iteration count from a wallet. Remove the # in front
#salt = binascii.unhexlify('a49e804e25740714')
#iterationcount = 91005

# Now if you run the program several times, you will see you get different wallet keys for the same password.
# The random salt and iterations help prevent duplicate wallet keys for the same password.

# Hashing with SHA512. This process generates the wallet key and IV. It is one-way. You cannot go back from
# here to recover the password, which is why it is so important you remember it.
# It is also essential the password is strong because this is where dictionary attacks can take place.
# Remember the salt & iterations are recoverable from the wallet.dat files!
hash512 = hashlib.pbkdf2_hmac('sha512', password, salt, iterationcount)

# The wallet key is the first 32 bytes of the hash.
wallet_key = hash512[0:32]
# The IV (initialization vector) is the next 16 bytes of the hash
iv = hash512[32:48]

# We now have all we need to encrypt the master key
# Encryption with AES-256-CBC
encrypter = pyaes.Encrypter(pyaes.AESModeOfOperationCBC(wallet_key, iv))
ciphertext = encrypter.feed(mkey)
ciphertext += encrypter.feed()
# The cipher text is what you see in the wallet.dat files as Mkey followed by 48 bytes
# There are also Ckey's which hold the private spend keys for each address.
#######################################################################################
# Your master private key is now encrypted!!
#######################################################################################
# Decryption is the reverse process using the same wallet key and IV to process the ciphertext (Mkey)

# Decryption with AES-256-CBC
decrypter = pyaes.Decrypter(pyaes.AESModeOfOperationCBC(wallet_key, iv))
decryptedData = decrypter.feed(ciphertext)
decryptedData += decrypter.feed()
# The master key is now decrypted for all the world to see.
# However, before we can spend any funds we need to decrypt the Ckeys which hold the private keys to the addresses
# As you can see with no Ckey's, wallet recovery services cannot access your funds. It is safe to send Mkey ciphertext
# iteration count and salt but not the wallet itself as this has ALL the keys.
# Decrypting Ckeys will be the subject of another post.

# If you have found this useful please consider a small BTC tip to bc1qg82720gvdyvnc3jycnun348fhs3qam44nsmeqm

# Display results
def printData(text, data):
    print(text + " (hex)   :" + data.hex())
    print(text + " (Base64):" + b64encode(data).decode('utf8') + "\n")


printData("SHA512    ", hash512)
printData("Wallet Key", wallet_key)
printData("16 bytes IV", iv)
printData("Master Key ", mkey)
printData("Ciphertext ", ciphertext)

# Decrypted data
printData("Decrypted  ", decryptedData)