Gemnigma 0.0.2

data/lib/Gemnigma/crack.rb

@@ -0,0 +1,199 @@
+require_relative "helpers"
+
+module Gemnigma
+  class Crack
+    include ValidateFileArg
+
+    def get_cmd_args
+      if ARGV.length < 4
+        Messages.new.few_args
+        return
+      end
+
+      if ARGV.length == 4
+        @input_file = ARGV[1]
+        @output_file = ARGV[2]
+        @date_gen = ARGV[3]
+        validate { brute_force_key_map(@input_file, @date_gen) }
+      end
+
+      if ARGV.length > 4
+        Messages.new.too_much_args
+        return
+      end
+    end
+
+    private
+
+    def true_date?(date)
+      (date.to_i ** 2).to_s.chars.last(4).map(&:to_i) == Offset.new.offset
+    end
+
+    def brute_force_key_map(input, date)
+      unless true_date?(date)
+        Messages.new.wrong_date(date)
+        return
+      end
+
+      encrypted_file = File.open(input, "r")
+      index_count = 0
+      crack_key = 0
+      end_char_arr = []
+      @key_map = []
+
+      encrypted_file.read.split("").each do |item|
+        index_count = 0 if index_count > 3
+        end_char_arr << [item, index_count]
+        index_count += 1
+      end
+
+      end_chars = end_char_arr[-7..-4]
+
+
+      while crack_key <= 99
+        if CipherDecrypt.rotate_backward(crack_key)[end_chars[0][0]] == "."
+          @key_map[end_chars[0][1]] = crack_key
+          crack_key = 0
+          break
+        end
+        crack_key += 1
+      end
+
+      while crack_key <= 99
+        if CipherDecrypt.rotate_backward(crack_key)[end_chars[1][0]] == "."
+          @key_map[end_chars[1][1]] = crack_key
+          crack_key = 0
+          break
+        end
+        crack_key += 1
+      end
+
+      while crack_key <= 99
+        if CipherDecrypt.rotate_backward(crack_key)[end_chars[2][0]] == "e"
+          @key_map[end_chars[2][1]] = crack_key
+          crack_key = 0
+          break
+        end
+        crack_key += 1
+      end
+
+      while crack_key <= 99
+        if CipherDecrypt.rotate_backward(crack_key)[end_chars[3][0]] == "n"
+          @key_map[end_chars[3][1]] = crack_key
+          crack_key = 0
+          break
+        end
+        crack_key += 1
+      end
+
+      if @key_map.length == 4
+        crack_file(@input_file, @output_file)
+      end
+
+      encrypted_file.close
+
+    end
+
+    def map_word_to_crack(word)
+      result = []
+      count_key = 0
+
+      word.downcase.split("").each_with_index do |letter, index|
+        if count_key >= @key_map.length
+          count_key = 0
+        end
+        result << [letter, @key_map[count_key]]
+        count_key += 1
+      end
+      result
+    end
+
+    def brute_crack(word)
+      mapping = map_word_to_crack(word)
+      
+      mapping.map! do |arr|
+        CipherDecrypt.rotate_backward(arr.last)[arr.first]
+      end
+
+      mapping.join
+    end
+
+    def pad_key(key)
+      if key.to_s.length == 1
+        key = "0" + key.to_s
+      else
+        key = key.to_s
+      end
+    end
+
+    def key_gen(init, next_item)
+      new_arr = []
+
+      if pad_key(init)[1] != pad_key(next_item)[0]
+        if pad_key(init + 39)[1] == next_item.to_s[0]
+          new_arr << (init + 39)
+          new_arr << next_item
+        elsif pad_key(init + 78)[1] == next_item.to_s[0]
+          new_arr << (init + 78)
+          new_arr << next_item
+        elsif pad_key(init + 39)[1] == (next_item + 39).to_s[0]
+          new_arr << (init + 39)
+          new_arr << (next_item + 39)
+        elsif pad_key(init + 39)[1] == (next_item + 78).to_s[0]
+          new_arr << (init + 39)
+          new_arr << (next_item + 78)
+        elsif pad_key(init + 78)[1] == (next_item + 39).to_s[0]
+          new_arr << (init + 78)
+          new_arr << (next_item + 39)
+        elsif pad_key(init + 78)[1] == (next_item + 78).to_s[0]
+          new_arr << (init + 78)
+          new_arr << (next_item + 78)
+        elsif pad_key(init)[1] == (next_item + 39).to_s[0]
+          new_arr << init
+          new_arr << (next_item + 39)
+        elsif pad_key(init)[1] == (next_item + 78).to_s[0]
+          new_arr << init
+          new_arr << (next_item + 78)
+        end
+      end
+
+      if pad_key(init)[1] == pad_key(next_item)[0]
+        new_arr << init
+        new_arr << next_item
+      end
+
+      new_arr
+    end
+
+    def generate_cracked_key
+      @cracked_key = 0
+      date_offset = Offset.new.offset
+
+      key_arr = @key_map.zip(date_offset).map {|arr| arr.inject(&:-)}
+      possible_key_combination = [key_gen(key_arr[0], key_arr[1]), key_gen(key_arr[2], key_arr[3])].flatten
+
+       possible_key_combination.map! do |number|
+        if number == possible_key_combination.last
+          number
+        else
+          number.to_s[0].to_i
+        end
+       end
+      @cracked_key = possible_key_combination.join
+      Messages.new.success_message(@output_file, @secret_key, @date_gen)
+    end
+
+    def crack_file(input, output)
+      encrypted_file = File.open(input, "r+")
+      cracked_file = File.open(output, "w+")
+      input_content = encrypted_file.read
+
+      cracked_file.write(brute_crack(input_content))
+      
+      encrypted_file.close
+      cracked_file.close
+      generate_cracked_key
+    end
+
+  end
+end

