cobreak 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a09c670a9a5b9b5953e1fafba85d2467a1fbaccdd16ffc837be34f6aed0fd6a9
-  data.tar.gz: e31a4eec8f7859a2ebacc40d39aab1fd949653adb8a72259a592b0b42e9a248c
+  metadata.gz: 6f3aa9bece5d8c3accb9660d8b0bbc6efc962d1b334c86fdf426c18479f7537a
+  data.tar.gz: 66eff273559279aefe72ae90eae0523c481dc723d6647c8b8523539adc5cd977
 SHA512:
-  metadata.gz: 0c4424194967159ad8b6fb0c4c7afe84b6a2dd74a1a710e4d1b8ad2240a50438ed5cdbe95971fd663bca7fce8ea247e1f67d8d46da0b97cf7deb03c8cf78ba7b
-  data.tar.gz: 34b789efd4187eb4ff551c71744a42a5d8d291c6482fcd4d10adf51bea0e0ee445e3a16e49333af9d3838b426649ba2118977ef7be2ec6d4ac4361a751c000fb
+  metadata.gz: 2347f91a8a197f04557ab9a4b0ec3c29faa3f3d0778bf1045fe4c5d65e32b46ac9bf76ad761592e3c3174c3111140d1280a3270b6103477808e3157e6817d420
+  data.tar.gz: 92e4cd9f4f1d873ff71a4e04320f3b3ede2aeaeef8fdc0b7a967467bb41400164b04791b6a093b4ef67c10e6511d55d78f0f524f35798a8f9ca13aa73ca05418

data/cobreak.gemspec

@@ -1,18 +1,17 @@
 Gem::Specification.new do |info|
   info.name        = 'cobreak'
-  info.version     = '0.0.6'
+  info.version     = '0.0.8'
   info.executables << "cobreak"
   info.description = "The CoBreak script is an cipher and cryptography tool"
-  info.add_development_dependency  "Digest"
-  info.add_development_dependency  "sequel"
-  info.add_development_dependency  "sqlite3"
-#  info.extensions  << 'Gemfile'
+  info.add_development_dependency "bundler", "~> 1.5"
+  info.add_development_dependency  "Digest", "~> 3.0.0"
+  info.add_development_dependency  "sequel", "~> 5.44.0"
+  info.add_development_dependency  "sqlite3", "~> 1.4.2"
   info.authors     = ["BreakerBox"]
   info.email       = 'breakerhtb@gmail.com'
   info.summary     = "Force Brute, Cipher, Cryptography"
-  info.files = Dir["{lib}/**/*", "bin/*", "*.gemspec", "*.txt", "Gemfile", "LICENSE", "*.md"]
-  info.homepage    = 'https://rubygeminfo.org/breakerbox/cobreak'
-  info.metadata    = {"source_code_uri" => "https://github.com/BreakerBox/CoBreak"}
+  info.files = Dir["{lib}/**/*.rb"] + Dir["{lib}/**/show/*.db", "{lib}/**/hash/hash.db", "bin/*.rb", "*.gemspec", "diccionario.txt", "Gemfile", "LICENSE", "*.md"]
+  info.homepage    = 'https://github.com/BreakerBox/CoBreak'
   info.license       = 'MIT'
   info.post_install_message = "thanks for installing my gem"
 end

data/lib/cobreak/binary.rb

@@ -0,0 +1,10 @@
+module CoBreak
+  class Binary
+    def self.binary(dato)
+      return dato.unpack("B*").join('')
+    end
+    def self.hexbinary(dato)
+      return [dato].pack("B*")
+    end
+  end
+end

data/lib/cobreak/{Cesar.rb → cesar.rb}

@@ -1,16 +1,13 @@
 class CesarCifrado
-  attr_accessor :dato
-  def initialize(dato = nil)
-    @dato = dato
-  end
   def cesar(dato, rotasiones, orientacion = 1)
+    cesar = OpenStruct.new
+    cesar.cad_rot = []
     alfa_mayus = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     alfa_minus = "abcdefghijklmnopqrstuvwxyz"
     alf = 26
     lit_mayus = 65
     lit_minus = 97
     cad_rot = ""
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m CipherText: "
     for letra in dato.chars
       if !letra.match(/^[[:alpha:]]$/)
         cad_rot += letra
@@ -25,11 +22,9 @@ class CesarCifrado
       var_ascii = letra.ord
       rot_ver = rotasiones * orientacion
       new_pos = (var_ascii - limit + rot_ver) % alf
