pqc_rails 0.1.0

data/lib/pqc_rails/ffi/sig.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module PqcRails
+  module Ffi
+    # liboqsのGeneric SIG(署名)APIへの低レベルFFIバインディング。
+    # PqcRails::Ffi::Kem と対になる、署名アルゴリズム版。
+    module Sig
+      extend FFI::Library
+
+      ffi_lib PqcRails.configuration.liboqs_path
+
+      # liboqs/include/oqs/sig.h の OQS_SIG 構造体に対応。
+      # liboqs 0.15.0の実物ヘッダ(/usr/local/include/oqs/sig.h)で確認済みのフィールド順序。
+      #
+      # KEMのOQS_KEM構造体との違い:
+      #   - euf_cma / suf_cma / sig_with_ctx_support という3つのbool値が追加されている
+      #   - length_ciphertext / length_shared_secret は無く、代わりに length_signature がある
+      #   - keypair_derand に相当するderandomized版は無い(2026-06-20時点のヘッダには存在しない)
+      #   - sign / verify に加えて、コンテキスト文字列付きの
+      #     sign_with_ctx_str / verify_with_ctx_str が追加で存在する
+      class Struct < FFI::Struct
+        layout(
+          :method_name,            :pointer,
+          :alg_version,            :pointer,
+          :claimed_nist_level,     :uint8,
+          :euf_cma,                 :bool,
+          :suf_cma,                 :bool,
+          :sig_with_ctx_support,   :bool,
+          :length_public_key,      :size_t,
+          :length_secret_key,      :size_t,
+          :length_signature,       :size_t,
+          :keypair,                 :pointer,
+          :sign,                    :pointer,
+          :sign_with_ctx_str,      :pointer,
+          :verify,                  :pointer,
+          :verify_with_ctx_str,    :pointer
+        )
+      end
+
+      # OQS_SIG *OQS_SIG_new(const char *method_name);
+      attach_function :OQS_SIG_new, [:string], :pointer
+
+      # void OQS_SIG_free(OQS_SIG *sig);
+      attach_function :OQS_SIG_free, [:pointer], :void
+
+      # OQS_STATUS OQS_SIG_keypair(const OQS_SIG *sig, uint8_t *public_key, uint8_t *secret_key);
+      attach_function :OQS_SIG_keypair, [:pointer, :pointer, :pointer], :int
+
+      # OQS_STATUS OQS_SIG_sign(const OQS_SIG *sig, uint8_t *signature, size_t *signature_len,
+      #                          const uint8_t *message, size_t message_len, const uint8_t *secret_key);
+      # 引数は6個: sig, signature, signature_len(出力, size_t*), message, message_len, secret_key
+      # signature_len は size_t* (出力引数)。FFIでは :pointer として渡し、
+      # 呼び出し側で FFI::MemoryPointer#read_ulong 等で読み出す必要がある。
+      attach_function :OQS_SIG_sign,
+                       [:pointer, :pointer, :pointer, :pointer, :size_t, :pointer],
+                       :int
+
+      # OQS_STATUS OQS_SIG_verify(const OQS_SIG *sig, const uint8_t *message, size_t message_len,
+      #                            const uint8_t *signature, size_t signature_len, const uint8_t *public_key);
+      # 引数は6個: sig, message, message_len, signature, signature_len, public_key
+      attach_function :OQS_SIG_verify,
+                       [:pointer, :pointer, :size_t, :pointer, :size_t, :pointer],
+                       :int
+    end
+  end
+end

