familia 2.0.0.pre4 → 2.0.0.pre6

data/try/features/encryption_fields/aad_protection_try.rb

@@ -0,0 +1,138 @@
+# try/features/encryption_fields/aad_protection_try.rb
+
+require 'concurrent'
+require 'base64'
+
+require_relative '../../helpers/test_helpers'
+
+test_keys = {
+  v1: Base64.strict_encode64('a' * 32),
+}
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+class AADProtectedModel < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  field :email
+  encrypted_field :api_key, aad_fields: [:email]
+end
+
+# Clean test environment
+Familia.dbclient.flushdb
+
+## AAD prevents field substitution attacks - proper cross-record test
+@victim = AADProtectedModel.new(id: 'victim-1', email: 'victim@example.com')
+@victim.save  # Need to save first for AAD to be active
+@victim.api_key = 'victim-secret-key'
+@victim.save  # Save the encrypted value
+
+# Extract the raw encrypted JSON data (not the ConcealedString object)
+@victim_encrypted_data = @victim.api_key.encrypted_value
+
+# Create an attacker record with different AAD context (different email)
+@attacker = AADProtectedModel.new(id: 'attacker-1', email: 'attacker@evil.com')
+@attacker.save  # Need to save for AAD to be active
+
+# Simulate database tampering: set attacker's field to victim's encrypted data
+# This simulates what an attacker with database access might try to do
+@attacker.instance_variable_set(:@api_key,
+  ConcealedString.new(@victim_encrypted_data, @attacker, @attacker.class.field_types[:api_key]))
+
+# Attempt to decrypt should fail due to AAD mismatch
+@result1 = begin
+  decrypted_value = nil
+  @attacker.api_key.reveal { |plaintext| decrypted_value = plaintext }
+  "UNEXPECTED SUCCESS: #{decrypted_value}"
+rescue Familia::EncryptionError => error
+  error.class.name
+end
+@result1
+#=> "Familia::EncryptionError"
+
+## Verify error message indicates decryption failure
+@result2 = begin
+  @attacker.api_key.reveal { |plaintext| plaintext }
+  "No error occurred"
+rescue Familia::EncryptionError => error
+  error.message.include?('Decryption failed')
+end
+@result2
+#=> true
+
+## Cross-record attack with same email (should still fail due to different identifiers)
+victim2 = AADProtectedModel.new(id: 'victim-2', email: 'shared@example.com')
+victim2.save
+victim2.api_key = 'victim2-secret'
+victim2.save
+
+attacker2 = AADProtectedModel.new(id: 'attacker-2', email: 'shared@example.com')  # Same email!
+attacker2.save
+
+# Extract victim's encrypted data and try to decrypt with attacker's context
+victim2_encrypted_data = victim2.api_key.encrypted_value
+attacker2.instance_variable_set(:@api_key,
+  ConcealedString.new(victim2_encrypted_data, attacker2, attacker2.class.field_types[:api_key]))
+
+# Should fail because identifier is part of AAD even when aad_fields match
+@result3 = begin
+  attacker2.api_key.reveal { |plaintext| plaintext }
+  "UNEXPECTED SUCCESS"
+rescue Familia::EncryptionError => error
+  error.class.name
+end
+@result3
+#=> "Familia::EncryptionError"
+
+## Without saving, AAD is not enforced (no database context)
+unsaved_model = AADProtectedModel.new(id: 'unsaved-1', email: 'test@example.com')
+unsaved_model.api_key = 'test-key'
+
+# Change email after encryption but before save - should still work
+unsaved_model.email = 'changed@example.com'
+decrypted = nil
+unsaved_model.api_key.reveal { |plaintext| decrypted = plaintext }
+decrypted
+#=> "test-key"
+
+## Cross-model attack with raw encrypted JSON
+# Demonstrate that raw encrypted data can't be moved between models
+@json_victim = AADProtectedModel.new(id: 'json-victim-1', email: 'jsonvictim@example.com')
+@json_victim.save
+@json_victim.api_key = 'json-victim-secret'
+
+# Get the raw encrypted JSON and create a new ConcealedString for different record
+@raw_encrypted_json = @json_victim.api_key.encrypted_value
+@json_attacker = AADProtectedModel.new(id: 'json-attacker-1', email: 'jsonattacker@evil.com')
+@json_attacker.save
+
+# Create ConcealedString with stolen encrypted JSON for the attacker
+@fake_concealed = ConcealedString.new(@raw_encrypted_json, @json_attacker, @json_attacker.class.field_types[:api_key])
+
+# Attempt decryption should fail
+@result4 = begin
+  @fake_concealed.reveal { |plaintext| plaintext }
+  "UNEXPECTED SUCCESS"
+rescue Familia::EncryptionError => error
+  error.class.name
+end
+@result4
+#=> "Familia::EncryptionError"
+
+## Successful decryption with correct context (control test)
+legitimate_user = AADProtectedModel.new(id: 'legitimate-1', email: 'legit@example.com')
+legitimate_user.save
+legitimate_user.api_key = 'legitimate-secret'
+legitimate_user.save
+
+# Normal decryption should work
+decrypted_legit = nil
+legitimate_user.api_key.reveal { |plaintext| decrypted_legit = plaintext }
+decrypted_legit
+#=> "legitimate-secret"
+
+# Cleanup
+Familia.dbclient.flushdb
+Familia.config.encryption_keys = nil
+Familia.config.current_key_version = nil

