cobreaktws 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1a1000df1c655580f07fc0b8d0e552472d1bf8ed61237f1586f61db496dd1e39
+  data.tar.gz: 6a39de6bfbcac26983322fa42ec2bc5ec6fbe1b9f7c9d9be0fed48dcf287158c
+SHA512:
+  metadata.gz: df08b6a634312072473b69ee522a3af98bc9a4623370ef7d79ad766984eca1e33bf77a2a170f0d1c8edc90dbce94b4d454a2c70638130dbe5201cb2ea6619000
+  data.tar.gz: 2dbcbd15ca642b8309a5a07a5a1c42fd5c5767c3184c3e9df48d8ddd9c8b47e093c40ea974246472cce221fff4c121b358d13bc5c98fee5d54227b555b4e75ae

data/.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    "files.associations": {
+        "cobreak_base32.h": "c",
+        "cobreak_ruby.h": "c",
+        "cobreak_openssl.h": "c",
+        "md4.h": "c",
+        "cobreak_ascii85.h": "c",
+        "cobreak_binary.h": "c"
+    }
+}

data/Gemfile

@@ -0,0 +1,18 @@
+#source 'https://rubygems.org'
+source 'http://127.0.0.1:9292'
+gem "cobreak"
+=begin
+group :code do
+  gem 'base16'
+  gem 'base32'
+  gem 'base64'
+  gem 'Ascii85'
+end
+group :crypt do
+  gem 'openssl'
+end
+group :database do
+  gem 'sqlite3'
+  gem 'sequel'
+end
+=end

data/README.md

