diff --git a/8-lab/szyfrowanie-krzywe.rb b/8-lab/szyfrowanie-krzywe.rb index 9d3b88f..b0abcff 100755 --- a/8-lab/szyfrowanie-krzywe.rb +++ b/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) diff --git a/Gemfile b/Gemfile new file mode 100644 index 0000000..80916ed --- /dev/null +++ b/Gemfile @@ -0,0 +1,4 @@ +source "https://rubygems.org" +ruby "3.0.0" + +gem 'thwait', '~> 0.2.0' diff --git a/module.rb b/module.rb index bfc3e10..34082d4 100755 --- a/module.rb +++ b/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}"