data/lib/pqc_rails/generators/install/install_generator.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "rails/generators"
+require_relative "../../hybrid_kem"
+require_relative "../../session/encryptor"
+require_relative "../../session/key_manager"
+
+module PqcRails
+  module Generators
+    # `rails generate pqc_rails:install` で実行される。
+    # config/initializers/pqc_rails.rbを生成し、セッション暗号化用のHybridKemキーペアを
+    # 生成してRails credentialsに保存する。
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Generates the pqc_rails initializer and a PQC session key in Rails credentials."
+
+      def create_initializer
+        copy_file "initializer.rb", "config/initializers/pqc_rails.rb"
+      end
+
+      def add_session_key_to_credentials
+        encoded_key = PqcRails::Session::KeyManager.encode(generated_keypair)
+
+        credentials.change do |tmp_path|
+          data = YAML.safe_load(tmp_path.read, permitted_classes: [Symbol], aliases: true) || {}
+          data["pqc_session_key"] = encoded_key
+          tmp_path.write(data.to_yaml)
+        end
+
+        say_status :credentials, "Added pqc_session_key to Rails credentials"
+      end
+
+      private
+
+      def generated_keypair
+        @generated_keypair ||= PqcRails::HybridKem.open(PqcRails::Session::Encryptor::DEFAULT_PQ_ALG_NAME) do |hybrid|
+          hybrid.generate_keypair
+        end
+      end
+
+      def credentials
+        Rails.application.credentials
+      end
+    end
+  end
+end

data/lib/pqc_rails/generators/install/templates/initializer.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# config/application.rb (または config/initializers/session_store.rb) で
+# 以下を設定すると、セッションがPQC(ML-KEM + X25519のハイブリッド)で暗号化されます。
+#
+#   config.session_store :pqc_cookie_store
+#
+PqcRails.configure do |config|
+  # config.liboqs_path = "/usr/local/lib/liboqs.dylib"
+end

