Works module4

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

.gitignore

@@ -1,3 +1,5 @@
+*.lock
 *.mpv
 *.mkv
 *.mp4
+*.jpg

10-lab/modul4.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/ruby
+# coding: utf-8
+
+##################################################################################
+#
+# Marcin Woźniak
+# s434812
+#
+##################################################################################
+
+########################### Module 4 ############################################
+# Podstawowe operacje na Galois Field GF(2^8)
+# Źródła:
+# * https://people.scs.carleton.ca/~maheshwa/courses/4109/Seminar11/The_Advanced_Encryption_Standard_AES_.pdf
+# * https://cs465.internet.byu.edu/static/lectures/w19/AES.pdf
+# * https://en.wikipedia.org/wiki/Finite_field_arithmetic
+# * https://swarm.cs.pub.ro/~mbarbulescu/cripto/Understanding%20Cryptography%20by%20Christof%20Paar%20.pdf
+# * http://www.cs.man.ac.uk/~banach/COMP61411.Info/CourseSlides/Wk2.2.FinField.pdf
+#################################################################################
+
+#################################################################################
+# Zadanie 1
+# Funkcja suma(a,b) wykorzystujac liczby hex
+#################################################################################
+def suma(a,b)
+  binA = a.to_i(16).to_s(2)
+  binB = b.to_i(16).to_s(2)
+  return (binA.to_i(2) ^ binB.to_i(2)).to_s(16)
+end
+
+#################################################################################
+# Zadanie 2
+# Funkcja xtime(a) wykorzystujac liczby hex
+#################################################################################
+def xtime(a)
+  binA = a.to_i(16).to_s(2)
+  const = "1B"
+
+  dl = binA.length
+  while dl != 8
+    binA = "0" + binA
+    dl = dl + 1
+  end
+
+  if binA[0].to_i == 1
+    binA[0] = ''
+    return suma((binA.to_i(2) << 1 ).to_s(16), const)
+  elsif binA[0].to_i == 0
+    return (binA.to_i(2) << 1 ).to_s(16)
+  end
+end
+
+#################################################################################
+# Zadanie 3
+# Funkcja iloczyn(a,b) wykorzystujac liczby hex
+# {53} • {CA} = {01}
+# {57} • {13} = {fe}
+#################################################################################
+def iloczyn(a,b)
+  solve = "0"
+  binA = a.to_i(16).to_s(2)
+
+  len = binA.length - 1
+  binA.split('').each { |a|
+    if a == "1"
+      tmp = b
+      counter = len
+      while counter != 0
+        tmp = xtime(tmp)
+        counter = counter - 1
+      end
+      solve = suma(tmp.to_i(16).to_s(16), solve)
+    end
+    len = len - 1
+  }
+  return solve
+end
+
+#################################################################################
+# Zadanie 4
+# Funkcja odwrotnosc(a) wykorzystujac liczby hex
+#################################################################################
+def odwrotnosc(a)
+  b = a
+  i = 13
+  const = 1
+  while i > 0
+    if i.to_s(2).to_i & const.to_s(2).to_i == 1
+      tmp = b
+    else
+      tmp = a
+    end
+    b = iloczyn(b,tmp)
+    i = i - 1
+  end
+  return b
+end

5-rsa/TEST-WIEDZY-zad2.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/ruby
+# coding: utf-8
 
 ######################################
 #
@@ -7,9 +8,11 @@
 #
 #####################################
 
-load 'modul1.rb'
+load '../module.rb'
 n=27558470307440807219575682445016430658685939156856477981777500279476244420599603476748648980604761766608173748421620897170615333674094203575560097701690600826765406153596728525522315006116823384679389665857084287734253844405374570906508352529980913768864581357633034050503316047153788822635367810607315822926036124094287753417643415534136727508769976105166846205170174541587788697208216080000563807101454012030501696997416883981774325045315898834544625445196823745452535408968088842047986215565636998321471356227742283630803792491817788329982895051126047698957867121151892976870203507010533578712963435
 b=21875839411860645751733414110507990938211947727566391650896268008014380471972884571819736247050909728035053094674608860293328893562160370394486537468106530827734742365411685767421588718185228782785552003001901855737170458066041248113076076995829550562900882883523060263336325733268287346885180980638925314361707330025700091411497796538991591403928171963244057349974038193893033645118506895181867417354461306709371353246617609796519071938239982148796049681802334559009898901024618676368438304178254967098179018064625240466547107577198806528894531245365445740726881296825273420342141309804295596060104598
 a = reciprocal_Phi_p(b,n)
 
 puts a.inspect
