cobreak 0.0.3

data/lib/cobreak/force.rb

@@ -0,0 +1,227 @@
+require 'sequel'
+require 'ostruct'
+require 'cobreak/function_hash'
+class Forze_brute
+  def initialize(author = 'BreakerBox')
+    @author = author
+  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
+    end
+    IO.foreach(word) {|lin|
+      lin = lin.chomp
+      hash_db[:datahash] << {ori:lin, has:dato}
+    }
+    ha = hash_db[:datahash].filter(ori:dato).map(:has)
+    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"
+      exit
+    end
+  end
+  def md4(dato, wordlist)
+    verify(dato)
+    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
+    }
+   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
+      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
+      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
+end
+ForzeBrute = Forze_brute.new

data/lib/cobreak/force_brute.rb

@@ -0,0 +1,81 @@
+#!/bin/env ruby
+require 'cobreak/version'
+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[32m╭─[\e[0m CoBreak: #{CoBreak.version}"
+      if (File.exists?(@options.wordlist.to_s))
+        puts "\e[32m├─[\e[0m Wordlist: #{File.expand_path(@options.wordlist)}"
+      else
+        puts "\e[31m├─[\e[0m WordList 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 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))
+          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)
+            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)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cobreak/function_db.rb

@@ -0,0 +1,27 @@
+require 'fileutils'
+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,29 @@
+require 'fileutils'
+require 'sequel'
+require 'cobreak/version'
+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,29 @@
+ac5585d98646d255299c359140537783
+4d186321c1a7f0f354b297e8914ab240
+849ceedae14b70e6292c58f27454cff4
+0fb0a49e3068aae01d664978c56a2291
+4cecb21b44628b17c436739bf6301af2
+187ef4436122d1cc2f40dc2b92f0eba0
+b86fc6b051f63d73de262d4c34e3a0a9
+670da91be64127c92faac35c8300e814
+f9ca81659235ad6de39c77cb7154f30d
+0ef546118008f6fb7ebab60c7e3cee2f
+fb8d211b98db3feb5206ed7501749cd8
+2466ed15c785916f782b6ab6daa558df
+da387ec05c4902110dabb22395a26b6b
+534b9a3588bdd87bf7c3b9d650e43e46
+60885f7923ace3a3328c23e98c88e60e
+518ed29525738cebdac49c49e60ea9d3
+31d6cfe0d16ae931b73c59d7e0c089c0
+d41d8cd98f00b204e9800998ecf8427e
+2510c39011c5be704182423e3a695e91
+99800b85d3383e3a2fb45eb7d0066a4879a9dad0
+f39ef9f3e4426b4b9b705b52d4b8ae426c33f9b0
+1a1f58c9adc75e11a9c4c108e39bb79bfb4435ac
+41d1de28e96dc1cde568d3b068fa17bb
+f33da01f361b228b4406e1f3cc467777
+a439344f4b08d69e633a4ae02ced47a3b89cf37dd8138d5568696657
+d77e22123e64d3d87f1f95d9cff7a0b6af6c32b9a81552cb90e991eb55cf63d4
+aa985c9abeaa7eaa4cba092bb9cf324d5b1a166ba71b994104d3ea7bca7b66f2ebf2c556e78fda4ef3c7cf310a649acd
+789ffe2f72383f30704918bf701f9f2fe4ae836857c0c415319850d099b0aa219fb7f0c5c029d1e959ed0f91594354b5003946dfff4bf95673072fa15af9ccb3
+e5b4c7c6d3e871790c46124c2b51cf177b5bb9fc

data/lib/cobreak/info_author.rb

@@ -0,0 +1,22 @@
+require 'launchy'
+module CoBreak
+  class Author
+    def self.author()
+      return "Breaker Box"
+    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"
+      Launchy.open(group)
+      return group
+    end
+  end
+end

data/lib/cobreak/list_all.rb

@@ -0,0 +1,19 @@
+module CoBreak
+  class List
+    #all list formats and types
+    def initialize(options)
+      type = Array.new
+      type << "Base64" << "Base32" << "Base16" << "Ascii85" << "Binary" << "Cesar"
+      if (options.list.eql?("type"))
+        puts "\nMode Cipher:"
+        puts type
+      end
+      format = Array.new
+      format << "MD4" << "MD5" << "SHA1" << "SHA224" << "SHA256" << "SHA384" << "SHA512" << "RIPEMD160"
+      if (options.list.eql?("format"))
+        puts "\nMode Cryptography:"
+        puts format
+      end
+    end
+  end
+end

data/lib/cobreak/optionpr.rb

@@ -0,0 +1,59 @@
+require 'optparse'
+require 'cobreak/cobreak'
+require 'cobreak/force_brute'
+require 'cobreak/version'
+require 'cobreak/list_all'
+module CoBreak
+  class ParseOPT
+    def self.optparse(options)
+      begin
+      OptionParser.new do|param|
+        param.banner = "Usage: CoBreak.rb [--options] [text or file]"
+        param.separator ''
+        param.separator "Mode Cipher:"
+        param.on('--encoding=[TYPE]', String, 'encoding parameter'){|en_co| options.enc = en_co}
+        param.on('--decoding=[TYPE]', String, 'decoding parameter'){|de_co| options.dec = de_co}
+        param.separator "Mode Cryptography"
+        param.on('--encrypt=[FORMAT]', String, 'encrypt parameter'){|en_en| options.encrypt = en_en}
+        param.on('--decrypt=[FORMAT]', String, 'decrypt parameter'){|de_en| options.decrypt = de_en}
+        param.separator "Mode BruteForce"
+        param.on('--bruteforce=[FORMAT]', String, 'brute force mode to crack a hash'){|modeforce| options.bruteforce = modeforce}
+        param.separator ""
+        param.separator "Options:"
+        param.on('-l', '--list=TYPE or FORMAT', String, 'list cipher types of hash formats'){|lin| options.list = lin}
+        param.on('-r', '--range MIN MAX', Integer, "word chars length"){|min| options.min = min}
+        param.on('-c', '--chars CHARACTERS', 'character input to generate word lists'){|chars| options.chars = chars}
+        param.on('-w', '--wordlist=WORDLIST', 'Wordlist mode, read words from FILE or stadin (default: diccionario.txt)'){|wordlist| options.wordlist = wordlist}
+        param.on('-i', '--input FILE or TEXT', String, 'take file or text to carry out the process'){|alg| options.algo = alg}
+        param.on_tail('-v', '--version', 'show version'){puts "CoBreak version #{CoBreak.version}"; exit}
+        param.on_tail('-h', '--help', 'command to view help parameters'){puts param; exit}
+        param.separator ''
+      end.parse!
+      rescue OptionParser::MissingArgument => missing
+        if missing.to_s.include?("--wordlist")
+          options.wordlist = File.join(Gem.path[1], 'gems', "cobreak-#{CoBreak.version}", 'diccionario.txt')
+        elsif missing.to_s.include?("--chars")
+          options.chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"
+        else
+          puts missing.message
+        end
+      ensure
+        if (options.wordlist == "diccionario.txt")
+          unless (File.exists?(options.wordlist))
+            options.wordlist = File.join(Gem.path[1], 'gems', "cobreak-#{CoBreak.version}", 'diccionario.txt')
+          end
+        end
+      end
+      CoBreak::Box.var(options)
+      CoBreak::Box::Cipher.coding()
+      CoBreak::Box::Cryptgraphy.crypt()
+      CoBreak::List.new(options)
+      unless (options.wordlist.nil?) or (options.wordlist.empty?)
+        bruteforce = CoBreak::BruteForze.new(options)
+        bruteforce.banner_wordlist()
+        bruteforce.wordlist
+      end
+    end
+  end
+end
+