cobreak 1.0.1 → 1.0.2

data/lib/cobreak/cesar.rb

@@ -2,8 +2,8 @@ class CesarCifrado
   def cesar(dato, rotasiones, orientacion = 1)
     cesar = OpenStruct.new
     cesar.cad_rot = []
-    alfa_mayus = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    alfa_minus = "abcdefghijklmnopqrstuvwxyz"
+    alfa_mayus = ('A'..'Z').to_a
+    alfa_minus = ('a'..'z').to_a
     alf = 26
     lit_mayus = 65
     lit_minus = 97
@@ -27,4 +27,4 @@ class CesarCifrado
       return cesar.cad_rot.join('')
   end
 end
-Cesar = CesarCifrado.new
+Cesar = CesarCifrado.new

data/lib/cobreak/cifrado.rb

@@ -24,10 +24,10 @@ module CoBreak
         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'))
+        puts "\n\e[1;32m[\e[37m+\e[1;32m]\e[37m Ciphertext: #{cipher.result}"
+        puts "\e[1;32m[\e[37m+\e[1;32m]\e[37m Number Rotations: #{ARGV[0]}" if (cipher.mode.eql?('cesar'))
       else
-        puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Cipher Text..."
+        puts "\e[1;31m[\e[37m+\e[1;31m]\e[37m Not Cipher Text..."
       end
     end
   end

data/lib/cobreak/cobreak.rb

@@ -51,24 +51,24 @@ module CoBreak
         @options.encrypt = "" if @options.encrypt.nil? == true
         @options.decrypt = "" if @options.decrypt.nil? == true
         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));
+        show.crypt = %w[MD4 MD5 SHA1 SHA224 SHA256 SHA384 SHA512 RIPEMD160]
+        if (show.crypt.include?(@options.encrypt.upcase)) or (show.crypt.include?(@options.decrypt.upcase));
           if (File.exists?(@options.algo));
             IO.foreach(@options.algo){|line|
               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))
+              EnCrypt::show(@options.encrypt, line) if (show.crypt.include?(@options.encrypt.upcase))
+              DeCrypt::show(@options.decrypt, line) if (show.crypt.include?(@options.decrypt.upcase))
             }
           else
-            if (show.hash.include?(@options.encrypt.upcase))
+            if (show.crypt.include?(@options.encrypt.upcase))
               EnCrypt::show(@options.encrypt, @options.algo)
             end
-            if (show.hash.include?(@options.decrypt.upcase))
+            if (show.crypt.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"
+          abort "\e[31m[\e[37m✘\e[31m]\e[37m Invalid Hash Format"
         end
       end
     end

data/lib/cobreak/decifrado.rb

@@ -24,10 +24,12 @@ module CoBreak
         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'))
+        puts "\n\e[1;32m[\e[37m+\e[1;32m]\e[37m DecipherText: #{decipher.result}"
+        if (decipher.mode.eql?('cesar'))
+          puts "\e[1;32m[\e[37m+\e[1;32m]\e[37m Number Rotations: #{ARGV[0]}"
+        end
       else
-        puts "\e[1;31m[\e[0m+\e[1;31m]\e[0m Not Cipher Text..."
+        puts "\e[1;31m[\e[37m+\e[1;31m]\e[37m Not Cipher Text..."
       end
     end
   end

data/lib/cobreak/decrypt.rb

@@ -1,5 +1,3 @@
-require 'openssl'
-require 'sequel'
 require 'cobreak/version'
 class Decrypt
   def show(mode, dato)
@@ -11,32 +9,34 @@ class Decrypt
       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
+      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!
-      dbs[:hashes] << {original:line, hash:decrypt.hash.hexdigest(line)}
+      dbs[:hashes] << {original:line, hash:decrypt.crypt.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(',')}"
+     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[0m+\e[1;31m]\e[0m Hash Not Found in Database..."
+     puts "\e[1;31m[\e[1;37m+\e[1;31m]\e[1;37m Hash Not Found in Database...\e[0m"
    end
   end
 end

data/lib/cobreak/encrypt.rb

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

data/lib/cobreak/force.rb

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