cobreak 0.0.6 → 1.0.2

data/lib/cobreak/encrypt.rb

@@ -3,53 +3,36 @@ 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
+    case encrypt.mode
+      when ('md4')
+        encrypt.crypt = OpenSSL::Digest::MD4.hexdigest(dato)
+      when ('md5')
+        encrypt.crypt = OpenSSL::Digest::MD5.hexdigest(dato)
+      when ('sha1')
+        encrypt.crypt = OpenSSL::Digest::SHA1.hexdigest(dato)
+      when ('sha224')
+        encrypt.crypt = OpenSSL::Digest::SHA224.hexdigest(dato)
+      when ('sha256')
+        encrypt.crypt = OpenSSL::Digest::SHA256.hexdigest(dato)
+      when ('sha384')
+        encrypt.crypt = OpenSSL::Digest::SHA384.hexdigest(dato)
+      when ('sha512')
+        encrypt.crypt = OpenSSL::Digest::SHA512.hexdigest(dato)
+      when ('ripemd160')
+        encrypt.crypt = OpenSSL::Digest::RIPEMD160.hexdigest(dato)
+      else "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Type Hash Not Found"
+    end
+    unless (encrypt.crypt.nil?)
+      puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Encrypted Text: #{encrypt.crypt}"
+      $datBas::database(encrypt.crypt)
+      DB::database(dato, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', "#{encrypt.mode}.db"))
+    else
+      puts "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Not Encrypt Text..."
+    end
   end
 end
 EnCrypt = Encrypt.new

data/lib/cobreak/force.rb

@@ -1,227 +1,212 @@
-require 'sequel'
-require 'ostruct'
 require 'cobreak/function_hash'
 class Forze_brute
+  attr_accessor :hash_input, :type_hash, :crypt, :min_chr, :max_chr, :charact, :word, :wordlist, :result, :out, :verbose, :crack
   def initialize(author = 'BreakerBox')
     @author = author
+    @result = nil
+    @crack = nil
+    @crypt = nil
+    @dict = nil
+    @word = nil
   end
   def verify(dato, word = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'hash', 'hash.db'))
     hash_db = Sequel.sqlite
     hash_db.create_table? :datahash do
       String :ori
-      String :has
+      String :hash
     end