data/lib/Gemnigma/decrypt.rb

@@ -0,0 +1,64 @@
+require_relative "helpers"
+
+module Gemnigma
+  class Decrypt < RotatorDecrypt
+    include ValidateFileArg
+
+    def get_cmd_args
+      if ARGV.length < 5
+        Messages.new.few_args
+        return
+      end
+
+      if ARGV.length == 5
+        @input_file = ARGV[1]
+        @output_file = ARGV[2]
+        @secret_key = ARGV[3]
+        @date_gen = ARGV[4]
+        validate { decrypt_file(@input_file, @output_file,@secret_key,@date_gen) }
+      end
+
+      if ARGV.length > 5
+        Messages.new.too_much_args
+        return
+      end
+
+    end
+
+    private
+
+    def true_key?(key)
+      key.length == 5 && key.match(/\d\d\d\d\d/) ? true : false
+    end
+
+    def true_date?(date)
+      (date.to_i ** 2).to_s.chars.last(4).map(&:to_i) == Offset.new.offset
+    end
+
+    def decrypt_file(input, output, key, date)
+      unless true_key?(key)
+        puts "#{key} doesn't match the specified key format"
+        puts "Exiting..."
+        return
+      end
+
+      unless true_date?(date)
+        puts "#{date} doesn't match the specified date format"
+        puts "Exiting..."
+        return
+      end
+      
+      encrypted_file = File.open(input, "r+")
+      decrypted_file = File.open(output, "w+")
+      input_content = encrypted_file.read
+
+      decrypt = RotatorDecrypt.new(Key.new(key.to_i))
+
+      decrypted_file.write(decrypt.rot_decrypt(input_content))
+
+      encrypted_file.close
+      decrypted_file.close
+      Messages.new.success_message(@output_file, @secret_key, @date_gen)
+    end
+  end
+end

data/lib/Gemnigma/encrypt.rb