data/lib/pqc_rails/hybrid_kem.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "openssl"
+require_relative "blob_packing"
+require_relative "dh_kem"
+require_relative "kem"
+
+module PqcRails
+  # 古典ECDH(DhKem)とPQ KEM(liboqs経由のKem)を組み合わせたハイブリッドKEM。
+  #
+  # 量子コンピュータがPQ側を破ったとしても古典側が安全なら(あるいはその逆でも)
+  # 全体の共有鍵は安全、という「移行期間中の保険」を提供するのが目的。
+  # NIST標準化されたML-KEMはまだ実運用歴が浅いため、実績のあるX25519と組み合わせることで
+  # 「PQアルゴリズム自体に未知の脆弱性が見つかった場合」のリスクを下げる。
+  #
+  # コンバイナの方式: 古典側の共有鍵とPQ側の共有鍵を連結し、両者のciphertext
+  # (encapsulateの出力)をHKDFのinfoにバインドした上でHKDF-SHA256にかけて
+  # 32バイトの最終共有鍵を導出する。ciphertextをバインドするのは、
+  # 通常のTLSハンドシェイクのようなトランスクリプトハッシュによる結合が無い
+  # スタンドアロン用途のため、コンバイナ自体に結合の安全性を持たせる必要があるため。
+  #
+  # この「連結してからHKDFにかける」方式は自己流ではなく、RFC 9954(TLS 1.3ハイブリッド鍵共有、
+  # 旧draft-ietf-tls-hybrid-design)が採用する"concatenation approach"と同じ構成であり、
+  # NIST SP 800-56Cが承認済みアルゴリズムと非承認アルゴリズムのハイブリッド共有鍵生成における
+  # 承認済み手法として単純連結を挙げている。RFC 9954はこの構成が「dual-PRFコンバイナ」に対応し、
+  # ハッシュ関数がdual-PRFであるという仮定の下で安全性が証明されているとしている([BINDEL]論文)。
+  # なお、RFC 9370(IKEv2の複数鍵交換)はSKEYSEED(n) = prf(SK_d(n-1), SK(n) | Ni | Nr)という
+  # 逐次的なPRF連鎖(cascade)を採るため、本実装とは別のコンバイナ方式である点に注意
+  # (2026-07-16、一次資料読解セッションでRFC本文を確認して検証済み)。
+  #
+  # 使い方:
+  #   PqcRails::HybridKem.open(:ml_kem_512) do |hybrid|
+  #     keypair = hybrid.generate_keypair
+  #     encap   = hybrid.encapsulate(keypair.public_key)
+  #     shared  = hybrid.decapsulate(encap.ciphertext, keypair.secret_key)
+  #     shared == encap.shared_secret # => true
+  #   end
+  class HybridKem
+    Keypair = Struct.new(:public_key, :secret_key)
+    Encapsulation = Struct.new(:ciphertext, :shared_secret)
+
+    COMBINER_LABEL = "pqc_rails-hybrid-kem-v1"
+    SHARED_SECRET_LENGTH = 32
+
+    attr_reader :pq_alg_name, :classical_curve
+
+    def initialize(pq_alg_name, classical_curve = "X25519")
+      @pq_alg_name = pq_alg_name
+      @classical_curve = classical_curve
+      @classical = DhKem.new(classical_curve)
+      @pq = Kem.new(pq_alg_name)
+      @freed = false
+    end
+
+    def generate_keypair
+      ensure_not_freed!
+
+      classical_keypair = @classical.generate_keypair
+      pq_keypair = @pq.generate_keypair
+
+      Keypair.new(
+        BlobPacking.pack(classical_keypair.public_key, pq_keypair.public_key),
+        BlobPacking.pack(classical_keypair.secret_key, pq_keypair.secret_key)
+      )
+    end
+
+    def encapsulate(public_key)
+      ensure_not_freed!
+
+      classical_public_key, pq_public_key = BlobPacking.unpack(public_key)
+      classical_encap = @classical.encapsulate(classical_public_key)
+      pq_encap = @pq.encapsulate(pq_public_key)
+
+      Encapsulation.new(
+        BlobPacking.pack(classical_encap.ciphertext, pq_encap.ciphertext),
+        combine(classical_encap.shared_secret, pq_encap.shared_secret,
+                classical_encap.ciphertext, pq_encap.ciphertext)
+      )
+    end
+
+    def decapsulate(ciphertext, secret_key)
+      ensure_not_freed!
+
+      classical_ciphertext, pq_ciphertext = BlobPacking.unpack(ciphertext)
+      classical_secret_key, pq_secret_key = BlobPacking.unpack(secret_key)
+
+      classical_shared = @classical.decapsulate(classical_ciphertext, classical_secret_key)
+      pq_shared = @pq.decapsulate(pq_ciphertext, pq_secret_key)
+
+      combine(classical_shared, pq_shared, classical_ciphertext, pq_ciphertext)
+    end
+
+    def free
+      return if @freed
+
+      @pq.free
+      @freed = true
+    end
+
+    def self.open(pq_alg_name, classical_curve = "X25519")
+      hybrid = new(pq_alg_name, classical_curve)
+      yield hybrid
+    ensure
+      hybrid&.free
+    end
+
+    private
+
+    # 古典側とPQ側の共有鍵を連結し、両者のciphertextとアルゴリズム名をinfoに
+    # バインドした上でHKDF-SHA256にかけ、最終的な共有鍵を導出する。
+    def combine(classical_secret, pq_secret, classical_ciphertext, pq_ciphertext)
+      ikm = classical_secret + pq_secret
+      info = [
+        COMBINER_LABEL,
+        @classical.curve,
+        @pq.alg_name.to_s,
+        classical_ciphertext,
+        pq_ciphertext
+      ].join("\x00")
+
+      OpenSSL::KDF.hkdf(ikm, salt: "", info: info, length: SHARED_SECRET_LENGTH, hash: "SHA256")
+    end
+
+    def ensure_not_freed!
+      raise PqcRails::Error, "this PqcRails::HybridKem instance has already been freed" if @freed
+    end
+  end
+end