-      cad_rot = alfabeto[new_pos]
-      print cad_rot
+      cesar.cad_rot << alfabeto[new_pos]
       end
-    puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Rotations Number: #{rotasiones}"
+      return cesar.cad_rot.join('')
   end
 end
-CifraCesar = CesarCifrado.new
-DecifraCesar = CesarCifrado.new
+Cesar = CesarCifrado.new

data/lib/cobreak/cifrado.rb

@@ -2,31 +2,33 @@ require 'base64'
 require 'base32'
 require 'base16'
 require 'ascii85'
-
-class Cifrado
-  attr_accessor :data
-  def initialize(data = nil)
-    @data = data
-  end
-  def base16(dato)
-     bas16 = Base16.encode16(dato)
-     puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{bas16}\e[0m"
-  end
-  def base32(dato)
-     bas32 = Base32.encode(dato)
-     puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{bas32}\e[0m"
-  end
-  def base64(dato)
-     bas64 = Base64.encode64(dato)
-     print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{bas64}"
-  end
-  def binary(dato)
-    result = dato.unpack("B*").join('')
-    puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{result}"
-  end
-  def ascii85(dato)
-    asci85 = Ascii85.encode(dato)
-    puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{asci85}"
+require 'cobreak/cesar'
+require 'cobreak/binary'
+module CoBreak
+  class Cifrado
+    def self.cipher(mode, dato)
+      cipher = OpenStruct.new
+      cipher.mode = mode
+      cipher.dato = dato
+      if (cipher.mode.eql?('base16'))
+        cipher.result = Base16.encode16(dato)
+      elsif (cipher.mode.eql?('base32'))
+        cipher.result = Base32.encode(dato)
+      elsif (cipher.mode.eql?('base64'))
+        cipher.result = Base64.encode64(dato)
+      elsif (cipher.mode.eql?('ascii85'))
+        cipher.result = Ascii85.encode(dato)
+      elsif (cipher.mode.eql?('cesar'))
+        cipher.result = Cesar.cesar(dato, ARGV[0].to_i)
+      elsif (cipher.mode.eql?('binary'))
+        cipher.result = CoBreak::Binary.binary(dato)
+      end
+      unless (cipher.result.nil?) or (cipher.result.eql?(cipher.dato))
+        puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{cipher.result}"
+        puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Number Rotations: #{ARGV[0]}" if (cipher.mode.eql?('cesar'))
+      else
+        puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Cipher Text..."
+      end
+    end
   end
 end
-Cifra = Cifrado.new

data/lib/cobreak/cobreak.rb

@@ -8,7 +8,6 @@ module CoBreak
     begin
       require 'cobreak/cifrado'
       require 'cobreak/decifrado'
-      require 'cobreak/Cesar'
       require 'cobreak/encrypt'
       require 'cobreak/decrypt'
     rescue LoadError => e
@@ -23,72 +22,25 @@ module CoBreak
         @options = $options
         @options.enc = "" if @options.enc.nil? == true
         @options.dec = "" if @options.dec.nil? == true
-        if (@options.enc.casecmp?('base16')) or (@options.dec.casecmp?('base16'));
+        @options.cipher = %w[Base16 Base32 Base64 Ascii85 Binary Cesar]
+        if (@options.cipher.include?(@options.enc.capitalize)) or (@options.cipher.include?(@options.dec.capitalize));
           if (File.exists?(@options.algo));
             IO.foreach(@options.algo){|line|
-            line.chomp!
-            Cifra::base16(line.to_s) if (@options.enc.casecmp?('base16'))
-            Decifra::base16(line.to_s) if (@options.dec.casecmp?('base16'))
+              line.chomp!
+              if (@options.cipher?(@options.enc.capitalize))
+                CoBreak::Cifrado.cipher(line.to_s)
+              end
+              if (@options.cipher.include?(@options.dec.capitalize))
+                CoBreak::Decifrado.cipher(line.to_s)
+              end
             }
-          else;
-            Cifra::base16(@options.algo.to_s) if (@options.enc.casecmp?('base16'))
-            Decifra::base16(@options.algo.to_s) if (@options.dec.casecmp?('base16'))
-          end
-        elsif (@options.enc.casecmp?('base32')) or (@options.dec.casecmp?('base32'));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            Cifra::base32(line.to_s) if (@options.enc.casecmp?('base32'))
-            Decifra::base32(line.to_s) if (@options.dec.casecmp('base32'))
-            }
-          else;
-            Cifra::base32(@options.algo.to_s) if (@options.enc.casecmp?('base32'))
-            Decifra::base32(@options.algo.to_s) if (@options.dec.casecmp?('base32'))
-          end
-        elsif (@options.enc.casecmp?('base64')) or (@options.dec.casecmp?('base64'));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            Cifra::base64(line.to_s) if (@options.enc.casecmp?('base64'))
-            Decifra::base64(line.to_s) if (@options.dec.casecmp?('base64'))
-           }
-          else;
-            Cifra::base64(@options.algo.to_s) if (@options.enc.casecmp?('base64'))
-            Decifra::base64(@options.algo.to_s) if (@options.dec.casecmp?('base64'))
-          end
-        elsif (@options.enc.casecmp?('ascii85')) or (@options.dec.casecmp?('ascii85'));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            Cifra::ascii85(line.to_s) if (@options.enc.casecmp?('ascii85'))
-            Decifra::ascii85(line.to_s) if (@options.dec.casecmp?('ascii85'))
-            }
-          else;
-            Cifra::ascii85(@options.algo.to_s) if (@options.enc.casecmp?('ascii85'))
-            Decifra::ascii85(@options.algo.to_s) if (@options.dec.casecmp?('ascii85'))
-          end
-        elsif (@options.enc.casecmp?('binary')) or (@options.dec.casecmp?('binary'));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            Cifra::binary(line.to_s) if (@options.enc.casecmp?('binary'))
-            Decifra::binary(line.to_s) if (@options.dec.casecmp?('binary'))
-            }
-         else;
-          Cifra::binary(@options.algo.to_s) if (@options.enc.casecmp?('binary'))
-          Decifra::binary(@options.algo.to_s) if (@options.dec.casecmp?('binary'))
-         end
-        elsif (@options.enc.casecmp?('cesar')) or (@options.dec.casecmp?('cesar'));
-          dat = ARGV[0]
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            CifraCesar::cesar(line.to_s, dat.to_i) if (@options.enc.casecmp?('cesar'))
-            DecifraCesar::cesar(line.to_s, dat.to_i, -1) if (@options.dec.casecmp?('cesar'))
-            }
-          else;
-            CifraCesar::cesar(@options.algo.to_s, dat.to_i) if (@options.enc.casecmp?('cesar'))
-            DecifraCesar::cesar(@options.algo.to_s, dat.to_i, -1) if (@options.dec.casecmp?('cesar'))
+          else
+            if (@options.cipher.include?(@options.enc.capitalize))
+              CoBreak::Cifrado::cipher(@options.enc, @options.algo.to_s)
+            end
+            if (@options.cipher.include?(@options.dec.capitalize))
+              CoBreak::Decifrado::cipher(@options.dec,@options.algo.to_s)
+            end
           end
         end
       end
