CSR Decoder

Decode a PKCS#10 request — subject, key, requested SANs and attributes — and see what a CA will reject, entirely on this device.

0 bytes uploaded

Common name——Key——DER size——

Certificate request — paste PEM, hex or Base64

Drop a .csr or .der file here — reading it starts no upload and no enrolment.

Subject distinguished name, attribute by attribute
Attribute	Value	DER string type
Paste or drop a certification request and its fields appear here.

0 characters · Format: auto

Reads one certification request up to 65536 bytes. · Each table below is a scrollable region: press Tab to focus it, then the arrow keys to read it.

Stored only on this device —

A PRIVATE KEY block was pasted with this request. It was not decoded, nothing left this device, and it is hidden below — but treat that key as compromised if this text has been shared anywhere.

The signature is reported as present, with its algorithm and its size. It is not verified here: proving possession of the private key is the CA's job, and this page never has that key.

This page reads a request. It does not create one, does not submit it to a CA, and does not check a key and a request against each other.

What you paste is never stored — not in this browser, not anywhere else. Only the view and format settings above are kept, and they are kept on this device.

A shared link carries the view and format settings above and nothing else — the request you pasted cannot travel in it.

This paste is credential-shaped. It is not stored, and it cannot travel in a shared link — the link has no field for it.

Keyboard: Ctrl ↵ — Copy the pane you are looking at · e — Expand or collapse every structure · f — Cycle the input format: auto, PEM, hex, Base64

Do it offline:$ openssl req -in request.csr -noout -text

How to use it

Paste the request, drop a .csr or .der file, or paste raw DER as hex or Base64. A badge names the form the bytes were read as; press f to state the form you expected and be told when the bytes disagree.
Read Before you send first: every line is a statement with its reason, never a score and never a grade, so a missing alternative name reads as what an authority will see.
Open Subject, Key, Requested extensions and Attributes for the detail. A challengePassword arrives masked behind its own reveal control, and an identifier this decoder cannot name keeps its bytes in place.
Copy the pane you are reading, or copy one structure's bytes as hex from its own row. A shared link and the downloadable state file carry the view you left open and no part of what you pasted.

A certification request is what you hand an authority before any certificate exists: the name you are asking for, the public half of a key you already hold, and the extensions you would like copied across. Paste one and every field an issuer will read is printed, with plain observations beside it. The bytes stay on this device.

Examples

Form: pem (CERTIFICATE REQUEST)
Version: v1 (INTEGER 0)
Subject: C=GB, ST=London, L=Shoreditch, O=CSR Spike Ltd, OU=Ops, CN=csr.example.net, emailAddress=csr@example.net
Key: rsaEncryption (1.2.840.113549.1.1.1), 2048-bit modulus, exponent 65537
Signature: sha256WithRSAEncryption (1.2.840.113549.1.1.11), 2048-bit — presence reported, validity not checked
DER SHA-256: 0b8ebc76ad8d950b1aaaa2b0e851a2e9e27d1740249c6a219e7407d298b931b7
SPKI SHA-256: b0cf8de001fa8fe892a62052d7299218d319633d19fa77914b5e77da9e0d22a5
Requested extensions: 3
  subjectAltName (2.5.29.17)
    DNS: csr.example.net
    DNS: alt.csr.example.net
    DNS: *.csr.example.net
    IP: 203.0.113.5
    IP: 2001:db8::1
    email: csr@example.net
    URI: https://csr.example.net/enroll
    otherName: userPrincipalName: ops@example.net
  keyUsage (2.5.29.15)
    digitalSignature
    keyEncipherment
  basicConstraints (2.5.29.19)
    CA: false
Attributes: 3
  challengePassword (1.2.840.113549.1.9.7) — value hidden
  unstructuredName (1.2.840.113549.1.9.2) — csr-spike-unstructured [UTF8String]
  extensionRequest (1.2.840.113549.1.9.14)
