Öffentlicher Schlüsselgenerator in Python (SECP256K1-Kryptographie mit elliptischen Kurven) ⇐ Python

[Guest]

Ich bin derzeit neu in Python und Kryptographie. Ich versuche, manuell (ohne entsprechende Bibliotheksnutzung) aus einem zufällig generierten privaten Schlüssel einen öffentlichen Schlüssel der elliptischen Kurve SECP256K1 zu erstellen, wie ich erfahren habe. Die Methode zur Generierung des privaten Schlüssels ist kostenlos. Was zählt, ist der Prozess, der daraus den öffentlichen Schlüssel macht.
Das habe ich.

Code: Select all

import random
import os
import time
import hashlib

def generate_private_key():
global P
while(True):
key=str(random.random())+str(os.urandom(100))+str(time.time())
key=hashlib.sha256(key.encode())
key=int(key.hexdigest(),16)
if(P>key):
return key

def generate_public_key(private_key):
global G
global P
bit=list(bin(private_key)[2:])
point=(0,0)
for i in bit:
if i=='0':
point=point_double(point, P)
elif i=='1':
point=point_double(point, P)
point=point_add(point,G, P)
return point

#Extended Euclidean Algorithm
def inverse(b,n):
r1=n
r2=b
t1=0
t2=1
while(r2>0):
q=r1//r2
t=t1-q*t2
t1=t2
t2=t
r=r1-q*r2
r1=r2
r2=r
if t1>0: return t1
else: return t1+t2

def point_double(point, P):
(x,y)=point
lam=3*(x**2)*inverse(2*y,P)
xsum=lam**2-x*2
ysum=lam*(x-xsum)-y
return xsum%P, ysum%P

def point_add(p1, p2, P):
(x1,y1)=p1
(x2, y2)=p2
if x1==x2 and y1==y2:
return point_double(p1)

lam=(y2-y1)*inverse(x2-x1, P)
xsum= lam**2-(x1+x2)
ysum= lam*(x1-xsum)-y1
return xsum%P, ysum%P

P=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F

G = (0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

private_key=generate_private_key()

#my private key
print(hex(private_key))

#public key
print(generate_public_key(private_key))

Ich vergleiche das Ergebnis meines Codes mit dem Ergebnis dieser Website: https://paulmillr.com/noble/
Ich kann jedoch nicht denselben öffentlichen Schlüssel aus dem erhalten Gleicher privater Schlüssel.
Das ist der Prozess, den ich denke:

• Erstellen Sie einen zufälligen privaten Schlüssel.
  Erstellen Sie einen öffentlichen Schlüssel mit (privatem Schlüssel * einem festen Punkt G)

2-1. Verwenden Sie die Double-and-Add-Methode, um zu vermeiden, dass G [privater Schlüssel] mal addiert wird, da beide Zahlen dafür zu groß sind.
2-2. Auf alle Zusätze folgt (mod P). P ist ebenfalls eine sehr große Zahl, fest.
2-3. Nicht alle Unterteilungen sind im wahrsten Sinne des Wortes Unterteilungen. Es ist eine Umkehrung von (mod P). Das Lösen der Umkehrung von (mod P) erfolgt mithilfe des erweiterten euklidischen Algorithmus ('inverse'-Funktion im Code).
Da ich nicht sicher war, wo ich das '%P' einfügen sollte Code, ich habe an mehreren Stellen versucht, „%P“ einzufügen, hatte aber bisher kein Glück und landete beim aktuellen Code. Ich konnte das Ergebnis nicht Schritt für Schritt testen, da die Anzahl und der Prozessaufwand zu groß waren.