Bitcoin Forum
February 09, 2025, 08:20:20 PM *
News: Community Awards voting is open
 
   Home   Help Search Login Register More  
Pages: « 1 ... 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 [190] 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 ... 369 »
  Print  
Author Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it  (Read 253161 times)
nomachine
Member
**
Online Online

Activity: 507
Merit: 38


View Profile
October 24, 2023, 03:39:58 PM
Last edit: October 24, 2023, 04:17:59 PM by nomachine
 #3781

Let's say we have a 66 bit private key. Such key must be a multiple of smaller number

Why numbers at all?

Let's say we have a Puzzle 65, 64, 63 private keys in bytes:

Code:
Puzzle 65 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xa88\xb15\x05\xb2hg'
Puzzle 64 b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x05\x1f'\xb0\x91\x12\xd4"
Puzzle 63 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00|\xce^\xfd\xac\xcfh\x08'
and so on....

Do you see how many leading zeros there are and how small the end is in bytes?

b'\x00' * 23 (twenty-three zeroes) + 9 bytes

You need to generate the last 9 bytes to get full WIF (from 66 to 71 bits).

 I went one step further now. To represent hash160 directly in the vector as bytes and

 
Code:
  std::vector<std::vector<unsigned char>> target_hash160_list = {
        {0x20, 0xd4, 0x5a, 0x6a, 0x76, 0x25, 0x35, 0x70, 0x0c, 0xe9, 0xe0, 0xb2, 0x16, 0xe3, 0x19, 0x94, 0x33, 0x5d, 0xb8, 0xa5},
        {0x73, 0x94, 0x37, 0xbb, 0x3d, 0xd6, 0xd1, 0x98, 0x3e, 0x66, 0x62, 0x9c, 0x5f, 0x08, 0xc7, 0x0e, 0x52, 0x76, 0x93, 0x71},
        {0xe0, 0xb8, 0xa2, 0xba, 0xee, 0x1b, 0x77, 0xfc, 0x70, 0x34, 0x55, 0xf3, 0x9d, 0x51, 0x47, 0x74, 0x51, 0xfc, 0x8c, 0xfc},
        {0x61, 0xeb, 0x8a, 0x50, 0xc8, 0x6b, 0x05, 0x84, 0xbb, 0x72, 0x7d, 0xd6, 0x5b, 0xed, 0x8d, 0x24, 0x00, 0xd6, 0xd5, 0xaa},
        {0xf6, 0xf5, 0x43, 0x1d, 0x25, 0xbb, 0xf7, 0xb1, 0x2e, 0x8a, 0xdd, 0x9a, 0xf5, 0xe3, 0x47, 0x5c, 0x44, 0xa0, 0xa5, 0xb8},
        {0xbf, 0x74, 0x13, 0xe8, 0xdf, 0x4e, 0x7a, 0x34, 0xce, 0x9d, 0xc1, 0x3e, 0x2f, 0x26, 0x48, 0x78, 0x3e, 0xc5, 0x4a, 0xdb},
        {0xfe, 0x7c, 0x45, 0x12, 0x67, 0x31, 0xf7, 0x38, 0x46, 0x40, 0xb0, 0xb0, 0x04, 0x5f, 0xd4, 0x0b, 0xac, 0x72, 0xe2, 0xa2}
    };

 compare them directly afterwards without any conversion to hex.

This works fast as hell.  It is SO fast that you can barely see the numbers on the display. Flashing characters on the screen....
But it's not fast enough for Puzzles over 60...Need GPU....

bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
AlanJohnson
Member
**
Offline Offline

Activity: 126
Merit: 11


View Profile
October 24, 2023, 04:30:49 PM
 #3782

Let's say we have a 66 bit private key. Such key must be a multiple of smaller number

Why numbers at all?

Let's say we have a Puzzle 65, 64, 63 private keys in bytes:

Code:
Puzzle 65 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xa88\xb15\x05\xb2hg'
Puzzle 64 b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x05\x1f'\xb0\x91\x12\xd4"
Puzzle 63 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00|\xce^\xfd\xac\xcfh\x08'
and so on....

Do you see how many leading zeros there are and how small the end is in bytes?

b'\x00' * 23 (twenty-three zeroes) + 9 bytes

You need to generate the last 9 bytes to get full WIF (from 66 to 71 bits).

 I went one step further now. To represent hash160 directly in the vector as bytes and

 
