kpqc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f95c1887b2a5ec7382d85fc701193a27404ba01a3618d69686530a310cd48259
+  data.tar.gz: 71e65d041b8a9c828db977f7676aaf26c3d7e330278498867a6823b4146696a3
+SHA512:
+  metadata.gz: 6cfa24eef04e809b60842ee49dd858c950797b33a462dcb87eb59c5db46b7df97fc1180f941a55f84e4ccc96a2168bc07c511591fed9b8876089ba2006a6cd6c
+  data.tar.gz: ee190f6a25021501395dbf6403027521bac354433beb5fa7a5f0d5b9cc4db6f4afc530df309b7a1708c0513d48a77bd9623f32f4ffaf1e431d98028025f49b63

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gemspec
+

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 osuolfou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,174 @@
+# KpqC
+
+KpqC provides synchronous Ruby APIs for AIMer, HAETAE, NTRU+, and SMAUG-T.
+
+## Runtime support
+
+- Ruby 2.6 or newer
+- Windows, macOS, or Linux
+- A C11 compiler and Ruby development headers when building from source
+
+## Install
+
+```sh
+gem install kpqc
+```
+
+## Available schemes
+
+| Algorithm | Type | Exports |
+| --- | --- | --- |
+| **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` |
+
+Requiring an algorithm family keeps the entry point focused:
+
+```ruby
+require "kpqc/aimer"
+
+aimer128f = KpqC::Aimer.aimer128f
+payload = "release-manifest:v3".b
+keys = aimer128f.generate_key_pair
+proof = aimer128f.sign(payload, keys.secret_key)
+
+unless aimer128f.verify(payload, proof, keys.public_key)
+  raise "Signature verification failed"
+end
+```
+
+### Signature contexts
+
+AIMer and HAETAE accept an optional context. A context separates signatures
+created for different application purposes and may contain up to 255 bytes.
+
+```ruby
+require "kpqc/haetae"
+
+haetae3 = KpqC::Haetae.haetae3
+payload = "account=42".b
+context = "audit-record".b
+keys = haetae3.generate_key_pair
+
+signature = haetae3.sign(payload, keys.secret_key, context: context)
+valid = haetae3.verify(
+  payload,
+  signature,
+  keys.public_key,
+  context: context
+)
+
+puts valid # true
+```
+
+Verification fails when the supplied context does not match the one used for
+signing.
+
+### Key encapsulation
+
+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.
+
+```ruby
+require "kpqc/smaugt"
+
+smaugt192 = KpqC::SmaugT.smaugt192
+recipient = smaugt192.generate_key_pair
+
+outbound = smaugt192.encapsulate(recipient.public_key)
+# Send outbound.ciphertext to the recipient.
+
+inbound_secret = smaugt192.decapsulate(
+  outbound.ciphertext,
+  recipient.secret_key
+)
+
+puts inbound_secret == outbound.shared_secret # true
+```
+
+## Imports
+
+Each family has a dedicated require path:
+
+```ruby
+require "kpqc/aimer"
+require "kpqc/haetae"
+require "kpqc/ntruplus"
+require "kpqc/smaugt"
+
+signer = KpqC::Aimer.aimer256s
+another_signer = KpqC::Haetae.haetae5
+key_exchange = KpqC::NtruPlus.ntruplus1152
+another_key_exchange = KpqC::SmaugT.timer
+```
+
+All named algorithms are also available from the package root:
+
+```ruby
+require "kpqc"
+
+signer = KpqC.aimer192f
+key_exchange = KpqC.ntruplus864
+```
+
+## Data and failures
+
+Inputs and outputs are binary `String` instances. Each algorithm exposes an
+`id` and an immutable `sizes` object.
+
+### Parameter sizes
+
+All sizes are in bytes.
+
+#### Signatures
+
+| Algorithm | Public key | Secret key | Signature |
+| --- | ---: | ---: | ---: |
+| `aimer128f` | 32 | 48 | 5,888 |
+| `aimer128s` | 32 | 48 | 4,160 |
+| `aimer192f` | 48 | 72 | 13,056 |
+| `aimer192s` | 48 | 72 | 9,120 |
+| `aimer256f` | 64 | 96 | 25,120 |
+| `aimer256s` | 64 | 96 | 17,056 |
+| `haetae2` | 992 | 1,408 | 1,474 |
+| `haetae3` | 1,472 | 2,112 | 2,349 |
+| `haetae5` | 2,080 | 2,752 | 2,948 |
+
+#### Key encapsulation
+
+| Algorithm | Public key | Secret key | Ciphertext | Shared secret |
+| --- | ---: | ---: | ---: | ---: |
+| `ntruplus768` | 1,152 | 2,336 | 1,152 | 32 |
+| `ntruplus864` | 1,296 | 2,624 | 1,296 | 32 |
+| `ntruplus1152` | 1,728 | 3,488 | 1,728 | 32 |
+| `smaugt128` | 672 | 832 | 672 | 32 |
+| `smaugt192` | 1,088 | 1,312 | 992 | 32 |
+| `smaugt256` | 1,440 | 1,728 | 1,376 | 32 |
+| `timer` | 672 | 832 | 608 | 32 |
+
+Methods reject values of the wrong type or size. Signature verification returns
+`false` for an invalid signature. NTRU+ rejects an invalid ciphertext.
+SMAUG-T performs implicit rejection and returns a replacement secret instead;
+that value will not equal the sender's shared secret.
+
+## Distribution
+
+The published gem includes Ruby modules, native extension sources, and the
+bundled algorithm sources. Each parameter set is loaded on first use. The gem
+has no runtime dependencies.
+
+## Security
+
+The native cores are compiled from the upstream algorithm implementations.
+This gem has not received an independent security audit and does not provide a
+constant-time execution guarantee. Assess those constraints before using it
+with sensitive production keys.
+
+Secret keys stored in `KeyPair` and shared secrets stored in
+`EncapsulatedSecret` can be wiped in place on a best-effort basis with
+`clear!`. A `String` returned by `decapsulate` remains the caller's
+responsibility.
+
+Third-party licenses and attributions are listed in
+[THIRD_PARTY_NOTICES.md](./THIRD_PARTY_NOTICES.md).

data/Rakefile

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require "rake/clean"
+require "rake/testtask"
+require_relative "lib/kpqc/version"
+
+EXTENSION_DIRS = Dir[File.expand_path("ext/kpqc/*", __dir__)]
+  .select { |directory| File.file?(File.join(directory, "extconf.rb")) }
+  .sort
+
+CLEAN.include(*EXTENSION_DIRS.flat_map do |directory|
+  [File.join(directory, "Makefile"), File.join(directory, "mkmf.log")]
+end)
+CLOBBER.include(*EXTENSION_DIRS.flat_map do |directory|
+  [File.join(directory, "**", "*.o"), File.join(directory, "**", "*.bundle"),
+   File.join(directory, "**", "*.so"), File.join(directory, "**", "*.dSYM")]
+end)
+CLOBBER.include("pkg")
+
+def compile_extensions(test_entropy: false)
+  make = RbConfig::CONFIG["MAKE"] || "make"
+  EXTENSION_DIRS.each do |directory|
+    Dir.chdir(directory) do
+      environment = test_entropy ? { "KPQC_TEST_ENTROPY" => "1" } : {}
+      sh environment, RbConfig.ruby, "extconf.rb"
+      sh make, "clean"
+      sh make
+    end
+  end
+end
+
+desc "Compile all native parameter-set extensions"
+task :compile do
+  compile_extensions
+end
+
+task :compile_test do
+  compile_extensions(test_entropy: true)
+end
+
+Rake::TestTask.new(:test => :compile_test) do |task|
+  task.libs << "lib"
+  EXTENSION_DIRS.each { |directory| task.libs << directory }
+  task.pattern = "test/**/*_test.rb"
+  task.warning = true
+end
+
+desc "Build the gem package"
+task :build do
+  mkdir_p "pkg"
+  package = File.join("pkg", "kpqc-#{KpqC::VERSION}.gem")
+  sh RbConfig.ruby, "-S", "gem", "build", "kpqc.gemspec",
+     "--output", package
+end
+
+task :default => :test

data/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,53 @@
+# Third-party notices
+
+The native extensions published in this gem contain code from the following
+KpqC reference implementations:
+
+- AIMer reference implementation, by the AIMer team / Samsung SDS
+- HAETAE reference implementation, Copyright (c) 2026 Team HAETAE
+- NTRU+ reference implementation, Copyright (c) 2024–2026 NTRU+ TEAM
+- SMAUG-T reference implementation, Copyright (c) 2026 Team SMAUG-T
+
+These components are distributed under the MIT License. Full original license
+texts are included in the gem source distribution.
+
+Imported on 2026-09-06. `vendor/SOURCES.json` records the SHA-256 of each
+source file before the shared KpqC binding adaptations, under its destination
+path. Original NIST notices in AIMer headers are preserved; we acknowledge
+NIST as the source of the software identified by those notices.
+
+The SHA-3/SHAKE code is based on public-domain implementations by Ronny Van
+Keer and on TweetFips202 by Gilles Van Assche, Daniel J. Bernstein and Peter
+Schwabe.
+
+## Source and Ruby binding adaptations
+
+- Production entropy uses operating-system random-number sources through
+  `ext/kpqc/randombytes.c`. Upstream RNG/CTR-DRBG/AES implementations and
+  benchmark/KAT executables are not compiled or shipped as runtime components.
+- AIMer, HAETAE, NTRU+, and SMAUG-T public operations check RNG return codes.
+  NTRU+ RNG declarations return `int` to propagate failure. The optional
+  random-seed branch in SMAUG-T's `indcpa_enc` also stops on RNG failure.
+- AIMer and NTRU+ SHA-3/SHAKE contexts use embedded storage and wipe it on
+  release, avoiding process termination when heap allocation fails. AIMer
+  signing and verification allocation failures propagate to Ruby as
+  `KpqC::Error` or `NoMemoryError`.
+- The imported SMAUG-T sources include full-vector initialization in `key.c`,
+  corrected output indexing in `dg.c`, and the correct output buffer size in
+  `packring.c`.
+- Unused HAETAE helper code and local variables were removed, and a SMAUG-T
+  loop counter was changed to `size_t` to match its bound.
+- Parameter sets are built as separate Ruby extensions with their upstream
+  configuration macros and hidden C symbols. The binding validates input sizes
+  before entering C and wipes unpublished outputs on failure.
+
+The bundled implementations are the same adapted cores used to generate the
+npm package's JavaScript runtime.
+
+## Known-answer tests
+
+`test/kat` contains the first KAT record for every parameter set. AIMer,
+HAETAE, and NTRU+ records come from their reference implementations. SMAUG-T
+records reflect the documented source fixes also used by the npm and PyPI
+packages. The tests reproduce the NIST AES-256 CTR DRBG and compare keys,
+signatures, ciphertexts, and shared secrets byte-for-byte.

data/ext/kpqc/aimer128f/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative "../extconf_helper"
+KpqCBuild.aimer("aimer128f", "128f")
+

data/ext/kpqc/aimer128s/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative "../extconf_helper"
+KpqCBuild.aimer("aimer128s", "128s")
+

data/ext/kpqc/aimer192f/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative "../extconf_helper"
+KpqCBuild.aimer("aimer192f", "192f")
+

data/ext/kpqc/aimer192s/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative "../extconf_helper"
+KpqCBuild.aimer("aimer192s", "192s")
+

data/ext/kpqc/aimer256f/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative "../extconf_helper"
+KpqCBuild.aimer("aimer256f", "256f")
+

data/ext/kpqc/aimer256s/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative "../extconf_helper"
+KpqCBuild.aimer("aimer256s", "256s")
+

data/ext/kpqc/extconf_helper.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rbconfig"
+
+module KpqCBuild
+  ROOT = File.expand_path("../..", __dir__)
+  EXT_ROOT = __dir__
+  VENDOR = File.join(ROOT, "vendor")
+
+  module_function
+
+  def aimer(name, parameter)
+    root = File.join(VENDOR, "AIMer")
+    configure(
+      name,
+      [root, File.join(root, "common")],
+      ["aim2.c", "hash.c", "sign.c", "tree.c",
+       "field#{parameter[0, 3]}.c", "fips202.c"],
+      "PARAMS" => parameter,
+      "KPQC_SIGNATURE" => 1,
+      "KPQC_AIMER" => 1
+    )
+  end
+
+  def haetae(name, mode)
+    root = File.join(VENDOR, "HAETAE")
+    sources = %w[
+      decompose.c encoding.c fft.c fixpoint.c ntt.c packing.c poly.c
+      polyfix.c polymat.c polyvec.c reduce.c sampler.c sign.c fips202.c
+      symmetric-shake.c
+    ]
+    configure(
+      name,
+      [File.join(root, "include"), File.join(root, "src")],
+      sources,
+      "HAETAE_CONFIG_MODE" => mode,
+      "KPQC_SIGNATURE" => 1
+    )
+  end
+
+  def ntruplus(name, parameter)
+    root = File.join(VENDOR, "NTRUplus", "NTRU+#{parameter}")
+    configure(
+      name,
+      [root, File.join(root, "fips202")],
+      %w[kem.c ntt.c poly.c symmetric.c fips202.c],
+      {}
+    )
+  end
+
+  def smaugt(name, mode)
+    root = File.join(VENDOR, "SMAUG-T")
+    sources = %w[
+      cbd.c ciphertext.c dg.c hash.c hwt.c indcpa.c kem.c key.c pack.c
+      packring.c poly.c toomcook.c verify.c fips202.c
+    ]
+    configure(
+      name,
+      [File.join(root, "include"), File.join(root, "src")],
+      sources,
+      "SMAUGT_CONFIG_MODE" => mode
+    )
+  end
+
+  def configure(name, source_directories, sources, definitions)
+    extension_constant = name.sub(/\A([a-z])/) { Regexp.last_match(1).upcase }
+    definitions = definitions.merge(
+      "KPQC_NATIVE_INIT" => "#{name}_native",
+      "KPQC_NATIVE_CONST" => extension_constant
+    )
+    definitions["KPQC_TEST_ENTROPY"] = 1 if ENV["KPQC_TEST_ENTROPY"] == "1"
+
+    $VPATH << EXT_ROOT
+    source_directories.each do |directory|
+      $VPATH << directory
+      $INCFLAGS << " -I#{directory}"
+    end
+
+    $srcs = ["module.c", "randombytes.c"] + sources
+    definitions.each { |key, value| $defs << "-D#{key}=#{value}" }
+
+    if RbConfig::CONFIG["CC"] =~ /(?:^|\s)cl(?:\.exe)?(?:\s|$)/i
+      $CFLAGS << " /O2 /W0"
+    else
+      $CFLAGS << " -std=c11 -O2 -fvisibility=hidden -fno-strict-aliasing -w"
+    end
+
+    have_library("bcrypt") if Gem.win_platform?
+    have_library("m") unless Gem.win_platform?
+    create_makefile("kpqc/#{name}_native")
+  end
+end

data/ext/kpqc/haetae2/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative "../extconf_helper"
+KpqCBuild.haetae("haetae2", 0)
+

data/ext/kpqc/haetae3/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative "../extconf_helper"
+KpqCBuild.haetae("haetae3", 1)
+

data/ext/kpqc/haetae5/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative "../extconf_helper"
+KpqCBuild.haetae("haetae5", 2)
+

data/ext/kpqc/module.c

@@ -0,0 +1,195 @@
+/* SPDX-License-Identifier: MIT */
+#include <stddef.h>
+#include <stdint.h>
+#include <ruby.h>
+#include "api.h"
+
+#define KPQC_JOIN_(left, right) left##right
+#define KPQC_JOIN(left, right) KPQC_JOIN_(left, right)
+#define KPQC_STRING_(value) #value
+#define KPQC_STRING(value) KPQC_STRING_(value)
+#define KPQC_INIT(name) KPQC_JOIN(Init_, name)
+#define KPQC_DATA(value) ((uint8_t *)RSTRING_PTR(value))
+
+static VALUE kpqc_error;
+#ifdef KPQC_SIGNATURE
+static const uint8_t kpqc_empty_input = 0;
+
+static const uint8_t *kpqc_input(VALUE value) {
+    return RSTRING_LEN(value) == 0 ? &kpqc_empty_input : KPQC_DATA(value);
+}
+#endif
+
+static void kpqc_require_string(VALUE value, const char *label) {
+    if (!RB_TYPE_P(value, T_STRING)) {
+        rb_raise(rb_eTypeError, "%s must be a String", label);
+    }
+}
+
+static void kpqc_require_size(VALUE value, long expected, const char *label) {
+    kpqc_require_string(value, label);
+    if (RSTRING_LEN(value) != expected) {
+        rb_raise(rb_eArgError, "%s must be %ld bytes, received %ld",
+                 label, expected, RSTRING_LEN(value));
+    }
+}
+
+#ifdef KPQC_SIGNATURE
+static void kpqc_require_context(VALUE context) {
+    kpqc_require_string(context, "context");
+    if (RSTRING_LEN(context) > 255) {
+        rb_raise(rb_eArgError,
+                 "context cannot exceed 255 bytes, received %ld",
+                 RSTRING_LEN(context));
+    }
+}
+#endif
+
+static void kpqc_wipe(VALUE value) {
+    volatile uint8_t *bytes = KPQC_DATA(value);
+    long length = RSTRING_LEN(value);
+    while (length-- > 0) *bytes++ = 0;
+}
+
+#if defined(_MSC_VER)
+#define KPQC_NORETURN __declspec(noreturn)
+#elif defined(__GNUC__) || defined(__clang__)
+#define KPQC_NORETURN __attribute__((noreturn))
+#else
+#define KPQC_NORETURN
+#endif
+
+static KPQC_NORETURN void kpqc_failure(int status, const char *operation) {
+    if (status == -2) rb_memerror();
+    rb_raise(kpqc_error, "%s failed with status %d", operation, status);
+}
+
+static VALUE kpqc_keygen(VALUE self) {
+    VALUE public_key = rb_str_new(NULL, CRYPTO_PUBLICKEYBYTES);
+    VALUE secret_key = rb_str_new(NULL, CRYPTO_SECRETKEYBYTES);
+    int status;
+    (void)self;
+
+#ifdef KPQC_SIGNATURE
+    status = crypto_sign_keypair(KPQC_DATA(public_key), KPQC_DATA(secret_key));
+#else
+    status = crypto_kem_keypair(KPQC_DATA(public_key), KPQC_DATA(secret_key));
+#endif
+    if (status != 0) {
+        kpqc_wipe(public_key);
+        kpqc_wipe(secret_key);
+        kpqc_failure(status, "key generation");
+    }
+    return rb_ary_new_from_args(2, public_key, secret_key);
+}
+
+#ifdef KPQC_SIGNATURE
+static VALUE kpqc_sign(VALUE self, VALUE message, VALUE secret_key,
+                       VALUE context) {
+    VALUE signature;
+    size_t signature_length = 0;
+    int status;
+    (void)self;
+
+    kpqc_require_string(message, "message");
+    kpqc_require_size(secret_key, CRYPTO_SECRETKEYBYTES, "secret_key");
+    kpqc_require_context(context);
+    signature = rb_str_new(NULL, CRYPTO_BYTES);
+
+    status = crypto_sign_signature(
+        KPQC_DATA(signature), &signature_length,
+        kpqc_input(message), (size_t)RSTRING_LEN(message),
+        kpqc_input(context), (size_t)RSTRING_LEN(context),
+        KPQC_DATA(secret_key));
+    if (status != 0) {
+        kpqc_wipe(signature);
+        kpqc_failure(status, "signing");
+    }
+    if (signature_length != CRYPTO_BYTES) {
+        kpqc_wipe(signature);
+        rb_raise(rb_eRuntimeError,
+                 "core returned an invalid signature size: expected %d, received %lu",
+                 CRYPTO_BYTES, (unsigned long)signature_length);
+    }
+    return signature;
+}
+
+static VALUE kpqc_verify(VALUE self, VALUE message, VALUE signature,
+                         VALUE public_key, VALUE context) {
+    int status;
+    (void)self;
+
+    kpqc_require_string(message, "message");
+    kpqc_require_string(signature, "signature");
+    kpqc_require_size(public_key, CRYPTO_PUBLICKEYBYTES, "public_key");
+    kpqc_require_context(context);
+    if (RSTRING_LEN(signature) != CRYPTO_BYTES) return Qfalse;
+
+    status = crypto_sign_verify(
+        KPQC_DATA(signature), (size_t)RSTRING_LEN(signature),
+        kpqc_input(message), (size_t)RSTRING_LEN(message),
+        kpqc_input(context), (size_t)RSTRING_LEN(context),
+        KPQC_DATA(public_key));
+    if (status == -2) kpqc_failure(status, "verification");
+    return status == 0 ? Qtrue : Qfalse;
+}
+#else
+static VALUE kpqc_encapsulate(VALUE self, VALUE public_key) {
+    VALUE ciphertext;
+    VALUE shared_secret;
+    int status;
+    (void)self;
+
+    kpqc_require_size(public_key, CRYPTO_PUBLICKEYBYTES, "public_key");
+    ciphertext = rb_str_new(NULL, CRYPTO_CIPHERTEXTBYTES);
+    shared_secret = rb_str_new(NULL, CRYPTO_BYTES);
+    status = crypto_kem_enc(KPQC_DATA(ciphertext), KPQC_DATA(shared_secret),
+                            KPQC_DATA(public_key));
+    if (status != 0) {
+        kpqc_wipe(ciphertext);
+        kpqc_wipe(shared_secret);
+        kpqc_failure(status, "encapsulation");
+    }
+    return rb_ary_new_from_args(2, ciphertext, shared_secret);
+}
+
+static VALUE kpqc_decapsulate(VALUE self, VALUE ciphertext, VALUE secret_key) {
+    VALUE shared_secret;
+    int status;
+    (void)self;
+
+    kpqc_require_size(ciphertext, CRYPTO_CIPHERTEXTBYTES, "ciphertext");
+    kpqc_require_size(secret_key, CRYPTO_SECRETKEYBYTES, "secret_key");
+    shared_secret = rb_str_new(NULL, CRYPTO_BYTES);
+    status = crypto_kem_dec(KPQC_DATA(shared_secret), KPQC_DATA(ciphertext),
+                            KPQC_DATA(secret_key));
+    if (status != 0) {
+        kpqc_wipe(shared_secret);
+        kpqc_failure(status, "decapsulation");
+    }
+    return shared_secret;
+}
+#endif
+
+RUBY_FUNC_EXPORTED void KPQC_INIT(KPQC_NATIVE_INIT)(void) {
+    VALUE kpqc = rb_define_module("KpqC");
+    VALUE native = rb_define_module_under(kpqc, "Native");
+    VALUE algorithm = rb_define_module_under(
+        native, KPQC_STRING(KPQC_NATIVE_CONST));
+
+    kpqc_error = rb_define_class_under(kpqc, "Error", rb_eStandardError);
+    rb_define_singleton_method(algorithm, "keygen", kpqc_keygen, 0);
+#ifdef KPQC_SIGNATURE
+    rb_define_singleton_method(algorithm, "sign", kpqc_sign, 3);
+    rb_define_singleton_method(algorithm, "verify", kpqc_verify, 4);
+#else
+    rb_define_singleton_method(algorithm, "encapsulate", kpqc_encapsulate, 1);
+    rb_define_singleton_method(algorithm, "decapsulate", kpqc_decapsulate, 2);
+#endif
+#ifdef KPQC_TEST_ENTROPY
+    {
+        void kpqc_randombytes_test_init(VALUE);
+        kpqc_randombytes_test_init(algorithm);
+    }
+#endif
+}

data/ext/kpqc/ntruplus1152/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative "../extconf_helper"
+KpqCBuild.ntruplus("ntruplus1152", 1152)
+

data/ext/kpqc/ntruplus768/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative "../extconf_helper"
+KpqCBuild.ntruplus("ntruplus768", 768)
+

data/ext/kpqc/ntruplus864/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative "../extconf_helper"
+KpqCBuild.ntruplus("ntruplus864", 864)
+