cobreak 0.0.4 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70d1c3162c9064af440424db397c3ac6940acfb5492d3ae9e8cc4f8935933dde
-  data.tar.gz: c4c05b88da28a6a253ba7d9c78363d83df2c04f39cfd3d7796b148d50e3ac72c
+  metadata.gz: 9cd38e3a0c2c619fe0dfa738e8a7963d7b2ca135a2f49f2b8d2fd8f6494c5ea0
+  data.tar.gz: 232595ebcca59527750dea27084c153abb95274243c08513a18b8b634c119c36
 SHA512:
-  metadata.gz: fadc43dda0b0e9518f766f4ed0cf538e203a5b5a54dad975121d72582270aea0d67050683de38a11e3887305540901acc02cc26896fa6dc8c7dc9b51f93cf99c
-  data.tar.gz: 0ac6f4f7cd11623f87e0b5298456f1a89e0a4276d5979a131d253ffde33d2514c5ce4339048e43b83b8c25832c117a11767d7cc4f46c2b86a93f10ae755c74d4
+  metadata.gz: 6d6388ce0dd355c0b8fae3520ac955c28401ff3b8653b4fd5dda5ed775864b9a5d3114d1069730e975fd5251cb66502b5346821f3b9df7f407603784bf53ae8b
+  data.tar.gz: 810b4d19c7fb9dfd372d4e686a1b7beaf2110192a46bc6dd8556cd0b5f3b3f9c103684449d30f5506549d94e14e449f2926badaf101a737e94518ac8b712b676

data/cobreak.gemspec

@@ -1,18 +1,17 @@
 Gem::Specification.new do |info|
   info.name        = 'cobreak'
-  info.version     = '0.0.4'
+  info.version     = '1.0.1'
   info.executables << "cobreak"
   info.description = "The CoBreak script is an cipher and cryptography tool"
-  info.add_development_dependency  "Digest"
-  info.add_development_dependency  "sequel"
-  info.add_development_dependency  "sqlite3"
-#  info.extensions  << 'Gemfile'
+  info.add_development_dependency "bundler", "~> 1.5"
+  info.add_development_dependency  "Digest", "~> 3.0.0"
+  info.add_development_dependency  "sequel", "~> 5.44.0"
+  info.add_development_dependency  "sqlite3", "~> 1.4.2"
   info.authors     = ["BreakerBox"]
   info.email       = 'breakerhtb@gmail.com'
   info.summary     = "Force Brute, Cipher, Cryptography"
-  info.files = Dir["{lib}/**/*", "bin/*", "*.gemspec", "*.txt", "Gemfile", "LICENSE", "*.md"]
-  info.homepage    = 'https://rubygeminfo.org/breakerbox/cobreak'
-  info.metadata    = {"source_code_uri" => "https://github.com/BreakerBox/CoBreak"}
+  info.files = Dir["{lib}/**/*.rb"] + Dir["{lib}/**/show/*.db", "{lib}/**/hash/hash.db", "bin/*.rb", "*.gemspec", "diccionario.txt", "Gemfile", "LICENSE", "*.md"]
+  info.homepage    = 'https://github.com/BreakerBox/CoBreak'
   info.license       = 'MIT'
   info.post_install_message = "thanks for installing my gem"
 end

data/lib/cobreak/binary.rb

@@ -0,0 +1,10 @@
+module CoBreak
+  class Binary
+    def self.binary(dato)
+      return dato.unpack("B*").join('')
+    end
+    def self.hexbinary(dato)
+      return [dato].pack("B*")
+    end
+  end
+end

data/lib/cobreak/{Cesar.rb → cesar.rb}

@@ -1,16 +1,13 @@
 class CesarCifrado
-  attr_accessor :dato
-  def initialize(dato = nil)
-    @dato = dato
-  end
   def cesar(dato, rotasiones, orientacion = 1)
+    cesar = OpenStruct.new
+    cesar.cad_rot = []
     alfa_mayus = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     alfa_minus = "abcdefghijklmnopqrstuvwxyz"
     alf = 26
     lit_mayus = 65
     lit_minus = 97
     cad_rot = ""
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m CipherText: "
     for letra in dato.chars
       if !letra.match(/^[[:alpha:]]$/)
         cad_rot += letra
@@ -25,11 +22,9 @@ class CesarCifrado
       var_ascii = letra.ord
       rot_ver = rotasiones * orientacion
       new_pos = (var_ascii - limit + rot_ver) % alf
