Author

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

member
Activity: 462
Merit: 24
If it didn't work, appeal to our future overlord aka AD(artificial dumbness).😉

ChatGTP is a dead horse for programming. I don't advise any normal person to do any serious things with it.
Doesn't see many things at once, you have to draw him exactly what you want, the possibility of it predicting what you want is small... Example.....

I tell him that I want to separate segments from the text file...

Segments are separated by a vertical line |

In file 1.txt :

text1 | text2 | text3| text4

I want to get in file 2.txt :

text1 | text2 | text4

From file 1.txt . . .

And tells me dead serious here is a python script for you:
Code:
import re

# Function to process the text and extract the desired parts
def extract_text(input_file, output_file):
    with open(input_file, 'r') as f:
        input_text = f.read()

    # Regular expression pattern to capture the desired text
    pattern = r'(\b\w+_\w+\b)\s*\|\s*(\b\w+_\w+\b)\s*\|\s*\w+\s*\|\s*(\b\w+_\w+\b)\s*\|'

    matches = re.findall(pattern, input_text)

    # Create the new text format from the extracted matches
    output_text = "\n".join([" | ".join(match) for match in matches])

    # Write the new text to the output file
    with open(output_file, 'w') as f:
        f.write(output_text)

# Example usage
input_file = '1.txt'
output_file = '2.txt'
extract_text(input_file, output_file)

The script does nothing....I have a blank file.

Too much dulls and overcomplicate it...

The solution is in bash one line

Code:
cat 1.txt | cut -d '|' -f1,2,4 > 2.txt

He says you are right,  sorry for the confusion…. Grin

p.s.
If someone thinks that this story has nothing to do with the topic - it does.

This is 1.txt file
https://raw.githubusercontent.com/HomelessPhD/BTC32/main/BTC32_solved_unsolved.txt



which program is that ? Can you link, please?

https://github.com/albertobsd/keyhunt
vhh
newbie
Activity: 14
Merit: 2
I think your comments/scripts confuse people more than helps them, IMO.
I thought everyone is a cryptography expert around here, or worked for more than 25 years on EC, if my methods confuses you is because you don't try working only with scalars to penetrate N the group order. If I explain everything step by step, where would be the fun in that? Have you shared anything you could discover by operating over scalars?
Whatever method, equation you can use to get definitive results over scalars, applies to points as well. I have explained how to get meaningful results based on that before. To Alek on a few previous pages, regarding how to get target /1024 for sure.

Digaran, you're like a toddler when it comes to ECC. Without the proper knowledge about ECC, group fields, etc , you will always be mesmerized by every result you're getting when you perform some arithmetical operations on the curve.

Quote
..if my methods confuses you is because you don't try working only with scalars to penetrate N the group order

That is so stupid in so many ways. The order is a prime number and you are trying to find a divisor that is different from 1 and the number itself....I'm speechless!

Quote
Whatever method, equation you can use to get definitive results over scalars, applies to points as well.

Another stupidity. For example you can multiply 2 scalars over the group field but you cannot do that with 2 points.


It seems that posting whatever crosses your mind, it's your full time job! This wouldn't be a problem if you will present concrete examples from A to Z or if you will have a solid understanding about ECC. The problem is that you're lacking both. There are tons of materials about ECC and how it works - you just have to google it. The more you'll learn, the more you'll realize what a masterpiece the secp256k1 is. "Penetrate N the group order" by using a combination of subtractions and divisions is at least pointless!
hero member
Activity: 630
Merit: 731
Bitcoin g33k
  • Version 0.2.230519 Satoshi Quest, developed by AlbertoBSD
  • Random mode
which program is that ? Can you link, please?
copper member
Activity: 1330
Merit: 899
🖤😏
Moreover, if you do not write the received data to a file, but simply display it on the screen, then the script works great.

Ok, try this one,
Code:
With open("S-1.txt","a") as file:
    file.write(str(i)+" = "+str(C)+"\n")
    file.close()

    With open("D-1.txt","a") as file:
    file.write(str(i)+" = "+str(D)+"\n")
    file.close()