Code:
  std::vector<std::vector<unsigned char>> target_hash160_list = {
        {0x20, 0xd4, 0x5a, 0x6a, 0x76, 0x25, 0x35, 0x70, 0x0c, 0xe9, 0xe0, 0xb2, 0x16, 0xe3, 0x19, 0x94, 0x33, 0x5d, 0xb8, 0xa5},
        {0x73, 0x94, 0x37, 0xbb, 0x3d, 0xd6, 0xd1, 0x98, 0x3e, 0x66, 0x62, 0x9c, 0x5f, 0x08, 0xc7, 0x0e, 0x52, 0x76, 0x93, 0x71},
        {0xe0, 0xb8, 0xa2, 0xba, 0xee, 0x1b, 0x77, 0xfc, 0x70, 0x34, 0x55, 0xf3, 0x9d, 0x51, 0x47, 0x74, 0x51, 0xfc, 0x8c, 0xfc},
        {0x61, 0xeb, 0x8a, 0x50, 0xc8, 0x6b, 0x05, 0x84, 0xbb, 0x72, 0x7d, 0xd6, 0x5b, 0xed, 0x8d, 0x24, 0x00, 0xd6, 0xd5, 0xaa},
        {0xf6, 0xf5, 0x43, 0x1d, 0x25, 0xbb, 0xf7, 0xb1, 0x2e, 0x8a, 0xdd, 0x9a, 0xf5, 0xe3, 0x47, 0x5c, 0x44, 0xa0, 0xa5, 0xb8},
        {0xbf, 0x74, 0x13, 0xe8, 0xdf, 0x4e, 0x7a, 0x34, 0xce, 0x9d, 0xc1, 0x3e, 0x2f, 0x26, 0x48, 0x78, 0x3e, 0xc5, 0x4a, 0xdb},
        {0xfe, 0x7c, 0x45, 0x12, 0x67, 0x31, 0xf7, 0x38, 0x46, 0x40, 0xb0, 0xb0, 0x04, 0x5f, 0xd4, 0x0b, 0xac, 0x72, 0xe2, 0xa2}
    };

 compare them directly afterwards without any conversion to hex.

This works fast as hell.  It is SO fast that you can barely see the numbers on the display. Flashing characters on the screen....
But it's not fast enough for Puzzles over 60...Need GPU....

I just tried your previous program (for puzzle 15) that is using openssl...

It works ok  but only for puzzle 15...

I edited the code with differend rmd160 hashes  and changed the  value int puzzle = 15  to a different puzzle but then it counts endlessly and never finds a solution.

If i want to try this program for different puzzles what parameters i need to change in the code Huh
nomachine
Member
**
Online Online

Activity: 507
Merit: 38


View Profile
October 24, 2023, 05:01:26 PM
 #3783

If i want to try this program for different puzzles what parameters i need to change in the code Huh

That's the first test script...You have a pm. Let's not bother others with technicalities here.  Wink

bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
WanderingPhilospher
Sr. Member
****
Offline Offline

Activity: 1288
Merit: 253

Shooters Shoot...


View Profile
October 24, 2023, 05:23:48 PM
 #3784

Let's say we have a 66 bit private key. Such key must be a multiple of smaller number


This works fast as hell.  It is SO fast that you can barely see the numbers on the display. Flashing characters on the screen....
But it's not fast enough for Puzzles over 60...Need GPU....

Soooo nomachine, how fast is fast?
How fast can your script on your PC solve a 60 bit key?
You say it’s fast, just not fast enough to solve puzzles over 60, so how fast is fast?

albert0bsd
Hero Member
*****
Offline Offline

Activity: 1119
Merit: 718



View Profile
October 24, 2023, 05:54:14 PM
 #3785

It is SO fast that you can barely see the numbers on the display.

Print ALL the keys on screen is stupid and slow
digaran
Copper Member
Hero Member
*****
Offline Offline

Activity: 1330
Merit: 900

🖤😏


View Profile
October 24, 2023, 06:14:46 PM
 #3786

Let's say we have a 66 bit private key. Such key must be a multiple of smaller number


This works fast as hell.  It is SO fast that you can barely see the numbers on the display. Flashing characters on the screen....
But it's not fast enough for Puzzles over 60...Need GPU....

Soooo nomachine, how fast is fast?
How fast can your script on your PC solve a 60 bit key?
You say it’s fast, just not fast enough to solve puzzles over 60, so how fast is fast?


Hey hey now, it's not cool talking to a colleague like that, soooo is obvious you are making fun of his speed, lets say the script is so fast that it flashes on the screen very fast, and lets leave it at that.
Instead of smearing each other, lets develop an algorithm to show the world *who we are.

Proposal untested :
Subtract 2 from target, set as target2, set original key as target1, subtract n/2 from target1 and perform point torsion on it, subtract 1 from target2 then perform point torsion on it, now either sub or add the results together, check to see if you get any results.
Yesterday I managed to definitively find the value of last char of unknown keys, but I forgot it after going to get some coffee. 😐
I can't manage testing anything right now cause I resent myself for that.