data/lib/pqc_rails/kem.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "algorithms"
+require_relative "length_validation"
+require_relative "ffi/kem"
+
+module PqcRails
+  # liboqsのGeneric KEM APIをRubyらしく包んだクラス。
+  #
+  # 使い方:
+  #   kem = PqcRails::Kem.new(:ml_kem_512) # またはliboqsの生の名前 "ML-KEM-512"
+  #   keypair = kem.generate_keypair
+  #   encap   = kem.encapsulate(keypair.public_key)
+  #   shared  = kem.decapsulate(encap.ciphertext, keypair.secret_key)
+  #   shared == encap.shared_secret # => true
+  #
+  # kem.free を呼ぶか、ブロック形式(PqcRails::Kem.open)を使うことで
+  # Cレベルのメモリを確実に解放できる。
+  class Kem
+    include LengthValidation
+
+    Keypair = Struct.new(:public_key, :secret_key)
+    Encapsulation = Struct.new(:ciphertext, :shared_secret)
+
+    attr_reader :alg_name
+
+    def initialize(alg_name)
+      @alg_name = alg_name
+      liboqs_alg_name = Algorithms.resolve_kem_name(alg_name)
+      @kem_ptr = Ffi::Kem.OQS_KEM_new(liboqs_alg_name)
+      if @kem_ptr.null?
+        raise PqcRails::Error,
+              "OQS_KEM_new failed for '#{liboqs_alg_name}'. " \
+              "liboqsがこのアルゴリズムを有効にしてビルドされているか確認してください。"
+      end
+
+      @kem = Ffi::Kem::Struct.new(@kem_ptr)
+      @freed = false
+    end
+
+    def length_public_key    = @kem[:length_public_key]
+    def length_secret_key    = @kem[:length_secret_key]
+    def length_ciphertext    = @kem[:length_ciphertext]
+    def length_shared_secret = @kem[:length_shared_secret]
+
+    def generate_keypair
+      ensure_not_freed!
+
+      public_key = FFI::MemoryPointer.new(:uint8, length_public_key)
+      secret_key = FFI::MemoryPointer.new(:uint8, length_secret_key)
+
+      status = Ffi::Kem.OQS_KEM_keypair(@kem_ptr, public_key, secret_key)
+      raise PqcRails::Error, "OQS_KEM_keypair failed (status=#{status})" unless status.zero?
+
+      Keypair.new(
+        public_key.read_bytes(length_public_key),
+        secret_key.read_bytes(length_secret_key)
+      )
+    end
+
+    def encapsulate(public_key)
+      ensure_not_freed!
+      validate_length!(public_key, length_public_key, "public_key")
+
+      ciphertext    = FFI::MemoryPointer.new(:uint8, length_ciphertext)
+      shared_secret = FFI::MemoryPointer.new(:uint8, length_shared_secret)
+      pk_ptr        = FFI::MemoryPointer.new(:uint8, public_key.bytesize)
+      pk_ptr.put_bytes(0, public_key)
+
+      status = Ffi::Kem.OQS_KEM_encaps(@kem_ptr, ciphertext, shared_secret, pk_ptr)
+      raise PqcRails::Error, "OQS_KEM_encaps failed (status=#{status})" unless status.zero?
+
+      Encapsulation.new(
+        ciphertext.read_bytes(length_ciphertext),
+        shared_secret.read_bytes(length_shared_secret)
+      )
+    end
+
+    def decapsulate(ciphertext, secret_key)
+      ensure_not_freed!
+      validate_length!(ciphertext, length_ciphertext, "ciphertext")
+      validate_length!(secret_key, length_secret_key, "secret_key")
+
+      shared_secret = FFI::MemoryPointer.new(:uint8, length_shared_secret)
+      ct_ptr        = FFI::MemoryPointer.new(:uint8, ciphertext.bytesize)
+      ct_ptr.put_bytes(0, ciphertext)
+      sk_ptr        = FFI::MemoryPointer.new(:uint8, secret_key.bytesize)
+      sk_ptr.put_bytes(0, secret_key)
+
+      status = Ffi::Kem.OQS_KEM_decaps(@kem_ptr, shared_secret, ct_ptr, sk_ptr)
+      raise PqcRails::Error, "OQS_KEM_decaps failed (status=#{status})" unless status.zero?
+
+      shared_secret.read_bytes(length_shared_secret)
+    end
+
+    def free
+      return if @freed
+
+      Ffi::Kem.OQS_KEM_free(@kem_ptr)
+      @freed = true
+    end
+
+    def self.open(alg_name)
+      kem = new(alg_name)
+      yield kem
+    ensure
+      kem&.free
+    end
+
+    private
+
+    def ensure_not_freed!
+      raise PqcRails::Error, "this PqcRails::Kem instance has already been freed" if @freed
+    end
+  end
+end