If it didn't work, appeal to our future overlord aka AD(artificial dumbness).😉
newbie
Activity: 49
Merit: 0

What did you try? Did you try running as administrator? Sometimes I used to get that error, I don't know the exact reason, because it wasn't always happening. It just returns that error because your system doesn't allow the script to open the text file, maybe change your directory?  Try like this if you are using windows, type in search box inside BTCPazzle folder, type cmd and hit enter, then type python test.py hit enter, this should fix it.
[/quote]


I tried everything. I ran it with administrator rights and changed the directory. Useless.
Moreover, if you do not write the received data to a file, but simply display it on the screen, then the script works great.
full member
Activity: 1162
Merit: 237
Shooters Shoot...
Quote
Well that BBC is your answer, but it seems nobody has figured it out yet. Good news for our dragon.

The answer to what? See, you throw out numbers and math but none of it makes sense, is new, or doesn't help in knowingly how to reduce a range.

Elaborate what is shows/tells you? If you can.
copper member
Activity: 1330
Merit: 899
🖤😏
Hello.
Tell me how to remove this error?
PermissionError: [Errno 13] Permission denied:

No matter what I tried, it didn't work... Huh

Code:
C:\BTCPazzle>test.py
Target: 0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b
Traceback (most recent call last):
  File "C:\BTCPazzle>test.py", line 20, in
    data = open("D-1000.txt","a")
PermissionError: [Errno 13] Permission denied: "D-1000.txt"


What did you try? Did you try running as administrator? Sometimes I used to get that error, I don't know the exact reason, because it wasn't always happening. It just returns that error because your system doesn't allow the script to open the text file, maybe change your directory?  Try like this if you are using windows, type in search box inside BTCPazzle folder, type cmd and hit enter, then type python test.py hit enter, this should fix it.
newbie
Activity: 49
Merit: 0
subtract G 99 times from target, you will have 100 keys in total, then divide them all by 100, one of the results will definitely be the target/100. Then come here ask me what's next. But first I would need to test your script to see if it does what I said.😉

Hello, is this what you need?

Code:
import secp256k1 as ice
import bitcoin

target= "03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852"
print("Target:", target)
Target_upub= ice.pub2upub(target)

for i in range (100):
    A= ice.scalar_multiplication(i)
    B= ice.point_subtraction(Target_upub, A)
    C= ice.to_cpub(B.hex())
    D= bitcoin.divide(C, 100)

    data = open("S-1.txt","a")
    data.write(str(i)+" = "+str(C)+"\n")
    data.close()

    data = open("D-1.txt","a")
    data.write(str(i)+" = "+str(D)+"\n")
    data.close()

Hello.
Tell me how to remove this error?
PermissionError: [Errno 13] Permission denied:

No matter what I tried, it didn't work... Huh

Code:
C:\BTCPazzle>test.py
Target: 0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b
Traceback (most recent call last):
  File "C:\BTCPazzle>test.py", line 20, in
    data = open("D-1000.txt","a")
PermissionError: [Errno 13] Permission denied: "D-1000.txt"

copper member
Activity: 1330
Merit: 899
🖤😏
Code:
499218910101699464426468676555989843968 /
 3808738022626491275226354038665694 =  131072
Code:
Target_1 =  0x0000000000000000000000000000000377921095386a9e4adb9c7eb1e3bda61c
Target_2 is known =  0x000000000000000000000000000000020000000000000000000000000000a61c
Both targets/131072, subtracting division results
Offset_1 = 0x000000000000000000000000000000000000bbc9084a9c354f256dce3f58f1de
Now replace target_2 with whatever you want, divide with whatever you like, then subtract and add the results, DO NOT try this with public keys, waste of time.

All I can see is that you ended up getting a BBC 👀
That's because you are a pervert, I might add that I don't have the capacity for a big black... wait are we talking about the same thing? Lol  Well that BBC is your answer, but it seems nobody has figured it out yet. Good news for our dragon.😉
member
Activity: 462
Merit: 24
reduce all of the additional hex keys i am searching for.

