one_time_pad 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 33f288597326f8bac1f7f4d51e5dd803fe94594937cecbdb0259ae3c18ea5c00
+  data.tar.gz: 3b6108b127b784808f8f489a32cdf1302a8e77da31591cb0b8782df8cef12100
+SHA512:
+  metadata.gz: 2427e8f2a849086917a66a9d877d2110c387d41ccca36449760e96fbabe2d739d4e4873911c229e05176e968ccc9be9f4dd461bb1a6791b5b5a3b48f4e72cc76
+  data.tar.gz: 747a960a9233d04927a1fbba00d7094454d45153b3b707eea5a678f07253195bb959421ad0186c229a79d3c133ad4a0cfe12a342b98117eebfd931074d973e2b

data/.envrc

@@ -0,0 +1,2 @@
+
+export RR=`pwd`

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [1.0.0] - 2024-12-19
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Dewayne VanHoozer
+
+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,156 @@
+# OneTimePad
+
+OneTimePad is a Ruby gem that provides a casually secure implementation of the One-Time Pad encryption technique. It uses multiple substitution ciphers and is suitable for educational and practical use.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'one_time_pad'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install one_time_pad
+```
+
+## Usage
+
+Here's a basic example of how to use the OneTimePad class:
+
+```ruby
+require 'one_time_pad'
+
+# Create a new OneTimePad instance
+otp = OneTimePad.new
+
+# Set a secret (optional, defaults to current time if not set)
+otp.secret = Time.now
+
+# Generate a one-time pad
+pad = otp.generate_otp
+
+# Encode a message
+encoded_message = otp.code(message: "Hello, World!")
+
+# Decode the message
+decoded_message = otp.decode(message: encoded_message)
+
+puts decoded_message # Output: Hello, World!
+```
+
+You can also initialize the OneTimePad with a secret or an existing pad:
+
+```ruby
+# Initialize with a secret
+otp = OneTimePad.new(secret: Time.now)
+
+# Initialize with an existing pad
+existing_pad = Array.new(2048) { (32..126).to_a.shuffle }
+otp = OneTimePad.new(otp: existing_pad)
+```
+
+Example using a custom number of rows:
+
+```ruby
+# Create a new OneTimePad instance
+otp = OneTimePad.new
+
+# Set the number of rows to 5
+otp.rows = 5
+
+# Generate a one-time pad
+pad = otp.generate_otp
+
+# Encode a message
+encoded_message = otp.code(message: "This is a test message.")
+
+# Decode the message
+decoded_message = otp.decode(message: encoded_message)
+
+puts decoded_message # Output: This is a test message.
+```
+
+## Features
+
+- Generate a one-time pad based on a secret or current time
+- Initialize with an existing pad
+- Encode messages using ASCII characters (32-126)
+- Decode messages using the same pad
+- Handles non-ASCII characters by replacing them with underscores
+
+## What is a Pad?
+
+Its a matrix.  The columns are character values.  A row is a full collection of the ASCII characters (32..129)  You index a row using the value of the plaintext character minus 32.  `row[0]['x'.ord - 32` to get the encoded value for 'x'  Each row is used for encoding one character.  The next character to be incoded will be at the current row index + 1 with a module on the size of the Pad.
+
+If we had a Pad size of 3 rows and wanted to encode the message 'xox'  The two 'x' characters would have the same encrypted value from row 0.  If the number of rows in the Pad is greater than the number of characters in your message then it is highly unlikely that the plaintext 'x' character would have the same encoded character since they never use the same row in the Pad.
+
+## What is a Pad?
+
+A Pad in this gem is a two-dimensional matrix used for encoding and decoding messages. It consists of multiple rows, each containing a shuffled set of ASCII characters (32-126).
+
+```ruby
+# Structure:
+pad = [
+  (32..126).to_a.shuffle,  # Row 0
+  (32..126).to_a.shuffle,  # Row 1
+  # ... more rows ...
+]
+```
+
+Encoding process:
+1. For each character in the plaintext:
+   a. Calculate the index: char.ord - 32
+   b. Use this index to look up the encoded value in the current row
+   c. Move to the next row (wrapping around if necessary)
+
+```ruby
+# Example:
+# To encode 'x' using row 0:
+encoded_x = pad[0]['x'.ord - 32]
+```
+
+The Pad's size affects security:
+- Larger Pads (more rows) reduce the chance of reusing rows for long messages
+- A Pad with more rows than the message length ensures each character uses a unique substitution
+
+Here is what happens when you have too few rows.
+
+Example:
+Encoding 'xox' with a 2-row Pad:
+- 'x' uses row 0
+- 'o' uses row 1
+- 'x' uses row 0 (same as the first 'x')
+- 'o' uses row 1 (same as the first 'o')
+
+Now your secret hugs and kisses may be exposed.
+
+The more rows approach significantly increases the difficulty of breaking the cipher through frequency analysis or other common cryptanalysis techniques.
+
+## Background
+
+The history of ciphers dates back thousands of years, with ancient examples such as the Caesar cipher, which shifted letters in the alphabet to obscure messages. Substitution ciphers, like the Caesar cipher, replace each letter of the plaintext with another letter. Although simple and historically significant, these early ciphers were vulnerable to frequency analysis due to their fixed substitution rules.
+
+One of the most secure methods introduced in the 20th century is the One-Time Pad (OTP). The One-Time Pad was first conceptualized by Frank Miller in 1882 and was later popularized by Gilbert Vernam in 1917. It is the only cryptographic method recognized as information-theoretically secure when implemented correctly. The security of the OTP arises from its use of a completely random key that is as long as the message and used only once. This ensures that even with infinite computational power, an eavesdropper cannot decipher the message without the key.
+
+However, while the One-Time Pad is theoretically unbreakable, it's crucial to emphasize that complexity does not inherently equate to strength. Despite the robust principles behind the One-Time Pad, practical implementation issues such as key generation and distribution can expose vulnerabilities.
+
+In this OneTimePad Ruby gem, we harness the Ruby MT1995 pseudo-random number generator, which can produce approximately 4.3 billion possible seeds. This level of randomness is significant, but it is important to note that the true security of the implementation relies on the utilization of an unknown number of unique pads. We use a default pad size of 2048 rows, each containing shuffled ASCII codes from 32 to 126. This provides a significant amount of randomness for practical use.  Theoritically a plain text message could have 2048 "X" characters which result in 2048 unique encoded characters.
+
+Each plaintext is run through different pads, adding layers of complexity. However, a determined adversary with sufficient resources and expertise might still find ways to break the cipher quickly.
+
+This class aims to take advantage of these principles for educational and practical use, illustrating the foundational concepts of modern cryptography and the importance of careful implementation.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/lib/one_time_pad.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+# lib/one_time_pad.rb
+
+# Implements a One-Time Pad (OTP) encryption system
+# This class provides methods to generate and use a one-time pad for
+# message encryption and decryption using ASCII characters (32-126)
+#
+# @example
+#   otp = OneTimePad.new
+#   otp.secret = Time.now
+#   pad = otp.generate_otp
+#   encoded = otp.code(message: "Hello")
+#   decoded = otp.decode(message: encoded)
+class OneTimePad
+  VERSION   = '1.0.0'
+  MAX_ROWS  = 2048
+
+  attr_accessor :pad, :secret, :rows
+
+  # Initialize a new OneTimePad instance
+  #
+  # @param secret [Time, nil] Optional time value used for pad generation
+  # @param otp [Array<Array<Integer>>, nil] Optional existing pad to use
+  # @return [OneTimePad] New instance
+  def initialize(
+      secret: nil,
+      otp:    nil
+    )
+
+    @secret = secret
+    @rows   = MAX_ROWS
+
+    if otp
+      @pad = otp
+    end
+  end
+
+  # Generates a random seed based on provided UTC time or current time
+  #
+  # @return [Integer] A random seed value based on time components
+  def kaos
+    utc = secret.nil? ? Time.now.utc : secret
+    utc.year + utc.month + utc.day +
+    utc.hour + utc.min   + utc.sec +
+    utc.usec
+  end
+
+  # Generates a pad of shuffled ASCII codes (32-126)
+  #
+  # @return [Array<Array<Integer>>] A 2D array of @rows,
+  #   each containing shuffled ASCII codes from 32-126
+  def generate_otp
+    srand(kaos) # seed the random generator
+    ascii_codes = (32..126).to_a
+    row_size    = ascii_codes.size
+    @pad = Array.new(@rows) { ascii_codes.shuffle }
+  end
+
+
+  # Encodes a message using the current pad
+  #
+  # @param message [String] The message to encode
+  # @return [String] The encoded message as a string of ASCII characters
+  def code(message:)
+    ascii_string = message.encode('ASCII', 
+                                  invalid: :replace,
+                                  undef:   :replace, 
+                                  replace: '_')
+
+    ascii_string.bytes.map.with_index do |byte, i|
+      row       = @pad[i % @pad.size]
+      char_code = byte.clamp(32, 126)
+      row[char_code - 32]
+    end.map(&:chr).join
+  end
+
+  # Decodes a message using the current pad
+  #
+  # @param message [String, Array<Integer>] The encoded message
+  # @return [String] The decoded message, with invalid characters
+  #   replaced by underscores
+  def decode(message:)
+    encoded = message.is_a?(String) ? message.bytes : message
+    encoded.map.with_index do |code, i|
+      row        = @pad[i % @pad.size]
+      char_index = row.index(code)
+      if char_index.nil?
+        '_'
+      else
+        (char_index + 32).chr
+      end
+    end.join
+  end
+end
+
+# Main Line
+if __FILE__ == $PROGRAM_NAME
+
+  original_message = <<~MESSAGE
+    The British are comming!
+    The British are comming!
+    The British are comming!
+    The British are comming!
+    They are so pretty in their red coats; however,
+    its our job as minute men to shoot them
+    down.  Don't fire until you see the whites of their eyes!
+    Grab your muskets and hide your women!
+    Grab your muskets and hide your women!
+    Grab your muskets and hide your women!
+    Grab your muskets and hide your women!
+    The British are comming!
+    The British are comming!
+  MESSAGE
+
+  otp         = OneTimePad.new
+  otp.secret  = Time.now
+  my_code     = otp.generate_otp
+  secret      = otp.code(message: original_message)
+
+  puts
+  puts secret
+  puts "="*65
+  puts otp.decode(message: secret)
+  puts "="*65
+  puts "== Different Instance with otp passed in ..."
+  puts
+  another = OneTimePad.new(otp: my_code)
+  puts another.decode(message: secret)
+  puts
+end

data/sig/one_time_pad.rbs

@@ -0,0 +1,4 @@
+module Otp
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: one_time_pad
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+original_platform: ''
+authors:
+- Dewayne VanHoozer
+bindir: bin
+cert_chain: []
+date: 2024-12-20 00:00:00.000000000 Z
+dependencies: []
+description: "This gem provides a casually secure (you will never beat \nthe pros)
+  implementation of the One-Time Pad \nencryption technique, using multiple substitution
+  \ncyphers suitable for educational and practical use.\nKnowing the code, you still
+  have approximately\n4.3 billion randon seeds to choose from to decode an\nunknown
+  message.\n"
+email:
+- dvanhoozer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".envrc"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/one_time_pad.rb
+- sig/one_time_pad.rbs
+homepage: https://github.com/MadBomber/one_time_pad
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/MadBomber/one_time_pad
+  source_code_uri: https://github.com/MadBomber/one_time_pad
+  changelog_uri: https://github.com/MadBomber/one_time_pad/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.1
+specification_version: 4
+summary: A One-Time Pad encryption method for messages.
+test_files: []