class Forze_brute

Attributes

charact[RW]
crack[RW]
crypt[RW]
hash_input[RW]
max_chr[RW]
min_chr[RW]
out[RW]
result[RW]
type_hash[RW]
verbose[RW]
word[RW]
wordlist[RW]

Public Class Methods

new(author = 'BreakerBox') click to toggle source
# File lib/cobreak/force.rb, line 4
def initialize(author = 'BreakerBox')
  @author = author
  @result = nil
  @crack = nil
  @crypt = nil
  @dict = nil
  @word = nil
end

Public Instance Methods

chars(dato, range, char, type, out, verbose = false) click to toggle source
# File lib/cobreak/force.rb, line 135
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
  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
verify(dato, word = File.join(Gem.path[1], "gems", "cobreak- click to toggle source
# File lib/cobreak/force.rb, line 12
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 :hash
  end
  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[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