mcpField
P
pkinative MCP — X.509, CMS, OCSP, time-stamps and PKCS#12 without a key byte leaving

pkinative MCP — X.509, CMS, OCSP, time-stamps and PKCS#12 without a key byte leaving

ローカル
github.comセキュリティ02 週間前に更新
リポジトリ公式サイト

pkinative MCP — X.509, CMS, OCSP, time-stamps and PKCS#12 without a key byte leaving について

pkinative-mcpは、証明書関連データの検査、検証、作成を行う開発者やセキュリティチーム向けのPKIサーバーです。TypeScriptエンジンはネットワークに接続せず、秘密鍵のバイト列も返しません。

主な機能

  1. 01X.509証明書とCSRの検査
  2. 02証明書パスと失効状態の検証
  3. 03証明書、CSR、署名の作成
  4. 04ASN.1、PEM、OIDのデコードとエンコード
  5. 05PKCS#8とPKCS#12鍵の安全な読み込み

活用シーン

  1. 01証明書チェーンとホスト名の確認
  2. 02CRLとOCSP応答の検査
  3. 03証明書リクエストとタイムスタンプリクエストの作成
  4. 04PKIの調査時におけるASN.1構造のデコード

MCP 対応

証明書、CSR、CRL、OCSP、CMS、タイムスタンプ、エンコード操作向けに、34個のPKIツールと7個のプロンプトをMCPクライアントに提供します。ネットワークアクセスはなく、秘密鍵のバイト列も返しません。

設定

ローカルサーバーの設定はどのクライアントでも共通です。コピーしてクライアントの MCP 設定ファイルに貼り付けてください。

mcp.json · 共通設定
{
  "mcpServers": {
    "nizoka-pkinative": {
      "command": "npx",
      "args": [
        "-y",
        "pkinative-mcp"
      ],
      "env": {
        "PKINATIVE_MCP_OUTPUT_DIR": "<PKINATIVE_MCP_OUTPUT_DIR>",
        "PKINATIVE_MCP_CACHE_DIR": "<PKINATIVE_MCP_CACHE_DIR>",
        "PKINATIVE_MCP_PORT": "<PKINATIVE_MCP_PORT>",
        "PKINATIVE_MCP_HTTP_TOKEN": "<PKINATIVE_MCP_HTTP_TOKEN>",
        "PKINATIVE_MCP_PASSWORD": "<PKINATIVE_MCP_PASSWORD>",
        "PKINATIVE_MCP_AT": "<PKINATIVE_MCP_AT>",
        "PKINATIVE_MCP_MAX_INPUT_BYTES": "<PKINATIVE_MCP_MAX_INPUT_BYTES>",
        "PKINATIVE_MCP_MAX_KDF_ITERATIONS": "<PKINATIVE_MCP_MAX_KDF_ITERATIONS>",
        "PKINATIVE_MCP_MAX_PATHS_EXPLORED": "<PKINATIVE_MCP_MAX_PATHS_EXPLORED>"
      }
    }
  }
}
起動コマンドnpx -y pkinative-mcp
設定が必要な環境変数
PKINATIVE_MCP_OUTPUT_DIRAbsolute path of the one sandbox directory: path inputs are read from it and outputMode='file' outputs are written under it (never overwritten; the real path of every file read and of every parent written must stay inside — a planted symlink or junction is SECURITY_VIOLATION). Key-bearing files (.key .p8 .p12 .pfx) are read by the key tools only, never written, never served as resources. Unset: every tool works on inline PEM / base64 only.
PKINATIVE_MCP_CACHE_DIROpt-in content-addressed response cache directory (SHA-256 keyed, 1h TTL, 256 MiB LRU, plaintext at rest). Never caches path inputs, file output, a call carrying a password or a signer, a clock-dependent instant, a random serial or nonce, describe_engine or draft_governance_issue.
PKINATIVE_MCP_PORTServe Streamable HTTP on this loopback port (POST /mcp) instead of stdio (MCP 2026-07-28, stateless, legacy fallback). Unauthenticated unless PKINATIVE_MCP_HTTP_TOKEN is set.
PKINATIVE_MCP_HTTP_TOKENシークレットOpt-in bearer token for the HTTP transport (>= 16 chars, no whitespace; a weaker value refuses to start). When set, /mcp requires 'Authorization: Bearer <token>' or answers 401. Compared constant-time, never logged.
PKINATIVE_MCP_PASSWORDシークレットOperator-side password of the encrypted PKCS#8 key or PKCS#12 file the tools open (keeps the secret out of the model transcript). Exclusive with the per-call password input (both at once is VALIDATION_ERROR). Never logged; only its presence is reported at startup.
PKINATIVE_MCP_ATPinned instant (ISO 8601 or epoch milliseconds) every omitted at / notBefore / signingTime falls back to, for reproducible verdicts and artefacts. Unset: the wall clock (a clock-dependent result is never cached). An invalid value refuses to start.
PKINATIVE_MCP_MAX_INPUT_BYTESOperator ceiling for limits.maxInputBytes and the decoded size of one PKI object (default 67108864 = 64 MiB, the engine default). Integer >= 1024, read once at startup; an invalid value refuses to start. A per-call value above it is refused with LIMIT_CEILING_EXCEEDED.
PKINATIVE_MCP_MAX_KDF_ITERATIONSOperator ceiling for limits.maxKdfIterations and limits.maxPkcs12KdfIterations (default 10000000, the engine default): the CPU bound of a hostile PBES2 key or PKCS#12 file. Integer >= 1, read once at startup; an invalid value refuses to start.
PKINATIVE_MCP_MAX_PATHS_EXPLOREDOperator ceiling for limits.maxPathsExplored (default 1000, the engine default): the RFC 5280 section 6 path-building work bound. Integer >= 1, read once at startup; an invalid value refuses to start.

ローカルサーバーにはマシン上の実行環境（Node.js 18 以上など）が必要です。設定ファイルの場所はクライアントごとに異なります。

パッケージ
npmpkinative-mcp1.0.0

ツール

34

掲載時のツール一覧 · 2 週間前に更新

パラメーター型必須説明
modeenumはい'decode' は PEM テキスト内のブロックを一覧表示し、extractIndex で1つを抽出します。'encode' は DER バイト列を1つの PEM ブロックに包みます。decode | encode
inputobjectはいPEM テキスト（decode：pem または PEM ファイルへのパス）または DER バイト列（encode：derBase64 または DER ファイルへのパス）：pem / derBase64 / path のうち、ちょうど1つを指定してください。
input.pemstringいいえRFC 7468 PEM テキスト（-----BEGIN で始まります）。
input.pathstringいいえPKINATIVE_MCP_OUTPUT_DIR サンドボックス内にある PEM / DER ファイルの相対パス（キャッシュされません）。
input.derBase64stringいいえbase64 形式の DER バイト列。指定は1回のみ（PEM テキストではありません）。
labelstringいいえdecode：このラベルを持つブロックのみを一覧表示します。encode：ブロックのラベル（必須。例：'CERTIFICATE'）。大文字と数字で構成し、単語は半角スペース1つで区切ります。秘密鍵のラベルは拒否されます（SECURITY_VIOLATION）。
fieldsarrayいいえverbosity の適用後に保持するドットパス（配列では各要素に適用）。一致しないパスは _meta.unmatchedFields に格納されます。
limitsobjectいいえこの呼び出しで pkinative の名前付きセキュリティ制限22項目を引き上げます（信頼できる入力のみ。指定されていないキーにはエンジンのデフォルト値が適用されます）。オペレーター上限（PKINATIVE_MCP_MAX_INPUT_BYTES、PKINATIVE_MCP_MAX_KDF_ITERATIONS、PKINATIVE_MCP_MAX_PATHS_EXPLORED）を超える値は LIMIT_CEILING_EXCEEDED になります。デフォルト値と上限は describe_engine に一覧表示されます。
limits.maxDepthintegerいいえ構築された値のネストの深さ。デフォルトは64です。
limits.maxNodesintegerいいえ1つの入力からデコードする値の数。デフォルトは200000です。
limits.maxOidBytesintegerいいえ1つの OBJECT IDENTIFIER の内容の長さ。デフォルトは256です。
limits.maxPoliciesintegerいいえ1つの拡張に含まれるポリシーまたはポリシーマッピングの数。デフォルトは1024です。
limits.maxPemBlocksintegerいいえ1つの PEM テキストから読み取るブロック数。デフォルトは10000です。
limits.maxAttributesintegerいいえ1 つの属性セットの属性。デフォルトは 256。
limits.maxExtensionsintegerいいえ1 つの証明書またはリクエストの拡張。デフォルトは 256。
limits.maxInputBytesintegerいいえ1 つの DER 入力のサイズ、または 1 つの PEM テキストの長さ。デフォルトは 67108864。
limits.maxPkcs12Bagsintegerいいえ1 つの PKCS#12 から読み取る SafeBags の数。すべての SafeContents が対象。デフォルトは 4096。
limits.maxBerSegmentsintegerいいえ1 つの BER 構成文字列から連結されるセグメント数。デフォルトは 10000。
limits.maxChainLengthintegerいいえ1 つの認証パスに含められる証明書数。デフォルトは 10。
limits.maxPolicyNodesintegerいいえRFC 5280 valid_policy_tree の有効ノード数。デフォルトは 4096。
limits.maxSignerInfosintegerいいえ1 つの SignedData の署名者数。デフォルトは 64。
limits.maxGeneralNamesintegerいいえ1 つのフィールドの GeneralName エントリー数。デフォルトは 10000。
limits.maxIntegerBytesintegerいいえbigint に変換する 1 つの INTEGER の内容長。デフォルトは 8192。
limits.maxKdfIterationsintegerいいえ1 回の導出で実行する PBKDF2 の反復回数。デフォルトは 10000000。
limits.maxPathsExploredintegerいいえ1 つのパスの構築中に探索する候補パス数（RFC 5280 §6 の作業上限）。デフォルトは 1000。
limits.maxNameAttributesintegerいいえ1 つの識別名の属性数。デフォルトは 1024。
limits.maxOcspSingleResponsesintegerいいえ1 つの OCSP レスポンスの SingleResponse エントリー数。デフォルトは 256。
limits.maxPkcs12KdfIterationsintegerいいえ1 つの PKCS#12 で必要となる PBKDF2 の総反復回数。デフォルトは 10000000。
limits.maxRevokedCertificatesintegerいいえ1 つの CRL revokedCertificates リストで走査するエントリー数。デフォルトは 1000000。
limits.maxCmsCertificatesAndCrlsintegerいいえ1 つの SignedData が含む証明書および失効エントリー数。デフォルトは 1024。
strictbooleanいいえエンジンの最初の警告を diagnostics[] に記載せず、PKI_STRICT_DIAGNOSTIC エラーに昇格させます。
pemModeenumいいえ'strict'（RFC 7468 に厳密に準拠、デフォルト）または 'lax'（空白、行の長さ、RFC 1421 ヘッダーを許容）。strict | lax
encodingenumいいえ成果物のエンコーディング。decode + extractIndex：'der'（デフォルト、生バイト）、'pem'（厳密な形式で再出力したブロック）、または 'hex'（インラインのみ、≤ 64 KiB）。encode：常に 'pem'（それ以外はすべて VALIDATION_ERROR）。pem | der | hex
verbosityenumいいえ'summary' はスカラー項目のみを保持します（トークン節約）。full | summary
outputModeenumいいえ'base64'（デフォルト）は成果物を埋め込みリソースとしてインラインで返します（≤ 50 MiB）。'file' は PKINATIVE_MCP_OUTPUT_DIR 内に書き込み（上書きなし、≤ 1 GiB）、resource_link を返します。base64 | file
outputPathstringいいえサンドボックス内の相対パス（outputMode='file' の場合のみ）。拡張子はエンコード形式と一致する必要があります（der の場合は .der .crt .cer .csr .crl .p7s .bin …、pem の場合は .pem）。鍵を含む拡張子（.key .p8 .p12 .pfx）は拒否されます。ここでは秘密鍵を書き込みません。
extractIndexintegerいいえdecode：テキスト内の位置がこのインデックスに一致するブロックも、`encoding` 形式の成果物として返します。秘密鍵ブロックは抽出できません（SECURITY_VIOLATION）。
encodingRulesenumいいえ'der'（厳密な X.690 DER、デフォルト）または 'ber'（不定長／非最小長および構造化文字列を許可。レガシー CMS 生成器の出力に対応）。der | ber

詳細

pkinative-mcp

PKI 用 MCP サーバー — X.509 証明書、CSR、CRL、OCSP レスポンス、CMS SignedData、RFC 3161 タイムスタンプの検査と検証、証明書チェーンの構築と検証（RFC 5280 パス検証、名前と用途のチェック、オフラインでの CRL および OCSP による失効確認）、証明書、CSR、CMS 署名、OCSP およびタイムスタンプ要求の作成、PKCS#8 および PKCS#12 の秘密鍵バイトを一切返さずに開く、ASN.1、PEM、OID のデコード — pkinative エンジン（依存関係ゼロ、純粋な TypeScript、すべての署名に Web Crypto を使用、OpenSSL 3 との相互運用性を CI で検証済み）上の 34 個のツールと 7 個のプロンプトを備え、Claude Desktop、Cursor、ChatGPT、およびあらゆる Model Context Protocol クライアントに対応しています。ネットワーク接続は一切行いません。

npm version npm downloads Node version License: MIT CI OpenSSL interoperability MCP pkinative TypeScript OpenSSF Scorecard CodeQL

✨ 特長

pkinative-mcp は、あらゆる MCP ホストに 34 個のツールを 6 つのグループに分けて公開します。種類は結果の形式を示します。読み取りツールは事実を返します（structuredContent。verbosity / fields で投影可能）。判定ツールは valid + reasons[] を返し、否定的な判定でも 決して isError にはなりません。成果物ツールは DER または PEM をインライン、またはサンドボックスに一度だけ出力します。最後の列には、エージェントが処理を分岐する際に使う拒否コードを記載しています（一覧は docs/AGENT_CONTRACT.md を参照）。