@@ -0,0 +1,45 @@
+require_relative "helpers"
+
+module Gemnigma
+  class Encrypt < RotatorEncrypt
+    include ValidateFileArg
+
+    def get_cmd_args
+      if ARGV.length < 3
+        Messages.new.few_args
+        return
+      end
+
+      if ARGV.length == 3
+        @input_file = ARGV[1]
+        @output_file = ARGV[2]
+        validate { encrypt_file(@input_file, @output_file) }
+      end
+
+      if ARGV.length > 3
+        Messages.new.too_much_args
+        return
+      end
+
+    end
+
+    private
+
+    def encrypt_file(input, output)
+      file_input = File.open(input, "r+")
+      encrypted_file = File.open(output, "w+")
+      decryption_key = File.open("#{output.sub('txt', 'secret')}", "w+")
+      input_content = file_input.read
+      @secret_key = rand(10000..99999)
+      @date_gen = Offset.new.full_date
+      encrypt = RotatorEncrypt.new(Key.new(@secret_key))
+
+      encrypted_file.write(encrypt.rot_encrypt(input_content))
+      decryption_key.write("Decrypt #{@output_file} with the key: #{@secret_key} and date: #{@date_gen}")
+
+      file_input.close
+      encrypted_file.close
+      Messages.new.success_message(@output_file, @secret_key, @date_gen)
+    end
+  end
+end

data/lib/Gemnigma/helpers.rb

@@ -0,0 +1,4 @@
+require_relative "../../helpers/rotator_encrypt"
+require_relative "../../helpers/rotator_decrypt"
+require_relative "../../helpers/messages"
+require_relative "../../helpers/validate_file_arg"

data/lib/Gemnigma/version.rb

@@ -0,0 +1,3 @@
+module Gemnigma
+  VERSION = "0.0.2"
+end

data/lib/Gemnigma.rb

@@ -0,0 +1,7 @@
+require "Gemnigma/version"
+require_relative "Gemnigma/encrypt"
+require_relative "Gemnigma/decrypt"
+require_relative "Gemnigma/crack"
+
+module Gemnigma
+end

data/message.txt

@@ -0,0 +1 @@
+This message is secured with the genigma encryption engine ..end..

data/spec/Gemnigma_spec.rb

@@ -0,0 +1,55 @@
+require_relative "spec_helper"
+
+describe Gemnigma do
+  it "should be a module" do
+    expect(Gemnigma.class).to eql(Module)
+  end
+
+  it "should have a version constant available to it" do
+    expect(Gemnigma.constants.include? :VERSION).to be true
+  end
+
+  it "should have a version number 0.0.1" do
+    expect(Gemnigma::VERSION).to eql("0.0.1")
+  end
+
+  it "should have access to the char_map module" do
+    expect(Gemnigma.constants.include? :CharMap).to be true
+  end
+
+  it "should have access to the cipher_decrypt module" do
+    expect(Gemnigma.constants.include? :CipherDecrypt).to be true
+  end
+
+  it "should have access to the cipher_encrypt module" do
+    expect(Gemnigma.constants.include? :CipherEncrypt).to be true
+  end
+
+  it "should have access to the key class" do
+    expect(Gemnigma.constants.include? :Key).to be true
+  end
+
+  it "should have access to the offset class" do
+    expect(Gemnigma.constants.include? :Offset).to be true
+  end
+
+  it "should have access to the rotator_decrypt class" do
+    expect(Gemnigma.constants.include? :RotatorDecrypt).to be true
+  end
+
+  it "should have access to the rotator_encrypt class" do
+    expect(Gemnigma.constants.include? :RotatorEncrypt).to be true
+  end
+
+  it "should have access to the decrypt class" do
+    expect(Gemnigma.constants.include? :Decrypt).to be true
+  end
+
+  it "should have access to the encrypt class" do
+    expect(Gemnigma.constants.include? :Encrypt).to be true
+  end
+
+  it "should have access to the crack class" do
+    expect(Gemnigma.constants.include? :Crack).to be true
+  end
+end

data/spec/char_map_spec.rb

