Applications of knowing the divisibility given two numbers modulo N blindly

[bitcurve]

Well,
This is something I haven't seen anywhere else on the internet, something I thought was impossible, but it sure is possible.

We can determine the divisibility of a given number by another under modulo N blindly, and by "blindly" I mean using addition, subtraction, multiplication and division, and direct comparison. (Aka, +, -, *, / ==)

This means, that under modulo N, we can "break" the ECDLP.
but the question becomes, how to apply this under modulo P? It sure works on modulo any number, but the question is how to apply this on the curve?

Here is an example of the method in python, for checking if a number is divisible by 123456:

* EDIT * The usage of int() is just to convert from a float from the form of 123.0 to 123, you can see all the correct divisible results end up with .0.

N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
N2 = 78074008874160198520644763525212887401909906723592317393988542598630163514318
Z = 55539364884045311247562660492089512137756313339020479813129993372185873536791

P1 = 123456*123
R1 = (P1*N2 % N)
D = int(P1/123456)
R2 = (R1-(Z*D) % N)
if R2 == 0:
    print("Divisible by 123456!")
else:
    print("Not divisible by 123456!")

[mcdouglasx]

Explain your code:
What is the target?
Should it always be 123456?
What are N2 and Z?
Use the

Code:

function
Regards!


edit:
tested, in ecc your code always results in infinity, whether divisible or not.

Code:

import bitcoin
import secp256k1 as ice

#129660898560

o= "020000000000000000000000000000000000000000000000000000000000000000"

target="03c5c23f0ed6fb2a97f9dfbe7d7bcd06859bfbff0cda81fc11ef13d0f60e7ad617"


N2 = 78074008874160198520644763525212887401909906723592317393988542598630163514318
Z = 55539364884045311247562660492089512137756313339020479813129993372185873536791

P1= bitcoin.multiply(target, 123)

R1= bitcoin.multiply(P1, N2)

D= bitcoin.divide(P1, 123456)

R2= ice.point_subtraction(ice.pub2upub(R1), ice.pub2upub(bitcoin.multiply(D, Z))).hex()

A2 = ice.to_cpub(R2)

print(A2)
if A2 in o:
    
    print("True")
else:
    print("False")

Your divisions are standard divisions (using "/") which is incorrect, hence your confusion, in mod N to divide the dividend is multiplied by the modular inverse of the divisor.

the correct form would be:

Code:

import bitcoin

             
N = 115792089237316195423570985008687907852837564279074904382605163141518161494337
N2 = 78074008874160198520644763525212887401909906723592317393988542598630163514318
Z = 55539364884045311247562660492089512137756313339020479813129993372185873536791

Div = 123456
a=bitcoin.inv(Div,N)

P1 = 129660898559*123 %N
print("P1:",P1)

R1 = (P1 * N2) % N
print("R1:",R1)

#div
D = P1 *a % N
print("D:",D)

D1= D*Z % N
print("D1:",D1)

R2 = R1-D1 % N
print("R2:",R2)

if R2 == 0:
    print("¡Divisible by 123456!")
else:
    print("¡Not divisible by 123456!")

[bitcurve]

Indeed, true what you said, if we use modular inverse multiplication instead of normal division it doesn't work (I mean, it works for all points, hence it doesn't detect it = isn't useful):

code example:

N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
N2 = 78074008874160198520644763525212887401909906723592317393988542598630163514318
Z = 55539364884045311247562660492089512137756313339020479813129993372185873536791

def modInv(a, m):
    return pow(a, -1, m)

P1 = 123456*123
R1 = (P1*N2 % N)
D = P1 * modInv(123456, N)
R2 = (R1-(Z*D) % N)
if R2 == 0:
    print("Divisible by 123456!")
else:
    print("Not divisible by 123456!")

[COBRAS]

Indeed, true what you said, if we use modular inverse multiplication instead of normal division it doesn't work (I mean, it works for all points, hence it doesn't detect it = isn't useful):

code example:

N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
N2 = 78074008874160198520644763525212887401909906723592317393988542598630163514318
Z = 55539364884045311247562660492089512137756313339020479813129993372185873536791

def modInv(a, m):
    return pow(a, -1, m)

P1 = 123456*123
R1 = (P1*N2 % N)
D = P1 * modInv(123456, N)
R2 = (R1-(Z*D) % N)
if R2 == 0:
    print("Divisible by 123456!")
else:
    print("Not divisible by 123456!")

I dont understand what is Z and N2


but, if you looking for how to use this on point, see, you czn calc what is a point = 0, or 2 for ex, and then replace numbers  in you code to points coordinates, to points coordinates, identify good result easy.So, if you know how to take this point (R2/  you can crack 2**130 in 65 times divides by 2.
if R2 == 0


edit, your code not work:

Divisible by 123456!: 1 2  9999999 etc