エンコーディング
ツール種類機能主な拒否コード
convert_pem読み取りmode: 'decode' は PEM テキスト内のすべてのブロックを一覧表示します（ラベル、DER サイズ、オフセット、SHA-256）。extractIndex を指定すると、そのブロックを DER／PEM／hex 形式で取得できます。mode: 'encode' は、DER 値を1つだけ、label の下に厳密な RFC 7468 ブロックとしてラップします。秘密鍵ブロックは一覧表示されますが、取得されることも生成されることもありません。入力内のどこかに鍵のマテリアルがある場合は拒否されます。SECURITY_VIOLATION、NOT_FOUND、VALIDATION_ERROR、PKI_PEM_UNEXPECTED_LABEL、PKI_PEM_*
resolve_oid読み取り1回の呼び出しでオブジェクト識別子を処理します。name（登録済みの名前、1回あたり ≤ 1000 件）、validate（X.660 の文法を検証し、エラーとしてスローせず結果を返します）、list（エンジンのレジストリをページ分割して表示、200／2000 件）、encode（ドット区切りから hex へ変換。内容または TLV 全体、RELATIVE-OID）、decode（hex からドット区切りの識別子と名前へ変換）。VALIDATION_ERROR、PKI_OID_INVALID、PKI_ASN1_*
compute_fingerprint読み取り正確な DER の fingerprint（デフォルトは SHA-256。SHA-1／384／512 も指定可能）、証明書、CSR、または PUBLIC KEY の公開鍵の識別子である key-id（RFC 5280 §4.2.1.2）、および Ed448 CMS ダイジェストである shake256（outputLength バイト）を計算します。任意のオブジェクトをダイジェスト化できます。入力バイトが返されることはありません。VALIDATION_ERROR、PKI_X509_*、PKI_ASN1_*
decode_asn1読み取り任意の DER の X.690 ノードツリー（encodingRules: 'ber' を指定すると BER）を表示します。オフセット、タグ、プレビュー、OID 名を含み、ノード数は最大 20 000 件です。nodePath でサブツリーを絞り込み、read で型付きリーダーを適用し、reencode: true でノードをアーティファクトとして再エンコードします。秘密鍵または PKCS#12 は拒否されます（ラベルによる判定、または DER の解析結果による判定）。SECURITY_VIOLATION、NOT_FOUND、PKI_ASN1_UNEXPECTED_TAG、PKI_API_MISUSE、PKI_ASN1_*
encode_asn1アーティファクトJSON ノード spec（boolean、integer、bit-string、octet-string、oid、string、time、sequence／set／set-of、explicit／implicit、tlv、der）を、エンジン独自のエンコーダーで DER にエンコードします。決定的な動作で、decode_asn1 の逆の処理を行います。VALIDATION_ERROR（JSON パスを示します）、SECURITY_VIOLATION、PKI_LIMIT_EXCEEDED、PKI_ASN1_*、PKI_OID_INVALID
証明書とリクエスト
ツール種類内容主な拒否コード
inspect_certificate読み取り1つの証明書についての RFC 5280 レポートです。シリアル番号、アルゴリズム、発行者／サブジェクト（RFC 4514 + RDN）、有効期間、公開鍵、デコードされた19種類の拡張（rawExtensions: true を指定すると生データのまま保持）、フィンガープリント、診断情報を返します。extension は1つの拡張を返します。issuer／checkSelfSignature は署名チェックを1回追加しますが、これは信頼性の確認ではありません。NOT_FOUND、PKI_PEM_UNEXPECTED_LABEL、PKI_X509_*、PKI_CRYPTO_ALGORITHM_REFUSED
create_certificate成果物spec（サブジェクト、有効期間、拡張）から X.509 v3 証明書を発行します。signer（PKCS#8 鍵、または抽出不可能な Web Crypto 鍵としてインポートされた PKCS#12 ファイル）で署名します。自己署名 CA 証明書、または証明書／CSR／PUBLIC KEY から発行されたリーフ証明書を作成できます。シリアル番号のデフォルトは 'random' で、バイト列を返す前に発行者に対して検証されます。KEY_MISMATCH、RSA_SCHEME_REQUIRED、KEY_TYPE_REQUIRED、SECRET_REQUIRED、UNSUPPORTED_KEY、VALIDATION_ERROR
encode_x509_structure成果物1つの X.509 構成要素（name、validity、spki、algorithm-identifier、extension(s)、basic-constraints、key-usage、extended-key-usage、subject-alt-name、SKI／AKI、signature-algorithm）を、閉じた spec から決定論的にエンコードします。デフォルトは16進数です。ここでは署名しません。VALIDATION_ERROR（メンバー名を表示）、KEY_TYPE_REQUIRED、SECRET_REQUIRED、RSA_SCHEME_REQUIRED
decode_extension読み取り1つの extnValue の内容（16進数または DER）を、OID に基づいて inspect_certificate と同様にデコードします。critical は種類ごとの RFC 5280 の規則に照らしてチェックされます（拒否ではなく診断です）。PKI_X509_EXTENSION_MALFORMED、VALIDATION_ERROR
check_certificate_name判定RFC 6125 に基づく識別情報の判定です。certificate と host／ip（SAN の dNSName／iPAddress、ワイルドカード、チェーンの名前制約に従うオプトインの CN フォールバック）、または証明書なしの一致形式 presented + reference を指定します。PKI_REASON_NAME_MISMATCH（reasons[] 内）、VALIDATION_ERROR
check_certificate_purpose判定[certificate, ...chain] に沿って、certificate を purpose（serverAuth、clientAuth、codeSigning、emailProtection、timeStamping、ocspSigning、any、または OID）に使用できるかを判定します。restrictIssuers（デフォルトは true）は、CA 自身の EKU を、その CA が発行した証明書に適用します。PKI_REASON_PURPOSE_NOT_PERMITTED（reasons[] 内）、VALIDATION_ERROR
inspect_csr読み取り1つの PKCS#10 リクエストについての RFC 2986 レポートです。サブジェクト、鍵、属性、リクエストされた拡張、challengePassword の有無（内容は決して返しません）を返します。デフォルトでは所持証明（signature.valid）も確認します。PKI_REASON_SIGNATURE_NOT_CHECKED（reasons[] 内）、PKI_X509_*、PKI_PEM_UNEXPECTED_LABEL
create_csr成果物spec（サブジェクト、リクエストする拡張）から PKCS#10 リクエストを作成し、signer で署名します。公開鍵はプレーンな鍵から導出するか、PKCS#12 証明書から取得するか、subjectPublicKey として指定できます。バイト列を返す前に所持証明を検証します。KEY_MISMATCH、RSA_SCHEME_REQUIRED、SECRET_REQUIRED、KEY_TYPE_REQUIRED、VALIDATION_ERROR
パス、CRL、OCSP
ツール種類機能主な拒否コード
verify_certificate_chain判定1 回の呼び出しで信頼性を判定：leaf から candidates を経由していずれかの trustAnchors に至るパスを構築し、すべての署名を検証します。at 時点で RFC 5280 §6 の検証（有効期間、制約、鍵の使用法、名前、ポリシー）を行い、serverName（RFC 6125）と purposes を確認し、ユーザーが指定する CRL／OCSP バイト列から失効状態を確認します（requireRevocation を指定すると、エンドエンティティ証明書の証拠が必須になります）。reasons[] 内の PKI_REASON_*（NO_TRUST_ANCHOR、EXPIRED、NOT_YET_VALID、REVOKED、REVOCATION_UNKNOWN、NAME_MISMATCH、…）、VALIDATION_ERROR
build_certificate_path判定パスの検出のみ：構造上のルールに従い、at 時点で leaf からアンカーに至る中間証明書を特定します。署名は検証しません。valid は常に false で、判定結果は found と structuralReasons です。PKI_REASON_SIGNATURE_NOT_CHECKED（常に）、PKI_REASON_NO_TRUST_ANCHOR
validate_certificate_path判定ユーザーが順序を指定した（最初が leaf）パスを、at 時点でユーザーのアンカーに対して RFC 5280 §6.1 に基づいて検証します。まず各リンクの署名を検証します（checkSignatures: false を指定すると、failingReasons を含む構造上の判定結果が返されます）。失効確認は行いません。PKI_REASON_SIGNATURE_INVALID、PKI_REASON_SIGNATURE_NOT_CHECKED、VALIDATION_ERROR
inspect_crl読み取り1 つの CRL について RFC 5280 §5 に基づくレポートを返します。発行者、更新情報、CRL 番号、差分インジケーター、IDP、エントリー数（すべてをデコードするのではなく、走査して数えます）、拡張を確認できます。find は指定したシリアル番号を検索し、issuer は署名検証を 1 回追加します。VALIDATION_ERROR、PKI_X509_*、PKI_CRYPTO_ALGORITHM_REFUSED
check_crl_revocation判定取得した 1 つのベース crl（および任意の delta）に対し、at 時点で 1 つの certificate を確認します。対象範囲、新鮮さ（staleTolerance）、issuer に対する署名検証、シリアル番号の検索を行います。issuer に対する署名を検証できない delta は適用されず、delta に PKI_REASON_REVOCATION_UNKNOWN を含む valid: false が返されます。reasons[] 内の PKI_REASON_REVOKED、PKI_REASON_REVOCATION_UNKNOWN、VALIDATION_ERROR（deltaCRLIndicator のない delta）
create_ocsp_requestアーティファクトissuer に基づく certificate 用の DER OCSPRequest（RFC 6960）を生成します。CertID には SHA-1（デフォルト）または SHA-256 を使用し、RFC 8954 の nonce（'random' または 16 進数）と certIdOnly を指定できます。応答側にバイト列を POST するのはユーザーです。summary.nonceHex／certIdHex は応答と一致します。VALIDATION_ERROR
inspect_ocsp_response読み取り1 つの応答について RFC 6960 に基づくレポートを返します。ステータス、レスポンダー ID、producedAt、すべての SingleResponse（CertID、ステータス、更新情報）、拡張、埋め込み証明書、nonce の有無を確認できます。responder は署名検証を 1 回追加します。PKI_*（PKI_ASN1_*、PKI_X509_*）、VALIDATION_ERROR
check_ocsp_status判定1 つの certificate に対する 1 つの response を確認します。issuer から CertID を再計算し、署名を検証し（responder、埋め込み証明書、または issuer を使用）、署名者が認可されていること（RFC 6960 §4.2.2.2）、ステータス、at 時点での新鮮さ、nonce（nonce、requireNonce）を確認します。reasons[] 内の PKI_REASON_REVOKED およびその他の PKI_REASON_*、VALIDATION_ERROR
CMS とタイムスタンプ
ツール種類内容主な拒否コード
sign_cms成果物content（attached または detached）または事前計算済みの contentDigest、1 つの signer（PKCS#8 鍵または PKCS#12）、certificate、chain、crls から RFC 5652 SignedData を生成し、解析後に埋め込みます。署名属性（contentType、messageDigest、signingTime、SigningCertificateV2、CMSAlgorithmProtection）は常に書き込まれ、バイト列を返す前に署名者の証明書に対して検証されます。KEY_MISMATCH、RSA_SCHEME_REQUIRED、SECRET_REQUIRED、VALIDATION_ERROR、PKI_API_MISUSE、ENGINE_ERROR
verify_cms判定SignedData に対する一度の呼び出しによる判定です。すべての署名者について、署名属性、コンテンツダイジェスト（埋め込みのもの、または content / contentDigest）、署名、at 時点での trustAnchors までの証明書チェーン、すべてのカウンタータイムスタンプ、指定されたバイト列とメッセージに含まれる失効情報を検証します。atTimeStamp: true は長期検証を行います。reasons[] に含まれる PKI_REASON_*（署名者ごとの理由も含みます。intact で改ざんの有無と信頼性を区別します）、PKI_ASN1_TRAILING_DATA、VALIDATION_ERROR
inspect_cms読み取りRFC 5652 のレポートです。コンテンツの種類と長さ、ダイジェストアルゴリズム、埋め込み証明書、CRL / OCSP の数、すべての署名者（識別子、アルゴリズム、申告された署名時刻、属性、タイムスタンプの数、カウンタータイムスタンプが刻印する署名値）を示します。signerCertificate を指定すると、signerIndex が示す署名者の鍵を追加で確認します。NOT_FOUND（signerCertificate を指定し、signerIndex が最後の署名者を超えている場合）、PKI_ASN1_TRAILING_DATA、PKI_*
amend_cms成果物署名済みメッセージに後から正当に加えられる唯一の編集です。署名者 signerIndex に対し、add-unsigned-attribute（16 進数で指定する DER Attribute）または add-timestamp（TimeStampToken または TimeStampResp 全体）を追加します。署名済みのオクテットはすべて変更されません。書き込み前に、トークンのインプリントが署名値と一致することを確認します。VALIDATION_ERROR（data.detail が PKI_REASON_TSP_IMPRINT_MISMATCH）、NOT_FOUND、PKI_API_MISUSE
create_timestamp_request成果物ご自身で TSA に POST する RFC 3161 TimeStampReq です。data または digestHex（SHA-256 / 384 / 512）のインプリント、nonce（'random'、10 進数または 16 進数）、policy、certReq を指定します。VALIDATION_ERROR（ダイジェストの長さが不正な場合）
inspect_timestamp読み取りTimeStampResp、TimeStampToken、または TSTInfo 単体（自動検出、または as で指定）を解析し、ステータス、ポリシー、インプリント、シリアル番号、genTime、精度、nonce、記載された TSA 名、CMS エンベロープを示します。解析しても何も証明されません。PKI_*、PKI_STRICT_DIAGNOSTIC（strict: true の場合）
verify_timestamp判定token または response を、ご自身がタイムスタンプの対象として指定した内容（request、data、または digestHex の少なくとも 1 つ）、TSA の署名、at 時点での指定アンカーまでの証明書チェーン（critical な timeStamping EKU を含む）、指定されたバイト列から得られる失効情報に照らして判定します。PKI_REASON_TSP_IMPRINT_MISMATCH、PKI_REASON_TSP_NOT_GRANTED、reasons[] に含まれるその他の PKI_REASON_*、VALIDATION_ERROR
秘密鍵と PKCS#12
ツール種類説明主な拒否コード
inspect_private_key読み取りパスワードを指定せずに PKCS#8 キーを記述します（PKINATIVE_MCP_PASSWORD が未設定の場合。この変数は、パスワードを受け付けるすべてのツールでパスワードとして扱われます）。形式、種類、楕円曲線、アルゴリズム、暗号化されたキーの PBES2 パラメーター（または pkinative が拒否するレガシー方式）を確認できます。tryImport: true を指定すると、抽出不可能な Web Crypto キーとしてインポートし、ハンドルを報告します。結果にキーのバイト列が含まれることはありません。SECRET_REQUIRED, KEY_TYPE_REQUIRED, RSA_SCHEME_REQUIRED, PKI_CRYPTO_DECRYPTION_FAILED, PKI_KEY_ENCRYPTION_UNSUPPORTED
inspect_pkcs12読み取りパスワードを指定せずに .p12 / .pfx を記述します（オペレーターの PKINATIVE_MCP_PASSWORD もパスワードとして扱われるため、未設定にする必要があります）。MAC の構成（PBMAC1 またはレガシーな RFC 7292 MAC）、すべての SafeContents とその方式、および暗号化されていないもののバッグを確認できます。パスワードを指定すると、macVerified と opened（すべてのバッグの許可リスト形式のビュー）を返します。暗号化された SafeContents に対して誤ったパスワードを指定すると、PKI_CRYPTO_DECRYPTION_FAILED になります。PKI_CRYPTO_DECRYPTION_FAILED, PKI_KEY_MAC_UNSUPPORTED, PKI_KEY_ENCRYPTION_UNSUPPORTED
open_pkcs12判定1 回の呼び出しで PKCS#12 を開きます。MAC を検証し、PBES2 の SafeContents を復号し、すべてのキーを直接、抽出不可能な Web Crypto キーにアンラップして記述します（エクスポートはしません）。証明書を解析し、CRL を数えます。exportCertificates: true を指定すると、証明書と CRL の PEM バンドルを追加します。キーは追加しません。SECRET_REQUIRED；reasons[] 内：PKI_REASON_PKCS12_MAC_MISMATCH, PKI_REASON_PKCS12_ENCRYPTION_UNSUPPORTED, PKI_REASON_PKCS12_INTEGRITY_UNVERIFIED, PKI_REASON_PKCS12_RSA_SCHEME_UNSPECIFIED
メタ
ツール種類説明主な拒否コード
describe_engineエンジンオフラインの事前確認です。バージョン、ホストの Web Crypto 機能、エンジンの 22 個のデフォルト上限、オペレーターの上限、すべてのサーバー上限、サンドボックス／キャッシュ／ピン留めされた瞬時状態、57 個の PKI_*／43 個の PKI_REASON_*／97 個の PKI_DIAG_* の語彙、21 個のラッパーコード、ドクトリンによる拒否、および意図的に公開されていないエンジンの機能を確認できます。network は常に 'none' です。キャッシュされることはありません。VALIDATION_ERROR
explain_code説明このサーバーが出力できる任意のコードを、pkinative v1.0.0 タグに同梱されたレジストリに基づいて説明します（分類、標準、CWE、対処法、そのコードを解消する MCP 入力）。list: true を指定すると、1 つの語彙を列挙します。NOT_FOUND
draft_governance_issueガバナンスpkinative、pkinative-cli、または pkinative-mcp 向けの GitHub イシュードラフトとコンプライアンスレポートをローカルに作成します。送信はされません。人間が自身の ID で提出します。GOVERNANCE_VIOLATION, MISSING_OUTPUT_PATH, INVALID_EXTENSION, OUTPUT_EXISTS, SECURITY_VIOLATION