+
+

6/krzywa.rb

@@ -9,119 +9,6 @@
 ########################################
 
 load '../module.rb'
-require 'thread'
-require 'thwait'
-
-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
-
-def delta(a,b,p)
-  d = ((4 * betterExponentiation(a,3,p) % p) + (27 * betterExponentiation(b,2,p) % p)) % p
-  return d
-end
-
-def rownanieKrzywej(a,b,p,x)
-  fx = (betterExponentiation(x,3,p) + (a * x) % p + b % p) % p
-  return fx
-end
-
-def generatorKrzywej(p)
-  a = 0
-  b = 0
-
-  while true
-    if primalityTest(p) &&  p % 4 == 3
-      threads = []
-
-      threads << Thread.new {
-        a = SecureRandom.random_number(1..p-1)
-      }
-
-      threads << Thread.new {
-        b = SecureRandom.random_number(1..p-1)
-      }
-
-      ThreadsWait.all_waits(*threads)
-
-      if delta(a,b,p) != 0
-        returnRownanie(a,b,p)
-        return a,b
-      end
-    end
-  end
-end
-
-def punktNaKrzywej(a,b,p)
-   if delta(a,b,p) != 0
-     while true
-       x = SecureRandom.random_number(1..p-1)
-       fx = rownanieKrzywej(a,b,p,x)
-       if remSqEuler(fx,p)
-         if a == 0
-          y = 0
-         elsif p == 2
-          y = p
-         elsif p % 4 == 3
-          y = Math.sqrt(fx).to_i % p
-          #y = betterExponentiation(a,(p+1/4),p)
-         end
-         return x,y
-       end
-     end
-   end
-end
-
-def czyPunktNalezyDoKrzywej(a,b,p,x,y)
-  fx = rownanieKrzywej(a,b,p,x)
-
-  if fx == betterExponentiation(y,2,p)
-    return true
-  else
-    return false
-  end
-end
-
-def punktPrzeciwny(x,y)
-  return x,-y
-end
-
-def sumaPunktow(a,b,p,x1,y1,x2,y2)
-  # P + Q = R
-  if (x1 != x2) && (y1 != y2)
-    alpha = (((y2 - y1) % p) * reciprocal_Phi_p((x2 - x1),p)) % p
-    x3 = (betterExponentiation(alpha,2,p) - (x1 % p) - (x2 % p)) % p 
-    y3 = (alpha * (x1 - x3) - y1) % p
-    return x3,y3
-  end
-  # P + -Q = 0 DZIALA
-  if (x1 == x2) && (y1 == -y2)
-    return "0"
-  end
-  # P + P = 2P DZIALA
-  if (x1 == x2) && (y1 == y2)
-    alpha = (((3 * betterExponentiation(x1,2,p) % p + a) % p) * reciprocal_Phi_p(2 * y1,p)) % p
-    x3 = betterExponentiation(alpha,2,p) - (x1 % p) - (x2 % p)
-    y3 = (alpha * (x1 - x3) - y1) % p
-    return x3,y3
-  end
-  # 0 - element neutrany --> P + 0 = P
-  if (x1 == 0 && y1 == 0 )
-    return x2,y2
-  elsif (x2 == 0 && y2 == 0)
-    return x1,y1
-  end
-    
-end
-
-#puts generatorKrzywej(11).inspect
-#puts punktNaKrzywej(2,7,11).inspect
-#puts czyPunktNalezyDoKrzywej(2,7,11,7,1).inspect
-#puts czyPunktNalezyDoKrzywej(2,7,11,2,2).inspect
-#puts punktPrzeciwny(2,2).inspect
-#puts sumaPunktow(2,2,17,5,1,5,1).inspect
 
 ##################################################
 # Zadania z konca wykladu suma punktow
