cobreaktws 1.0.4

data/lib/cobreak/decrypt.rb

@@ -0,0 +1,98 @@
+require 'cobreak/version'
+require 'cobreak/cobreak'
+class Decrypt
+  def show(mode, dato)
+    decrypt = OpenStruct.new
+    decrypt.mode = mode
+    decrypt.wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', "#{decrypt.mode}.db")
+    #decrypt.wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', "MD5.db")
+    dbs = Sequel.sqlite
+    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!
+      if(decrypt.mode.downcase=='md4')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::MD4.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='md5')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::MD5.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='half-md5')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::HALF_MD5.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='sha1')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::SHA1.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='sha2-224')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::SHA2_224.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='sha2-256')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::SHA2_256.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='sha2-384')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::SHA2_384.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='sha2-512')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::SHA2_512.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='sha3-224')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::SHA3_224.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='sha3-256')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::SHA3_256.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='sha3-384')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::SHA3_384.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='sha3-512')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::SHA3_512.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='ripemd-160')
+        dbs[:hashes] << {original:line, hash:CoBreak::OpenSSL::RIPEMD_160.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='tiger-160')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::TIGER_160.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='double-sha1')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::DOUBLE_SHA1.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='blake2s-128')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::BLAKE2S_128.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='blake2s-160')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::BLAKE2S_160.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='blake2s-224')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::BLAKE2S_224.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='blake2s-256')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::BLAKE2S_256.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='blake2b-160')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::BLAKE2B_160.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='blake2b-256')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::BLAKE2B_256.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='blake2b-384')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::BLAKE2B_384.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='blake2b-512')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::BLAKE2B_512.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='whirlpool')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::WHIRLPOOL.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='gost-streebog-256')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::GOST_STREEBOG_256.hexdigest(line)}
+      elsif(decrypt.mode.downcase=='gost-streebog-512')
+        dbs[:hashes] << {original:line, hash:CoBreak::GCrypt::GOST_STREEBOG_512.hexdigest(line)}
+      end
+    }
+   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

data/lib/cobreak/details.rb

@@ -0,0 +1,19 @@
+module CoBreak
+  class Details
+    def self.info()
+      return "The CoBreak script is an cipher and cryptography tool made with the purpose of facilitating the encryption of data or others, it includes parameters to brute force the hashes through dictionaries"
+    end
+    def self.dependecias()
+      return %w(gcrypt openmp openssl sequel sqlite3)
+    end
+    def self.date()
+      return "2020-5-25"
+    end
+    def self.cipher()
+      return %w(base64 base32 base16 ascii85 cesar binary)
+    end
+    def self.crypt()
+      return %w(MD4 MD5 HALF-MD5 SHA1 SHA2-224 SHA2-256 SHA2-384 SHA2-512 SHA3-224 SHA3-256 SHA3-384 SHA3-512 RIPEMD-160 TIGER-160 DOUBLE-SHA1 BLAKE2S-128 BLAKE2S-160 BLAKE2B-160 BLAKE2S-224 BLAKE2S-256 BLAKE2B-256 BLAKE2B-384 BLAKE2B-512 WHIRLPOOL GOST-STREEBOG-256 GOST-STREEBOG-512 SHAKE-128)
+    end
+  end
+end

data/lib/cobreak/encrypt.rb