@@ -98,94 +50,25 @@ module CoBreak
         @options = $options
         @options.encrypt = "" if @options.encrypt.nil? == true
         @options.decrypt = "" if @options.decrypt.nil? == true
-        if (@options.encrypt.casecmp?("md4")) or (@options.decrypt.casecmp?("md4"));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::md4(line) if (@options.encrypt.casecmp?("md4"))
-            DeCrypt::md4(line) if (@options.decrypt.casecmp?("md4"))
-            }
-          else
-            EnCrypt::md4(@options.algo) if (@options.encrypt.casecmp?("md4"))
-            DeCrypt::md4(@options.algo) if (@options.decrypt.casecmp?("md4"))
-          end
-        elsif (@options.encrypt.casecmp?("md5")) or (@options.decrypt.casecmp?("md5"));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::md5(line) if (@options.encrypt.casecmp?("md5"))
-            DeCrypt::md5(line) if (@options.decrypt.casecmp?("md5"))
-            }  
-          else
-            EnCrypt::md5(@options.algo) if (@options.encrypt.casecmp?("md5"))
-            DeCrypt::md5(@options.algo) if (@options.decrypt.casecmp?("md5"))
-          end
-        elsif (@options.encrypt.casecmp?("sha1")) or (@options.decrypt.casecmp?("sha1"))
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::sha1(line) if (@options.encrypt.casecmp?("sha1"))
-            DeCrypt::sha1(line) if (@options.decrypt.casecmp?("sha1"))
-            }
-          else
-            EnCrypt::sha1(@options.algo) if (@options.encrypt.casecmp?("sha1"))
-            DeCrypt::sha1(@options.algo) if (@options.decrypt.casecmp?("sha1"))
-          end
-        elsif (@options.encrypt.casecmp?("sha224")) or (@options.decrypt.casecmp?("sha224"));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::sha224(line) if (@options.encrypt.casecmp?("sha224"))
-            DeCrypt::sha224(line) if (@options.decrypt.casecmp?("sha224"))
-            }
-          else
-            EnCrypt::sha224(@options.algo) if (@options.encrypt.casecmp?("sha224"))
-            DeCrypt::sha224(@options.algo) if (@options.decrypt.casecmp?("sha224"))
-          end
-        elsif (@options.encrypt.casecmp?("sha256")) or (@options.decrypt.casecmp?("sha256"));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::sha256(line) if (@options.encrypt.casecmp?("sha256"))
-            DeCrypt::sha256(line) if (@options.decrypt.casecmp?("sha256"))
-            }
-          else
-            EnCrypt::sha256(@options.algo) if (@options.encrypt.casecmp?("sha256"))
-            DeCrypt::sha256(@options.algo) if (@options.decrypt.casecmp?("sha256"))
-          end
-        elsif (@options.encrypt.casecmp?("sha384")) or (@options.decrypt.casecmp?("sha384"));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::sha384(line) if (@options.encrypt.casecmp?("sha384"))
-            DeCrypt::sha384(line) if (@options.decrypt.casecmp?("sha384"))
-            } 
-          else
-            EnCrypt::sha384(@options.algo) if (@options.encrypt.casecmp?("sha384"))
-            DeCrypt::sha384(@options.algo) if (@options.decrypt.casecmp?("sha384"))
-          end
-        elsif (@options.encrypt.casecmp?("sha512")) or (@options.decrypt.casecmp?("sha512"));
-          if (File.exists?(@options.algo));
-            IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::sha512(line) if (@options.encrypt.casecmp?("sha512"))
-            DeCrypt::sha512(line) if (@options.decrypt.casecmp?("sha512"))
-            }
-          else
-            EnCrypt::sha512(@options.algo) if (@options.encrypt.casecmp?("sha512"))
-            DeCrypt::sha512(@options.algo) if (@options.decrypt.casecmp?("sha512"))
-          end
-        elsif (@options.encrypt.casecmp?("ripemd160")) or (@options.decrypt.casecmp?("ripemd160"));
+        show = OpenStruct.new
+        show.hash = %w[MD4 MD5 SHA1 SHA224 SHA256 SHA384 SHA512 RIPEMD160]
+        if (show.hash.include?(@options.encrypt.upcase)) or (show.hash.include?(@options.decrypt.upcase));
           if (File.exists?(@options.algo));
             IO.foreach(@options.algo){|line|
-            line.chomp!
-            EnCrypt::ripemd160(line) if (@options.encrypt.casecmp?("ripemd160"))
-            DeCrypt::ripemd160(line) if (@options.decrypt.casecmp?("ripemd160"))
+              line.chomp!
+              EnCrypt::show(@options.encrypt, line) if (show.hash.include?(@options.encrypt.upcase))
+              DeCrypt::show(@options.decrypt, line) if (show.hash.include?(@options.decrypt.upcase))
             }
           else