すべてのツールが保証すること：

  • 🌐 ネットワーク接続は一切ありません — CRL／OCSP／AIA／TSA の取得、テレメトリー、GitHub、引数から指定された URL、オペレーターが設定可能なエンドポイントはありません。失効証拠とタイムスタンプトークンは入力です。create_ocsp_request と create_timestamp_request は、お客様が転送するバイト列を生成します。すべてのツールは openWorldHint: false を通知します。
  • 🔑 鍵のバイト列が外部に出ることはありません — 署名鍵は抽出不可能な Web Crypto ハンドルです。鍵／PKCS#12 のレポートはすべて許可リストに基づく表示です。鍵を含むファイル（.key .p8 .p12 .pfx）は書き込まれることも、リソースとして提供されることもありません。convert_pem、decode_asn1、encode_asn1 は秘密鍵のマテリアルを拒否します。鍵の生成もエクスポートもできません。
  • 🧭 判定はレポート、エラーは拒否を示します — 否定的な判定は valid: false とエンジンの PKI_REASON_* コード（43 種類）を含む reasons[] で表されます。isError は、エンジンが拒否する入力（57 種類の PKI_* コードのいずれか。data.errorClass と対処方法を添えてそのまま返されます）、またはラッパーによる拒否（21 種類のコード。それぞれに対処方法があります）に限られます。メッセージではなく、コードに基づいて分岐してください。
  • 📐 隠さずに示すポリシー — SHA-1 は allowSha1: true の場合に限り使用できます。RSA には明示的な rsaScheme（'pkcs1' | 'pss'。デフォルトなし）が必要です。PBES2 と PBMAC1 のみを使用できます（従来の RC2／3DES PKCS#12 は拒否され、OpenSSL 3.4 による変換方法が提示されます）。DSA と ML-DSA は解析されますが、検証は行われません。診断（97 種類の PKI_DIAG_* コード）は、strict: true でない限りエラーではありません。エンジンの 22 種類の制限は呼び出しごとに引き上げられますが、オペレーターの上限を超えることはありません。
  • 🪙 トークン消費を節約 — 読み取りツールと判定ツールは verbosity: 'summary' と fields: [...] を受け付けます。成果物は埋め込み resource ブロックまたは resource_link として一度だけ返され、structuredContent に重複して含まれることはありません。
  • 🔁 必要に応じて再現可能 — at、notBefore、signingTime、serialNumber、nonce を固定する（または PKINATIVE_MCP_AT でオペレーターが時刻を固定する）と、成果物や判定は入力の純粋関数になります。structuredContent.sha256 がその証明です（docs/guides/REPRODUCIBLE.md）。
  • 🧪 OpenSSL 3 による判定 — サーバーが書き込むすべての成果物は、CI で OpenSSL 3.x により読み戻されます（準拠した成果物 23 件、拒否されるカナリア 5 件、コマンドファミリー 12 種類）。Linux と Windows の両方でブロックされます。

成果物を生成するすべてのツールは、2 種類の出力モードと 3 種類のエンコーディングに対応しています。

  • base64 (デフォルト) — 成果物は埋め込み resource コンテンツブロックとして一度だけ返されます（PEM は text、DER は blob。MIME タイプは application/pkix-cert、application/pkcs10、application/pkcs7-signature、application/pkix-crl、application/ocsp-request、application/timestamp-query など）。structuredContent には { mode, encoding, sizeBytes, sha256, summary, diagnostics } が含まれます。encoding: 'hex' の場合、バイト列は代わりに structuredContent.hex に格納されます（インラインのみ、最大 64 KiB）。
  • file — 成果物は PKINATIVE_MCP_OUTPUT_DIR で設定されたサンドボックス内に書き込まれます（排他的に作成され、上書きされることはありません → OUTPUT_EXISTS。最大 1 GiB）。結果には resource_link が含まれます。この変数が設定されていない場合、ファイル I/O は無効です。絶対パス、パストラバーサル、NUL バイト、鍵を含む拡張子または不明な拡張子、実際のパスがサンドボックスの外に出るシンボリックリンクまたはジャンクションはすべて拒否されます。同じサンドボックスがすべての path 入力に使用されるため、create_csr → create_certificate → verify_certificate_chain の一連の処理ではバイト列を再送する必要がありません。

トークン消費を節約する読み取り。 読み取りツールと判定ツール（および describe_engine、explain_code）は、次の 2 つの省略可能な入力を受け付けます。

  • verbosity: 'summary' — コンパクトなスカラー値のみの判定です。例：verify_certificate_chain → { valid, reasonCodes, pathLength, evaluatedAt, revocationEvidence, diagnosticCount }、inspect_certificate → サブジェクト、発行者、シリアル番号、有効期間、鍵、拡張機能の種類。
  • fields: ['a', 'b.c'] — 構造化された結果から、指定したドットパスのフィールドを抽出します（最大16個。配列の場合は各要素に適用されます）。verbosity の後に適用されます。一致するものがなかったパスは、ネストされたパスも含めて省略され、_meta.unmatchedFields に報告されます（_meta.availableFields も含まれます）。__proto__、constructor、prototype のセグメントを含むパスは VALIDATION_ERROR になります。

「このサーバー証明書を信頼できるか？」を最小限の入力で確認する例：verify_certificate_chain に対して { "leaf": {…}, "trustAnchors": [{…}], "at": "2027-01-01T00:00:00Z", "serverName": { "host": "example.test" }, "verbosity": "summary", "fields": ["valid", "reasonCodes"] } を指定します。

このサーバーには7つのMCPプロンプトも用意されています — governance_contract、draft_issue_workflow、verify_before_trust、issue_certificate、sign_and_timestamp、offline_revocation、open_keys_safely — また、サンドボックス内の秘密情報以外のすべてのファイルを pkinative://output/{+path} リソースとして公開します。

pkinative を選ぶ理由

pkinative-mcp は、基盤エンジンのすべての保証を引き継ぎます。

  • エンジンに実行時依存関係はありません — 純粋なTypeScriptで、ネイティブバインディングは不要です。すべての署名にWeb Cryptoを使用するため、秘密情報に依存する演算がJavaScriptで実行されることはありません（このサーバーが追加するのはMCP SDKとzodのみで、実行時依存関係は合計3つです）。
  • RFC 5280のパス検証（構築、§6.1の検証、名前制約、ポリシー）、RFC 6125の名前、RFC 6960のOCSP、RFC 5652のCMS、RFC 3161のタイムスタンプ、RFC 2986のCSR、PBES2を使用するRFC 5958 / 8018のPKCS#8、PBMAC1を使用するRFC 7292 / 9579のPKCS#12、厳格なX.690 DER（BERはオプトイン）。
  • すべてのパーサーループにCWEタグ付きの名前付き制限を22個適用 — 明示的な入力によってのみ引き上げられ、暗黙に変更されることはありません。
  • 固定された語彙 — PKI_* エラーコード57個、PKI_REASON_* 判定理由43個、PKI_DIAG_* 診断97個をv1.0.0タグの状態でベンダーに含め、そのまま渡します。
  • 対応しないこと： 鍵生成、鍵のエクスポート、PKCS#8 / PKCS#12 / CRL / OCSPレスポンス / タイムスタンプレスポンスの書き出し、DSA / ML-DSAの検証、ネットワークアクセスは一切ありません。

🚀 インストール

# Run directly with npx (recommended for MCP clients)
npx -y pkinative-mcp

# Or install globally
npm install -g pkinative-mcp
pkinative-mcp

要件：Node.js ≥ 22（エンジンの最低要件は ^22.22.2 || ^24.14.1 || >=25.8.2 です。describe_engine.capabilities.nodeFloorSatisfied で確認できます）。ソースから実行する場合：git clone https://github.com/Nizoka/pkinative-mcp.git && cd pkinative-mcp && npm ci --ignore-scripts && npm run build && node dist/cli.js。

⚙️ 設定

Claude Desktop

~/Library/Application Support/Claude/claude_desktop_config.json（macOS）または %APPDATA%\Claude\claude_desktop_config.json（Windows）を編集します。

{
  "mcpServers": {
    "pkinative": {
      "command": "npx",
      "args": ["-y", "pkinative-mcp"],
      "env": {
        "PKINATIVE_MCP_OUTPUT_DIR": "/Users/you/Documents/mcp-pki"
      }
    }
  }
}
Claude Code

プロジェクトのルートにある .mcp.json（リポジトリには dist/cli.js からビルド済みサーバーを起動する設定が含まれています）。

{
  "mcpServers": {
    "pkinative": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "pkinative-mcp"],
      "env": { "PKINATIVE_MCP_OUTPUT_DIR": "${CLAUDE_PROJECT_DIR}/.mcp-pki" }
    }
  }
}
Cursor / Continue / Zed / Windsurf / Cline / Roo Code

stdioサーバーに対応するMCPクライアントであれば、どれでも使用できます。同じ command + args + env の組み合わせを使用してください。Cursorの例（~/.cursor/mcp.json）：

{
  "mcpServers": {
    "pkinative": {
      "command": "npx",
      "args": ["-y", "pkinative-mcp"],
      "env": { "PKINATIVE_MCP_OUTPUT_DIR": "/Users/you/Documents/mcp-pki" }
    }
  }
}

Windsurf / Cline / Roo Codeでは、それぞれのMCP設定ファイル内で同じ形式を使用します。

VS Code

.vscode/mcp.json：

{
  "servers": {
    "pkinative": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "pkinative-mcp"],
      "env": { "PKINATIVE_MCP_OUTPUT_DIR": "${workspaceFolder}/.mcp-pki" }
    }
  }
}
🌐 対応する AI エコシステムとクライアント

pkinative-mcp は MCP ネイティブな環境向けに設計されており、stdio または Streamable HTTP 経由で MCP をサポートするクライアントで動作します。対応クライアントは、Claude Desktop、Claude Code、Cursor、Continue、Zed、Windsurf、Cline、Roo Code、VS Code、ChatGPT（Streamable HTTP）、MCP Inspector、および MCP TypeScript / Python SDK を基盤とするあらゆるクライアントです。このサーバーは独自にソケットを開かないため、エアギャップ環境や外部への通信が制限されたホストでも安全に実行できます。PKI の情報は通常、このような環境に保管されています。

このサーバーは、「native」ファミリーで3番目のサーバーです。pdfnative-mcp（PDF）、zipnative-mcp（ZIP）に続くもので、同じ薄いラッパーアーキテクチャ、サンドボックス、キャッシュ、プロジェクション、ガバナンスの規約、そして人間参加型のルールを採用しています。同じエンジンは、コマンドラインでは pkinative-cli として利用できます。

🔌 MCP プロトコルへの準拠

このサーバーは MCP TypeScript SDK v2（@modelcontextprotocol/server）を基盤とし、MCP 2026-07-28 に対応しています。

  • ステートレスなサービス提供 — server/discover がセッションハンドシェイクに代わり、すべての結果に resultType と _meta の serverInfo エンベロープが含まれます。HTTP では、2026-07-28 対応クライアントは各 POST /mcp リクエストに Mcp-Method / Mcp-Name ヘッダーを付けます。
  • キャッシュヒント — tools/list と prompts/list は ttlMs が24時間の public、server/discover は1時間の public、resources/list / resources/templates/list / resources/read は ttlMs: 0 の private です（サンドボックス内のファイルはホストごとのユーザーデータです）。
  • プロトコルエラー — 不明なツール名を指定した tools/call は、isError の結果ではなく JSON-RPC エラー（-32602、[UNKNOWN_TOOL] Unknown tool: …）になります。不明なリソース URI は、仕様の要件どおり -32602（Invalid params）になります。isError: true は実行失敗の場合にのみ使用されます。
  • レガシーへの自動フォールバック — initialize で開始するクライアントには、SDK がネゴシエートするすべてのリビジョン（レガシーの 2024-10-07、2024-11-05、2025-03-26、2025-06-18、2025-11-25 と、モダンな 2026-07-28）で、stdio と HTTP の両方において SDK のレガシーパスを通じてサービスを提供します。既存のホストに変更はありません。
  • HTTP — POST /mcp のみ対応します。GET / DELETE /mcp は 405 を返します（SSE による再開には非対応で、サーバーはステートレスです）。127.0.0.1 にバインドし、Host / Origin ガードを適用します（許可されていない値には 403 を返します）。PKINATIVE_MCP_HTTP_TOKEN を設定すると、任意でベアラートークンによる制御を追加できます（トークンがない場合は 401 と WWW-Authenticate を返します）。256 MiB を超えるリクエストボディには 413 を返します。
  • stdio — フレーム上限は 256 MiB です。これにより、数 MiB の Base64 CMS メッセージや PKCS#12 を1回の tools/call で送信できます。すべての SDK リリースと同様に、レガシーパスでは initialize より前に送信されたリクエストは、返信なしで破棄されます。
  • 出力スキーマ — すべての structuredContent はツールの outputSchema（2026-07-28 で必須）に準拠することを検証されます。verbosity: 'summary' や fields によるプロジェクションも対象です。読み取りツールと判定ツールはプロジェクション可能なスキーマを宣言します（すべてのプロパティをオプションとし、additionalProperties: false を維持します）。入力スキーマには、ポリシーにより $schema キーワードと $ref を含めません（ホストによっては inputSchema を、未知のキーワードを拒否する関数呼び出し API に転送するためです）。serverInfo には websiteUrl が含まれます。リソーステンプレートは pkinative://output/{+path} です。

tools/call のペイロード（content、structuredContent、isError）は、2026-07-28 のパスとレガシーパスで同一です。tests/http-modern.test.ts でこれを検証し、tests/schema-conformance.test.ts では SDK の JSON Schema 2020-12 バリデーターを使って structuredContent を検証します。

クライアントトランスポートネゴシエートされるプロトコル
Claude Desktop、Cursor、Continue、Zed、Windsurf、Clinestdio従来の initialize（2024-xx / 2025-xx）— 変更なし
ChatGPT およびその他の Streamable HTTP ホストHTTP POST /mcp従来のステートレスな Streamable HTTP — 変更なし
MCP 2026-07-28 クライアント（SDK v2 Client、現行の MCP Inspector）stdio / HTTPserver/discover、キャッシュヒント、_meta エンベロープ

互換性マトリクス — 両方のトランスポートでネゴシエートされる各リビジョンと、それを証明するテスト：

リビジョン時代stdioHTTP POST /mcp証明するテスト
2024-10-07従来の initialize✓✓tests/protocol-revisions.test.ts
2024-11-05従来の initialize✓✓tests/protocol-revisions.test.ts
2025-03-26従来の initialize✓✓tests/protocol-revisions.test.ts
2025-06-18従来の initialize✓✓tests/protocol-revisions.test.ts、tests/http-transport.test.ts
2025-11-25従来の initialize✓✓tests/protocol-revisions.test.ts、tests/cli-stdio.test.ts、tests/autonomy.test.ts
2026-07-28モダン（server/discover、_meta エンベロープ、キャッシュヒント）✓✓（+ ベアラートークン）tests/stdio-modern.test.ts、tests/http-modern.test.ts、tests/autonomy.test.ts
環境変数

9つすべてが server.json で宣言され、起動時に一度だけ読み込まれます。不正な値（1〜65535の範囲外の PKINATIVE_MCP_PORT、相対パスの PKINATIVE_MCP_OUTPUT_DIR、不正な形式の日時または上限）が指定されている場合、起動を拒否し、暗黙のフォールバックは行いません。ログに記録されるのは、シークレットが存在するかどうかのみです。