@@ -137,30 +24,89 @@ end
 # 3) P + Q
 # 4) 2R
 #
-##################################################
 # Rozwiązanie:
-a = 0
+#a = 0
-b = 1
+#b = 1
-p = 7
+#p = 7
+#
+#xp = 1
+#yp = 3
+#
+#xq = 2
+#yq = 4
+#
+#xr = 6
+#yr = 0
+#
+## 1) -Q
+#puts punktPrzeciwny(xq,yq).inspect
+#
+## 2) R + [0,0]
+#puts sumaPunktow(a,b,p,xr,yr,"e","e").inspect
+#
+## 3) P + Q
+#puts sumaPunktow(a,b,p,xp,yp,xq,yq).inspect
+#
+## 4) 2R
+#puts sumaPunktow(a,b,p,xp,yp,xp,yp).inspect
+###################################################
 
-xp = 1
-yp = 3
-
-xq = 2
-yq = 4
-
-xr = 6
-yr = 0
-
-# 1) -Q
-puts punktPrzeciwny(xq,yq).inspect
-
-# 2) R + [0,0]
-puts sumaPunktow(a,b,p,xr,yr,0,0).inspect
-
-# 3) P + Q
-puts sumaPunktow(a,b,p,xp,yp,xq,yq).inspect
-
-# 4) 2R
-puts sumaPunktow(a,b,p,xp,yp,xp,yp).inspect
 ##################################################
+# Zadanie od profersora
+#a=239614427021073265587611886177902927263167863041565491257781227550405368115731464059190159
+#b=447169285435982716467332439542997876345372330045685811964291613238129105735899852114277221
+#p=1183779584357076950937981497685946292711107412152534481102525547387604378262522402526266939
+#px=285113634279465403319996581740169338329454608669814309137990174814243655992779447106132850
+#py=598700530906084162596261101440667782569915319623798143751082061599951188013331503150304328
+#
+#
+#puts "Zadanie 1 #{generatorKrzywej(p).inspect}"
+#puts "Zadanie 2 #{punktNaKrzywej(a,b,p).inspect}"
+#puts "Zadanie 3 #{czyPunktNalezyDoKrzywej(a,b,p,px,py).inspect}"
+#puts "Zadanie 4 #{punktPrzeciwny(px,py).inspect}"
+#puts "Zadanie 5"
+#pp=sumaPunktow(a,b,p,px,py,px,py)
+#qx,qy=pp[0],pp[1]
+#r=sumaPunktow(a,b,p,px,py,qx,qy)
+#puts "P+P=Q = #{pp.inspect}"
+#puts "P+Q=R = #{r.inspect}"
+#
+#################################################
+#Zadania od Marcina
+#puts `clear`
+#p = 489198001832658669053371291694019055502521600295245000665130252689633682157211441103746103
+#a = 143655542375421547495538657783935617582804745476111687935604061101439410572992748159327949
+#b = 317483121238416221164186798475625852751072649807905602729473072669192329094502393489452530
+#px = 214920231222257412002472184644105947527864300425093926130634470978902408198296382507987372
+#py = 213782952948563488188771820496583435437623918801486982688994669228366002105132455299788553
+#
+#puts "Zadanie1: #{generatorKrzywej(p).inspect}"
+#puts "Zadanie2: #{punktNaKrzywej(a,b,p).inspect}"
+#puts "Zadanie3: #{czyPunktNalezyDoKrzywej(a,b,p,px,py).inspect}"
+#puts "Zadanie4: #{punktPrzeciwny(px,py).inspect}"
+#puts "Zadanie5:"
+#pe = sumaPunktow(a,b,p,px,py,"e","e")
+#pmp = sumaPunktow(a,b,p,px,py,px,-py)
+#pp = sumaPunktow(a,b,p,px,py,px,py)
+#puts "P + e = #{pe.inspect}"
+#puts "P + (-P) = #{pmp.inspect}"
+#puts "P + P = #{pp.inspect}"
+#
+#qx = 642259555221384310824793582418757985600466641224722883964129011723625337870528779957486982
+#qy = 217544632016156259911730007881694454319320868952565819223745628076715981593127804307986145
+#puts "P + Q = #{sumaPunktow(a,b,p,px,py,qx,qy)}"
+#
+
+p = 1538255343667180808195708522177986895059786729714603384471797563076417208690821410309839367
+a = 715342794670902354305018359597199506955388115300843026803751557193763639728084344185723
+b = 1310687127378189233907141356419474988172837541544430152741262021759183741113116543743146348
+puts "Zadanie1: #{generatorKrzywej(p).inspect}"
+puts "Zadanie2: #{punktNaKrzywej(a,b,p).inspect}"
+px = 594932631894926193421437283987806574765302728699542654903674886448369552319213626349713311
+py = 957752861784564367578830846183560854043857673111182304497829726211341185920049820320440474
+qx = 876637806459659863220283205686618437204645589144030749155094254881674465651564141161317623
+qy = 466327193499960026299197596349518168121975030810688292370617392939557876329218294835906002
+pp = sumaPunktow(a,b,p,px,py,px,py)
+pq = sumaPunktow(a,b,p,px,py,qx,qy)
+puts "P + P = #{pp.inspect}"
+puts "P + Q = #{pq.inspect}"

