ff1 1.0.0

data/spec/ff1_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+RSpec.describe FF1 do
+  it "has a version number" do
+    expect(FF1::VERSION).not_to be nil
+  end
+
+  describe FF1::Cipher do
+    let(:key) { "\x2B\x7E\x15\x16\x28\xAE\xD2\xA6\xAB\xF7\x15\x88\x09\xCF\x4F\x3C" }
+    let(:cipher) { FF1::Cipher.new(key, 10) }
+
+    describe "#initialize" do
+      it "accepts a valid 128-bit key" do
+        expect { FF1::Cipher.new(key, 10) }.not_to raise_error
+      end
+
+      it "accepts a valid 192-bit key" do
+        key_192 = "\x2B" * 24
+        expect { FF1::Cipher.new(key_192, 10) }.not_to raise_error
+      end
+
+      it "accepts a valid 256-bit key" do
+        key_256 = "\x2B" * 32
+        expect { FF1::Cipher.new(key_256, 10) }.not_to raise_error
+      end
+
+      it "rejects invalid key lengths" do
+        invalid_key = "\x2B" * 15
+        expect { FF1::Cipher.new(invalid_key, 10) }.to raise_error(FF1::Error, "Invalid key length")
+      end
+
+      it "rejects invalid radix values" do
+        expect { FF1::Cipher.new(key, 1) }.to raise_error(FF1::Error, "Invalid radix")
+        expect { FF1::Cipher.new(key, 65537) }.to raise_error(FF1::Error, "Invalid radix")
+      end
+
+      it "accepts valid radix values" do
+        expect { FF1::Cipher.new(key, 2) }.not_to raise_error
+        expect { FF1::Cipher.new(key, 16) }.not_to raise_error
+        expect { FF1::Cipher.new(key, 65536) }.not_to raise_error
+      end
+    end
+
+    describe "#encrypt and #decrypt" do
+      it "encrypts and decrypts correctly for numeric data" do
+        plaintext = "1234567890"
+        ciphertext = cipher.encrypt(plaintext)
+        
+        expect(ciphertext).not_to eq(plaintext)
+        expect(ciphertext.length).to eq(plaintext.length)
+        expect(cipher.decrypt(ciphertext)).to eq(plaintext)
+      end
+
+      it "preserves the format of the data" do
+        plaintext = "9876543210"
+        ciphertext = cipher.encrypt(plaintext)
+        
+        expect(ciphertext.length).to eq(plaintext.length)
+        ciphertext.each_char do |char|
+          expect(char).to match(/[0-9]/)
+        end
+      end
+
+      it "produces different ciphertext for different plaintexts" do
+        plaintext1 = "1234567890"
+        plaintext2 = "0987654321"
+        
+        ciphertext1 = cipher.encrypt(plaintext1)
+        ciphertext2 = cipher.encrypt(plaintext2)
+        
+        expect(ciphertext1).not_to eq(ciphertext2)
+      end
+
+      it "works with tweaks" do
+        plaintext = "1234567890"
+        tweak = "test"
+        
+        ciphertext_with_tweak = cipher.encrypt(plaintext, tweak)
+        ciphertext_without_tweak = cipher.encrypt(plaintext)
+        
+        expect(ciphertext_with_tweak).not_to eq(ciphertext_without_tweak)
+        expect(cipher.decrypt(ciphertext_with_tweak, tweak)).to eq(plaintext)
+      end
+
+      it "handles hexadecimal data with radix 16" do
+        hex_cipher = FF1::Cipher.new(key, 16)
+        plaintext = "ABCDEF123456"
+        
+        ciphertext = hex_cipher.encrypt(plaintext)
+        expect(hex_cipher.decrypt(ciphertext)).to eq(plaintext)
+        
+        ciphertext.each_char do |char|
+          expect(char).to match(/[0-9A-F]/)
+        end
+      end
+
+      it "raises error for input too short" do
+        expect { cipher.encrypt("1") }.to raise_error(FF1::Error, "Input length must be at least 2")
+      end
+
+      it "raises error for empty input" do
+        expect { cipher.encrypt("") }.to raise_error(FF1::Error, "Input cannot be empty")
+      end
+
+      it "raises error for nil input" do
+        expect { cipher.encrypt(nil) }.to raise_error(FF1::Error, "Input cannot be nil")
+      end
+
+      it "raises error for invalid characters" do
+        expect { cipher.encrypt("12A4") }.to raise_error(FF1::Error, /Invalid character/)
+      end
+
+      it "raises error for domain too small" do
+        # Create a cipher with radix 2 and input "10" -> 2^2 = 4 < 100
+        binary_cipher = FF1::Cipher.new(key, 2)
+        short_plaintext = "10"
+        expect { binary_cipher.encrypt(short_plaintext) }.to raise_error(FF1::Error, /Domain size too small/)
+      end
+
+      it "handles minimum valid domain size" do
+        plaintext = "12345"  # 10^5 = 100,000 > 100
+        ciphertext = cipher.encrypt(plaintext)
+        expect(cipher.decrypt(ciphertext)).to eq(plaintext)
+      end
+    end
+
+    describe "consistency tests" do
+      it "encryption is deterministic" do
+        plaintext = "1234567890"
+        
+        ciphertext1 = cipher.encrypt(plaintext)
+        ciphertext2 = cipher.encrypt(plaintext)
+        
+        expect(ciphertext1).to eq(ciphertext2)
+      end
+
+      it "decryption is deterministic" do
+        plaintext = "1234567890"
+        ciphertext = cipher.encrypt(plaintext)
+        
+        decrypted1 = cipher.decrypt(ciphertext)
+        decrypted2 = cipher.decrypt(ciphertext)
+        
+        expect(decrypted1).to eq(decrypted2)
+        expect(decrypted1).to eq(plaintext)
+      end
+
+      it "handles various input lengths" do
+        ["123", "1234", "12345", "123456", "1234567", "12345678", "123456789", "1234567890"].each do |plaintext|
+          next if plaintext.length < 3  # Skip too short inputs
+          
+          ciphertext = cipher.encrypt(plaintext)
+          decrypted = cipher.decrypt(ciphertext)
+          
+          expect(decrypted).to eq(plaintext), "Failed for input: #{plaintext}"
+          expect(ciphertext.length).to eq(plaintext.length), "Length mismatch for: #{plaintext}"
+        end
+      end
+    end
+
+    describe "different radix support" do
+      it "works with radix 2 (binary)" do
+        binary_cipher = FF1::Cipher.new(key, 2)
+        # Note: For radix 2, we need longer inputs to meet domain size requirements
+        # 2^7 = 128 > 100
+        plaintext = "1010101"
+        
+        ciphertext = binary_cipher.encrypt(plaintext)
+        expect(binary_cipher.decrypt(ciphertext)).to eq(plaintext)
+        
+        ciphertext.each_char do |char|
+          expect(char).to match(/[01]/)
+        end
+      end
+
+      it "works with radix 36" do
+        alpha_cipher = FF1::Cipher.new(key, 36)
+        # For testing, we'll use a simple numeric string that fits within radix 36
+        plaintext = "123ABC"
+        
+        # Convert to proper format for radix 36 (0-9, then continue with character codes)
+        # For simplicity in this test, we'll just use numbers
+        plaintext = "123456"
+        
+        ciphertext = alpha_cipher.encrypt(plaintext)
+        expect(alpha_cipher.decrypt(ciphertext)).to eq(plaintext)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rspec'
+require_relative '../lib/ff1'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: ff1
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- FF1 Gem
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-09-11 00:00:00.000000000 Z
+dependencies:
+- !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: A Ruby implementation of the FF1 Format Preserving Encryption algorithm
+  from NIST SP 800-38G
+email:
+- ahmed.abdelatife@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- DEMO.md
+- IMPLEMENTATION.md
+- LICENSE
+- README.md
+- examples/basic_usage.rb
+- lib/ff1.rb
+- lib/ff1/cipher.rb
+- lib/ff1/modes.rb
+- lib/ff1/version.rb
+- spec/ff1_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/a-abdellatif98/ff1
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: FF1 Format Preserving Encryption implementation
+test_files: []