cobreak 0.0.6 → 1.0.2

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)
-    alfa_mayus = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    alfa_minus = "abcdefghijklmnopqrstuvwxyz"
+    cesar = OpenStruct.new
+    cesar.cad_rot = []
+    alfa_mayus = ('A'..'Z').to_a
+    alfa_minus = ('a'..'z').to_a
     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[37m+\e[1;32m]\e[37m Ciphertext: #{cipher.result}"
+        puts "\e[1;32m[\e[37m+\e[1;32m]\e[37m Number Rotations: #{ARGV[0]}" if (cipher.mode.eql?('cesar'))
+      else
+        puts "\e[1;31m[\e[37m+\e[1;31m]\e[37m 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.crypt = %w[MD4 MD5 SHA1 SHA224 SHA256 SHA384 SHA512 RIPEMD160]
+        if (show.crypt.include?(@options.encrypt.upcase)) or (show.crypt.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.crypt.include?(@options.encrypt.upcase))
+              DeCrypt::show(@options.decrypt, line) if (show.crypt.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.crypt.include?(@options.encrypt.upcase))
+              EnCrypt::show(@options.encrypt, @options.algo)
+            end
+            if (show.crypt.include?(@options.decrypt.upcase))
+              DeCrypt::show(@options.decrypt, @options.algo)
+            end
           end
+        else
+          abort "\e[31m[\e[37m✘\e[31m]\e[37m Invalid Hash Format"
         end
       end
     end

data/lib/cobreak/decifrado.rb

@@ -2,31 +2,35 @@ 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[37m+\e[1;32m]\e[37m DecipherText: #{decipher.result}"
+        if (decipher.mode.eql?('cesar'))
+          puts "\e[1;32m[\e[37m+\e[1;32m]\e[37m Number Rotations: #{ARGV[0]}"
+        end
+      else
+        puts "\e[1;31m[\e[37m+\e[1;31m]\e[37m Not Cipher Text..."
+      end
+    end
   end
 end
-Decifra = Decifrado.new

data/lib/cobreak/decrypt.rb

@@ -1,110 +1,43 @@
-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
+      case decrypt.mode
+        when ('md4')
+          decrypt.crypt = OpenSSL::Digest::MD4.new
+        when ('md5')
+          decrypt.crypt = OpenSSL::Digest::MD5.new
+        when ('sha1')
+          decrypt.crypt = OpenSSL::Digest::SHA1.new
+        when ('sha224')
+          decrypt.crypt = OpenSSL::Digest::SHA224.new
+        when ('sha256')
+          decrypt.crypt = OpenSSL::Digest::SHA256.new
+        when ('sha384')
+          decrypt.crypt = OpenSSL::Digest::SHA384.new
+        when ('sha512')
+          decrypt.crypt = OpenSSL::Digest::SHA512.new
+        when ('ripemd160')
+          decrypt.crypt = OpenSSL::Digest::RIPEMD160.new
+      end
+    File.foreach(decrypt.wordlist) {|line|
+      line.chomp!
+      dbs[:hashes] << {original:line, hash:decrypt.crypt.hexdigest(line)}
+    }
+   decrypt.pass = dbs[:hashes].filter(hash:dato).map(:original)
+   unless (decrypt.pass.empty?)
+     puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Type Hash: #{decrypt.mode}"
+     puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Hash Found: #{decrypt.pass.join(',')}\e[0m"
+   else
+     puts "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Hash Not Found in Database...\e[0m"
+   end
   end
 end
 DeCrypt = Decrypt.new