cobreak 0.0.3

data/lib/cobreak.rb

@@ -0,0 +1,3 @@
+require 'cobreak/version'
+require 'cobreak/info_author'
+require 'cobreak/details'

data/lib/cobreak/Cesar.rb

@@ -0,0 +1,35 @@
+class CesarCifrado
+  attr_accessor :dato
+  def initialize(dato = nil)
+    @dato = dato
+  end
+  def cesar(dato, rotasiones, orientacion = 1)
+    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
+        next
+      end
+      alfabeto = alfa_mayus
+      limit = lit_mayus
+      if letra == letra.downcase
+        alfabeto = alfa_minus
+        limit = lit_minus
+      end
+      var_ascii = letra.ord
+      rot_ver = rotasiones * orientacion
+      new_pos = (var_ascii - limit + rot_ver) % alf
+      cad_rot = alfabeto[new_pos]
+      print cad_rot
+      end
+    puts "\n\e[1;32m[\e[0m+\e[1;32m]\e[0m Rotations Number: #{rotasiones}"
+  end
+end
+CifraCesar = CesarCifrado.new
+DecifraCesar = CesarCifrado.new

data/lib/cobreak/cifrado.rb

@@ -0,0 +1,32 @@
+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}"
+  end
+end
+Cifra = Cifrado.new

data/lib/cobreak/cobreak.rb

@@ -0,0 +1,193 @@
+#!/bin/env ruby
+module CoBreak
+  class Box
+    def self.var(options)
+      @options = options
+      $options = options
+    end
+    begin
+      require 'cobreak/cifrado'
+      require 'cobreak/decifrado'
+      require 'cobreak/Cesar'
+      require 'cobreak/encrypt'
+      require 'cobreak/decrypt'
+    rescue LoadError => e
+      puts e.message
+      puts "A file is missing from the repository"
+      puts ""
+      exit(1)
+    end
+    #encoding and decoding algoritmhs
+    class Cipher
+      def self.coding()
+        @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'));
+          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'))
+            }
+          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'))
+          end
+        end
+      end
+    end
+    class Cryptgraphy
+      def self.crypt()
+        @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"));
+          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"))
+            }
+          else
+            EnCrypt::ripemd160(@options.algo) if (@options.encrypt.casecmp?("ripemd160"))
+            DeCrypt::ripemd160(@options.algo) if (@options.decrypt.casecmp?("ripemd160"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cobreak/decifrado.rb

@@ -0,0 +1,32 @@
+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}"
+  end
+end
+Decifra = Decifrado.new

data/lib/cobreak/decrypt.rb

@@ -0,0 +1,110 @@
+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)
+  end
+end
+DeCrypt = Decrypt.new

data/lib/cobreak/details.rb

@@ -0,0 +1,19 @@
+module CoBreak
+  class Details
+    def self.info()
+      return "The CoBreak script is an cipher and cryptography tool made with the purpose of facilitating the encryption of data or others, it includes parameters to brute force the hashes through dictionaries"
+    end
+    def self.dependecias()
+      return %w(base14 base32 base16 ascii85 cesar binary openssl animat sequel sqlite3)
+    end
+    def self.date()
+      return "2020-5-25"
+    end
+    def self.cipher()
+      return %w(base64 base32 base16 ascii85 cesar binary)
+    end
+    def self.crypt()
+      return %w(MD4 MD5 SHA1 SHA224 SHA256 SHA384 SHA512 RIPEMD160)
+    end
+  end
+end

data/lib/cobreak/encrypt.rb

@@ -0,0 +1,55 @@
+require 'openssl'
+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)
+  end
+end
+EnCrypt = Encrypt.new