変数既定値意味
PKINATIVE_MCP_OUTPUT_DIR(未設定)唯一のサンドボックスディレクトリの絶対パスです。すべての path 入力（PKI オブジェクト、コンテンツ、鍵）はここから読み込まれ、outputMode: 'file' の出力はここに書き込まれます（排他的に作成され、上書きされることはありません）。読み込むすべてのファイルの実パスと、書き込み先のすべての親ディレクトリの実パスが、このディレクトリ内にとどまる必要があります。サンドボックス内に仕掛けられたシンボリックリンクまたはジャンクションは、読み込み側と書き込み側の両方で SECURITY_VIOLATION になります。鍵を含むファイル（.key .p8 .p12 .pfx）は鍵ツールのみが読み込み、書き込まれることも、リソースとして提供されることもありません。また、resources/* は名前にかかわらず、内容から鍵素材を判別して拒否します。未設定の場合、すべてのツールはインラインの PEM／base64 のみで動作します。
PKINATIVE_MCP_CACHE_DIR(未設定)オプトイン方式のコンテンツアドレス指定レスポンスキャッシュです（SHA-256 をキーとし、有効期間 1 時間、LRU で 256 MiB、保存時は平文。キーはツール API、パッケージ、エンジンのバージョンごとに名前空間を分けます）。path 入力、ファイル出力、password または signer を伴う呼び出し、'random' のシリアル番号または nonce、'now' またはピン留めされていない時刻、describe_engine、draft_governance_issue はキャッシュしません。また、PKINATIVE_MCP_PASSWORD が設定されている間は、パスワードを受け付けるツールをキャッシュしません。キャッシュがヒットすると _meta.cached: true が含まれます。
PKINATIVE_MCP_PORT(未設定 → stdio)有効なポート（1～65535）を設定すると、stdio の代わりに http://127.0.0.1:<port>/mcp で Streamable HTTP を提供します。それ以外の値では起動を拒否します。最大 256 MiB のリクエストボディを受け付けます（それを超えると 413）。ループバックのみで、DNS リバインディングを防止します（外部の Host／Origin は 403）。GET／DELETE は 405 になります。PKINATIVE_MCP_HTTP_TOKEN が設定されていない場合、認証はありません。他のローカルプロセスからエンドポイントにアクセスできます。
PKINATIVE_MCP_HTTP_TOKEN(未設定)(シークレット) HTTP トランスポート用のオプトイン方式のベアラートークンです（16 文字以上、空白なし。条件を満たさない値では起動が中止されます）。設定すると、すべての /mcp リクエストに Authorization: Bearer <token> が必要です。そうでない場合は 401 と WWW-Authenticate: Bearer realm="pkinative-mcp" を返します（認証情報が送信された場合のみ error="invalid_token" を付加します — RFC 6750 §3.1）。定時間比較を行い、ログには記録されません。
PKINATIVE_MCP_PASSWORD(未設定)(シークレット) ツールが開く、暗号化された PKCS#8 鍵または PKCS#12 ファイルのオペレーター側のパスワードです。これにより、シークレットがモデルのトランスクリプトに含まれません。パスワードを受け付けるすべてのツール（inspect_private_key、inspect_pkcs12、open_pkcs12、署名ツールの signer）のパスワードとして使用されます。「パスワードなしで記述」するには、未設定にする必要があります。呼び出しごとの password 入力とは併用できません（両方を指定すると VALIDATION_ERROR）。ログには記録されず、起動時には設定されているかどうかだけが報告されます。
PKINATIVE_MCP_AT(未設定 → 実時間)結果と生成物を再現可能にするために、at／notBefore／signingTime が省略された場合にフォールバックする、固定された時刻です（ISO 8601 またはエポックミリ秒）。未設定の場合は実時間が使われ、時刻に依存する結果はキャッシュされません。
PKINATIVE_MCP_MAX_INPUT_BYTES67108864（64 MiB）limits.maxInputBytes と、1 つの PKI オブジェクトのデコード後のサイズに対するオペレーター側の上限です（エンジンの既定値）。1024 以上の整数を指定します。呼び出しごとの値がこれを超えると LIMIT_CEILING_EXCEEDED になります。上限をエンジンの既定値より低くすると、既定値が暗黙に引き下げられます。
PKINATIVE_MCP_MAX_KDF_ITERATIONS10000000limits.maxKdfIterations と limits.maxPkcs12KdfIterations に対するオペレーター側の上限です（エンジンの既定値）。敵対的な PBES2 鍵または PKCS#12 ファイルによる CPU 負荷の上限となります。1 以上の整数を指定します。
PKINATIVE_MCP_MAX_PATHS_EXPLORED1000limits.maxPathsExplored に対するオペレーター側の上限です（エンジンの既定値）。RFC 5280 §6 のパス構築処理量の上限となります。1 以上の整数を指定します。
演算子の上限値です。 エンジンには、名前付きの PkiLimits が22個あります（maxInputBytes、maxDepth、maxNodes、maxIntegerBytes、maxOidBytes、maxBerSegments、maxPemBlocks、maxExtensions、maxGeneralNames、maxNameAttributes、maxPolicies、maxChainLength、maxPolicyNodes、maxRevokedCertificates、maxOcspSingleResponses、maxPathsExplored、maxSignerInfos、maxAttributes、maxCmsCertificatesAndCrls、maxKdfIterations、maxPkcs12Bags、maxPkcs12KdfIterations）。信頼できる入力に限り、limits フラグメントを使って、呼び出しごとに上限値を引き上げられます。このうち3つは、前述の3つの演算子上限値によって制限されます。上限を超える値は LIMIT_CEILING_EXCEEDED で拒否され、data.env に、演算子が変更する変数名が示されます。「無制限」の設定はなく、ツール引数で変更できる上限値もありません。describe_engine は、デフォルト値、上限値、適用中のすべての上限を報告します。

🛠 ツールリファレンス

すべての PKI オブジェクト入力は、pem（RFC 7468 テキスト）、derBase64（DER を Base64 でエンコードしたもの。1回だけエンコードし、data: URI や PEM は不可）、path（サンドボックス内の相対パス。.pem .crt .cer .der .csr .p10 .crl .p7s .p7b .p7c .p7m .cms .p12 .pfx .key .p8 .pub .ocsp .ors .orq .tsq .tsr .tst .bin .asn1）のうち、いずれか1つだけを含むオブジェクトです。エンジンに関わるすべてのツールは PARSE フラグメント（encodingRules、pemMode、strict、limits）を受け取ります。読み取りツールと判定ツールは verbosity と fields を、アーティファクトツールは outputMode、outputPath、encoding を受け取ります。各フラグメントについては、共通入力フラグメントを参照してください。エラー結果は次のとおりです。content[0].text = "<tool> failed [CODE]: message"、isError: true、_meta.error = { code, message, data? }。完全な入出力スキーマは tools/list で公開されています。コンシューマー向けの仕様（カタログ、判断ツリー、レシピ、完全なエラー一覧）は docs/AGENT_CONTRACT.md にあります。以下の各例は、examples/ またはツールの _meta.examples にある実行可能な呼び出しです（fixtures/… のパスは、例の実行ツールがサンドボックスにコピーするテスト専用の PKI です。公開されているパスワードは test-only-password です）。

convert_pem

RFC 7468 レイヤー（カタログ）です。入力： mode（decode | encode）、input（PKI_INPUT。encode ではDER値を1つだけ指定）、label、extractIndex、PARSE、PROJECTION、OUTPUT（encoding は der / pem / hex）です。出力： blocks[]（index、label、sizeBytes、offset、sha256）、count、extracted、およびブロックを抽出する場合、またはDERをラップする場合の artefact です。コード： SECURITY_VIOLATION（ラベルを問わず、秘密鍵ブロック、または入力内のどこかにある鍵素材。プレフィックスの後ろや、ほかのブロックに含まれる鍵素材も対象です）、NOT_FOUND（最後のブロックを超えるインデックス）、VALIDATION_ERROR、PKI_PEM_UNEXPECTED_LABEL、PKI_PEM_*。

{ "mode": "decode", "input": { "path": "fixtures/leaf.crt.pem" }, "label": "CERTIFICATE", "extractIndex": 0, "encoding": "hex", "fields": ["extracted", "artefact"] }
resolve_oid

1回の呼び出しでオブジェクト識別子を処理します。入力： mode（name | validate | list | encode | decode）、oids[]（≤ 1000）、filter、offset / limit（デフォルトは200、最大は2000）、form（content | tlv）、relative、hex または input（PKI_INPUT — pem / derBase64 / path — を decode のソースとして指定）、PARSE、PROJECTIONです。出力： モードに応じて、名前または有効性を含む oids[]、entries[] と total / hasMore、または1つの oid と name です。encode はOIDごとの16進数を返し、アーティファクトは返しません。PEMでラップされたOIDには encode_asn1 { spec: { type: 'oid', value }, encoding: 'pem', label } を使用してください。コード： VALIDATION_ERROR（モードに対応しないメンバー、form: 'tlv' を指定せずに relative を指定、hex と input の両方を指定）、PKI_OID_INVALID（encode / decode の場合。validate では代わりに無効であることを報告）、PKI_ASN1_*。

{ "mode": "name", "oids": ["1.2.840.10045.4.3.2", "2.5.29.17", "1.3.6.1.5.5.7.3.1", "1.2.3.4"] }
compute_fingerprint

1つのオブジェクトのダイジェストです。入力： input（PKI_INPUT。任意のラベルまたは DER。バンドルは拒否されます）、mode（fingerprint | key-id | shake256）、algorithm、webcrypto、outputLength（≤ 1 MiB）、separator、letterCase、PARSE、PROJECTION。出力： hex、formatted、algorithm、sizeBytes、label、from（key-id で公開鍵の取得元）。コード： VALIDATION_ERROR（モードに対応しないアルゴリズム、鍵識別子に対する SHA-384 / 512）、PKI_X509_* / PKI_ASN1_*（公開鍵を持たないオブジェクトに対する key-id）。

{ "input": { "path": "fixtures/leaf.csr.pem" }, "mode": "key-id", "fields": ["formatted", "from"] }
decode_asn1

X.690 ノードツリーです。入力： input（PKI_INPUT — 秘密鍵または PKCS#12 は指定できません）、sequence、nodePath（'0.2.1'）、read（boolean | integer | small-integer | enumerated | null | bit-string | octet-string | oid | relative-oid | string | time）、stringType、timeType、reencode、label（入力にラベルがない場合、またはサブノードが選択されている場合の、reencode 成果物の PEM ラベル）、allowTrailingData、maxPreviewBytes（デフォルトは 32）、PARSE、PROJECTION、OUTPUT。出力： nodes[]（path、offset、lengths、tag、constructed、children、preview、oid + oidName）、nodeCount、truncated（20 000 ノードを超えた場合）、value（型指定された読み取り値）、reencode.identical、artefact。コード： SECURITY_VIOLATION、NOT_FOUND（nodePath のステップが見つからない場合。範囲を示します）、PKI_ASN1_UNEXPECTED_TAG（リーダーが正しくない場合）、PKI_API_MISUSE（stringType / timeType の指定がない IMPLICIT 文字列 / 時刻）、PKI_ASN1_*、ENGINE_ERROR（limits.maxDepth を引き上げた状態で呼び出しスタックが枯渇した場合 — メッセージに対処方法として値を下げるよう示されます）。

{ "input": { "path": "fixtures/leaf.crt.der" }, "nodePath": "0.1", "read": "integer", "verbosity": "summary" }
encode_asn1

JSON ノード仕様を DER に変換します。入力： spec（1つのノード { type, … }）、label（encoding: 'pem' の場合）、PARSE、OUTPUT（encoding は der / hex / pem。デフォルトは der）。出力： 成果物（sizeBytes、sha256、hex またはリソース）と summary（ルートタグ、ノード数）。コード： JSON パス（$.children[1].value …）を示す VALIDATION_ERROR、SECURITY_VIOLATION（秘密鍵ラベル、または鍵や PKCS#12 として解析される値）、PKI_LIMIT_EXCEEDED（ネストが limits.maxDepth を超えた場合）、PKI_ASN1_*、PKI_OID_INVALID。

{ "spec": { "type": "sequence", "children": [{ "type": "oid", "value": "1.2.840.10045.4.3.2" }] }, "encoding": "hex" }
inspect_certificate

RFC 5280 レポートです。入力： certificate（PKI_INPUT）、extension（19 種類のいずれか）、rawExtensions、issuer（PKI_INPUT）または checkSelfSignature、requireAlgorithmMatch、fingerprints[]、allowSha1、PARSE、PROJECTION。出力： version、serialNumber、signatureAlgorithm、issuer / subject（および issuerString / subjectString）、validity、subjectPublicKeyInfo、extensions[]、selfIssued、fingerprints、signature（検証した場合は valid / algorithm）、diagnostics[]。コード： NOT_FOUND（証明書に存在しない extension）、PKI_PEM_UNEXPECTED_LABEL（証明書として鍵が指定された場合 — バイトの解析前にラベルで拒否されます）、PKI_X509_*、PKI_CRYPTO_ALGORITHM_REFUSED（allowSha1 がない場合の SHA-1）。

{ "certificate": { "path": "fixtures/leaf.crt.pem" }, "issuer": { "path": "fixtures/inter.crt.pem" }, "fingerprints": ["SHA-256", "SHA-1"], "fields": ["signature", "extensions.kind", "subjectString", "fingerprints"] }
create_certificate

証明書を発行します。入力： spec（serialNumber — 整数、16進文字列、または 'random'、subject、issuer、notBefore、notAfter / validityDays、extensions — basicConstraints、keyUsage、extendedKeyUsage、subjectAltName、issuerAltName、SKI / AKI、raw）、issuerCertificate（PKI_INPUT。省略時は自己署名）、subjectPublicKey（証明書、CSR、または PUBLIC KEY）、signer（SIGNER）、allowSha1、PARSE、OUTPUT（デフォルトは pem）。出力： 成果物と summary（serialNumber、randomSerial、subject、issuer、selfSigned、signatureAlgorithm、notBefore / notAfter と notBeforeSource、拡張の種類、signatureVerified、publicKeyFrom）。コード： KEY_MISMATCH（新しい証明書を発行者または自身に対して検証できなかった場合）、RSA_SCHEME_REQUIRED、KEY_TYPE_REQUIRED、SECRET_REQUIRED、UNSUPPORTED_KEY、VALIDATION_ERROR（不明な spec メンバー、allowSha1 がない場合の SHA-1、notAfter が notBefore より前の場合）。

{
  "spec": {
    "serialNumber": 1,
    "subject": { "C": "FR", "O": "Acme", "CN": "Acme Test CA" },
    "notBefore": "2027-01-01T00:00:00Z",
    "validityDays": 3650,
    "extensions": { "basicConstraints": { "ca": true, "pathLen": 0 }, "keyUsage": ["keyCertSign", "cRLSign"] }
  },
  "signer": { "key": { "path": "fixtures/ed25519.key.pem" } }
}
encode_x509_structure

構造をDERにエンコードするための構成要素です。入力： structure（name | name-attribute | validity | spki | algorithm-identifier | attribute | extension | extensions | basic-constraints | key-usage | extended-key-usage | subject-alt-name | subject-key-identifier | authority-key-identifier | signature-algorithm）、spec（閉じたオブジェクト）、signer（signature-algorithm のみ — 鍵は抽出不可としてインポートされ、アルゴリズムのみが読み取られます）、label、allowSha1、PARSE、OUTPUT（デフォルトはhex）。出力： 成果物（デフォルトはhex）とsummary。コード： VALIDATION_ERROR（spec <member> を指定。不明または不足しているメンバーが黙って破棄されることはありません）、KEY_TYPE_REQUIRED、SECRET_REQUIRED、RSA_SCHEME_REQUIRED。

{ "structure": "subject-alt-name", "spec": { "dns": ["svc.example.test", "*.wild.example.test"], "ip": ["192.0.2.1"] } }
decode_extension

OIDで指定する1つのextnValueです。入力： oid、valueHexまたはvalue（PKI_INPUT — OCTET STRING内のDER）、critical、PARSE、PROJECTION。出力： kind、oid、name、critical、sizeBytes、decoded（kindのメンバー）、diagnostics[]（criticalityチェック）。コード： PKI_X509_EXTENSION_MALFORMED（対処法：decode_asn1）、VALIDATION_ERROR。

{ "oid": "2.5.29.19", "valueHex": "30030101ff", "critical": true }
check_certificate_name

RFC 6125に基づく識別情報の判定です。入力： 証明書形式 — certificate（PKI_INPUT）とhostまたはip、chain[]（CNフォールバック用のPKI_BUNDLE）、allowCommonNameFallback（デフォルトはfalse）、allowWildcards（デフォルトはtrue）；照合形式 — presentedとreference；PARSE、PROJECTION。出力： form、valid、reasons[]、reference、subject / presented、match。コード： reasons[]内のPKI_REASON_NAME_MISMATCHなど（判定結果であり、isErrorではありません）；VALIDATION_ERROR（両方の形式が同時に指定された場合）。

{ "certificate": { "path": "fixtures/leaf.crt.pem" }, "host": "a.wild.example.test", "verbosity": "summary" }
check_certificate_purpose

RFC 5280 §4.2.1.12に基づく目的の判定です。入力： certificate、chain[]（リーフの発行者を先頭に指定）、purpose（serverAuth | clientAuth | codeSigning | emailProtection | timeStamping | ocspSigning | any | ドット区切りのOID）、restrictIssuers（デフォルトはtrue）、requireExplicitPurpose（デフォルトはfalse）、PARSE、PROJECTION。出力： valid、reasons[]、purposeOid、purposeName、subject、pathLength。コード： reasons[]内のPKI_REASON_PURPOSE_NOT_PERMITTED（path[i]要素を含む）；VALIDATION_ERROR（不明な目的名）。

{ "certificate": { "path": "fixtures/leaf.crt.pem" }, "purpose": "codeSigning" }
inspect_csr

RFC 2986に基づくレポートです。入力： request（PKI_INPUT）、rawExtensions、verify（デフォルトはtrue — 所有証明としてWeb Cryptoによる検証を1回実行）、allowSha1、PARSE、PROJECTION。出力： subject（およびsubjectString）、subjectPublicKeyInfo、attributes[]、extensions[]、challengePassword（存在するかどうかのみ。内容は返しません）、signatureAlgorithm、signature（valid、reasons[]）。コード： signature.reasons[]内のPKI_REASON_SIGNATURE_NOT_CHECKED（allowSha1が指定されていない場合のSHA-1）、PKI_X509_*、PKI_PEM_UNEXPECTED_LABEL。

{ "request": { "path": "fixtures/leaf.csr.pem" }, "verbosity": "summary" }
create_csr

PKCS#10リクエストです。入力： spec（subject、extensions — subjectAltName、keyUsage、extendedKeyUsage、basicConstraints、subjectKeyIdentifier、raw。発行者の拡張機能は受け付けません）、subjectPublicKey（暗号化されたPKCS#8鍵には必須）、signer（SIGNER）、allowSha1、PARSE、OUTPUT（デフォルトはpem）。出力： 成果物とsummary（subject、signatureAlgorithm、要求された拡張機能の種類、signatureVerified、publicKeyFrom）。コード： KEY_MISMATCH（鍵が指定された公開鍵と一致しません）、RSA_SCHEME_REQUIRED、SECRET_REQUIRED、KEY_TYPE_REQUIRED、VALIDATION_ERROR。

{
  "spec": {
    "subject": { "C": "FR", "O": "Acme", "CN": "svc.example.test" },
    "extensions": { "subjectAltName": { "dns": ["svc.example.test", "www.svc.example.test"] }, "keyUsage": ["digitalSignature"], "extendedKeyUsage": ["serverAuth"] }
  },
  "signer": { "key": { "path": "fixtures/leaf.key.pem" } }
}
verify_certificate_chain

RFC 5280 §6 の判定です。入力： leaf（PKI_INPUT）、TRUST（trustAnchors[]、candidates[]、crls[]、ocspResponses[]、at、requireRevocation、purposes[]、policy）、serverName（host | ip）、ocspNonce、requireOcspNonce、allowSha1、PARSE、PROJECTION。出力： valid、reasons[]、path[]（リーフからアンカーまで）、pathLength、explored、signatureVerifications[]、evaluatedAt と evaluatedAtSource、revocationEvidence。コード： reasons[] の PKI_REASON_* — NO_TRUST_ANCHOR、EXPIRED、NOT_YET_VALID、REVOKED、REVOCATION_UNKNOWN、REVOCATION_STALE、NAME_MISMATCH、PURPOSE_NOT_PERMITTED、…（判定であり、isError ではありません）。エンジンが拒否する入力には VALIDATION_ERROR、PKI_* が返されます。

{
  "leaf": { "path": "fixtures/revoked.crt.pem" },
  "candidates": [{ "path": "fixtures/inter.crt.pem" }],
  "trustAnchors": [{ "path": "fixtures/root.crt.pem" }],
  "crls": [{ "path": "fixtures/inter.crl.pem" }],
  "ocspResponses": [{ "path": "fixtures/revoked.ocsp.der" }],
  "requireRevocation": true,
  "at": "2027-01-01T00:00:00Z",
  "fields": ["valid", "reasons.code", "revocationEvidence", "pathLength"]
}
build_certificate_path

パスを検出します。署名は検証しません。入力： leaf、candidates[]、trustAnchors[]、at、purposes[]、policy、PARSE、PROJECTION。出力： found、structuralReasons[]、path[]、pathLength、explored、valid（常に false）、reasons[]、signaturesChecked: false。コード： PKI_REASON_SIGNATURE_NOT_CHECKED（常に含まれます）、PKI_REASON_NO_TRUST_ANCHOR（アンカーに到達するパスがない場合に structuralReasons[] に含まれます）。

{ "leaf": { "path": "fixtures/leaf.crt.pem" }, "candidates": [{ "path": "fixtures/inter.crt.pem" }], "trustAnchors": [{ "path": "fixtures/root.crt.pem" }], "at": "2027-01-01T00:00:00Z", "verbosity": "summary" }
validate_certificate_path

順序付けされたパスに対する RFC 5280 §6.1 の検証です。入力： path[]（PKI_BUNDLE、リーフが先頭）、trustAnchors[]、at、checkSignatures（デフォルトは true）、policy、allowSha1、PARSE、PROJECTION。出力： valid、reasons[]、failingReasons[]、path[]、signaturesChecked、signatures[]（リンクごとの判定）、evaluatedAt。コード： PKI_REASON_SIGNATURE_INVALID、PKI_REASON_SIGNATURE_NOT_CHECKED（checkSignatures: false）、VALIDATION_ERROR。

{ "path": [{ "path": "fixtures/leaf.crt.pem" }, { "path": "fixtures/inter.crt.pem" }], "trustAnchors": [{ "path": "fixtures/root.crt.pem" }], "at": "2027-01-01T00:00:00Z" }
inspect_crl

RFC 5280 §5 のレポートです。入力： crl（PKI_INPUT）、find（serialHex | certificate）、issuer（PKI_INPUT、署名チェック 1 回）、allowSha1、PARSE、PROJECTION。出力： issuer（および issuerString）、signatureAlgorithm、thisUpdate / nextUpdate、crlNumber、isDelta、baseCrlNumber、issuingDistributionPoint、entryCount、extensions[]、entry（revoked、revocationDate、reason、invalidityDate）、signature。コード： VALIDATION_ERROR、PKI_X509_*、PKI_CRYPTO_ALGORITHM_REFUSED。

{ "crl": { "path": "fixtures/inter.crl.der" }, "find": { "certificate": { "path": "fixtures/revoked.crt.pem" } }, "fields": ["entry", "issuerString", "crlNumber", "nextUpdate.iso"] }
check_crl_revocation

1 つの CRL に対して 1 つの証明書を確認します。入力： certificate、crl、delta、issuer（CRL 発行者 — これがない場合、このリストは証拠として受け入れられません。判定として PKI_REASON_REVOCATION_UNKNOWN を伴う valid: false が返されます）、at、staleTolerance（ms）、allowSha1、PARSE、PROJECTION。出力： valid、reasons[]、signatureVerified、deltaSignatureVerified、crlNumber、isDelta、deltaCrlNumber、evaluatedAt。署名が issuer によって検証されない delta は適用されません。delta に対して PKI_REASON_REVOCATION_UNKNOWN を伴う valid: false が返されます。コード： PKI_REASON_REVOKED（理由を伴う）、PKI_REASON_REVOCATION_UNKNOWN および鮮度／スコープに関する理由（reasons[] 内）、VALIDATION_ERROR（deltaCRLIndicator のない delta）。

{ "certificate": { "path": "fixtures/ed25519.crt.pem" }, "crl": { "path": "fixtures/ed25519.crl.der" }, "delta": { "path": "fixtures/ed25519-delta.crl.der" }, "issuer": { "path": "fixtures/ed25519.crt.pem" }, "at": "2027-01-01T00:00:00Z" }
create_ocsp_request

自分で POST する RFC 6960 リクエストです。入力： certificate、issuer、hashAlgorithm（デフォルトは SHA-1 | SHA-256）、nonce（'random' または 1～32 バイトの 16 進数）、certIdOnly、label（encoding: 'pem' の PEM ラベル）、PARSE、OUTPUT（デフォルトは der、.orq）。出力： 成果物と summary（certIdHex、nonceHex、randomNonce、serial）。コード： VALIDATION_ERROR。

{ "certificate": { "path": "fixtures/leaf.crt.pem" }, "issuer": { "path": "fixtures/inter.crt.pem" }, "hashAlgorithm": "SHA-256", "nonce": "random", "encoding": "hex" }
inspect_ocsp_response

RFC 6960 のレポートです。入力： response（PKI_INPUT）、responder（PKI_INPUT、署名チェック 1 回。省略時は埋め込み証明書を試します）、PARSE、PROJECTION。出力： status、basicResponse（responder id、producedAt、CertID／status／updates を含む responses[]、extensions、certificates、signature algorithm）、noncePresent、signature（valid、source）。コード： PKI_ASN1_*、PKI_X509_*、VALIDATION_ERROR。

{ "response": { "path": "fixtures/revoked.ocsp.der" }, "responder": { "path": "fixtures/ocsp.crt.pem" }, "fields": ["signature", "basicResponse.responses.status", "basicResponse.responses.certId.serialNumber", "noncePresent"] }
check_ocsp_status

証明書 1 件に対する応答です。入力： response、certificate、issuer、responder、responderTrusted、hashAlgorithm、nonce（16 進数）、requireNonce、at、staleTolerance、futureTolerance、allowSha1、PARSE、PROJECTION。出力： valid、reasons[]、status（good | revoked | unknown | null）、signatureVerified、responderAuthorized、responder、responderSource、hashAlgorithm、certIdHex、evaluatedAt。コード： PKI_REASON_REVOKED、reasons[] 内の鮮度、nonce、認可に関する理由（成功以外の応答ステータスは、status: null の否定判定になります）；VALIDATION_ERROR。

{ "response": { "path": "fixtures/leaf.ocsp.der" }, "certificate": { "path": "fixtures/leaf.crt.pem" }, "issuer": { "path": "fixtures/inter.crt.pem" }, "nonce": "1538349c433373ed058c291909df5b3e", "requireNonce": true, "at": "2027-01-01T00:00:00Z", "verbosity": "summary" }
sign_cms

RFC 5652 の SignedData です。入力： content（CONTENT_INPUT）または contentDigest（HEX、detached の場合のみ）、detached、contentType（OID）、certificate、chain[]、crls[]、sid（デフォルトは issuerAndSerialNumber | subjectKeyIdentifier）、signingTime（時刻、'now'、'none'）、signingCertificateV2、algorithmProtection、signedAttributes[] / unsignedAttributes[]（16 進数形式の DER Attributes）、signer（SIGNER）、allowSha1、PARSE、OUTPUT（デフォルトは der、.p7s）。出力： 生成物と summary（detached、contentType、signerSubject / signerSerial、sid、ダイジェストおよび署名アルゴリズム、signingTime と signingTimeSource、certificatesEmbedded、crlsEmbedded、属性数、signatureVerified）。コード： KEY_MISMATCH（新しい署名が署名者の証明書に対して検証できませんでした）、RSA_SCHEME_REQUIRED、SECRET_REQUIRED、KEY_TYPE_REQUIRED、VALIDATION_ERROR（detached なしの contentDigest、signer.key があるのに certificate がない）、SECURITY_VIOLATION（キーを含む拡張機能を指定する、またはキー素材を保持する content.path — ツールがサンドボックスから読み取るコンテンツがキーになることはありません）、PKI_API_MISUSE（属性タイプの重複、またはビルダーが管理する属性タイプ）、ENGINE_ERROR。

{
  "content": { "path": "fixtures/content.txt" },
  "detached": true,
  "certificate": { "path": "fixtures/leaf.crt.pem" },
  "chain": [{ "path": "fixtures/inter.crt.pem" }],
  "signingTime": "2027-01-01T00:00:00Z",
  "signer": { "key": { "path": "fixtures/leaf.key.pem" } }
}
verify_cms

RFC 5652 の判定です。入力： signedData（PKI_INPUT）、content（CONTENT_INPUT）または contentDigest（デタッチ署名の場合）、TRUST（trustAnchors[]、candidates[]、crls[]、ocspResponses[]、at、requireRevocation、purposes[]）、atTimeStamp、requireSigningCertificate、requireAlgorithmProtection、allowTrailingData、allowSha1、PARSE、PROJECTION。出力： valid、reasons[]、signers[]（署名者ごとに、valid、intact、reasons[]、証明書チェーン、タイムスタンプ、失効情報）、signerCount、signatureVerifications[]、evaluatedAt、atTimeStamp。コード： reasons[] 内の PKI_REASON_*（NO_TRUST_ANCHOR、SIGNATURE_INVALID、REVOKED、TSP_*、…）；PKI_API_MISUSE（添付メッセージにはコンテンツが含まれているため、そのメッセージに対してコンテンツが指定された場合）、VALIDATION_ERROR（content と contentDigest の両方が指定された場合）、PKI_ASN1_TRAILING_DATA（allowTrailingData なしでの PDF /Contents のゼロパディング）。

{ "signedData": { "path": "fixtures/attached.p7s" }, "trustAnchors": [{ "path": "fixtures/root.crt.pem" }], "crls": [{ "path": "fixtures/inter.crl.pem" }], "ocspResponses": [{ "path": "fixtures/leaf.ocsp.der" }], "requireRevocation": true, "purposes": ["emailProtection"], "at": "2027-01-01T00:00:00Z" }
inspect_cms

RFC 5652 のレポートです。入力： signedData、allowTrailingData、signerCertificate（鍵の照合 1 件）、signerIndex、content（署名付き属性のない署名者の場合）、allowSha1、PARSE、PROJECTION。出力： version、contentType、contentLength（null = デタッチ）、digestAlgorithms[]、certificates[]、crlCount、ocspResponseCount、signerInfos[]（sid、アルゴリズム、申告された署名時刻、属性、タイムスタンプ数、16 進数形式の signature）、signerSignature。コード： NOT_FOUND（signerCertificate が指定されているときに signerIndex が最後の署名者を超えている場合 — このインデックスは、照合対象の署名者を指定します）、PKI_ASN1_TRAILING_DATA、PKI_*。

{ "signedData": { "path": "fixtures/detached.p7s" }, "signerCertificate": { "path": "fixtures/leaf.crt.pem" }, "content": { "path": "fixtures/content.txt" }, "fields": ["signerInfos.signature", "signerInfos.sid", "signerSignature"] }
amend_cms

唯一の正規な編集です。入力： signedData、signerIndex、operation（add-unsigned-attribute | add-timestamp）、attribute（HEX）、token（PKI_INPUT — .tst または .tsr 全体）、allowSha1、PARSE、OUTPUT（デフォルトは der）。出力： 成果物と summary。コード： data.detail が PKI_REASON_TSP_IMPRINT_MISMATCH の VALIDATION_ERROR（署名者の署名値以外を対象とするトークンです。対処方法として inspect_cms → create_timestamp_request → amend_cms の順序が示されます）、NOT_FOUND、PKI_API_MISUSE（署名済み専用の属性タイプ）、PKI_*。

{ "signedData": { "path": "fixtures/attached.p7s" }, "operation": "add-unsigned-attribute", "attribute": "300d06032a0304310606042a030405" }
create_timestamp_request

自分で POST する RFC 3161 リクエストです。入力： data（CONTENT_INPUT）または digestHex（HEX）、hashAlgorithm（デフォルトは SHA-256 | SHA-384 | SHA-512）、nonce（'random'、10 進数または 0x 形式の 16 進数）、policy（OID）、certReq（デフォルトは true）、label（encoding: 'pem' の PEM ラベル）、PARSE、OUTPUT（デフォルトは der、.tsq）。出力： 成果物と summary（imprintHex、hashAlgorithm、nonce、randomNonce、policy、certReq）。コード： VALIDATION_ERROR（アルゴリズムと長さが一致しないダイジェスト）、SECURITY_VIOLATION（鍵を含む拡張を示す data.path、または鍵素材を含むデータ）。

{ "data": { "path": "fixtures/content.txt" }, "nonce": "random" }
inspect_timestamp

RFC 3161 レポートです。入力： input（PKI_INPUT）、as（response | token | tstinfo）、PARSE、PROJECTION。出力： as、status（statusStrings、failInfo）、token（CMS エンベロープ：署名者数、証明書）、tstInfo（policy、messageImprint、serialNumber、genTime、accuracy、ordering、nonce、tsa、extensions）。コード： PKI_*（バイト列が 3 つの構造のいずれでもない場合）、PKI_STRICT_DIAGNOSTIC（strict: true の場合 — OpenSSL のトークンには PKI_DIAG_CMS_SET_NOT_SORTED が含まれます）。

{ "input": { "path": "fixtures/content.tst" }, "as": "token", "fields": ["token.tstInfo.genTime.iso", "token.tstInfo.messageImprint", "token.certificates.subject"] }
verify_timestamp

RFC 3161 の検証結果です。入力： token または response、request（送信した .tsq — imprint、nonce、policy のすべてが検証されます）、data（CONTENT_INPUT）または digestHex、TRUST（trustAnchors[]、candidates[]、crls[]、ocspResponses[]、at、requireRevocation）、allowNonCriticalTimeStampingEku、allowSha1、PARSE、PROJECTION。出力： valid、reasons[]、genTime、earliest / latest（精度を適用）、tsa、chain（{ valid, path[], reasons[] }）、signatureVerifications[]、evaluatedAt。コード： PKI_REASON_TSP_IMPRINT_MISMATCH、PKI_REASON_TSP_NOT_GRANTED、PKI_REASON_TSP_REQUEST_MISMATCH、PKI_REASON_TSP_TOKEN_INVALID および reasons[] 内のチェーンに関する理由、VALIDATION_ERROR（タイムスタンプ対象が指定されていない場合 — 対象データなしで検証されたトークンは、何の証明にもなりません）。

{ "response": { "path": "fixtures/content.tsr" }, "request": { "path": "fixtures/content.tsq" }, "data": { "path": "fixtures/content.txt" }, "trustAnchors": [{ "path": "fixtures/root.crt.pem" }], "candidates": [{ "path": "fixtures/inter.crt.pem" }], "at": "2027-01-01T00:00:00Z" }
inspect_private_key

鍵バイトを含めずに記述した PKCS#8 鍵です。入力： key（PKI_INPUT）、tryImport、password（または PKINATIVE_MCP_PASSWORD）、keyType（ec-p256 | ec-p384 | ec-p521 | ed25519 | ed448 | rsa | rsa-pss）、hash、rsaScheme、saltLength、allowSha1、PARSE、PROJECTION。出力： format（pkcs8 | encrypted-pkcs8）、kind、curve、algorithm + algorithmName、attributes、publicKey（埋め込みの有無）、encryption（方式、PBKDF2 の反復回数、PRF、AES の鍵サイズ、ソルト長）、encryptedBytes、imported（ハンドルのタイプ、アルゴリズム、用途）。コード： SECRET_REQUIRED、KEY_TYPE_REQUIRED、RSA_SCHEME_REQUIRED、PKI_CRYPTO_DECRYPTION_FAILED（パスワードが誤っている場合）、PKI_KEY_ENCRYPTION_UNSUPPORTED（レガシー暗号の場合。対処方法は openssl pkcs8 です）、PKI_*（PUBLIC KEY または PKCS#8 以外の DER）。

{ "key": { "path": "fixtures/leaf.key.enc.pem" }, "tryImport": true, "password": "test-only-password", "keyType": "ec-p256", "fields": ["imported", "encryption.scheme"] }
inspect_pkcs12

PKCS#12の内容を、鍵のバイト列を含めずに記述します。入力： pkcs12（PKI_INPUT。Windowsで書き込まれたPFXの場合は、encodingRules: 'ber' を指定してBER形式で解析します）、password（省略可）、PARSE、PROJECTION。出力： version、mac（種類は pbmac1 | pkcs12-kdf | null、パラメーター）、contents[]（パス、暗号化方式とパラメーター、暗号化されていないもののバッグ）、bagCount、macVerified（パスワードがある場合。false が報告されるのは、SafeContentsが一切暗号化されていない場合のみです。それ以外の場合、間違ったパスワードはMACの報告前に PKI_CRYPTO_DECRYPTION_FAILED になります）、opened[]（許可リストに基づくビュー：サブジェクト／発行者／シリアル番号別のcertBags、アルゴリズム／曲線／暗号化パラメーター別の鍵バッグ、サイズ別のcrlBags）。PKINATIVE_MCP_PASSWORD が設定されている場合、その値がパスワードとして扱われます。パスワードなしでファイルを記述するには、この変数の設定を解除してください。コード： PKI_CRYPTO_DECRYPTION_FAILED（暗号化されたSafeContentsに対する間違ったパスワード）、PKI_KEY_MAC_UNSUPPORTED、PKI_KEY_ENCRYPTION_UNSUPPORTED（いずれもOpenSSL 3.4への変換による解決方法が示されます）。

{ "pkcs12": { "path": "fixtures/legacy.p12" }, "fields": ["mac.kind", "contents.path", "contents.encryption.scheme"] }
open_pkcs12

PKCS#12を1回の呼び出しで開きます。入力： pkcs12、password（または PKINATIVE_MCP_PASSWORD）、allowUnverifiedIntegrity、rsaScheme（pkcs1 | pss）、hash、exportCertificates、PARSE、PROJECTION、OUTPUT（PEMのみ。バンドルにはDER形式がありません）。出力： valid、integrity（verified | unverified | mismatch）、reasons[]、keys[]（アルゴリズム、ハンドルの種類、用途。バイト列は含まれません）、certificates[]、keyCount / certificateCount / crlCount、exportSkipped、artefact（PEMバンドル）。コード： SECRET_REQUIRED（どちらの経路からもパスワードが指定されていない場合）。reasons[] に含まれるコード：PKI_REASON_PKCS12_MAC_MISMATCH（間違ったパスワード、または改変されたファイル。復号は行われません）、PKI_REASON_PKCS12_ENCRYPTION_UNSUPPORTED、PKI_REASON_PKCS12_INTEGRITY_UNVERIFIED、PKI_REASON_PKCS12_RSA_SCHEME_UNSPECIFIED。また、MISSING_OUTPUT_PATH、OUTPUT_TOO_LARGE。

{ "pkcs12": { "path": "fixtures/leaf.p12" }, "password": "test-only-password", "exportCertificates": true }
describe_engine

オフラインの事前チェックです。入力： PROJECTIONのみ。出力： server（名前、バージョン、toolApiVersion、プロトコル、toolCount）、engine（名前、バージョン、nodeFloor）、capabilities（canVerify、canSign、canDecrypt、node、nodeFloorSatisfied、platform）、randomness、defaultLimits、ceilings、caps、sandbox（enabled、cacheEnabled、pinnedInstant、拡張機能の許可リスト）、network: 'none'、registries（57／43／97個のコード、ラッパーコード、用途、鍵使用ビット、OIDレジストリの件数）、refusals（設計方針）、unexposed。コード： VALIDATION_ERROR。

{ "fields": ["defaultLimits", "ceilings", "sandbox", "capabilities"] }
explain_code

任意のコードについて説明します。入力： code、または kind（error | reason | diagnostic | wrapper）を指定した list: true、PROJECTION。出力： code、kind、summary、standard、severity、errorClass、engineClass、cwe、since、remedy、または codes[] と count。コード： NOT_FOUND（不明なコード）。

{ "code": "PKI_REASON_PKCS12_RSA_SCHEME_UNSPECIFIED" }
draft_governance_issue

人間がレビューして送信するための、ガバナンスに準拠した GitHub issue をローカルで作成します。対象は pkinative（エンジンの動作：解析、検証、制限、拒否）、pkinative-cli または pkinative-mcp（ラッパーの動作：スキーマ、サンドボックス、トランスポート）です。サーバーは GitHub に接続しません。ネットワークを利用するコードパスが一切ないためです。サーバーはドラフトの Markdown と、機械可読なコンプライアンスレポートを返します。その両方をユーザーに提示してから停止してください。レビューして送信するのはユーザー自身です。入力： title、summary、issueType（bug | feature | security | docs | performance）、targetRepo、reproduction（{ command, result }）、expectedBehavior、actualBehavior、affectedPackages[]、duplicateSearchPerformed（true である必要があります）、outputMode（inline | file）＋ outputPath（サンドボックス内の相対 .md パス）。出力： draftMarkdown、warnings[]、（.github/AGENT_RULES.md の9つのキーを含む）compliance。コード： GOVERNANCE_VIOLATION（実行時依存関係が提案された場合、秘密鍵またはパスワードが埋め込まれている場合、再現手順がない場合、duplicateSearchPerformed: false の場合）、MISSING_OUTPUT_PATH、INVALID_EXTENSION、OUTPUT_EXISTS、SECURITY_VIOLATION。

{
  "title": "parseCertificateList refuses a delta CRL with an empty revokedCertificates list",
  "summary": "A delta CRL (deltaCRLIndicator present) whose revokedCertificates SEQUENCE is absent is refused with PKI_X509_STRUCTURE_INVALID although RFC 5280 makes the field OPTIONAL.",
  "issueType": "bug",
  "targetRepo": "pkinative",
  "reproduction": { "command": "inspect_crl { crl: { path: \"fixtures/empty-delta.crl\" } }", "result": "PKI_X509_STRUCTURE_INVALID at revokedCertificates" },
  "expectedBehavior": "The delta CRL parses with entryCount 0.",
  "affectedPackages": ["pkinative", "pkinative-mcp"],
  "duplicateSearchPerformed": true
}

人間が関与するプロセスの全契約については、governance_contract と draft_issue_workflow のプロンプト、および docs/guides/AI_GOVERNANCE.md を参照してください。

🧩 共通入力フラグメント

同じ10個のフラグメントがカタログ全体で使われます。各ツールの説明には、そのツールが含むフラグメントが記載されています。すべてのオブジェクトスキーマは閉じています（additionalProperties: false、すべての階層で Zod の .strict() を適用）。未知のキーやスペルミスのあるキーは、黙って破棄されるのではなく、該当するパスを示す VALIDATION_ERROR になります。

フラグメント形式ルール
PKI_INPUT{ pem } | { derBase64 } | { path }いずれか1つのみです。pem は -----BEGIN で始まる RFC 7468 テキストです。1つのオブジェクトが想定されるときに、複数のブロックを含む PEM テキストは拒否されます（convert_pem extractIndex またはバンドルを使用してください）。derBase64 は DER を base64 で正確に1回エンコードしたものです（data: URI ではなく、PEM でもありません）。path はサンドボックスからの相対パスで、先頭バイトから PEM または DER を判別し、拡張子は許可リストに基づいて検証され、キャッシュされることはありません。バイト列を解析する前にラベルが検証されます（PKI_PEM_UNEXPECTED_LABEL）。
PKI_BUNDLEPKI_INPUT[]（1～256項目）trustAnchors、candidates、crls、ocspResponses、chain、path：各項目のすべての PEM ブロックを、順序どおりに取り込みます。
CONTENT_INPUT{ text } | { base64 } | { path }署名、検証、またはタイムスタンプ付与の対象となるバイト列です。UTF-8 テキスト、base64（デコード後 ≤ 128 MiB）、またはサンドボックス内のファイル（拡張子は問わないものの、鍵を含む拡張子は不可、≤ 1 GiB）を指定します。これはコンテンツであり、PKI オブジェクトではありません。ツールが読み取るコンテンツが鍵になることは決してないため、鍵素材を含むファイルは SECURITY_VIOLATION になります。
HEX文字列contentDigest、digestHex、valueHex、attribute、nonce、ocspNonce、serialHex：16進数です。0x プレフィックス、コロン、空白は許容されます（^(?:0x)?(?:[0-9a-fA-F]{2}[:\s]?)+$）。
PARSEencodingRules、pemMode、strict、limitsencodingRules は 'der'（厳密な X.690、デフォルト）または 'ber'（レガシー CMS 生成ツールが出力する、不定長または非最小長）です。pemMode は 'strict'（RFC 7468 に厳密に準拠）または 'lax'（空白、行長、RFC 1421 ヘッダーを許容）です。strict: true にすると、エンジンの最初の警告が PKI_STRICT_DIAGNOSTIC に昇格します。limits は以下を参照してください。
LIMITS{ maxInputBytes, maxDepth, … }（22個のキー）信頼できる入力に限り、この呼び出しでエンジンの名前付き上限を引き上げます。指定のないキーにはエンジンのデフォルト値が適用されます。各値は1以上の整数です。maxInputBytes、maxKdfIterations／maxPkcs12KdfIterations、maxPathsExplored はオペレーターが設定した上限で制限されます（LIMIT_CEILING_EXCEEDED）。引き上げた maxDepth の範囲内で呼び出しスタックが枯渇した場合、対処法（値を下げる）を示すコード付きの ENGINE_ERROR になります。
SIGNER{ key } | { p12 }、+ password、keyType、hash、rsaScheme、saltLengthkey（プレーンまたは PBES2 で暗号化された PKCS#8 秘密鍵。PEM または DER。SEC1／PKCS#1 鍵は、先に openssl pkcs8 -topk8 で変換する必要があります）または p12（PBES2 + PBMAC1 のみ）のいずれか1つを指定します。鍵は抽出不可能な Web Crypto 鍵としてインポートされ、エンジンの外に出ることはありません。アルゴリズムは鍵に応じて決まります。鍵の曲線に対応した ECDSA（曲線に応じて SHA-256／384／512）、Ed25519／Ed448（ハッシュなし）、RSA は rsaScheme（'pkcs1' | 'pss'、saltLength は任意）の指定が必須です。暗号化された鍵には password（または PKINATIVE_MCP_PASSWORD）が必要です。また、証明書または公開鍵入力で指定されていない場合は keyType も必要です。署名者を含む呼び出しはキャッシュされません。
TRUSTtrustAnchors、candidates、crls、ocspResponses、at、requireRevocation、purposes、policy判定結果は、ユーザーが指定する信頼アンカー（少なくとも1つ）を基準にします。at は ISO 8601 の日時（タイムゾーンを指定しない場合は UTC）、エポックミリ秒、または 'now' です。省略時は PKINATIVE_MCP_AT を使用し、それもなければシステム時刻を使用します（キャッシュされません）。requireRevocation: true を指定すると、エンドエンティティ証明書に対する最新の証拠が必須になります（そうでない場合は PKI_REASON_REVOCATION_UNKNOWN になります。これはエンジンのルールです。中間証明書は渡された証拠に基づいて判定され、そのステータスは revocationEvidence に報告されます）。purposes（≤ 16）は EKU 名または OID です。policy には RFC 5280 §6.1.1 の入力（initialPolicySet、requireExplicitPolicy、inhibitPolicyMapping、inhibitAnyPolicy）を指定します。
PROJECTIONverbosity、fields'full'（デフォルト）または 'summary' です。verbosity 適用後に保持するドットパスを最大16個指定できます（配列は各要素に適用されます）。一致しなかったパスは、ネストされたものも含め、すべて _meta.unmatchedFields に _meta.availableFields とともに報告されます。__proto__／constructor／prototype セグメントは VALIDATION_ERROR になります。
OUTPUToutputMode、outputPath、encoding'base64'（デフォルト、インライン出力は ≤ 50 MiB）または 'file'（encoding に対応する拡張子を持つ相対 outputPath。PEM は .pem、DER は .der .crt .cer .csr .p10 .crl .p7s .p7m .p7b .cms .orq .tsq .bin .asn1 …。鍵を含む拡張子は拒否され、既存ファイルは上書きされません。≤ 1 GiB）です。encoding は 'pem'、'der'、または 'hex'（インラインのみ、≤ 64 KiB）です。hex は structuredContent.hex に格納されます。
すべての結果には、diagnostics[]（コードとパスで重複排除し、最大 200 件。超過時は diagnosticsTruncated を設定）と diagnosticCounts も含まれます。ツールにパスワード入力がある場合、その入力はプレーンテキストの文字列（4096 文字以下）で、エコー、ログ記録、キャッシュへの保存は一切行われません。

🔐 セキュリティモデル

pkinative-mcp はホストプロセス内で動作し、stdio MCP サーバー（またはループバック限定の HTTP エンドポイント）を公開します。すべての証明書、リクエスト、リスト、レスポンス、メッセージ、トークン、鍵、PKCS#12 を信頼できない入力として扱い、PKINATIVE_MCP_CACHE_DIR 配下のオプトイン式レスポンスキャッシュ以外では、設定されたサンドボックスの外部で I/O を行いません。

  • シークレットの受け渡しは 2 つの経路のみで、3 つ目はありません。 パスワードは、呼び出しごとの password 入力、または運用担当者側の PKINATIVE_MCP_PASSWORD を通じてサーバーに渡されます。1 回の呼び出しにつき、指定できるのはどちらか 1 つです（同時に指定すると VALIDATION_ERROR）。どちらも指定されていない場合は SECRET_REQUIRED になります。パスワードが結果やエラーテキストにエコーされることはなく、ログにも記録されません（起動時に変数が設定されているかどうかだけが報告されます）。キャッシュファイルへの書き込みや、リソースとしての提供も行われません。秘密鍵は抽出不可の Web Crypto ハンドルにインポートされます。すべての鍵レポートと PKCS#12 レポートは、フィールドごとに作成される許可リスト形式のビュー（src/key-views.ts）です。テストスイートでは、フィクスチャから算出した検索用テーブルを使って、いずれの結果、stderr、キャッシュファイル、stdio トランスクリプトにも、鍵のバイト列、スカラー、JWK メンバー、暗号化された鍵の本文、パスワードが出力されないことを証明します（tests/secret-leak.test.ts）。
  • サンドボックス（PKINATIVE_MCP_OUTPUT_DIR）は、読み取り（すべての path 入力、resources/read）と書き込み（outputPath、ガバナンスのドラフト）を行う唯一のファイルシステム境界です。パスは相対パスでなければなりません。絶対パス、ドライブパス、UNC パス、..、NUL バイト、許可リストにない拡張子は拒否されます。読み取るファイルと書き込み先の親ディレクトリの実際のパスは、いずれもサンドボックス内にとどまる必要があります（サンドボックス内に仕掛けられたシンボリックリンクまたはジャンクションは、読み取りと書き込みの両方で SECURITY_VIOLATION になります）。ファイルは排他的に開かれ（OUTPUT_EXISTS。上書きは行われません）、書き込みに失敗した場合は部分的なファイルが削除されます。鍵を含む拡張子（.key .p8 .p12 .pfx）は鍵ツールだけが読み取り、書き込み、一覧表示、resources/* による提供は一切行われません。また、resources/list と resources/read はファイル名にかかわらず、内容によっても鍵素材を拒否します。プレフィックスの後に続く PEM 鍵、多数のブロックに紛れた鍵、不要なデータの後ろに置かれた生の DER 鍵、テキストファイル内の base64 鍵素材は、いずれも SECURITY_VIOLATION になります。同じ内容検査は、汎用エンコーダー（convert_pem encode は DER 値を 1 つだけ受け付け、鍵素材を拒否）と内容入力（sign_cms の content.path、create_timestamp_request の data.path）も保護します。サンドボックスからツールが読み取る「内容」が鍵になることはありません。未設定の場合は、インライン PEM／base64 のみを使用します。
  • 上限 — すべてのバイト数と件数の上限は src/caps.ts の定数であり、describe_engine.caps で公開されます。
上限値
stdio フレーム／HTTP 本文256 MiB
呼び出しごとのインライン PKI 入力のデコード後サイズ／インライン content128 MiB／128 MiB
content.path のメモリへの全読み込み1 GiB
インライン出力（成果物、リソース読み取り）50 MiB
ファイル出力1 GiB
インライン 16 進数成果物64 KiB
バンドル項目数／インライン DER 属性数／呼び出しごとの OID 数256／256／1000
resolve_oid のリストページデフォルト 200／最大 2000
SHAKE256 の出力／パスワード／fields のパス／decode_asn1 のプレビュー／ツリーノード1 MiB／4096／16／32 バイト／20 000
結果ごとの診断数200 件（コードとパスで重複排除）
resources/list のエントリー数／走査の深さ／resources/read1000／8／50 MiB
レスポンスキャッシュの TTL／サイズ3600 秒／256 MiB
エンジンのデフォルト値（limits）pkinative 1.0.0 の 22 個の PkiLimits — maxInputBytes は 64 MiB、maxKdfIterations は 10 000 000、maxPathsExplored は 1000、ほか（describe_engine.defaultLimits）
  • キャッシュのゲート（isCacheable、src/server.ts） — PKINATIVE_MCP_CACHE_DIR が設定されている場合、結果がキャッシュから返されるのは、その結果が環境、シークレット、時刻、乱数のいずれにも依存しない場合に限られます。path 入力は決して対象になりません（パスはコンテンツではなく参照先です）。outputMode: 'file' も対象になりません。password または signer を含む呼び出しも対象になりません。'random' のシリアル番号やノンスも対象になりません。'now' または固定されていない時刻も対象になりません。describe_engine や draft_governance_issue も対象になりません。また、PKINATIVE_MCP_PASSWORD が設定されている間は、パスワードを受け取るツールも対象になりません（入力にシークレットが含まれていなくても、オペレーターのパスワードが使用された可能性があるためです）。キーの名前空間にはツール API、パッケージ、エンジンのバージョンが含まれるため、エンジンをアップグレードしても、以前のエンジンが書き込んだバイト列が返されることはありません。
  • ドクトリンに基づく拒否（describe_engine.refusals） — サーバーが越えない一線と、それぞれの対処法を示します。ネットワーク通信なし、鍵の生成なし（HSM、KMS、または openssl genpkey で鍵を用意してください）、鍵のエクスポートなし、PKCS#8／PKCS#12／CRL／OCSP レスポンス／タイムスタンプレスポンスの書き出し機能なし（発行ソフトウェアまたは OpenSSL を使い、ここで結果を検証してください）、デフォルトで SHA-1 を拒否、デフォルトの RSA 方式なし、レガシー PKCS#12 と PBES1 鍵を拒否（OpenSSL 3.4 以降で一度だけ変換してください：openssl pkcs12 -legacy … の後に -export -pbmac1_pbkdf2）、DSA／ML-DSA は解析しますが、検証も署名もしません、診断はエラーではありません、上限を引き上げるのは明示的に指定し、かつ上限値の範囲内に限ります、乱数はラッパー内で生成され、報告されます（randomSerial、randomNonce）。
  • 入力は、各ツールの境界で厳格な JSON Schema と Zod に照らして検証されます。どの階層でも未知のキーやスペルミスのあるキーは VALIDATION_ERROR になります。パーサーを実行する前に、base64 の妥当性を確認します（data: URI、DER が想定される箇所の PEM、二重エンコードまたは空のペイロードは、対処法とともに拒否されます）。仕様はプロトタイプ汚染に対して安全な方法で構築されます（tests/prototype-pollution.test.ts）。
  • HTTP トランスポート（PKINATIVE_MCP_PORT）は、Host／Origin ガードを設けてループバックにのみバインドします。PKINATIVE_MCP_HTTP_TOKEN が設定されていない限り、認証はありません（設定されている場合、有効なベアラートークンがなければ 401 になります）。
ネットワークと外部送信：なし

一切ありません。 サーバーにはネットワークを使うコードパスがありません。CRL、OCSP、AIA、TSA の取得、テレメトリー、GitHub、更新確認、ツール引数からの URL はありません。また、PDF 版の兄弟プロジェクトとは異なり、オペレーターが設定できるエンドポイントも一切ありません。describe_engine は network: 'none' を報告し、すべてのツールが openWorldHint: false を示します。失効の証拠とタイムスタンプトークンは、入力として別途取得しておくものです。create_ocsp_request と create_timestamp_request は、ユーザーが転送するバイト列を生成します（application/ocsp-request、application/timestamp-query）。エンジン自体がソケットを開いたり、ファイルシステムにアクセスしたり、eval を実行したりすることはありません。

責任ある脆弱性開示の手順と脅威モデルについては SECURITY.md を、CWE ID を含む防御策については docs/guides/SECURITY.md を参照してください。

🧪 適合性（OpenSSL 3）

OpenSSL 3.x は、このサーバーの外部審査ツールです。pdfnative-mcp における veraPDF の役割と同じで、ツールが書き出したものを別の実装が読み込み、検証します。npm run corpus:pki は、固定した時刻にビルド済みサーバー（scripts/generate-pki-corpus.ts、コーパステーブルは scripts/lib/pki-corpus.ts）を実行し、manifest.json（ステータス、SHA-256、各決定的エントリーの2つ目のダイジェスト）とともに、相互運用性コーパスを test-output/pki/ に書き出します。コーパスには 適合する成果物が23件 含まれます。すべての署名方式（Ed25519、RSA PKCS#1 v1.5、RSA-PSS、ECDSA P-256）の自己署名 CA とリーフ証明書、pathLen-0 の中間証明書とその配下のリーフ証明書、3つの CSR、添付および切り離し CMS メッセージ（Ed25519 署名者を含む）、2つのタイムスタンプ要求、2つの OCSP 要求、DER フィクスチャの PEM 再エンコードです。また、宣言されたコードで拒否されるべき 拒否対象のカナリアが5件 含まれます（SHA-1 署名、レガシー PKCS#12 署名者、スキームのない RSA キー、notBefore より前の notAfter、仕様内の URL メンバー）。バイト列を書き出すカナリアは XPASS となり、実行は失敗します。

続いて npm run validate:pki（scripts/validate-pki.ts）が、すべての成果物を2つのレベルで検査します。

  • レベル 0 — エンジンのラウンドトリップ：dist/server.js を通じたプロセス内検査です。すべての証明書を検査し、固定時刻にコーパス CA まで検証します（リーフには serverName と purposes を指定して verify_certificate_chain を使用します）。すべての要求を読み込み、所持証明を確認します。すべての CMS メッセージをアンカー（および切り離しコンテンツ）を使って検証します。すべての OCSP 要求とタイムスタンプ要求を node:crypto で独立してデコードし、再計算します（CertID ハッシュ、シリアル番号、メッセージインプリント、ノンス）。また、すべての決定的エントリーが同じハッシュ値で2回生成されることを確認します。外部ツールは不要で、常に実行されます。
  • レベル 1 — OpenSSL：PATH 上の openssl 3.x（OPENSSL_BIN で上書き可能。LibreSSL および OpenSSL < 3.0 は理由とともに拒否されます）。12のコマンドファミリーを実行します。すべての証明書（DER と PEM）に対する x509 -text、各コーパス CA に対する verify（リーフには -purpose sslserver、中間証明書には -untrusted、固定時刻には -attime を指定）、req -verify、crl -text、cms -verify（添付および切り離し、フィクスチャルートの -CAfile を指定）、asn1parse、ocsp -req_text、ts -query -text です。生のトランスクリプトは test-output/pki/reports/ に保存されます。OpenSSL がない場合は、理由とともにスキップされます。PKINATIVE_INTEROP_REQUIRED=1 またはゲートの --require-all を指定した場合は失敗します。

カバレッジカナリアは、docs/data/interop.json の declared.conformant / declared.refused にコーパスを照合し、検証対象が気付かないうちに減る回帰を防ぎます。バリデーターはファイルごとに PASS / FAIL / XFAIL / XPASS / INFRA / SKIP を報告します。終了コードは次のとおりです。0 はすべての期待値を満たした場合、1 は FAIL / XPASS / カナリアが発生した場合、2 はコーパスまたは dist/ が存在しない場合、3 は OpenSSL が必須なのに存在しない場合です。同じレベル1検査の vitest 版は tests/interop/openssl.test.ts（npm run test:interop）です。また、tests/interop/lint.test.ts（npm run test:lint-certs、公開プロファイル）は、scripts/data/lint-waivers.json のレビュー済み免除（現時点ではなし）を適用し、コーパス内の証明書に対して zlint と pkilint の証明書リンターを実行します。

このゲートは ブロッキング です。ci ワークフローは Linux（Node 22 および 24）、Windows、macOS 上で --require-all を指定して実行します。また、interop ワークフローは4つの OS レッグ（ubuntu-22.04、ubuntu-24.04、windows-latest、macos-latest）で同じ検査を繰り返します。そのうち interop (ubuntu-24.04) と interop (windows-latest) は必須のステータスチェックです。OpenSSL はランナーのツールであり、依存関係ではありません。PASS は特定の OpenSSL リビジョン（開発ホストでは 3.5.5）に対する検証の証拠であり、認証ではありません。docs/guides/CONFORMANCE.md を参照してください。

自律性の証明

tests/autonomy.test.ts は、4 つのトランスポート × 時代の組み合わせ（stdio レガシー、stdio モダン、HTTP レガシー、PKINATIVE_MCP_HTTP_TOKEN を使用する HTTP モダン）で、ビルド済みの dist/cli.js に対して、1 つのスクリプト化されたエージェントシナリオ（S0〜S18：ハンドシェイク → カタログ → describe_engine → inspect_certificate とワイヤー経由のキャッシュヒット → CRL と OCSP の証拠を使ったチェーン判定 → 名前と用途 → ファイルモードでの CA、CSR、発行済みリーフ → CMS 署名の署名、検証、その後の改ざん → タイムスタンプ要求の作成と応答の検証 → トランスクリプトにキーのバイト列を含めずに PKCS#12 を開く → resources/* → コードと対処法を示して拒否される悪意ある入力 → 上限値 → プロトコルエラー → draft_governance_issue → prompts/get → explain_code → 正常なシャットダウン）を再生します。このテストは、フィクスチャ、キャッシュディレクトリ、引き下げた PKINATIVE_MCP_MAX_PATHS_EXPLORED 上限値を含むサンドボックスのもとで実行されます（呼び出しごとに時刻を固定し、シナリオでは pinnedInstant: null をアサートします）。そのうえで、やり取りが発生しないこと、予期しない isError がないこと、すべての拒否にコードと対処法があること、ワイヤー経由でキャッシュヒットすること、秘密の文字列がどこにも（stdout、stderr、キャッシュ、サンドボックス）存在しないこと、stdout が JSON のみであること、正常に終了することをアサートします。Claude Code、Claude Desktop、MCP Inspector から手動で再生する方法については、docs/guides/LOCAL_TESTING.md を参照してください（リポジトリにはすぐに使える .mcp.json が含まれています）。

🧪 ローカル開発

git clone https://github.com/Nizoka/pkinative-mcp.git
cd pkinative-mcp
npm ci --ignore-scripts   # .npmrc sets ignore-scripts=true: nothing builds on install
npm run gate:fast         # before every commit: typecheck:all, lint, test, code-tables, server-json, verify:docs
npm run gate              # the CI profile: + build, dist checks, stdio smoke test, tool shape, samples, coverage, docs, the OpenSSL corpus and interop
npx tsx scripts/gate.ts --publish --require-all   # release branches: everything incl. lint:certs (zlint / pkilint); a skipped step fails

npm run gate（scripts/gate.ts）は、合格基準を一元的に定義しています。111 ファイルにわたる 2381 件のテスト、vitest.config.ts のカバレッジしきい値（94 / 90 / 95 / 94）、そして stdio 経由で実行するビルド済みサーバーが対象です。サーバーの stdout には JSON-RPC フレームのみが出力され、dist/ にテストキーのバイトが 1 つも含まれていない必要があります。各ステップにつき 1 行を出力し、ログを test-output/.gate/<step>.log に書き込みます。--only <step> は 1 つのステップを実行し、--from <step> はそこから再開し、--json は機械処理用の出力を生成します（フラグを渡すにはスクリプトを直接呼び出してください。PowerShell は npm run の後の単独の -- を無視します）。各ステップは通常の npm スクリプトです。

スクリプト内容
npm run typecheck:allsrc/ と tests/ に対して tsc --noEmit を実行し、その後 scripts/ に対して実行します
npm run linteslint src --max-warnings 0 を実行します。警告が 1 つでもあると失敗します
npm test / npm run test:coveragevitest（ドットレポーター）／v8 カバレッジ付きで実行します。しきい値は vitest.config.ts にあります
npm run buildtsc -p tsconfig.build.json → dist/
npm run examples:check89 個の examples/*.json を tools/call ハンドラー経由で実際に実行します（複数ステップの例は連結して実行します）
npm run test:generate / npm run verify:samples98 サンプルのベースライン：隔離された環境でビルド済みサーバーを実行し、test-output/samples/ に出力します。tests/_fixtures/samples.sha256.json に基づいて検証します（10 件はバイト単位で完全一致、3 件は TBS 構造、85 件は意味的に一致）
npm run corpus:pki / npm run validate:pkiOpenSSL コーパス（23 + 5）を test-output/pki/ に出力し、レベル 0 および 1 で検証します
npm run test:interop / npm run test:lint-certsレベル 1 の vitest 版（PKINATIVE_INTEROP_REQUIRED=1 を指定すると、スキップせずに失敗します）／zlint と pkilint のリンター
npm run verify:tool-shapeビルド済みの tools/list 構造を tests/_fixtures/tool-shape.json と照合します。カタログの上限は 448 KiB、説明の上限は 8 KiB です（意図的なスキーマ変更後に限り npx tsx scripts/tool-shape.ts --write を実行してください）
npm run verify:docsドキュメント内のすべての数、バージョン、ツール、コード、オペレーター変数、リンク、アンカーを docs/assets/ecosystem.json およびソースツリーと照合します
npm run agents:rules.github/instructions/*.instructions.md から .claude/rules/*.md を再生成します
npm run release:prepareバージョンを機械的に更新します（コミット、タグ付け、公開は行いません）
npm run hooks:install / hooks:uninstallオプトインの git フック（pre-commit：lint と CRLF チェック、pre-push：高速ゲート）

各スクリプト、フラグ、終了コードの一覧は scripts/README.md にあります。tests/fixtures/pki/ にある 42 個のフィクスチャは OpenSSL 3.5.5 で作成され（tests/fixtures/PROVENANCE.md）、SHA256SUMS で固定されており、既存ファイルを上書きして再生成することはありません。ここにある秘密鍵はすべて公開済みのテスト専用素材です（パスワードは test-only-password）。

お使いのマシン上の OpenSSL。 レベル 1 では、PATH 上（または OPENSSL_BIN で指定した場所）に openssl 3.x が必要です。Linux：ディストリビューションのパッケージを使用します。macOS：brew install openssl@3（システムの /usr/bin/openssl は LibreSSL のため、理由を示して拒否されます）。Windows：PATH 上の OpenSSL 3 ビルド、または Git for Windows に同梱されているもの（usr/bin/openssl.exe）を使用します。PATH の先頭にない場合は、OPENSSL_BIN でその場所を指定してください。見つからない場合、validate:pki と interop は理由を示して SKIP し、--require-all を指定すると失敗します。

stdio 経由でサーバーのスモークテストを実行します。

node dist/cli.js
# In another terminal, send a JSON-RPC initialize request via stdin (e.g. with the MCP Inspector).
npx @modelcontextprotocol/inspector --cli node dist/cli.js --method tools/list

ベアラートークンとサンドボックスを使って HTTP 経由で実行します。

PKINATIVE_MCP_PORT=3000 PKINATIVE_MCP_HTTP_TOKEN=change-me-to-a-real-secret PKINATIVE_MCP_OUTPUT_DIR=/tmp/pki npx pkinative-mcp
# POST http://127.0.0.1:3000/mcp with Authorization: Bearer …

コントリビューター向け： AGENTS.md（すべてのコーディングエージェントとコントリビューターに共通するリポジトリのルール）から始め、ローカル検証ワークフローの全容については docs/guides/LOCAL_TESTING.md をご覧ください。品質ゲート、テストとしてのサンプル、サンプルのベースライン、OpenSSL コーパス、Claude Code または MCP Inspector からのビルド済みサーバーの操作について説明しています。

📣 リリースプロセス

pkinative-mcp は、pkinative、pdfnative-mcp、zipnative-mcp と同じリリース形式に従います。

  • タグごとに release-notes/vX.Y.Z.md にリリースノートファイルを1つ作成します
  • CHANGELOG.md に各リリースの箇条書きを反映します
  • GitHub Release の本文には release-notes/vX.Y.Z.md の内容をコピーします
  • npx tsx scripts/release-prepare.ts --version X.Y.Z でバージョン更新の機械的な部分を適用します（コミット、タグ付け、公開は行いません）。バージョンは package.json、src/version.ts、server.json、CITATION.cff（tests/metadata.test.ts）と docs/assets/ecosystem.json（npm run verify:docs、ルール manifest-shape）の間で常に一致させます
  • リリースブランチは npx tsx scripts/gate.ts --publish --require-all に合格する必要があります。OpenSSL を含むすべてのステップをスキップせずに実行します（zlint と pkilint がインストールされている場合は、証明書リンターも実行されます）
  • npm への公開は GitHub Actions Trusted Publishing（OIDC）を使用し、NPM_TOKEN は使わず、保護された npm-publish 環境から行います。ワークフローはタグとパッケージのバージョンが一致することを確認し、公開ゲートを実行して --provenance を付けて公開します。2つ目のジョブでは、CycloneDX SBOM とともに tarball のアテステーション（ビルド来歴）を生成し、両方を GitHub Release に添付します
  • Linux と Windows の各ジョブは step-security/harden-runner から開始します（このアクションは macOS をサポートしていないため、macOS ジョブは文書化された例外です）。persist-credentials: false を指定してチェックアウトし、npm ci --ignore-scripts でインストールし、最小権限の permissions で実行します。アクションはコミット SHA で固定されます。OpenSSL の相互運用性ゲートはブロッキングです
  • 人が関与するプロセスです。コーディングエージェントが準備と検証を行い、メンテナーがプッシュ、プルリクエストの作成、タグ付け、公開を行います（.github/AGENT_RULES.md）

標準構成と公開チェックリストについては release-notes/TEMPLATE.md を、リリース手順については CONTRIBUTING.md をご覧ください。

📚 プロジェクト構成

src/
├── cli.ts                      # entrypoint: stdio (default, 256 MiB frames) or Streamable HTTP (PKINATIVE_MCP_PORT); reads the operator knobs once
├── http.ts                     # Node http <-> Web Request/Response bridge, 256 MiB body cap, Host/Origin loopback guard
├── auth.ts                     # opt-in HTTP bearer token (PKINATIVE_MCP_HTTP_TOKEN)
├── server.ts                   # Server factory, dispatch by tool kind, cache hints, the cache gate, SERVER_INSTRUCTIONS, 7 prompts, resources
├── caps.ts                     # every byte / count cap + the three operator ceilings
├── limits.ts                   # the 22 PkiLimits as the `limits` fragment; LIMIT_CEILING_EXCEEDED
├── sandbox.ts                  # the single filesystem boundary (PKINATIVE_MCP_OUTPUT_DIR): extension allow-lists, realpath checks, wx writes
├── pki-input.ts                # pem XOR derBase64 XOR path; PEM sniffing, label discipline, bundles
├── content-input.ts            # text XOR base64 XOR path for the bytes to sign / verify / time-stamp; the HEX grammar
├── parse-context.ts            # the PARSE fragment (encodingRules, pemMode, strict, limits) and the per-call input budget
├── signer.ts                   # PKCS#8 / PKCS#12 -> non-extractable SigningKey; the algorithm rules (rsaScheme, hashes)
├── secrets.ts                  # the two password channels (input XOR PKINATIVE_MCP_PASSWORD), redaction
├── key-views.ts                # allow-list views of keys and PKCS#12 bags (never a key byte)
├── trust.ts                    # the TRUST fragment (anchors, candidates, evidence, at, purposes, policy) and reasons[]
├── time.ts                     # ISO 8601 instants, PKINATIVE_MCP_AT, clock-dependence
├── random.ts                   # serialNumber:'random' / nonce:'random' (node:crypto), reported in summaries
├── x509-spec.ts, asn1-spec.ts  # the closed JSON specs of create_certificate / create_csr / encode_* (depth-bounded, pollution-safe)
├── names.ts, spki.ts           # host / IP identity inputs; public-key kinds and curves
├── pki-errors.ts               # PkiError -> ToolError (the 57 PKI_* codes verbatim, classes, remedies), guard()
├── wrapper-codes.ts            # the 21 wrapper codes with meaning and remedy (served by explain_code)
├── diagnostics.ts              # engine diagnostic sink (de-duplicated, capped at 200) -> diagnostics[]; strict escalation
├── projection.ts               # verbosity / fields projection for the read and verdict tools
├── output.ts                   # artefact emitter: embedded resource (pem / der / hex) or exclusive sandbox file
├── resources.ts                # pkinative://output/{+path} over the sandbox (key-bearing files never listed nor served)
├── cache.ts                    # opt-in SHA-256 response cache (PKINATIVE_MCP_CACHE_DIR)
├── views.ts, wire.ts, base64.ts  # wire views (no raw DER echoes), hex helpers, base64 boundary diagnostics
├── engine.ts                   # engine version and Node floor, the Web Crypto capability probe
├── governance.ts               # AI-governance / HITL contract text + draft validation
├── errors.ts, version.ts, index.ts
├── data/pkinative/             # the registries vendored at the pkinative v1.0.0 tag: errors, reasons, diagnostics, limits, core-exports + generated code-tables.ts
└── tools/                      # one file per tool (34), _definition.ts (kinds, annotations), _registry.ts + _group-*.ts (catalogue order), _shared.ts
scripts/                        # TypeScript run by tsx — the full table is in scripts/README.md
├── gate.ts                     # THE quality gate (npm run gate / gate:fast; --publish --require-all on release branches)
├── generate-samples.ts         # npm run test:generate — the examples through the built server -> test-output/samples/
├── verify-samples.ts           # npm run verify:samples — the 98-sample baseline (tests/_fixtures/samples.sha256.json)
├── generate-pki-corpus.ts      # npm run corpus:pki — the OpenSSL interoperability corpus (23 + 5)
├── validate-pki.ts             # npm run validate:pki — level 0 (engine round trip) + level 1 (OpenSSL 3.x); exit 0 / 1 / 2 / 3
├── tool-shape.ts               # structural tools/list fingerprint and size budgets (--write refreshes the fixture)
├── verify-docs.ts              # npm run verify:docs — the docs held to docs/assets/ecosystem.json and the source tree
├── release-prepare.ts          # mechanical version bump (never commits, tags or publishes)
├── build-claude-rules.ts       # npm run agents:rules — .github/instructions/ -> .claude/rules/
├── build-code-tables.mjs       # regenerates src/data/pkinative/code-tables.ts from the vendored registries
├── verify-issue.mjs            # governance draft checker (npm run verify:issue)
├── lib/                        # pki-corpus, interop-tools (OpenSSL), sample-fingerprint, tool-shape, mcp-surface, markdown-anchors, agent-config, prose-language, json-schema-lite
└── helpers/, data/, validators/  # hermetic env, I/O, the lint waivers, the pkilint driver
docs/
├── AGENT_CONTRACT.md           # the consumer contract for agents that USE the server (catalogue, decision tree, recipes, error reference)
├── AI_GUIDE.md, KNOWLEDGE_BASE.md, API_STABILITY.md
├── guides/                     # AI_GOVERNANCE, LOCAL_TESTING, SECURITY, SIGNING, VERIFICATION, REVOCATION, TIMESTAMPS, KEYS, CONFORMANCE, REPRODUCIBLE
├── data/                       # errors, reasons, diagnostics, limits, core-exports (mirrors of src/data/pkinative/), interop.json (the corpus counts)
└── assets/ecosystem.json       # the single source of every count and version quoted in the docs
examples/                       # 89 executable tools/call sequences (npm run examples:check)
AGENTS.md, CLAUDE.md            # repository rules for coding agents; .github/instructions/ holds the per-area rules
.claude/                        # shared agent settings, the fail-closed guard hook, generated rules, the release-audit skill
.github/workflows/              # ci (Linux Node 22 / 24, Windows, macOS — the gate with --require-all), interop (4 OS legs, blocking),
                                #   sample-regression, publish (Trusted Publishing + SBOM + attestation), docs, codeql, scorecard,
                                #   dependency-review, audit, node-current
.github/rulesets/               # branch and tag rulesets to import
tests/                          # vitest suites (one per tool / module), _fixtures/ (tool shape, sample baseline, the registry schema),
                                #   fixtures/pki/ (42 OpenSSL-made TEST-ONLY files, SHA256SUMS, PROVENANCE.md), interop/ (OpenSSL, linters), tools/ (repository tooling)

🗺 ロードマップ

v1.0.0 は、pkinative 1.0.0 を基盤とする最初のリリースです。エンジンのランタイム機能全体（117個のランタイムエクスポートすべてが名前付きツールから利用可能）をオフラインで提供します。リリース済みのマイルストーン、上流でブロックされている項目、次のステップ、長期的な方向性を含む計画全体は、ROADMAP.md をご覧ください。

設計上、上流でブロックされている機能（エンジンにはなく、薄いラッパーで偽装することもしません）：

  • 鍵生成 — pkinative は何も生成しません。鍵はお使いの HSM、KMS、または openssl genpkey で用意してください。
  • PKCS#8、PKCS#12、CRL、OCSP レスポンス、タイムスタンプレスポンスの書き込み機能 — エンジンにはこれらの機能がありません。お使いの CA ソフトウェアまたは OpenSSL で発行し、ここで検証してください。
  • DSA と ML-DSA の検証 — 解析して報告しますが、検証も署名も行いません（PKI_REASON_SIGNATURE_NOT_CHECKED / UNSUPPORTED_KEY）。

機能のアイデアがありますか？ イシューまたは PR を作成してください。または、エージェントに draft_governance_issue で下書きを作成させ、自分で提出することもできます。

⭐ プロジェクトにスターを付ける

pkinative-mcp が役に立ったら、このリポジトリに ⭐ を付けてください。基盤となるエンジン Nizoka/pkinative にもスターを付けていただけると幸いです。スターは、ほかの人がプロジェクトを見つける助けとなり、継続的な開発の励みになります。

🤝 コントリビューション

コントリビューションを歓迎します。CONTRIBUTING.md を読み、未解決のイシューを確認し、行動規範に従ってください。

📄 ライセンス

MIT © 2026 Nizoka。サードパーティの素材については、THIRD-PARTY-NOTICES.md をご覧ください。

pkinative-mcp は pkinative と Model Context Protocol TypeScript SDK を基盤として構築されています。

コメント

Markdown 対応

MCP は初めてですか？

プロトコルの概要から最初のサーバーの導入まで、よくある疑問にまとめて答えます。

AI アプリケーションが外部のツールやデータソースに統一的な方法で接続するためのオープンなプロトコルです。クライアントはモデルとの対話を担い、MCP サーバーはツール・リソース・プロンプトテンプレートを提供します。標準メッセージでやり取りするため、1 つのサーバーを複数のクライアントで再利用できます。