Before you send:
  ok · CN_PRESENT — The subject common name is csr.example.net.
  ok · SUBJECT_MINIMAL — The subject holds 7 relative distinguished names.
  ok · EXTENSION_REQUEST_PRESENT — The extensionRequest attribute (1.2.840.113549.1.9.14) is present and carries 3 extension(s). This is the only place a CSR can ask for SANs or key usage.
  ok · SAN_PRESENT — A subjectAltName extension is requested, which is the list browsers actually match against.
  ok · SAN_COUNT — 8 subject alternative name(s) are requested, including the DNS name(s) csr.example.net, alt.csr.example.net, *.csr.example.net.
  ok · CN_IN_SAN — The common name csr.example.net is covered by the requested DNS SAN list.
  ok · WILDCARD_CN — The common name csr.example.net is not a wildcard.
  ok · KEY_STRENGTH — The key is RSA 2048-bit, at or above the 2048-bit floor public CAs have required since 2014 (CA/Browser Forum Baseline Requirements §6.1.5).
  ok · RSA_EXPONENT — The RSA public exponent is 65537, the value every mainstream generator emits.
  ok · SIGNATURE_DIGEST — This request is signed with sha256WithRSAEncryption. That signature is proof of possession of the private key — this tool reports that it is present and does not verify it.
  ok · CHALLENGE_PASSWORD_PRESENT — A challengePassword attribute is present (RFC 2985 §5.4.1). Its value is hidden here. Some enrolment systems require it; most public CAs ignore it, and it travels in the request in the clear.

The everyday case: alternative names, key usage and a challenge password, all arriving inside the extensionRequest attribute — the only place a request can ask for anything. The challenge value stays hidden.

MIHUMHsCAQAwGTEXMBUGA1UEAwwOZWMuZXhhbXBsZS5vcmcwWTATBgcqhkjOPQIB
BggqhkjOPQMBBwNCAARREvumcT0qK7jcr0OvRJ7sF0n6sWfOjlQ3puSo8lhCc6Gu
Uk3ZvVTfdcyIuPrfaQJ8dUbXlwgIhs3rB0ds0pdroAAwCgYIKoZIzj0EAwIDSQAw
RgIhAOuSCYWwzXZz/NtaOIgF1gmC8TnPMChoBuCQHtPgDEDhAiEAqQTWlxIFAsgq
4q0up02mVF/1LTz07+w+2uOsfkHczuM=

Form: base64
Version: v1 (INTEGER 0)
Subject: CN=ec.example.org
Key: id-ecPublicKey (1.2.840.10045.2.1), curve P-256
Signature: ecdsa-with-SHA256 (1.2.840.10045.4.3.2), 576-bit — presence reported, validity not checked
DER SHA-256: 3035734ba5a31fb676e91836bb2e2b19b405cf80cd78578d05e2c7841a09ac44
SPKI SHA-256: 63e3b86cbb85d88b9aedc23c6e4b3f1072c035fc95de372e9b1ee972715cee85
Requested extensions: 0
Attributes: 0
Before you send:
  ok · CN_PRESENT — The subject common name is ec.example.org.
  note · SUBJECT_MINIMAL — The subject holds one relative distinguished name. Public CAs issue against that for domain validation; organisation-validated products usually also require O, L, ST and C.
  missing · EXTENSION_REQUEST_PRESENT — There is no extensionRequest attribute, so this request asks for no extensions at all. Anything the certificate needs — SANs, key usage — would have to come from the CA's own profile.
  missing · SAN_PRESENT — No subjectAltName is requested. Browsers match a hostname only against the SAN list and ignore the common name entirely (RFC 6125 §6.4.4), so a certificate issued from this request would not match any name in a browser unless the CA adds one.
  missing · SAN_COUNT — The requested SAN list is empty.
  missing · CN_IN_SAN — There is no SAN list to compare the common name ec.example.org against.
  ok · WILDCARD_CN — The common name ec.example.org is not a wildcard.
  ok · KEY_STRENGTH — The key is an elliptic-curve key on P-256. Public CAs accept P-256, P-384 and P-521 (Baseline Requirements §6.1.5).
  ok · SIGNATURE_DIGEST — This request is signed with ecdsa-with-SHA256. That signature is proof of possession of the private key — this tool reports that it is present and does not verify it.
  missing · CHALLENGE_PASSWORD_PRESENT — There is no challengePassword attribute. Public CAs do not need one; some enterprise and SCEP enrolments do.
T_WHITESPACE: Whitespace and line breaks were ignored

A Base64 body with no fence around it, which needs no label to decode. This request asks for nothing at all: one common name, an elliptic-curve key, and not a single attribute.