8-lab/szyfrowanie-krzywe.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/ruby
+# coding: utf-8
+
+###################################
+#
+# Marcin Woźniak
+# s434812
+#
+###################################
+
+load '../module.rb'
+
+def main
+  k = 400
+  m = 7382908210982109821098
+  u = SecureRandom.random_number(30..50)
+  a,b,p,px,py,qx,qy,x = generowanieKluczyElGamalKrzywaEliptyczna(k)
+
+  pubKey = [a,b,p,px,py,qx,qy]
+  privKey = [a,b,p,px,py,qx,qy,x]
+
+  puts "Klucz pub: #{pubKey.inspect}"
+  puts "Klucz priv: #{privKey.inspect}"
+  puts ""
+
+  # BOB
+  pm = algorytmKodowania(a,b,p,m,u)
+  c1, c2 = szyfrowanieElGamala(a,b,p,u,px,py,qx,qy,pm[0],pm[1])
+
+  # ALICE
+  pmd = deKododwanieElGamala(a,b,p,c1[0],c1[1],c2[0],c2[1],x)
+  d = algorytmDeSzyfrowania(pmd[0],pmd[1],u)
+  puts "Deszyfowany punkt #{pmd.inspect}"
+  puts "Dekodowana wiadomość #{d.inspect}"
+  puts "\n\n---------------DANE DO ZADANIA----------------\nm = #{m} \na = #{a}\nb = #{b}\np = #{p}\npx = #{px}\npy = #{py}\nqx = #{qx}\nqy = #{qy}\nx = #{x}\nu = #{u}\nc1 = #{c1.inspect}\nc2 = #{c2.inspect}\n---------------------------------------------"
+end
+
+#puts generowanieKluczyElGamalKrzywaEliptyczna(2048).inspect
+#puts wielokrotnoscPunktu(8,10,19,3,15,3).inspect
+#puts algorytmSzyfrowania(8,10,19,29102901920190,29102901920199,50).inspect
+#Puts algorytmDeSzyfrowania(8,10,19,12,17,50)
+
+def prof
+  p = 2609851093885672531604546618282965491657570314241630591985918197877686507680174634344306143
+  a = 39746926425836399039258105470873774392122997653409098298906197201548801192257224379572749
+  b = 357758004741884143788834147448966908166771657009672776346195608808675430720026748380346214
+  px = 1752779174606701535340714968386694890708439813322474322723061659600059923305207235005963526
+  py = 692575814560566162056537964537393338270737177090733420494053855669625561475768305447331017
+  qx = 1859733423522807921537556587280278373018778723945077866335841026984756695533872750973383203
+  qy = 2221415723705529494603362237538702810871518537067269952747134368932432130149327465664405538
+  pmx = 1632858042793817840589568786779891550617922233361846684642975374690944475963011731075819538
+  pmy = 1425948989523949818696633854257999800509690944329987427951625560436648299955576658406402833
+  u = 30
+  x = 365201008216944469945066035191785204730196821748386113747483955067753230980
+
+  y = SecureRandom.random_number(0..liczenieOrd(p))
+
+  c1 = wielokrotnoscPunktu(a,b,p,y,px,py)
+  puts "c1 #{c1}"
+
+  yq = wielokrotnoscPunktu(a,b,p,y,qx,qy)
+  c2 = sumaPunktow(a,b,p,pmx,pmy,yq[0],yq[1])
+  puts "c2 #{c2}"
+
+  pmd = deKododwanieElGamala(a,b,p,c1[0],c1[1],c2[0],c2[1],x)
+  d = algorytmDeSzyfrowania(pmd[0],pmd[1],u)
+
+  puts "pmd #{pmd.inspect}"
+  puts "d = #{d}"
+end
+
+#puts prof
+puts main.inspect

