From dab640ca388d8c31fe6724b1bacb472acfe2e2a8 Mon Sep 17 00:00:00 2001
From: anastasiiiaaa <lalalamik@yandex.ru>
Date: Sun, 7 Nov 2021 16:43:05 +0300
Subject: [PATCH 1/2] Added vernam.rb and vigenere.rb Added vernam_test.rb and
 vigenere_test.rb

---
 lib/aaa_crypt.rb                 |  3 +-
 lib/aaa_crypt/vernam.rb          | 53 ++++++++++++++++++++++++++++++++
 lib/aaa_crypt/vigenere.rb        | 36 ++++++++++++++++++++++
 test/encryption/vernam_test.rb   | 31 +++++++++++++++++++
 test/encryption/vigenere_test.rb | 33 ++++++++++++++++++++
 5 files changed, 155 insertions(+), 1 deletion(-)
 create mode 100644 lib/aaa_crypt/vernam.rb
 create mode 100644 lib/aaa_crypt/vigenere.rb
 create mode 100644 test/encryption/vernam_test.rb
 create mode 100644 test/encryption/vigenere_test.rb

diff --git a/lib/aaa_crypt.rb b/lib/aaa_crypt.rb
index 38c6625..01d4123 100644
--- a/lib/aaa_crypt.rb
+++ b/lib/aaa_crypt.rb
@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "aaa_crypt/version"
-
+require_relative "aaa_crypt/vernam"
+require_relative "aaa_crypt/vigenere"
 module AaaCrypt
   class Error < StandardError; end
   # Your code goes here...
diff --git a/lib/aaa_crypt/vernam.rb b/lib/aaa_crypt/vernam.rb
new file mode 100644
index 0000000..dbd684a
--- /dev/null
+++ b/lib/aaa_crypt/vernam.rb
@@ -0,0 +1,53 @@
+require 'securerandom'
+class Vernam
+
+#generates random key, len-length of key
+def self.key_generate(len)
+  #key= SecureRandom.hex(len/2)
+  o = [('a'..'z'),('A'..'Z'),(0..9)].map(&:to_a).flatten
+  key = (0...len).map { o[rand(o.length)] }.join
+  key
+end
+#makes array of binary codes(for every char) from string
+def self.string_to_bin(str)
+  str_new= String.new()
+  str.each_byte {|c| str_new += c.to_s(2)+" "}
+  arr=str_new.split(" ")
+  arr.each_with_index{|arr,i | while(arr.length<8)
+                                 arr[0]="0"+arr[0]
+                               end}
+  arr
+end
+#vernam encryption
+def self.vernam_encrypt(str,key)
+  length_str=str.length
+  arr=string_to_bin(str)
+  key_arr=string_to_bin(key)
+  res=Array.new()
+  arr.zip(key_arr).each {|arr, key_arr| res.push((arr.to_i(2) ^ key_arr.to_i(2)).to_s(2).rjust(arr.length, '0'))}
+  result=String.new()
+  res.each {|c| result += c+" "}
+  result
+
+end
+#makes string of chars from string of binary codes
+def self.bin_to_string(str)
+  str_new= String.new()
+  arr=str.split(" ")
+  arr.each {|c| str_new += (c.to_i(2)).chr}
+  str_new
+end
+#vernam decryption
+def self.vernam_decrypt(str,key)
+  length_str=str.length
+  arr=str.split(" ")
+  key_arr=string_to_bin(key)
+  res=Array.new()
+  arr.zip(key_arr).each {|arr, key_arr| res.push((arr.to_i(2) ^ key_arr.to_i(2)).to_s(2).rjust(arr.length, '0'))}
+  result=String.new()
+  res.each {|c| result += c+" "}
+  resstr=bin_to_string(result)
+  resstr
+
+end
+end
diff --git a/lib/aaa_crypt/vigenere.rb b/lib/aaa_crypt/vigenere.rb
new file mode 100644
index 0000000..cdaa21f
--- /dev/null
+++ b/lib/aaa_crypt/vigenere.rb
@@ -0,0 +1,36 @@
+require 'securerandom'
+class Vigenere
+#generates random key, len-length of future key (includes only downcase latin letters)
+def self.key_generate(len)
+  #key= SecureRandom.hex(len/2)
+  o = [('a'..'z')].map(&:to_a).flatten
+  key = (0...len).map { o[rand(o.length)] }.join
+  key
+end
+# These Vigenere encryption and decryption are based on Vigenere table that includes only downcase latin letters
+#vigenere encryption
+def self.vigenere_encrypt(str,key)
+  alph=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
+  n = alph.length
+  res=String.new()
+  arr=str.chars
+  arrk=key.chars
+  arr.zip(arrk).each do |c,k| t=(alph.index(c)+alph.index(k))%n
+  res+=alph[t]
+  end
+  res
+end
+#vigenere decryption
+def self.vigenere_decrypt(str,key)
+  alph=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
+  n = alph.length
+  res=String.new()
+  arr=str.chars
+  arrk=key.chars
+  arr.zip(arrk).each do |c,k| t=(alph.index(c)+n -alph.index(k))%n
+  res+=alph[t]
+  end
+  res
+end
+end
+
diff --git a/test/encryption/vernam_test.rb b/test/encryption/vernam_test.rb
new file mode 100644
index 0000000..dc5568d
--- /dev/null
+++ b/test/encryption/vernam_test.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class VernamTest < Minitest::Test
+  include AaaCrypt
+
+  def test_vernam_encrypt_a_with_key_1
+    assert_equal"01010000 ", Vernam.vernam_encrypt("a","1")
+  end
+  def test_vernam_decrypt_01010000
+    assert_equal"a", Vernam.vernam_decrypt("01010000 ","1")
+  end
+
+  def test_vernam_encrypt_Hello_world_with_key_wr3u44uejxm1
+    assert_equal"00111111 00010111 01011111 00011001 01011011 00010100 00000010 00001010 00011000 00010100 00001001 00010000 ", Vernam.vernam_encrypt("Hello world!","wr3u44uejxm1")
+  end
+  def test_vernam_decrypt_00111111_00010111_01011111_00011001_01011011_00010100_00000010_00001010_00011000_00010100_00001001_00010000
+    assert_equal"Hello world!", Vernam.vernam_decrypt("00111111 00010111 01011111 00011001 01011011 00010100 00000010 00001010 00011000 00010100 00001001 00010000 ","wr3u44uejxm1")
+  end
+
+  def test_vernam_encrypt_Number_11_with_key_fdt4udht7
+    assert_equal"00101000 00010001 00011001 01010110 00010000 00010110 01001000 01000101 00000110 ", Vernam.vernam_encrypt("Number 11","fdt4udht7")
+  end
+  def test_vernam_decrypt_00101000_00010001_00011001_01010110_00010000_00010110_01001000_01000101_00000110
+    assert_equal"Number 11", Vernam.vernam_decrypt("00101000 00010001 00011001 01010110 00010000 00010110 01001000 01000101 00000110 ","fdt4udht7")
+  end
+
+
+end
+
diff --git a/test/encryption/vigenere_test.rb b/test/encryption/vigenere_test.rb
new file mode 100644
index 0000000..939765a
--- /dev/null
+++ b/test/encryption/vigenere_test.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class VigenereTest < Minitest::Test
+  include AaaCrypt
+
+
+  def test_vigenere_encrypt_a_with_key_d
+    assert_equal"d",  Vigenere.vigenere_encrypt("a","d")
+  end
+  def test_vernam_decrypt_d
+    assert_equal"a",  Vigenere.vigenere_decrypt("d","d")
+  end
+
+  def test_vigenere_encrypt_abba_with_key_mama
+    assert_equal"mbna",  Vigenere.vigenere_encrypt("abba","mama")
+  end
+  def test_vernam_decrypt_mbna
+    assert_equal"abba",  Vigenere.vigenere_decrypt("mbna","mama")
+  end
+
+  def test_vigenere_encrypt_awesome_with_key_weekend
+    assert_equal"waicszh",  Vigenere.vigenere_encrypt("awesome","weekend")
+  end
+  def test_vernam_decrypt_waicszh
+    assert_equal"awesome",  Vigenere.vigenere_decrypt("waicszh","weekend")
+  end
+
+
+end
+
+

