Only MATH is the way of Private Key

[ElDalmatino]

***********

[1714585008]

1714585008

[1714585008]

1714585008

[1714585008]

1714585008

[hexan123]

The topic is good but I didn't see the light. Write something more.

[ABCbits]

And how long it's needed to get a private key from a public key using your math formula and modern GPU?

[hexan123]

Describe how you find the private key from the public key. Is it a brute force method or can you calculate it without checking all the combinations. Can you recognize the parity of the key or whether it has a positive or negative value?

[satashi_nokamato]

Please if you can show us the family relatives for this public key

Code:

02b5c3acff8a44ff0948bf094d949d1d39734318a752e6215169a835f72314a79a

I have a feeling that you can't.

[hexan123]

Are you explaining it so as not to say anything These brothers are keys with the same value "x"? Good luck counting your keys.

[hexan123]

My English is also through a translator. I don't know how it works, but I think you can post the photos here: https://www.talkimg.com/

[krashfire]

OK i would like to say, till now i get all the puzzles from 1 to 65 faster than let´s say kangaroo, and the code i have, is write in python !!

I would like to put a picture here in, so maybe it explain more, but i don´t know how to do it.

My maths. but something is off. i still feel its not right somewhere.

Code:

 import random
import hashlib
from sage.crypto.util import ascii_to_bin
from sage.arith.misc import random_prime
from sage.crypto.util import ascii_to_bin
from sage.crypto.util import bin_to_ascii

p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
n = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141

E = EllipticCurve(GF(p), [0, 7]) 

r = 0x
s = 0x
z = 0x


G = E.point( (0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798,0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8))   # Base point

