Zmiana obliczania ord oraz dodanie funkcju mysqrt do duzych liczb

Signed-off-by: Marcin Woźniak <y0rune@aol.com>

8-lab/szyfrowanie-krzywe.rb

@@ -11,7 +11,7 @@
 load '../module.rb'
 
 def main
-  k = 2048
+  k = 300
   m = 73
   n = m + SecureRandom.random_number(0..1000000)
   u = SecureRandom.random_number(30..50)

Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+ruby "3.0.0"
+
+gem 'thwait', '~> 0.2.0'

module.rb

@@ -1,12 +1,12 @@
 #!/usr/bin/ruby
 # coding: utf-8
 
-#####################################
+##################################################################################
 #
 # Marcin Woźniak
 # s434812
 #
-#####################################
+##################################################################################
 
 require 'openssl'
 require 'securerandom'
@@ -14,13 +14,13 @@ require 'prime'
 require 'thread'
 require 'thwait'
 
-####################################
+#################################################################################
 # Funkcja nwd(a,b)
 #
 # Oblicza nwd podanych liczb np
 # nwd(10,14) => 2
 #
-####################################
+#################################################################################
 def nwd(a, b)
   if a == 0
     return false
@@ -28,14 +28,14 @@ def nwd(a, b)
   b == 0 ? a : nwd(b, a.modulo(b))
 end
 
-####################################
+#################################################################################
 # Funkcja extended_euklides(a,b)
 #
 # Oblicza rozszerzony algorytm euklidesa
 # zwracajac u,v
 # extended_euklides(10,14) => [3, -2]
 #
-#####################################
+##################################################################################
 def extended_euklides(a, b)
   return 1, 0 if b == 0
 
@@ -45,13 +45,13 @@ def extended_euklides(a, b)
   return t, s - q * t
 end
 
-####################################
+#################################################################################
 # Funkcja random_gen_Zn(k,n)
 #
 # Oblicza losowy element z zbioru Z_n
 # random_gen_Zn(1,10) => 1
 #
-####################################
+#################################################################################
 def random_gen_Zn(k,n)
 
   if n == 0
@@ -79,7 +79,7 @@ def random_gen_Zn(k,n)
   end
 end
 
-####################################
+#################################################################################
 # Funkcja reciprocal_Phi_p(n,p)
 #
 # Oblicza odwrotnosc w grupie Phi(n)
@@ -88,7 +88,7 @@ end
 # Funkcja oblicza 10^(-1) mod 7 = 5
 # Dowód: 5 * 10 mod 7 = 1
 #        a^(-1) * a mod p = e = 1
-####################################
+#################################################################################
 def reciprocal_Phi_p(n,p)
   u = extended_euklides(n,p)[0]
   v = extended_euklides(n,p)[1]
@@ -106,13 +106,13 @@ def reciprocal_Phi_p(n,p)
   end
 end
 
-####################################
+#################################################################################
 # Funkcja betterExponentiation(x,k,n)
 #
 # Oblicza potęgi x^k mod n
 # betterExponentiation(8,2,30) => 4
 #
-####################################
+#################################################################################
 def betterExponentiation(x,k,n)
   if n == 0
     return false
@@ -139,14 +139,14 @@ def betterExponentiation(x,k,n)
   end
 end
 
-####################################
+#################################################################################
 # Funkcja remSqEuler(a,b)
 #
 # Sprawdzenie czy element a jest
 # reszta kwadratowa w Z_p
 # remSqEuler(3,13) => true
 #
-####################################
+#################################################################################
 def remSqEuler(a,p)
   ans = betterExponentiation(a,(p-1)/2,p)
   if ans == 1 && primalityTest(p)
@@ -156,10 +156,10 @@ def remSqEuler(a,p)
   end
 end
 
-####################################
+#################################################################################
 # Funkcja squareRootFp(a,b)
 #
-####################################
+#################################################################################
 def squareRootFp(p,b)
   if p % 4 == 3 && remSqEuler(p,b) == true
       a = betterExponentiation(b, (p+1)/4, p)
@@ -167,13 +167,13 @@ def squareRootFp(p,b)
   end
 end
 
