Bitcoin puzzle transaction ~32 BTC prize to who solves it

[nomachine]

You're right. I should have asked him for the fastest version for hashing. The problem is that I don't even know what to do when I have a weak processor. 

You need a high-end GPU for that version, along with a better processor.

[b0dre]

Can you explain how is this useful? Does it do H160(pubKey)?

This is my fault. It only outputs public keys(what I asked for).  

And this helps with what? I see things related to AVX2 and stuff, wasn't this useful for hashing?

If you only want public keys, for whatever reason, there are much faster options than that.

on CPU?

[kTimesG]

Can you explain how is this useful? Does it do H160(pubKey)?

This is my fault. It only outputs public keys(what I asked for).  

And this helps with what? I see things related to AVX2 and stuff, wasn't this useful for hashing?

If you only want public keys, for whatever reason, there are much faster options than that.

on CPU?

Yes. Maybe I'm like a broken record, but carry-free 5x52 is much faster than 4x64 arithmetic, on CPUs. And it's parallelized away by the compiler automatically. At least by clang.

[nomachine]

To compile with Clang, I used the AOCC compiler located at /opt/AMD/aocc-compiler-5.0.0/bin/clang

https://www.amd.com/en/developer/aocc.html

[Akito S. M. Hosana]

To compile with Clang, I used the AOCC compiler located at /opt/AMD/aocc-compiler-5.0.0/bin/clang

https://www.amd.com/en/developer/aocc.html

How? 

[b0dre]

Yes. Maybe I'm like a broken record, but carry-free 5x52 is much faster than 4x64 arithmetic, on CPUs. And it's parallelized away by the compiler automatically. At least by clang.

How to hard is to change from one to other, I mean in order to update this tool by myself?

[nomachine]

How? 

How to hard is to change from one to other, I mean in order to update this tool by myself?

It's not that simple. Plus, if all the components aren't in the system, acceleration may not occur. 

Upgrade GCC:

Code:

sudo apt update
sudo apt install software-properties-common
sudo add-apt-repository ppa:ubuntu-toolchain-r/test
sudo apt update

Code:

sudo apt install gcc-11 g++-11

Code:

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 100
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-11 100

Code:

sudo apt install libomp-dev

Code:

sudo dpkg -i aocc-compiler-5.0.0_1_amd64.deb

Code:

export LD_LIBRARY_PATH=/opt/AMD/aocc-compiler-5.0.0/lib:$LD_LIBRARY_PATH

To make this change permanent, add the above line to your shell configuration file (e.g., ~/.bashrc or ~/.zshrc) and reload it:

Code:

source ~/.bashrc

In my case it was essential to remove all Intel intrinsics (_builtin_ia32) from the code since these intrinsics are specific to Intel processors and incompatible with AMD processors.

You need to update the macro definition in Int.h to use the correct intrinsic function name. Specifically, replace __builtin_ia32_sbb_u64 with __builtin_ia32_subborrow_u64.


Makefile

Code:

# Compiler
CXX = /opt/AMD/aocc-compiler-5.0.0/bin/clang++

# Compiler flags
CXXFLAGS = -m64 -std=c++17 -Ofast -mssse3 -Wall -Wextra \
           -Wno-write-strings -Wno-unused-variable -Wno-deprecated-copy \
           -Wno-unused-parameter -Wno-sign-compare -Wno-strict-aliasing \
           -Wno-unused-but-set-variable \
           -march=native -mtune=native \
           -funroll-loops -ftree-vectorize -fstrict-aliasing -fno-semantic-interposition \
           -fno-trapping-math -flto \
           -fassociative-math -fopenmp -mavx2 -mbmi2 -madx

# Linker flags
LDFLAGS = -L/opt/AMD/aocc-compiler-5.0.0/lib -lomp

# Source files
SRCS = Cyclone.cpp SECP256K1.cpp Int.cpp Timer.cpp IntGroup.cpp IntMod.cpp \
       Point.cpp

# Object files
OBJS = $(SRCS:.cpp=.o)

# Target executable
TARGET = Cyclone

# Default target
all: fix_rdtsc $(TARGET)

# Target to replace __rdtsc with my_rdtsc
fix_rdtsc:
	find . -type f -name '*.cpp' -exec sed -i 's/__rdtsc/my_rdtsc/g' {} +

# Link the object files to create the executable and then delete .o files
$(TARGET): $(OBJS)
	$(CXX) $(CXXFLAGS) $(LDFLAGS) -o $(TARGET) $(OBJS)
	rm -f $(OBJS) && chmod +x $(TARGET)

# Compile each source file into an object file
%.o: %.cpp
	$(CXX) $(CXXFLAGS) -c $< -o $@

# Clean up build files
clean:
	echo "Cleaning..."
	rm -f $(OBJS) $(TARGET)

# Phony targets
.PHONY: all clean fix_rdtsc

Good luck.

[Akito S. M. Hosana]