From c0537a9d23e0c8ddba721d7452115954ea67eef0 Mon Sep 17 00:00:00 2001
From: anastasiiiaaa <lalalamik@yandex.ru>
Date: Sun, 14 Nov 2021 11:02:49 +0300
Subject: [PATCH 2/2] Added alph to class variable Replaced res=Array.new()
 with res=[]

---
 lib/aaa_crypt/vernam.rb   |  4 ++--
 lib/aaa_crypt/vigenere.rb | 11 +++++++++--
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/lib/aaa_crypt/vernam.rb b/lib/aaa_crypt/vernam.rb
index dbd684a..d1bff25 100644
--- a/lib/aaa_crypt/vernam.rb
+++ b/lib/aaa_crypt/vernam.rb
@@ -23,7 +23,7 @@ def self.vernam_encrypt(str,key)
   length_str=str.length
   arr=string_to_bin(str)
   key_arr=string_to_bin(key)
-  res=Array.new()
+  res=[]
   arr.zip(key_arr).each {|arr, key_arr| res.push((arr.to_i(2) ^ key_arr.to_i(2)).to_s(2).rjust(arr.length, '0'))}
   result=String.new()
   res.each {|c| result += c+" "}
@@ -42,7 +42,7 @@ def self.vernam_decrypt(str,key)
   length_str=str.length
   arr=str.split(" ")
   key_arr=string_to_bin(key)
-  res=Array.new()
+  res=[]
   arr.zip(key_arr).each {|arr, key_arr| res.push((arr.to_i(2) ^ key_arr.to_i(2)).to_s(2).rjust(arr.length, '0'))}
   result=String.new()
   res.each {|c| result += c+" "}
diff --git a/lib/aaa_crypt/vigenere.rb b/lib/aaa_crypt/vigenere.rb
index cdaa21f..7b70ce6 100644
--- a/lib/aaa_crypt/vigenere.rb
+++ b/lib/aaa_crypt/vigenere.rb
@@ -1,4 +1,10 @@
 require 'securerandom'
+class Alph
+  @@letters = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
+  def self.letters
+    @@letters
+  end
+end
 class Vigenere
 #generates random key, len-length of future key (includes only downcase latin letters)
 def self.key_generate(len)
@@ -10,7 +16,7 @@ def self.key_generate(len)
 # These Vigenere encryption and decryption are based on Vigenere table that includes only downcase latin letters
 #vigenere encryption
 def self.vigenere_encrypt(str,key)
-  alph=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
+  alph=Alph.letters
   n = alph.length
   res=String.new()
   arr=str.chars
@@ -22,7 +28,7 @@ def self.vigenere_encrypt(str,key)
 end
 #vigenere decryption
 def self.vigenere_decrypt(str,key)
-  alph=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
+  alph=Alph.letters
   n = alph.length
   res=String.new()
   arr=str.chars
@@ -34,3 +40,4 @@ def self.vigenere_decrypt(str,key)
 end
 end
 
+