-      cad_rot = alfabeto[new_pos]
-      print cad_rot
+      cesar.cad_rot << alfabeto[new_pos]
       end
-    puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Rotations Number: #{rotasiones}"
+      return cesar.cad_rot.join('')
   end
 end
-CifraCesar = CesarCifrado.new
-DecifraCesar = CesarCifrado.new
+Cesar = CesarCifrado.new

data/lib/cobreak/cifrado.rb

@@ -2,31 +2,33 @@ require 'base64'
 require 'base32'
 require 'base16'
 require 'ascii85'
-
-class Cifrado
-  attr_accessor :data
-  def initialize(data = nil)
-    @data = data
-  end
-  def base16(dato)
-     bas16 = Base16.encode16(dato)
-     puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{bas16}\e[0m"
-  end
-  def base32(dato)
-     bas32 = Base32.encode(dato)
-     puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{bas32}\e[0m"
-  end
-  def base64(dato)
-     bas64 = Base64.encode64(dato)
-     print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{bas64}"
-  end
-  def binary(dato)
-    result = dato.unpack("B*").join('')
-    puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{result}"
-  end
-  def ascii85(dato)
-    asci85 = Ascii85.encode(dato)
-    puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{asci85}"
+require 'cobreak/cesar'
+require 'cobreak/binary'
+module CoBreak
+  class Cifrado
+    def self.cipher(mode, dato)
+      cipher = OpenStruct.new
+      cipher.mode = mode
+      cipher.dato = dato
+      if (cipher.mode.eql?('base16'))
+        cipher.result = Base16.encode16(dato)
+      elsif (cipher.mode.eql?('base32'))
+        cipher.result = Base32.encode(dato)
+      elsif (cipher.mode.eql?('base64'))
+        cipher.result = Base64.encode64(dato)
+      elsif (cipher.mode.eql?('ascii85'))
+        cipher.result = Ascii85.encode(dato)
+      elsif (cipher.mode.eql?('cesar'))
+        cipher.result = Cesar.cesar(dato, ARGV[0].to_i)
+      elsif (cipher.mode.eql?('binary'))
+        cipher.result = CoBreak::Binary.binary(dato)
+      end
+      unless (cipher.result.nil?) or (cipher.result.eql?(cipher.dato))
+        puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{cipher.result}"
+        puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Number Rotations: #{ARGV[0]}" if (cipher.mode.eql?('cesar'))
+      else
+        puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Cipher Text..."
+      end
+    end
   end
 end
-Cifra = Cifrado.new

data/lib/cobreak/cobreak.rb

@@ -8,7 +8,6 @@ module CoBreak
     begin
       require 'cobreak/cifrado'
       require 'cobreak/decifrado'
-      require 'cobreak/Cesar'
       require 'cobreak/encrypt'
       require 'cobreak/decrypt'
     rescue LoadError => e
@@ -23,72 +22,25 @@ module CoBreak
         @options = $options
         @options.enc = "" if @options.enc.nil? == true
         @options.dec = "" if @options.dec.nil? == true
-        if (@options.enc.casecmp?('base16')) or (@options.dec.casecmp?('base16'));
+        @options.cipher = %w[Base16 Base32 Base64 Ascii85 Binary Cesar]
+        if (@options.cipher.include?(@options.enc.capitalize)) or (@options.cipher.include?(@options.dec.capitalize));
           if (File.exists?(@options.algo));
             IO.foreach(@options.algo){|line|
-            line.chomp!
-            Cifra::base16(line.to_s) if (@options.enc.casecmp?('base16'))
-            Decifra::base16(line.to_s) if (@options.dec.casecmp?('base16'))
+              line.chomp!
+              if (@options.cipher?(@options.enc.capitalize))
+                CoBreak::Cifrado.cipher(line.to_s)
+              end
+              if (@options.cipher.include?(@options.dec.capitalize))
+                CoBreak::Decifrado.cipher(line.to_s)
+              end
             }
-          else;
-            Cifra::base16(@options.algo.to_s) if (@options.enc.casecmp?('base16'))
-            Decifra::base16(@options.algo.to_s) if (@options.dec.casecmp?('base16'))
-          end
-        elsif (@options.enc.casecmp?('base32')) or (@options.dec.casecmp?('base32'));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            Cifra::base32(line.to_s) if (@options.enc.casecmp?('base32'))
-            Decifra::base32(line.to_s) if (@options.dec.casecmp('base32'))
-            }
-          else;
-            Cifra::base32(@options.algo.to_s) if (@options.enc.casecmp?('base32'))
-            Decifra::base32(@options.algo.to_s) if (@options.dec.casecmp?('base32'))
-          end
-        elsif (@options.enc.casecmp?('base64')) or (@options.dec.casecmp?('base64'));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            Cifra::base64(line.to_s) if (@options.enc.casecmp?('base64'))
-            Decifra::base64(line.to_s) if (@options.dec.casecmp?('base64'))
-           }
-          else;
-            Cifra::base64(@options.algo.to_s) if (@options.enc.casecmp?('base64'))
-            Decifra::base64(@options.algo.to_s) if (@options.dec.casecmp?('base64'))
-          end
-        elsif (@options.enc.casecmp?('ascii85')) or (@options.dec.casecmp?('ascii85'));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            Cifra::ascii85(line.to_s) if (@options.enc.casecmp?('ascii85'))
-            Decifra::ascii85(line.to_s) if (@options.dec.casecmp?('ascii85'))
-            }
-          else;
-            Cifra::ascii85(@options.algo.to_s) if (@options.enc.casecmp?('ascii85'))
-            Decifra::ascii85(@options.algo.to_s) if (@options.dec.casecmp?('ascii85'))
-          end
-        elsif (@options.enc.casecmp?('binary')) or (@options.dec.casecmp?('binary'));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            Cifra::binary(line.to_s) if (@options.enc.casecmp?('binary'))
-            Decifra::binary(line.to_s) if (@options.dec.casecmp?('binary'))
-            }
-         else;
-          Cifra::binary(@options.algo.to_s) if (@options.enc.casecmp?('binary'))
-          Decifra::binary(@options.algo.to_s) if (@options.dec.casecmp?('binary'))
-         end
-        elsif (@options.enc.casecmp?('cesar')) or (@options.dec.casecmp?('cesar'));
-          dat = ARGV[0]
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            CifraCesar::cesar(line.to_s, dat.to_i) if (@options.enc.casecmp?('cesar'))
-            DecifraCesar::cesar(line.to_s, dat.to_i, -1) if (@options.dec.casecmp?('cesar'))
-            }
-          else;
-            CifraCesar::cesar(@options.algo.to_s, dat.to_i) if (@options.enc.casecmp?('cesar'))
-            DecifraCesar::cesar(@options.algo.to_s, dat.to_i, -1) if (@options.dec.casecmp?('cesar'))
+          else
+            if (@options.cipher.include?(@options.enc.capitalize))
+              CoBreak::Cifrado::cipher(@options.enc, @options.algo.to_s)
+            end
+            if (@options.cipher.include?(@options.dec.capitalize))
+              CoBreak::Decifrado::cipher(@options.dec,@options.algo.to_s)
+            end
           end
         end
       end