data/lib/pqc_rails/key_source.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "rails"
+require "base64"
+require_relative "blob_packing"
+require_relative "hybrid_kem"
+
+module PqcRails
+  class MissingKeyError < PqcRails::Error; end
+
+  # 環境変数→Rails credentialsの順で鍵を読み込み、HybridKem::Keypairへデコードするまでの
+  # 共通処理。Session::KeyManagerとActiveRecord::KeyProviderで同じ手順(fetch→無ければ例外→decode)
+  # が必要になるため共通化している。環境変数を優先するのは本番運用でcredentialsファイルを
+  # 使わずに鍵を渡せるようにするため(コンテナのsecret注入等と相性が良い)。
+  module KeySource
+    module_function
+
+    def fetch(env_var:, credentials_key:)
+      ENV.fetch(env_var, nil) || credentials_value(credentials_key)
+    end
+
+    # fetchした値がnilならMissingKeyErrorを送出する版。
+    def fetch!(env_var:, credentials_key:, label:)
+      fetch(env_var: env_var, credentials_key: credentials_key) ||
+        raise(MissingKeyError,
+              "PQC #{label} key not found. Set ENV['#{env_var}'] or run `rails generate pqc_rails:install`.")
+    end
+
+    # fetch! + decodeまでを1回で行う。Session::KeyManager#keypairとActiveRecord::KeyProvider#keypairの
+    # 両方が同じ「fetch→無ければ例外→decode」という処理列を重複実装していたため、ここに統合した。
+    def fetch_keypair!(env_var:, credentials_key:, label:)
+      decode(fetch!(env_var: env_var, credentials_key: credentials_key, label: label))
+    end
+
+    def credentials_value(credentials_key)
+      return nil unless Rails.respond_to?(:application) && Rails.application
+
+      Rails.application.credentials[credentials_key]
+    end
+
+    # HybridKem::Keypairのシリアライズ形式。セッション固有の処理ではなく鍵の保存形式そのものなので、
+    # Session::KeyManagerではなくここに置く(セッション/AR両方から使われる)。
+    def encode(keypair)
+      Base64.strict_encode64(BlobPacking.pack(keypair.public_key, keypair.secret_key))
+    end
+
+    def decode(encoded)
+      public_key, secret_key = BlobPacking.unpack(Base64.strict_decode64(encoded))
+      HybridKem::Keypair.new(public_key, secret_key)
+    end
+
+    # ENV/Rails credentialsから現行鍵・旧鍵世代を読み込むデフォルトの鍵ソース。
+    #
+    # Session::KeyManagerとActiveRecord::KeyProviderは、鍵の取得元をこのクラスのインスタンスに
+    # 委譲する。`#current_keypair`/`#previous_keypairs`という2メソッドさえ実装すれば、
+    # 将来HSM/PKCS#11経由の鍵ソースにも差し替えられる(実装はしないが、この分離だけで済むように
+    # しておく、というPhase4での抽象化)。
+    #
+    # 旧鍵世代は、ENVではカンマ区切りの文字列、credentialsでは配列として持たせる(ENVは
+    # 文字列しか持てないため)。世代数に上限は設けない。ローテーション完了後は運用側が
+    # previous_env_var/previous_credentials_keyを空にすることで旧鍵を無効化する。
+    class EnvCredentials
+      def initialize(env_var:, previous_env_var:, credentials_key:, previous_credentials_key:, label:)
+        @env_var = env_var
+        @previous_env_var = previous_env_var
+        @credentials_key = credentials_key
+        @previous_credentials_key = previous_credentials_key
+        @label = label
+      end
+
+      def current_keypair
+        KeySource.fetch_keypair!(env_var: @env_var, credentials_key: @credentials_key, label: @label)
+      end
+
+      def previous_keypairs
+        raw = KeySource.fetch(env_var: @previous_env_var, credentials_key: @previous_credentials_key)
+        return [] if raw.nil?
+
+        entries = raw.is_a?(::Array) ? raw : raw.split(",")
+        entries.map { |encoded| KeySource.decode(encoded.strip) }
+      end
+    end
+  end
+end