Gemfile

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

README.md

@@ -0,0 +1,13 @@
+## How to install ruby?
+
+To install ruby you should go [here](https://www.ruby-lang.org/en/downloads/).
+
+## Install requirements:
+```bash
+bundle install
+```
+
+## Requirements in the project:
+* thwait
+
+for `Ruby 3.0.0`

module.rb

@@ -1,25 +1,26 @@
 #!/usr/bin/ruby
 # coding: utf-8
 
-#####################################
+##################################################################################
 #
 # Marcin Woźniak
 # s434812
 #
-#####################################
+##################################################################################
 
 require 'openssl'
 require 'securerandom'
 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
@@ -27,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
 
@@ -44,13 +45,13 @@ def extended_euklides(a, b)
   return t, s - q * t
 end
 
-####################################
+#################################################################################
-# Funkcja nwd(a,b)
+# Funkcja random_gen_Zn(k,n)
 #
-# Oblicza nwd podanych liczb np
+# Oblicza losowy element z zbioru Z_n
-# nwd(10,14) => 2
+# random_gen_Zn(1,10) => 1
 #
-####################################
+#################################################################################
 def random_gen_Zn(k,n)
 
   if n == 0
@@ -78,13 +79,16 @@ def random_gen_Zn(k,n)
   end
 end
 
-####################################
+#################################################################################
-# Funkcja nwd(a,b)
+# Funkcja reciprocal_Phi_p(n,p)
 #
-# Oblicza nwd podanych liczb np
+# Oblicza odwrotnosc w grupie Phi(n)
-# nwd(10,14) => 2
+# reciprocal_Phi_p(10,7) => 5
 #
-####################################
+# 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]
@@ -102,18 +106,22 @@ def reciprocal_Phi_p(n,p)
   end
 end
 
-####################################
+#################################################################################
-# Funkcja nwd(a,b)
+# Funkcja betterExponentiation(x,k,n)
 #
-# Oblicza nwd podanych liczb np
+# Oblicza potęgi x^k mod n
-# nwd(10,14) => 2
+# betterExponentiation(8,2,30) => 4
 #
-####################################
+#################################################################################
 def betterExponentiation(x,k,n)
   if n == 0
     return false
   end
 
+  if x == 0
+    return 0
+  end
+
   if x < n && x > 0
     b = k.to_s(2).reverse
     l = b.count "[0-1]"
@@ -131,30 +139,27 @@ def betterExponentiation(x,k,n)
   end
 end
 
-####################################
+#################################################################################
-# Funkcja nwd(a,b)
+# Funkcja remSqEuler(a,b)
 #
-# Oblicza nwd podanych liczb np
+# Sprawdzenie czy element a jest
-# nwd(10,14) => 2
+# 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)
-  if ans == 1 && Prime.prime?(p)
     return true
   else
     return false
   end
 end
 
-####################################
+#################################################################################
-# Funkcja nwd(a,b)
+# Funkcja squareRootFp(a,b)
 #
-# Oblicza nwd podanych liczb np
+#################################################################################
-# nwd(10,14) => 2
-#
-####################################
 def squareRootFp(p,b)
   if p % 4 == 3 && remSqEuler(p,b) == true
       a = betterExponentiation(b, (p+1)/4, p)
@@ -162,13 +167,13 @@ def squareRootFp(p,b)
   end
 end
 
-####################################
+#################################################################################
-# Funkcja nwd(a,b)
+# Funkcja primalityTest(n)
 #
-# Oblicza nwd podanych liczb np
+# Test pierwszości
-# nwd(10,14) => 2
+# primalityTest(13) => true
 #
-####################################
+#################################################################################
 def primalityTest(n)
   if n == 1
     return false
@@ -189,13 +194,12 @@ def primalityTest(n)
   return true
 end
 
-####################################
+#################################################################################
-# Funkcja nwd(a,b)
+# Funkcja specyficPrimaryNumber
 #
-# Oblicza nwd podanych liczb np
+# Generuje potrzebne do pierwszego
-# nwd(10,14) => 2
+# ElGamala
-#
+##################################################################################
-####################################
 def specyficPrimaryNumber
   p = 0
   q = 0
@@ -220,13 +224,13 @@ def specyficPrimaryNumber
   end
 end
 
-####################################
+#################################################################################
-# Funkcja nwd(a,b)
+# Funkcja generator(a,b)
 #
-# Oblicza nwd podanych liczb np
+# Generuje generator dla podanych liczb
-# nwd(10,14) => 2
+# do RSA i ElGamala
 #
-####################################
+#################################################################################
 def generator(p,q)
   while true
     g = SecureRandom.random_number(2..p-2)
@@ -238,13 +242,413 @@ def generator(p,q)
   end
 end
 
-####################################
+#################################################################################
-# Funkcja nwd(a,b)
+# Funkcja generate(n)
 #
-# Oblicza nwd podanych liczb np
+# Generator liczby losowej o podanej
-# nwd(10,14) => 2
+# 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
+
+  while true
+    if primalityTest(p) &&  (p % 4 == 3)
+      threads = []
+
+      threads << Thread.new {
+        a = SecureRandom.random_number(1..p-1)
+      }
+
+      threads << Thread.new {
+        b = SecureRandom.random_number(1..p-1)
+      }
+
+      ThreadsWait.all_waits(*threads)
+      if delta(a,b,p) != 0
+        #returnRownanie(a,b,p)
+        return a,b
+      end
+    else
+      puts "Liczba nie spełnia wymagań"
+      break
+    end
+  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
+      x = SecureRandom.random_number(0..p-1)
+      fx = rownanieKrzywej(a,b,p,x)
+      if remSqEuler(fx,p)
+        y = betterExponentiation(fx,((p+1)/4),p)
+        return x,y
+      end
+    end
+  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)
+
+  if fx == betterExponentiation(y,2,p)
+    return true
+  else
+    return false
+  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" )
+    return x2,y2
+  elsif (x2 == "e" && y2 == "e")
+    return x1,y1
+  end
+  # P + Q = R
+  if (x1 != x2)
+    lambda = (((y2 - y1) % p) * reciprocal_Phi_p((x2 - x1),p)) % p
+    x3 = (betterExponentiation(lambda,2,p) - (x1 % p) - (x2 % p)) % p
+    y3 = (lambda * (x1 - x3) - y1) % p
+    return x3,y3
+  end
+  # P + -Q = 0 DZIALA
+  if (x1 == x2) && (y1 == -y2)
+    #puts "0 - el.neutralny"
+    return "e","e"
+  end
+  # P + P = 2P DZIALA
+  if (x1 == x2) && (y1 == y2)
+    lambda = (((3 * betterExponentiation(x1,2,p) % p + a) % p) * reciprocal_Phi_p(2 * y1,p)) % p
+    x3 = (betterExponentiation(lambda,2,p) - (x1 % p) - (x2 % p)) % p
+    y3 = (lambda * (x1 - x3) - y1) % p
+    return x3,y3
+  end
+  # P + -Q = 0 DZIALA
+  if (x1 == x2) && (y1 == y2%p)
+    #puts "0 - el.neutralny"
+    return "e","e"
+  end
+end
+
+#### MODULE 3 ####
+
+
+#################################################################################
+# Funkcje mysqrt(n)
+#
+# Oblicza wartość pierwiastka z dużych
+# liczb
+#
+# Źródło: https://stackoverflow.com/questions/8226087/how-do-i-get-math-sqrt-to-return-a-bignum-and-not-a-float
+#################################################################################
+def mysqrt(x)
+  return 0 if x==0
+  m=x
+  p=x
+  loop do
+    r=(m+p/m)/2
+    return m if m<=r
+    m=r
+  end
+end
+
+#################################################################################
+# Funkcja liczenieOrd(p)
+#
+# Oblicza wartość ord dla podanych p.
+#################################################################################
+def liczenieOrd(p)
+  ord = (p + 1 - (2 * mysqrt(p))) % p
+  return ord
+end
+
+#################################################################################
+# Zadanie 1
+# Funkcja generowanieKluczyElGamalKrzywaEliptyczna(k)
+#
+# Generatoruje klucz publiczny
+# oraz prywatny.
+#################################################################################
+def generowanieKluczyElGamalKrzywaEliptyczna(k)
+  while true
+  p = generate(k)
+    if (primalityTest(p)) && (p % 4 == 3)
+      krzywa = generatorKrzywej(p)
+      a = krzywa[0].to_i
+      b = krzywa[1].to_i
+
+      punktyNaKrzywej = Array.new
+
+      punktP = punktNaKrzywej(a,b,p)
+      ord = liczenieOrd(p)
+
+      while true
+        x = SecureRandom.random_number(1..ord)
+        if x < ord
+          punktQ = wielokrotnoscPunktu(a,b,p,x,punktP[0],punktP[1])
+          pubKey = [a,b,p,punktP[0],punktP[1],punktQ[0],punktQ[1]]
+          privKey = [a,b,p,punktP[0],punktP[1],punktQ[0],punktQ[1],x]
+          return a,b,p,punktP[0],punktP[1],punktQ[0],punktQ[1],x
+        end
+      end
+    end
+  end
+end
+
+#################################################################################
+# Zadanie 2
+# 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"]
+
+  while n > 0
+    if n % 2 == 1
+      punktR = sumaPunktow(a,b,p,punktR[0],punktR[1],punktQ[0],punktQ[1])
+      n = n - 1
+    end
+    punktQ = sumaPunktow(a,b,p,punktQ[0],punktQ[1],punktQ[0],punktQ[1])
+    n = n / 2
+  end
+  return punktR
+end
+
+#################################################################################
+# Zadanie 3
+# Funkcja algorytmKodowania(a,b,p,m,n,u)
+#
+#################################################################################
+def algorytmKodowania(a,b,p,m,u)
+  n = m + SecureRandom.random_number(0..1000000)
+  if (m < n) && (p > n*u)
+    for i in 1..u
+      x = (m * u % p) + (i % p)
+      fx = rownanieKrzywej(a,b,p,x)
+      if remSqEuler(fx,p)
+        y = betterExponentiation(fx,((p+1)/4),p)
+      end
+    end
+  else
+    puts "Nieprawidołowe dane"
+  end
+  puts "Punkt na krzywej to #{[x,y].inspect}"
+  return [x,y]
+end
+
+#################################################################################
+# Zadanie 4
+# Funkcja szyfrowanieElGamala(a,b,p,m,u,px,py,qx,qy)
+#
+# Zwraca szyfrogramy.
+#################################################################################
+def szyfrowanieElGamala(a,b,p,u,px,py,qx,qy,pmx,pmy)
+  y = SecureRandom.random_number(0..liczenieOrd(p))
+  puts "y = #{y}"
+  c1 = wielokrotnoscPunktu(a,b,p,y,px,py)
+  yq = wielokrotnoscPunktu(a,b,p,y,qx,qy)
+  c2 = sumaPunktow(a,b,p,pmx,pmy,yq[0],yq[1])
+  puts "Ciphers: C1=#{c1}, C2=#{c2}"
+  return c1,c2
+end
+
+#################################################################################
+# Zadanie 5
+# Funkcja deKodowanieElGamala(a,b,p,c1x,c1y,c2x,c2y,x)
+#
+# Zwraca odszyfrowany punkt początkowy na którym była wiadomość.
+#################################################################################
+def deKododwanieElGamala(a,b,p,c1x,c1y,c2x,c2y,x)
+  xc1 = wielokrotnoscPunktu(a,b,p,x,c1x,c1y)
+  pmd = sumaPunktow(a,b,p,c2x,c2y,xc1[0],-xc1[1])
+  #puts "-------------------DEBUG MODE-------------------\na = #{a}\nb = #{b}\np = #{p}\nc1x = #{c1x} \nc1y = #{c1y} \nc2x = #{c2x} \nc2y = #{c2y} \nx = #{x}\nXC1 = #{xc1.inspect}\npm = #{pmd.inspect}\n-------------------"
+  return pmd
+end
+
+#################################################################################
+# Zadanie 6
+# Funkcja algorytmDeSzyfrowania(x,y,u)
+#
+# Zwraca odszyfrowaną wiadomość.
+#################################################################################
+def algorytmDeSzyfrowania(x,y,u)
+  m = (x - 1) / u
+  return m
+end
+
+########################### Module 4 ############################################
+# Podstawowe operacje na Galois Field GF(2^8)
+# Źródła:
+# * https://people.scs.carleton.ca/~maheshwa/courses/4109/Seminar11/The_Advanced_Encryption_Standard_AES_.pdf
+# * https://cs465.internet.byu.edu/static/lectures/w19/AES.pdf
+# * https://en.wikipedia.org/wiki/Finite_field_arithmetic
+# * https://swarm.cs.pub.ro/~mbarbulescu/cripto/Understanding%20Cryptography%20by%20Christof%20Paar%20.pdf
+# * http://www.cs.man.ac.uk/~banach/COMP61411.Info/CourseSlides/Wk2.2.FinField.pdf
+#################################################################################
+
+#################################################################################
+# Zadanie 1
+# Funkcja suma(a,b) wykorzystujac liczby hex
+#################################################################################
+def suma(a,b)
+  binA = a.to_i(16).to_s(2)
+  binB = b.to_i(16).to_s(2)
+  return (binA.to_i(2) ^ binB.to_i(2)).to_s(16)
+end
+
+#################################################################################
+# Zadanie 2
+# Funkcja xtime(a) wykorzystujac liczby hex
+#################################################################################
+def xtime(a)
+  binA = a.to_i(16).to_s(2)
+  const = "1B"
+
+  dl = binA.length
+  while dl != 8
+    binA = "0" + binA
+    dl = dl + 1
+  end
+
+  if binA[0].to_i == 1
+    binA[0] = ''
+    return suma((binA.to_i(2) << 1 ).to_s(16), const)
+  elsif binA[0].to_i == 0
+    return (binA.to_i(2) << 1 ).to_s(16)
+  end
+end
+
+#################################################################################
+# Zadanie 3
+# Funkcja iloczyn(a,b) wykorzystujac liczby hex
+# {53} • {CA} = {01}
+# {57} • {13} = {fe}
+#################################################################################
+def iloczyn(a,b)
+  solve = "0"
+  binA = a.to_i(16).to_s(2)
+
+  len = binA.length - 1
+  binA.split('').each { |a|
+    if a == "1"
+      tmp = b
+      counter = len
+      while counter != 0
+        tmp = xtime(tmp)
+        counter = counter - 1
+      end
+      solve = suma(tmp.to_i(16).to_s(16), solve)
+    end
+    len = len - 1
+  }
+  return solve
+end
+
+#################################################################################
+# Zadanie 4
+# Funkcja odwrotnosc(a) wykorzystujac liczby hex
+#################################################################################
+def odwrotnosc(a)
+  b = a
+  i = 13
+  const = 1
+  while i > 0
+    if i.to_s(2).to_i & const.to_s(2).to_i == 1
+      tmp = b
+    else
+      tmp = a
+    end
+    b = iloczyn(b,tmp)
+    i = i - 1
+  end
+  return b
+end