@@ -98,94 +50,25 @@ module CoBreak
         @options = $options
         @options.encrypt = "" if @options.encrypt.nil? == true
         @options.decrypt = "" if @options.decrypt.nil? == true
-        if (@options.encrypt.casecmp?("md4")) or (@options.decrypt.casecmp?("md4"));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::md4(line) if (@options.encrypt.casecmp?("md4"))
-            DeCrypt::md4(line) if (@options.decrypt.casecmp?("md4"))
-            }
-          else
-            EnCrypt::md4(@options.algo) if (@options.encrypt.casecmp?("md4"))
-            DeCrypt::md4(@options.algo) if (@options.decrypt.casecmp?("md4"))
-          end
-        elsif (@options.encrypt.casecmp?("md5")) or (@options.decrypt.casecmp?("md5"));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::md5(line) if (@options.encrypt.casecmp?("md5"))
-            DeCrypt::md5(line) if (@options.decrypt.casecmp?("md5"))
-            }  
-          else
-            EnCrypt::md5(@options.algo) if (@options.encrypt.casecmp?("md5"))
-            DeCrypt::md5(@options.algo) if (@options.decrypt.casecmp?("md5"))
-          end
-        elsif (@options.encrypt.casecmp?("sha1")) or (@options.decrypt.casecmp?("sha1"))
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::sha1(line) if (@options.encrypt.casecmp?("sha1"))
-            DeCrypt::sha1(line) if (@options.decrypt.casecmp?("sha1"))
-            }
-          else
-            EnCrypt::sha1(@options.algo) if (@options.encrypt.casecmp?("sha1"))
-            DeCrypt::sha1(@options.algo) if (@options.decrypt.casecmp?("sha1"))
-          end
-        elsif (@options.encrypt.casecmp?("sha224")) or (@options.decrypt.casecmp?("sha224"));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::sha224(line) if (@options.encrypt.casecmp?("sha224"))
-            DeCrypt::sha224(line) if (@options.decrypt.casecmp?("sha224"))
-            }
-          else
-            EnCrypt::sha224(@options.algo) if (@options.encrypt.casecmp?("sha224"))
-            DeCrypt::sha224(@options.algo) if (@options.decrypt.casecmp?("sha224"))
-          end
-        elsif (@options.encrypt.casecmp?("sha256")) or (@options.decrypt.casecmp?("sha256"));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::sha256(line) if (@options.encrypt.casecmp?("sha256"))
-            DeCrypt::sha256(line) if (@options.decrypt.casecmp?("sha256"))
-            }
-          else
-            EnCrypt::sha256(@options.algo) if (@options.encrypt.casecmp?("sha256"))
-            DeCrypt::sha256(@options.algo) if (@options.decrypt.casecmp?("sha256"))
-          end
-        elsif (@options.encrypt.casecmp?("sha384")) or (@options.decrypt.casecmp?("sha384"));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::sha384(line) if (@options.encrypt.casecmp?("sha384"))
-            DeCrypt::sha384(line) if (@options.decrypt.casecmp?("sha384"))
-            } 
-          else
-            EnCrypt::sha384(@options.algo) if (@options.encrypt.casecmp?("sha384"))
-            DeCrypt::sha384(@options.algo) if (@options.decrypt.casecmp?("sha384"))
-          end
-        elsif (@options.encrypt.casecmp?("sha512")) or (@options.decrypt.casecmp?("sha512"));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::sha512(line) if (@options.encrypt.casecmp?("sha512"))
-            DeCrypt::sha512(line) if (@options.decrypt.casecmp?("sha512"))
-            }
-          else
-            EnCrypt::sha512(@options.algo) if (@options.encrypt.casecmp?("sha512"))
-            DeCrypt::sha512(@options.algo) if (@options.decrypt.casecmp?("sha512"))
-          end
-        elsif (@options.encrypt.casecmp?("ripemd160")) or (@options.decrypt.casecmp?("ripemd160"));
+        show = OpenStruct.new
+        show.hash = %w[MD4 MD5 SHA1 SHA224 SHA256 SHA384 SHA512 RIPEMD160]
+        if (show.hash.include?(@options.encrypt.upcase)) or (show.hash.include?(@options.decrypt.upcase));
           if (File.exists?(@options.algo));
             IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::ripemd160(line) if (@options.encrypt.casecmp?("ripemd160"))