@@ -0,0 +1,38 @@
+require_relative "spec_helper"
+
+describe Gemnigma::CharMap do
+  it "should be a module" do
+    expect(Gemnigma::CharMap.class).to eql(Module)
+  end
+  
+  it "should have a method, #generate_char_map" do
+      expect(Gemnigma::CharMap.methods.include? :generate_char_map).to be true
+  end
+
+  describe "#generate_char_map" do
+    it "should return an array" do
+      expect(Gemnigma::CharMap.generate_char_map.class).to eql(Array)
+    end
+
+    it "should return an array of 39 characters" do
+      expect(Gemnigma::CharMap.generate_char_map.length).to eql(39)
+    end
+
+    it "should return alphabets as it's first 26 characters" do
+      alphabets =  ["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", "0"]
+      expect(Gemnigma::CharMap.generate_char_map[0..26]).to eql(alphabets)
+    end
+
+    it "should return numbers as strings as the next 10 characters" do
+      numbers = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
+      expect(Gemnigma::CharMap.generate_char_map[26...36]).to eql(numbers)
+    end
+
+    it "should return an empty string, a period and a comma as the last 3 characters" do
+      others = [" ", ".", ","]
+      expect(Gemnigma::CharMap.generate_char_map.last(3)).to eql(others)
+    end
+  end
+
+end

data/spec/cipher_decrypt_spec.rb

@@ -0,0 +1,55 @@
+require_relative "spec_helper"
+
+describe Gemnigma::CipherDecrypt do
+  it "should be a module" do
+    expect(Gemnigma::CipherDecrypt.class).to eql(Module)
+  end
+
+  it "should have a method #rotate_backward" do
+    expect(Gemnigma::CipherDecrypt.methods.include? :rotate_backward).to be true
+  end
+
+  describe "#rotate_backward" do
+    context "without parameters" do
+      it "should raise an exception" do
+        expect { Gemnigma::CipherDecrypt.rotate_backward }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "with parameters" do
+      it "should return a hash" do
+        expect(Gemnigma::CipherDecrypt.rotate_backward(3).class).to eql(Hash)
+      end
+
+      it "should return a hash with a length of 39" do
+        expect(Gemnigma::CipherDecrypt.rotate_backward(3).length).to eql(39)
+      end
+
+      it "should be a reverse of CipherEncrypt #rotate_forward method" do
+        expect(Gemnigma::CipherDecrypt.rotate_backward(3)).to eql(Gemnigma::CipherEncrypt.rotate_forward(3).invert)
+      end
+
+      it "should reverse a rotation if the rotation number match" do
+        word = Gemnigma::CipherEncrypt.rotate_forward(3)["a"]
+        expect(Gemnigma::CipherDecrypt.rotate_backward(3)[word]).to eql("a")
+      end
+
+      it "should reverse a rotation if the rotation number is an addition of the number and 39" do
+        word = Gemnigma::CipherEncrypt.rotate_forward(3)["a"]
+        expect(Gemnigma::CipherDecrypt.rotate_backward(3 + 39)[word]).to eql("a")
+      end
+
+      it "should reverse a rotation with rotation number plus a multiple of 39" do
+        word = Gemnigma::CipherEncrypt.rotate_forward(3)["a"]
+        expect(Gemnigma::CipherDecrypt.rotate_backward(3 + 78)[word]).to eql("a")
+        expect(Gemnigma::CipherDecrypt.rotate_backward(3 + 117)[word]).to eql("a")
+      end
+
+      it "should not reverse a rotation if the rotation number doesn't match" do
+        word = Gemnigma::CipherEncrypt.rotate_forward(3)["a"]
+        expect(Gemnigma::CipherDecrypt.rotate_backward(4)[word]).not_to eql("a")
+      end
+    end
+  end
+
+end

data/spec/cipher_encrypt_spec.rb

