Ethereum: Ecdsa X, Y verification of the coordinate of validity does not seem to work

The Ethereum platform is largely based on the electrical electric curve (ECDSA), in particular the SECP256K1 used for Bitcoin, to secure transactions and ensure data integrity. However, the last study raised concerns about the validity verification process using the X, Y ECDSA coordinate formula.

Understanding the Ecds equation

The ECDSA algorithm uses the following equation to determine the validity of the alleged point on the elliptical curve:

y^2 = x^3 + 7 mod p

Where (x, y) is a point on the curve, and P is a row (i.e. the number of points on the curve associated with this equation).

Problem with verification

In a study published on the Web2.0Calc website, the authors showed how to check if the alleged ECDSA point was valid using Python code. They created the ECDS implementation and used it to generate and verify points on the elliptical curve.

However, after closer control of their code, they noticed that the equation y^2 = x^3 + 7 mod P does not seem to be the right basis for verifying the validity of the alleged point. The authors indicated that this is the equation:

• It is too simple: it only requires a square and a rampart of X and Y, which makes it susceptible to errors.

• Does not take into account all possible cases: there are many other ways to generate points on an elliptical curve, and the current equation does not take into account these changes.

Application

To sum up, the findings of the study suggest that the use of X, Y ECDSA coordinates to verify validity may not be credible. This is due to its simplicity, lack of reliability towards various attacks and the lack of taking into account all possible cases of the elliptical curve.

As a result, programmers and users should be careful, relying on validation methods based on ECDS. It is necessary to confirm points using more advanced techniques that take into account the complexity of elliptical curves.

Recommendations

To solve this problem, we recommend:

• The use of more solid methods of verification, such as those based on a discreet logarithm problem (DLP) or abbreviations.

• Implementation of additional controls and verification to ensure the validity of points before continuing the transaction.

• Maintaining the latest research and development of cryptography.

Example of code

The authors of the study presented the implementation of ECDS in Python to generate and verify points on the elliptical curve. Although this code is not suitable for production, it illustrates the concepts discussed above:

`Python

Import ellipcurve

Def Generate_Point (Krzywa):

Generate a random point (x, y) using curve parameters.

x = random.randint (1, 100)

y = power (x, 3, linen (curve))

Return (X, Y)

def verify_point (point, curve):

Check if a given point is valid on the curve.

for k in the range (linen (curve)):

If POW (K, 3, Len (curve)) == x ** 3 + 7:

Receive truly

return false

Krzywa = EllipticCurve (SECP256K1)

Load an elliptical curve secp256K1.

Generate a random point (x, y).

Point = Generate_Point (curve)

Check if the point is important.

If Verify_Point (point, curve):

print ("point is valid.")

otherwise:

print ("point is incorrect.")

Note that this code is only for educational purposes and should not be used in production. It emphasizes the need for more solid verification methods to ensure the safety and integrity of cryptographic transactions on blockchain platforms.