y0rune/KRzA
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Zmiana obliczania ord oraz dodanie funkcju mysqrt do duzych liczb

Browse Source 
Signed-off-by: Marcin Woźniak <y0rune@aol.com>
This commit is contained in:
Marcin Woźniak 2021-01-01 23:03:03 +01:00
parent 0caad16b83
commit ec4a4773cc
Signed by: y0rune
GPG Key ID: F204C385F57EB348
3 changed files with 88 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
8-lab/szyfrowanie-krzywe.rb
View File

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

4
Gemfile Normal file
View File

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

136
module.rb
View File

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