-            EnCrypt::ripemd160(@options.algo) if (@options.encrypt.casecmp?("ripemd160"))
-            DeCrypt::ripemd160(@options.algo) if (@options.decrypt.casecmp?("ripemd160"))
+            if (show.hash.include?(@options.encrypt.upcase))
+              EnCrypt::show(@options.encrypt, @options.algo)
+            end
+            if (show.hash.include?(@options.decrypt.upcase))
+              DeCrypt::show(@options.decrypt, @options.algo)
+            end
           end
+        else
+          abort "\e[31m[\e[0m✘\e[31m]\e[0m Invalid Hash Format"
         end
       end
     end

data/lib/cobreak/decifrado.rb

@@ -2,31 +2,33 @@ require 'base64'
 require 'base32'
 require 'base16'
 require 'ascii85'
-
-class Decifrado
-  attr_accessor :data
-  def initialize(data = nil)
-    @data = data
-  end
-  def base16(dato)
-     bas16 = Base16.decode16(dato)
-     puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m DecipherText: #{bas16}\e[0m"
-  end
-  def base32(dato)
-     bas32 = Base32.decode(dato)
-     puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m DecipherText: #{bas32}\e[0m"
-  end
-  def base64(dato)
-     bas64 = Base64.decode64(dato)
-     puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m DecipherText: #{bas64}"
-  end
-  def binary(dato)
-    result = [dato].pack("B*")
-    puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m DecipherText: #{result}"
-  end
-  def ascii85(dato)
-    asci85 = Ascii85.decode(dato)
-    puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m DecipherText: #{asci85}"
+require 'cobreak/cesar'
+require 'cobreak/binary'
+module CoBreak
+  class Decifrado
+    def self.cipher(mode, dato)
+      decipher = OpenStruct.new
+      decipher.mode = mode
+      decipher.dato = dato
+      if (decipher.mode.eql?('base16'))
+        decipher.result = Base16.decode16(decipher.dato)
+      elsif (decipher.mode.eql?('base32'))
+        decipher.result = Base32.decode(decipher.dato)
+      elsif (decipher.mode.eql?('base64'))
+        decipher.result = Base64.decode64(decipher.dato)
+      elsif (decipher.mode.eql?('ascii85'))
+        decipher.result = Ascii85.decode(decipher.dato)
+      elsif (decipher.mode.eql?('cesar'))
+        decipher.result = Cesar.cesar(decipher.dato, ARGV[0].to_i, -1)
+      elsif (decipher.mode.eql?('binary'))
+        decipher.result = CoBreak::Binary.hexbinary(decipher.dato)
+      end
+      unless (decipher.result.nil?) or (decipher.result.eql?(decipher.dato))
+        puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Ciphertext: #{decipher.result}"
+        puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Number Rotations: #{ARGV[0]}" if (decipher.mode.eql?('cesar'))
+      else
+        puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Cipher Text..."
+      end
+    end
   end
 end