-            DeCrypt::ripemd160(line) if (@options.decrypt.casecmp?("ripemd160"))
+              line.chomp!
+              EnCrypt::show(@options.encrypt, line) if (show.hash.include?(@options.encrypt.upcase))
+              DeCrypt::show(@options.decrypt, line) if (show.hash.include?(@options.decrypt.upcase))
             }
           else
-            EnCrypt::ripemd160(@options.algo) if (@options.encrypt.casecmp?("ripemd160"))
-            DeCrypt::ripemd160(@options.algo) if (@options.decrypt.casecmp?("ripemd160"))
+            if (show.hash.include?(@options.encrypt.upcase))
+              EnCrypt::show(@options.encrypt, @options.algo)
+            end
+            if (show.hash.include?(@options.decrypt.upcase))
+              DeCrypt::show(@options.decrypt, @options.algo)
+            end
           end
+        else
+          abort "\e[31m[\e[0m✘\e[31m]\e[0m Invalid Hash Format"
         end
       end
     end

data/lib/cobreak/decifrado.rb

@@ -2,31 +2,33 @@ require 'base64'
 require 'base32'
 require 'base16'
 require 'ascii85'
-
-class Decifrado
-  attr_accessor :data
-  def initialize(data = nil)
-    @data = data
-  end
-  def base16(dato)
-     bas16 = Base16.decode16(dato)
-     puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m DecipherText: #{bas16}\e[0m"
-  end
-  def base32(dato)
-     bas32 = Base32.decode(dato)
-     puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m DecipherText: #{bas32}\e[0m"
-  end
-  def base64(dato)
-     bas64 = Base64.decode64(dato)
-     puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m DecipherText: #{bas64}"
-  end
-  def binary(dato)
-    result = [dato].pack("B*")
-    puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m DecipherText: #{result}"
-  end
-  def ascii85(dato)
-    asci85 = Ascii85.decode(dato)
-    puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m DecipherText: #{asci85}"
+require 'cobreak/cesar'
+require 'cobreak/binary'
+module CoBreak
+  class Decifrado
+    def self.cipher(mode, dato)
+      decipher = OpenStruct.new
+      decipher.mode = mode
+      decipher.dato = dato
+      if (decipher.mode.eql?('base16'))
+        decipher.result = Base16.decode16(decipher.dato)
+      elsif (decipher.mode.eql?('base32'))
+        decipher.result = Base32.decode(decipher.dato)
+      elsif (decipher.mode.eql?('base64'))
+        decipher.result = Base64.decode64(decipher.dato)
+      elsif (decipher.mode.eql?('ascii85'))
+        decipher.result = Ascii85.decode(decipher.dato)
+      elsif (decipher.mode.eql?('cesar'))
+        decipher.result = Cesar.cesar(decipher.dato, ARGV[0].to_i, -1)
+      elsif (decipher.mode.eql?('binary'))
+        decipher.result = CoBreak::Binary.hexbinary(decipher.dato)
+      end
+      unless (decipher.result.nil?) or (decipher.result.eql?(decipher.dato))
+        puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{decipher.result}"
+        puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Number Rotations: #{ARGV[0]}" if (decipher.mode.eql?('cesar'))
+      else
+        puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Cipher Text..."
+      end
+    end
   end
 end