-####################################
+#################################################################################
 # Funkcja primalityTest(n)
 #
 # Test pierwszości
 # primalityTest(13) => true
 #
-####################################
+#################################################################################
 def primalityTest(n)
   if n == 1
     return false
@@ -194,12 +194,12 @@ def primalityTest(n)
   return true
 end
 
-####################################
+#################################################################################
 # Funkcja specyficPrimaryNumber
 #
 # Generuje potrzebne do pierwszego
 # ElGamala
-#####################################
+##################################################################################
 def specyficPrimaryNumber
   p = 0
   q = 0
@@ -224,13 +224,13 @@ def specyficPrimaryNumber
   end
 end
 
-####################################
+#################################################################################
 # Funkcja generator(a,b)
 #
 # Generuje generator dla podanych liczb
 # do RSA i ElGamala
 #
-####################################
+#################################################################################
 def generator(p,q)
   while true
     g = SecureRandom.random_number(2..p-2)
@@ -242,64 +242,64 @@ def generator(p,q)
   end
 end
 
-####################################
+#################################################################################
 # Funkcja generate(n)
 #
 # Generator liczby losowej o podanej
 # n-bitowej liczbie
 #
-####################################
+#################################################################################
 def generate(n)
   return `openssl prime -generate -bits '#{n}'`.gsub(/\n$/, '').to_i
 end
 
 #### MODULE 2 ####
 
-####################################
+#################################################################################
 # Funkcja returnRownanie(a,b,p)
 #
 # Zwraca ładniejszą formę równania
 #
-####################################
+#################################################################################
 def returnRownanie(a,b,p)
   puts
   puts "Równanie krzywej jest równe: " + "Y^2 = X^3+" + a.inspect + "X+" + b.inspect + " mod "+ p.inspect
   puts
 end
 
-####################################
+#################################################################################
 # Funkcja delta(a,b,p)
 #
 # Oblicza deltę dla krzywej
 # eliptycznej o podanych parametrach
 # a,b nad ciałem F_p
 #
-####################################
+#################################################################################
 def delta(a,b,p)
   d = ((4 * betterExponentiation(a,3,p) % p) + (27 * betterExponentiation(b,2,p) % p)) % p
   return d
 end
 
-####################################
+#################################################################################
 # Funkcja rownanieKrzywej(a,b,p,x)
 #
 # Oblicza wartość fx dla podanej
 # krzywej eliptycznej o podanych
 # parametrach a,b,p,x
 #
-####################################
+#################################################################################
 def rownanieKrzywej(a,b,p,x)
   fx = ((betterExponentiation(x,3,p) + (a * x) % p + b % p) % p) % p
   return fx
 end
 
-####################################
+#################################################################################
 # Funkcja generatorKrzywej(p)
 #
 # Generuje krzywą o podanej liczbie
 # pierwszej p.
 #
-####################################
+#################################################################################
 def generatorKrzywej(p)
   a = 0
   b = 0
@@ -328,14 +328,14 @@ def generatorKrzywej(p)
   end
 end
 
-####################################
+#################################################################################
 # Funkcja punktNaKrzywej(a,b,p)
 #
 # Zwraca losowy punkt na krzywej
 # eliptycznej o podanych wartościach
 # a,p,p.
 #
-####################################
+#################################################################################
 def punktNaKrzywej(a,b,p)
   if (delta(a,b,p) != 0) &&  (p % 4 == 3)
     while true
@@ -349,13 +349,13 @@ def punktNaKrzywej(a,b,p)
   end
 end
 
-####################################
+#################################################################################
 # Funkcja czyPunktNalezyDoKrzywej(a,b,p,x,y)
 #
 # Sprawdza czy podany punkt nalezy
 # do krzywej eliptycznej.
 #
-####################################
+#################################################################################
 def czyPunktNalezyDoKrzywej(a,b,p,x,y)
   fx = rownanieKrzywej(a,b,p,x)
 
@@ -366,23 +366,23 @@ def czyPunktNalezyDoKrzywej(a,b,p,x,y)
   end
 end
 
-####################################
+#################################################################################
 # Funkcja punktPrzeciwny(x,y)
 #
 # Zwraca przeciwny punkt dla (x,y)
 #