Proposal 2 : normal division not using torsion, halve the target first, set as target2, original point as target1, divide both by starting range = n/2-100, end range = n/2+100, then add/sub results, check for a solution.

P2-2 : we need to find a way to get a composite number, even if it's as large as 255bit, remember do everything over scalar first, if our key is :
Code:
T2 :
000000000000000000000000000000014551231950b75fc4402da1732fc9bebf
Key inverse, -n :
Code:
fffffffffffffffffffffffffffffffd755db9cd5e9140777fa4bd19a06c8282
Now cut off this part from it :
fffffffffffffffffffffffffffffff000000000000000000000000000000000
By subtracting from target -n to have : T1
0000000000000000000000000000000d755db9cd5e9140777fa4bd19a06c8282
Set T1 and T2, do the division sub/add, with n/2-100 etc, check the result.
I know you will see the distance between them being divided, but try to divide one of the results which has many trailing zeros, divide by power of 2, until you reach to fractions, you will see that there is a possibility to do the same with unknown keys. Try these, I know you can find something, after all you taught me how to do point operations on EC. 😉

You know where to find my test scripts on project development. (Ground breaking etc).lol

*= who are we really? We will deal with this identity crisis later.😂

🖤😏
nomachine
Member
**
Online Online

Activity: 507
Merit: 38


View Profile
October 24, 2023, 06:23:56 PM
 #3787

so how fast is fast?

For first test is fast  Grin

Print ALL the keys on screen is stupid and slow

I agree. but I need to have insight into what the application does exactly in the test phases.

soooo is obvious you are making fun of his speed, lets say the script is so fast that it flashes on the screen very fast

Even I joke about my speed.

bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
WanderingPhilospher
Sr. Member
****
Offline Offline

Activity: 1288
Merit: 253

Shooters Shoot...


View Profile
October 24, 2023, 07:25:48 PM
 #3788

so how fast is fast?

For first test is fast  Grin

Print ALL the keys on screen is stupid and slow

I agree. but I need to have insight into what the application does exactly in the test phases.

soooo is obvious you are making fun of his speed, lets say the script is so fast that it flashes on the screen very fast

Even I joke about my speed.

No, it's a serious question. Maybe you are on to something, maybe not.

I wonder how fast it really is? What about 56 bit key or a 52 bit key? Do you not have any benchmarks?
WanderingPhilospher
Sr. Member
****
Offline Offline

Activity: 1288
Merit: 253

Shooters Shoot...


View Profile
October 24, 2023, 07:31:19 PM
 #3789

Quote
Proposal untested :
Subtract 2 from target, set as target2, set original key as target1, subtract n/2 from target1 and perform point torsion on it, subtract 1 from target2 then perform point torsion on it, now either sub or add the results together, check to see if you get any results.
Yesterday I managed to definitively find the value of last char of unknown keys, but I forgot it after going to get some coffee. 😐
I can't manage testing anything right now cause I resent myself for that.

Proposal 2 : normal division not using torsion, halve the target first, set as target2, original point as target1, divide both by starting range = n/2-100, end range = n/2+100, then add/sub results, check for a solution.

P2-2 : we need to find a way to get a composite number, even if it's as large as 255bit, remember do everything over scalar first, if our key is :
I honestly get lost trying to figure out what you are trying to do.

If you had worked with smaller keys, whether hex or numbers, and shown an example of what you did on a smaller scale, it would be easier to follow.

And no, not just an example of the operations, but an example of the operations performed and the results at each operation, until you reached the outcome you were trying for.
patsat
Newbie
*
Offline Offline

Activity: 3
Merit: 0


View Profile
October 24, 2023, 07:41:21 PM
 #3790



Ok.

I'm working on Kangaroo Twimi algorithm on  hash160.
I don't know if it will work, but this is an idea.
It uses two EC_POINT objects (K and W) and iteratively moves them around the elliptic curve by adding random steps until they land on the same point.
When the Kangaroo and Wallaby points collide, the algorithm returns the discrete logarithm k.


Can you find one bit of the K nonce ?
WanderingPhilospher
Sr. Member
****
Offline Offline

Activity: 1288
Merit: 253

Shooters Shoot...


View Profile
October 24, 2023, 07:42:14 PM
 #3791

Quote
^^^^^ This is the best and logical answer on this forum ^^^^^^

Most people here just wasting their time trying to solve things that are unsolvable with current hardware (at least hardware available to them).

Even using blind random cracking - realistically it's not gonna be solved in any sane amount of time.
I can agree, to an extent,This really depends on your hardware and strategy. And a lack of dedicated pool for Kangaroo/awareness is another big reason 130 seems impossible at the moment.