-Decifra = Decifrado.new

data/lib/cobreak/decrypt.rb

@@ -2,109 +2,42 @@ require 'openssl'
 require 'sequel'
 require 'cobreak/version'
 class Decrypt
-  def md4(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'md4.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::MD4.hexdigest(line)}
-    }
-   print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-   puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def md5(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'md5.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::MD5.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def sha1(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha1.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::SHA1.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def sha224(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha224.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::SHA224.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def sha256(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha256.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::SHA256.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def sha384(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha384.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::SHA384.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def sha512(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha512.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::SHA512.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def ripemd160(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'ripemd160.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::RIPEMD160.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
+  def show(mode, dato)
+    decrypt = OpenStruct.new
+    decrypt.mode = mode.downcase
+    decrypt.wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', "#{decrypt.mode}.db")
+    dbs = Sequel.sqlite
+    dbs.create_table? :hashes do
+      String :original
+      String :hash
+    end
+      if (decrypt.mode.eql?('md4'))
+        decrypt.hash = OpenSSL::Digest::MD4.new
+      elsif (decrypt.mode.eql?('md5'))
+        decrypt.hash = OpenSSL::Digest::MD5.new
+      elsif (decrypt.mode.eql?('sha1'))
+        decrypt.hash = OpenSSL::Digest::SHA1.new
+      elsif (decrypt.mode.eql?('sha224'))
+        decrypt.hash = OpenSSL::Digest::SHA224.new
+      elsif (decrypt.mode.eql?('sha256'))
+        decrypt.hash = OpenSSL::Digest::SHA256.new
+      elsif (decrypt.mode.eql?('sha384'))
+        decrypt.hash = OpenSSL::Digest::SHA384.new
+      elsif (decrypt.mode.eql?('sha512'))
+        decrypt.hash = OpenSSL::Digest::SHA512.new
+      elsif (decrypt.mode.eql?('ripemd160'))
+        decrypt.hash = OpenSSL::Digest::RIPEMD160.new
+      end
+    File.foreach(decrypt.wordlist) {|line|
+      line.chomp!
+      dbs[:hashes] << {original:line, hash:decrypt.hash.hexdigest(line)}
+    }
+   decrypt.pass = dbs[:hashes].filter(hash:dato).map(:original)
+   unless (decrypt.pass.empty?)
+     puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash Found: #{decrypt.pass.join(',')}"
+   else
+     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Hash Not Found in Database..."
+   end
   end
 end
 DeCrypt = Decrypt.new