308202b43082019c02010030313118301606035504030c0f7777772e6578616d
706c652e6f726731153013060355040a0c0c4d69736d61746368204c74643082
0122300d06092a864886f70d01010105000382010f003082010a0282010100d6
1b1c40d8d80d317e9c72f36cbd1cf7bf4f256c23d547b28bdc3501524a928b2a
a6525c70e2910837f1b19b4f8db417b75d7299337ee16fba3a0e9bc46c107eaf
dc84d82c35e9384e27d986a0601010793809b029dce2bfd55348d44f1728a510
c8998344c691df7331e8fbc5b384f8426769cd784b74370d357ce94e7aa73b3f
ab36c204eb2441c0abeb225d6e00198670455cd85e3a2fd16e82bb95ed55d371
5c5b08d6cef94221f0fa7ac32647b8844f684a6d6c2275d9c5d432718c5fbc90
0e2b6c0ef68abd12e078df5b68bb0212376a4cb518018a6a642af28f6145e28c
bbd764956253fb6ee5c3786d0533fdf3abcd857a0ef661ca912db401b8224f02
03010001a03e303c06092a864886f70d01090e312f302d302b0603551d110424
3022820f6170692e6578616d706c652e6f7267820f63646e2e6578616d706c65
2e6f7267300d06092a864886f70d01010b050003820101004597f4afd5b661da
22558eafd63a25b410e5b1047067f1d8fd23129d31b9932bd3a528cc46446e00
96eb7fa55e7f50e4205cd18da1d97e24d176f55966ea185b096f7254e32d9381
17537282199338e0f8a28e86c8998b764b783c5356bb1e5ef616a3523d98a56a
04d33a8eacd36be8ceb4a3483ceaf358397b3712643b842898359694ff198da7
403b0e1ab5aef84c943531763efb05877bf91748203fcf0ff9f114f6c2f9729d
a3c9be4b7d3caefc4e61fd4292ef6c6ac305d04a7ec97bdfee39f1c689ed9fb1
ea4d019a66005e92b4a94ffb14fd2cf23302b5a65485eacd2bbdbf38b3c99568
cd0b6313eb915f99cec876efe8f230f39b2aa3431d11aff1

Form: hex
Version: v1 (INTEGER 0)
Subject: CN=www.example.org, O=Mismatch Ltd
Key: rsaEncryption (1.2.840.113549.1.1.1), 2048-bit modulus, exponent 65537
Signature: sha256WithRSAEncryption (1.2.840.113549.1.1.11), 2048-bit — presence reported, validity not checked
DER SHA-256: 8c3a075793c60ebc9f3c02fec7cb776afb6310a3a607701d7ae88fb81635a6c1
SPKI SHA-256: b0cf8de001fa8fe892a62052d7299218d319633d19fa77914b5e77da9e0d22a5
Requested extensions: 1
  subjectAltName (2.5.29.17)
    DNS: api.example.org
    DNS: cdn.example.org
Attributes: 1
  extensionRequest (1.2.840.113549.1.9.14)
Before you send:
  ok · CN_PRESENT — The subject common name is www.example.org.
  ok · SUBJECT_MINIMAL — The subject holds 2 relative distinguished names.
  ok · EXTENSION_REQUEST_PRESENT — The extensionRequest attribute (1.2.840.113549.1.9.14) is present and carries 1 extension(s). This is the only place a CSR can ask for SANs or key usage.
  ok · SAN_PRESENT — A subjectAltName extension is requested, which is the list browsers actually match against.
  ok · SAN_COUNT — 2 subject alternative name(s) are requested, including the DNS name(s) api.example.org, cdn.example.org.
  note · CN_IN_SAN — The common name www.example.org does not appear in the requested SAN list (api.example.org, cdn.example.org). A browser would not accept a certificate issued from this request for www.example.org.
  ok · WILDCARD_CN — The common name www.example.org is not a wildcard.
  ok · KEY_STRENGTH — The key is RSA 2048-bit, at or above the 2048-bit floor public CAs have required since 2014 (CA/Browser Forum Baseline Requirements §6.1.5).
  ok · RSA_EXPONENT — The RSA public exponent is 65537, the value every mainstream generator emits.
  ok · SIGNATURE_DIGEST — This request is signed with sha256WithRSAEncryption. That signature is proof of possession of the private key — this tool reports that it is present and does not verify it.
  missing · CHALLENGE_PASSWORD_PRESENT — There is no challengePassword attribute. Public CAs do not need one; some enterprise and SCEP enrolments do.
T_SEPARATORS: Separators (colons/spaces/commas/line breaks) were ignored