-    IO.foreach(word) {|lin|
-      lin = lin.chomp
-      hash_db[:datahash] << {ori:lin, has:dato}
-    }
-    ha = hash_db[:datahash].filter(ori:dato).map(:has)
+    begin
+      IO.foreach(word) {|lin|
+        lin = lin.chomp
+        hash_db[:datahash] << {ori:lin, hash:dato}
+      }
+    rescue Errno::ENOENT
+      return
+    end
+    ha = hash_db[:datahash].filter(ori:dato).map(:hash)
     arr = Array.new
     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[1;37m+\e[1;32m]\e[1;37m Hash already existing in the database: #{dato}"
+      puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m show the hash using --show, see the help parameter for more information\e[0m"
       exit
     end
   end
-  def md4(dato, wordlist)
-    verify(dato)
+  def word(dato, wordlist, type, out, verbose = false)
     forzebrute = OpenStruct.new
-    forzebrute.time = Time.now
-    forzebrute.hash = dato
-    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
-      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
+    @hash_input = dato
+    @type_hash = type
+    @out = out
+    @verbose = verbose
+    @wordlist = wordlist
+    File.foreach(File.join(Gem.path[1], "gems","cobreak-#{CoBreak.version}" , "lib", "cobreak", "config", "database.db"), mode: 'r'){|booleano|
+    forzebrute.booleano = booleano
+    if (booleano.eql?('true'))
+      verify(dato)
+    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)
-    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
+      if (type_hash.downcase.eql?('md4'))
+        @crypt = OpenSSL::Digest::MD4.new
+      elsif (type_hash.downcase.eql?('md5'))
+        @crypt = OpenSSL::Digest::MD5.new
+      elsif (type_hash.downcase.eql?('sha1'))
+        @crypt = OpenSSL::Digest::SHA1.new
+      elsif (type_hash.downcase.eql?('sha224'))
+        @crypt = OpenSSL::Digest::SHA224.new
+      elsif (type_hash.downcase.eql?('sha256'))
+        @crypt = OpenSSL::Digest::SHA256.new
+      elsif (type_hash.downcase.eql?('sha384'))
+        @crypt = OpenSSL::Digest::SHA384.new
+      elsif (type_hash.downcase.eql?('sha512'))
+        @crypt = OpenSSL::Digest::SHA512.new
+      elsif (type_hash.downcase.eql?('ripemd160'))
+        @crypt = OpenSSL::Digest::RIPEMD160.new
       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'))
+      lin = 0
+      forzebrute.time = Time.now
+        begin
+          if (verbose)
+            thread = Thread.new do
+              dict = File.open(wordlist, mode: 'r')
+              while word = dict.gets
+                lin += 1
+                $word = word
+                if (crypt.hexdigest(word.chomp).eql?(hash_input))
+                  @result = word
+                  verbose = false
+                  thread.kill
+                end
+              end
+              verbose = 'no'
+            end
+          else
+            dict = File.open(wordlist, mode: 'r')
+            while word = dict.gets
+              lin += 1
+              begin
+                if (crypt.hexdigest(word.chomp).eql?(hash_input.chomp))
+                  @result = word
+                  verbose = false
+                  break
+                end
+              rescue
+              end
+            end
+          end
+          while (verbose == true)
+            STDOUT.flush
+            begin
+              print "\r\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Password Crack: #{$word.chomp}" + " " *30
+            rescue
+            end
+            sleep(0.1)
+          end
+          if (verbose == false)
+            puts "\r\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Password Crack: #{result}"
+            puts "\r\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Number of lines: #{lin}"
+            puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Hash Cracking in #{Time.now - forzebrute.time} seconds"
+          else
+            puts "\r\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Not Cracking Text: #{hash_input}"
+            puts "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Time: #{Time.now - forzebrute.time} seconds\e[0m"
+          end
+          if (forzebrute.booleano.eql?('true'))
+            $datBas::database(crypt.hexdigest(wordlist.chomp))
+            DB::database(result, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', "#{type_hash}.db"))
+          end
+          if !(result.nil?)
+            if !(out.nil?)
+              File.open(out, mode: 'a'){|out|
+                out.puts "=================================================="
+                out.puts "software: CoBreak #{CoBreak.version}"
+                out.puts "Type Hash: #{type_hash}\n"
+                out.puts "#{result.chomp}:#{crypt.hexdigest(result)}"
+                out.puts "=================================================="
+              }
+            end
+          end
+        rescue Interrupt
+        puts "\n\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Interrupt mode"
+        puts "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Password Not Cracked"
+        puts "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Number of Lines: #{lin}"
+        puts "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Wait Time: #{Time.now - forzebrute.time} seconds\e[0m"
         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
+  def chars(dato, range, char, type, out, verbose = false)
+    bool = File.open(File.join(Gem.path[1], "gems","cobreak-#{CoBreak.version}" , "lib", "cobreak", "config", "database.db"))
+    bool = bool.readlines[0].to_s.chomp
+    if (bool.eql?('true'))
+      verify(dato)
+    end
+    forzechars = OpenStruct.new
+    forzechars.dato = dato
+    forzechars.range = range
+    forzechars.char = char.chars
+    forzechars.type = type
+    forzechars.out = out
+    forzechars.verbose = verbose
+    forzechars.cont = Array.new
+    forzechars.result = nil
+    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
+    lin = 0
+    begin
+      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)
+          lin += 1
+          if (forzechars.verbose.eql?(true))
+            print "\r\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Password Crack: #{chars}"
+          end
+          if (forzechars.crypt.hexdigest(chars).eql?(forzechars.dato))
+            forzechars.result = chars
+            puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Password Crack: #{chars}"
+            puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Number of Lines: #{lin}"
+            puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Hash Cracking in #{Time.now - forzechars.time} seconds"
+            if bool.eql?('true')
+              $datBas::database(forzechars.crypt.hexdigest(chars))
+              DB::database(chars, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', "#{forzechars.type}.db"))
+            end
+            if !(forzechars.out.nil?)
+              File.open(forzechars.out, mode: 'a'){|out|
+                out.puts "=================================================="
+                out.puts "software: CoBreak #{CoBreak.version}"
+                out.puts "Type Hash: #{forzechars.type}\n"
+                out.puts "#{chars}:#{forzechars.crypt.hexdigest(chars)}"
+                out.puts "=================================================="
+              }
+            end
+            break
+          end
+        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
+    rescue Interrupt
+      puts "\n\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Interrupt mode"
+      puts "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Password Not Cracked"
+      puts "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Number of Lines: #{lin}"
+      puts "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Wait Time: #{Time.now - forzechars.time} seconds\e[0m"
+      exit
+    end
+    if (forzechars.result.nil?)
+      puts "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Not Cracking Text: #{forzechars.dato}"
+      puts "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Time: #{Time.now - forzechars.time}\e[0m"
+      exit
+    end
   end
 end
-ForzeBrute = Forze_brute.new
+ForzeBrute = Forze_brute.new