cobreak 0.0.4 → 1.0.1

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.crypt.hexdigest(line))
+          DB::database(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.crypt.hexdigest(chars))
+          DB::database(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
+

data/lib/cobreak/force_brute.rb

@@ -39,40 +39,12 @@ module CoBreak
           IO.foreach(@options.algo.to_s){|line|
             line.chomp!
             if (@options.bruteforce.to_s.downcase.eql?('md4'))
-              ForzeBrute::md4(line, @options.wordlist)
-            elsif (@options.bruteforce.to_s.downcase.eql?('md5'))
-              ForzeBrute::md5(line, @options.wordlist)
-            elsif (@options.bruteforce.to_s.downcase.eql?('sha1'))
-              ForzeBrute::sha1(line, @options.wordlist)
-            elsif (@options.bruteforce.to_s.downcase.eql?('sha224'))
-              ForzeBrute::sha224(line, @options.wordlist)
-            elsif (@options.bruteforce.to_s.downcase.eql?('sha256'))
-              ForzeBrute::sha256(line, @options.wordlist)
-            elsif (@options.bruteforce.to_s.downcase.eql?('sha384'))
-              ForzeBrute::sha384(line, @options.wordlist)
-            elsif (@options.bruteforce.to_s.downcase.eql?('sha512'))
-              ForzeBrute::sha512(line, @options.wordlist)
-            elsif (@options.bruteforce.to_s.downcase.eql?('ripemd160'))
-              ForzeBrute::ripemd160(line, @options.wordlist)
+              ForzeBrute::word(line, @options.wordlist, @options.bruteforce.to_s)
             end
           }
         else
-          if (@options.bruteforce.to_s.downcase.eql?('md4'))
-            ForzeBrute::md4(@options.algo.to_s, @options.wordlist)
-          elsif (@options.bruteforce.to_s.downcase.eql?('md5'))
-            ForzeBrute::md5(@options.algo.to_s, @options.wordlist)
-          elsif (@options.bruteforce.to_s.downcase.eql?('sha1'))
-            ForzeBrute::sha1(@options.algo.to_s, @options.wordlist)
-          elsif (@options.bruteforce.to_s.downcase.eql?('sha224'))
-            ForzeBrute::sha224(@options.algo.to_s, @options.wordlist)
-          elsif (@options.bruteforce.to_s.downcase.eql?('sha256'))
-            ForzeBrute::sha256(@options.algo.to_s, @options.wordlist)
-          elsif (@options.bruteforce.to_s.downcase.eql?('sha384'))
-            ForzeBrute::sha384(@options.algo.to_s, @options.wordlist)
-          elsif (@options.bruteforce.to_s.downcase.eql?('sha512'))
-            ForzeBrute::sha512(@options.algo.to_s, @options.wordlist)
-          elsif (@options.bruteforce.to_s.downcase.eql?('ripemd160'))
-            ForzeBrute::ripemd160(@options.algo.to_s, @options.wordlist)
+          if (@hash.include?(@options.bruteforce.upcase))
+            ForzeBrute::word(@options.algo.to_s, @options.wordlist, @options.bruteforce.to_s)
           end
         end
       end

data/lib/cobreak/force_chars.rb

@@ -0,0 +1,65 @@
+require 'ostruct'
+module CoBreak
+  class BruteChars
+    def initialize(options)
+      @options = options
+      @hash = %w[MD4 MD5 SHA1 SHA224 SHA256 SHA384 SHA512 RIPEMD160]
+    end
+    def banner_chars()
+      puts "\e[32m╭─[\e[0m CoBreak: #{CoBreak.version}"
+      unless (@options.range.nil?)
+        puts "\e[32m├─[\e[0m Range: #{@options.range[0]} #{@options.range[1]}"
+      else
+        puts "\e[31m├─[\e[0m Range Not Found"
+      end
+      unless (@options.chars.nil?) or (@options.chars.empty?)
+        puts "\e[32m├─[\e[0m Characters: #{@options.chars}"
+      else
+        puts "\e[31m├─[\e[0m Characters Not Found"
+      end
+      if (@hash.include?(@options.bruteforce.to_s.upcase))
+        puts "\e[32m├─[\e[0m Type Hash: #{@options.bruteforce.upcase}"
+      else
+        puts "\e[31m├─[\e[0m Type Hash Not Found"
+      end
+      unless (@options.algo.nil?) or (@options.algo.empty?)
+        puts "\e[32m╰─[\e[0m Hash: #{@options.algo}\n\n"
+      else
+        puts "\e[31m╰─[\e[0m Hash Not Found"
+      end
+    end
+    def chars()
+#      if (@options.range.empty?) or (@options.chars.nil?) or (@param.algo.nil?)
+#        abort "\n"
+#      end"
+      if (@hash.include?(@options.bruteforce.upcase))
+        if (File.exists?(@options.algo.to_s))
+          IO.foreach(@options.algo){|line|
+            line.chomp!
+            if (@options.bruteforce.to_s.downcase.eql?('md4'))
+              ForzeBrute::md4(line, @options)
+            elsif (@options.bruteforce.to_s.downcase.eql?('md5'))
+              ForzeBrute::md5(line, @options)
+            elsif (@options.bruteforce.to_s.downcase.eql?('sha1'))
+              ForzeBrute::sha1(line, @options)
+            elsif (@options.bruteforce.to_s.downcase.eql?('sha224'))
+              ForzeBrute::sha224(line, @options)
+            elsif (@options.bruteforce.to_s.downcase.eql?('sha256'))
+              ForzeBrute::sha256(line, @options)
+            elsif (@options.bruteforce.to_s.downcase.eql?('sha384'))
+              ForzeBrute::sha384(line, @options)
+            elsif (@options.bruteforce.to_s.downcase.eql?('sha512'))
+              ForzeBrute::sha512(line, @options)
+            elsif (@options.bruteforce.to_s.downcase.eql?('ripemd160'))
+              ForzeBrute::ripemd160(line, @options)
+            end
+          }
+        else
+          if (@hash.include?(@options.bruteforce.upcase))
+            ForzeBrute::chars(@options.algo, @options.range, @options.chars, @options.bruteforce)
+          end
+        end
+      end
+    end
+  end
+end