-####################################
+#################################################################################
 def punktPrzeciwny(x,y)
   return x,-y
 end
 
-####################################
+#################################################################################
 # Funkcja sumaPunktow(a,b,p,x1,y1,x2,y2)
 #
 # Oblicza sumę punktów na krzywej
 # eliptycznej dla podanych a,b,p,x1,y1,x2,y2
 #
-####################################
+#################################################################################
 def sumaPunktow(a,b,p,x1,y1,x2,y2)
   # 0 - element neutrany --> P + 0 = P
   if (x1 == "e" && y1 == "e" )
@@ -418,12 +418,12 @@ end
 
 #### MODULE 3 ####
 
-####################################
+#################################################################################
 # Funkcja wielokrotnoscPunktu(a,b,p,n,x,y)
 #
 # Oblicza wielokrotność punktów np.
 # 2n = n + n
-####################################
+#################################################################################
 def wielokrotnoscPunktu(a,b,p,n,x,y)
   punktQ = [x,y]
   punktR = ["e","e"]
@@ -439,22 +439,52 @@ def wielokrotnoscPunktu(a,b,p,n,x,y)
   return punktR
 end
 
-####################################
+#################################################################################
+# Funkcje mysqrt(n)
+#
+# Oblicza wartość pierwiastka z dużych
+# liczb
+#
+# Źródło: https://codegolf.stackexchange.com/questions/85555/the-fastest-square-root-calculator
+#################################################################################
+def mysqrt(n)
+    highest = 1
+    sqrt_highest = 1
+    while highest < n
+        highest <<= 2
+        sqrt_highest <<= 1
+    end
+
+    n /= highest+0.0
+
+    result = (n/4) + 1
+    result = (result/2) + (n/(result*2))
+    result = (result/2) + (n/(result*2))
+
+    return result*sqrt_highest
+end
+
+#################################################################################
 # Funkcja liczenieOrd(p)
 #
 # Oblicza wartość ord dla podanych p.
-####################################
+# Wynik jest zaokrąglany do podłogi, jeżeli chodzi o `mysqrt(p).to_i`
+#
+# Np.
+# 2 * mysqrt(8) => 5.68756145526057
+# (2 * mysqrt(8)).to_i => 5
+#################################################################################
 def liczenieOrd(p)
-  ord = p + 1 - 2 * squareRootFp(p,p).to_i
+  ord = (p + 1 - (2 * mysqrt(p)).to_i ) % p
   return ord
 end
 
-####################################
+#################################################################################
 # Funkcja generowanieKluczyElGamalKrzywaEliptyczna(k)
 #
 # Generatoruje klucz publiczny
 # oraz prywatny.
-####################################
+#################################################################################
 def generowanieKluczyElGamalKrzywaEliptyczna(k)
   while true
   p = generate(k)
@@ -481,10 +511,10 @@ def generowanieKluczyElGamalKrzywaEliptyczna(k)
   end
 end
 
-####################################
+#################################################################################
 # Funkcja algorytmKodowania(a,b,p,m,n,u)
 #
-####################################
+#################################################################################
 def algorytmKodowania(a,b,p,m,n,u)
   if (m < n) && (p > n*u)
     for i in 1..u
@@ -500,22 +530,22 @@ def algorytmKodowania(a,b,p,m,n,u)
   return [x,y]
 end
 
-####################################
+#################################################################################
 # Funkcja algorytmDeKodowania(a,b,p,x,y,n,u)
 #
 # Zwraca odszyfrowaną wiadomość.
-####################################
+#################################################################################
 def algorytmDeKodowania(a,b,p,x,y,n,u)
   m = (x - 1) / u
   return m
 end
 
-####################################
+#################################################################################
 # Funkcja szyfrowanieElGamala(m,n,u,a,b,p,px,py,qx,qy)
 #
 # Koduje wiadomość na punkt na krzywej
 # eliptycznej.
-####################################
+#################################################################################
 def szyfrowanieElGamala(m,n,u,a,b,p,px,py,qx,qy)
   c = algorytmKodowania(a,b,p,m,n,u)
   puts "Wiadomość na prostej jako punkt #{c.inspect}"