@@ -0,0 +1,43 @@
+require_relative "spec_helper"
+
+describe Gemnigma::CipherEncrypt do
+  it "should be a module" do
+    expect(Gemnigma::CipherEncrypt.class).to eql(Module)
+  end
+
+  it "should have a method #rotate_forward" do
+    expect(Gemnigma::CipherEncrypt.methods.include? :rotate_forward).to be true
+  end
+
+  describe "#rotate_forward" do
+    context "without parameters" do
+      it "should raise an exception" do
+        expect { Gemnigma::CipherEncrypt.rotate_forward }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "with parameters" do
+      it "should return a hash" do
+        expect(Gemnigma::CipherEncrypt.rotate_forward(3).class).to eql(Hash)
+      end
+
+      it "should return a hash with a length of 39" do
+        expect(Gemnigma::CipherEncrypt.rotate_forward(3).length).to eql(39)
+      end
+
+      it "should rotate characters by passed in rotation number" do
+        expect(Gemnigma::CipherEncrypt.rotate_forward(1)["a"]).to eql("b")
+        expect(Gemnigma::CipherEncrypt.rotate_forward(1)[","]).to eql("a")
+        expect(Gemnigma::CipherEncrypt.rotate_forward(12)["a"]).to eql("m")
+       end
+
+       it "should not rotate characters when 0 is passed in or multiples of 39" do
+          expect(Gemnigma::CipherEncrypt.rotate_forward(0)["a"]).to eql("a")
+          expect(Gemnigma::CipherEncrypt.rotate_forward(39)["n"]).to eql("n")
+          expect(Gemnigma::CipherEncrypt.rotate_forward(78)["n"]).to eql("n")
+          expect(Gemnigma::CipherEncrypt.rotate_forward(117)["a"]).to eql("a")
+       end
+    end
+  end
+
+end

data/spec/crack_spec.rb