@@ -0,0 +1,114 @@
+require 'cobreak/function_db' 
+require 'cobreak/function_hash'
+require 'cobreak/cobreak'
+require 'cobreak/version'
+
+class Encrypt
+  def show(mode, dato)
+    bool = File.open(File.join(Gem.path[1], "gems","cobreak-#{CoBreak.version}" , "lib", "cobreak", "config", "database.db"))
+    bool = bool.readlines[0].to_s.chomp
+    encrypt = OpenStruct.new
+    encrypt.mode = mode.downcase
+    encrypt.dato = dato
+    case encrypt.mode
+      when ('md4')
+        encrypt.crypt = CoBreak::OpenSSL::MD4.hexdigest(dato)
+        out_db = 'MD4'
+      when ('md5')
+        encrypt.crypt = CoBreak::OpenSSL::MD5.hexdigest(dato)
+        out_db = 'MD5'
+      when ('half-md5')
+        encrypt.crypt = CoBreak::OpenSSL::HALF_MD5.hexdigest(dato)
+        out_db = 'HALF-MD5'
+      when ('sha1')
+        encrypt.crypt = CoBreak::OpenSSL::SHA1.hexdigest(dato)
+        out_db = 'SHA1'
+      when ('sha2-224')
+        encrypt.crypt = CoBreak::OpenSSL::SHA2_224.hexdigest(dato)
+        out_db = 'SHA2-224'
+      when ('sha2-256')
+        encrypt.crypt = CoBreak::OpenSSL::SHA2_256.hexdigest(dato)
+        out_db = 'SHA2-256'
+      when ('sha2-384')
+        encrypt.crypt = CoBreak::OpenSSL::SHA2_384.hexdigest(dato)
+        out_db = 'SHA2-384'
+      when ('sha2-512')
+        encrypt.crypt = CoBreak::OpenSSL::SHA2_512.hexdigest(dato)
+        out_db = 'SHA2-512'
+      when ('sha3-224')
+        encrypt.crypt = CoBreak::OpenSSL::SHA3_224.hexdigest(dato)
+        out_db = 'SHA3-224'
+      when ('sha3-256')
+        encrypt.crypt = CoBreak::OpenSSL::SHA3_256.hexdigest(dato)
+        out_db = 'SHA3-256'
+      when ('sha3-384')
+        encrypt.crypt = CoBreak::OpenSSL::SHA3_384.hexdigest(dato)
+        out_db = 'SHA3-384'
+      when ('sha3-512')
+        encrypt.crypt = CoBreak::OpenSSL::SHA3_512.hexdigest(dato)
+        out_db = 'SHA3-512'
+      when ('ripemd-160')
+        encrypt.crypt = CoBreak::OpenSSL::RIPEMD_160.hexdigest(dato)
+        out_db = 'RIPEMD-160'
+      when ('SHAKE-128')
+        encrypt.crypt = CoBreak::GCrypt::SHAKE_128.hexdigest(dato)
+        out_db = 'SHAKE-128'
+      when ('gost-streebog-256')
+        encrypt.crypt = CoBreak::GCrypt::GOST_STREEBOG_256.hexdigest(dato)
+        out_db = 'GOST-STREEBOG-256'
+      when ('gost-streebog-512')
+        encrypt.crypt = CoBreak::GCrypt::GOST_STREEBOG_512.hexdigest(dato)
+        out_db = 'GOST-STREEBOG-512'
+      when ('tiger-160')
+        encrypt.crypt = CoBreak::GCrypt::TIGER_160.hexdigest(dato)
+        out_db = 'TIGER-160'
+      when ('double-sha1')
+        encrypt.crypt = CoBreak::GCrypt::DOUBLE_SHA1.hexdigest(dato)
+        out_db = 'DOUBLE-SHA1'
+      when ('blake2s-128')
+        encrypt.crypt = CoBreak::GCrypt::BLAKE2S_128.hexdigest(dato)
+        out_db = 'BLAKE2S-128'
+      when ('blake2s-160')
+        encrypt.crypt = CoBreak::GCrypt::BLAKE2S_160.hexdigest(dato)
+        out_db = 'BLAKE2S-160'
+      when ('blake2b-160')
+        encrypt.crypt = CoBreak::GCrypt::BLAKE2B_160.hexdigest(dato)
+        out_db = 'BLAKE2B-160'
+      when ('blake2s-224')
+        encrypt.crypt = CoBreak::GCrypt::BLAKE2S_224.hexdigest(dato)
+        out_db = 'BLAKE2S-224'
+      when ('blake2s-256')
+        encrypt.crypt = CoBreak::GCrypt::BLAKE2S_256.hexdigest(dato)
+        out_db = 'BLAKE2S-256'
+      when ('blake2b-256')
+        encrypt.crypt = CoBreak::GCrypt::BLAKE2B_256.hexdigest(dato)
+        out_db = 'BLAKE2B-256'
+      when ('blake2b-384')
+        encrypt.crypt = CoBreak::GCrypt::BLAKE2B_384.hexdigest(dato)
+        out_db = 'BLAKE2B-384'
+      when ('blake2b-512')
+        encrypt.crypt = CoBreak::GCrypt::BLAKE2B_512.hexdigest(dato)
+        out_db = 'BLAKE2B-512'
+      when ('whirlpool')
+        encrypt.crypt = CoBreak::GCrypt::WHIRLPOOL.hexdigest(dato)
+        out_db = 'WHIRLPOOL'
+      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}"
+      begin
+        if bool.eql?('true')
+          $datBas::database(encrypt.crypt)
+          DB::database(dato, File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', "#{out_db}.db"))
+          puts "\n\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Hash Saved In The Database"
+        end
+      rescue Errno::EACCES
+        puts "\n\n\e[1;31m[\e[1;37m✘\e[1;31m]\e[1;37m Access Denied"
+        puts "\e[1;31m[\e[1;37m✘\e[1;31m]\e[1;37m You need root privileges to save the hash to the database"
+      end
+    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

@@ -0,0 +1,226 @@
+require 'cobreak/function_hash'
+require 'cobreak/cobreak'
+class Forze_brute
+  attr_accessor :hash_input, :type_hash, :crypt, :min_chr, :max_chr, :charact, :word, :wordlist, :result, :out, :verbose, :crack
+  def initialize(author = 'BreakerTW')
+    @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 :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
+  def word(dato, wordlist, type, out, verbose = false)
+    begin
+      raise Errno::EACCES, "\e[1;31m[\e[1;37m✘\e[1;31m]\e[1;37m root privileges needed" if `whoami`.chomp != "root"
+    rescue  Errno::EACCES => e
+      puts e.message
+      exit
+    end
+    forzebrute = OpenStruct.new
+    @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 (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
+      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', "#{out_db}.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
+  end
+  def chars(dato, range, char, type, out, verbose = false)
+    begin
+      raise Errno::EACCES, "\e[1;31m[\e[1;37m✘\e[1;31m]\e[1;37m root privileges needed" if `whoami`.chomp != "root"
+    rescue  Errno::EACCES => e
+      puts e.message
+      exit
+    end
+    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')
+              forzechars.type = forzechars.type.downcase
+              $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
+            return 0
+          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
+end
+ForzeBrute = Forze_brute.new

data/lib/cobreak/force_brute.rb

@@ -0,0 +1,62 @@
+#!/bin/env ruby
+require 'ruby_figlet'
+require 'cobreak/version'
+using RubyFiglet
+module CoBreak
+  class BruteForze
+    def initialize(options)
+      @options = options
+      @hash = %w[MD4 MD5 SHA1 SHA224 SHA256 SHA384 SHA512 RIPEMD160]
+    end
+    begin
+      require 'cobreak/force'
+    rescue LoadError => e
+      puts e.message
+      abort "reinstall gem new"
+    end
+    def banner_wordlist()
+      puts "\e[0;31m"
+      puts "cobreak".art("Bloody")
+      puts "\e[0m"
+      puts "\e[1;32m╭─[\e[37m CoBreak: #{CoBreak.version}"
+      if (File.exists?(@options.wordlist.to_s))
+        puts "\e[1;32m├─[\e[37m Wordlist: #{File.expand_path(@options.wordlist)}"
+      else
+        puts "\e[1;31m├─[\e[37m WordList Not Found"
+      end
+      if (@hash.include?(@options.bruteforce.to_s.upcase))
+        puts "\e[1;32m├─[\e[37m Type Hash: #{@options.bruteforce.upcase}"
+      else
+        puts "\e[1;31m├─[\e[37m Type Hash Not Found"
+      end
+      unless (@options.algo.nil?) or (@options.algo.empty?)
+        puts "\e[1;32m╰─[\e[37m Hash: #{@options.algo}\n\n"
+      else
+        puts "\e[1;31m╰─[\e[37m Hash Not Found"
+      end
+    end
+    def wordlist()
+      if (@options.wordlist.nil?) or (@options.wordlist.empty?) or ('-'.include?(@options.wordlist.to_s))
+        abort "\n"
+      end
+      if (@hash.include?(@options.bruteforce.to_s.upcase))
+        if (File.exists?(@options.algo.to_s))
+          begin
+            IO.foreach(@options.algo.to_s){|line|
+              line.chomp!
+              if (@hash.include?(@options.bruteforce.to_s.upcase))
+                ForzeBrute::word(line, @options.wordlist, @options.bruteforce.to_s, @options.out, @options.verbose)
+              end
+            }
+          rescue ArgumentError => e
+            puts e.message
+          end
+        else
+          if (@hash.include?(@options.bruteforce.upcase.to_s))
+            ForzeBrute::word(@options.algo.to_s, @options.wordlist, @options.bruteforce.to_s, @options.out, @options.verbose)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cobreak/force_chars.rb

@@ -0,0 +1,54 @@
+require 'ostruct'
+require 'ruby_figlet'
+using RubyFiglet
+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[0;31m"
+      puts "cobreak".art("Bloody")
+      puts "\e[0m"
+      puts "\e[1;32m╭─[\e[1;37m CoBreak: #{CoBreak.version}"
+      unless (@options.range.nil?)
+        puts "\e[32m├─[\e[1;37m Range: #{@options.range[0]} #{@options.range[1]}"
+      else
+        puts "\e[31m├─[\e[1;37m Range Not Found"
+      end
+      unless (@options.chars.nil?) or (@options.chars.empty?)
+        puts "\e[32m├─[\e[1;37m Characters: #{@options.chars}"
+      else
+        puts "\e[31m├─[\e[1;37m Characters Not Found"
+      end
+      if (@hash.include?(@options.bruteforce.to_s.upcase))
+        puts "\e[32m├─[\e[1;37m Type Hash: #{@options.bruteforce.upcase}"
+      else
+        puts "\e[31m├─[\e[1;37m Type Hash Not Found"
+      end
+      unless (@options.algo.nil?) or (@options.algo.empty?)
+        puts "\e[32m╰─[\e[1;37m Hash: #{@options.algo}\n\n"
+      else
+        puts "\e[31m╰─[\e[1;37m 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!
+            ForzeBrute::chars(line, @options.range, @options.chars, @options.bruteforce, @options.out, @options.verbose)
+          }
+        else
+          if (@hash.include?(@options.bruteforce.upcase))
+            ForzeBrute::chars(@options.algo, @options.range, @options.chars, @options.bruteforce, @options.out, @options.verbose)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cobreak/function_db.rb

@@ -0,0 +1,26 @@
+require 'sequel'
+class DataBase
+  $db = Sequel.sqlite
+  $db.create_table? :database do
+    String :text_db
+  end
+  def initialize(alg = nil)
+  @alg = alg
+  end
+  def database(alg, var1)
+    if File.exists?(var1) == false
+      FileUtils.touch(var1)
+    end
+      IO.foreach(var1) {|line|
+        line.chomp!
+        $db[:database] << {text_db:line}
+      }
+      if ($db[:database].filter(text_db:alg).map(:text_db)).include?(alg) == true
+        exit
+      end
+      File.open(var1, mode: 'a'){|lin|
+        lin.puts alg
+      }
+  end
+end
+DB = DataBase.new

data/lib/cobreak/function_hash.rb

@@ -0,0 +1,28 @@
+require 'cobreak/version'
+require 'fileutils'
+class BaseDato
+  $db = Sequel.sqlite
+  $db.create_table? :database do
+    String :text_db
+  end
+  def initialize(alg = nil)
+  @alg = alg
+  end
+  def database(alg)
+    	var1 = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'hash', 'hash.db')
+    	if File.exists?(var1) == false
+      		FileUtils.touch(var1)
+    	end
+      	IO.foreach(var1) {|line|
+        	line.chomp!
+        	$db[:database] << {text_db:line}
+      	}
+      	if ($db[:database].filter(text_db:alg).map(:text_db)).include?(alg) == true
+        	exit
+      	end
+      	File.open(var1, mode: 'a'){|lin|
+        	lin.puts alg
+      	} 
+  end
+end
+$datBas = BaseDato.new

data/lib/cobreak/hash/hash.db

@@ -0,0 +1 @@
+

data/lib/cobreak/info_author.rb

@@ -0,0 +1,20 @@
+module CoBreak
+  class Author
+    def self.author()
+      return "BreakerTW"
+    end
+    def self.email()
+      return "breakerhtb@gmail.com"
+    end
+    def self.date()
+      return "2020-5-25"
+    end
+    def self.telegram()
+      return "@BreakerBox"
+    end
+    def self.group()
+      group = "https://t.me/Black0utx"
+      return group
+    end
+  end
+end