Holy *hit. I knew they had a secret. My brain hurts after this.  

Will this also work for hashes - keyhunt, etc?

[nomachine]

Will this also work for hashes - keyhunt, etc?

Sure.

[b0dre]

Thanks in Advance

Something like this?

❯ ./Cyclone -a 1FRoHA9xewq7DjrZ1psWJVeTer8gHRqEvR -r 1:ffffffff -p 3

================= WORK IN PROGRESS =================
Target Address: 1FRoHA9xewq7DjrZ1psWJVeTer8gHRqEvR
Prefix length : 3 bytes
CPU Threads   : 16
Mkeys/s       : 37.71
Total Checked : 1885316608
Elapsed Time  : 00:00:50
Range         : 1:ffffffff
Progress      : 43.8959 %
Progress Save : 0
================== PARTIAL MATCH FOUND! ============
Prefix length : 3 bytes
Private Key   : 0000000000000000000000000000000000000000000000000000000018573147
Public Key    : 02E1C602DEB1BCF47A66166D2397112FD44B85457C2BBA47BADEE3AA56A64A356E
WIF           : KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M8ADiUeziYmcmg
Found Hash160 : 9e426069a651b8c2d9a44cf42b23da4b2ef9cb5c
Target Hash160: 9e42601eeaedc244e15f17375adb0e2cd08efdc9
Matched bytes : 9e4260
================== FOUND MATCH! ====================
Private Key   : 00000000000000000000000000000000000000000000000000000000B862A62E
Public Key    : 0209C58240E50E3BA3F833C82655E8725C037A2294E14CF5D73A5DF8D56159DE69
WIF           : KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9MACNivtz8yMYTd
P2PKH Address : 1FRoHA9xewq7DjrZ1psWJVeTer8gHRqEvR
Total Checked : 2262740480
Elapsed Time  : 00:00:52
Speed         : 36.2887 Mkeys/s

Cyclone.cpp:

Code:

            // Construct local buffeer
            for (int i = 0; i < fullBatchSize; i++) {
                pointToCompressedBin(pointBatch[i], localPubKeys[localBatchCount]);
                pointIndices[localBatchCount] = i;
                localBatchCount++;

                // 8 keys are ready - time to use avx2
                if (localBatchCount == HASH_BATCH_SIZE) {
                    computeHash160BatchBinSingle(localBatchCount, localPubKeys, localHashResults);
                    // Results check
                    for (int j = 0; j < HASH_BATCH_SIZE; j++) {
                        __m128i cand16 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(localHashResults[j]));
                        __m128i cmp = _mm_cmpeq_epi8(cand16, target16);

                        // Use the g_prefixLength variable for comparison
                        if (_mm_movemask_epi8(cmp) & ((1 << g_prefixLength) - 1) == ((1 << g_prefixLength) - 1)) {
                            // If the first g_prefixLength bytes match, perform a memcmp to be sure
                            if (!matchFound && std::memcmp(localHashResults[j], targetHash160.data(), g_prefixLength) == 0) {
                                #pragma omp critical
                                {
                                    if (!matchFound) {
                                        auto tEndTime = std::chrono::high_resolution_clock::now();
                                        globalElapsedTime = std::chrono::duration<double>(tEndTime - tStart).count();
                                        mkeysPerSec = (double)(globalComparedCount + localComparedCount) / globalElapsedTime / 1e6;
                                        
                                        // Recovering private key
                                        Int matchingPrivateKey;
                                        matchingPrivateKey.Set(&currentBatchKey);
                                        int idx = pointIndices[j];
                                        if (idx < 256) {
                                            Int offset; offset.SetInt32(idx);
                                            matchingPrivateKey.Add(&offset);
                                        } else {
                                            Int offset; offset.SetInt32(idx - 256);
                                            matchingPrivateKey.Sub(&offset);
                                        }
                                        foundPrivateKeyHex = padHexTo64(intToHex(matchingPrivateKey));
                                        Point matchedPoint = pointBatch[idx];
                                        foundPublicKeyHex = pointToCompressedHex(matchedPoint);

                                        bool bytesMatch = true;
                                        for (int b = 0; b < 20; b++) {
                                            if (localHashResults[j][b] != targetHash160.data()[b]) {
                                                bytesMatch = false;
                                                break;
                                            }
                                        }
                                        if (bytesMatch) {
                                            matchFound = true;
                                            foundWIF = P2PKHDecoder::compute_wif(foundPrivateKeyHex, true);
                                        } else {
                                            matchFound = false;
                                            foundWIF = P2PKHDecoder::compute_wif(foundPrivateKeyHex, true);
                                            // Print the partial match information
                                            std::lock_guard<std::mutex> lock(coutMutex);
                                            std::cout << "\033[11;1H";
                                            std::cout << "\033[K";
                                            std::cout << "================== PARTIAL MATCH FOUND! ============\n";
                                            std::cout << "Prefix length : " << g_prefixLength << " bytes" << "\n";
                                            std::cout << "Private Key   : " << foundPrivateKeyHex << "\n";
                                            std::cout << "Public Key    : " << foundPublicKeyHex << "\n";
                                            std::cout << "WIF           : " << foundWIF << "\n";
                                            std::cout << "Found Hash160 : ";
                                            for (int b = 0; b < 20; b++) {
                                                printf("%02x", localHashResults[j][b]);
                                            }
                                            std::cout << "\n";
                                            std::cout << "Target Hash160: ";
                                            for (int b = 0; b < 20; b++) {
                                                printf("%02x", targetHash160.data()[b]);
                                            }
                                            std::cout << "\n";
                                            std::cout << "Matched bytes : ";
                                            for (int b = 0; b < g_prefixLength; b++) {
                                                printf("%02x", targetHash160.data()[b]);
                                            }
                                            std::cout << std::endl;
                                            std::cout.flush();
                                          }
                                        }

                                    }
                                }
                                #pragma omp cancel parallel
                            }
                            localComparedCount++;
                        } else {
                            localComparedCount++;
                        }
                    }
                    localBatchCount = 0;
                }