data/lib/pqc_rails/length_validation.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module PqcRails
+  # 鍵・暗号文・署名等のバイト列長を検証する共通処理。
+  # Kem/Sig/DhKem/EnvelopeCipherで同じチェックが必要になるため切り出している。
+  module LengthValidation
+    private
+
+    def validate_length!(bytes, expected_length, name)
+      return if bytes.bytesize == expected_length
+
+      raise ArgumentError,
+            "#{name} has wrong length: expected #{expected_length} bytes, got #{bytes.bytesize}"
+    end
+  end
+end

data/lib/pqc_rails/session/encryptor.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "base64"
+require_relative "../blob_packing"
+require_relative "../hybrid_kem"
+require_relative "../envelope_cipher"
+
+module PqcRails
+  module Session
+    # HybridKem(KEM) + EnvelopeCipher(DEM)によるKEM-DEM構成のハイブリッド公開鍵暗号。
+    #
+    # セッションストアは同一サーバがencrypt(Cookie書き込み時)とdecrypt(Cookie読み込み時)の
+    # 両方を行うため、二者間のインタラクティブな鍵交換ではなく、毎回encapsulateし直す
+    # ランダム化された公開鍵暗号として使う。これにより、長期鍵(secret_key)はサーバにしか無くても、
+    # Cookieごとに異なるciphertextが作られる(per-cookieのforward secrecy的な性質を持つ)。
+    class Encryptor
+      DEFAULT_PQ_ALG_NAME = :ml_kem_768
+
+      def initialize(keypair, pq_alg_name: DEFAULT_PQ_ALG_NAME)
+        @keypair = keypair
+        @pq_alg_name = pq_alg_name
+      end
+
+      def encrypt(data)
+        serialized = Marshal.dump(data)
+
+        HybridKem.open(@pq_alg_name) do |hybrid|
+          encap = hybrid.encapsulate(@keypair.public_key)
+          encrypted = EnvelopeCipher.new(encap.shared_secret).encrypt(serialized)
+
+          Base64.strict_encode64(BlobPacking.pack(encap.ciphertext, encrypted))
+        end
+      end
+
+      def decrypt(blob)
+        ciphertext, encrypted = BlobPacking.unpack(Base64.strict_decode64(blob))
+
+        HybridKem.open(@pq_alg_name) do |hybrid|
+          shared_secret = hybrid.decapsulate(ciphertext, @keypair.secret_key)
+          Marshal.load(EnvelopeCipher.new(shared_secret).decrypt(encrypted))
+        end
+      end
+    end
+  end
+end

