elliptic-curves-fq 2.2.1

ECC Library

Bibliothek zur Aritmetik elliptischer Kurven

Beschreibung :pencil:

Diese Bibliothek bietet Funktionalitaeten fuer elliptische Kurven ueber endlichen Koerpern $F_{p^n}$. Sie ermoeglicht unter anderem Berechnungen auf elliptischen Kurven.

Verwendung :computer:

Um die Funktionalitaeten dieser Bibliothek zu nutzen, koennen Sie die folgenden Schritte ausfuehren:

1. Installation :inbox_tray:: Sie koennen die elliptische Kurven Bibliothek mit pip installieren:

   pip install elliptic-curves-fq
   

2. Importieren des Paketetes: Hier wird gezeigt, wie man die Bibliothek verwenden kann.

   # Erforderliche Module importieren
   import elliptic_curves_fq
   

3. Klassen, Funktionen und ihre Verwendungen :gear::

   • start_point Stellt den Startpunkt der sicheren elliptischen Kurve ueber dem schnell implementierten Koerper $F_{47^{46}}$ mit integrierter Aretmetik.

     from elliptic_curves_fq import start_point
     # Beispielcode fuer start_point
     Startpunkt = start_point()
     print(Startpunkt.on_Curve())
     privater_Schluessel = 1000000
     oeffentlicher_Schluessel = Startpunkt * privater_Schluessel
     test = oeffentlicher_Schluessel + Startpunkt
     

   • Fp: Stellt ein endlichen Koerper $F_p$ bereit und unterstuetzt arithmetische Operationen wie Addition, Subtraktion, Multiplikation, Division und Potenzieren durch Ueberschreiben der vorhandenen Operationen von Python.

     • Parameter:
       • element (int): Ein Element im endlichen Koerper.
       • p (int): Eine Primzahl, die den endlichen Koerper definiert.

     from elliptic_curves_fq import Fp
     # Beispielcode fuer Fp
     p = 23
     element = Fp(7, p)
     print(element)  # Ausgabe: 7
     print(element + 20) # Ausgabe 4
     print(element - 10) # Ausgabe 20
     print(element ** 2) # Ausgabe 3
     

   • get_irreductible_polynomial: Generiert ein irreduziblen Polynoms ueber einem endlichen Koerper $F_{p}$.

     • Parameter:
       • p (int): Die Primzahl, die den endlichen Koerper definiert.
       • n (int): Der Grad des Polynoms.

     from elliptic_curves_fq import get_irreductible_polynomial
     # Beispielcode fuer get_irreductible_polynomial
     p = 17
     n = 3
     poly, attempts = get_irreductible_polynomial(p, n)
     print(poly)  # Ausgabe: [1, 7, 1, 10]
     print(attempts)  # Ausgabe: 3 (Anzahl der Versuche, die benoetigt wurden, um das irreduzible Polynom zu generieren.)
     

   • Fpn: Ermoeglicht das Rechnen mit endlichen Koerpern $F_{p^n}$ und bietet Methoden wie Addition, Subtraktion, Multiplikation, Division und Potenzieren durch Ueberschreiben der vorhandenen Operationen von Python.

     • Parameter:
       • p (int): Eine Primzahl, die $F_p$ definiert.
       • irreducible_poly (list): Ein irreduzibles Polynom ueber diesem Koerper. Definiert den Koerper $F_{p^n}$
       • element (list): Ein Element von $F_{p^n}$.

     from elliptic_curves_fq import Fpn
     # Beispielcode fuer Fpn
     p = 17
     irreducible_poly = [1, 1, 1, 2]  
     element = Fpn(p, irreducible_poly, [1, 2, 3]) 
     print(element)  # Ausgabe: [1, 2, 3]
     print(element + [5,4,3]) #Ausgabe [6, 6, 6]
     print(element * [2,1,3]) #Ausgabe [6, 2, 3]
     print(element ** 5) #Ausgabe [6, 7, 12]
     

   • curve: Ermoeglicht die Arbeit mit elliptischen Kurven ueber endlichen Koerpern $F_{p}$. Eine elliptische Kurve hat die folgende Form $$y^2 = x^3 + ax + b$$

     • Parameter:
       • a (int): Der Koeffizient 'a' der elliptischen Kurve.
       • b (int): Der Koeffizient 'b' der elliptischen Kurve.
       • p (int): Eine Primzahl, die den endlichen Koerper definiert.
       • start_point (list[int,int]): Ein Startpunkt auf der elliptischen Kurve.
       • ord (int): Die Ordnung der Kurve. Wenn die Ordnung nicht bestummen wurde: None
     • Die Koeffizienten a und b werden direkt zu Objekten der Klasse Fp gemacht.

     from elliptic_curves_fq import curve
     # Beispielcode fuer curve
     p = 17
     a = 12  
     b = 6  
     start_point = [8,11]  
     curve = curve(a, b, p, start_point, None)
     print(curve)  # Ausgabe: curve( a = 12, b = 6, p = 17, Startpoint = (8, 11), ord = None)
     

   • curve_Fpn: Ermoeglicht die Arbeit mit elliptischen Kurven ueber endlichen Koerpern $F_{p^n}$.

     • Parameter:
       • a (list): Der Koeffizient 'a' der elliptischen Kurve.
       • b (list): Der Koeffizient 'b' der elliptischen Kurve.
       • p (int): Eine Primzahl, die die Basis fuer den endlichen Koerper $F_p$ ist.
       • irreducible_poly (list): Ein irreduzibles Polynom ueber $F_p$ , welches den Koerper $F_{p^n}$ definiert.
       • start_point (list[list,list]): Ein Startpunkt auf der elliptischen Kurve.
       • ord (int): Die Ordnung der Kurve.
     • Die Koeffizienten a und b werden direkt zu Objekten der Klasse Fpn gemacht.

     from elliptic_curves_fq import curve_Fpn
     # Beispielcode fuer curve_Fpn
     p = 17
     irreducible_poly = [1, 1, 1, 2]  
     a = [1, 12, 8]  
     b = [2, 7, 6]  
     start_point = [[9, 10, 11],[7, 2, 4]]  
     curve = curve_Fpn(a, b, p, irreducible_poly, start_point, None)
     print(curve)  # Ausgabe: curve_Fpn( a = [1, 12, 8], b =[2, 7, 6], p = 17, ir_poly = [1, 1, 1, 2], Startpoint = ([9, 10, 11], [7, 2, 4]), ord = None)
     

   • get_random_curve :game_die:: Ermoeglicht das Erstellen einer neuen zufaelligen Kurve.

     • Parameter:
       • p (int): Eine Primzahl, die den endlichen Koerper definiert.
       • degree (int): Der Grad des irreduziblen Polynom fuer die Kurve.
       • should_print (bool): Ein Parameter, der bestimmt, ob die Kurve gedruckt werden soll.

     from elliptic_curves_fq import get_randomcurve
     # Beispielcode fuer get_random_curve
     p = 17
     degree = 7
     get_randomcurve(p,degree) # Ausgabe unter anderem: Kurve wurde erfolgreich generiert. Hier die Kurve um abzuspeichern. 
     # Kurve = curve_Fpn([15, 5, 14, 5, 3, 10, 16],[11, 10, 7, 8, 13, 4, 4],17,[1, 6, 14, 13, 4, 8, 13, 8],[[10, 15, 9, 13, 7, 2, 6],[6, 0, 12, 15, 2, 1, 12]],None)
     curve = get_randomcurve(p,degree,should_print=False)
     start_point = curve.startpoint 
     

   • Points: Ermoeglicht die Arithmetik elliptischer Kurve und unterstuetzt Operationen wie Punktaddition, Punktvervielfachung und andere Funktionen im Kontext elliptischer Kurven.

     • Parameter:
       • curve (object): Die elliptische Kurve, mit der der Punkt verbunden ist.
       • point (list): Ein Punkt auf der elliptischen Kurve.
     • Der Attribute x und y vom Punkt werden direkt in Objekte der Klassen Fp respektive Fpn umgewandelt.

     from elliptic_curves_fq import Points, curve_Fpn
     
     curve = curve_Fpn([1, 12, 8], [2, 7, 6], 17, [1, 1, 1, 2], [[9, 10, 11],[7, 2, 4]], None)  # Beispielkurve
     point = curve.startpoint 
     point2 = Points([[3, 12, 16], [1, 4, 13]],curve) 
     
     print(point)  # Ausgabe: ([9, 10, 11], [7, 2, 4])
     print(point2) # Ausgabe: ([3, 12, 16],[1, 4, 13])
     print(point + point2 ) # Ausgabe ([12, 8, 1], [1, 0, 5])
     print(point * 3500) #Ausgabe ([8, 8, 2], [11, 11, 2])
     

   • main_schoof : Zur Bestimmer Anzahl der Punkten auf einer bestimmten Kurve ueber dem Koerper $F_{47^{46}}$

     • Parameter:
       • a (numpy array): Paramter a der Kurve
       • b (numpy array): Paramter a der Kurve
       • x (numpy array): x Koordinate eines Puntes auf der Kurve
       • y (numpy array): y Koordinate eines Puntes auf der Kurve
       • cores (int): Zur verfuegung stehenden Cores zur paralelisierung. 8 reichen fuer die maximale Geschwindigkeit.

     from elliptic_curves_fq import get_randomcurve, fast_schooftest_multy_process
     import numpy as np
     q = 47**46
     Curve = get_randomcurve(47,[1]+ [0]*45 + [2])
     a = np.array(Curve.a.value,dtype=int)
     b = np.array(Curve.b.value,dtype=int)
     x = np.array(Curve.startpoint.x.value,dtype=int)
     y = np.array(Curve.startpoint.y.value,dtype=int)
     print(fast_schooftest_multy_process.main_schoof(a,b,x,y,8))
     

   • Gespeicherte Kurven :floppy_disk:: Ich stelle Kurven zur Verfuegung, damit nicht immer eine neue ertsellt werden muss. Alle Kurven bis auf die Kurve P_192 wurden von mir generiert.

     • P_192: Sichere NIST-Kurve ueber Fp mit p ungefaehr 2^192
     • FBillionPowerTo20: Eigene Kurve ueber $F(p^n)$ mit p ungefaehr 1 Billion und n = 20.
     • P991: Eigene Kurve ueber $F(991^3)$. Die Parameter sind zufaellig.
     • P23: Eigene Kurve ueber $F(23^3)$. Die Parameter sind zufaellig.
     • ord353: Eigene Kurve ueber $F(7^3)$. Die Ordnung der elliptischen Kurve ist 353 und somit prim. Jeder Punkt ist ein Generator.
     • testcurvemod5: Eigene Kurve ueber $F(5^3)$.
     • kurzmod5: Eigene kleinste moegliche Kurve ueber $F(5^2)$.
     • Ascii: Eigene Kurve ueber $F(131^8)$.
     • ten_power_12_power_150: Eine spezielle Kurve mit extrem hohen Werten mit p ungefaehr 1 Billion und n = 150

   Die Kurven sind als Funktionen abgespeichert. Jede Funktion hier hat kein Argument, und man erhaelt die zugehoerige Kurve.

   from elliptic_curves_fq import ord353
   #Beispiel Code
   Kurve = ord353()
   startpunkt = Kurve.startpoint
   

4. Weitere Informationen :page_facing_up::

   • Die vollstaendige Dokumentation fuer die Bibliothek finden Sie in meinem GitHub Account im Odrner docs.

License :scroll:

Dieses Projekt steht unter der MIT License - Sehen sie unter LICENSE fuer Details nach.

Ich hoffe, dass Sie diese Bibliothek nuetzlich finden. Bitte zoegern Sie nicht, bei Fragen oder Anregungen mich unter [e-mail] zu kontaktieren.