cobreak 0.0.3 → 0.0.9

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

data/lib/cobreak/encrypt.rb

@@ -3,53 +3,34 @@ require 'cobreak/function_db'
 require 'cobreak/function_hash'
 require 'cobreak/version'
 class Encrypt
-  def md4(dato)
-    md4 = OpenSSL::Digest::MD4.hexdigest(dato)
-    puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Encrypted Text: " + md4
-    $datBas::database(md4)
-    DB::database(dato, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'md4.db'))
-  end
-  def md5(dato)
-    md5 = OpenSSL::Digest::MD5.hexdigest(dato)
-    puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Encrypted Text: " + md5
-    DB::database(dato, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'md5.db'))
-    $datBas::database(md5)
-  end
-  def sha1(dato)
-    sha1 = OpenSSL::Digest::SHA1.hexdigest(dato)
-    puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Encrypted Text: " + sha1
-    DB::database(dato, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha1.db'))
-    $datBas::database(sha1)
-  end
-  def sha224(dato)
-    sha224 = OpenSSL::Digest::SHA224.hexdigest(dato)
-    puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Encrypted Text: " + sha224
-    DB::database(dato, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha224.db'))
-    $datBas::database(sha224)
-  end
-  def sha256(dato)
-    sha256 = OpenSSL::Digest::SHA256.hexdigest(dato)
-    puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Encrypted Text: " + sha256
-    DB::database(dato, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha256.db'))
-    $datBas::database(sha256)
-  end
-  def sha384(dato)
-    sha384 = OpenSSL::Digest::SHA384.hexdigest(dato)
-    puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Encrypted Text: " + sha384
-    DB::database(dato, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', '384.db'))
-    $datBas::database(sha384)
-  end
-  def sha512(dato)
-    sha512 = OpenSSL::Digest::SHA512.hexdigest(dato)
-    puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Encrypted Text: " + sha512
-    DB::database(dato, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha512.db'))
-    $datBas::database(sha512)
-  end
-  def ripemd160(dato)
-    ripemd160 = OpenSSL::Digest::RIPEMD160.hexdigest(dato)
-    puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Encrypted Text: " + ripemd160
-    DB::database(dato, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'ripemd160.db'))
-    $datBas::database(ripemd160)
+  def show(mode, dato)
+    encrypt = OpenStruct.new
+    encrypt.mode = mode.downcase
+    encrypt.dato = dato
+    if (encrypt.mode.eql?('md4'))
+      encrypt.crypt = OpenSSL::Digest::MD4.hexdigest(dato)
+    elsif (encrypt.mode.eql?('md5'))
+      encrypt.crypt = OpenSSL::Digest::MD5.hexdigest(dato)
+    elsif (encrypt.mode.eql?('sha1'))
+      encrypt.crypt = OpenSSL::Digest::SHA1.hexdigest(dato)
+    elsif (encrypt.mode.eql?('sha224'))
+      encrypt.crypt = OpenSSL::Digest::SHA224.hexdigest(dato)
+    elsif (encrypt.mode.eql?('sha256'))
+      encrypt.crypt = OpenSSL::Digest::SHA256.hexdigest(dato)
+    elsif (encrypt.mode.eql?('sha384'))
+      encrypt.crypt = OpenSSL::Digest::SHA384.hexdigest(dato)
+    elsif (encrypt.mode.eql?('sha512'))
+      encrypt.crypt = OpenSSL::Digest::SHA512.hexdigest(dato)
+    elsif (encrypt.mode.eql?('ripemd160'))
+      encrypt.crypt = OpenSSL::Digest::RIPEMD160.hexdigest(dato)
+    end
+    unless (encrypt.crypt.nil?)
+      puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Encrypted Text: #{encrypt.crypt}"
+      $datBas::database(encrypt.crypt)
+      DB::database(dato, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'md4.db'))
+    else
+      puts "\n\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Encrypt Text..."
+    end
   end
 end
 EnCrypt = Encrypt.new

data/lib/cobreak/force.rb

@@ -1,5 +1,3 @@
-require 'sequel'
-require 'ostruct'
 require 'cobreak/function_hash'
 class Forze_brute
   def initialize(author = 'BreakerBox')
@@ -20,208 +18,90 @@ class Forze_brute
     arr << dato
     if (ha == arr)
       puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash already existing in the database: #{dato}"
-      puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m decrypt the hash using --decrypt, see the help parameter for more information"
+      puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m show the hash using --show, see the help parameter for more information"
       exit
     end
   end
-  def md4(dato, wordlist)
+  def word(dato, wordlist, type)
     verify(dato)
     forzebrute = OpenStruct.new
-    forzebrute.time = Time.now
     forzebrute.hash = dato
+    forzebrute.type = type
     forzebrute.wordlist = wordlist
-    require 'openssl'
-    File.foreach(forzebrute.wordlist) {|line|
-      line.chomp!      
-      forzebrute.md4 = OpenSSL::Digest::MD4.hexdigest(line)
-      if (forzebrute.md4 == forzebrute.hash)
-        print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-        puts line
-        puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash Cracking #{Time.now - forzebrute.time} seconds"
-        $datBas::database(forzebrute.hash)
-        DB::database(forzebrute.md4, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'md4.db'))
-        exit
+      if (forzebrute.type.downcase.eql?('md4'))
+        forzebrute.crypt = OpenSSL::Digest::MD4.new
+      elsif (forzebrute.type.downcase.eql?('md5'))
+        forzebrute.crypt = OpenSSL::Digest::MD5.new
+      elsif (forzebrute.type.downcase.eql?('sha1'))
+        forzebrute.crypt = OpenSSL::Digest::SHA1.new
+      elsif (forzebrute.type.downcase.eql?('sha224'))
+        forzebrute.crypt = OpenSSL::Digest::SHA224.new
+      elsif (forzebrute.type.downcase.eql?('sha256'))
+        forzebrute.crypt = OpenSSL::Digest::SHA256.new
+      elsif (forzebrute.type.downcase.eql?('sha384'))
+        forzebrute.crypt = OpenSSL::Digest::SHA384.new
+      elsif (forzebrute.type.downcase.eql?('sha512'))
+        forzebrute.crypt = OpenSSL::Digest::SHA512.new
+      elsif (forzebrute.type.downcase.eql?('ripemd160'))
+        forzebrute.crypt = OpenSSL::Digest::RIPEMD160.new
       end
-    }
-   if true
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Decrypted Text: #{dato}"
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Time: #{Time.now - forzebrute.time} seconds"
-   end
-  end
-  def md5(dato, wordlist)
-#    verify(dato)
-    forzebrute = OpenStruct.new
-    forzebrute.hash = dato
-    forzebrute.wordlist = wordlist
-    require 'digest/md5'
-    forzebrute.time = Time.now
-    File.foreach(forzebrute.wordlist) {|line|
-      line.chomp!
-      forzebrute.md5 = Digest::MD5.hexdigest(line)
-      if (forzebrute.md5 == forzebrute.hash)
-        print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-        puts line
-        puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash Cracking #{Time.now - forzebrute.time} seconds"
-        $datBas::database(forzebrute.hash)
-        DB::database(forzebrute.md5, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'md5.db'))
-        exit
-      end
-    }
-   if true
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Decrypted Text: #{dato}"
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Time: #{Time.now - forzebrute.time} seconds"
-     exit
-   end
-  end
-  def sha1(dato, wordlist)
-    verify(dato)
-    forzebrute = OpenStruct.new
-    forzebrute.time = Time.now
-    forzebrute.hash = dato
-    forzebrute.wordlist = wordlist
-    require 'digest/sha1'
-    File.foreach(forzebrute.wordlist) {|line|
-      line.chomp!
-      forzebrute.sha1 = Digest::SHA1.hexdigest(line)
-      if (forzebrute.sha1 == forzebrute.hash)
-        print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-        puts line
-        puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash Cracking #{Time.now - forzebrute.time} seconds"
-        $datBas::database(forzebrute.hash)
-        DB::database(forzebrute.sha1, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha1.db'))
-        exit
-      end
-    }
-   if true
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Decrypted Text: #{dato}"
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Time: #{Time.now - forzebrute.time} seconds"
-   end
-  end
-  def sha224(dato, wordlist)
-    verify(dato)
-    forzebrute = OpenStruct.new
-    forzebrute.time = Time.now
-    forzebrute.hash = dato
-    forzebrute.wordlist = wordlist
-    require 'digest/sha224'
-    File.foreach(forzebrute.wordlist) {|line|
-      line.chomp!
-      forzebrute.sha224 = Digest::SHA224.hexdigest(line)
-      if (forzebrute.sha224 == forzebrute.hash)
-        print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-        puts line
-        puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash Cracking #{Time.now - forzebrute.time} seconds"
-        $datBas::database(forzebrute.hash)
-        DB::database(forzebrute.sha224, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha224.db'))
-        exit
-      end
-    }
-   if true
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Decrypted Text: #{dato}"
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Time: #{Time.now - forzebrute.time} seconds"
-     exit
-   end    
-  end
-  def sha256(dato, wordlist)
-    verify(dato)
-    forzebrute = OpenStruct.new
-    forzebrute.time = Time.now
-    forzebrute.hash = dato
-    forzebrute.wordlist = wordlist
-    require 'digest/sha256'
-    File.foreach(forzebrute.wordlist) {|line|
-      line.chomp!
-      forzebrute.sha256 = Digest::SHA256.hexdigest(line)
-      if (forzebrute.sha256 == forzebrute.hash)
-        print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-        puts line
-        puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash Cracking #{Time.now - forzebrute.time} seconds"
-        $datBas::database(forzebrute.hash)
-        DB::database(forzebrute.sha256, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha256.db'))
-        exit
-      end
-    }
+      forzebrute.time = Time.now
+      File.foreach(forzebrute.wordlist) {|line|
+        line.chomp!
+        if (forzebrute.crypt.hexdigest(line).eql?(forzebrute.hash))
+          puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: " + line
+          puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash Cracking #{Time.now - forzebrute.time} seconds"
+          $datBas::database(forzebrute.hash)
+          DB::database(forzebrute.crypt.hexdigest(line), File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', "#{forzebrute.type}.db"))
+          exit
+        end
+      }
    if true
      puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Decrypted Text: #{dato}"
      puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Time: #{Time.now - forzebrute.time} seconds"
-     exit
    end
   end
-  def sha384(dato, wordlist)
+  def chars(dato, range, char, type)
     verify(dato)
-    forzebrute = OpenStruct.new
-    forzebrute.time = Time.now
-    forzebrute.hash = dato
-    forzebrute.wordlist = wordlist
-    require 'digest/sha384'
-    File.foreach(forzebrute.wordlist) {|line|
-      line.chomp!
-      forzebrute.sha384 = Digest::SHA384.hexdigest(line)
-      if (forzebrute.sha384 == forzebrute.hash)
-        print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-        puts line
-        puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash Cracking #{Time.now - forzebrute.time} seconds"
-        $datBas::database(forzebrute.hash)
-        DB::database(forzebrute.sha384, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha384.db'))
-        exit
-      end
-    }
-   if true
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Decrypted Text: #{forzebrute.hash}"
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Time: #{Time.now - forzebrute.time} seconds"
-     exit
-   end
-  end
-  def sha512(dato, wordlist)
-    verify(dato)
-    forzebrute = OpenStruct.new
-    forzebrute.time = Time.now
-    forzebrute.hash = dato
-    forzebrute.wordlist = wordlist
-    require 'digest/sha512'
-    File.foreach(forzebrute.wordlist) {|line|
-      line.chomp!
-      forzebrute.sha512 = Digest::SHA512.hexdigest(line)
-      if (forzebrute.sha512 == forzebrute.hash)
-        print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-        puts line
-        puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash Cracking #{Time.now - forzebrute.time} seconds"
-        $datBas::database(forzebrute.hash)
-        DB::database(forzebrute.sha512, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha512.db'))
-        exit
-      end
-    }
-   if true
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Decrypted Text: #{forzebrute.hash}"
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Time: #{Time.now - forzebrute.time} seconds"
-     exit
-   end
-  end
-  def ripemd160(dato, wordlist)
-    verify(dato)
-    verify(dato)
-    forzebrute = OpenStruct.new
-    forzebrute.time = Time.now
-    forzebrute.hash = dato
-    forzebrute.wordlist = wordlist
-    require 'digest/rmd160'
-    File.foreach(forzebrute.wordlist) {|line|
-      line.chomp!
-      forzebrute.ripemd160 = Digest::RMD160.hexdigest(line)
-      if (forzebrute.ripemd160 == forzebrute.hash)
-        print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-        puts line
-        puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash Cracking #{Time.now - forzebrute.time} seconds"
-        $datBas::database(forzebrute.hash)
-        DB::database(forzebrute.ripemd160, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'ripemd160.db'))
-        exit
+    forzechars = OpenStruct.new
+    forzechars.dato = dato
+    forzechars.range = range
+    forzechars.char = char.chars
+    forzechars.type = type
+    if (forzechars.type.downcase.eql?('md4'))
+      forzechars.crypt = OpenSSL::Digest::MD4.new
+    elsif (forzechars.type.downcase.eql?('md5'))
+      forzechars.crypt = OpenSSL::Digest::MD5.new
+    elsif (forzechars.type.downcase.eql?('sha1'))
+      forzechars.crypt = OpenSSL::Digest::SHA1.new
+    elsif (forzechars.type.downcase.eql?('sha224'))
+      forzechars.crypt = OpenSSL::Digest::SHA224.new
+    elsif (forzechars.type.downcase.eql?('sha256'))
+      forzechars.crypt = OpenSSL::Digest::SHA256.new
+    elsif (forzechars.type.downcase.eql?('sha384'))
+      forzechars.crypt = OpenSSL::Digest::SHA384.new
+    elsif (forzechars.type.downcase.eql?('sha512'))
+      forzechars.crypt = OpenSSL::Digest::SHA512.new
+    elsif (forzechars.type.downcase.eql?('ripemd160'))
+      forzechars.crypt = OpenSSL::Digest::RIPEMD160.new
+    end
+    forzechars.time = Time.now
+    for range in (forzechars.range[0].to_i..forzechars.range[1].to_i).to_a
+      for chars in forzechars.char.repeated_permutation(range).map(&:join)
+        if (forzechars.crypt.hexdigest(chars.chomp)) == (forzechars.dato)
+          puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: #{chars}"
+          puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash Cracking #{Time.now - forzechars.time} seconds"
+          $datBas::database(forzechars.dato)
+          DB::database(forzechars.crypt.hexdigest(chars), File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', "#{forzechars.type}.db"))
+          exit
+        end
       end
-    }
-   if true
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Decrypted Text: #{forzebrute.hash}"
-     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Time: #{Time.now - forzebrute.time} seconds"
-     exit
-   end
+    end
+    if true
+      puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Decrypted Text..."
+      puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Time: #{Time.now - forzechars.time}"
+    end
   end
 end
 ForzeBrute = Forze_brute.new
+