data/lib/pqc_rails/session/key_manager.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../key_source"
+
+module PqcRails
+  module Session
+    # セッション暗号化用のHybridKemキーペアを、環境変数またはRails credentialsから読み込む。
+    # 実際のfetch/decode処理はKeySource::EnvCredentialsに一本化されており、ここはセッション用の
+    # ENV変数名/credentialsキーを添えて委譲するだけ。
+    #
+    # 鍵ローテーション時は#previous_keypairsが旧鍵世代を返す。PqcCookieStoreはこれを使って
+    # 現行鍵で復号できなかったCookieを旧鍵で試す。セッションはDBと違い自然に失効するため、
+    # ロールバック期間(概ね最長セッション有効期限)を過ぎたら運用側がPREVIOUS_ENV_VARを
+    # 空にすれば旧鍵は自動的に無効化される。
+    module KeyManager
+      ENV_VAR = "PQC_SESSION_KEY"
+      PREVIOUS_ENV_VAR = "PQC_SESSION_PREVIOUS_KEYS"
+      CREDENTIALS_KEY = :pqc_session_key
+      PREVIOUS_CREDENTIALS_KEY = :pqc_session_previous_keys
+
+      module_function
+
+      def keypair
+        key_source.current_keypair
+      end
+
+      def previous_keypairs
+        key_source.previous_keypairs
+      end
+
+      def encode(keypair) = KeySource.encode(keypair)
+      def decode(encoded) = KeySource.decode(encoded)
+
+      def key_source
+        KeySource::EnvCredentials.new(
+          env_var: ENV_VAR, previous_env_var: PREVIOUS_ENV_VAR,
+          credentials_key: CREDENTIALS_KEY, previous_credentials_key: PREVIOUS_CREDENTIALS_KEY,
+          label: "session"
+        )
+      end
+    end
+  end
+end

data/lib/pqc_rails/session/pqc_cookie_store.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "action_dispatch"
+require_relative "encryptor"
+require_relative "key_manager"
+
+module PqcRails
+  module Session
+    # ActionDispatch::Session::CookieStoreを継承し、Railsのsecret_key_baseによる
+    # AES暗号化(signed_or_encryptedクッキージャー)を使わず、HybridKem(PQC)で
+    # セッション内容そのものを暗号化する。
+    #
+    # set_cookie/get_cookieはCookieStoreがRailsの暗号化クッキージャーへの委譲点として
+    # 用意しているprivateな拡張点(Rails 7.1〜8.1で同一シグネチャ)。ここを上書きして
+    # 生のcookie_jar(署名・暗号化なし)に対してEncryptorで暗号化した文字列を直接書き込む。
+    # AEAD(AES-256-GCM)が改竄検知も兼ねるため、Railsの署名は不要。
+    #
+    # 鍵ローテーション対応: 書き込みは常に現行鍵(@encryptor)のみを使う。読み込みは
+    # 現行鍵で失敗した場合、previous_keypairs(鍵ローテーション前の旧鍵)で順に再試行する。
+    # previous_keypairsはDB側のようにprevious:機構で永続する必要はなく、ローテーション後
+    # 発行済みの旧セッションCookieが自然に失効するまでの一時的な設定という位置づけ。
+    class PqcCookieStore < ActionDispatch::Session::CookieStore
+      def initialize(app, options = {})
+        keypair = options.delete(:keypair) || KeyManager.keypair
+        previous_keypairs = options.delete(:previous_keypairs) || KeyManager.previous_keypairs
+        pq_alg_name = options.delete(:pq_alg_name) || Encryptor::DEFAULT_PQ_ALG_NAME
+        @encryptor = Encryptor.new(keypair, pq_alg_name: pq_alg_name)
+        @previous_encryptors = previous_keypairs.map { |kp| Encryptor.new(kp, pq_alg_name: pq_alg_name) }
+        super(app, options)
+      end
+
+      private
+
+      def set_cookie(request, _session_id, cookie)
+        cookie[:value] = @encryptor.encrypt(cookie[:value])
+        request.cookie_jar[@key] = cookie
+      end
+
+      # 現行鍵→旧鍵世代の順に復号を試す(鍵ローテーション対応)。全て失敗、または
+      # そもそもCookieが無い場合はnilを返し、改竄・不正なCookieと同様に空セッションとして扱う。
+      # Railsの署名/暗号化クッキージャーが復号失敗時にnilを返す挙動に揃えている。
+      def get_cookie(request)
+        raw = request.cookie_jar[@key]
+        return nil if raw.nil?
+
+        [@encryptor, *@previous_encryptors].each do |encryptor|
+          return encryptor.decrypt(raw)
+        rescue StandardError
+          next
+        end
+
+        nil
+      end
+    end
+  end
+end