-Decifra = Decifrado.new

data/lib/cobreak/decrypt.rb

@@ -2,109 +2,42 @@ require 'openssl'
 require 'sequel'
 require 'cobreak/version'
 class Decrypt
-  def md4(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'md4.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::MD4.hexdigest(line)}
-    }
-   print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-   puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def md5(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'md5.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::MD5.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def sha1(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha1.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::SHA1.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def sha224(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha224.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::SHA224.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def sha256(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha256.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::SHA256.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def sha384(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha384.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::SHA384.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def sha512(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'sha512.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::SHA512.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
-  end
-  def ripemd160(dato, wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', 'ripemd160.db'))
-    dbs = Sequel.sqlite
-    dbs.create_table? :hashes do
-      String :original
-      String :hash
-    end
-    IO.foreach(wordlist) {|line|
-      line.chomp!
-      dbs[:hashes] << {original:line, hash:OpenSSL::Digest::RIPEMD160.hexdigest(line)}
-    }
-    print "\e[1;32m[\e[0m+\e[1;32m]\e[0m Decrypted Text: "
-    puts dbs[:hashes].filter(hash:dato).map(:original)
+  def show(mode, dato)
+    decrypt = OpenStruct.new
+    decrypt.mode = mode.downcase
+    decrypt.wordlist = File.join(Gem.path[1], "gems", "cobreak-#{CoBreak.version}", 'lib', 'cobreak', 'show', "#{decrypt.mode}.db")
+    dbs = Sequel.sqlite
+    dbs.create_table? :hashes do
+      String :original
+      String :hash
+    end
+      if (decrypt.mode.eql?('md4'))
+        decrypt.hash = OpenSSL::Digest::MD4.new
+      elsif (decrypt.mode.eql?('md5'))
+        decrypt.hash = OpenSSL::Digest::MD5.new
+      elsif (decrypt.mode.eql?('sha1'))
+        decrypt.hash = OpenSSL::Digest::SHA1.new
+      elsif (decrypt.mode.eql?('sha224'))
+        decrypt.hash = OpenSSL::Digest::SHA224.new
+      elsif (decrypt.mode.eql?('sha256'))
+        decrypt.hash = OpenSSL::Digest::SHA256.new
+      elsif (decrypt.mode.eql?('sha384'))
+        decrypt.hash = OpenSSL::Digest::SHA384.new
+      elsif (decrypt.mode.eql?('sha512'))
+        decrypt.hash = OpenSSL::Digest::SHA512.new
+      elsif (decrypt.mode.eql?('ripemd160'))
+        decrypt.hash = OpenSSL::Digest::RIPEMD160.new
+      end
+    File.foreach(decrypt.wordlist) {|line|
+      line.chomp!
+      dbs[:hashes] << {original:line, hash:decrypt.hash.hexdigest(line)}
+    }
+   decrypt.pass = dbs[:hashes].filter(hash:dato).map(:original)
+   unless (decrypt.pass.empty?)
+     puts "\e[1;32m[\e[0m+\e[1;32m]\e[0m Hash Found: #{decrypt.pass.join(',')}"
+   else
+     puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Hash Not Found in Database..."
+   end
   end
 end
 DeCrypt = Decrypt.new

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')
@@ -24,204 +22,84 @@ class Forze_brute
       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.hash)
+          DB::database(forzebrute.crypt.hexdigest(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"
+          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

data/lib/cobreak/optionpr.rb

@@ -1,6 +1,7 @@
 require 'optparse'
 require 'cobreak/cobreak'
 require 'cobreak/force_brute'
+require 'cobreak/force_chars'
 require 'cobreak/version'
 require 'cobreak/list_all'
 module CoBreak
@@ -8,22 +9,22 @@ module CoBreak
     def self.optparse(options)
       begin
       OptionParser.new do|param|
-        param.banner = "Usage: CoBreak.rb [--options] [text or file]"
+        param.banner = "Usage: CoBreak.rb [--mode] [--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.on('--encoding=[TYPE]', String, 'encoding input text or file'){|en_co| options.enc = en_co}
+        param.on('--decoding=[TYPE]', String, 'decoding input text or file'){|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('-r', '--range MIN MAX', Array, "word chars length"){|rang| options.range = rang}
+        param.on('-c', '--chars CHARACTERS', String, '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('--show=[FORMAT]', String, 'show decrypted specific hash'){|de_en| options.decrypt = de_en}
         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}
@@ -45,15 +46,24 @@ module CoBreak
         end
       end
       CoBreak::Box.var(options)
-      CoBreak::Box::Cipher.coding()
-      CoBreak::Box::Cryptgraphy.crypt()
+      if !(options.enc.nil?) or !(options.dec.nil?)
+        CoBreak::Box::Cipher.coding()
+      end
+      if !(options.encrypt.nil?) or !(options.decrypt.nil?)
+        CoBreak::Box::Cryptgraphy.crypt()
+      end
       CoBreak::List.new(options)
       unless (options.wordlist.nil?) or (options.wordlist.empty?)
         bruteforce = CoBreak::BruteForze.new(options)
         bruteforce.banner_wordlist()
         bruteforce.wordlist
       end
+      unless (options.chars.nil?) or (options.chars.empty?)
+        options.range << ARGV[0].to_i
+        brutechars = CoBreak::BruteChars.new(options)
+        brutechars.banner_chars()
+        brutechars.chars()
+      end
     end
   end
 end
-

data/lib/cobreak/version.rb

@@ -1,5 +1,5 @@
 module CoBreak
   def self.version()
-    return '0.0.6'
+    return '0.0.8'
   end
 end

metadata

@@ -1,57 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: cobreak
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - BreakerBox
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-30 00:00:00.000000000 Z
+date: 2021-06-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: Digest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 5.44.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 5.44.0
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.4.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.4.2
 description: The CoBreak script is an cipher and cryptography tool
 email: breakerhtb@gmail.com
 executables:
@@ -66,7 +80,8 @@ files:
 - cobreak.gemspec
 - diccionario.txt
 - lib/cobreak.rb
-- lib/cobreak/Cesar.rb
+- lib/cobreak/binary.rb
+- lib/cobreak/cesar.rb
 - lib/cobreak/cifrado.rb
 - lib/cobreak/cobreak.rb
 - lib/cobreak/decifrado.rb
@@ -75,6 +90,7 @@ files:
 - lib/cobreak/encrypt.rb
 - lib/cobreak/force.rb
 - lib/cobreak/force_brute.rb
+- lib/cobreak/force_chars.rb
 - lib/cobreak/function_db.rb
 - lib/cobreak/function_hash.rb
 - lib/cobreak/hash/hash.db
@@ -91,11 +107,10 @@ files:
 - lib/cobreak/show/sha384.db
 - lib/cobreak/show/sha512.db
 - lib/cobreak/version.rb
-homepage: https://rubygeminfo.org/breakerbox/cobreak
+homepage: https://github.com/BreakerBox/CoBreak
 licenses:
 - MIT
-metadata:
-  source_code_uri: https://github.com/BreakerBox/CoBreak
+metadata: {}
 post_install_message: thanks for installing my gem
 rdoc_options: []
 require_paths: