kpqc 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62b5c05c4a099ed480898de92399ea5bc5afcdcd15aef2192773187bf51cb779
-  data.tar.gz: aa315f890bf4242423749e2e864b381f91145a6c5ab15d55e3e632495506e556
+  metadata.gz: 46c577c95e4c31c71f815b922990271f4352b3f84b84ff66b010598ec2421c55
+  data.tar.gz: e59071e5a75c838071b0d47c574194c49689f573857d35426855bca6f33f7a29
 SHA512:
-  metadata.gz: cabb4f39af2279d6a0b4f47496e66beb09d6676e041da9be5c1e0e3633c0d326952d7639fe9a1477e05975609dd785546a8d4e35d0bf69e034344f3c79efcdd5
-  data.tar.gz: 197e9fd75a10d840a9e53d1ed3f7eaac4941f0470df948ee7fd08443f8d9fc01073aaeb14062b0dd164ed8d77f06dabc553dccb99344e2af1d53d00e553676fb
+  metadata.gz: 6c68fe659266446fe1ce738d4b29370d49f72827c91d4f3efed1e8339905e53c253c752d44530a6542b471e57edd49bbc157e1e3c0fbfe4f6a5951c208924cfb
+  data.tar.gz: f606ae127792ab6b3826898d001a7e9db0fb109c62b3c5bdd6a7e17fd7d12c302983bbafcb80ea8f935e6e8a25f7df4756350ed4fc82f5970556b61d29299510

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.2.1
+
+- Standardized KEM terminology and pinned upstream source revisions.
+- Validated all supported parameter sets against the shared KAT repository.
+
 ## 0.2.0
 
 - Updated the bundled reference implementations.

data/README.md

@@ -1,6 +1,7 @@
 # KpqC
 
-KpqC provides synchronous Ruby APIs for AIMer, HAETAE, NTRU+, and SMAUG-T.
+KpqC provides synchronous Ruby APIs for the AIMer and HAETAE signature schemes
+and the NTRU+ and SMAUG-T key encapsulation mechanisms (KEMs).
 
 ## Runtime support
 
@@ -23,8 +24,8 @@ are not compatible with this version.
 | --- | --- | --- |
 | **AIMer** | Signature | `aimer128f`, `aimer128s`, `aimer192f`, `aimer192s`, `aimer256f`, `aimer256s` |
 | **HAETAE** | Signature | `haetae2`, `haetae3`, `haetae5` |
-| **NTRU+** | Key encapsulation | `ntruplus768`, `ntruplus864`, `ntruplus1152` |
-| **SMAUG‑T** | Key encapsulation | `smaugt128`, `smaugt192`, `smaugt256`, `timer` |
+| **NTRU+** | KEM | `ntruplus768`, `ntruplus864`, `ntruplus1152` |
+| **SMAUG‑T** | KEM | `smaugt128`, `smaugt192`, `smaugt256`, `timer` |
 
 Requiring an algorithm family keeps the entry point focused:
 
@@ -68,7 +69,7 @@ puts valid # true
 Verification fails when the supplied context does not match the one used for
 signing.
 
-### Key encapsulation
+### KEM
 
 A KEM creates a shared secret for a sender and a recipient. The public key may
 be distributed; the secret key and resulting shared secret must remain private.
@@ -102,8 +103,8 @@ require "kpqc/smaugt"
 
 signer = KpqC::Aimer.aimer256s
 another_signer = KpqC::Haetae.haetae5
-key_exchange = KpqC::NtruPlus.ntruplus1152
-another_key_exchange = KpqC::SmaugT.timer
+kem = KpqC::NtruPlus.ntruplus1152
+another_kem = KpqC::SmaugT.timer
 ```
 
 All named algorithms are also available from the package root:
@@ -112,7 +113,7 @@ All named algorithms are also available from the package root:
 require "kpqc"
 
 signer = KpqC.aimer192f
-key_exchange = KpqC.ntruplus864
+kem = KpqC.ntruplus864
 ```
 
 ## Data and failures
@@ -138,7 +139,7 @@ All sizes are in bytes.
 | `haetae3` | 1,472 | 2,112 | 2,349 |
 | `haetae5` | 2,080 | 2,752 | 2,948 |
 
-#### Key encapsulation
+#### KEM
 
 | Algorithm | Public key | Secret key | Ciphertext | Shared secret |
 | --- | ---: | ---: | ---: | ---: |
@@ -155,6 +156,17 @@ Methods reject values of the wrong type or size. Signature verification returns
 SMAUG-T performs implicit rejection and returns a replacement secret instead;
 that value will not equal the sender's shared secret.
 
+## Known-answer tests
+
+The test suite validates all 1,600 KAT records in
+[KpqC/kpqc-test-vectors at commit d75490bf824f](https://github.com/KpqC/kpqc-test-vectors/tree/d75490bf824faa4b148cd0b901a2eb13198fe0da).
+With `kpqc-test-vectors` checked out beside `kpqc-ruby`, run:
+
+```sh
+KPQC_TEST_VECTORS=../kpqc-test-vectors \
+  bundle exec rake test TEST=test/kat_test.rb
+```
+
 ## Distribution
 
 The published gem includes Ruby modules, native extension sources, and the

data/THIRD_PARTY_NOTICES.md

@@ -3,10 +3,10 @@
 This package includes code from the following upstream reference
 implementations:
 
-- [AIMer](https://github.com/samsungsds-opensource/AIMer/tree/5f786ccd572d7bc2f92cf9f662e2c6cab2c45fa2), Copyright (c) 2022–2026 SAMSUNG SDS
-- [HAETAE](https://github.com/CryptoLabInc/HAETAE/tree/3130c9e26670a3406af31e2aa73ef73b223acf49), Copyright (c) 2026 Team HAETAE
-- [NTRU+](https://github.com/ntruplus/ntruplus/tree/9b607231246fc2eb8b93634ff4bb94ecf1f62c75), Copyright (c) 2024–2026 NTRU+ TEAM
-- [SMAUG-T](https://github.com/CryptoLabInc/SMAUG-T/tree/3cd19f3c8531a95c06010846a832b0e8ece4f939), Copyright (c) 2026 Team SMAUG-T
+- [AIMer](https://github.com/samsungsds-opensource/AIMer/tree/734cc76fa4695ca8c8eaa070508db8ff62205e68), Copyright (c) 2022–2026 SAMSUNG SDS
+- [HAETAE](https://github.com/CryptoLabInc/HAETAE/tree/743c31df48183fc8c8a39a4f50a634da1c4af03a), Copyright (c) 2026 Team HAETAE
+- [NTRU+](https://github.com/ntruplus/ntruplus/tree/3991b2ae08d6f0008d37e41b8aceaaab27b4ec89), Copyright (c) 2024–2026 NTRU+ TEAM
+- [SMAUG-T](https://github.com/CryptoLabInc/SMAUG-T/tree/bbc463cd788eae36c6d155cef667ac9dbd9054cd), Copyright (c) 2026 Team SMAUG-T
 
 These components are distributed under the MIT License. Their original license
 texts are included under `vendor/` and with the package.

data/kpqc.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary = "Ruby APIs for AIMer, HAETAE, NTRU+, and SMAUG-T."
   spec.description =
     "Synchronous Ruby bindings for the bundled AIMer and HAETAE signature " \
-    "schemes and NTRU+ and SMAUG-T key-encapsulation mechanisms."
+    "schemes and NTRU+ and SMAUG-T key encapsulation mechanisms (KEMs)."
   spec.homepage = "https://github.com/KpqC/kpqc-ruby"
   spec.license = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")

data/lib/kpqc/api.rb

@@ -103,7 +103,7 @@ module KpqC
 
   end
 
-  # A key-encapsulation algorithm and parameter set.
+  # A KEM algorithm and parameter set.
   class KeyEncapsulationAlgorithm
     include AlgorithmSupport
 

data/lib/kpqc/ntruplus.rb

@@ -3,7 +3,7 @@
 require_relative "api"
 
 module KpqC
-  # NTRU+ key-encapsulation parameter sets.
+  # NTRU+ KEM parameter sets.
   module NtruPlus
     NTRUPLUS768 = KeyEncapsulationAlgorithm.new(
       "NTRU+768", KemSizes.new(1_152, 2_336, 1_152, 32), "ntruplus768"

data/lib/kpqc/smaugt.rb

@@ -3,7 +3,7 @@
 require_relative "api"
 
 module KpqC
-  # SMAUG-T and TiMER key-encapsulation parameter sets.
+  # SMAUG-T and TiMER KEM parameter sets.
   module SmaugT
     SMAUGT128 = KeyEncapsulationAlgorithm.new(
       "SMAUG-T128", KemSizes.new(672, 832, 672, 32), "smaugt128"

data/lib/kpqc/types.rb

@@ -23,7 +23,7 @@ module KpqC
     alias to_s inspect
   end
 
-  # The result of a key-encapsulation operation.
+  # The result of a KEM operation.
   class EncapsulatedSecret
     attr_reader :ciphertext, :shared_secret
 
@@ -69,7 +69,7 @@ module KpqC
     end
   end
 
-  # Byte sizes for a key-encapsulation parameter set.
+  # Byte sizes for a KEM parameter set.
   class KemSizes
     attr_reader :public_key, :secret_key, :ciphertext, :shared_secret
 

data/lib/kpqc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KpqC
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/test/kat_test.rb

@@ -4,6 +4,25 @@ require_relative "test_helper"
 require_relative "kat_drbg"
 
 class KnownAnswerTest < Minitest::Test
+  VECTOR_PATHS = {
+    "aimer128f" => "aimer/128f",
+    "aimer128s" => "aimer/128s",
+    "aimer192f" => "aimer/192f",
+    "aimer192s" => "aimer/192s",
+    "aimer256f" => "aimer/256f",
+    "aimer256s" => "aimer/256s",
+    "haetae2" => "haetae/mode2",
+    "haetae3" => "haetae/mode3",
+    "haetae5" => "haetae/mode5",
+    "ntruplus768" => "ntruplus/768",
+    "ntruplus864" => "ntruplus/864",
+    "ntruplus1152" => "ntruplus/1152",
+    "smaugt128" => "smaugt/mode1",
+    "smaugt192" => "smaugt/mode3",
+    "smaugt256" => "smaugt/mode5",
+    "timer" => "smaugt/modet"
+  }.freeze
+
   def test_aes_256_primitive
     key = binary(
       "000102030405060708090a0b0c0d0e0f" \
@@ -15,69 +34,107 @@ class KnownAnswerTest < Minitest::Test
   end
 
   def test_signature_parameter_sets
+    total = 0
     SIGNATURE_ALGORITHMS.each do |algorithm|
-      vector = read_vector(native_name(algorithm))
-      native = algorithm.send(:native)
-      random = KatDrbg::CtrDrbg.new(binary(vector.fetch("seed")))
-      native.__set_randombytes(lambda { |length| random.random_bytes(length) })
-
-      keys = algorithm.generate_key_pair
-      assert_equal binary(vector.fetch("pk")), keys.public_key, algorithm.id
-      assert_equal binary(vector.fetch("sk")), keys.secret_key, algorithm.id
-
-      context = signature_context(algorithm, random)
-      message = binary(vector.fetch("msg"))
-      signature = algorithm.sign(message, keys.secret_key, context: context)
-      expected = if vector.key?("sig")
-                   binary(vector.fetch("sig"))
-                 else
-                   binary(vector.fetch("sm")).byteslice(message.bytesize..-1)
-                 end
-      assert_equal expected, signature, algorithm.id
-      assert algorithm.verify(
-        message, signature, keys.public_key, context: context
-      ), algorithm.id
-    ensure
-      native.__reset_randombytes if native
-      keys.clear! if keys
+      vectors = read_vectors(native_name(algorithm))
+      vectors.each do |vector|
+        keys = nil
+        native = algorithm.send(:native)
+        random = KatDrbg::CtrDrbg.new(binary(vector.fetch("seed")))
+        native.__set_randombytes(lambda { |length| random.random_bytes(length) })
+
+        begin
+          keys = algorithm.generate_key_pair
+          assert_equal binary(vector.fetch("pk")), keys.public_key, algorithm.id
+          assert_equal binary(vector.fetch("sk")), keys.secret_key, algorithm.id
+
+          context = signature_context(algorithm, random)
+          message = binary(vector.fetch("msg"))
+          signature = algorithm.sign(message, keys.secret_key, context: context)
+          expected = if vector.key?("sig")
+                       binary(vector.fetch("sig"))
+                     else
+                       binary(vector.fetch("sm")).byteslice(message.bytesize..-1)
+                     end
+          assert_equal expected, signature, algorithm.id
+          assert algorithm.verify(
+            message, signature, keys.public_key, context: context
+          ), algorithm.id
+        ensure
+          native.__reset_randombytes
+          keys.clear! if keys
+        end
+        total += 1
+      end
+      assert_equal expected_vector_count, vectors.length, algorithm.id
     end
+    assert_equal expected_vector_count * SIGNATURE_ALGORITHMS.length, total
   end
 
-  def test_key_encapsulation_parameter_sets
+  def test_kem_parameter_sets
+    total = 0
     KEM_ALGORITHMS.each do |algorithm|
-      vector = read_vector(native_name(algorithm))
-      native = algorithm.send(:native)
-      random = KatDrbg::CtrDrbg.new(binary(vector.fetch("seed")))
-      native.__set_randombytes(lambda { |length| random.random_bytes(length) })
-
-      keys = algorithm.generate_key_pair
-      assert_equal binary(vector.fetch("pk")), keys.public_key, algorithm.id
-      assert_equal binary(vector.fetch("sk")), keys.secret_key, algorithm.id
-
-      encapsulated = algorithm.encapsulate(keys.public_key)
-      assert_equal binary(vector.fetch("ct")), encapsulated.ciphertext,
-                   algorithm.id
-      assert_equal binary(vector.fetch("ss")), encapsulated.shared_secret,
-                   algorithm.id
-      assert_equal encapsulated.shared_secret,
-                   algorithm.decapsulate(
-                     encapsulated.ciphertext, keys.secret_key
-                   ), algorithm.id
-    ensure
-      native.__reset_randombytes if native
-      keys.clear! if keys
-      encapsulated.clear! if encapsulated
+      vectors = read_vectors(native_name(algorithm))
+      vectors.each do |vector|
+        keys = nil
+        encapsulated = nil
+        native = algorithm.send(:native)
+        random = KatDrbg::CtrDrbg.new(binary(vector.fetch("seed")))
+        native.__set_randombytes(lambda { |length| random.random_bytes(length) })
+
+        begin
+          keys = algorithm.generate_key_pair
+          assert_equal binary(vector.fetch("pk")), keys.public_key, algorithm.id
+          assert_equal binary(vector.fetch("sk")), keys.secret_key, algorithm.id
+
+          encapsulated = algorithm.encapsulate(keys.public_key)
+          assert_equal binary(vector.fetch("ct")), encapsulated.ciphertext,
+                       algorithm.id
+          assert_equal binary(vector.fetch("ss")), encapsulated.shared_secret,
+                       algorithm.id
+          assert_equal encapsulated.shared_secret,
+                       algorithm.decapsulate(
+                         encapsulated.ciphertext, keys.secret_key
+                       ), algorithm.id
+        ensure
+          native.__reset_randombytes
+          keys.clear! if keys
+          encapsulated.clear! if encapsulated
+        end
+        total += 1
+      end
+      assert_equal expected_vector_count, vectors.length, algorithm.id
     end
+    assert_equal expected_vector_count * KEM_ALGORITHMS.length, total
   end
 
   private
 
-  def read_vector(name)
-    path = File.expand_path("kat/#{name}.rsp", __dir__)
-    File.readlines(path).each_with_object({}) do |line, fields|
+  def read_vectors(name)
+    root = ENV["KPQC_TEST_VECTORS"]
+    path = if root
+             File.join(root, VECTOR_PATHS.fetch(name), "kat.rsp")
+           else
+             File.expand_path("kat/#{name}.rsp", __dir__)
+           end
+    vectors = []
+    fields = {}
+    File.foreach(path) do |line|
       match = /\A([a-z]+) = ([0-9A-Fa-f]*)\s*\z/.match(line)
-      fields[match[1]] = match[2] if match
+      next unless match
+
+      if match[1] == "count" && !fields.empty?
+        vectors << fields
+        fields = {}
+      end
+      fields[match[1]] = match[2]
     end
+    vectors << fields unless fields.empty?
+    vectors
+  end
+
+  def expected_vector_count
+    ENV["KPQC_TEST_VECTORS"] ? 100 : 1
   end
 
   def signature_context(algorithm, random)
@@ -96,4 +153,3 @@ class KnownAnswerTest < Minitest::Test
     [value].pack("H*")
   end
 end
-

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: kpqc
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - osuolfou
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-10-09 00:00:00.000000000 Z
 dependencies: []
 description: Synchronous Ruby bindings for the bundled AIMer and HAETAE signature
-  schemes and NTRU+ and SMAUG-T key-encapsulation mechanisms.
+  schemes and NTRU+ and SMAUG-T key encapsulation mechanisms (KEMs).
 email:
 - osuolfou@naver.com
 executables: []
@@ -235,6 +236,7 @@ metadata:
   bug_tracker_uri: https://github.com/KpqC/kpqc-ruby/issues
   changelog_uri: https://github.com/KpqC/kpqc-ruby/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -249,7 +251,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.20
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: Ruby APIs for AIMer, HAETAE, NTRU+, and SMAUG-T.
 test_files: []