I can run a simple keyhunt/bitcrack/vansearch program and cut the 66 bit puzzle down to having a 1 in 2^30 chance, every few minutes with nothing but simple CPUs (think i5/i7 6th. 7th. 8th generation type).
With the higher puzzles currently at 130, group ops, is almost the same as brute forcing 66, 67, 68, 69 puzzles.

I bounce around all over the place with different strategies. but for now, I am sticking with my 2^30 chances for 66 bit puzzle.
nomachine
Member
**
Online Online

Activity: 507
Merit: 38


View Profile
October 24, 2023, 08:12:15 PM
Last edit: October 25, 2023, 03:25:13 AM by nomachine
 #3792

Maybe you are on to something, maybe not.

Maybe maybe not.   Wink

bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
digaran
Copper Member
Hero Member
*****
Offline Offline

Activity: 1330
Merit: 900

🖤😏


View Profile
October 24, 2023, 09:50:33 PM
 #3793

For now digest this and penetrate order of the group n.
On line 27, change (result_2 - result_1) % n to +, then compare the results starting with 7, a, 6 etc with both targets. Then Ask me what is scalar torsion, and I will give you another script to work with, remember to work with the results by sub/adding them with different values to find a short cut, I simply subtracted target 2 from n and then removed all leading Fs from it, both targets can be divided by each other, you just need to find the right divisor, also remember to remove # from line 30 and 31 separately to see each target's division results as well.
Code:
import gmpy2 as mpz
from gmpy2 import powmod

# Define the ec_operations function
def ec_operations(start_range, end_range, scalar_1, scalar_2, n, divide_1_by_odd=True, divide_1_by_even=True, divide_2_by_odd=True, divide_2_by_even=True):
    for i in range(start_range + (start_range%2), end_range, 1):
        # divide scalar 1 by odd or even numbers
        if i%2 == 0 and not divide_1_by_even:
            continue
        elif i%2 == 1 and not divide_1_by_odd:
            continue
        try:
            # calculate inverse modulo of i
            i_inv = powmod(i, n-2, n)

            # multiply the scalar targets by i modulo n
            result_1 = scalar_2 * i_inv % n
            result_2 = scalar_1 * i_inv % n

            # divide scalar 2 by odd or even numbers
            if i%2 == 0 and not divide_2_by_even:
                continue
            elif i%2 == 1 and not divide_2_by_odd:
                continue

            # subtract the results
            sub_result = (result_2 - result_1) % n

            # print results separately
          #  print(f"{hex(result_1)[2:]}")
           # print(f"{hex(result_2)[2:]}")
            print(f"{hex(sub_result)[2:]}")

        except ZeroDivisionError:
            pass


if __name__ == "__main__":
    # Set the targets and range for the operations
    scalar_1 = 0x0000000000000000000000000000000b011d90a8cba60d550a2e332b5ef58546
    scalar_2 = 0x00000000000000000000000000000003b9914c3de3a292e6b5a42b617140bbfb

    n = mpz.mpz("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141")

    start_range = 57896044618658097711785492504343953926418782139537452191302581570759080747160
    end_range = 57896044618658097711785492504343953926418782139537452191302581570759080747180

    ec_operations(start_range, end_range, scalar_1, scalar_2, n)



When you are done, go for this one :

Code:
import gmpy2 as mpz
from gmpy2 import powmod

# Define the EllipticCurve class
class EllipticCurve:
    def __init__(self, a, b, p):
        self.a = mpz.mpz(a)
        self.b = mpz.mpz(b)
        self.p = mpz.mpz(p)

    def contains(self, point):
        x, y = point.x, point.y
        return (y * y) % self.p == (x * x * x + self.a * x + self.b) % self.p

    def __str__(self):
        return f"y^2 = x^3 + {self.a}x + {self.b} mod {self.p}"