Raw DER pasted as hex. The subject names one host, the requested list names two others, and a certificate issued from this would match neither name in its own subject.

This is a CERTIFICATE block, not a certificate request — it is what a CA sends back, not what you send them. Decode it with the certificate decoder.

The refusal you are likeliest to meet, and it is the answer rather than the question: a certificate carries an issuer, a validity window and someone else's signature.

MIICdTCCAV0CAQAwMDEbMBkGA1UEAwwSKi53aWxkLmV4YW1wbGUuY29tMREwDwYD
VQQKDAhXaWxkIEx0ZDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANYb
HEDY2A0xfpxy82y9HPe/TyVsI9VHsovcNQFSSpKLKqZSXHDikQg38bGbT420F7dd
cpkzfuFvujoOm8RsEH6v3ITYLDXpOE4n2YagYBAQeTgJsCnc4r/VU0jUTxcopRDI
mYNExpHfczHo+8WzhPhCZ2nNeEt0Nw01fOlOeqc7P6s2wgTrJEHAq+siXW4AGYZw
RVzYXjov0W6Cu5XtVdNxXFsI1s75QiHw+nrDJke4hE9oSm1sInXZxdQycYxfvJAO
K2wO9oq9EuB431touwISN2pMtRgBimpkKvKPYUXijLvXZJViU/tu5cN4bQUz/fOr
zYV6DvZhypEttAG4Ik8CAwEAAaAAMA0GCSqGSIb3DQEBBQUAA4IBAQCeEWeGWIJf
pqRP5kLnxmhMK4Xfv8hAZmBATjYcdzxT6Vsmi03ga7JSXi4hwUMMT/9rNCHjyaon
xdoz9lOAWMMG97MUOxddFZQmPL8Zw7daVyFcZBS+tG4LD+2f9zApvK02vcE7dAwD
uKYhrzZEkhhK4zn6lMDdCxuINT0mLkfsYily8VI+bE8h/s2yuYpnTWpk/3mfA4UF
3W1k3T2i7pLQSHz6fu9UoI5TYmSkC89S1S0XC0O8UpcZN4Qn85A3crcztLh+3mcq
PNo2rstheqRxoC7f7YXy93EmUZB5FUUqWok/8OVgvhzVfehLDyM4PK7quKXxkdGp
rx+PdO6FNRTP

Form: base64
Version: v1 (INTEGER 0)
Subject: CN=*.wild.example.com, O=Wild Ltd
Key: rsaEncryption (1.2.840.113549.1.1.1), 2048-bit modulus, exponent 65537
Signature: sha1WithRSAEncryption (1.2.840.113549.1.1.5), 2048-bit — presence reported, validity not checked
DER SHA-256: f9bd2203bfc4f105318e3da7171966c4b15583e94ef215c38bf08b2fd49b6a63
SPKI SHA-256: b0cf8de001fa8fe892a62052d7299218d319633d19fa77914b5e77da9e0d22a5
Requested extensions: 0
Attributes: 0
Before you send:
  ok · CN_PRESENT — The subject common name is *.wild.example.com.
  ok · SUBJECT_MINIMAL — The subject holds 2 relative distinguished names.
  missing · EXTENSION_REQUEST_PRESENT — There is no extensionRequest attribute, so this request asks for no extensions at all. Anything the certificate needs — SANs, key usage — would have to come from the CA's own profile.
  missing · SAN_PRESENT — No subjectAltName is requested. Browsers match a hostname only against the SAN list and ignore the common name entirely (RFC 6125 §6.4.4), so a certificate issued from this request would not match any name in a browser unless the CA adds one.
  missing · SAN_COUNT — The requested SAN list is empty.
  missing · CN_IN_SAN — There is no SAN list to compare the common name *.wild.example.com against.
  note · WILDCARD_CN — The common name *.wild.example.com is a wildcard. It matches one label only — wild.example.com itself is not covered unless it is also in the SAN list — and CAs validate wildcard requests differently from plain ones.
  ok · KEY_STRENGTH — The key is RSA 2048-bit, at or above the 2048-bit floor public CAs have required since 2014 (CA/Browser Forum Baseline Requirements §6.1.5).
  ok · RSA_EXPONENT — The RSA public exponent is 65537, the value every mainstream generator emits.
  note · SIGNATURE_DIGEST — This request is signed with sha1WithRSAEncryption, whose digest is SHA-1 or weaker. Many CA enrolment endpoints reject a request signed that way. The signature proves you hold the private key; it does not decide the digest the CA will sign the certificate with.
  missing · CHALLENGE_PASSWORD_PRESENT — There is no challengePassword attribute. Public CAs do not need one; some enterprise and SCEP enrolments do.
