pq_crypto-seal 0.1.0

data/test/seal_test.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+require_relative "test_helper"
+
+class SealTest < Minitest::Test
+  def setup
+    @alice = PQCrypto::HybridKEM.generate(PQCrypto::Seal::WRAP_KEM_ALGORITHM)
+    @bob = PQCrypto::HybridKEM.generate(PQCrypto::Seal::WRAP_KEM_ALGORITHM)
+  end
+
+  def test_multi_recipient_round_trip_and_padding
+    data = ("image" * 10_000).b
+    envelope = PQCrypto::Seal.encrypt(
+      data, to: [@alice.public_key, @bob.public_key],
+      metadata: "private", public_metadata: "public"
+    )
+    alice = PQCrypto::Seal.open(envelope, with: @alice)
+    bob = PQCrypto::Seal.open(envelope, with: @bob)
+    assert_equal data, alice.data
+    assert_equal data, bob.data
+    assert_equal "private", alice.metadata
+    assert_equal "public", alice.public_metadata
+    assert_equal PQCrypto::Seal::Format::PADDING_PADME, alice.padding_policy_id
+    assert_operator envelope.bytesize, :>=, data.bytesize
+  end
+
+  def test_wrong_recipient_and_tampering_fail
+    envelope = PQCrypto::Seal.encrypt("secret", to: @alice.public_key)
+    stranger = PQCrypto::HybridKEM.generate(PQCrypto::Seal::WRAP_KEM_ALGORITHM)
+    assert_raises(PQCrypto::Seal::RecipientNotFoundError) do
+      PQCrypto::Seal.decrypt(envelope, with: stranger)
+    end
+    broken = envelope.dup
+    broken.setbyte(broken.bytesize - 1, broken.getbyte(-1) ^ 1)
+    assert_raises(PQCrypto::Seal::AuthenticationError) do
+      PQCrypto::Seal.decrypt(broken, with: @alice)
+    end
+  end
+
+  def test_rebuild_recipients_preserves_payload
+    envelope = PQCrypto::Seal.encrypt("document", to: @alice.public_key)
+    rebuilt = PQCrypto::Seal.rebuild_recipients(
+      envelope, with: @alice,
+      recipients: [@alice.public_key, @bob.public_key]
+    )
+    assert_equal "document", PQCrypto::Seal.decrypt(rebuilt, with: @bob)
+    assert_raises(PQCrypto::Seal::RecipientNotFoundError) do
+      PQCrypto::Seal.decrypt(envelope, with: @bob)
+    end
+  end
+
+  def test_rebuild_randomizes_entire_recipient_section
+    envelope = PQCrypto::Seal.encrypt("document", to: @alice.public_key)
+    rebuilt = PQCrypto::Seal.rebuild_recipients(
+      envelope, with: @alice, recipients: [@alice.public_key]
+    )
+    original_info = PQCrypto::Seal.inspect_envelope(envelope)
+    rebuilt_info = PQCrypto::Seal.inspect_envelope(rebuilt)
+    assert_equal original_info.payload_id, rebuilt_info.payload_id
+    refute_equal envelope, rebuilt
+    assert_equal "document", PQCrypto::Seal.decrypt(rebuilt, with: @alice)
+  end
+
+  def test_padme_and_none_policy_ids
+    data = "x" * 12_345
+    metadata = "m" * 19
+    envelope = PQCrypto::Seal.encrypt(data, to: @alice.public_key, metadata: metadata, padding: :padme)
+    info = PQCrypto::Seal.inspect_envelope(envelope)
+    assert_equal PQCrypto::Seal::Format::PADDING_PADME, info.padding_policy_id
+    assert_equal data, PQCrypto::Seal.decrypt(envelope, with: @alice)
+
+    none_env = PQCrypto::Seal.encrypt("hi", to: @alice.public_key, padding: :none)
+    assert_equal PQCrypto::Seal::Format::PADDING_NONE,
+                 PQCrypto::Seal.inspect_envelope(none_env).padding_policy_id
+    assert_equal "hi", PQCrypto::Seal.decrypt(none_env, with: @alice)
+  end
+
+  def test_truncation_trailing_bytes_and_payload_tamper_fail
+    envelope = PQCrypto::Seal.encrypt("secret" * 100, to: @alice.public_key)
+    assert_raises(PQCrypto::Seal::FormatError) do
+      PQCrypto::Seal.decrypt(envelope.byteslice(0, envelope.bytesize - 1), with: @alice)
+    end
+    assert_raises(PQCrypto::Seal::FormatError) do
+      PQCrypto::Seal.decrypt(envelope + "x", with: @alice)
+    end
+
+    info = PQCrypto::Seal.inspect_envelope(envelope)
+    payload_offset = info.envelope_bytes - info.padded_inner_length - PQCrypto::Seal::Format::TAG_BYTES
+    broken = envelope.dup
+    broken.setbyte(payload_offset, broken.getbyte(payload_offset) ^ 1)
+    assert_raises(PQCrypto::Seal::AuthenticationError) do
+      PQCrypto::Seal.decrypt(broken, with: @alice)
+    end
+  end
+
+  def test_separately_loaded_credentials_and_duplicate_rejection
+    credentials = PQCrypto::Seal.credentials(
+      secret_key: @alice.secret_key, public_key: @alice.public_key
+    )
+    envelope = PQCrypto::Seal.encrypt("x", to: @alice.public_key)
+    assert_equal "x", PQCrypto::Seal.decrypt(envelope, with: credentials)
+    assert_raises(PQCrypto::Seal::InvalidConfigurationError) do
+      PQCrypto::Seal.encrypt("x", to: [@alice.public_key, @alice.public_key])
+    end
+  end
+
+  def test_rotate_dek_preserves_envelope_size_by_default
+    envelope = PQCrypto::Seal.encrypt(
+      "document" * 500, to: @alice.public_key, padding: { to: 20_000 }
+    )
+    rotated = PQCrypto::Seal.rotate_dek(
+      envelope, with: @alice, recipients: [@alice.public_key, @bob.public_key]
+    )
+    assert_equal envelope.bytesize, rotated.bytesize
+    assert_equal "document" * 500, PQCrypto::Seal.decrypt(rotated, with: @bob)
+    assert_equal PQCrypto::Seal::Format::PADDING_FIXED,
+                 PQCrypto::Seal.inspect_envelope(rotated).padding_policy_id
+  end
+
+  def test_capacity_is_fixed_policy
+    assert_raises(PQCrypto::Seal::RecipientCapacityExceeded) do
+      keys = 5.times.map { PQCrypto::HybridKEM.generate(PQCrypto::Seal::WRAP_KEM_ALGORITHM).public_key }
+      PQCrypto::Seal.encrypt("x", to: keys, recipient_capacity: 4)
+    end
+  end
+
+  def test_internals_are_not_public
+    refute PQCrypto::Seal.respond_to?(:unwrap_dek)
+    refute PQCrypto::Seal.respond_to?(:derive_kek)
+    refute PQCrypto::Seal.respond_to?(:build_slot)
+    refute PQCrypto::Seal.respond_to?(:parse_envelope)
+    refute PQCrypto::Seal.respond_to?(:wipe_string!)
+    assert PQCrypto::Seal.respond_to?(:encrypt)
+    assert PQCrypto::Seal.respond_to?(:decrypt)
+    assert PQCrypto::Seal.respond_to?(:open)
+    assert PQCrypto::Seal.respond_to?(:digest)
+  end
+
+  def test_resource_limit_rejects_huge_declared_inner
+    envelope = PQCrypto::Seal.encrypt("tiny", to: @alice.public_key, padding: :none)
+    assert_raises(PQCrypto::Seal::ResourceLimitError) do
+      PQCrypto::Seal.decrypt(envelope, with: @alice, max_staging_bytes: 8)
+    end
+  end
+
+  def test_malformed_capacity_is_format_error
+    envelope = PQCrypto::Seal.encrypt("x", to: @alice.public_key, padding: :none)
+    # capacity sits after magic(8)+ver(1)+hdrlen(4)+suite(2)+lookup(1)+flags(2)+pad_policy(1)+pid(32)+nonce(32)
+    offset = 8 + 1 + 4 + 2 + 1 + 2 + 1 + 32 + 32
+    broken = envelope.dup
+    broken.setbyte(offset, 0xff)
+    broken.setbyte(offset + 1, 0xff)
+    assert_raises(PQCrypto::Seal::FormatError) do
+      PQCrypto::Seal.decrypt(broken, with: @alice)
+    end
+  end
+
+  def test_array_credentials_form
+    envelope = PQCrypto::Seal.encrypt("array-cred", to: @alice.public_key, padding: :none)
+    assert_equal "array-cred",
+                 PQCrypto::Seal.decrypt(envelope, with: [@alice.secret_key, @alice.public_key])
+  end
+
+  def test_fixed_and_bucket_padding_policies
+    fixed = PQCrypto::Seal.encrypt("x", to: @alice.public_key, padding: { to: 12_000 })
+    assert_equal 12_000, fixed.bytesize
+    assert_equal PQCrypto::Seal::Format::PADDING_FIXED,
+                 PQCrypto::Seal.inspect_envelope(fixed).padding_policy_id
+    assert_equal "x", PQCrypto::Seal.decrypt(fixed, with: @alice)
+
+    bucketed = PQCrypto::Seal.encrypt("y", to: @alice.public_key, padding: { buckets: [8_000, 16_000, 32_000] })
+    assert_includes [8_000, 16_000, 32_000], bucketed.bytesize
+    assert_equal PQCrypto::Seal::Format::PADDING_BUCKETS,
+                 PQCrypto::Seal.inspect_envelope(bucketed).padding_policy_id
+    assert_equal "y", PQCrypto::Seal.decrypt(bucketed, with: @alice)
+  end
+
+  def test_digest_changes_on_recipient_rebuild
+    envelope = PQCrypto::Seal.encrypt("stable-payload", to: @alice.public_key, padding: :none)
+    d1 = PQCrypto::Seal.digest(envelope)
+    rebuilt = PQCrypto::Seal.rebuild_recipients(
+      envelope, with: @alice, recipients: [@alice.public_key, @bob.public_key]
+    )
+    d2 = PQCrypto::Seal.digest(rebuilt)
+    refute_equal d1, d2
+    assert_equal PQCrypto::Seal.open(envelope, with: @alice).payload_id,
+                 PQCrypto::Seal.open(rebuilt, with: @alice).payload_id
+  end
+
+  def test_wrap_kem_algorithm_is_pinned
+    assert_equal :ml_kem_768_x25519_xwing, PQCrypto::Seal::WRAP_KEM_ALGORITHM
+    assert_equal 1216, PQCrypto::Seal::Format::XWING_PUBLIC_KEY_BYTES
+    assert_equal 1120, PQCrypto::Seal::Format::XWING_CIPHERTEXT_BYTES
+    assert_equal 32, PQCrypto::Seal::Format::XWING_SHARED_SECRET_BYTES
+    refute PQCrypto::Seal::Format.const_defined?(:XWING_SECRET_KEY_BYTES)
+  end
+
+  def test_index_binding_prevents_naive_slot_duplication
+    # wrap_ad / derive_kek bind slot_index, so byte-copying a real slot into
+    # another index cannot open a second time for the same recipient.
+    envelope = PQCrypto::Seal.encrypt(
+      "ambig", to: @alice.public_key, recipient_capacity: 2, slot_size: 2048, padding: :none
+    )
+    header = PQCrypto::Seal::Format.parse_header(envelope)
+    section_offset = header.raw.bytesize
+    slots_offset = section_offset + 2 + PQCrypto::Seal::Format::SECTION_ID_BYTES
+    slot0 = envelope.byteslice(slots_offset, header.slot_size)
+    broken = envelope.dup
+    broken[slots_offset + header.slot_size, header.slot_size] = slot0
+    assert_equal "ambig", PQCrypto::Seal.decrypt(broken, with: @alice)
+  end
+
+  def test_two_valid_stanzas_for_same_recipient_are_ambiguous
+    # Defense-in-depth: a crafted envelope with two correctly-built slots for
+    # the same public key (different indices) must not pick an arbitrary DEK.
+    envelope = PQCrypto::Seal.encrypt(
+      "ambig", to: @alice.public_key, recipient_capacity: 2, slot_size: 2048, padding: :none
+    )
+    header, section, ciphertext, tag = PQCrypto::Seal.send(:parse_envelope, envelope)
+    dek = PQCrypto::Seal.send(:unwrap_dek, header, section, @alice)
+    crafted_section = PQCrypto::Seal.send(
+      :build_recipient_section,
+      recipients: [@alice.public_key, @alice.public_key],
+      capacity: 2,
+      slot_size: header.slot_size,
+      payload_id: header.payload_id,
+      header_hash: PQCrypto::Seal.const_get(:Native).sha256(header.raw),
+      dek: dek,
+      wrap_suite_id: PQCrypto::Seal::Format::WRAP_SUITE_MLKEM768_X25519_AEGIS256
+    )
+    crafted = header.raw + crafted_section + ciphertext + tag
+    assert_raises(PQCrypto::Seal::AmbiguousRecipientStanzas) do
+      PQCrypto::Seal.decrypt(crafted, with: @alice)
+    end
+  ensure
+    PQCrypto::Seal.send(:wipe_string!, dek) if defined?(dek)
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "tmpdir"
+require "stringio"
+require "pq_crypto/seal"

metadata

@@ -0,0 +1,244 @@
+--- !ruby/object:Gem::Specification
+name: pq_crypto-seal
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Roman Khaidarov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pq_crypto
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.14'
+- !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: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: Versioned multi-recipient document encryption using PQCrypto hybrid KEM,
+  HKDF-SHA256, and vendored AEGIS-256.
+email:
+- roman-haidarov@users.noreply.github.com
+executables: []
+extensions:
+- ext/pq_crypto_seal/extconf.rb
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- CHANGELOG.md
+- FORMAT.md
+- GET_STARTED.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- RELEASING.md
+- Rakefile
+- SECURITY.md
+- VENDORING.md
+- ext/pq_crypto_seal/aegis_unused_stubs.c
+- ext/pq_crypto_seal/extconf.rb
+- ext/pq_crypto_seal/pq_crypto_seal.c
+- ext/pq_crypto_seal/vendor/libaegis/LICENSE
+- ext/pq_crypto_seal/vendor/libaegis/TREE_SHA256
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/aegis128l.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/aegis128l_aesni.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/aegis128l_aesni.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/aegis128l_altivec.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/aegis128l_altivec.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/aegis128l_common.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/aegis128l_neon_aes.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/aegis128l_neon_aes.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/aegis128l_neon_sha3.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/aegis128l_neon_sha3.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/aegis128l_soft.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/aegis128l_soft.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128l/implementations.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/aegis128x2.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/aegis128x2_aesni.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/aegis128x2_aesni.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/aegis128x2_altivec.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/aegis128x2_altivec.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/aegis128x2_avx2.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/aegis128x2_avx2.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/aegis128x2_common.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/aegis128x2_neon_aes.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/aegis128x2_neon_aes.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/aegis128x2_soft.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/aegis128x2_soft.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x2/implementations.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_aesni.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_aesni.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_altivec.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_altivec.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_avx2.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_avx2.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_avx512.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_avx512.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_common.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_neon_aes.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_neon_aes.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_soft.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/aegis128x4_soft.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis128x4/implementations.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256_aesni.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256_aesni.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256_altivec.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256_altivec.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256_common.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256_neon_aes.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256_neon_aes.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256_soft.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256/aegis256_soft.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256/implementations.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/aegis256x2.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/aegis256x2_aesni.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/aegis256x2_aesni.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/aegis256x2_altivec.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/aegis256x2_altivec.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/aegis256x2_avx2.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/aegis256x2_avx2.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/aegis256x2_common.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/aegis256x2_neon_aes.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/aegis256x2_neon_aes.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/aegis256x2_soft.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/aegis256x2_soft.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x2/implementations.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_aesni.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_aesni.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_altivec.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_altivec.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_avx2.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_avx2.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_avx512.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_avx512.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_common.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_neon_aes.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_neon_aes.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_soft.c
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/aegis256x4_soft.h
+- ext/pq_crypto_seal/vendor/libaegis/src/aegis256x4/implementations.h
+- ext/pq_crypto_seal/vendor/libaegis/src/common/common.c
+- ext/pq_crypto_seal/vendor/libaegis/src/common/common.h
+- ext/pq_crypto_seal/vendor/libaegis/src/common/cpu.c
+- ext/pq_crypto_seal/vendor/libaegis/src/common/cpu.h
+- ext/pq_crypto_seal/vendor/libaegis/src/common/keccak.c
+- ext/pq_crypto_seal/vendor/libaegis/src/common/keccak.h
+- ext/pq_crypto_seal/vendor/libaegis/src/common/softaes.c
+- ext/pq_crypto_seal/vendor/libaegis/src/common/softaes.h
+- ext/pq_crypto_seal/vendor/libaegis/src/include/aegis.h
+- ext/pq_crypto_seal/vendor/libaegis/src/include/aegis128l.h
+- ext/pq_crypto_seal/vendor/libaegis/src/include/aegis128x2.h
+- ext/pq_crypto_seal/vendor/libaegis/src/include/aegis128x4.h
+- ext/pq_crypto_seal/vendor/libaegis/src/include/aegis256.h
+- ext/pq_crypto_seal/vendor/libaegis/src/include/aegis256x2.h
+- ext/pq_crypto_seal/vendor/libaegis/src/include/aegis256x4.h
+- ext/pq_crypto_seal/vendor/libaegis/src/include/aegis_raf.h
+- ext/pq_crypto_seal/vendor/libaegis/src/raf/raf.c
+- ext/pq_crypto_seal/vendor/libaegis/src/raf/raf_aegis128l.c
+- ext/pq_crypto_seal/vendor/libaegis/src/raf/raf_aegis128x2.c
+- ext/pq_crypto_seal/vendor/libaegis/src/raf/raf_aegis128x4.c
+- ext/pq_crypto_seal/vendor/libaegis/src/raf/raf_aegis256.c
+- ext/pq_crypto_seal/vendor/libaegis/src/raf/raf_aegis256x2.c
+- ext/pq_crypto_seal/vendor/libaegis/src/raf/raf_aegis256x4.c
+- ext/pq_crypto_seal/vendor/libaegis/src/raf/raf_internal.h
+- ext/pq_crypto_seal/vendor/libaegis/src/raf/raf_merkle.c
+- ext/pq_crypto_seal/vendor/libaegis/src/raf/raf_merkle.h
+- ext/pq_crypto_seal/vendor/libaegis/src/raf/raf_variant.h
+- fuzz/decrypt_fuzz.rb
+- lib/pq_crypto/seal.rb
+- lib/pq_crypto/seal/binary.rb
+- lib/pq_crypto/seal/core.rb
+- lib/pq_crypto/seal/errors.rb
+- lib/pq_crypto/seal/format.rb
+- lib/pq_crypto/seal/io.rb
+- lib/pq_crypto/seal/native.rb
+- lib/pq_crypto/seal/padding.rb
+- lib/pq_crypto/seal/version.rb
+- pq_crypto-seal.gemspec
+- script/vendor_libs.rb
+- test/aegis_vectors_test.rb
+- test/golden_vectors_test.rb
+- test/io_test.rb
+- test/native_test.rb
+- test/seal_test.rb
+- test/test_helper.rb
+homepage: https://github.com/roman-haidarov/pq_crypto-seal
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/roman-haidarov/pq_crypto-seal
+  changelog_uri: https://github.com/roman-haidarov/pq_crypto-seal/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.22
+signing_key:
+specification_version: 4
+summary: Post-quantum envelope encryption for Ruby
+test_files: []