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

PKI MCP server: inspect, verify, issue, sign X.509, CSR, CRL, OCSP, CMS, TSP, PKCS#12.

Connector by Nizoka · GitHub account verified by the MCP Registry

IndexedMITLocal (stdio)

Install

Works with Claude Code, Codex, VS Code, Cursor, Windsurf, Claude Desktop. Read the repository before you give any tool access to your data.

npx agentmarket install connector/nizoka-pkinative-mcp

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

About

PKI MCP server: inspect, verify, issue, sign X.509, CSR, CRL, OCSP, CMS, TSP, PKCS#12. 34 tools

Reviews

Write a review

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this server can do and what it asks for, from its tool list and install config. Checked Oct 25, 2026.

Tools: 23 read · 11 write · 0 delete
Secrets: 2 (API keys, tokens or passwords)
Install scripts: Not scanned yet
Runs as: Node.js package

Tools by what they do 34

Read from the source code; the running server may list different tools.

Read 23 · Look things up without changing anything.

build_certificate_path
check_certificate_name
check_certificate_purpose
check_crl_revocation
check_ocsp_status
compute_fingerprint
decode_asn1
decode_extension
describe_engine
explain_code
inspect_certificate
inspect_cms

Show 11 more tools

inspect_crl
inspect_csr
inspect_ocsp_response
inspect_pkcs12
inspect_private_key
inspect_timestamp
resolve_oid
validate_certificate_path
verify_certificate_chain
verify_cms
verify_timestamp

Write 11 · Create, change, send or run things.

amend_cms
convert_pem
create_certificate
create_csr
create_ocsp_request
create_timestamp_request
draft_governance_issue
encode_asn1
encode_x509_structure
open_pkcs12
sign_cms

Secrets and settings it asks for

Secrets: values you paste in that let it act as you.

PKINATIVE_MCP_HTTP_TOKEN
PKINATIVE_MCP_PASSWORD

Other settings (environment variables or headers).

PKINATIVE_MCP_AT
PKINATIVE_MCP_CACHE_DIR
PKINATIVE_MCP_MAX_INPUT_BYTES
PKINATIVE_MCP_MAX_KDF_ITERATIONS
PKINATIVE_MCP_MAX_PATHS_EXPLORED
PKINATIVE_MCP_OUTPUT_DIR
PKINATIVE_MCP_PORT

Files it touches

Any path the agent passes to its tools

Tools (34)

Read from the source code; the running server may differ. Descriptions are the server’s own words; hidden characters are shown as [U+…].