[Niekko]

Okay, I’ve been away for a few days and I find pages and pages of nothing, hahaha  . What is this festival of incompetence? I’m glad I didn’t show up then.

Anyone with a basic understanding of cryptography would know you’re wasting time searching for nothing.

We’re talking cryptography, not math; it’s based on uniform distribution and the absence of any patterns, so two 'similar' hashes have absolutely no relation. And it’s not an opinion, it’s a fact.

I suggest exploring other solutions.

[Akito S. M. Hosana]

Okay, I’ve been away for a few days and I find pages and pages of nothing, hahaha 
I suggest exploring other solutions.

Glad you could grace us with your cryptographic wisdom. You're absolutely right. Uniform distribution and lack of patterns are so basic, it’s almost like we’re not even trying. But hey, while you’re here, maybe you could enlighten us with your groundbreaking solution? Or is this just the 'I’m smarter than everyone' tour? 

[Niekko]

Okay, I’ve been away for a few days and I find pages and pages of nothing, hahaha 
I suggest exploring other solutions.

Glad you could grace us with your cryptographic wisdom. You're absolutely right. Uniform distribution and lack of patterns are so basic, it’s almost like we’re not even trying. But hey, while you’re here, maybe you could enlighten us with your groundbreaking solution? Or is this just the 'I’m smarter than everyone' tour? 

absolutely not, I'm not a professional magician

[Akito S. M. Hosana]

Okay, I’ve been away for a few days and I find pages and pages of nothing, hahaha 
I suggest exploring other solutions.

Glad you could grace us with your cryptographic wisdom. You're absolutely right. Uniform distribution and lack of patterns are so basic, it’s almost like we’re not even trying. But hey, while you’re here, maybe you could enlighten us with your groundbreaking solution? Or is this just the 'I’m smarter than everyone' tour? 

absolutely not, I'm not a professional magician

Shame, because pulling solutions out of thin air seems to be your specialty. But don’t worry, we’ll keep searching for patterns in the chaos—after all, someone’s gotta do the heavy lifting while you’re busy not being Houdini. 

[Bram24732]

Okay, I’ve been away for a few days and I find pages and pages of nothing, hahaha 
I suggest exploring other solutions.

Glad you could grace us with your cryptographic wisdom. You're absolutely right. Uniform distribution and lack of patterns are so basic, it’s almost like we’re not even trying. But hey, while you’re here, maybe you could enlighten us with your groundbreaking solution? Or is this just the 'I’m smarter than everyone' tour? 

Here’s one groundbreaking solution : scan all keys, in any order you prefer. Realise that there is no silver bullet or statistical bias. Find the key and profit.
If you want to work on better strategies I suggest you work on 135. At least there is room for improvement there.

[Niekko]

Here’s one groundbreaking solution : scan all keys, in any order you prefer. Realise that there is no silver bullet or statistical bias. Find the key and profit.
If you want to work on better strategies I suggest you work on 135. At least there is room for improvement there.

I totally agree

[nomachine]

the moment when some serious users post thoughtful things, immediately there appears some fresh created account user, posting exactly something against what was being discusses

Yes, the internet's natural law: for every thoughtful post, there must arise a freshly minted account, ready to deliver the hottest of takes with the chilliest of evidence.

It's like clockwork—or maybe performance art. 

[Niekko]

Yes, the internet's natural law: for every thoughtful post, there must arise a freshly minted account, ready to deliver the hottest of takes with the chilliest of evidence.

It's like clockwork—or maybe performance art.  

Keep in mind that you and I have been signup since the same year; I simply prefer reading over writing.

[Akito S. M. Hosana]

Truly, the internet’s silent ninja. 🥷

[JackMazzoni]

Which is more easier puzzle #68 or puzzle #135?