@@ -0,0 +1,170 @@
+require_relative "spec_helper"
+
+describe Gemnigma::Crack do
+  before :each do
+    @crack = Gemnigma::Crack.new
+  end
+
+  it "should be an instance of the class Crack" do
+    expect(@crack).to be_an_instance_of Gemnigma::Crack
+  end
+
+  describe "#get_cmd_args" do
+    it "should take no arguments" do
+      expect{ @crack.get_cmd_args(2) }.to raise_error(ArgumentError)
+    end
+
+   it "should display an error message if few arguments are passed as command line arguments" do
+
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.few_args
+
+      expect(io).to have_received(:puts).with("Not enough arguments passed in. Run Gemnigma --help for instructions on usage\nExiting...")
+    end
+
+    it "should display an error message if too many arguments are passed as command line arguments" do
+
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.too_much_args
+
+      expect(io).to have_received(:puts).with("Too many arguments passed in. Run Gemnigma --help for instructions on usage\nExiting...")
+    end
+  end
+
+  describe "#true_date?" do
+    it "should be a private method" do
+      expect{ @crack.true_date?(2) }.to raise_error(NoMethodError)
+    end
+
+    it "should take one compulsory argument" do
+      expect{ @crack.send(:true_date?) }.to raise_error(ArgumentError)
+      expect{ @crack.send(:true_date?, 123456, 90919) }.to raise_error(ArgumentError)
+    end
+
+    it "should return true for valid dates" do
+      expect(@crack.send(:true_date?, 11015)).to be true
+      expect(@crack.send(:true_date?, 81015)).to be true
+    end
+
+    it "should return false for invalid dates" do
+      expect(@crack.send(:true_date?, 110152)).to be false
+      expect(@crack.send(:true_date?, "hello")).to be false
+    end
+  end
+
+  describe "#brute_force_key_map" do
+    it "should be a private method" do
+      expect{ @crack.brute_force_key_map }.to raise_error(NoMethodError)
+    end
+
+    it "should display an error message if an invalid date is passed in" do
+      
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.wrong_date("hello")
+
+      expect(io).to have_received(:puts).with("hello doesn't match the specified date format\nExiting...")
+    end
+
+    it "should throw an error if file to be read from doesn't exist" do
+      expect{ @crack.send(:brute_force_key_map, "unexistent.txt", 11015) }.to raise_error(StandardError)
+    end
+
+  end
+
+  describe "#pad_key" do
+    it "should be a private method" do
+      expect{ @crack.pad_key(2) }.to raise_error(NoMethodError)
+    end
+
+    it "should take one compulsory argument" do
+      expect{ @crack.send(:pad_key) }.to raise_error(ArgumentError)
+    end
+
+    it "should return a padded key if the length is one" do
+      expect(@crack.send(:pad_key, 0)).to eql("00")
+      expect(@crack.send(:pad_key, 1)).to eql("01")
+      expect(@crack.send(:pad_key, 2)).to eql("02")
+      expect(@crack.send(:pad_key, 3)).to eql("03")
+      expect(@crack.send(:pad_key, 4)).to eql("04")
+    end
+
+    it "should return a non-padded key if the length is greater than one" do
+      expect(@crack.send(:pad_key, 10)).to eql("10")
+      expect(@crack.send(:pad_key, 121)).to eql("121")
+      expect(@crack.send(:pad_key, 1234)).to eql("1234")
+      expect(@crack.send(:pad_key, 12345)).to eql("12345")
+    end
+  end
+
+  describe "#key_gen" do
+    it "should be a private method" do
+      expect{ @crack.key_gen(2, 6) }.to raise_error(NoMethodError)
+    end
+
+    it "should return an array" do
+      expect(@crack.send(:key_gen, 2, 6).class).to eql(Array)
+    end
+
+    it "should return an array of generated keys" do
+      expect(@crack.send(:key_gen, 4, 34)).to eql([43, 34])
+    end
+
+    it "should return an empty array if key could not be generated" do
+      expect(@crack.send(:key_gen, 2, 6)).to eql([])
+    end
+  end
+
+  describe "#generate_cracked_key" do
+    it "should be a private method" do
+      expect{ @crack.generate_cracked_key }.to raise_error(NoMethodError)
+    end
+
+    it "should display a success message if file was successfully created" do
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.success_message("file.txt", "94704", "81015")
+
+      expect(io).to have_received(:puts).with("\n........................................................")
+      expect(io).to have_received(:puts).with("\nCreated 'file.txt' with secret key 94704 and date 81015")
+    end
+  end
+
+  describe "#map_word_to_crack" do
+    it "should be a private method" do
+      expect{ @crack.map_word_to_crack }.to raise_error(NoMethodError)
+    end
+
+    it "should take one compulsory argument" do
+      expect{ @crack.send(:map_word_to_crack) }.to raise_error(ArgumentError)
+      expect{ @crack.send(:map_word_to_crack, "hello", "ade") }.to raise_error(ArgumentError)
+      expect{ @crack.send(:map_word_to_crack, "hello", "ade", "one") }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#brute_crack" do
+    it "should be a private method" do
+      expect{ @crack.brute_crack }.to raise_error(NoMethodError)
+    end
+
+    it "should take one compulsory argument" do
+      expect{ @crack.send(:brute_crack) }.to raise_error(ArgumentError)
+      expect{ @crack.send(:brute_crack, 2, 3) }.to raise_error(ArgumentError)
+      expect{ @crack.send(:brute_crack, 2, 3, "ade") }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#crack_file" do
+    it "should be a private method" do
+      expect{ @crack.crack_file("encoded.txt", "cracked.txt") }.to raise_error(NoMethodError)
+    end
+
+    it "should take two compulsory arguments" do
+      expect{ @crack.send(:crack_file) }.to raise_error(ArgumentError)
+      expect{ @crack.send(:crack_file, "file.txt") }.to raise_error(ArgumentError)
+      expect{ @crack.send(:crack_file, "file.txt", "out.txt", "last.txt") }.to raise_error(ArgumentError)
+    end
+  end
+end