amend_cmsAmend CMS (add an unsigned attribute or an RFC 3161 counter time-stamp)
The one edit a signed message legitimately receives afterwards, every signed octet unchanged: operation 'add-unsigned-attribute' appends `attribute` (one DER Attribute as hex) to signer `signerIndex`'s unsigned attributes; 'add-timestamp' appends `token` — a TimeStampToken, or the whole TimeStampResp a TSA returned (unwrapped; a declined response is refused) — as id-aa-signatureTimeStampToken (CAdES-T / PAdES B-T). A counter time-stamp stamps the signer's SIGNATURE VALUE, not the document: the token's imprint is checked against that value BEFORE anything is written and a token over anything el…
build_certificate_pathBuild certificate path (discovery to a trust anchor, signatures NOT checked)read-only
Path discovery only (RFC 5280 §6 path building): walks from `leaf` through the untrusted `candidates` to one of YOUR `trustAnchors` under the structural rules evaluated at `at` (validity, basic constraints, key usage, name constraints, the `policy` inputs; `purposes` steer discovery but the leaf's extended key usage is judged by verify_certificate_chain, not here) and reports the path it found, leaf first up to the anchor. NO signature is verified: the engine marks every link PKI_REASON_SIGNATURE_NOT_CHECKED, so `valid` is always false and the verdict of this tool is `found` (a path reached an…
check_certificate_nameCheck certificate name (RFC 6125 host / IP identity, or one name match)read-only
The RFC 6125 identity verdict, two forms. Certificate form: `certificate` + exactly one of `host` (DNS name as it appeared in the URL) / `ip` — is the certificate valid for that identity (subjectAltName dNSName / iPAddress; wildcards under `allowWildcards`, default true; `allowCommonNameFallback`, default false, reads a CN-only certificate's commonName and then needs `chain` — the issuing CAs, leaf's issuer first — so the CN is held to their dNSName name constraints as a SAN would be). Match form: `presented` (the certificate's dNSName, possibly a wildcard) + `reference` — one RFC 6125 §6.4 na…
check_certificate_purposeCheck certificate purpose (extended key usage along the path)read-only
The RFC 5280 §4.2.1.12 purpose verdict: may `certificate` be used for `purpose` (serverAuth, clientAuth, codeSigning, emailProtection, timeStamping, ocspSigning, any, or a dotted KeyPurposeId OID)? The path judged is [certificate, ...chain] (issuers, leaf's issuer first): under `restrictIssuers` (default true, what every Web PKI validator does) a CA's own extKeyUsage restricts what it issued; `requireExplicitPurpose` (default false) refuses a certificate with no extKeyUsage instead of reading its absence as unrestricted. A negative verdict is valid:false + reasons[] (PKI_REASON_PURPOSE_NOT_PER…
check_crl_revocationCheck CRL revocation (one certificate against one CRL, optional delta)read-only
The RFC 5280 §6.3 revocation verdict of ONE `certificate` against ONE base `crl` you fetched (this server never fetches), evaluated at `at`: the list must be in scope for the certificate (issuer, issuing distribution point, reasons), fresh (nextUpdate, or `staleTolerance` ms past it), signature-verified, and the serial must not be listed (PKI_REASON_REVOKED with the reason otherwise). `delta` applies a delta CRL over the base (it must carry a deltaCRLIndicator — VALIDATION_ERROR otherwise — and name the base's number). `issuer` is the CRL issuer certificate: the base (and delta) signatures are…
check_ocsp_statusCheck OCSP status (one response for one certificate: CertID, responder, freshness, nonce)read-only
The RFC 6960 verdict of ONE OCSP `response` you fetched (this server never queries a responder) for ONE `certificate`: the CertID is recomputed from `issuer` (with the hash the response used, or `hashAlgorithm`) and must be answered; the signature is verified with `responder`, else the certificates embedded in the response, else the issuer itself; the signer must be authorised (RFC 6960 §4.2.2.2: the CA, a delegate the CA issued carrying id-kp-OCSPSigning, or `responderTrusted:true` for a trust you hold out of band); then the engine judges the status (good; PKI_REASON_REVOKED / unknown otherwi…
compute_fingerprintCompute fingerprint (DER digest, key identifier, SHAKE256)read-only
Description is built at runtime.
convert_pemConvert PEM (list and extract blocks, or wrap DER)
The RFC 7468 layer. mode:'decode' lists every block of a PEM text (index, label, DER size, offset, RFC 1421 headers under pemMode:'lax', SHA-256 of the DER) — `label` keeps one kind, `extractIndex` also delivers that block as an artefact (encoding 'der' by default, 'pem' or 'hex'; inline as an embedded resource, or as a sandbox file with outputMode:'file' + outputPath, never overwritten). mode:'encode' wraps DER bytes (derBase64 or a DER file path) into one strict PEM block under `label` (required) and delivers it as the artefact (64-character lines, LF). A private-key block (PRIVATE KEY, ENCR…
create_certificateCreate certificate (CA or leaf, from a JSON spec, Web Crypto signed)
Issue an X.509 v3 certificate from `spec` (subject, validity, extensions — basicConstraints, keyUsage, extendedKeyUsage, subjectAltName, issuerAltName, SKI / AKI, raw), signed through `signer` (a PKCS#8 key or a PKCS#12 file, imported as a NON-EXTRACTABLE Web Crypto key — nothing generates or exports a key here). Self-signed when no `issuerCertificate` is given (the subject key is derived from a plain signer.key, or taken from `subjectPublicKey`); issued when `issuerCertificate` is given (`subjectPublicKey` = a certificate, a CSR or a PUBLIC KEY is then required; the AKI is computed from the i…
create_csrCreate CSR (PKCS#10 request from a JSON spec, Web Crypto signed)
Build a PKCS#10 certification request (RFC 2986) from `spec` (subject; the extensions to request — subjectAltName, keyUsage, extendedKeyUsage, basicConstraints, subjectKeyIdentifier, raw — carried in extensionRequest; issuerAltName / authorityKeyIdentifier are refused as the issuer's), signed through `signer` (a PKCS#8 key or a PKCS#12 file imported as a NON-EXTRACTABLE Web Crypto key; nothing generates or exports a key here). The public key certified is the signing key's own: derived from a plain signer.key, taken from the PKCS#12 certificate, or given as `subjectPublicKey` (a certificate, a …
create_ocsp_requestCreate OCSP request (RFC 6960 DER, SHA-1 or SHA-256 CertID, nonce)
Build the DER OCSPRequest (RFC 6960 §4.1) asking a responder for the status of `certificate`, identified by the CertID computed from `issuer` (the CA that issued it — its name and key hashes) and the serial. `hashAlgorithm` 'SHA-1' (default, the engine default and what every responder answers) or 'SHA-256' (recommended where the responder supports it). `nonce` adds the RFC 8954 nonce extension: 'random' (16 bytes from node:crypto, summary.randomNonce:true) or your own hex (1–32 bytes); keep summary.nonceHex to demand it back with check_ocsp_status. `certIdOnly:true` returns the bare CertID (de…
create_timestamp_requestCreate time-stamp request (RFC 3161 TimeStampReq over data or a digest)
Build the RFC 3161 TimeStampReq you POST to a TSA yourself (Content-Type application/timestamp-query; this server never talks to a network): the message imprint is `hashAlgorithm` (SHA-256 default, SHA-384, SHA-512) over `data`, or `digestHex` already computed with it (wrong length → VALIDATION_ERROR). `nonce:'random'` draws 63 bits from node:crypto (summary.randomNonce:true; never cached) — without a nonce nothing ties the response to THIS request; a decimal or 0x-hex value pins it. `policy` names the TSA policy, `certReq` (default true) asks for the TSA certificate in the token. For a counte…
decode_asn1Decode ASN.1 (node tree, typed read, re-encode)read-only
Description is built at runtime.
decode_extensionDecode extension (one extnValue by OID, the 19 known kinds)read-only
Read-only decode of ONE X.509 extension value by its OID — the bytes INSIDE extnValue's OCTET STRING, as `valueHex` or `value` (DER by derBase64 / sandbox path) — exactly as inspect_certificate decodes a certificate's extensions: the 19 known kinds (basicConstraints, keyUsage, extendedKeyUsage, subjectAltName, nameConstraints, certificatePolicies, crlDistributionPoints, authorityInfoAccess, SCT list, …) come back with their members, any other OID as kind 'unknown' with its size; `critical` (default false) is reported and checked against the kind's RFC 5280 rule (a diagnostic, not a refusal). A…
describe_engineDescribe engine & server capabilitiesread-only
Description is built at runtime.

Show 19 more tools

draft_governance_issueDraft a governance-compliant GitHub issue (HITL)
Produce a LOCAL GitHub issue draft + compliance report for pkinative / pkinative-cli / pkinative-mcp and NEVER submit it — the agent drafts, a human reviews and files it under their own identity (Human-In-The-Loop contract, .github/AGENT_RULES.md). No GitHub write path and no network path exist in this server. The draft is checked against the zero-dependency + reproduction + no-secret policy; a violation (new runtime dependency, an embedded private key or password, missing reproduction, duplicateSearchPerformed:false) throws GOVERNANCE_VIOLATION. targetRepo 'pkinative' for engine behaviour (pa…
encode_asn1Encode ASN.1 (JSON node spec to DER)
Encode a JSON node spec into DER through the engine's own encoders: `spec` is one node { type, … } — boolean (value), integer / enumerated (value: integer, decimal or 0x-hex string, negative allowed), null, bit-string (hex, unusedBits), named-bits (bits[]), octet-string (hex), oid / relative-oid (value), string (stringType utf8|numeric|printable|teletex|ia5|visible|universal|bmp, value), time (value: ISO instant or epoch ms; timeType UTCTime|GeneralizedTime|rfc5280 — the RFC 5280 rule by default), sequence / set / set-of (children[]; set-of is sorted as DER requires), explicit / implicit (tag,…
encode_x509_structureEncode X.509 structure (one building block to DER, from a JSON spec)
Encode ONE X.509 building block to DER through pkinative's structural encoders, deterministically (the same spec gives the same bytes): `structure` is 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 or signature-algorithm; `spec` holds that structure's members (closed objects — an unknown or missing member is refused with VALIDATION_ERROR naming `spec <path>`; validity takes explicit notBefore AND notAfter, never an implicit now; a k…
explain_codeExplain a code (errors, reasons, diagnostics, wrapper codes)read-only
Explain any code this server can emit, from the registries vendored at the pkinative v1.0.0 tag: the 57 PKI_* engine error codes (coarse class, PkiError subclass, when raised, CWE, the engine's remedy and the MCP input that lifts it), the 43 PKI_REASON_* codes a verdict returns, the 97 PKI_DIAG_* diagnostics (with severity) and the wrapper's own codes (VALIDATION_ERROR, SECURITY_VIOLATION, LIMIT_CEILING_EXCEEDED, SECRET_REQUIRED, …). list:true enumerates (kind filters one vocabulary). Branch on codes, never on message text.
inspect_certificateInspect certificate (RFC 5280 report, extensions, fingerprints, signature check)read-only
Read-only RFC 5280 report of ONE certificate in one call: version, serial, signature algorithm, issuer and subject (RFC 4514 + RDNs), validity (epoch ms + ISO), public key (kind, bits, curve / modulus / exponent), every extension decoded (the 19 kinds pkinative knows; rawExtensions:true keeps them undecoded), self-issued flag, fingerprints (SHA-256 by default), and every engine diagnostic. `extension:'subjectAltName'` returns that one extension. `issuer` or `checkSelfSignature:true` adds a signature check — ONE signature against ONE key, which is NOT trust: verify_certificate_chain is the RFC …
inspect_cmsInspect CMS SignedData (RFC 5652 report, signers, attributes, signature values)read-only
Read-only RFC 5652 report of ONE CMS SignedData (.p7s / .p7m / .p7b, CMS or PKCS7 PEM, or a PDF /Contents): version, content type, attached content length (null = detached), digest algorithms, the embedded certificates (subject / issuer / serial), CRL and OCSP counts, and every signer — identifier (issuer + serial or key id), algorithms, signing time as CLAIMED, ESS signing-certificate, CMSAlgorithmProtection, signed and unsigned attributes (oid, name, value count), counter time-stamp count and the signature value as hex (what a counter time-stamp stamps: fields:['signerInfos.signature'], hash…
inspect_crlInspect CRL (RFC 5280 §5 report, one entry lookup, signature check)read-only
Read-only RFC 5280 §5 report of ONE certificate revocation list: version, issuer (RFC 4514 + RDNs), signature algorithm, thisUpdate / nextUpdate, CRL number, delta indicator and base CRL number, issuing distribution point, entry count (the entries are counted by walking, never all decoded — bounded by limits.maxRevokedCertificates), every extension decoded, size, diagnostics. `find` looks ONE serial up (serialHex, or a certificate whose serial and issuer are used) and returns `entry` (revoked, revocationDate, reason, invalidityDate, entry extensions). `issuer` adds a signature check — ONE sign…
inspect_csrInspect CSR (RFC 2986 report, requested extensions, proof of possession)read-only
Read-only RFC 2986 report of ONE PKCS#10 certification request: subject (RFC 4514 + RDNs), public key (kind, bits, curve / modulus), every attribute, the extensions requested through extensionRequest decoded as a certificate's would be (rawExtensions:true keeps them undecoded), whether a challengePassword is present (never its text), the signature algorithm, and — by default (`verify`, one Web Crypto verification) — the proof of possession: signature.valid tells whether the request was signed by the key it carries, with reasons[] (PKI_REASON_SIGNATURE_NOT_CHECKED for SHA-1 without allowSha1:tr…
inspect_ocsp_responseInspect OCSP response (RFC 6960 report, signature check)read-only
Read-only RFC 6960 §4.2 report of ONE OCSP response (the DER a responder returned): the response status (only successful carries an answer), the BasicOCSPResponse — responder id (by name or by key hash), producedAt, every SingleResponse (CertID: hash algorithm, issuer name / key hashes, serial; status good / revoked with time and reason / unknown; thisUpdate, nextUpdate, extensions), response extensions, the embedded certificates, the signature algorithm — whether an RFC 8954 nonce is echoed, and diagnostics (bounded by limits.maxOcspSingleResponses). `responder` adds a signature check against…
inspect_pkcs12Inspect PKCS#12 (MAC kind, SafeContents, bags; optional MAC check and opening, no key byte)read-only
Describe a PKCS#12 (.p12 / .pfx) WITHOUT its password: version, the MAC construction (kind 'pbmac1' RFC 9579 with its PBKDF2 / HMAC parameters, or 'pkcs12-kdf' — the RFC 7292 Appendix B MAC pkinative never verifies; null when the file has none), every SafeContents with its encryption scheme (PBES2 parameters, or the name of a legacy RC2 / 3DES scheme pkinative refuses), and the bags of the unencrypted SafeContents. With `password` (or PKINATIVE_MCP_PASSWORD): `macVerified` (true / false — a wrong password or an altered file is a REPORT, not an error; null without a MAC) and `opened`: every Saf…
inspect_private_keyInspect private key (PKCS#8 description, optional import proof, no key byte)read-only
Describe a PKCS#8 private key WITHOUT its password: format ('pkcs8' or 'encrypted-pkcs8'), version, kind (ec / rsa / rsa-pss / ed25519 / ed448 / x25519 / x448 / ml-dsa / unknown), curve, algorithm OID and name, attributes, whether a public key is embedded; for an encrypted key the PBES2 parameters (PBKDF2 iterations, PRF, AES key size, salt length, ciphertext size) or the name of a scheme pkinative refuses (PKCS#12 / PKCS#5 v1.5 ciphers). `tryImport:true` additionally imports the key into a NON-EXTRACTABLE Web Crypto key and reports the handle (type, algorithm, usages) — an encrypted key then …
inspect_timestampInspect time-stamp (RFC 3161 response, token or TSTInfo)read-only
Read-only RFC 3161 report of a TimeStampResp (.tsr: status, statusStrings, failInfo, and the token when granted), a TimeStampToken (.tst) or a bare TSTInfo — auto-detected in that order unless `as` names one. The TSTInfo view: policy, message imprint (algorithm + hex), serial, genTime (epoch ms + ISO), accuracy (null = undeclared), ordering, nonce (decimal), the TSA name as STATED (a hint, not an identity), extensions; the token view adds its CMS envelope (signer count, embedded certificates). Parsing proves nothing — verify_timestamp is the verdict (imprint, TSA signature, chain, revocation).…
open_pkcs12Open PKCS#12 (MAC, decryption, non-extractable key import, certificates; optional PEM bundle)
Open a PKCS#12 (.p12 / .pfx) in one call with `password` (or PKINATIVE_MCP_PASSWORD; SECRET_REQUIRED without one): the RFC 9579 PBMAC1 MAC is verified, every PBES2 SafeContents decrypted, every key unwrapped by the host straight into a NON-EXTRACTABLE Web Crypto key — described (algorithm, handle type, usages) and never exported — every certificate parsed (compact refs) and every CRL counted. The verdict is valid + integrity ('verified' | 'unverified' | 'mismatch') + reasons[]; a negative verdict is a REPORT, never isError: a wrong password or altered file → integrity 'mismatch' + PKI_REASON_P…
resolve_oidResolve OID (name, validate, list, encode, decode)read-only
Description is built at runtime.
sign_cmsSign CMS (RFC 5652 SignedData, attached or detached, Web Crypto signed)
Produce an RFC 5652 SignedData over `content` (attached, or `detached:true`) or over a precomputed `contentDigest` (detached only — the PDF /ByteRange case), with ONE signer: `signer` (a PKCS#8 key or a PKCS#12 file, imported as a NON-EXTRACTABLE Web Crypto key — nothing generates or exports a key here) and `certificate` (required with signer.key; a PKCS#12 bag's certificate serves otherwise), `chain` and `crls` parsed (never embedded unread) then embedded. Signed attributes are always written: contentType, messageDigest, signingTime (default PKINATIVE_MCP_AT or now, whole seconds; 'none' omit…
validate_certificate_pathValidate certificate path (RFC 5280 §6.1 on an ordered path, link signatures)read-only
RFC 5280 §6.1 validation of a path YOU ordered (`path`, leaf first, then each issuer) against YOUR `trustAnchors` at `at`: validity, basic constraints, key usage, name constraints and the `policy` inputs. By default every link signature is verified first — certificate i against i+1, the last against the anchor whose subject matches its issuer — and reported per link in signatures[] (PKI_REASON_SIGNATURE_INVALID fails the verdict). `checkSignatures:false` gives a structural verdict: `valid` stays false (PKI_REASON_SIGNATURE_NOT_CHECKED on every link) and `failingReasons` carries what actually f…
verify_certificate_chainVerify certificate chain (the RFC 5280 §6 verdict, offline revocation)read-only
The one-call trust verdict for a certificate: builds a path from `leaf` through `candidates` to one of YOUR `trustAnchors`, verifies every signature, validates the path at `at` (RFC 5280 §6: validity, basic constraints, key usage, name constraints, policies — `policy` inputs), checks `serverName` (RFC 6125 host or IP) and `purposes` (extended key usage along the path), and judges revocation from the CRL / OCSP bytes YOU supply (`crls`, `ocspResponses`; `requireRevocation:true` demands evidence for every certificate below the anchor; this server never fetches). A negative verdict is valid:false…
verify_cmsVerify CMS SignedData (the RFC 5652 verdict: signers, chains, time-stamps, revocation)read-only
The one-call verdict on a CMS SignedData (a .p7s, an S/MIME body, a PDF /Contents): for EVERY signer, the signed attributes (contentType, messageDigest, ESS signing-certificate, CMSAlgorithmProtection), the content digest (attached, or `content` / `contentDigest` for a detached signature — a detached signature without its content is NOT valid), the signature, the certificate's chain through `candidates` and the embedded certificates to one of YOUR `trustAnchors` at `at` (RFC 5280 §6, `purposes` along the path), every counter time-stamp (RFC 3161, verified like verify_timestamp), and revocation…
verify_timestampVerify time-stamp (the RFC 3161 verdict: imprint, TSA signature, chain, revocation)read-only
The one-call verdict on an RFC 3161 time-stamp: exactly one of `token` (a TimeStampToken, .tst) or `response` (the whole TimeStampResp, .tsr — a declined response is PKI_REASON_TSP_NOT_GRANTED), judged against what YOU say was stamped — `request` (the .tsq you sent: imprint, nonce and policy are all checked, the only way to catch a replay), `data` (hashed with the token's own algorithm) or `digestHex`; at least one is required, because a token verified without what it stamps proves nothing (VALIDATION_ERROR otherwise). The TSA's signature is verified, its certificate must chain to one of YOUR …

Signals

Stars: 0
Forks: 0
Open issues: 0
Last commit: Oct 17, 2026 (12 days ago)
Last release: Oct 17, 2026 (12 days ago)

From GitHub (fetched Oct 24, 2026).

Details

Registry name: io.github.Nizoka/pkinative-mcp
Version: 1.0.0
Auth: API key
Packages: npm pkinative-mcp
License: MIT
Repository: github.com/Nizoka/pkinative-mcp
Website: github.com/Nizoka/pkinative-mcp#readme
First seen: Oct 24, 2026
Last checked: Oct 24, 2026
Source: Official MCP Registry github-graphql

More from Nizoka

Cite this page

pkinative MCP — X.509, CMS, OCSP, time-stamps and PKCS#12 without a key byte…. Agent Mart. https://agentmart.dev/connectors/nizoka-pkinative-mcp (last updated 2026-10-24)