Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 234. (Read 244277 times)

Example of a strange public key:

Just like there is invalid private keys, specifically those after the key fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140 .. there are also invalid public keys. The reason is  there are pub keys that lie outside the curve. But i gotta agree that the mentioned pubs above are interesting, especially knowing that one of their addresses is a used one. The only thing I'm not so fond of is the idea of.trying to figure out a mathematical formula to solve the puzzle. Sometimes it's possible to find a pattern in chaos, but most times you can't.

It's actually interesting to see public keys that follow this pattern. The keys produce the following addresses when they are uncompressed:


at compressed format they produce the following addresses (and they had an out transaction meaning they have a valid private key)

That's bullshit mate. These are freaking completely normal VALID public keys and have of course private keys that are connected to the them. There is nothing strange with them or what so ever....

Just because a public key has many zeros does not make it "weird" or "strange".


Here's a VALID private key with many zeros. Is it weird?

./calculatefrompublickey 0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c633f3979bf72ae8202983dc989aec7f2ff2ed91bdd69ce02fc0700ca100e59ddf3
address 16qakrWzEAPvDsY1yMdCrkgAWZ6DxpTK4z

./calculatefrompublickey 0400000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63c0c686408d517dfd67c2367651380d00d126e4229631fd03f8ff35eef1a61e3c
address 14szHdohyNkdE3XdiwUw1wNmuBUamPBXiS

./calculatefrompublickey 0200000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63
address 13see6qjfupx1YWgRefwEkccZeM8QGTAiJ
./calculatefrompublickey 0300000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63
address 1LVAsnUyEtJgZ9HzLfbtiJZuZMzHLX1n6k

Edit:
Example of a strange public key:



Find their difference, also after that check 69 and 96 as hex, convert them to decimal and compare their values and difference in values, as I have said before this is an ocean, and somehow the designers of EC and the math involved either used magic to come up with these equations, or I am still unable to fathom  the infrastructure underneath them all, yet.  Do not rely on existing tools, if you can come up with new solutions, share them if they can not be used to endanger coins other than puzzle coins. Otherwise you should not reveal anything if it can be exploited to steal coins from people.

000000000000000000000000000000000ffff000000000001111111111100000

from os import system
system("title "+__file__)
import random
import time
#from bit import Key
#from combi import *

import gmpy2
import secp256k1 as ice


list2 = ["13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so"]

F1="01"

aa1=F1[0]*70
aa2=F1[1]*70

def find_permutation(lst,K,numberbit1,numberbit0):

    l = lst

    N = numberbit0
    M = numberbit1

    if N == len(l):
        return F1[1] * N
   
    if M == len(l):
        return F1[1] * M

    result = ''   

    for i in range (0, len(lst)-1):
        K0 = gmpy2.comb(len(l)-1, M)

        if (K < K0):
            result += F1[0]
            l.remove (F1[0])
        else:
            result += F1[1]
            l.remove (F1[1])
            M -=1
            K = K - K0

    result += l[0]

    return result

#count = 0
#5444517870735015415413993718908291383296  2^66×2^66
#93820969697840041204785894580506297666600 140!/70!/70!

while True:
   
    random.seed()
    sssakkki = random.randrange(1,73786976294838206464,1)
    saki = 73786976294838206464 * sssakkki
   
    print("")
    print("")
    print("")
    print(sssakkki,saki,"step",5444517870735015415413993718908291383296//saki)
    #time.sleep(random.randrange(1,10,1))

   
    X2=0 #X=10
    while X2 <= 5444517870735015415413993718908291383296:

        X=X2 #X=10
        while X <= X2: #+1000
                   
            a3 = list(aa1+aa2)
            K = X #perm_int
            numberbit1 = len(aa1)
            numberbit0 = len(aa2)

            aa = find_permutation(a3,K,numberbit1,numberbit0)
            random.seed(aa)

            b = random.randrange(36893488147419103232,73786976294838206464,1)

           
            if b >= 36893488147419103232:
                   
                    #key = Key.from_int(b)
                addr = ice.privatekey_to_address(0, True, b) #key.address
                           
                if addr in list2:
                               
                    print ("found!!!",b,addr)
                    s1 = str(b)
                    s2 = addr
                    f=open("a.txt","a")
                    f.write(s1)
                    f.write(s2)       
                    f.close()
                    pass
                else:
                    #pass
                    print(b,addr) #print(X,r1,b,addr)

               
            X=X+1


        X2=X2+saki
       
        #print("")
        #print(X2)
        #print("")

 

Sorry - but still not possible. even if you combine 1,000 GPUs for puzzle 125 using Kangaroo, you still would need to solve approx 63 bits, which equals to many many years of searching.

Won't work, rmd160 has 40 characters and by searching for their prefix, should we stop hashing half way? Meaning converting sha256 hash of public key into rmd160 but only looking for a specific prefix, either we generate the whole hash and compare with our target or we can't generate just a prefix to compare because it would break the function and we wouldn't know the result.

About brute force tools, bitcrack, vanity etc they all convert rmd160 to address, otherwise why would they accept an address as an input to check against?

// Convert each address from base58 encoded form to a 160-bit integer
	for (unsigned int i = 0; i < targets.size(); i++) {

		if (!Address::verifyAddress(targets[i])) {
			throw KeySearchException("Invalid address '" + targets[i] + "'");
		}

		KeySearchTarget t;

		Base58::toHash160(targets[i], t.value);

		_targets.insert(t);
	}

	_device->setTargets(_targets);
}

Hello,
is there any pool where we can combine all our gpus to bruteforce a puzzle?

Puzzle 66 is really low a LOT with its prize. Satoshi could've increased the price by 10x again so it'll be worth the time and electricity we are investing on it.

I would love to give a suggestion to Satoshi again.

I'd take all unsolved puzzle coins from 101 to 160 and add them to the unsolved parts that are under 100 bits.

I think the maximum is 100 bits we can crack without a public key, so it'll be worth the mention.

Thanks Satoshi,

Who agree? guys merit me so Satoshi can see and take actions

why was the last post of "Professor of wilds" here about puzzle #66 deleted? To the poster: please write again your proposal about the key search and the list you posted

i cant dm because im a newbie to this group you would have to pm me.

Hi, yes there is in development a pool for #125 puzzle. If you want to follow me, DM me.

is there a pool or group chat for 125? id love to toss my fire power with yours at this.

I have yet to figure it out. Therefore, I had to create my stride function with the help of python lol...python creates next stride; but this is not as fast as if it were built into the program.

program, python stride, program, python stride, etc.

How is it possible to achieve this through Python? Since VanBitCracken always starts counting from 1, so it is impossible to have a jump like stride. Could you provide me with an example, how to accomplish this using Python? Even if there is a difference in speed, the stride function should work.