Code:
import os, random, secrets, hashlib, ecdsa

# List of target Hash 160 values to search for
target_public_key_hashes = [
    bytes.fromhex('20d45a6a762535700ce9e0b216e31994335db8a5'),
    bytes.fromhex('739437bb3dd6d1983e66629c5f08c70e52769371'),
    bytes.fromhex('e0b8a2baee1b77fc703455f39d51477451fc8cfc'),
    bytes.fromhex('61eb8a50c86b0584bb727dd65bed8d2400d6d5aa'),
    bytes.fromhex('f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8'),
]
# Open a file for writing the found matches
with open('found_matches.txt', 'w') as output_file:
    while True:
        dec = secrets.SystemRandom().randrange(36893488147419103231, 2361183241434822606847)
        private_key_bytes = (b'\x00' * 32)[:-len(dec.to_bytes((dec.bit_length() + 7) // 8, 'big'))] + dec.to_bytes((dec.bit_length() + 7) // 8, 'big')
        signing_key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
        h160 = hashlib.new('ripemd160', hashlib.sha256(signing_key.get_verifying_key().to_string("compressed")).digest()).digest()
        h160_hex = h160.hex()       
        if h160_hex.startswith(('20d45a', '739437', 'e0b8a2', '61eb8a', 'f6f543')):
            print(h160_hex, dec)
            if h160 in target_public_key_hashes:
                match_str = f"Found match with hash {dec}\n"
                print(match_str)
                output_file.write(match_str)
                target_public_key_hashes.remove(h160)  # Remove the found hash from the list
                if not target_public_key_hashes:
                    print("All target hashes found.")
                    break

There is no limit and way someone can search for a puzzle. It's like art. Mostly worthless art collection.  Grin
full member
Activity: 1162
Merit: 237
Shooters Shoot...
Code:
499218910101699464426468676555989843968 /
 3808738022626491275226354038665694 =  131072
Code:
Target_1 =  0x0000000000000000000000000000000377921095386a9e4adb9c7eb1e3bda61c
Target_2 is known =  0x000000000000000000000000000000020000000000000000000000000000a61c
Both targets/131072, subtracting division results
Offset_1 = 0x000000000000000000000000000000000000bbc9084a9c354f256dce3f58f1de
Now replace target_2 with whatever you want, divide with whatever you like, then subtract and add the results, DO NOT try this with public keys, waste of time.

All I can see is that you ended up getting a BBC 👀
copper member
Activity: 1330
Merit: 899
🖤😏
Code:
499218910101699464426468676555989843968 /
 3808738022626491275226354038665694 =  131072
Code:
Target_1 =  0x0000000000000000000000000000000377921095386a9e4adb9c7eb1e3bda61c
Target_2 is known =  0x000000000000000000000000000000020000000000000000000000000000a61c
Both targets/131072, subtracting division results
Offset_1 = 0x000000000000000000000000000000000000bbc9084a9c354f256dce3f58f1de
Now replace target_2 with whatever you want, divide with whatever you like, then subtract and add the results, DO NOT try this with public keys, waste of time.
full member
Activity: 1162
Merit: 237
Shooters Shoot...
MoreForUs, here is my similar script. I wrote this probably 3 years ago when everyone was looking for #64, in old Python 2.7

Code:
import binascii, hashlib, base58, sys, ecdsa, codecs, random
pkeys = set(line.rstrip() for line in open('H160Targets.txt'))

lr    = 0x20000000000000000
ur    = 0x21000000000000000
br    = random.randrange(lr, ur)

def com(privkey):
   
    pvk_to_bytes = codecs.decode (privkey, 'hex')
    key = ecdsa.SigningKey.from_string (pvk_to_bytes, curve=ecdsa.SECP256k1).verifying_key
    key_bytes = key.to_string()
    key_hex = codecs.encode(key_bytes, 'hex')
   
    if(ord(bytearray.fromhex(key_hex[-2:])) % 2 == 0):
        public_key_compressed = '02' + key_hex[0:64]
        public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
        sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
        sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()
        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_public_key_compressed_digest)
        ripemd160_digest = ripemd160.digest()
        ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
        if ripemd160_hex in pkeys:
            fwrite = open('KeyFound.txt', 'a')
            fwrite.write('Key: ' + privk + '  ' + ripemd160_hex + '\n' )
           
    else:
        public_key_compressed = '03' + key_hex[0:64]
        public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
        sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
        sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()
        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_public_key_compressed_digest)
        ripemd160_digest = ripemd160.digest()
        ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
        if ripemd160_hex in pkeys:
            fwrite = open('KeyFound.txt', 'a')
            fwrite.write('Key: ' + privk + '  ' + ripemd160_hex + '\n' )

countall = 0
while True:

    if __name__== "__main__":

        privk = hex( br ).lstrip("0x").rstrip("L").zfill(64)
        com(privk)
        br = (br + 0x1000000000000000)
        sys.stdout.write("\r" + "   # of Keys: "  + str(countall))
        sys.stdout.flush()
        countall +=1
        if (br > 0x200000000000000000):
            lr    = 0x20000000000000000
            ur    = 0x21000000000000000
            br    = random.randrange(lr, ur)

As stated, I use a .txt file to store the h160 targets in and use the set function.
full member
Activity: 1162
Merit: 237
Shooters Shoot...
Quote

I am getting about 300 keys per second, currently looking into speeding it up. 1 way would be to reduce all of the additional hex keys i am searching for.
additional_hex_numbers = ['3','4','5','6','7','8', '9', 'a', 'b', 'c', 'd', 'e', 'f','10','11','12','13','14','15','16','17','18','19','1a', '1b', '1c','1d', '1e', '1f'
,'40','41','42','43','44','45','46','47','48','49','4a', '4b', '4c','4d', '4e', '4f' ,'50','51','52','53','54','55','56','57','58','59','5a', '5b', '5c','5d', '5e', '5f' ,'60','61','62','63','64','65','66','67','68','69','6a', '6b', '6c','6d', '6e', '6f' ,'70','71','72','73','74','75','76','77','78','79','7a', '7b', '7c','7d', '7e', '7f' ] its also written like that, so when a match is found it will print verbatim

Mine does the same as yours. But I only have it programmed up to #69.
But I do not have all the additional hex numbers; I merely use a stride of
0x1000000000000000
So it generates a random number in the 2000…(66 bit) range, then iterates up to
7f000…(69 bit) and then I hit it with an if statement, that if it goes over 0x8000…to generate a new random starting point in the 0x2000…(66 bit) range and then rinse and repeat until key is found.

I am sure there are several ways to speed my old script up as well.

EDIT: I also use a file with the targets in it and use the Python set feature.
newbie
Activity: 17
Merit: 0


MoreForUs, what speed are you showing with your program? When I ran it a few times, it seems very slow, and the text is somewhat confusing.
What is considered an iteration, one key checked?
Also:

Code:
Reached 12 iterations.
Elapsed Time: 0.53 seconds
Iterations per Second: 22.43
Decimal Number: 37120000000000000000
Private Key Hex: 0000000000000000000000000000000000000000000000020324bb546e800000
Target Hash 160: 09d19b3025828bca263e80cf2b5da1e08e938ca3
Target Decimal Number: 37120000000000000000

Reached 170 iterations.
Elapsed Time: 14.13 seconds
Iterations per Second: 12.03
Decimal Number: 38700000000000000000
Private Key Hex: 000000000000000000000000000000000000000000000002191204f5679e0000
Target Hash 160: 846874d169173600744fe5c1cdf9f2915cdb25ae
Target Decimal Number: 38700000000000000000

The Target Hash 160 verbiage is misleading, as it's not the target 160, it's the actual 160 of the current Private Key Hex being checked. Same for Target Dec Num, if we knew the target, we wouldn't be talking lol.

Anywho, I am trying to compare it's speed to my old slow python script; I think mine checks 3,000 key/s on a single core.
I am getting about 300 keys per second, currently looking into speeding it up. 1 way would be to reduce all of the additional hex keys i am searching for.
additional_hex_numbers = ['3','4','5','6','7','8', '9', 'a', 'b', 'c', 'd', 'e', 'f','10','11','12','13','14','15','16','17','18','19','1a', '1b', '1c','1d', '1e', '1f'
,'40','41','42','43','44','45','46','47','48','49','4a', '4b', '4c','4d', '4e', '4f' ,'50','51','52','53','54','55','56','57','58','59','5a', '5b', '5c','5d', '5e', '5f' ,'60','61','62','63','64','65','66','67','68','69','6a', '6b', '6c','6d', '6e', '6f' ,'70','71','72','73','74','75','76','77','78','79','7a', '7b', '7c','7d', '7e', '7f' ] its also written like that, so when a match is found it will print verbatim.
full member
Activity: 1162
Merit: 237
Shooters Shoot...
full member
Activity: 1162
Merit: 237
Shooters Shoot...
I think your comments/scripts confuse people more than helps them, IMO.
I thought everyone is a cryptography expert around here, or worked for more than 25 years on EC, if my methods confuses you is because you don't try working only with scalars to penetrate N the group order. If I explain everything step by step, where would be the fun in that? Have you shared anything you could discover by operating over scalars?
Whatever method, equation you can use to get definitive results over scalars, applies to points as well. I have explained how to get meaningful results based on that before. To Alek on a few previous pages, regarding how to get target /1024 for sure.

@mcdouglasx, sorry to hear that, I hope it all goes well God willing. Take care.🤲

Lol, I am not claiming I have discovered anything that isn't already talked about / known on this forum. However, I have not seen anything that you have given, with example, as something new.

One can sit back and sub, add, div, mult, all kind of pubs together, separately, by 100, by 1024, etc. and get a lot of different looking pubs, but it does not show how one is closer to showing a relation or reducing any keys, with 100%.

What meaningful results, with a concrete example, have you given? Not just asking us, "do you see that". Link to a concrete example of anything you have worked out in regards to these puzzles or EC for that matter. Thanks.
member
Activity: 462
Merit: 24
worked for more than 25 years on EC

To better understand the claim and specific experience with elliptic curves, we can ask you about your work, projects, and expertise in this area. This will provide more context and clarity about the 25 years you are referring to.

Can you point us to your published studies? I'm really curious and looking forward reading them.

We are still waiting for your reply from the other day.  Grin
copper member
Activity: 1330
Merit: 899
🖤😏
I think your comments/scripts confuse people more than helps them, IMO.
I thought everyone is a cryptography expert around here, or worked for more than 25 years on EC, if my methods confuses you is because you don't try working only with scalars to penetrate N the group order. If I explain everything step by step, where would be the fun in that? Have you shared anything you could discover by operating over scalars?
Whatever method, equation you can use to get definitive results over scalars, applies to points as well. I have explained how to get meaningful results based on that before. To Alek on a few previous pages, regarding how to get target /1024 for sure.

@mcdouglasx, sorry to hear that, I hope it all goes well God willing. Take care.🤲
jr. member
Activity: 82
Merit: 2
Exactly, this is what I am questioning. According to him, his i9 is getting 4Gkeys brute forcing without pub key....

He said it was from keyhunt, so unless he modified it, its straight brute force as pub key is not available for 66.

You're right. I can achieve a maximum of ~1 Ekeys/s with AMD Ryzen 9 7950X3D, but if I know what public key is.

...deleted...

If I don't know what public key is, the speed cannot be higher than 50 MKey/s. . .

Theoretically it could get closer... If you have a 128 Core Grin
https://www.titancomputers.com/Titan-A475-Dual-AMD-EPYC-Milan-7003-Series-Proce-p/a475.htm

Jump to: