cobreaktws 1.0.4

data/ext/cobreak/cobreak_openssl.c

@@ -0,0 +1,438 @@
+#include<cobreak_openssl.h>
+#define BLOCK_SIZE 64
+#define HASH_SIZE_512 64
+#define HASH_SIZE 32
+#define NUM_ROUNDS 12
+
+VALUE mCoBreakOpenSSL;
+VALUE cCoBreakOpenSSLmd4;
+VALUE cCoBreakOpenSSLmd5;
+VALUE cCoBreakOpenSSLhalf_md5;
+VALUE cCoBreakOpenSSLsha1;
+VALUE cCoBreakOpenSSLsha2_224;
+VALUE cCoBreakOpenSSLsha2_256;
+VALUE cCoBreakOpenSSLsha2_384;
+VALUE cCoBreakOpenSSLsha2_512;
+VALUE cCoBreakOpenSSLsha3_224;
+VALUE cCoBreakOpenSSLsha3_256;
+VALUE cCoBreakOpenSSLsha3_384;
+VALUE cCoBreakOpenSSLsha3_512;
+VALUE cCoBreakOpenSSLripemd160;
+
+
+VALUE ripemd160_hexdigest(VALUE self, VALUE full){
+	char *str = RSTRING_PTR(full);
+	int n;
+	RIPEMD160_CTX c;
+	unsigned char digest[65];
+	char *out = (char*)malloc(33);
+	int length = strlen(str);
+
+    RIPEMD160_Init(&c);
+
+    while (length > 0) {
+        if (length > 512) {
+            RIPEMD160_Update(&c, str, 512);
+        } else {
+            RIPEMD160_Update(&c, str, length);
+        }
+        length -= 512;
+	str += 512;
+    }
+
+    RIPEMD160_Final(digest, &c);
+
+    for (n = 0; n < RIPEMD160_DIGEST_LENGTH; ++n) {
+        snprintf(&(out[n*2]), RIPEMD160_DIGEST_LENGTH*2, "%02x", (unsigned int)digest[n]);
+    }
+
+    return rb_str_new2(out);
+    free(out);
+}
+
+VALUE md4_hexdigest(VALUE self, VALUE input) {
+    // Convertir el valor Ruby a una cadena C
+    char *str = RSTRING_PTR(input);
+    int length = RSTRING_LEN(input); // Obtener la longitud de la cadena
+    unsigned char digest[MD4_DIGEST_LENGTH]; // MD4 produce un hash de 16 bytes
+    char out[33]; // 16 bytes * 2 para hexadecimal + 1 para el terminador
+
+    // Calcular el hash MD4
+    MD4((unsigned char*)str, length, digest);
+
+    // Convertir el hash a una cadena hexadecimal
+    for (int n = 0; n < MD4_DIGEST_LENGTH; ++n) {
+        sprintf(&(out[n * 2]), "%02x", (unsigned int)digest[n]);
+    }
+    out[32] = '\0'; // Terminar la cadena
+
+    VALUE result = rb_str_new2(out); // Crear una nueva cadena Ruby
+    return result;
+}
+
+VALUE md5_hexdigest(VALUE self, VALUE input) {
+    // Convertir el valor Ruby a una cadena C
+    char *str = RSTRING_PTR(input);
+    int length = RSTRING_LEN(input); // Obtener la longitud de la cadena
+    unsigned char digest[MD5_DIGEST_LENGTH]; // MD5 produce un hash de 16 bytes
+    char out[33]; // 16 bytes * 2 para hexadecimal + 1 para el terminador
+
+    // Calcular el hash MD5
+    MD5((unsigned char*)str, length, digest);
+
+    // Convertir el hash a una cadena hexadecimal
+    for (int n = 0; n < MD5_DIGEST_LENGTH; ++n) {
+        sprintf(&(out[n * 2]), "%02x", (unsigned int)digest[n]);
+    }
+    out[32] = '\0'; // Terminar la cadena
+
+    VALUE result = rb_str_new2(out); // Crear una nueva cadena Ruby
+    return result;
+}
+
+VALUE half_md5_hexdigest(VALUE self, VALUE input) {
+    // Convertir el valor Ruby a una cadena C
+    char *str = RSTRING_PTR(input);
+    int length = RSTRING_LEN(input); // Obtener la longitud de la cadena
+    unsigned char digest[MD5_DIGEST_LENGTH]; // MD5 produce un hash de 16 bytes
+    char out[17]; // 8 bytes * 2 para hexadecimal + 1 para el terminador
+
+    // Calcular el hash MD5
+    MD5((unsigned char*)str, length, digest);
+
+    // Convertir solo los primeros 8 bytes del hash a una cadena hexadecimal
+    for (int n = 0; n < 8; ++n) {
+        sprintf(&(out[n * 2]), "%02x", (unsigned int)digest[n]);
+    }
+    out[16] = '\0'; // Terminar la cadena
+
+    VALUE result = rb_str_new2(out); // Crear una nueva cadena Ruby
+    return result;
+}
+
+VALUE sha1_hexdigest(VALUE self, VALUE input) {
+    // Convertir el valor Ruby a una cadena C
+    char *str = RSTRING_PTR(input);
+    int length = RSTRING_LEN(input); // Obtener la longitud de la cadena
+    unsigned char digest[SHA_DIGEST_LENGTH]; // SHA-1 produce un hash de 20 bytes
+    char out[41]; // 20 bytes * 2 para hexadecimal + 1 para el terminador
+
+    // Calcular el hash SHA-1
+    SHA1((unsigned char*)str, length, digest);
+
+    // Convertir el hash a una cadena hexadecimal
+    for (int n = 0; n < SHA_DIGEST_LENGTH; ++n) {
+        sprintf(&(out[n * 2]), "%02x", (unsigned int)digest[n]);
+    }
+    out[40] = '\0'; // Terminar la cadena
+
+    VALUE result = rb_str_new2(out); // Crear una nueva cadena Ruby
+    return result;
+}
+
+VALUE sha2_224_hexdigest(VALUE self, VALUE input) {
+    // Convertir el valor Ruby a una cadena C
+    char *str = RSTRING_PTR(input);
+    int length = RSTRING_LEN(input); // Obtener la longitud de la cadena
+    unsigned char digest[SHA224_DIGEST_LENGTH]; // SHA-224 produce un hash de 28 bytes
+    char out[57]; // 28 bytes * 2 para hexadecimal + 1 para el terminador
+
+    // Calcular el hash SHA-224
+    SHA224((unsigned char*)str, length, digest);
+
+    // Convertir el hash a una cadena hexadecimal
+    for (int n = 0; n < SHA224_DIGEST_LENGTH; ++n) {
+        sprintf(&(out[n * 2]), "%02x", (unsigned int)digest[n]);
+    }
+    out[56] = '\0'; // Terminar la cadena
+
+    VALUE result = rb_str_new2(out); // Crear una nueva cadena Ruby
+    return result;
+}
+
+VALUE sha2_256_hexdigest(VALUE self, VALUE input) {
+    // Convertir el valor Ruby a una cadena C
+    char *str = RSTRING_PTR(input);
+    int length = RSTRING_LEN(input); // Obtener la longitud de la cadena
+    unsigned char digest[SHA256_DIGEST_LENGTH]; // SHA-256 produce un hash de 32 bytes
+    char out[65]; // 32 bytes * 2 para hexadecimal + 1 para el terminador
+
+    // Calcular el hash SHA-256
+    SHA256((unsigned char*)str, length, digest);
+
+    // Convertir el hash a una cadena hexadecimal
+    for (int n = 0; n < SHA256_DIGEST_LENGTH; ++n) {
+        sprintf(&(out[n * 2]), "%02x", (unsigned int)digest[n]);
+    }
+    out[64] = '\0'; // Terminar la cadena
+
+    VALUE result = rb_str_new2(out); // Crear una nueva cadena Ruby
+    return result;
+}
+
+VALUE sha2_384_hexdigest(VALUE self, VALUE input) {
+    // Convertir el valor Ruby a una cadena C
+    char *str = RSTRING_PTR(input);
+    int length = RSTRING_LEN(input); // Obtener la longitud de la cadena
+    unsigned char digest[SHA384_DIGEST_LENGTH]; // SHA-384 produce un hash de 48 bytes
+    char out[97]; // 48 bytes * 2 para hexadecimal + 1 para el terminador
+
+    // Calcular el hash SHA-384
+    SHA384((unsigned char*)str, length, digest);
+
+    // Convertir el hash a una cadena hexadecimal
+    for (int n = 0; n < SHA384_DIGEST_LENGTH; ++n) {
+        sprintf(&(out[n * 2]), "%02x", (unsigned int)digest[n]);
+    }
+    out[96] = '\0'; // Terminar la cadena
+
+    VALUE result = rb_str_new2(out); // Crear una nueva cadena Ruby
+    return result;
+}
+
+VALUE sha2_512_hexdigest(VALUE self, VALUE input) {
+    // Convertir el valor Ruby a una cadena C
+    char *str = RSTRING_PTR(input);
+    int length = RSTRING_LEN(input); // Obtener la longitud de la cadena
+    unsigned char digest[SHA512_DIGEST_LENGTH]; // SHA-512 produce un hash de 64 bytes
+    char out[129]; // 64 bytes * 2 para hexadecimal + 1 para el terminador
+
+    // Calcular el hash SHA-512
+    SHA512((unsigned char*)str, length, digest);
+
+    // Convertir el hash a una cadena hexadecimal
+    for (int n = 0; n < SHA512_DIGEST_LENGTH; ++n) {
+        sprintf(&(out[n * 2]), "%02x", (unsigned int)digest[n]);
+    }
+    out[128] = '\0'; // Terminar la cadena
+
+    VALUE result = rb_str_new2(out); // Crear una nueva cadena Ruby
+    return result;
+}
+
+VALUE sha3_224_hexdigest(VALUE self, VALUE input) {
+
+    // Asegúrate de que el input es una cadena
+
+    Check_Type(input, T_STRING);
+
+
+    // Crear un contexto para el hash
+
+    EVP_MD_CTX *ctx = EVP_MD_CTX_new();
+
+    const EVP_MD *md = EVP_sha3_224();
+
+    
+
+    // Inicializar el contexto y calcular el hash
+
+    EVP_DigestInit_ex(ctx, md, NULL);
+
+    EVP_DigestUpdate(ctx, (unsigned char *)StringValueCStr(input), RSTRING_LEN(input));
+
+    
+
+    unsigned char output[EVP_MAX_MD_SIZE];
+
+    unsigned int output_len;
+
+
+    EVP_DigestFinal_ex(ctx, output, &output_len);
+
+    EVP_MD_CTX_free(ctx);
+
+
+    // Convertir el hash a una cadena hexadecimal
+
+    VALUE hex_string = rb_str_new("", 0);
+
+    for (unsigned int i = 0; i < output_len; i++) {
+
+        rb_str_catf(hex_string, "%02x", output[i]);
+
+    }
+
+
+    return hex_string;
+}
+
+VALUE sha3_256_hexdigest(VALUE self, VALUE input) {
+
+    // Asegúrate de que el input es una cadena
+
+    Check_Type(input, T_STRING);
+
+
+    // Crear un contexto para el hash
+
+    EVP_MD_CTX *ctx = EVP_MD_CTX_new();
+
+    const EVP_MD *md = EVP_sha3_256();
+
+    
+
+    // Inicializar el contexto y calcular el hash
+
+    EVP_DigestInit_ex(ctx, md, NULL);
+
+    EVP_DigestUpdate(ctx, (unsigned char *)StringValueCStr(input), RSTRING_LEN(input));
+
+    
+
+    unsigned char output[EVP_MAX_MD_SIZE];
+
+    unsigned int output_len;
+
+
+    EVP_DigestFinal_ex(ctx, output, &output_len);
+
+    EVP_MD_CTX_free(ctx);
+    // Convertir el hash a una cadena hexadecimal
+
+    VALUE hex_string = rb_str_new("", 0);
+
+    for (unsigned int i = 0; i < output_len; i++) {
+
+        rb_str_catf(hex_string, "%02x", output[i]);
+
+    }
+    return hex_string;
+}
+
+VALUE sha3_384_hexdigest(VALUE self, VALUE input) {
+
+    // Asegúrate de que el input es una cadena
+
+    Check_Type(input, T_STRING);
+
+
+    // Crear un contexto para el hash
+
+    EVP_MD_CTX *ctx = EVP_MD_CTX_new();
+
+    const EVP_MD *md = EVP_sha3_384();
+
+    
+
+    // Inicializar el contexto y calcular el hash
+
+    EVP_DigestInit_ex(ctx, md, NULL);
+
+    EVP_DigestUpdate(ctx, (unsigned char *)StringValueCStr(input), RSTRING_LEN(input));
+
+    
+
+    unsigned char output[EVP_MAX_MD_SIZE];
+
+    unsigned int output_len;
+
+
+    EVP_DigestFinal_ex(ctx, output, &output_len);
+
+    EVP_MD_CTX_free(ctx);
+
+
+    // Convertir el hash a una cadena hexadecimal
+
+    VALUE hex_string = rb_str_new("", 0);
+
+    for (unsigned int i = 0; i < output_len; i++) {
+
+        rb_str_catf(hex_string, "%02x", output[i]);
+
+    }
+    return hex_string;
+}
+
+VALUE sha3_512_hexdigest(VALUE self, VALUE input) {
+
+    // Asegúrate de que el input es una cadena
+
+    Check_Type(input, T_STRING);
+
+
+    // Crear un contexto para el hash
+
+    EVP_MD_CTX *ctx = EVP_MD_CTX_new();
+
+    const EVP_MD *md = EVP_sha3_512();
+
+    
+
+    // Inicializar el contexto y calcular el hash
+
+    EVP_DigestInit_ex(ctx, md, NULL);
+
+    EVP_DigestUpdate(ctx, (unsigned char *)StringValueCStr(input), RSTRING_LEN(input));
+
+    
+
+    unsigned char output[EVP_MAX_MD_SIZE];
+
+    unsigned int output_len;
+
+
+    EVP_DigestFinal_ex(ctx, output, &output_len);
+
+    EVP_MD_CTX_free(ctx);
+
+
+    // Convertir el hash a una cadena hexadecimal
+
+    VALUE hex_string = rb_str_new("", 0);
+
+    for (unsigned int i = 0; i < output_len; i++) {
+
+        rb_str_catf(hex_string, "%02x", output[i]);
+
+    }
+
+
+    return hex_string;
+
+}
+
+void init_cobreak_openssl(){
+                //Define module OpenSSL in mCoBreak
+                mCoBreakOpenSSL = rb_define_module_under(mCoBreak, "OpenSSL");
+                //Define Class MD4 encrypt mode
+                cCoBreakOpenSSLmd4 = rb_define_class_under(mCoBreakOpenSSL, "MD4", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLmd4, "hexdigest", md4_hexdigest, 1);
+                //Define Class MD5 encrypt mode
+                cCoBreakOpenSSLmd5 = rb_define_class_under(mCoBreakOpenSSL, "MD5", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLmd5, "hexdigest", md5_hexdigest, 1);
+                //Define Class MD5 encrypt mode
+                cCoBreakOpenSSLhalf_md5 = rb_define_class_under(mCoBreakOpenSSL, "HALF_MD5", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLhalf_md5, "hexdigest", half_md5_hexdigest, 1);
+                //Define Class SHA-1 encrypt mode
+                cCoBreakOpenSSLsha1 = rb_define_class_under(mCoBreakOpenSSL, "SHA1", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLsha1, "hexdigest", sha1_hexdigest, 1);
+                //Define Class SHA2-224 encrypt mode
+                cCoBreakOpenSSLsha2_224 = rb_define_class_under(mCoBreakOpenSSL, "SHA2_224", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLsha2_224, "hexdigest", sha2_224_hexdigest, 1);
+                //Define Class SHA2-256 encrypt mode
+                cCoBreakOpenSSLsha2_256 = rb_define_class_under(mCoBreakOpenSSL, "SHA2_256", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLsha2_256, "hexdigest", sha2_256_hexdigest, 1);
+                //Define Class SHA2-384 encrypt mode
+                cCoBreakOpenSSLsha2_384 = rb_define_class_under(mCoBreakOpenSSL, "SHA2_384", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLsha2_384, "hexdigest", sha2_384_hexdigest, 1);
+                //Define Class SHA2-512 encrypt mode
+                cCoBreakOpenSSLsha2_512 = rb_define_class_under(mCoBreakOpenSSL, "SHA2_512", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLsha2_512, "hexdigest", sha2_512_hexdigest, 1);
+                //Define Class SHA3-224 encrypt mode
+                cCoBreakOpenSSLsha3_224 = rb_define_class_under(mCoBreakOpenSSL, "SHA3_224", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLsha3_224, "hexdigest", sha3_224_hexdigest, 1);
+                //Define Class SHA3-224 encrypt mode
+                cCoBreakOpenSSLsha3_256 = rb_define_class_under(mCoBreakOpenSSL, "SHA3_256", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLsha3_256, "hexdigest", sha3_256_hexdigest, 1);
+                //Define Class SHA3-224 encrypt mode
+                cCoBreakOpenSSLsha3_384 = rb_define_class_under(mCoBreakOpenSSL, "SHA3_384", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLsha3_384, "hexdigest", sha3_384_hexdigest, 1);
+                //Define Class SHA3-224 encrypt mode
+                cCoBreakOpenSSLsha3_512 = rb_define_class_under(mCoBreakOpenSSL, "SHA3_512", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLsha3_512, "hexdigest", sha3_512_hexdigest, 1);
+                //Define Class RIPEMD-160 encrypt mode
+                cCoBreakOpenSSLripemd160 = rb_define_class_under(mCoBreakOpenSSL, "RIPEMD_160", rb_cObject);
+                rb_define_singleton_method(cCoBreakOpenSSLripemd160, "hexdigest", ripemd160_hexdigest, 1);
+}

data/ext/cobreak/cobreak_openssl.h

@@ -0,0 +1,21 @@
+#ifndef COBREAK_OPENSSL_RUBY
+#define COBREAK_OPENSS_RUBY
+
+//include library <cobreak_ruby.h> for project
+#include<cobreak_ruby.h>
+
+//definition body for file <header>
+#include<openssl/sha.h>
+//#include<openssl/sha3.h>
+#include<openssl/md4.h>
+#include<openssl/md5.h>
+#include<openssl/ripemd.h>
+#include <openssl/evp.h>
+#include <openssl/err.h>
+//#include<crypto.h>
+//#include<ssl.h>
+
+//initialize function
+void init_cobreak_openssl();
+
+#endif

data/ext/cobreak/cobreak_ruby.h

@@ -0,0 +1,24 @@
+#ifndef COBREAK_RUBY
+#define COBREAK_RUBY
+
+#include<ruby.h>
+#include<string.h>
+#include<stdbool.h>
+#include<stdlib.h>
+#include<stdio.h>
+#include<stdint.h>
+
+extern VALUE mCoBreak;
+#if 0
+	VALUE mCoBreak = rb_define_module("CoBreak");
+#endif
+
+
+
+
+#include<cobreak_openssl.h>
+#include<cobreak_gcrypt.h>
+#include<cobreak_cipher.h>
+//#include<cobreak_exception.h>
+//continue...
+#endif

data/ext/cobreak/extconf.rb

@@ -0,0 +1,27 @@
+require "mkmf"
+
+#Welcome to CoBreak ExtConf
+
+abort "Missing library crypto" unless have_library("crypto")
+#if not have_header("openssl/ssl.h") and have_header("nettle/nettle-types.h") and have_library("crypto")
+#  abort("missing libreries of openssl / nettle / crypto")
+#end
+if (`gem search sqlite3 --installed` == "true\n")
+  #dir of configuration
+  dir_config("cobreak")
+#  if have_header("cobreak_ruby.h")
+#    have_header("string.h")
+#    if RUBY_PLATFORM =~ /mswin|darwin/
+#      have_header("window.h")
+#    end
+    create_header
+    have_library( 'stdc++' );
+    have_library('gcrypt');
+    $CFLAGS << " -Wall"
+    create_makefile("cobreak/cobreak")
+ # else
+ #   abort("missing header's of CoBreak")
+#  end
+else
+  abort("missing libreries, use (gem install sqlite3)")
+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

@@ -0,0 +1,30 @@
+class CesarCifrado
+  def cesar(dato, rotasiones, orientacion = 1)
+    cesar = OpenStruct.new
+    cesar.cad_rot = []
+    alfa_mayus = ('A'..'Z').to_a
+    alfa_minus = ('a'..'z').to_a
+    alf = 26
+    lit_mayus = 65
+    lit_minus = 97
+    cad_rot = ""
+    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
+      cesar.cad_rot << alfabeto[new_pos]
+      end
+      return cesar.cad_rot.join('')
+  end
+end
+Cesar = CesarCifrado.new

data/lib/cobreak/cifrado.rb

@@ -0,0 +1,30 @@
+require 'ascii85'
+
+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 = CoBreak::Cipher::Base16.encode(dato)
+      elsif (cipher.mode.eql?('base32'))
+        cipher.result = CoBreak::Cipher::Base32.encode(dato)
+      elsif (cipher.mode.eql?('base64'))
+        cipher.result = CoBreak::Cipher::Base64.encode(dato)
+      elsif (cipher.mode.eql?('ascii85'))
+        cipher.result = Ascii85.encode(dato)
+      elsif (cipher.mode.eql?('cesar'))
+        cipher.result = CoBreak::Cipher::Cesar.encode(dato, ARGV[0].to_i)
+      elsif (cipher.mode.eql?('binary'))
+        cipher.result = CoBreak::Cipher::Binary.encode(dato)
+      end
+      unless (cipher.result.nil?) or (cipher.result.eql?(cipher.dato))
+        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[37m+\e[1;31m]\e[37m Not Cipher Text..."
+      end
+    end
+  end
+end

data/lib/cobreak/cobreak_opt.rb

@@ -0,0 +1,77 @@
+#!/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/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
+        @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!
+              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
+            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
+    end
+    class Cryptgraphy
+      def self.crypt()
+        @options = $options
+        @options.encrypt = "" if @options.encrypt.nil? == true
+        @options.decrypt = "" if @options.decrypt.nil? == true
+        show = OpenStruct.new
+        show.crypt = %w[MD4 MD5 HALF-MD5 SHA1 SHA2-224 SHA2-256 SHA2-384 SHA2-512 SHA3-224 SHA3-256 SHA3-384 SHA3-512 RIPEMD-160 TIGER-160 DOUBLE-SHA1 BLAKE2S-128 BLAKE2S-160 BLAKE2B-160 BLAKE2S-224 BLAKE2S-256 BLAKE2B-256 BLAKE2B-384 BLAKE2B-512 WHIRLPOOL GOST-STREEBOG-256 GOST-STREEBOG-512 SHAKE-128]
+        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.crypt.include?(@options.encrypt.upcase))
+              DeCrypt::show(@options.decrypt, line) if (show.crypt.include?(@options.decrypt.upcase))
+            }
+          else
+            if (show.crypt.include?(@options.encrypt.upcase))
+              EnCrypt::show(@options.encrypt, @options.algo)
+            end
+            if (show.crypt.include?(@options.decrypt.upcase))
+              DeCrypt::show(@options.decrypt.upcase, @options.algo)
+              #DeCrypt::show(@options.decrypt, @options.algo)
+            end
+          end
+        else
+          abort "\e[31m[\e[37m✘\e[31m]\e[37m Invalid Hash Format"
+        end
+      end
+    end
+  end
+end

data/lib/cobreak/decifrado.rb

@@ -0,0 +1,30 @@
+require 'ascii85'
+
+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 = CoBreak::Cipher::Base16.decode(decipher.dato)
+      elsif (decipher.mode.eql?('base32'))
+        decipher.result = CoBreak::Cipher::Base32.decode(decipher.dato)
+      elsif (decipher.mode.eql?('base64'))
+        decipher.result = CoBreak::Cipher::Base64.decode(decipher.dato)
+      elsif (decipher.mode.eql?('ascii85'))
+        decipher.result = Ascii85.decode(decipher.dato)
+      elsif (decipher.mode.eql?('cesar'))
+        decipher.result = CoBreak::Cipher::Cesar.decode(decipher.dato, ARGV[0].to_i)
+      elsif (decipher.mode.eql?('binary'))
+        decipher.result = CoBreak::Cipher::Binary.decode(decipher.dato)
+      end
+      unless (decipher.result.nil?) or (decipher.result.eql?(decipher.dato))
+        puts "\n\e[1;32m[\e[37m+\e[1;32m]\e[37m DecipherText: #{decipher.result}"
+        puts "\e[1;32m[\e[37m+\e[1;32m]\e[37m Number Rotations: #{ARGV[0]}" if (decipher.mode.eql?('cesar'))
+      else
+        puts "\e[1;31m[\e[37m+\e[1;31m]\e[37m Not Cipher Text..."
+      end
+    end
+  end
+end