ff1 1.0.0 → 1.2.0

data/spec/ff1_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe FF1 do
-  it "has a version number" do
+  it 'has a version number' do
     expect(FF1::VERSION).not_to be nil
   end
 
@@ -9,182 +11,321 @@ RSpec.describe FF1 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
+    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
+      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
+      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
+      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")
+        expect do
+          FF1::Cipher.new(invalid_key, 10)
+        end.to raise_error(FF1::Error, 'Invalid key length - must be 16, 24, or 32 bytes')
       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")
+      it 'rejects invalid radix values' do
+        expect { FF1::Cipher.new(key, 1) }.to raise_error(FF1::Error, 'Invalid radix - must be between 2 and 65536')
+        expect do
+          FF1::Cipher.new(key, 65_537)
+        end.to raise_error(FF1::Error, 'Invalid radix - must be between 2 and 65536')
       end
 
-      it "accepts valid radix values" do
+      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
+        expect { FF1::Cipher.new(key, 65_536) }.not_to raise_error
       end
     end
 
-    describe "#encrypt and #decrypt" do
-      it "encrypts and decrypts correctly for numeric data" do
-        plaintext = "1234567890"
+    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"
+      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"
-        
+      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"
-        
+      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
+      it 'handles hexadecimal data with radix 16' do
         hex_cipher = FF1::Cipher.new(key, 16)
