rcrypto 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3af4e1f11c1db798442da56a2f451abd4f77ea7b6ab51d3a8714a055fc77552e
+  data.tar.gz: f39a0a959480d573e635a31c9e9ae70f69dbbd97c53569c2361e44e3dea164da
+SHA512:
+  metadata.gz: c567ca02115e156bd8cf620089ea97e6cc3ca0994c160d85a87eee68bda90111c7df839de7528757bee2f855e000a40aba077edbef3dc23234f4dfc345bfa63c
+  data.tar.gz: 60499a2a310c8d9292cbbbc9fc7e95713f7b731b297efeb00353cd82be024f0de2373df87c4b4dbe73e384033117532ca362117add2ebbf7b58a05b90f9761a3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 MAVEN
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,193 @@
+
+
+# RCrypto
+
+**RCrypto** is a custom encryption library for Ruby that offers a variety of encryption methods, including XOR encryption, Caesar cipher, and substitution cipher. It is designed for developers looking to implement secure communication features in their Ruby applications.
+
+## Marketing Message
+
+Do you want your script to look like this, hidden from prying eyes?
+
+```
+ZYLYMBLhG0XONonzLIUpDCeLQ$sWYR5GfbHgdTZAICPJndFRdeOBdzGUpFBNLoIErBxZ0BtBrCPNd==#9defa851ec8ec36149a13815ec6233c1
+```
+
+Instead of this?
+
+```ruby
+puts "Ruby Is The Best yoo Note: RCrypto Is Easy"
+```
+
+Use **RCrypto** to protect your hard-earned code from being stolen. Secure the source code you spent sleepless nights writing.
+
+## Features
+
+- **XOR Encryption**: A simple yet effective encryption method.
+- **Caesar Cipher**: A classic encryption technique with customizable shifts.
+- **Substitution Cipher**: Encrypt text by substituting characters with a shuffled alphabet.
+- **Custom Key Generation**: Automatically generate secure keys for encryption.
+- **Encryption Detection**: Identify whether a given text appears to be encrypted.
+
+## Installation
+
+To use RCrypto, follow the steps below to clone the repository and integrate it into your Ruby project.
+
+### 1. Clone the Repository
+
+Clone the RCrypto repository to your local machine:
+
+```bash
+git clone https://github.com/Abo5/rcrypto.git
+```
+#### or
+```bash
+gem install rcrypto
+```
+#### or
+```ruby
+source 'https://rubygems.org'
+
+gem 'rcrypto' 
+```
+```bash
+bundle install rcrypto
+```
+
+### 2. Require the Library in Your Ruby Script
+
+After cloning the repository, require the library in your Ruby script:
+
+```ruby
+require 'rcrypto'
+```
+
+## Basic Usage
+
+### Encrypting and Decrypting a Script
+
+Suppose you have a Ruby script (`test.rb`) that you want to encrypt and later decrypt.
+
+```ruby
+require 'rcrypto'
+
+# Read the original script
+original_script = File.read('test.rb')
+
+# Encrypt the script
+encrypted_script = RCrypto::CustomEncryptor.encrypt(original_script)
+puts "Encrypted script:"
+puts encrypted_script
+
+# Decrypt the script
+decrypted_script = RCrypto::CustomEncryptor.decrypt(encrypted_script)
+puts "\nDecrypted script:"
+puts decrypted_script
+
+# Execute the decrypted script
+eval(decrypted_script)
+```
+
+### Encrypting with an Auto-generated Key
+
+```ruby
+# Read the original script
+original_script = File.read('main.rb')
+
+# Encrypt the script using an auto-generated key
+encrypted_script = RCrypto::CustomEncryptor.encrypt(original_script)
+puts "Encrypted script:"
+puts encrypted_script
+
+# Decrypt the script
+decrypted_script = RCrypto::CustomEncryptor.decrypt(encrypted_script)
+puts "\nDecrypted script:"
+puts decrypted_script
+```
+
+## Advanced Usage
+
+### Using the SimpleEncryptor for Custom Encryption
+
+The `SimpleEncryptor` class allows for more flexibility with custom keys and ciphers.
+
+```ruby
+require 'rcrypto'
+
+text = "Hello World!"
+key = RCrypto::SimpleEncryptor.generate_simple_key(20)
+
+# XOR Encryption
+encrypted_text = RCrypto::SimpleEncryptor.xor_encrypt(text, key)
+puts "XOR Encrypted text:"
+puts encrypted_text
+
+decrypted_text = RCrypto::SimpleEncryptor.xor_decrypt(encrypted_text, key)
+puts "Decrypted text:"
+puts decrypted_text
+
+# Caesar Cipher Encryption
+shift = 5
+caesar_encrypted = RCrypto::SimpleEncryptor.caesar_encrypt(text, shift)
+puts "Caesar Encrypted text:"
+puts caesar_encrypted
+
+caesar_decrypted = RCrypto::SimpleEncryptor.caesar_decrypt(caesar_encrypted, shift)
+puts "Decrypted text:"
+puts caesar_decrypted
+```
+
+### Detecting Encrypted Text
+
+RCrypto can help determine if a given text appears to be encrypted.
+
+```ruby
+long_text = "This is a longer text that should be more complex to encrypt and easier to detect as encrypted."
+encrypted_text = RCrypto::SimpleEncryptor.xor_encrypt(long_text, key)
+
+if RCrypto::SimpleEncryptor.seems_encrypted?(encrypted_text)
+  puts "The text seems to be encrypted."
+else
+  puts "The text does not appear to be encrypted."
+end
+```
+
+## Contributing
+
+Contributions are welcome! If you'd like to contribute to RCrypto, please follow these steps:
+
+1. **Fork the repository.**
+2. **Create a new branch** (`git checkout -b feature/YourFeatureName`).
+3. **Make your changes** and commit them (`git commit -m 'Add some feature'`).
+4. **Push to the branch** (`git push origin feature/YourFeatureName`).
+5. **Open a Pull Request** on GitHub.
+
+Please ensure your code follows the existing coding conventions and passes all tests.
+
+## Running Tests
+
+RCrypto uses RSpec for testing. To run the tests, ensure you have the required dependencies installed and run:
+
+```bash
+bundle install
+bundle exec rspec
+```
+
+This will run the test suite and ensure everything is working as expected.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](https://github.com/Abo5/rcrypto/LICENSE) file for more details.
+
+## Issues and Feedback
+
+If you encounter any issues or have suggestions for improvements, please feel free to [open an issue](https://github.com/Abo5/rcrypto/issues) on GitHub. Your feedback is highly appreciated!
+
+## Authors
+
+- **MAVEN** - *Initial work* - [GitHub Profile](https://github.com/Abo5)
+
+## Acknowledgments
+
+- Special thanks to the open-source community for their continuous support.
+- Inspired by classic encryption techniques and the need for secure communication in Ruby applications.
+

data/lib/RCrypto/decode.rb

@@ -0,0 +1,21 @@
+# lib/RCrypto/decode.rb
+
+module RCrypto
+  module Decode
+    def self.xor_decrypt(text, key)
+      RCrypto::Encode.xor_encrypt(text, key)  # XOR encryption is its own inverse
+    end
+
+    def self.base64_custom_decode(text)
+      Base64.strict_decode64(text)
+    end
+
+    def self.caesar_cipher_decrypt(text, shift)
+      RCrypto::Encode.caesar_cipher_encrypt(text, 26 - shift)
+    end
+
+    def self.remove_fake_token(text)
+      text.gsub(/\$[a-zA-Z0-9]{10}/, '')
+    end
+  end
+end

data/lib/RCrypto/encode.rb

@@ -0,0 +1,32 @@
+# lib/RCrypto/encode.rb
+
+module RCrypto
+  module Encode
+    def self.xor_encrypt(text, key)
+      text.bytes.map.with_index do |byte, i|
+        (byte ^ key.bytes[i % key.length]).chr
+      end.join
+    end
+
+    def self.base64_custom_encode(text)
+      Base64.strict_encode64(text)
+    end
+
+    def self.caesar_cipher_encrypt(text, shift)
+      text.chars.map do |char|
+        if char.match(/[a-zA-Z]/)
+          base = char =~ /[a-z]/ ? 'a'.ord : 'A'.ord
+          ((char.ord - base + shift) % 26 + base).chr
+        else
+          char
+        end
+      end.join
+    end
+
+    def self.add_fake_token(text)
+      fake_token = "$" + SecureRandom.alphanumeric(10)
+      insertion_point = SecureRandom.random_number(text.length)
+      text.insert(insertion_point, fake_token)
+    end
+  end
+end

data/lib/RCrypto/version.rb

@@ -0,0 +1,4 @@
+# lib/RCrypto/version.rb
+module RCrypto
+  VERSION = "1.0"
+end

data/lib/RCrypto.rb

@@ -0,0 +1,119 @@
+# RCrypto/lib/RCrypto.rb
+require 'openssl'
+require 'base64'
+require 'digest'
+require 'securerandom'
+
+require_relative 'RCrypto/encode'
+require_relative 'RCrypto/decode'
+
+module RCrypto
+  class CustomEncryptor
+    # Encrypts the given text using a series of encryption steps
+    def self.encrypt(text)
+      key = generate_key
+      stage1 = Encode.xor_encrypt(text, key[0..15])
+      stage2 = Encode.base64_custom_encode(stage1)
+      stage3 = Encode.caesar_cipher_encrypt(stage2, key.bytes.sum % 26)
+      stage4 = Encode.add_fake_token(stage3)
+      final_encrypted = stage4 + "#" + key
+      final_encrypted
+    end
+
+    # Decrypts the given encrypted text using the same steps in reverse
+    def self.decrypt(encrypted_text_with_key)
+      encrypted_text, key = encrypted_text_with_key.split("#", 2)
+      stage4 = Decode.remove_fake_token(encrypted_text)
+      stage3 = Decode.caesar_cipher_decrypt(stage4, key.bytes.sum % 26)
+      stage2 = Decode.base64_custom_decode(stage3)
+      original_text = Decode.xor_decrypt(stage2, key[0..15])
+      original_text
+    end
+
+    # Generates a random key using MD5 hash
+    def self.generate_key
+      Digest::MD5.hexdigest(SecureRandom.bytes(16))
+    end
+  end
+
+  class SimpleEncryptor
+    def initialize(key)
+      @key = key
+      @key = generate_simple_key(20)
+    end
+
+    # Performs XOR encryption using the provided key
+    def self.xor_encrypt(text, key)
+      Encode.xor_encrypt(text, key)
+    end
+
+    # Decrypts text that was encrypted using XOR
+    def self.xor_decrypt(encrypted_text, key)
+      Decode.xor_decrypt(encrypted_text, key)
+    end
+
+    # Encrypts the text using the Caesar cipher with the specified shift
+    def self.caesar_encrypt(text, shift)
+      Encode.caesar_cipher_encrypt(text, shift)
+    end
+
+    # Decrypts text that was encrypted using the Caesar cipher
+    def self.caesar_decrypt(encrypted_text, shift)
+      Decode.caesar_cipher_decrypt(encrypted_text, shift)
+    end
+
+    # Generates a simple substitution cipher key by shuffling the alphabet
+    def self.generate_simple_key(length = 26)
+      alphabet = ('a'..'z').to_a.shuffle.join
+      alphabet
+    end
+
+    # Encrypts the text using a substitution cipher with the provided key
+    def self.substitution_encrypt(text, key)
+      alphabet = ('a'..'z').to_a.join
+      text.downcase.tr(alphabet, key)
+    end
+
+    # Decrypts text that was encrypted using a substitution cipher
+    def self.substitution_decrypt(encrypted_text, key)
+      alphabet = ('a'..'z').to_a.join
+      encrypted_text.tr(key, alphabet)
+    end
+
+    # Generates a simple hash of the text
+    def self.simple_hash(text)
+      hash = 0
+      text.each_byte do |byte|
+        hash = ((hash << 5) - hash) + byte
+        hash = hash & 0xFFFFFFFF
+      end
+      hash.to_s(16)
+    end
+
+    # Analyzes the frequency of characters in the text
+    def self.frequency_analysis(text)
+      text.downcase.chars.group_by(&:itself).transform_values(&:count).sort_by { |_, v| -v }.to_h
+    end
+
+    # Determines if the text appears to be encrypted based on several criteria
+    def self.seems_encrypted?(text)
+      return false if text.length < 20  # Short texts are unlikely to be encrypted
+
+      # Calculate entropy
+      frequency = frequency_analysis(text)
+      entropy = frequency.values.sum { |count| -count * Math.log2(count.to_f / text.length) }
+      normalized_entropy = entropy / Math.log2(text.length)
+
+      # Calculate the ratio of non-alphabetic characters
+      non_alpha_chars_ratio = text.count("^a-zA-Z").to_f / text.length
+
+      # Analyze patterns - number of repeated sequences
+      repeated_patterns = text.scan(/(.+)\1/).size
+
+      # Consider the text encrypted if entropy is very high,
+      # if there is a high ratio of non-alphabetic characters,
+      # or if the number of repeated patterns is very low
+      normalized_entropy > 0.8 || non_alpha_chars_ratio > 0.3 || repeated_patterns < 2
+    end
+  end
+end

data/spec/rcrypto_spec.rb

@@ -0,0 +1,106 @@
+require 'rspec'
+require_relative '../lib/RCrypto'
+
+RSpec.describe RCrypto::CustomEncryptor do
+  let(:text) { 'Hello World!' }
+  
+  describe '.encrypt and .decrypt' do
+    it 'encrypts and decrypts text correctly' do
+      encrypted_text = RCrypto::CustomEncryptor.encrypt(text)
+      decrypted_text = RCrypto::CustomEncryptor.decrypt(encrypted_text)
+      
+      expect(decrypted_text).to eq(text)
+    end
+
+    it 'produces different outputs for the same text with different keys' do
+      encrypted_text_1 = RCrypto::CustomEncryptor.encrypt(text)
+      encrypted_text_2 = RCrypto::CustomEncryptor.encrypt(text)
+      
+      expect(encrypted_text_1).not_to eq(encrypted_text_2)
+    end
+  end
+
+  describe '.generate_key' do
+    it 'generates a unique key each time' do
+      key1 = RCrypto::CustomEncryptor.generate_key
+      key2 = RCrypto::CustomEncryptor.generate_key
+
+      expect(key1).not_to eq(key2)
+      expect(key1.length).to eq(32)
+      expect(key2.length).to eq(32)
+    end
+  end
+end
+
+RSpec.describe RCrypto::SimpleEncryptor do
+  let(:text) { 'Hello World!' }
+  let(:key) { RCrypto::SimpleEncryptor.generate_simple_key(20) }
+
+  describe '.xor_encrypt and .xor_decrypt' do
+    it 'encrypts and decrypts text correctly' do
+      encrypted_text = RCrypto::SimpleEncryptor.xor_encrypt(text, key)
+      decrypted_text = RCrypto::SimpleEncryptor.xor_decrypt(encrypted_text, key)
+
+      expect(decrypted_text).to eq(text)
+    end
+  end
+
+  describe '.caesar_encrypt and .caesar_decrypt' do
+    it 'encrypts and decrypts text correctly with Caesar cipher' do
+      shift = 5
+      encrypted_text = RCrypto::SimpleEncryptor.caesar_encrypt(text, shift)
+      decrypted_text = RCrypto::SimpleEncryptor.caesar_decrypt(encrypted_text, shift)
+
+      expect(decrypted_text).to eq(text)
+    end
+  end
+
+  describe '.substitution_encrypt and .substitution_decrypt' do
+    it 'encrypts and decrypts text correctly with substitution cipher' do
+      key = RCrypto::SimpleEncryptor.generate_simple_key(26)
+      encrypted_text = RCrypto::SimpleEncryptor.substitution_encrypt(text, key)
+      decrypted_text = RCrypto::SimpleEncryptor.substitution_decrypt(encrypted_text, key)
+
+      expect(decrypted_text).to eq(text.downcase)
+    end
+  end
+
+  describe '.simple_hash' do
+    it 'produces the same hash for the same input' do
+      hash1 = RCrypto::SimpleEncryptor.simple_hash(text)
+      hash2 = RCrypto::SimpleEncryptor.simple_hash(text)
+
+      expect(hash1).to eq(hash2)
+    end
+
+    it 'produces different hashes for different inputs' do
+      hash1 = RCrypto::SimpleEncryptor.simple_hash(text)
+      hash2 = RCrypto::SimpleEncryptor.simple_hash('Different text')
+
+      expect(hash1).not_to eq(hash2)
+    end
+  end
+
+  describe '.frequency_analysis' do
+    it 'calculates frequency of characters in text' do
+      frequency = RCrypto::SimpleEncryptor.frequency_analysis(text)
+      
+      expect(frequency['l']).to eq(3)
+      expect(frequency['o']).to eq(2)
+    end
+  end
+
+  describe '.seems_encrypted?' do
+    it 'detects if text seems encrypted' do
+      long_text = 'This is a longer text that should be more complex to encrypt and easier to detect as encrypted.'
+      encrypted_text = RCrypto::SimpleEncryptor.xor_encrypt(long_text, key)
+      puts "Encrypted Text: #{encrypted_text}"  # طباعة النص المشفر للتحليل
+      expect(RCrypto::SimpleEncryptor.seems_encrypted?(encrypted_text)).to be true
+    end
+  
+    it 'detects if text is not encrypted' do
+      expect(RCrypto::SimpleEncryptor.seems_encrypted?(text)).to be false
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+# spec/spec_helper.rb
+require 'rspec'
+require_relative '../lib/RCrypto'

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: rcrypto
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- MAVEN
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-08-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: digest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: securerandom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: RCrypto provides custom encryption methods including XOR, Caesar cipher,
+  and substitution cipher for secure communication in Ruby applications.
+email: aszda33@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/RCrypto.rb
+- lib/RCrypto/decode.rb
+- lib/RCrypto/encode.rb
+- lib/RCrypto/version.rb
+- spec/rcrypto_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Abo5/rcrypto
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: A custom encryption library for Ruby.
+test_files: []