# Define the Point class
class Point:
    def __init__(self, x, y, curve):
        self.x = mpz.mpz(x)
        self.y = mpz.mpz(y)
        self.curve = curve

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y and self.curve == other.curve

    def __ne__(self, other):
        return not self == other

    def __add__(self, other):
        if self.curve != other.curve:
            raise ValueError("Cannot add points on different curves")

        # Case when one point is zero
        if self == Point.infinity(self.curve):
            return other
        if other == Point.infinity(self.curve):
            return self

        if self.x == other.x and self.y != other.y:
            return Point.infinity(self.curve)

        p = self.curve.p
        s = 0
        if self == other:
            s = ((3 * self.x * self.x + self.curve.a) * powmod(2 * self.y, -1, p)) % p
        else:
            s = ((other.y - self.y) * powmod(other.x - self.x, -1, p)) % p

        x = (s * s - self.x - other.x) % p
        y = (s * (self.x - x) - self.y) % p

        return Point(x, y, self.curve)

    def __sub__(self, other):
        if self.curve != other.curve:
            raise ValueError("Cannot subtract points on different curves")

        # Case when one point is zero
        if self == Point.infinity(self.curve):
            return other
        if other == Point.infinity(self.curve):
            return self

        return self + Point(other.x, (-other.y) % self.curve.p, self.curve)

    def __mul__(self, n):
        if not isinstance(n, int):
            raise ValueError("Multiplication is defined for integers only")

        n = n % (self.curve.p - 1)
        res = Point.infinity(self.curve)
        addend = self

        while n:
            if n & 1:
                res += addend

            addend += addend
            n >>= 1

        return res

    def __str__(self):
        return f"({self.x}, {self.y}) on {self.curve}"

    @staticmethod
    def from_hex(s, curve):
        if len(s) == 66 and s.startswith("02") or s.startswith("03"):
            compressed = True
        elif len(s) == 130 and s.startswith("04"):
            compressed = False
        else:
            raise ValueError("Hex string is not a valid compressed or uncompressed point")

        if compressed:
            is_odd = s.startswith("03")
            x = mpz.mpz(s[2:], 16)

            # Calculate y-coordinate from x and parity bit
            y_square = (x * x * x + curve.a * x + curve.b) % curve.p
            y = powmod(y_square, (curve.p + 1) // 4, curve.p)
            if is_odd != (y & 1):
                y = -y % curve.p

            return Point(x, y, curve)
        else:
            s_bytes = bytes.fromhex(s)
            uncompressed = s_bytes[0] == 4
            if not uncompressed:
                raise ValueError("Only uncompressed or compressed points are supported")

            num_bytes = len(s_bytes) // 2
            x_bytes = s_bytes[1 : num_bytes + 1]
            y_bytes = s_bytes[num_bytes + 1 :]

            x = mpz.mpz(int.from_bytes(x_bytes, byteorder="big"))
            y = mpz.mpz(int.from_bytes(y_bytes, byteorder="big"))

            return Point(x, y, curve)

    def to_hex(self, compressed=True):
        if self.x is None and self.y is None:
            return "00"
        elif compressed:
            prefix = "03" if self.y & 1 else "02"
            return prefix + hex(self.x)[2:].zfill(64)
        else:
            x_hex = hex(self.x)[2:].zfill(64)
            y_hex = hex(self.y)[2:].zfill(64)
            return "04" + x_hex + y_hex

    @staticmethod
    def infinity(curve):
        return Point(-1, -1, curve)

# Define the ec_mul function
def ec_mul(point, scalar, base_point):
    result = Point.infinity(point.curve)
    addend = point

    while scalar:
        if scalar & 1:
            result += addend

        addend += addend
        scalar >>= 1

    return result

# Define the ec_operations function
def ec_operations(start_range, end_range, target_1, target_2, curve, divide_1_by_odd=True, divide_1_by_even=True, divide_2_by_odd=True, divide_2_by_even=True):
    # Define parameters for secp256k1 curve
    n = mpz.mpz("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141")
    G = Point(
        mpz.mpz("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
        mpz.mpz("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"),
        curve
    )

    for i in range(start_range + ( start_range%2), end_range, 1):
        # divide target 1 by odd or even numbers
        if i%2 == 0 and not divide_1_by_even:
            continue
        elif i%2 == 1 and not divide_1_by_odd:
            continue
        try:
            # calculate inverse modulo of i
            i_inv = powmod(i, n-2, n)
           
            # divide the targets by i modulo n
            result_1 = ec_mul(target_1, i_inv, G)
            result_2 = ec_mul(target_2, i_inv, G)

            # divide target 2 by odd or even numbers
            if i%2 == 0 and not divide_2_by_even:
                continue
            elif i%2 == 1 and not divide_2_by_odd:
                continue

            # subtract the results
            sub_result = result_2 - result_1

            # print the results  separately
        #    print(f"{result_1.to_hex()}")
          #  print(f"{result_1.to_hex()}")
            print(f"{sub_result.to_hex()}")
           # data = open("result.txt","a")
          #  data.write(str(sub_result.to_hex()) +"\n")
         #   data.close()

        except ZeroDivisionError:
            pass


if __name__ == "__main__":
    # Set the targets and range for the operations
    curve = EllipticCurve(
        mpz.mpz(0),
        mpz.mpz(7),
        mpz.mpz("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f")
    )

    target_1 = Point.from_hex("03439acdf494f8ed30baa5f465da96c62625dbf0f474535ad9bedefd3f23663f4d", curve)

    target_2 = Point.from_hex("02617125f42749f748bd047f3688f79f8e2a1bf5ef9eca7929bb2daa6fa467b8e1", curve)
   
    start_range = 57896044618658097711785492504343953926418782139537452191302581570759080747160
    end_range = 57896044618658097711785492504343953926418782139537452191302581570759080747180
   
    ec_operations(start_range, end_range, target_2, target_1, curve)

When you are done, repeat the same with unknown points, whatever you do with scalars on first script and whatever results you get, perform them on the points as well, all results will be the same.

🖤😏
rosengold
Jr. Member
*
Offline Offline

Activity: 149
Merit: 7


View Profile
October 25, 2023, 02:10:47 PM
 #3794


Code:
#include <iostream>
#include <vector>...

  • Bytea HASH160 Search by NoMachine
  • Sat Oct 21 10:39:23 2023
  • Puzzle: 15
  • Public Key Hash (Hash 160): fe7c45126731f7384640b0b0045fd40bac72e2a2
  • PUZZLE SOLVED: 2023-10-21 10:39:24
  • Target Public Key Hash (Hash160) found! Private Key: 00000000000000000000000000000000000000000
Hi @nomachine

how to make it work sequential instead of random ?
k3ntINA
Newbie
*
Offline Offline

Activity: 26
Merit: 0


View Profile
October 25, 2023, 03:19:02 PM
 #3795

Hi friends, after a few months of trying I have found what is definitely the key to this puzzle. I am not a professional programmer or math teacher.
I am a graphic designer and through the drawing of figures and maps, I reached a place where the relationship of these numbers and how they support each other through the 4 main mathematical operations (* + - /) is clearly visible.
Numbers have a strange order and order in chaos! I don't know what to call it
  In this order, you can see outputs that are a few numbers of private keys, mostly the first 3 digits
My shape and drawing is animated and with each key it has its own shape, but with all its changes, the connection and order of the numbers is not lost.
  I have a triangle which, by changing its size and moving in the range and even rotating from 0 to 360 degrees, displays the three sides of a single number or the sum of the other two sides.
We all know that the shapes are some kind of mathematical formulas, and this means that there is an algorithm, only a formula has not been written for it.
My friends, I need a programmer to program my shapes and actions so that the key is fully calculated.
Because the keys are related to each other from any direction, angle and distance. It was not without reason that the creator revealed the public keys in 5 steps.
Anyway, after a few years of heavy problems, I have now reached a point where I need to trust someone again. Now there is a possibility that this trust will destroy my life like in the past, but there is no other way.
Friends, I only work with an experienced programmer. Someone who has a portfolio on GitHub. Because there is nothing that can be told to a few people.
The next thing is that this algorithm is definitely correct, and the programmer and I should collect a maximum of 20 bits so that the rights of those who are trying and working on this puzzle are not lost and they can reach the keys in their own way. All this money is not for us.

My email is amir.k3nt@gmail.com

I used Google translation, so I apologize if there is a mistake.
WanderingPhilospher
Sr. Member
****
Offline Offline

Activity: 1288
Merit: 253

Shooters Shoot...


View Profile
October 25, 2023, 03:35:09 PM
 #3796

Hi friends, after a few months of trying I have found what is definitely the key to this puzzle. I am not a professional programmer or math teacher.
I am a graphic designer and through the drawing of figures and maps, I reached a place where the relationship of these numbers and how they support each other through the 4 main mathematical operations (* + - /) is clearly visible.
Numbers have a strange order and order in chaos! I don't know what to call it
  In this order, you can see outputs that are a few numbers of private keys, mostly the first 3 digits
My shape and drawing is animated and with each key it has its own shape, but with all its changes, the connection and order of the numbers is not lost.
  I have a triangle which, by changing its size and moving in the range and even rotating from 0 to 360 degrees, displays the three sides of a single number or the sum of the other two sides.
We all know that the shapes are some kind of mathematical formulas, and this means that there is an algorithm, only a formula has not been written for it.
My friends, I need a programmer to program my shapes and actions so that the key is fully calculated.
Because the keys are related to each other from any direction, angle and distance. It was not without reason that the creator revealed the public keys in 5 steps.
Anyway, after a few years of heavy problems, I have now reached a point where I need to trust someone again. Now there is a possibility that this trust will destroy my life like in the past, but there is no other way.
Friends, I only work with an experienced programmer. Someone who has a portfolio on GitHub. Because there is nothing that can be told to a few people.
The next thing is that this algorithm is definitely correct, and the programmer and I should collect a maximum of 20 bits so that the rights of those who are trying and working on this puzzle are not lost and they can reach the keys in their own way. All this money is not for us.

My email is amir.k3nt@gmail.com

I used Google translation, so I apologize if there is a mistake.
What are the 3 first digits? If your shapes/drawings are correct, we would know within a day or two.
Then you would probably have lots of people trying to help code your idea for #67, #68, etc.
If you send me the first 3 digits of #66, and I find the key; I would split it with you 50/50.
I can guarantee you, 1000% I have ranges ran for every first 3 digit combination; so I would only have to check so many keys vs starting from scratch.
rosengold
Jr. Member
*
Offline Offline

Activity: 149
Merit: 7


View Profile
October 25, 2023, 03:46:47 PM
 #3797

Hi friends, after a few months of trying I have found what is definitely the key to this puzzle. I am not a professional programmer or math teacher.
I am a graphic designer and through the drawing of figures and maps, I reached a place where the relationship of these numbers and how they support each other through the 4 main mathematical operations (* + - /) is clearly visible.
Numbers have a strange order and order in chaos! I don't know what to call it
  In this order, you can see outputs that are a few numbers of private keys, mostly the first 3 digits
My shape and drawing is animated and with each key it has its own shape, but with all its changes, the connection and order of the numbers is not lost.
  I have a triangle which, by changing its size and moving in the range and even rotating from 0 to 360 degrees, displays the three sides of a single number or the sum of the other two sides.
We all know that the shapes are some kind of mathematical formulas, and this means that there is an algorithm, only a formula has not been written for it.
My friends, I need a programmer to program my shapes and actions so that the key is fully calculated.
Because the keys are related to each other from any direction, angle and distance. It was not without reason that the creator revealed the public keys in 5 steps.
Anyway, after a few years of heavy problems, I have now reached a point where I need to trust someone again. Now there is a possibility that this trust will destroy my life like in the past, but there is no other way.
Friends, I only work with an experienced programmer. Someone who has a portfolio on GitHub. Because there is nothing that can be told to a few people.
The next thing is that this algorithm is definitely correct, and the programmer and I should collect a maximum of 20 bits so that the rights of those who are trying and working on this puzzle are not lost and they can reach the keys in their own way. All this money is not for us.

My email is amir.k3nt@gmail.com

I used Google translation, so I apologize if there is a mistake.

Interesting, I have built my own searcher to find it,

If you share the correct first 3 characters of #66 I'm ready to share 50/50 with you, I have all CUDA scripts to find it in about 5 days using some vast.ai instances.
nomachine
Member
**
Online Online

Activity: 507
Merit: 38


View Profile
October 25, 2023, 04:35:53 PM
Last edit: October 25, 2023, 05:29:05 PM by nomachine
 #3798


Code:
#include <iostream>
#include <vector>...

  • Bytea HASH160 Search by NoMachine
  • Sat Oct 21 10:39:23 2023
  • Puzzle: 15
  • Public Key Hash (Hash 160): fe7c45126731f7384640b0b0045fd40bac72e2a2
  • PUZZLE SOLVED: 2023-10-21 10:39:24
  • Target Public Key Hash (Hash160) found! Private Key: 00000000000000000000000000000000000000000
Hi @nomachine

how to make it work sequential instead of random ?

here you go,  buddy

Code:
#include <iostream>
#include <vector>
#include <iomanip>
#include <openssl/bn.h>
#include <openssl/ec.h>
#include <openssl/obj_mac.h>
#include <openssl/sha.h>
#include <openssl/evp.h>
#include <openssl/ripemd.h>
#include <ctime>
#include <sstream>
#include <fstream>

// Function to convert a byte vector to a hexadecimal string
std::string bytesToHex(const std::vector<unsigned char>& bytes) {
    std::stringstream ss;
    for (unsigned char byte : bytes) {
        ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(byte);
    }
    return ss.str();
}

// Function to calculate the RIPEMD160 hash of a byte vector
std::vector<unsigned char> calculateRIPEMD160(const std::vector<unsigned char>& data) {
    std::vector<unsigned char> hash(RIPEMD160_DIGEST_LENGTH);
    RIPEMD160(data.data(), data.size(), hash.data());
    return hash;
}

int main() {
    // Initialize the OpenSSL library
    if (OpenSSL_add_all_algorithms() != 1) {
        std::cerr << "OpenSSL initialization failed." << std::endl;
        return 1;
    }

    // Define the range
    std::string start_range_hex = "000000000000000000000000000000000000000000000001ffffffffffffffff";
    std::string end_range_hex = "000000000000000000000000000000000000000000000003ffffffffffffffff";
    // Set the target Hash160 value (replace with your target hash)
    std::string target_hash160_hex = "20d45a6a762535700ce9e0b216e31994335db8a5";

    // Create an EC_KEY object
    EC_KEY* ec_key = EC_KEY_new_by_curve_name(NID_secp256k1);

    // Calculate the SHA-256 hash of the public key
    unsigned char sha256_result[SHA256_DIGEST_LENGTH];

    // Calculate the RIPEMD160 hash of the SHA-256 hash
    std::vector<unsigned char> ripemd160_result(RIPEMD160_DIGEST_LENGTH);

    BIGNUM* start_range = BN_new();
    BIGNUM* end_range = BN_new();
    BN_hex2bn(&start_range, start_range_hex.c_str());
    BN_hex2bn(&end_range, end_range_hex.c_str());

    while (BN_cmp(start_range, end_range) <= 0) {
        // Create a BIGNUM from the current value in the range
        BIGNUM* bn_private_key = BN_dup(start_range);

        // Set the private key in the EC_KEY object
        EC_KEY_set_private_key(ec_key, bn_private_key);

        // Compute the public key from the private key
        EC_POINT* public_key_point = EC_POINT_new(EC_KEY_get0_group(ec_key));
        EC_POINT_mul(EC_KEY_get0_group(ec_key), public_key_point, bn_private_key, NULL, NULL, NULL);

        // Convert the public key point to binary representation (compressed)
        size_t public_key_length = EC_POINT_point2oct(EC_KEY_get0_group(ec_key), public_key_point, POINT_CONVERSION_COMPRESSED, NULL, 0, NULL);
        std::vector<unsigned char> public_key_bytes(public_key_length);
        EC_POINT_point2oct(EC_KEY_get0_group(ec_key), public_key_point, POINT_CONVERSION_COMPRESSED, public_key_bytes.data(), public_key_length, NULL);

        SHA256(public_key_bytes.data(), public_key_bytes.size(), sha256_result);
        ripemd160_result = calculateRIPEMD160(std::vector<unsigned char>(sha256_result, sha256_result + SHA256_DIGEST_LENGTH));

        // Convert the calculated RIPEMD160 hash to a hexadecimal string
        std::string calculated_hash160_hex = bytesToHex(ripemd160_result);

        // Display the generated public key hash (Hash160) and private key
        std::string message = "\r\033[01;33m[+] Public Key Hash (Hash 160): " + calculated_hash160_hex;
        std::cout << message << "\e[?25l";
        std::cout.flush();

        // Check if the generated public key hash matches the target
        if (calculated_hash160_hex == target_hash160_hex) {
            // Get the current time
            std::time_t currentTime;
            std::time(&currentTime);
            std::tm tmStruct = *std::localtime(&currentTime);

            // Format the current time into a human-readable string
            std::stringstream timeStringStream;
            timeStringStream << std::put_time(&tmStruct, "%Y-%m-%d %H:%M:%S");
            std::string formattedTime = timeStringStream.str();

            std::cout << "\n\033[32m[+] PUZZLE SOLVED: " << formattedTime << "\033[0m" << std::endl;
            std::cout << "\r\033[32m[+] Target Public Key Hash (Hash160) found! Private Key: " << BN_bn2hex(bn_private_key) << std::endl;

            // Append the private key information to a file if it matches
            std::ofstream file("KEYFOUNDKEYFOUND.txt", std::ios::app);
            if (file.is_open()) {
                file << "\nPUZZLE SOLVED " << formattedTime;
                file << "\nPrivate Key (hex): " << BN_bn2hex(bn_private_key);
                file << "\n--------------------------------------------------------------------------------------------------------------------------------------------";
                file.close();
            }

            BN_free(bn_private_key);
            break;
        }

        // Increment the current value in the range
        BN_add_word(start_range, 1);
    }

    // Free the EC_KEY and BIGNUM objects
    BN_free(start_range);
    BN_free(end_range);
    EC_KEY_free(ec_key);

    return 0;
}

Code:
g++ -m64 -march=native -pthread -O3 -I. -o puzzle66 puzzle.cpp -lssl -lcrypto -ldl


bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
digaran
Copper Member
Hero Member
*****
Offline Offline

Activity: 1330
Merit: 900

🖤😏


View Profile
October 25, 2023, 04:58:40 PM
 #3799



By any chance, are you from middle east? If yes you can explain yourself here : https://bitcointalk.org/index.php?topic=620798.0
Or you could find your local language and seek help from a homie.😉
Also note that, the puzzle designer doesn't know how to solve these puzzles, and he didn't leave any clues, because there are no clues.
Ps, I like it the way you attribute trustworthiness to having a github page.😂

🖤😏
nomachine
Member
**
Online Online

Activity: 507
Merit: 38


View Profile
October 25, 2023, 05:45:29 PM
Last edit: October 25, 2023, 06:22:34 PM by nomachine
 #3800

puzzle designer doesn't know how to solve these puzzles, and he didn't leave any clues, because there are no clues.

It's hard to believe he manually write each puzzle after extracting 256 keys from HD wallet...
He masked them (one by one) with leading 000...0001 to set difficulty.
it is done with some script, with errors = ZERO
So his script knows precisely how to solve the second part.  
Or to put it another way, he knows how to solve these puzzles.   Grin

bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
Pages: « 1 ... 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 [190] 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 ... 369 »
  Print  
 
Jump to:  

Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!