T_WHITESPACE: Whitespace and line breaks were ignored

Two observations worth having before an enrolment form returns them: a wildcard common name covers a single label, and SHA-1 in a signature algorithm is widely refused.

Every example on this page is executed against the same engine that powers the tool, on every build.

Gotchas worth knowing

Two spellings of the same fence

RFC 7468 §2 registers CERTIFICATE REQUEST, and openssl req -newhdr still writes NEW CERTIFICATE REQUEST; both open here, and the label found is reported. Text above the fence, Windows line endings and an unwrapped body are read as they arrive.

Version 0 is version 1

The version field holds INTEGER 0, which RFC 2986 §4.1 defines as v1 — the only version there has ever been. Both numbers are printed together, so a console and this page cannot look like they disagree.

A request with no subject in it

An empty subject is legal when identity lives in the requested subjectAltName, and it is equally what a broken template produces. The case is named rather than left blank, with the requested names printed beside it.

Identifiers this decoder cannot name

Enterprise enrolment is full of private arcs. An attribute or requested extension outside the registry keeps its dotted arc, its critical marker and its bytes, with a subtree in place and a control that copies that value as hex.

The cap, the key half, and what a link carries

One request at a time: 131072 characters of pasted text and 65536 bytes of DER, both named in the refusal, against a real RSA-4096 request of under two kilobytes. No field of the shared state can hold your input.

Common errors

This is a CERTIFICATE block, not a certificate request — it is what a CA sends back, not what you send them. Decode it with the certificate decoder.: The commonest mix-up, and the two do look alike from outside. The message names the label it found and stops there rather than half-reading the wrong structure.
These bytes do not open with the SEQUENCE that RFC 2986 §4 requires, so there is no certification request to read.: Bytes arrived and decoded, but the shape underneath is not a request — usually a fragment of a larger file, or a Base64 body that was cut short.
The certification request ends at byte 1030, but the input holds 3 more byte(s). A request ends with its signature, so the extra bytes are not part of it and were not decoded.: The request parsed completely and something followed it. The counts come from the decode itself, so a stray newline and a second blob pasted underneath are told apart by size.
This input is 200000 characters, over the 131072-character limit for a certificate request. A real CSR is a few kilobytes; paste just the request.: The character cap is measured before anything is decoded; the byte cap of 65536 applies after. Both are printed in the refusal, so neither has to be looked up.

FAQ

Why does openssl print my challengePassword as unable to print attribute?

Because that printer declines to render the attribute, not because the value is broken. Running openssl req -text over the first example prints exactly challengePassword :unable to print attribute, while the same request decodes here with its value read from the DER and shown masked.

Does a clean readout mean the authority will accept the request?

No. You get presence, not approval: the fields that were encoded, and observations tied to published thresholds such as the CA/Browser Forum Baseline Requirements on key size and exponent. Enrolment policies differ, and the signature is reported as present without being verified.

What happens to a private key pasted here by mistake?

It is refused rather than parsed, and the refusal says so. Its engine and island hold no fetch, XMLHttpRequest, sendBeacon, EventSource or WebSocket call, proved by grep on every test run, and the single link out of the tool does not prefetch — so nothing you paste is sent anywhere, and nothing you paste is stored.

Keyboard shortcuts

⌘/Ctrl + Enter: Copy the pane you are looking at, whichever one is open.
e: Expand or collapse every structure at once; single-key bindings honour the kill switch.
f: Cycle the input format: auto, then PEM, then hex, then Base64.

Nothing you paste here leaves this tab. State only ever travels in links you explicitly create.

RFC 2986 §4 — PKCS #10 CertificationRequest syntax · RFC 2985 §5.4 — PKCS #9 attributes: challengePassword, extensionRequest · RFC 5280 §4.1.2.4 — Name and RDNSequence · RFC 5280 §4.2.1.6 — Subject Alternative Name · RFC 7468 §2 — Textual encoding, CERTIFICATE REQUEST label · RFC 8017 §A.1 — RSASSA-PSS parameters · ITU-T X.690 — BER, CER and DER encoding rules

Last reviewed: 2026-08-18