data/try/features/encryption_fields/concealed_string_core_try.rb

@@ -0,0 +1,250 @@
+# try/features/encryption_fields/concealed_string_core_try.rb
+
+require_relative '../../helpers/test_helpers'
+require 'base64'
+
+Familia.debug = false
+
+# Configure encryption keys
+test_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+# Test class with encrypted fields
+class TestSecretDocument < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  field :title                    # Regular field for comparison
+  encrypted_field :content        # This will use ConcealedString
+  encrypted_field :api_key        # Another encrypted field
+end
+
+# Assign it to the global namespace for proper naming
+Object.const_set(:SecretDocument, TestSecretDocument)
+
+# Clean test environment
+Familia.dbclient.flushdb
+
+# Create test document
+@doc = SecretDocument.new
+@doc.id = "test123"
+@doc.title = "Public Title"
+@doc.content = "secret information"
+@doc.api_key = "sk-1234567890"
+
+## Basic ConcealedString creation
+@doc.content.class.name
+#=> "ConcealedString"
+
+## API key also returns ConcealedString
+@doc.api_key.class.name
+#=> "ConcealedString"
+
+## Reveal API - controlled decryption
+revealed_content = nil
+@doc.content.reveal do |plaintext|
+  revealed_content = plaintext
+end
+revealed_content
+#=> "secret information"
+
+## Reveal can be called multiple times
+revealed_again = nil
+@doc.content.reveal do |plaintext|
+  revealed_again = plaintext
+end
+revealed_again
+#=> "secret information"
+
+## Reveal requires block argument
+begin
+  @doc.content.reveal  # No block provided
+rescue ArgumentError => e
+  e.message
+end
+#=> "Block required for reveal"
+
+## Universal Serialization Safety - to_s
+@doc.content.to_s
+#=> "[CONCEALED]"
+
+## inspect method
+@doc.content.inspect
+#=> "[CONCEALED]"
+
+## to_str method should not exist for security (implicit string conversion)
+@doc.content.to_str
+#=!> NoMethodError
+
+## JSON serialization - to_json
+@doc.content.to_json
+#=> "\"[CONCEALED]\""
+
+## JSON serialization - as_json
+@doc.content.as_json
+#=> "[CONCEALED]"
+
+## Hash conversion
+@doc.content.to_h
+#=> "[CONCEALED]"
+
+## Array conversion
+@doc.content.to_a
+#=> ["[CONCEALED]"]
+
+## String concatenation safety
+(@doc.content + " extra")
+#=> "[CONCEALED]"
+
+## Length operation
+@doc.content.length
+#=> 11
+
+## Empty check
+@doc.content.empty?
+#=> false
+
+## Present check
+@doc.content.present?
+#=> true
+
+## Equality operations - different objects not equal
+@content1 = @doc.content
+@content2 = @doc.api_key
+(@content1 == @content2)
+#=> false
+
+## Same object equality
+(@content1 == @content1)
+#=> true
+
+## Hash consistency for timing attack prevention
+(@content1.hash == @content2.hash)
+#=> true
+
+## Pattern matching - deconstruct
+@doc.content.deconstruct
+#=> ["[CONCEALED]"]
+
+## Pattern matching - deconstruct_keys
+@doc.content.deconstruct_keys([])
+#=:> Hash
+
+## Enumeration safety
+@doc.content.map { |x| x.upcase }
+#=> ["[CONCEALED]"]
+
+## Encrypted data access for storage
+@encrypted_data = @doc.content.encrypted_value
+@encrypted_data
+#=:> String
+
+## Encrypted data is valid JSON
+begin
+  parsed = JSON.parse(@encrypted_data)
+  parsed.key?('algorithm')
+rescue
+  false
+end
+#=> true
+
+## Memory clearing functionality
+# Create a separate document for clearing tests to avoid affecting other tests
+@clear_doc = SecretDocument.new
+@clear_doc.id = "clear_test"
+@clear_doc.content = "data to be cleared"
+@test_concealed = @clear_doc.content
+@test_concealed.cleared?
+#=> false
+
+## Clear operation
+@test_concealed.clear!
+@test_concealed.cleared?
+#=> true
+
+## After clearing, reveal raises error
+begin
+  @test_concealed.reveal { |x| x }
+rescue SecurityError => e
+  e.message
+end
+#=> "Encrypted data already cleared"
+
+## String interpolation safety
+interpolated = "Content: #{@doc.content}"
+interpolated
+#=> "Content: [CONCEALED]"
+
+## Array inclusion safety
+debug_array = [@doc.title, @doc.content, @doc.api_key]
+debug_array.map(&:to_s)
+#=> ["Public Title", "[CONCEALED]", "[CONCEALED]"]
+
+## Database persistence - debug serialization
+@storage_hash = @doc.to_h_for_storage
+@storage_hash.keys
+#=> ["id", "title", "content", "api_key"]
+
+@save_result1 = @doc.save
+@save_result1
+#=> true
+
+## After saving, re-encrypt with proper AAD context
+@doc.content = "secret information"  # Re-encrypt now that record exists
+@save_result2 = @doc.save
+@save_result2
+#=> true
+
+## After saving, behavior is identical
+@doc.content.to_s
+#=> "[CONCEALED]"
+
+## Post-save reveal works
+@doc.content.reveal { |x| x }
+#=> "secret information"
+
+## Fresh load from database
+@fresh_doc = SecretDocument.load("test123")
+@fresh_doc&.content&.class&.name || "nil or missing"
+#=> "ConcealedString"
+
+## Debug what's actually in the database
+@all_keys = Familia.dbclient.keys("*")
+@all_keys
+#=> ["secretdocument:test123:object"]
+
+@db_hash = Familia.dbclient.hgetall("secretdocument:test123:object")
+@db_hash.keys
+#=> ["id", "title", "content", "api_key"]
+
+db_content = Familia.dbclient.hget("secretdocument:test123:object", "content")
+db_content&.class&.name || "nil"
+#=> "String"
+
+## Fresh load reveal works (if content exists)
+if @fresh_doc&.content.respond_to?(:reveal)
+  begin
+    @fresh_doc.content.reveal { |x| x }
+  rescue => e
+    "DECRYPTION ERROR: #{e.class}: #{e.message}"
+  end
+else
+  "content is nil or missing"
+end
+#=> "secret information"
+
+## Regular fields unaffected
+@doc.title
+#=:> String
+
+## Regular field access
+@doc.title
+#=> "Public Title"
+
+## Mixed field operations
+(@doc.title + " has concealed content")
+#=> "Public Title has concealed content"
+
+# Teardown
+Familia.dbclient.flushdb

