cobreak 0.0.3 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a5001f7a0dd1c7fcf88d797680c7ed5b0171850ab975292b3d37b3004d775e5
-  data.tar.gz: 719ef47f110dc0f72b6d1feb30e8a4aff4ef1f0c51aab766d909881ac5590909
+  metadata.gz: 2ba7b5f95bbe02154240d40486b32a78907bf9ceac8f34b0e2a553210c5dd553
+  data.tar.gz: d3ac3aec002c8ab20acef7a2d1bae39ec2343cc60eff7fc620e504071143c248
 SHA512:
-  metadata.gz: 400ffdecc20b1abdaa6aed69338df523ba7695460fd95cd242c02d79052d02c85fbc6f0cda523c0d14a663132f49c95eddc0bed06e8421b3f74f7036c2b82328
-  data.tar.gz: a5e9262ba3566ed6b580830e40039d353c081b4c715ef676d3fd94179a0aaa0859175c911bfe7835420400f33c16fa6b11487e79283fa7cacd88c9b396bd5c6c
+  metadata.gz: 6af73bb62f17ebc2611c2fdec3b3df6e71b7c4c17496a2057ff52b9e60ccd89e30c965ca82ac1d78d2004159eade0eb67d7068eaf77f8780908b05e50a95303e
+  data.tar.gz: 1e3d4e82fbcd1cb43f2b0b23305dd90b9453ce12fd88de8d4eaf40a9af58e46514f3a8324dab7cd63848d570637c727a832ab6b05175cb53d5f5df6258348db3

data/README.md

@@ -31,33 +31,20 @@ The CoBreak script is an cipher and cryptography tool made with the purpose of f
  - SHA-384
  - SHA-512
  - RIPEMD-160
-### Installation in termux
-
-> $ **apt update**
-
-> $ **apt upgrade**
-
-> $ **apt install git**
-
-> $ **apt install ruby**
-
-> $ **git clone https://github.com/BreakerBox/CoBreak.git/**
-
-> $ **cd CoBreak**
-
-> $ **bundle install**
+# Setup
+---
+###add to Gemfile:
 
-> $ **ruby CoBreak.rb --help**
+> $ **gem 'cobreak'**
 
-### Installation in others
+###and then execute:
 
-> $ **git clone https://github.com/BreakerBox/CoBreak.git/**
+> $ **bundle**
 
-> $ **cd CoBreak**
+###Or install it yourself as:
 
 > $ **bundle install**
 
-> $ **ruby CoBreak --help**
 
 ---
 # Version

data/cobreak.gemspec

@@ -1,12 +1,17 @@
-Gem::Specification.new do |s|
-  s.name        = 'cobreak'
-  s.version     = '0.0.3'
-  s.executables << "cobreak"
-  s.description = "The CoBreak script is an cipher and cryptography tool"
-  s.authors     = ["BreakerBox"]
-  s.email       = 'breakerhtb@gmail.com'
-  s.summary     = "My very first"
-  s.files = Dir["{lib}/**/*", "bin/*", "*.gemspec", "*.txt", "Gemfile", "LICENSE", "*.md"]
-  s.homepage    = 'https://github.com/BreakerBox/CoBreak.git'
-  s.license       = 'MIT'
+Gem::Specification.new do |info|
+  info.name        = 'cobreak'
+  info.version     = '0.0.9'
+  info.executables << "cobreak"
+  info.description = "The CoBreak script is an cipher and cryptography tool"
+  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}/**/*.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