I regret to inform you that Douglas last night decided to say goodbye to this world, I don't know how this works, he never showed me any sadness, I regret in my soul that I didn't see it coming. My condolences to those who knew him, I do not have access to his networks to notify anyone, only this and an email that is not associated with anything else. I'm taking care of the preparations. admins can now close this account.
I hope that you're joking. This is the kind of joke that I'd never want to hear. Doug, if you're out there this is not a good joke. I've just said to you that you'll be in a nice place but not on this kind of place. The place or state that you'll able to overcome your problems. I'm not dead!!! My ex-wife and her evils had no limits, I had to apply phishing to be able to recover my networks, this seems like a movie but it is reality, I am not completely well but I was able to overcome the depression, I only sometimes feel anxiety, I moved to another city to get away from that hell, I rented a small apartment, while I look for one of my own, here it is not expensive 10k is enough to buy, I am starting with more strength than ever to go for puzzle #130, no one will ruin my dreams. I'm sorry if my ex made you believe something else, I've never been a joker or a liar. Thank God, I'll be fine. tell your ex mate that this is not a good joke , you seems to be a good man to be abused by her and she do not deserve you man . anyway wishing you will find a better one and will do your life more greener than what you have with her, prove her that she was wrong leaving you. Thank you, I will do it, after the bad is over, there is nothing left but a good future and a lot of motivation.
|
|
|
I regret to inform you that Douglas last night decided to say goodbye to this world, I don't know how this works, he never showed me any sadness, I regret in my soul that I didn't see it coming. My condolences to those who knew him, I do not have access to his networks to notify anyone, only this and an email that is not associated with anything else. I'm taking care of the preparations. admins can now close this account.
I hope that you're joking. This is the kind of joke that I'd never want to hear. Doug, if you're out there this is not a good joke. I've just said to you that you'll be in a nice place but not on this kind of place. The place or state that you'll able to overcome your problems. I'm not dead!!! My ex-wife and her evils had no limits, I had to apply phishing to be able to recover my networks, this seems like a movie but it is reality, I am not completely well but I was able to overcome the depression, I only sometimes feel anxiety, I moved to another city to get away from that hell, I rented a small apartment, while I look for one of my own, here it is not expensive 10k is enough to buy, I am starting with more strength than ever to go for puzzle #130, no one will ruin my dreams. I'm sorry if my ex made you believe something else, I've never been a joker or a liar. Thank God, I'll be fine.
|
|
|
I regret to inform you that Douglas last night decided to say goodbye to this world, I don't know how this works, he never showed me any sadness, I regret in my soul that I didn't see it coming. My condolences to those who knew him, I do not have access to his networks to notify anyone, only this and an email that is not associated with anything else. I'm taking care of the preparations. admins can now close this account.
|
|
|
You will in a nicer place bud. I know that this problem that you're dealing with now is not going to last forever. You'll find your new happiness and I know that you'll be able to move on. I want to leave this in writing here, so that when I achieve my goals I can be an example of improvement, there is no evil that lasts forever and when we want we can move forward no matter what happens.
Happy day to everyone.
Please do, I am waiting for your happy moments and achievements that you'll be proud to say here when you're back. For now I am in a constant fight for my mental health, honestly it is difficult to concentrate, I do not spend a second that I do not think about the reason for things, and the little I sleep is interrupted by nightmares about it, I have mistakenly tried to recover my family and I have been ignored, if this happens to someone, don't make my mistake, if someone doesn't love you, they won't change their mind, this will happen and it will make me stronger. My goals are my reason to show the world that it is possible. Thanks for your words of encouragement.
|
|
|
A few months ago I wrote a method that gave me the freedom to say that practically in 1 month I could collect the reward. However, my happiness did not last long.
In the first instance I was in the wrong range.
My wife betrayed me for a new man and left me homeless, I lost everything I had built in many years of my life, now I only have depression and anxiety because of everything I have experienced, I now sleep at a friend's house and I lost my job thanks to what I suffer from.
The point of suing does not exist in my country, the new man is associated with criminal gangs and I fear for my life if I try to recover something.
My points in favor are that the code is in my mind, and they can't take that away from me.
This illness is the worst thing that has ever happened to me, and I write this to give some context. I know I will get out of this abyss and fulfill my dreams. I want to leave this in writing here, so that when I achieve my goals I can be an example of improvement, there is no evil that lasts forever and when we want we can move forward no matter what happens.
Happy day to everyone.
|
|
|
Yes, it is possible, but it is more likely that a hacker will obtain malware that is transmitted on the network, taking power and proceed to attack, than groups of miners will unite to destroy bitcoin, because if this happens the price will drop to zero.
|
|
|
I did about 10 attempts today, trying to change already broadcasted transaction, sent from bitcoin-core with RBF flag off. All attempts fail. First transaction always win.
Then we must do kind of kung-fu. Using older Electrum versions than 4.4.0 with RBF flag off. I already installed and ready to finalize.. needs only 1 more thing The problem lies in the rbf according to the configuration of each node, I think that if you do a tx deactivating rbf it must be replaced using another node to be able to replace it.
|
|
|
The only way for your signature to be compromised is to sign 2 messages using the same nonce K, which must be random between 1 and N-1 (where N is the order of the curve), as long as you do the signing in a secure environment. There will be problems, if they ask you to sign using their website or software provided by them, run away, it's probably a signature scam. If you make 2 signatures using the same nonce, they can derive your private key.
|
|
|
The advance that favors mining would be the reduction of electrical consumption, not the speed with which the systems are executed, the difficulty would be adjusted.
|
|
|
In my free time, for fun, I created this script: we create an addreess with additional secret code based on schnorr aggregate signatures How secure would a bitcoin address system proposed in this way be? My main thought was to reduce (even further) the probability that if the ECDSA algorithm were violated (paranoid mode), it would be even more difficult to deduce a pk from the public key. pip install bitcoinimport schnorr_lib import hashlib from bitcoin import * import random
N = 115792089237316195423570985008687907852837564279074904382605163141518161494337 ################################################################################################
privkey = random.randint(1,N-1)
secret_code= 1234567890
msg= b'Hello BitcoinTalk'
################################################################################################
def Pk_shadow(pubX, pubY): pub_sh_str = str(pubX)+str(pubY) converted_digits = [] for digit in pub_sh_str: nd = int(digit) if nd % 2 == 0: converted_digits.append(0) else: converted_digits.append(1) bits = "".join(map(str, converted_digits)) dec = int(bits, 2) return dec
upub_dec= privtopub(privkey) pubKeyX, pubKeyY = upub_dec
pubX=pubKeyX pubY=pubKeyY Pk_Sh = ((Pk_shadow(pubX, pubY))) % N
privkey2 = (int(privkey+Pk_Sh)*secret_code) % N
privkey_hex = hex(privkey)[2:] privkey_hex = '0' + privkey_hex if len(privkey_hex) % 2 != 0 else privkey_hex privkey2_hex = hex(privkey2)[2:] privkey2_hex = '0' + privkey2_hex if len(privkey2_hex) % 2 != 0 else privkey2_hex
print(f"Private key: {privkey_hex}"+"\n") #print(str(privkey2)+"\n") print(f"Secret Code: {secret_code}"+"\n") print("msg:", str(msg)[1:]+"\n")
pubkey1 = schnorr_lib.pubkey_gen_from_int(privkey) pubkey2 = schnorr_lib.pubkey_gen_from_int(privkey2)
msg = hashlib.sha256(msg).digest() print("msg_hash:", msg.hex()+"\n")
users = [{"privateKey": privkey_hex, "publicKey": pubkey1}, {"privateKey": privkey2_hex, "publicKey": pubkey2}] sig, agg_pubkey = schnorr_lib.schnorr_musig2_sign(msg, users)
print(f"Aggregated signature: {sig.hex()}"+"\n") print(f"Aggregated public key: {agg_pubkey.hex()}"+"\n")
verification = schnorr_lib.schnorr_verify(msg, agg_pubkey, sig)
print(f"Aggregated signature verification: {verification}"+"\n")
assert verification
multisig_address = str(scriptaddr(agg_pubkey.hex()))+"\n"
print("Address:","4"+multisig_address[1:]) schnorr_lib.py Thanks to https://github.com/BitPolito/schnorr-sig/blob/master/schnorr_lib.pyfrom typing import Tuple, Optional from binascii import unhexlify import hashlib import os
# Elliptic curve parameters p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 G = (0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798, 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)
# Points are tuples of X and Y coordinates # the point at infinity is represented by the None keyword Point = Tuple[int, int]
# Get bytes from an int def bytes_from_int(a: int) -> bytes: return a.to_bytes(32, byteorder="big")
# Get bytes from a hex def bytes_from_hex(a: hex) -> bytes: return unhexlify(a)
# Get bytes from a point def bytes_from_point(P: Point) -> bytes: return bytes_from_int(x(P))
# Get an int from bytes def int_from_bytes(b: bytes) -> int: return int.from_bytes(b, byteorder="big")
# Get an int from hex def int_from_hex(a: hex) -> int: return int.from_bytes(unhexlify(a), byteorder="big")
# Get x coordinate from a point def x(P: Point) -> int: return P[0]
# Get y coordinate from a point def y(P: Point) -> int: return P[1]
# Point addition def point_add(P1: Optional[Point], P2: Optional[Point]) -> Optional[Point]: if P1 is None: return P2 if P2 is None: return P1 if (x(P1) == x(P2)) and (y(P1) != y(P2)): return None if P1 == P2: lam = (3 * x(P1) * x(P1) * pow(2 * y(P1), p - 2, p)) % p else: lam = ((y(P2) - y(P1)) * pow(x(P2) - x(P1), p - 2, p)) % p x3 = (lam * lam - x(P1) - x(P2)) % p return x3, (lam * (x(P1) - x3) - y(P1)) % p
# Point multiplication def point_mul(P: Optional[Point], d: int) -> Optional[Point]: R = None for i in range(256): if (d >> i) & 1: R = point_add(R, P) P = point_add(P, P) return R
# Note: # This implementation can be sped up by storing the midstate # after hashing tag_hash instead of rehashing it all the time # Get the hash digest of (tag_hashed || tag_hashed || message) def tagged_hash(tag: str, msg: bytes) -> bytes: tag_hash = hashlib.sha256(tag.encode()).digest() return hashlib.sha256(tag_hash + tag_hash + msg).digest()
# Check if a point is at infinity def is_infinity(P: Optional[Point]) -> bool: return P is None
# Get xor of bytes def xor_bytes(b0: bytes, b1: bytes) -> bytes: return bytes(a ^ b for (a, b) in zip(b0, b1))
# Get a point from bytes def lift_x_square_y(b: bytes) -> Optional[Point]: x = int_from_bytes(b) if x >= p: return None y_sq = (pow(x, 3, p) + 7) % p y = pow(y_sq, (p + 1) // 4, p) if pow(y, 2, p) != y_sq: return None return x, y
def lift_x_even_y(b: bytes) -> Optional[Point]: P = lift_x_square_y(b) if P is None: return None else: return x(P), y(P) if y(P) % 2 == 0 else p - y(P)
# Get hash digest with SHA256 def sha256(b: bytes) -> bytes: return hashlib.sha256(b).digest()
# Check if an int is square def is_square(a: int) -> bool: return int(pow(a, (p - 1) // 2, p)) == 1
# Check if a point has square y coordinate def has_square_y(P: Optional[Point]) -> bool: infinity = is_infinity(P) if infinity: return False assert P is not None return is_square(y(P))
# Check if a point has even y coordinate def has_even_y(P: Point) -> bool: return y(P) % 2 == 0
# Generate public key from an int def pubkey_gen_from_int(seckey: int) -> bytes: P = point_mul(G, seckey) assert P is not None return bytes_from_point(P)
# Generate public key from a hex def pubkey_gen_from_hex(seckey: hex) -> bytes: seckey = bytes.fromhex(seckey) d0 = int_from_bytes(seckey) if not (1 <= d0 <= n - 1): raise ValueError( 'The secret key must be an integer in the range 1..n-1.') P = point_mul(G, d0) assert P is not None return bytes_from_point(P)
# Generate public key (as a point) from an int def pubkey_point_gen_from_int(seckey: int) -> Point: P = point_mul(G, seckey) assert P is not None return P
# Generate auxiliary random of 32 bytes def get_aux_rand() -> bytes: return os.urandom(32)
# Extract R_x int value from signature def get_int_R_from_sig(sig: bytes) -> int: return int_from_bytes(sig[0:32])
# Extract s int value from signature def get_int_s_from_sig(sig: bytes) -> int: return int_from_bytes(sig[32:64])
# Extract R_x bytes from signature def get_bytes_R_from_sig(sig: bytes) -> int: return sig[0:32]
# Extract s bytes from signature def get_bytes_s_from_sig(sig: bytes) -> int: return sig[32:64]
# Generate Schnorr signature def schnorr_sign(msg: bytes, privateKey: str) -> bytes: if len(msg) != 32: raise ValueError('The message must be a 32-byte array.') d0 = int_from_hex(privateKey) if not (1 <= d0 <= n - 1): raise ValueError( 'The secret key must be an integer in the range 1..n-1.') P = point_mul(G, d0) assert P is not None d = d0 if has_even_y(P) else n - d0 t = xor_bytes(bytes_from_int(d), tagged_hash("BIP0340/aux", get_aux_rand())) k0 = int_from_bytes(tagged_hash("BIP0340/nonce", t + bytes_from_point(P) + msg)) % n if k0 == 0: raise RuntimeError('Failure. This happens only with negligible probability.') R = point_mul(G, k0) assert R is not None k = n - k0 if not has_even_y(R) else k0 e = int_from_bytes(tagged_hash("BIP0340/challenge", bytes_from_point(R) + bytes_from_point(P) + msg)) % n sig = bytes_from_point(R) + bytes_from_int((k + e * d) % n) if not schnorr_verify(msg, bytes_from_point(P), sig): raise RuntimeError('The created signature does not pass verification.') return sig
# Verify Schnorr signature def schnorr_verify(msg: bytes, pubkey: bytes, sig: bytes) -> bool: if len(msg) != 32: raise ValueError('The message must be a 32-byte array.') if len(pubkey) != 32: raise ValueError('The public key must be a 32-byte array.') if len(sig) != 64: raise ValueError('The signature must be a 64-byte array.') P = lift_x_even_y(pubkey) r = get_int_R_from_sig(sig) s = get_int_s_from_sig(sig) if (P is None) or (r >= p) or (s >= n): return False e = int_from_bytes(tagged_hash("BIP0340/challenge", get_bytes_R_from_sig(sig) + pubkey + msg)) % n R = point_add(point_mul(G, s), point_mul(P, n - e)) if (R is None) or (not has_even_y(R)): # print("Please, recompute the sign. R is None or has even y") return False if x(R) != r: # print("There's something wrong") return False return True
# Generate Schnorr MuSig signature def schnorr_musig_sign(msg: bytes, users: list) -> bytes: if len(msg) != 32: raise ValueError('The message must be a 32-byte array.') # Key aggregation (KeyAgg), L = h(P1 || ... || Pn) L = b'' for u in users: L += pubkey_gen_from_hex(u["privateKey"]) L = sha256(L)
Rsum = None X = None for u in users: # Get private key di and public key Pi di = int_from_hex(u["privateKey"]) if not (1 <= di <= n - 1): raise ValueError('The secret key must be an integer in the range 1..n-1.') Pi = pubkey_point_gen_from_int(di) assert Pi is not None # KeyAggCoef # ai = h(L||Pi) ai = int_from_bytes(sha256(L + bytes_from_point(Pi))) u["ai"] = ai
# Computation of X~ # X~ = X1 + ... + Xn, Xi = ai * Pi X = point_add(X, point_mul(Pi, ai))
# Random ki with tagged hash t = xor_bytes(bytes_from_int(di), tagged_hash("BIP0340/aux", get_aux_rand())) ki = int_from_bytes(tagged_hash("BIP0340/nonce", t + bytes_from_point(Pi) + msg)) % n if ki == 0: raise RuntimeError('Failure. This happens only with negligible probability.') # Ri = ki * G Ri = point_mul(G, ki) assert Ri is not None # Rsum = R1 + ... + Rn Rsum = point_add(Rsum, Ri) u["ki"] = ki
# The aggregate public key X~ needs to be y-even if not has_even_y(X): for i, u in enumerate(users): users[i]["ai"] = n - u["ai"]
# If the aggregated nonce does not have an even Y # then negate individual nonce scalars (and the aggregate nonce) if not has_even_y(Rsum): for i, u in enumerate(users): users[i]["ki"] = n - u["ki"]
# c = hash( Rsum || X || M ) c = int_from_bytes(tagged_hash("BIP0340/challenge", (bytes_from_point(Rsum) + bytes_from_point(X) + msg))) % n
sSum = 0 for u in users: # Get private key di di = int_from_hex(u["privateKey"]) # sSum = s1 + ... + sn, # si = ki + di * c * ai mod n sSum += (di * c * u["ai"] + u["ki"]) % n sSum = sSum % n
signature_bytes = bytes_from_point(Rsum) + bytes_from_int(sSum)
if not schnorr_verify(msg, bytes_from_point(X), signature_bytes): raise RuntimeError('The created signature does not pass verification.') return signature_bytes, bytes_from_point(X)
# Generate Schnorr MuSig2 signature def schnorr_musig2_sign(msg: bytes, users: list) -> bytes: if len(msg) != 32: raise ValueError('The message must be a 32-byte array.')
nu = 2
# Key aggregation (KeyAgg), L = h(P1 || ... || Pn) L = b'' for u in users: L += pubkey_gen_from_hex(u["privateKey"]) L = sha256(L)
X = None for u in users: # Get private key di and public key Pi di = int_from_hex(u["privateKey"]) if not (1 <= di <= n - 1): raise ValueError('The secret key must be an integer in the range 1..n-1.') Pi = pubkey_point_gen_from_int(di) assert Pi is not None
# KeyAggCoef # ai = h(L||Pi) ai = int_from_bytes(sha256(L + bytes_from_point(Pi))) u["ai"] = ai
# Computation of X~ # X~ = X1 + ... + Xn, Xi = ai * Pi X = point_add(X, point_mul(Pi, ai))
# First signing round (Sign and SignAgg) r_list = [] R_list = []
for j in range(nu): # Random r with tagged hash t = xor_bytes(bytes_from_int(di), tagged_hash("BIP0340/aux", get_aux_rand())) r = int_from_bytes(tagged_hash("BIP0340/nonce", t + bytes_from_point(Pi) + msg)) % n if r == 0: raise RuntimeError('Failure. This happens only with negligible probability.') # Ri,j = ri,j * G (i represents the user) Rij = point_mul(G, r) assert Rij is not None
r_list.append(r) R_list.append(Rij) u["r_list"] = r_list u["R_list"] = R_list
# SignAgg # for each j in {1 .. nu} aggregator compute Rj as sum of Rij (where i goes # from 1 to n, and n is the number of user, while j is fixed for each round) # Rj is a set, where its size is nu Rj_list = [] for j in range(nu): Rj_list.append(None) for u in users: Rj_list[j] = point_add(Rj_list[j], u["R_list"][j]) # Second signing round (Sign', SignAgg', Sign'') # Sign' Rbytes = b'' for Rj in Rj_list: Rbytes += bytes_from_point(Rj)
# b = h(R1 || ... || Rn || X || M) b = sha256(Rbytes + bytes_from_point(X) + msg)
Rsum = None for j, Rj in enumerate(Rj_list): # Rsum = SUM (Rj * b^(j)) (Rsum is R in the paper) Rsum = point_add(Rsum, point_mul(Rj, int_from_bytes(b) ** j)) assert Rsum is not None
# The aggregate public key X~ needs to be y-even if not has_even_y(X): for i, u in enumerate(users): users[i]["ai"] = n - u["ai"]
# If the aggregated nonce does not have an even Y # then negate individual nonce scalars (and the aggregate nonce) if not has_even_y(Rsum): for i, u in enumerate(users): for j, r in enumerate(users[i]["r_list"]): users[i]["r_list"][j] = n - users[i]["r_list"][j]
# c = hash( Rsum || X || M ) c = int_from_bytes(tagged_hash("BIP0340/challenge", (bytes_from_point(Rsum) + bytes_from_point(X) + msg))) % n
# SignAgg' step sSum = 0 for u in users: # Get private key di di = int_from_hex(u["privateKey"])
rb = 0 for j in range(nu): rb += u["r_list"][j] * int_from_bytes(b)**j
# ssum = s1 + ... + sn, si = (c*ai*di + r) % n sSum += (di * c * u["ai"] + rb) % n sSum = sSum % n
signature_bytes = bytes_from_point(Rsum) + bytes_from_int(sSum) if not schnorr_verify(msg, bytes_from_point(X), signature_bytes): raise RuntimeError('The created signature does not pass verification.') return signature_bytes, bytes_from_point(X)
|
|
|
This is not bullshit, as some others users already mentioning, Doesn't matter if you mark it with or without RBF, the transaction always can be repleaced and that only depends of Node configuracions to accept it or reject it.
The only safest way to move the founds is ask to a miner if they mined your transaction without broadcast it (previously to the block begin mined), also it is even better if you are a miner and you include the transaction without broadcast it before it is mined.
And if the miner includes the transaction and his block is mined by others? Would the transaction be free for the sharks?
|
|
|
Maybe disabling RBF would be a start, and using a high fee.
That is currenly useless, even disabling that flag in your transactions, it still can be replaced due Nodes configurations. So we are in a big problem, there should be standard rules for all nodes so that rbf makes sense and is optional and not permanent. but I don't think the rules will be changed for the puzzles.
|
|
|
Hello everyone! I have a simple question about the power of gpu cards and the time to crack the puzzle 66
What is the actual cracking speed of Rtx 4090(Doesn't matter if bitcrack kangaroo or vanity) the faster one will be the better.
I want to calculate if i get 30x Rtx4090 How many days or months do i need to crack p66?
Hundreds of years. Once you crack it you'll want to spend it, so you'll have to disclose the public key over the network. Once everyone sees the public key and knows it has a 66-bit private key, they will crack the private key in a few seconds at most and double spend, making your efforts completely futile. So I guess the reward for ruining a lots of hardware and paying for the power goes straight to zero, since everyone will fight to double spend, making the fee higher and higher and the net profit going to zero. Maybe disabling RBF would be a start, and using a high fee.
|
|
|
happy birthday,
Thanks Mostly, I work on puzzle 66, but today, being a special day, I was trying some of my old scripts, among which was a batch (.bat) file that I occasionally run. Today, When I executed it, I saw something like Start:2C15823997A13A9000000000000000000 Stop :2C15823997A13A9FFFFFFFFFFFFFFFFFF Keys :1 Number of CPU thread: 0 Range width: 2^72 Jump Avg distance: 2^36.04 Number of kangaroos: 2^20.25 Suggested DP: 13 Expected operations: 2^37.12 Expected RAM: 707.9MB DP size: 13 [0xFFF8000000000000] GPU: GPU #0 NVIDIA GeForce RTX 3060 Ti (38x0 cores) Grid(76x128) (102.0 MB used) SolveKeyGPU Thread GPU#0: creating kangaroos... SolveKeyGPU Thread GPU#0: 2^20.25 kangaroos [4.2s] [999.21 MK/s][GPU 999.21 MK/s][Count 2^36.91][Dead 1][02:27 (Avg 02:29)][483.1/610.4MB] Key# 0 [1S]Pub: 0x03633CBE38F52C67DED3104637FAF4B05ABC85C6D9815DB628DF18719051FB8B3B Priv: 0x2C15823997A13A99FE40A3DC9797A1F2E
Done: Total time 02:37 Which made me quite happy. However, this joy was short-lived because the batch file was originally created to check some sample public keys during an experiment, Following this realization I felt quite disheartened in that sorrow, I typed the above message. You have 0.1 btc Cheer up!, that amount changes the lives of many.
|
|
|
I am the creator.
You are quite right, 161-256 are silly. I honestly just did not think of this. What is especially embarrassing, is this did not occur to me once, in two years. By way of excuse, I was not really thinking much about the puzzle at all.
I will make up for two years of stupidity. I will spend from 161-256 to the unsolved parts, as you suggest. In addition, I intend to add further funds. My aim is to boost the density by a factor of 10, from 0.001*length(key) to 0.01*length(key). Probably in the next few weeks. At any rate, when I next have an extended period of quiet and calm, to construct the new transaction carefully.
A few words about the puzzle. There is no pattern. It is just consecutive keys from a deterministic wallet (masked with leading 000...0001 to set difficulty). It is simply a crude measuring instrument, of the cracking strength of the community.
Finally, I wish to express appreciation of the efforts of all developers of new cracking tools and technology. The "large bitcoin collider" is especially innovative and interesting!
I need some fund to continue for my discoveries and projects, or else I'll have to abandon these endeavors entirely. It's quite distressing for me, but I've been left with no choice. The creator's support would mean the world to me as I strive to keep my work alive. As you mentioned, "it is simply a crude measuring instrument, of the cracking strength of the community." However, if all members of the community continue to leave their tasks incomplete due to constraints, your measuring instrument will repeatedly break. Please understand that in this community, 99% of members may have limited strength, but they put in a tremendous amount of effort. Anyways... Today is my birthday happy birthday, I hope you get it, for my part I abandoned my idea of sharing knowledge regarding puzzles, I was thinking of releasing the method once I unlocked 130, but this is a community that does not work as a community, I prefer to wait 2 months if possible necessary, to unlock puzzle #130 on my own without anyone's help. If I can do it with a broken i5 laptop without a keyboard in such a short time, it means I have an advantage over anyone else in the world. But although money is not important to me, I settle for what is necessary (because I need it). If I later unlock 135-140, I will donate it to charity and projects that I admire.
|
|
|
No olvide decir gracias, para motivarme a contribuir con otras ideas.
Gracias. Este código es sólo una demostración que puede no estar optimizado correctamente, preferiblemente cree su propia versión en C.
Correcto, no esta optimizado pero la idea se entiende bien! #@mcdouglasx b = bytes(BitArray(bin=my_str)) file = open("data-base.bin", "rb") dat = bytes(file.read()) if b in dat:
Esa parte del codigo es el mayor problema No hay una manera eficiente e instantea para buscar un sub-array de bits en un array extremadamente grande. No estoy hablando de una busqueda en 3 o 4 MB estoy hablando de una busqueda en un array de 128 GB o tal vez hasta un 1 Terabyte La idea es buena no lo niego, le he dado vueltas desde que la lei pero mientras mas grande es la base de datos mas tarda cada busqueda. Menciono 128 GB por que es lo que se necesita para 2^40 publickeys para ser almacenadas con ese metodo de 1 llave por bit >>> 2**40 // 8 // 1024 // 1024 // 1024 128
Un metodo que se me occurre para realizar busquedas mas eficientes es almacenar cada 16 o 32 bytes de tu base de datos en un bloom filter, de esta manera la base de datos original de 2^40 llaves publicas que requiere 128 GB en disco, puede ser dividida en 4294967296 items de 32 bytes o 8589934592 items de 16 bytes los cuales pueden ser almacenados en 14 GB de RAM para una busqueda mas eficiente en un bloom filter >>> 2**40 // 8 // 32 * 29 // 8 // 1024 // 1024 // 1024 14 >>> 2**40 // 8 // 32 4294967296 >>> 2**40 // 8 // 16 8589934592
De esta manera cada que exista un hit en el bloom filter (1 de cada 100 Millones por motivos de falso positivo) ahora si se realizara la busqueda full en tu base de datos de 2^40 items (128 GB) Estaba pensado en algun otro tipo de busqueda probabilistica que no sea tan exhaustivo pero aun no doy con nada. Saludos! esa es la parte complicada manejar la base de datos, las dos posibles cosas que se me ocurren ahora implican generar 4096 keys por cada busqueda de 2**40: con esto quiero decir que puedes 1- convertir cada 64 bits de la base de datos original en decimales, ordenar los numeros ,para facilitar su busqueda, en el script de busqueda serian 4096 keys para asegurarnos que no nos saltemos una posible concidencia: ejemplo: si tenemos esta porcion de bits obtenidos en el script de busqueda 1110000011011000111000000100000101100010010010010000101111111110001011100101001 0011010101111010001010101100101000101001001101001100101000011101010011001011100 100011100111001010101011101110100110000010 para encontrar 1000010111111111000101110010100100110101011110100010101011001010= 9655461591863929546 (presente en db ordenada) debemos tranformar en numeros porciones de 64 bits, 64 veces 11100000110110001110000001000001011000100100100100001011111111100010111001010010011010101111010001010101100101000101001001101001100101000011101 010011001011100100011100111001010101011101110100110000010 1 11000001101100011100000010000010110001001001001000010111111111000101110010100100110101011110100010101011001010001010010011010011001010000111010 10011001011100100011100111001010101011101110100110000010 11 10000011011000111000000100000101100010010010010000101111111110001011100101001001101010111101000101010110010100010100100110100110010100001110101 0011001011100100011100111001010101011101110100110000010 64 veces o hasta coincidir 11100000110110001110000001000001011000100100100 10000101111111110001011100101001001101010111101000101010110010100010100100110100110010100001110101001100101110010001110011100101010101110111010 0110000010 asi asegurarnos que no nos saltemos una posible concidencia. es decir 64 busquedas en la base de datos ordenada y 4096 keys para cubrir un rango de 2**40 2: puedes usar bf usando como referencia el metodo 1, almacenando cada 64bits. pero una cosa es la teoria y otra la practica, ni idea de que tan eficiente pueda ser.
|
|
|
Please if you can show us the family relatives for this public key 02b5c3acff8a44ff0948bf094d949d1d39734318a752e6215169a835f72314a79a I have a feeling that you can't. 5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip7CKpH45g4cagxfKaE KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLz3frbdQx3dhXTqd5
|
|
|
it is more likely to find a privatekey-publickey pattern than a pattern between privatekey-h160. For mathematical reasons, pubkeys are in their most "basic" section a residue of P, so you could go in scale reducing the search range where you get more matches. This is a vague idea of a possible search. #@mcdouglasx import secp256k1 as ice import random
print("vanity search...")
#03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852 Target_A = "633cbe3e"
min = 600000000000000000000000000000000000000 max = 1370000000000000000000000000000000000000
while True:
r = random.randint(min, max) A0 = ice.scalar_multiplication(r) A1 = A0.hex() dupuba = A1[2:66] puba = str(dupuba)
if puba.startswith((Target_A)):
print("Match") A2 = ice.to_cpub(A1) data = open("vanity.txt","a") data.write("Pk:"+" "+str(r)+"\n") data.write("cpub:"+" "+str(A2)+"\n"+"\n") data.close()
|
|
|
I have developed a new method! I have studied it 100% and it works. My calculations tell me that before the end of January 2024 I will have unlocked puzzle #130 (if someone else doesn't solve it before). For registration, I will send it to this address BTC bc1qxs47ttydl8tmdv8vtygp7dy76lvayz3r6rdahu
This message will not have edits for its validity.
If you want to question it, do it on February 1, 2024 if I don't send it to that address.
happy new year in advance, see you in February!, if life allows me.
blessings for all.
In summary, my search is 70%, I do not intend to take up your time waiting for a precise date, I do not take external factors into the equation when calculating the time, I live in an underdeveloped country where electrical failures are frequent, I have an i5 4GB ddr3, although I want to, I can't go faster, it is what it is, I got excited with the calculations and completely omitted the external factors, I have earned the criticism and I understand it, but it does not offend me, because my path continues. Based on mcdouglas' post-claim comments, I can feel his frustration when he encountered EC's punch in face! He's been tricked and overpowered by the Illusion-of-Mastery, which made him post such a big claim. I am not demotivating him, no no!! I am happy about him that he is learning good maths here. Trying to divide like 58.5 and figuring what half would be, good good, great!!!! Majority of guys here possibly have been through lots of similar curve punches here. Someone rightly figured out here that EC cannot be broken from inside, whatsoever!!!! The only thing attached to it from outside is its point at infinity, WHICH CAN'T BE TOUCHED DUE TO BEING AT INFINITY SOMEHOW I GUESS, OR MAY BE IDK!! Whatever secret mcdouglasx has, I am sure many of guys here have already tried & tested and accordingly slapped in ass by EC! SORRY FOR THAT!! The possibilities of EC being broken by any BTC puzzle enthusiast are very slim! Because there are giant research & security institutes (I know few of them personally visited as well) which are rigorously and systematically approaching towards the solutions to ECDLP. I bet Satoshi must have a good laugh today, Cheers, it is 1st of Feb 24!!!
no, I have not broken ecc, I never said it, otherwise, it would not take more than a month to find a key, breaking ecc is creating a formula that allows you to obtain the private key in an instant, this is not it, it is just a system of search faster than the already known ones, and it is easy to verify if a search code works or not, so I am not wrong. edit: It has not yet been proven that the ECDLP is computationally intractable, therefore in mathematics we cannot consider something impossible that you cannot prove to be impossible. An algorithm has not been found that can solve the ECDLP in polynomial time, but it cannot be said that it does not have such a solution. You can solve a problem in two ways: 1= solution. 2= no solution. If you are going to come and tell me that ECDLP is unbreakable in polynomial time, publish the formula that shows that this is the case, otherwise don't see something as impossible just because it is difficult, if all humans had that way of thinking, society would It was still in the prehistoric era. Yes, there are giant institutions studying this, this does not mean that you have to feel less than them, but that you can learn from them and overcome them. And I conclude that if you try and fail, you will have learned something, if you consider yourself incapable you only gain ignorance.
|
|
|
Anyone know how to get the private key for 58.5?
import bitcoin
target= 585
Div=10
N=115792089237316195423570985008687907852837564279074904382605163141518161494337
a=bitcoin.inv(Div,N)
b= target*a % N
print("target r:",target/Div) print("pk:",b) 58.5 PK 0.5 57896044618658097711785492504343953926418782139537452191302581570759080747169 pk 58 58 58.5 57896044618658097711785492504343953926418782139537452191302581570759080747169 + 58 = 57896044618658097711785492504343953926418782139537452191302581570759080747227 in hex 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20db What about 58.51?) 5851/100 import bitcoin
target= 5851
Div=100
N=115792089237316195423570985008687907852837564279074904382605163141518161494337
a=bitcoin.inv(Div,N)
b= target*a % N
print("target r:",target/Div) print("pk:",b)
|
|
|
|