data/try/features/encryption_fields/context_isolation_try.rb

@@ -0,0 +1,141 @@
+# try/features/encryption_fields/context_isolation_try.rb
+
+require 'base64'
+
+require_relative '../../helpers/test_helpers'
+
+# Setup encryption keys for testing
+test_keys = {
+  v1: Base64.strict_encode64('a' * 32),
+  v2: Base64.strict_encode64('b' * 32)
+}
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+class IsolationUser < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :user_id
+  field :user_id
+  encrypted_field :secret
+end
+
+# Different models with same field name have isolated contexts
+class ModelA < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :api_key
+end
+
+class ModelB < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :api_key
+end
+
+## Different user IDs produce different ciphertexts for same plaintext
+@user1 = IsolationUser.new(user_id: 'alice')
+@user2 = IsolationUser.new(user_id: 'bob')
+
+@user1.secret = 'shared-secret'
+@user2.secret = 'shared-secret'
+
+@cipher1 = @user1.instance_variable_get(:@secret)
+@cipher2 = @user2.instance_variable_get(:@secret)
+
+@cipher1 != @cipher2
+#=> true
+
+## Same plaintext decrypts correctly for both users - access via refinement
+@user1_decrypted = nil
+module User1TestAccess
+  using ConcealedStringTestHelper
+  user1 = IsolationUser.new(user_id: 'alice')
+  user1.secret = 'shared-secret'
+  user1.secret.reveal_for_testing
+end
+#=> 'shared-secret'
+
+@user2_decrypted = nil
+module User2TestAccess
+  using ConcealedStringTestHelper
+  user2 = IsolationUser.new(user_id: 'bob')
+  user2.secret = 'shared-secret'
+  user2.secret.reveal_for_testing
+end
+#=> 'shared-secret'
+
+## Different model classes have isolated encryption contexts
+@model_a = ModelA.new(id: 'same-id')
+@model_b = ModelB.new(id: 'same-id')
+
+@model_a.api_key = 'secret-key'
+@model_b.api_key = 'secret-key'
+
+@cipher_a = @model_a.instance_variable_get(:@api_key)
+@cipher_b = @model_b.instance_variable_get(:@api_key)
+
+@cipher_a != @cipher_b
+#=> true
+
+## Model A can decrypt its own data - access via refinement
+module ModelATestAccess
+  using ConcealedStringTestHelper
+  model_a = ModelA.new(id: 'same-id')
+  model_a.api_key = 'secret-key'
+  model_a.api_key.reveal_for_testing
+end
+#=> 'secret-key'
+
+## Model B can decrypt its own data - access via refinement
+module ModelBTestAccess
+  using ConcealedStringTestHelper
+  model_b = ModelB.new(id: 'same-id')
+  model_b.api_key = 'secret-key'
+  model_b.api_key.reveal_for_testing
+end
+#=> 'secret-key'
+
+## Cross-model decryption fails due to context mismatch
+@model_a.instance_variable_set(:@api_key, @cipher_b)
+begin
+  @model_a.api_key
+  false
+rescue Familia::EncryptionError
+  true
+end
+#=> true
+
+## Different field names in same model create different contexts
+class MultiFieldModel < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :field_one
+  encrypted_field :field_two
+end
+
+@multi = MultiFieldModel.new(id: 'test')
+@multi.field_one = 'same-value'
+@multi.field_two = 'same-value'
+
+@cipher_field1 = @multi.instance_variable_get(:@field_one)
+@cipher_field2 = @multi.instance_variable_get(:@field_two)
+
+@cipher_field1 != @cipher_field2
+#=> true
+
+## Cross-field decryption fails due to field context isolation
+@multi.instance_variable_set(:@field_one, @cipher_field2)
+begin
+  @multi.field_one
+  false
+rescue Familia::EncryptionError
+  true
+end
+#=> true
+
+# Cleanup
+Familia.config.encryption_keys = nil
+Familia.config.current_key_version = nil