def egcd(a, b):

    if a == 0:

        return (b, 0, 1)

    else:

        g, y, x = egcd(b % a, a)

        return (g, x - (b // a) * y, y)

def modinv(a, m):

    g, x, y = egcd(a, m)

    if g != 1:

        raise Exception('modular inverse does not exist')

    else:

        return x % m


def make_public(r, s, z):
    R = E.lift_x(Integer(r))
    w = int(modinv(s, n))
    u1 = int((z * w) % n)
    u2 = int((r * w) % n)
    u_n2 = modinv(u2, n) % n
    u_n1 = - u1 * modinv(u2, n) % n
    
    pub = u_n1 * G + u_n2 * R
    pub2 = u_n1 * G + u_n2 * (-R)
    return pub, pub2



def calc_u(r, s, z):
    mod_s = modinv(s, n) % n
    u1 = mod_s * z % n
    u2 = mod_s * r % n
    print("u1 =", hex(u1), "n-u1 =", hex(n - u1))
    print("u2 =", hex(u2), "n-u2 =", hex(n - u2))
    return u1, u2
u1, u2 = calc_u(r, s, z)

def verify(r, s, z, pub, k):
    w = int(modinv(s, n))
    u1 = int((z * w) % n)
    u2 = int((r * w) % n)
    D = u1 * G + u2 * pub
    x, y = D.xy()
    x = int(x)

    if (r % n) == (x % n):
        print(f"Signature k matches: {hex(k)} ")
        return True
    else:
        print(f"Signature k is invalid {hex(k)} ")
        return False

# Calculate the modular inverse of s (w = s^(-1) mod n)
g, x, y = egcd(s, n)
w = x % n

def find_k(r, s, z, pub):
    # Step 1: Calculate w = s^(-1) mod n
    w = int(modinv(s, n))
    
    # Step 2: Calculate u1 and u2
    u1 = int((z * w) % n)
    u2 = int((r * w) % n)
    
    # Step 3: Recover the elliptic curve point R
    R = u1 * G + u2 * pub
    
    # Extract x-coordinate from R
    x_R, _ = R.xy()
    x_R = int(x_R)
    
    # Calculate k
    k = (x_R - z) * modinv(w, n) % n
    print("k:",k)
    
    return k

# Call the function to find k
k = find_k(r, s, z, pub1)
print("Found k:", hex(k))

pub1, pub2 = make_public(r, s, z)
print("public_key1", pub1)
print("pub1_x=", hex(pub1.xy()[0]))
print("public_key2", pub2)
print("pub2_x=", hex(pub2.xy()[0]))
print("Step 1: Calculate g, x, y using extended Euclidean algorithm")
print("g:", hex(g))
print("x:", hex(x))
print("y:", hex(y))
print("Step 2: Calculate w (modular inverse of s)")
print("Calculated w:", hex(w))
print()


def find_k_bruteforce(r, s, z, pub):
    i = 1
    while True:
        k_candidate = (r * i + z) * modinv(s, n) % n
        
        # Verify the signature using the candidate k
        if verify(r, s, z, pub, k_candidate):
            print("Found k:", hex(k_candidate))
            break
        else:
            print(f"Attempt {i}: Incorrect k value {hex(k_candidate)}")
        
        i += 1  # Increment the attempt counter

# Call the function to find k using brute force
find_k_bruteforce(r, s, z, pub1)

def find_private_key(r, s, z, k, pub):
    # Calculate w = s^(-1) mod n
    w = int(modinv(s, n))
    
    # Calculate u1 and u2
    u1 = int((z * w) % n)
    u2 = int((r * w) % n)
    
    # Recover the elliptic curve point R
    R = u1 * G + u2 * pub
    
    # Extract x-coordinate from R
    x_R, _ = R.xy()
    x_R = int(x_R)
    
    # Calculate private key d
    d = (k * x_R - z) * modinv(r, n) % n
    
    return d

def find_private_key_bruteforce(r, s, z, k, pub, i):
    k_candidate = (r * i + z) * modinv(s, n) % n
    
    # Calculate private key d
    d = (k_candidate * r - z) * modinv(k_candidate, n) % n
    
    return d

# Call the function to find k using the formula-based approach
k_formula = find_k(r, s, z, pub1)
d_formula = find_private_key(r, s, z, k_formula, pub1)
print("Private key (formula-based):", hex(d_formula))

# Call the function to find k using brute force
k_bruteforce = find_k_bruteforce(r, s, z, pub1)
i_bruteforce = 1
d_bruteforce = find_private_key_bruteforce(r, s, z, k_bruteforce, pub1, i_bruteforce)
print(f"Private key (brute-force attempt {i_bruteforce}):", hex(d_bruteforce))

guessed_k_values = []
i = 1

while True:
    k = (r * i + z) * modinv(s, n) % n
    # Calculate R using the guessed k value
    guessed_R = k * G
    guessed_k_values.append((i, k, guessed_R))

    # Check if the guessed R value matches the original r value
    if guessed_R.xy()[0] == r:
        print(f"The correct k value ({k}) for iteration {i} is found.")
        # Calculate the private key using the correct k value
        d_bruteforce = find_private_key_bruteforce(r, s, z, k, pub1, i)
        print(f"Corresponding private key: {hex(d_bruteforce)}")
        break  # Exit the loop if the correct k is found

    i += 1  # Increment the iteration counter

[WanderingPhilospher]

My English is also through a translator. I don't know how it works, but I think you can post the photos here: https://www.talkimg.com/

OP, yes, you can use https://www.talkimg.com/, and upload your picture there.

After you upload it, copy the "Direct image link"; the link to your image.

Come back to this forum and make a post.

If you copied your image link that you uploaded on talkimg.com, just paste it where you want it, in your message/post.

Like this:




And now your picture should be posted.

[hexan123]

OP you promised to post screenshots.

[WanderingPhilospher]

Best visual representation, that I can come up with, based on what's been said so far.



Four octagons, in the shape of a square. I took this as 2x2, stacked.

The yellow dots represent the 16 points that "touch nothing" and the green dots represent the 16 points that do "touch something".

[satashi_nokamato]

You know, if you guys share something more than a few dots connected by a few lines, we could determine if you have found a breakthrough or not.
But if you want to play with shapes, you could search mandelbrowser, install it and enjoy. Otherwise provide something more.

[ecdsa123]

Come on, genius, let's have a laugh together. Human invention is highly desirable, but we often confuse what we know with what we would like. Perhaps the Pascal's triangle would be a better suggestion?

[ElDalmatino]

Come on, genius, let's have a laugh together. Human invention is highly desirable, but we often confuse what we know with what we would like. Perhaps the Pascal's triangle would be a better suggestion?

Keep on laughting my friend. But numbers never lie.

This can be delated or closed from the moderator, i have nothing to say more. 

[mcdouglasx]

Please if you can show us the family relatives for this public key

Code:

02b5c3acff8a44ff0948bf094d949d1d39734318a752e6215169a835f72314a79a

I have a feeling that you can't.

5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip7CKpH45g4cagxfKaE
KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLz3frbdQx3dhXTqd5

[Cricktor]

Please if you can show us the family relatives for this public key

Code:

02b5c3acff8a44ff0948bf094d949d1d39734318a752e6215169a835f72314a79a

I have a feeling that you can't.

5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip7CKpH45g4cagxfKaE
KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLz3frbdQx3dhXTqd5

Interesting, care to elaborate how you found the private key represented by both WIFs? The hex representation of the private key is:
0000000000000000000000000000000000000000000000008000000000000001
(zeros greyed out, my old eyes almost missed the bit responsible for the hex 8)

Maybe there are tables of all two-bit private keys already generated and more...


OP, what's the reason to overwrite your original post and other removals in your thread? Fortunately it's still visible here and with some more digging your other removals, too. Did you get cold feet or are otherwise embarrassed?

[ElDalmatino]

No special reason when the topic goes in the way

Come on, genius, let's have a laugh together. Human invention is highly desirable, but we often confuse what we know with what we would like. Perhaps the Pascal's triangle would be a better suggestion?

Maybe it´s better to stop it, cold feet never, but some here in the board think they own the knowledge !
And i have figure out, when you find some "thing", maybe better to "be quiet", like my fan !

Last from me, all is about sections, nothing more.
And every section has his regular and his contra, if you know the distance between the sections, you can calculate with "simple math" the corresponding value.
The whole PK Universe is not 2^256 it´s way more smaller, but has different variants, that you can find in the individual sectors, if you know how (that´s why dividing is for some impossible).

And now, let´s laugh together.

[satashi_nokamato]

Please if you can show us the family relatives for this public key

Code:

02b5c3acff8a44ff0948bf094d949d1d39734318a752e6215169a835f72314a79a

I have a feeling that you can't.

5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip7CKpH45g4cagxfKaE
KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLz3frbdQx3dhXTqd5

Nice, now can you show us the other 15 points related to that one, which according to Op touch nothing?

[stilichovandal]

No special reason when the topic goes in the way

Come on, genius, let's have a laugh together. Human invention is highly desirable, but we often confuse what we know with what we would like. Perhaps the Pascal's triangle would be a better suggestion?

Maybe it´s better to stop it, cold feet never, but some here in the board think they own the knowledge !
And i have figure out, when you find some "thing", maybe better to "be quiet", like my fan !

Last from me, all is about sections, nothing more.
And every section has his regular and his contra, if you know the distance between the sections, you can calculate with "simple math" the corresponding value.
The whole PK Universe is not 2^256 it´s way more smaller, but has different variants, that you can find in the individual sectors, if you know how (that´s why dividing is for some impossible).

And now, let´s laugh together.

I see what you mean here, I thought it was difficult to find distance between individual sectors and also I could not find a way to differentiate sectors.

[hexan123]

Every time I count I get hexan, not octagon. Why ?