@@ -0,0 +1,72 @@
+# CoBreak
+
+[`CoBreak.com`](https://github.com/BreakingTWS/CoBreak.git)
+
+This script was made by [`Breaker`](https://github.com/BreakingTWS/CoBreak.git)
+
+CoBreak is a password security audit and recovery tool available for many operating systems. CoBreak supports various types of cipher and hashing for the purpose of facilitating data encryption or other
+
+# GitHub Stats
+
+![BreakerBox GitHub Stats](https://github-readme-stats.vercel.app/api?username=BreakingTWS&show_icons=true&theme=midnight-purple)
+
+<h1> Installation</h2>
+
+<h3> Cipher</h3>
+
+ - Base64
+ - Base32
+ - Base16
+ - Ascii85
+ - Cesar
+ - Binaries
+
+<h3> Raw-Hash</h3>
+
+ - MD4
+ - MD5
+ - Half-MD5
+ - SHA-1
+ - Double-SHA1
+ - SHA2-224
+ - SHA2-256
+ - SHA2-384
+ - SHA2-512
+ - SHA3-224
+ - SHA3-256
+ - SHA3-384
+ - SHA3-512
+ - Ripemd-160
+ - Tiger-160
+ - Blake2s-128
+ - Blake2s-160
+ - Blake2s-256
+ - Blake2b-160
+ - Blake2b-256
+ - Blake2b-384
+ - Blake2b-512
+ - GOST R 34.11-2012 (Streebog) 256-bit, big-endian
+ - GOST R 34.11-2012 (Streebog) 512-bit, big-endian
+
+<h1> Setup</h3>
+---
+<h2>Execute in your terminal for build ruby gem and installation:</h2>
+
+<h3>Build ruby gem:</h3>
+
+> $ **gem build cobreak.gemspec**
+
+<h3>And after install ruby gem:</h3>
+
+> $ **sudo gem install ./cobreak-1.0.4.gem**
+
+---
+# Version
+## CoBreak
+
+![CoBreak](https://img.shields.io/badge/CoBreak-1.0.4-blueviolet)
+
+# License
+
+This project is licensed under the (GNU GENERAL PUBLIC LICENSE) - see the [LICENSE](LICENSE) file for details
+# CoBreak

data/bin/cbrdb

@@ -0,0 +1,95 @@
+#!/bin/env ruby
+require 'ostruct'
+require 'fileutils'
+require 'cobreak/version'
+options = OpenStruct.new
+ARGV.each {|opt|
+    path_hash = File.join(Gem.path[1], "gems","cobreak-#{CoBreak.version}" , "lib", "cobreak", "hash", "hash.db")
+    path_chr = File.join(Gem.path[1], "gems","cobreak-#{CoBreak.version}" , "lib", "cobreak", "show")
+    path_bool = File.join(Gem.path[1], "gems","cobreak-#{CoBreak.version}" , "lib", "cobreak", "config", "database.db")
+    #dat = ['md4', 'md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'ripemd160']
+    dat = %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]
+    case opt
+        when 'start'
+        	begin
+            	File.open(path_bool, mode: 'w'){|line|
+            	    line.write 'true'
+            	}
+            	puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m The Database was activated"
+            rescue Errno::EACCES
+                puts "\e[1;31m[\e[1;37m✘\e[1;31m]\e[1;37m Access Denied"
+                puts "\e[1;31m[\e[1;37m✘\e[1;31m]\e[1;37m root privileges needed"
+            end
+        when 'stop'
+            begin
+            	File.open(path_bool, mode: 'w'){|line|
+                	line.puts false
+            	}
+            	puts "\e[1;33m[i]\e[37m Database already stopped"
+            rescue Errno::EACCES
+            	puts "\e[1;31m[\e[1;37m✘\e[1;31m]\e[1;37m Access Denied"
+                puts "\e[1;31m[\e[1;37m✘\e[1;31m]\e[1;37m root privileges needed"
+            end
+        when 'reinit'
+            begin
+                File.foreach(path_bool){|line|
+                    line.chomp!
+                    if (line == 'false')
+                        abort "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Database Not Started"
+                    end
+                }
+                File.open(path_hash, mode: 'w'){|line|
+                    line.puts nil
+                }
+                for dbreinit in dat
+                    File.open(path_chr + "/#{dbreinit}.db", mode: 'w'){|line|
+                        line.puts nil
+                    }
+                end
+                puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Reinitializing The Database"
+            rescue Errno::EACCES
+                puts "\e[1;31m[\e[1;37m✘\e[1;31m]\e[1;37m Access Denied"
+                puts "\e[1;31m[\e[1;37m✘\e[1;31m]\e[1;37m root privileges needed"
+            end
+        when 'delete'
+            begin
+                for dbdelete in dat
+                    FileUtils.rm(path_chr + "/#{dbdelete}.db")
+                end
+                FileUtils.rm(path_hash)
+                File.open(path_bool, mode: 'w'){|line|
+                    line.puts false
+                }
+                puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Database Deleted Successfully"
+            rescue Errno::ENOENT
+                puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m Database Deleted Successfully"
+            rescue Errno::EACCES
+                puts "\e[1;31m[\e[1;37m✘\e[1;31m]\e[1;37m Access Denied"
+                puts "\e[1;31m[\e[1;37m✘\e[1;31m]\e[1;37m root privileges needed"
+            end
+        when 'status'
+            puts "\e[37mCoBreak Database Status"
+            File.foreach(path_bool){|line|
+                line.chomp!
+                if (line.eql?('true'))
+                    puts "\e[1;32m[\e[1;37m+\e[1;32m]\e[1;37m The Database Is Activated"
+                    exit
+                end
+            }
+            if true
+                puts "\e[1;33m[i]\e[1;37m The Database Is Deactivated"
+            end
+        when 'help'
+            puts "Manage the CoBreak database"
+            puts
+            puts "Examples: cbrdb start"
+            puts
+            puts "cbrdb start                           # start the database"
+            puts "cbrdb stop                            # stop the database"
+            puts "cbrdb reinit                          # delete and reinitialize the database"
+            puts "cbrdb delete                          # delete database and stop using it"
+            puts "cbrdb status                          # check database status"
+        else
+            puts "parameter not found, run cbrdb help"
+    end
+}

data/bin/cobreak

@@ -0,0 +1,11 @@
+#!/bin/env ruby
+require 'ostruct'
+require 'optparse'
+require 'cobreak/run'
+options = OpenStruct.new
+begin
+  CoBreakOPT::Runner.runner(options)
+rescue OptionParser::InvalidOption, OptionParser::InvalidArgument => error
+  puts error.message
+  exit(1)
+end

data/cobreak.gemspec

@@ -0,0 +1,28 @@
+Gem::Specification.new do |info|
+  info.name        = 'cobreaktws'
+  info.version     = '1.0.4'
+  info.executables << "cobreak" 
+  info.executables << "cbrdb"
+  info.description = "The CoBreak script is an cipher and cryptography tool"
+  info.add_development_dependency "bundler", "~> 1.5"
+  info.add_development_dependency  "openssl", "~> 2.2.0"
+  info.add_development_dependency  "sequel", "~> 5.44.0"
+  info.add_development_dependency  "sqlite3", '~> 1.4', '>= 1.4.0'
+#  info.add_runtime_dependency "sequel", '~> 2.0', '>= 2.0.0'
+  info.add_runtime_dependency "sqlite3", '~> 1.4', '>= 1.4.0'
+  info.add_runtime_dependency "Ascii85", '~> 1.0', '>= 1.0.0'
+#  info.add_runtime_dependency "ruby_figlet", "=> 0"
+  info.authors     = ["BreakerTW"]
+  info.email       = 'breaker@gmail.com'
+  info.summary     = "Force Brute, Cipher, Cryptography"
+
+  info.extensions = %w[ext/cobreak/extconf.rb]
+
+  info.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(/^.gitignore/)
+  end
+
+  info.homepage    = 'https://github.com/BreakingTWS/CoBreak'
+  info.license       = 'MIT'
+  info.post_install_message = "thanks for installing my gem"
+end

data/ext/cobreak/cobreak.c

@@ -0,0 +1,17 @@
+#include<cobreak_ruby.h>
+
+VALUE mCoBreak;
+
+void Init_cobreak(){
+
+	mCoBreak = rb_define_module("CoBreak");
+
+
+
+
+
+
+	init_cobreak_openssl();
+	init_cobreak_gcrypt();
+	init_cobreak_cipher();
+}

data/ext/cobreak/cobreak_cipher.c

@@ -0,0 +1,341 @@
+#include<cobreak_cipher.h>
+
+VALUE mCoBreakCipher;
+VALUE cCoBreakBase16;
+VALUE cCoBreakBase32;
+VALUE cCoBreakBase64;
+VALUE cCoBreakCesar;
+VALUE cCoBreakBinary;
+
+char b32[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+//Base16
+void decodeblock16(const char bl[], char *blstr, size_t length) {
+    for (size_t i = 0; i < length / 2; i++) {
+        int byte = 0;
+        if (sscanf(bl + (i * 2), "%2x", &byte) != 1) {
+            // Manejar error: entrada hex inválida
+            rb_raise(rb_eArgError, "Invalid hex input");
+            return; // Esto no se alcanzará, pero es una buena práctica
+        }
+        blstr[i] = (unsigned char)byte;
+    }
+    blstr[length / 2] = '\0';  // Terminar correctamente la cadena
+}
+
+VALUE b16_decode(VALUE self, VALUE full) {
+    char *myb16 = RSTRING_PTR(full);
+    char strb16[1024];
+    size_t length = strlen(myb16);
+
+    // Validar longitud
+    if (length % 2 != 0) {
+        rb_raise(rb_eArgError, "Hex string must have an even length");
+    }
+
+    // Decodificación
+    decodeblock16(myb16, strb16, length);
+    return rb_str_new2(strb16);
+}
+
+void encodeblock16(const char bl[], size_t length, char b16str[]) {
+    const char *hexDigits = "0123456789ABCDEF";
+    for (size_t i = 0; i < length; i++) {
+        b16str[i * 2] = hexDigits[(bl[i] >> 4) & 0x0F];    // Primer dígito
+        b16str[i * 2 + 1] = hexDigits[bl[i] & 0x0F];       // Segundo dígito
+    }
+    b16str[length * 2] = '\0';  // Agregar el terminador de cadena
+}
+
+VALUE b16_encode(VALUE self, VALUE full) {
+    char *strb16 = RSTRING_PTR(full);
+    char myb16[1024 * 2 + 1];  // Buffer para la codificación
+    size_t length = strlen(strb16);
+
+    // Codificación
+    encodeblock16(strb16, length, myb16);
+    return rb_str_new2(myb16);
+}
+
+//Base32
+int decodeblock32(const char bl[], char *blstr){
+    int buffer = 0;
+    int bits_left = 0;
+    size_t output_length = 0;
+
+    for (size_t i = 0; i < strlen(bl); i++) {
+        if (bl[i] == '=') {
+            break; // Fin del mensaje
+        }
+
+        int value = strchr(b32, bl[i]) - b32;
+        if (value < 0 || value >= 32) {
+            break; // Carácter inválido
+        }
+
+        buffer = (buffer << 5) | value;
+        bits_left += 5;
+
+        if (bits_left >= 8) {
+            blstr[output_length++] = (buffer >> (bits_left - 8)) & 0xFF;
+            bits_left -= 8;
+        }
+    }
+    return output_length;
+}
+
+VALUE b32_decode(VALUE self, VALUE full) {
+    char *myb32 = RSTRING_PTR(full);
+    char strb32[1024] = "";
+    char *clrdst = strb32;
+
+    // Decodificar
+    int decoded_length = decodeblock32(myb32, clrdst);
+    clrdst[decoded_length] = '\0'; // Asegurar que la cadena esté terminada
+
+    return rb_str_new2(strb32);
+}
+
+
+void encodeblock32(const char bl[], int len, char b32str[]){
+    int buffer = 0;
+    int bits_left = 0;
+    size_t output_length = 0;
+
+    for (size_t i = 0; i < len; i++) {
+        buffer = (buffer << 8) | bl[i];
+        bits_left += 8;
+
+        while (bits_left >= 5) {
+            b32str[output_length++] = b32[(buffer >> (bits_left - 5)) & 0x1F];
+            bits_left -= 5;
+        }
+    }
+
+    if (bits_left > 0) {
+        b32str[output_length++] = b32[(buffer << (5 - bits_left)) & 0x1F];
+    }
+
+    // Añadir padding
+    while (output_length % 8 != 0) {
+        b32str[output_length++] = '=';
+    }
+
+    b32str[output_length] = '\0';
+}
+
+VALUE b32_encode(VALUE self, VALUE full) {
+    char *strb32 = RSTRING_PTR(full);
+    char myb32[1024] = "";
+    char *clrdst = myb32;
+
+   encodeblock32(strb32, strlen(strb32), clrdst);
+
+    return rb_str_new2(myb32);
+}
+
+
+//Base64
+void decodeblock64(unsigned char in[], char *clrstr) {
+	unsigned char out[4];
+	out[0] = in[0] << 2 | in[1] >> 4;
+	out[1] = in[1] << 4 | in[2] >> 2;
+	out[2] = in[2] << 6 | in[3] >> 0;
+	out[3] = '\0';
+	strncat(clrstr, out, sizeof(out));
+}
+
+VALUE b64_decode(VALUE self, VALUE full){
+//	check_Type(full, T_STRING);
+	int c, phase, i;
+	unsigned char in[4];
+	char *p;
+
+	char *myb64 = RSTRING_PTR(full);
+	char strb64[1024] = "";
+	char *clrdst = strb64;
+	clrdst[0] = '\0';
+	phase = 0; i=0;
+	while(myb64[i]){
+		c = (int) myb64[i];
+		if(c == '='){
+			decodeblock64(in, clrdst);
+			break;
+		}
+		p = strchr(b64, c);
+		if(p){
+			in[phase] = p - b64;
+			phase = (phase + 1) % 4;
+			if(phase == 0){
+				decodeblock64(in, clrdst);
+				in[0]=in[1]=in[2]=in[3]=0;
+			}
+		}
+		i++;
+	}
+	return rb_str_new2(strb64);
+}
+
+void encodeblock64(unsigned char bl[], char b64str[], int len){
+	unsigned char out[5];
+	out[0] = b64[ bl[0] >> 2 ];
+	out[1] = b64[ ((bl[0] & 0x03) << 4) | ((bl[1] & 0xf0) >> 4) ];
+	out[2] = (unsigned char) (len > 1 ? b64[ ((bl[1] & 0x0f) << 2) | ((bl[2] & 0xc0) >> 6) ] : '=');
+	out[3] = (unsigned char) (len > 2 ? b64[ bl[2] & 0x3f ] : '=');
+	out[4] = '\0';
+	strncat(b64str, out, sizeof(out));
+}
+
+VALUE b64_encode(VALUE self, VALUE full){
+//	check_Type(full, T_STRING);
+	unsigned char in[3];
+	int i, len = 0;
+	int j = 0;
+	//char b64dst[1024];
+	char *strb64 = RSTRING_PTR(full);
+	char myb64[1024] = "";
+	char *b64dst = myb64;
+	b64dst[0] = '\0';
+	while(strb64[j]){
+		len = 0;
+		for(i=0; i<3; i++){
+			in[i] = (unsigned char) strb64[j];
+			if(strb64[j]) {
+				len++; j++;
+			}
+			else in[i] = 0;
+		}
+		if(len){
+			encodeblock64(in, b64dst, len);
+		}
+	}
+	return rb_str_new2(b64dst);
+}
+
+//Define Cesar
+void encodeblock_cesar(const char *input, char *output, int shift){
+    for (size_t i = 0; i < strlen(input); i++) {
+        char c = input[i];
+
+        if (c >= 'A' && c <= 'Z') {
+            output[i] = (c - 'A' + shift) % 26 + 'A';
+        } else if (c >= 'a' && c <= 'z') {
+            output[i] = (c - 'a' + shift) % 26 + 'a';
+        } else {
+            output[i] = c;
+        }
+    }
+    output[strlen(input)] = '\0';
+}
+
+
+void decodeblock_cesar(const char *input, char *output, int shift){
+    
+    encodeblock_cesar(input, output, 26 - (shift % 26));
+}
+
+VALUE cesar_encode(VALUE self, VALUE str, VALUE shift) {
+    char *input = RSTRING_PTR(str);
+    char output[1024];  // Buffer para la salida
+    int shift_value = NUM2INT(shift);
+
+   
+    encodeblock_cesar(input, output, shift_value);
+    return rb_str_new2(output);
+}
+
+
+VALUE cesar_decode(VALUE self, VALUE str, VALUE shift) {
+    char *input = RSTRING_PTR(str);
+    char output[1024];  // Buffer para la salida
+    int shift_value = NUM2INT(shift);
+
+   
+    decodeblock_cesar(input, output, shift_value);
+    return rb_str_new2(output);
+}
+
+//Define Binary
+void encodeblock_binary(const char bl[], char *blstr, size_t length) {
+    for (size_t i = 0; i < length; i++) {
+        for (int j = 7; j >= 0; j--) {
+            blstr[i * 8 + (7 - j)] = ((bl[i] >> j) & 1) ? '1' : '0';
+        }
+    }
+    blstr[length * 8] = '\0';  
+}
+
+void decodeblock_binary(const char bl[], char *blstr, size_t length) {
+    for (size_t i = 0; i < length / 8; i++) {
+        char byte = 0;
+        for (int j = 0; j < 8; j++) {
+            byte = (byte << 1) | (bl[i * 8 + j] - '0');
+        }
+        blstr[i] = byte;
+    }
+    blstr[length / 8] = '\0'; 
+}
+
+VALUE binary_encode(VALUE self, VALUE full) {
+    char *strb = RSTRING_PTR(full);
+    char mybinary[1024 * 8 + 1]; 
+    size_t length = strlen(strb);
+
+    encodeblock_binary(strb, mybinary, length);
+    return rb_str_new2(mybinary);
+}
+
+
+VALUE binary_decode(VALUE self, VALUE full) {
+    char *mybinary = RSTRING_PTR(full);
+    char strb[1024];
+    size_t length = strlen(mybinary);
+
+    if (length % 8 != 0) {
+        rb_raise(rb_eArgError, "Binary string must have a length that is a multiple of 8");
+    }
+
+    decodeblock_binary(mybinary, strb, length);
+    return rb_str_new2(strb);
+}
+
+void init_cobreak_cipher() {
+    //Define module Cipher in mCoBreak
+    mCoBreakCipher = rb_define_module_under(mCoBreak, "Cipher");
+
+    //Define class Base16 in module mCoBreakCipher
+    cCoBreakBase16 = rb_define_class_under(mCoBreakCipher, "Base16", rb_cObject);
+
+    //Define method for class Base16
+    rb_define_singleton_method(cCoBreakBase16, "encode", b16_encode, 1);
+    rb_define_singleton_method(cCoBreakBase16, "decode", b16_decode, 1);
+
+    //Define class Base32 in module mCoBreakCipher
+    cCoBreakBase32 = rb_define_class_under(mCoBreakCipher, "Base32", rb_cObject);
+
+    //Define method for class Base32
+    rb_define_singleton_method(cCoBreakBase32, "encode", b32_encode, 1);
+    rb_define_singleton_method(cCoBreakBase32, "decode", b32_decode, 1);
+
+    //Define class Base64 in module mCoBreakCipher
+    cCoBreakBase64 = rb_define_class_under(mCoBreakCipher, "Base64", rb_cObject);
+
+    //Define method for class Base64
+    rb_define_singleton_method(cCoBreakBase64, "encode", b64_encode, 1);
+    rb_define_singleton_method(cCoBreakBase64, "decode", b64_decode, 1);
+
+    //Define class Cesar in module mCoBreakCipher
+    cCoBreakCesar = rb_define_class_under(mCoBreakCipher, "Cesar", rb_cObject);
+
+    //Define method for class Cesar
+    rb_define_singleton_method(cCoBreakCesar, "encode", cesar_encode, 2);
+    rb_define_singleton_method(cCoBreakCesar, "decode", cesar_decode, 2);
+
+    //Define class Cesar in module mCoBreakCipher
+    cCoBreakBinary = rb_define_class_under(mCoBreakCipher, "Binary", rb_cObject);
+
+    //Define method for class Binary
+    rb_define_singleton_method(cCoBreakBinary, "encode", binary_encode, 1);
+    rb_define_singleton_method(cCoBreakBinary, "decode", binary_decode, 1);
+}

data/ext/cobreak/cobreak_cipher.h

@@ -0,0 +1,10 @@
+#ifndef COBREAK_CIPHER_RUBY
+#define COBREAK_CIPHER_RUBY
+
+//include library <cobreak_ruby.h> for project
+#include<cobreak_ruby.h>
+
+//initialize function
+void init_cobreak_cipher();
+
+#endif