data/try/features/encryption_fields/error_conditions_try.rb

@@ -0,0 +1,116 @@
+# try/features/encryption_fields/error_conditions_try.rb
+
+require 'base64'
+
+require_relative '../../helpers/test_helpers'
+
+# Setup encryption keys for error testing
+@test_keys = {
+  v1: Base64.strict_encode64('a' * 32),
+  v2: Base64.strict_encode64('b' * 32)
+}
+Familia.config.encryption_keys = @test_keys
+Familia.config.current_key_version = :v1
+
+class ErrorTest < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :id
+  field :id
+  encrypted_field :secret
+end
+
+## Malformed JSON raises appropriate error
+@model = ErrorTest.new(id: 'err-1')
+@model.instance_variable_set(:@secret, 'not-json{]')
+@model.secret
+#=!> Familia::EncryptionError
+#==> error.message.include?('Invalid JSON structure')
+
+## Tampered auth tag fails decryption
+@model.secret = 'valid-secret'
+@valid_cipher = @model.secret.encrypted_value
+@tampered = JSON.parse(@valid_cipher)
+@tampered['auth_tag'] = Base64.strict_encode64('tampered' * 4)
+@model.instance_variable_set(:@secret, @tampered.to_json)
+
+@model.secret
+#=!> Familia::EncryptionError
+#==> error.message.include?('Invalid auth_tag size')
+
+## Missing encryption config raises on validation
+@original_keys = Familia.config.encryption_keys
+Familia.config.encryption_keys = nil
+Familia::Encryption.validate_configuration!
+Familia.config.encryption_keys = @original_keys
+#=!> Familia::EncryptionError
+#==> error.message.include?('No encryption keys configured')
+
+## Invalid Base64 in stored data causes decryption failure
+# Reset keys for this test since they were cleared in previous test
+Familia.config.encryption_keys = @test_keys
+@model.instance_variable_set(:@secret, '{"algorithm":"aes-256-gcm","nonce":"!!!invalid!!!","ciphertext":"test","auth_tag":"test","key_version":"v1"}')
+@model.secret
+#=!> Familia::EncryptionError
+#==> error.message.include?('Invalid Base64 encoding')
+
+## Derivation counter still increments on decryption errors
+Familia::Encryption.reset_derivation_count!
+# Ensure keys are available for this test
+Familia.config.encryption_keys = @test_keys
+@error_model = ErrorTest.new(id: 'err-counter')
+# Set valid JSON but with invalid base64 data to trigger decrypt failure after parsing
+@error_model.instance_variable_set(:@secret, '{"algorithm":"aes-256-gcm","nonce":"dGVzdA==","ciphertext":"invalid-base64!!!","auth_tag":"dGVzdA==","key_version":"v1"}')
+begin
+  @error_model.secret
+rescue
+end
+# Derivation attempted even if decrypt fails
+Familia::Encryption.derivation_count.value
+#=> 1
+
+## Unsupported algorithm in encrypted data
+# Ensure keys are available for this test
+Familia.config.encryption_keys = @test_keys
+@model.secret = 'test-data'
+@cipher_data = JSON.parse(@model.secret.encrypted_value)
+@cipher_data['algorithm'] = 'unsupported-algorithm'
+@model.instance_variable_set(:@secret, @cipher_data.to_json)
+
+@model.secret
+#=!> Familia::EncryptionError
+#==> error.message.include?('Unsupported algorithm')
+
+## Missing current key version causes validation error
+@original_version = Familia.config.current_key_version
+Familia.config.current_key_version = nil
+Familia::Encryption.validate_configuration!
+Familia.config.current_key_version = @original_version
+#=!> Familia::EncryptionError
+#==> error.message.include?('No current key version set')
+
+## Invalid key version in encrypted data
+# Ensure keys are available for this test
+Familia.config.encryption_keys = @test_keys
+Familia.config.current_key_version = :v1
+@model.secret = 'test-data'
+@cipher_with_bad_version = JSON.parse(@model.secret.encrypted_value)
+@cipher_with_bad_version['key_version'] = 'nonexistent'
+@model.instance_variable_set(:@secret, @cipher_with_bad_version.to_json)
+@model.secret
+#=!> Familia::EncryptionError
+#==> error.message.include?('No key for version: nonexistent')
+
+## Empty string and nil values don't trigger encryption errors
+@empty_model = ErrorTest.new(id: 'empty-test')
+@empty_model.secret = ''
+@empty_model.secret
+#=> nil
+
+## Nil assignment and retrieval
+@empty_model.secret = nil
+@empty_model.secret
+#=> nil
+
+# Cleanup
+Familia.config.encryption_keys = nil
+Familia.config.current_key_version = nil