-        plaintext = "ABCDEF123456"
-        
+        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")
+      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")
+      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")
+      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/)
+      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
+      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"
+        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
+      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"
-        
+    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"
+      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
-          
+      it 'handles various input lengths' do
+        %w[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
+    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
+        # NOTE: For radix 2, we need longer inputs to meet domain size requirements
         # 2^7 = 128 > 100
-        plaintext = "1010101"
-        
+        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
+      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"
-        
+        plaintext = '123456'
+
         ciphertext = alpha_cipher.encrypt(plaintext)
         expect(alpha_cipher.decrypt(ciphertext)).to eq(plaintext)
       end
     end
+
+    describe 'text encryption support' do
+      it 'encrypts and decrypts simple text' do
+        text = 'Hello, World!'
+        encrypted = cipher.encrypt_text(text)
+        decrypted = cipher.decrypt_text(encrypted)
+
+        expect(decrypted).to eq(text)
+        expect(encrypted).not_to eq(text)
+        expect(encrypted).to match(%r{\A[A-Za-z0-9+/]+=*\z}) # base64 format
+      end
+
+      it 'handles text with special characters' do
+        text = "Special chars: !@#$%^&*()_+={[}]|\\:;\"'<,>.?/~`"
+        encrypted = cipher.encrypt_text(text)
+        decrypted = cipher.decrypt_text(encrypted)
+
+        expect(decrypted).to eq(text)
+      end
+
+      it 'handles Unicode text including emojis' do
+        text = 'Unicode: Héllo Wörld! 🌍🚀💻🔐'
+        encrypted = cipher.encrypt_text(text)
+        decrypted = cipher.decrypt_text(encrypted)
+
+        expect(decrypted).to eq(text)
+      end
+
+      it 'handles long text' do
+        text = 'This is a very long piece of text that contains multiple sentences and should test the ability of the FF1 cipher to handle large text inputs while maintaining all the security properties of format-preserving encryption. ' * 10
+        encrypted = cipher.encrypt_text(text)
+        decrypted = cipher.decrypt_text(encrypted)
+
+        expect(decrypted).to eq(text)
+        expect(text.length).to be > 1000 # Ensure it's actually long
+      end
+
+      it 'works with tweaks for text' do
+        text = 'Secret message'
+        tweak = 'context_123'
+
+        encrypted_with_tweak = cipher.encrypt_text(text, tweak)
+        encrypted_without_tweak = cipher.encrypt_text(text)
+
+        expect(encrypted_with_tweak).not_to eq(encrypted_without_tweak)
+        expect(cipher.decrypt_text(encrypted_with_tweak, tweak)).to eq(text)
+      end
+
+      it 'handles minimum length text (single character)' do
+        text = 'A'
+        encrypted = cipher.encrypt_text(text)
+        decrypted = cipher.decrypt_text(encrypted)
+
+        expect(decrypted).to eq(text)
+      end
+
+      it 'handles empty text edge case' do
+        expect { cipher.encrypt_text('') }.to raise_error(FF1::Error, 'Text cannot be empty')
+        expect { cipher.encrypt_text(nil) }.to raise_error(FF1::Error, 'Text cannot be nil')
+      end
+
+      it 'handles invalid base64 in decrypt_text' do
+        invalid_b64 = 'not-valid-base64!'
+        expect { cipher.decrypt_text(invalid_b64) }.to raise_error(FF1::Error, /Invalid base64/)
+      end
+
+      it 'text encryption is deterministic' do
+        text = 'Deterministic test'
+
+        encrypted1 = cipher.encrypt_text(text)
+        encrypted2 = cipher.encrypt_text(text)
+
+        expect(encrypted1).to eq(encrypted2)
+      end
+
+      it 'produces different ciphertext for different texts' do
+        text1 = 'First message'
+        text2 = 'Second message'
+
+        encrypted1 = cipher.encrypt_text(text1)
+        encrypted2 = cipher.encrypt_text(text2)
+
+        expect(encrypted1).not_to eq(encrypted2)
+      end
+
+      context 'with irreversible mode' do
+        let(:irreversible_cipher) { FF1::Cipher.new(key, 10, FF1::Modes::IRREVERSIBLE) }
+
+        it 'encrypts text in irreversible mode' do
+          text = 'Sensitive data to be deleted'
+          encrypted = irreversible_cipher.encrypt_text(text)
+
+          expect(encrypted).not_to eq(text)
+          expect(encrypted).to match(%r{\A[A-Za-z0-9+/]+=*\z}) # base64 format
+        end
+
+        it 'prevents decryption in irreversible mode' do
+          text = 'Cannot decrypt this'
+          encrypted = irreversible_cipher.encrypt_text(text)
+
+          expect { irreversible_cipher.decrypt_text(encrypted) }.to raise_error(
+            FF1::Error, 'Cannot decrypt text in irreversible mode - data is permanently transformed'
+          )
+        end
+
+        it 'produces consistent ciphertext for same plaintext in irreversible mode' do
+          text = 'Consistent irreversible'
+
+          encrypted1 = irreversible_cipher.encrypt_text(text)
+          encrypted2 = irreversible_cipher.encrypt_text(text)
+
+          expect(encrypted1).to eq(encrypted2)
+        end
+      end
+
+      context 'with different UTF-8 encodings' do
+        it 'handles text with different UTF-8 byte sequences' do
+          # Test various UTF-8 characters
+          texts = [
+            'ASCII only',
+            'Latin-1: café résumé',
+            'Cyrillic: Привет мир',
+            'Asian: 你好世界 こんにちは 안녕하세요',
+            'Math symbols: ∑∞≠±×÷',
+            'Emojis: 👋🌟💫✨🎉',
+            'Mixed: Hello 世界! 🌍'
+          ]
+
+          texts.each do |text|
+            encrypted = cipher.encrypt_text(text)
+            decrypted = cipher.decrypt_text(encrypted)
+            expect(decrypted).to eq(text), "Failed for text: #{text}"
+          end
+        end
+      end
+    end
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rspec'
 require_relative '../lib/ff1'
 
@@ -11,4 +13,4 @@ RSpec.configure do |config|
   end
 
   config.shared_context_metadata_behavior = :apply_to_host_groups
-end
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: ff1
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
-- FF1 Gem
+- Ahmed Abdellatif
 autorequire:
 bindir: exe
 cert_chain: []
@@ -38,8 +38,11 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: A Ruby implementation of the FF1 Format Preserving Encryption algorithm
-  from NIST SP 800-38G
+description: "A Ruby implementation of the FF1 Format Preserving Encryption algorithm
+  from NIST SP 800-38G.\nFeatures dual-mode operation: reversible encryption for active
+  data and irreversible encryption \nfor GDPR compliance and secure data deletion
+  while maintaining format and relationships.\nNow includes full UTF-8 text encryption
+  support for arbitrary strings while preserving FF1 security properties.\n"
 email:
 - ahmed.abdelatife@gmail.com
 executables: []
@@ -48,6 +51,7 @@ extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - DEMO.md
+- DUAL_MODE.md
 - IMPLEMENTATION.md
 - LICENSE
 - README.md
@@ -61,7 +65,12 @@ files:
 homepage: https://github.com/a-abdellatif98/ff1
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/a-abdellatif98/ff1/issues
+  changelog_uri: https://github.com/a-abdellatif98/ff1/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/a-abdellatif98/ff1/blob/main/README.md
+  homepage_uri: https://github.com/a-abdellatif98/ff1
+  source_code_uri: https://github.com/a-abdellatif98/ff1
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -80,5 +89,6 @@ requirements: []
 rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
-summary: FF1 Format Preserving Encryption implementation
+summary: NIST-compliant FF1 Format Preserving Encryption with dual-mode operation
+  and full text support
 test_files: []