csr_peek 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 942630258469d6c7e50b6951a51a49ea4c357ef1cf12e861de5af23aaa1fa735
+  data.tar.gz: ed71dc05821135752ae788f53b671b1e2529dbac44bcdeece3394cb5492b71b1
+SHA512:
+  metadata.gz: 3dd1f46b568fafd5903ec3ec88b99e39174514018e89d06d97583bc28192fd26293420277ae16c13e3babcebf231a4f8d23f6b8c7234ee7570703aa35a527f5f
+  data.tar.gz: 474826a92e714615048836ee660f1585b06cfc35e0e89b242ed4f8f7205f1261ff2d18a56d07e21f0804c742de5330d969860a154df6f7564c34f6051fd30821

data/CHANGELOG.md

@@ -0,0 +1,62 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Initial release.
+- `CsrPeek.parse` and `CsrPeek.parse_certificate`, returning nil on bad input.
+- `CsrPeek.parse!` and `CsrPeek.parse_certificate!`, raising
+  `CsrPeek::ParseError` with a reason when you want to know why input failed.
+- Subject, common name, and categorized Subject Alternative Names.
+- Key type, size, curve, SPKI fingerprint, and CA/Browser Forum weak-key check.
+- Whole-object fingerprints for CSRs and certificates.
+- Certificate signature algorithm and a `weak_signature?` check (flags MD5/SHA-1).
+- Certificate `ca?`, `path_length`, `key_usage`, `extended_key_usage`, and
+  `version`.
+- Certificate validity split into `valid_at?`, `expired?`, and `not_yet_valid?`.
+- `CsrPeek::Policy`, a pluggable issuance policy (minimum key sizes, key-type
+  and curve allowlists, a compromised-key SPKI blocklist, and weak-signature
+  hashes), with a `BASELINE` default. Keys and certificates gain
+  `acceptable_key?`/`acceptable?` and `key_policy_violations`/`policy_violations`.
+- `CsrPeek.parse_certificates` for reading every certificate in a PEM bundle
+  (a chain / `fullchain.pem`) in order.
+- A `csr_peek` command-line tool that prints a CSR or certificate as JSON.
+- Value semantics on `Csr` and `Certificate`: `==`/`eql?`/`hash` keyed on the
+  canonical DER (two parses of the same bytes are equal and hash-compatible),
+  and a concise `#inspect`.
+
+### Changed
+
+- **Requires Ruby 3.2+.** `Csr` and `Certificate` are now immutable `Data`
+  value objects. Every fact is resolved once, in a single guarded pass at parse
+  time, into frozen members; the objects are thread-safe and cannot be mutated.
+  Build them via `CsrPeek.parse`/`parse_certificate` or `.from_openssl`. The raw
+  OpenSSL object remains available as `#openssl`.
+- Subject Alternative Names, `key_usage`, `extended_key_usage`, and
+  `basicConstraints` are decoded from the DER rather than OpenSSL's display
+  string. SAN values containing commas (a `directoryName` between RDNs) are no
+  longer split, IPv6 renders canonically, and usage names are the stable RFC
+  identifiers (`digitalSignature`, `serverAuth`) instead of localized labels.
+- `weak_key?` now answers a purely cryptographic question. Ed25519/Ed448 are
+  no longer reported as weak, and DSA is judged by size; whether a key is
+  *permitted for issuance* moved to `acceptable_key?(policy)`.
+- `all_names` is now SAN-driven: the DNS SANs when present, falling back to the
+  Common Name only when there are none.
+- A public key that cannot be loaded now degrades to safe values (unknown type,
+  weak key, nil fingerprint) everywhere instead of letting an OpenSSL exception
+  escape from `weak_key?`/`to_h`.
+- Subject and SAN views are frozen, so a caller cannot mutate a memoized result.
+- `serial` is normalized to lower-case, even-length hex.
+
+### Internal
+
+- Reading logic shared by both value objects lives in a prepended
+  `CsrPeek::Inspectable`; key facts are extracted once by `CsrPeek::KeyFacts`;
+  distinguished-name and extension decoding live in `CsrPeek::Names` and
+  `CsrPeek::Extensions`. The wrappers cannot drift, and no accessor re-touches
+  the raise-prone key-loading path.

data/LICENSE

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

data/README.md

@@ -0,0 +1,240 @@
+# CsrPeek
+
+A friendlier, safe way to read certificate signing requests and X.509
+certificates in Ruby.
+
+The standard library can parse a CSR, but the ergonomics are rough: subjects
+come back as nested arrays, Subject Alternative Names are buried in a requested-
+extensions attribute you have to walk by hand, and a single malformed upload
+raises an `OpenSSL` exception that becomes a 500 if you forget to rescue it.
+CsrPeek wraps all of that in a small, memoized, never-raises API.
+
+## Why it exists
+
+- **Safe by default.** `CsrPeek.parse` returns `nil` for junk input - including
+  a certificate whose key cannot be loaded. A bad paste never becomes an
+  exception in your request path. Want the reason instead? Use `parse!`.
+- **The parts you actually want.** Subject, common name, and categorized SANs
+  (DNS, IP, email, URI) without ASN.1 spelunking. SANs are decoded from the DER,
+  so a comma inside a value never splits it and IPv6 renders canonically.
+- **Key and signature hygiene built in.** Key type, size, EC curve, a stable
+  SubjectPublicKey fingerprint, a `weak_key?` strength check, and a
+  `weak_signature?` check that flags MD5/SHA-1 certificates. Issuance rules live
+  in a pluggable `CsrPeek::Policy` (`acceptable_key?`), separate from raw
+  strength - so "strong but not permitted" (Ed25519 under the Baseline
+  Requirements) is expressible.
+- **Immutable value objects.** `Csr` and `Certificate` are frozen `Data`
+  structs - every fact is resolved once, at parse time, into frozen members.
+  They are safe to share across threads, compare by value (two parses of the
+  same bytes are `==` and usable as hash keys), and cannot be mutated.
+- **No dependencies.** Only `openssl` and `ipaddr`, both from the standard
+  library.
+
+## Installation
+
+Requires Ruby 3.2 or newer.
+
+```ruby
+gem "csr_peek"
+```
+
+Then `bundle install`, or `gem install csr_peek`.
+
+## Usage
+
+### Certificate signing requests
+
+```ruby
+require "csr_peek"
+
+csr = CsrPeek.parse(pem_or_der_string)   # => CsrPeek::Csr, or nil
+# CsrPeek.parse!(bad_input)              # raises CsrPeek::ParseError with a reason
+
+csr.common_name        # => "example.com"
+csr.subject            # => { "CN" => "example.com", "O" => "Example Inc" }
+csr.dns_names          # => ["example.com", "www.example.com"]
+csr.ip_addresses       # => ["192.0.2.10"]
+csr.all_names          # => ["example.com", "www.example.com"]  (DNS SANs, else CN)
+
+csr.signature_valid?   # => true   (self-signature verifies)
+csr.key_type           # => "RSA"
+csr.key_bits           # => 2048
+csr.weak_key?          # => false  (RSA < 2048 or EC < 256 would be true)
+csr.acceptable?        # => true   (satisfies the Baseline Requirements policy)
+
+csr.spki_fingerprint(:sha256) # => stable identity of the public key
+csr.fingerprint(:sha256)      # => digest of the whole CSR
+
+csr.to_h               # => a flat summary hash
+```
+
+### Certificates
+
+```ruby
+cert = CsrPeek.parse_certificate(pem_or_der_string) # => CsrPeek::Certificate, or nil
+
+cert.common_name         # => "example.com"
+cert.issuer              # => { "CN" => "Example Root CA" }
+cert.serial              # => "0a1b2c"  (lower-case, even-length hex)
+cert.version             # => 3
+cert.not_before          # => Time
+cert.not_after           # => Time
+cert.valid_at?           # => true   (now within [not_before, not_after])
+cert.expired?            # => false  (now past not_after)
+cert.not_yet_valid?      # => false  (now before not_before)
+cert.expired?(Time.now + 86_400) # check against a specific moment
+cert.self_signed?        # => true/false
+
+cert.ca?                 # => false  (basicConstraints CA:TRUE)
+cert.path_length         # => nil    (pathLenConstraint, when set)
+cert.key_usage           # => ["digitalSignature", "keyEncipherment"]
+cert.extended_key_usage  # => ["serverAuth", "clientAuth"]
+
+cert.signature_algorithm # => "sha256WithRSAEncryption"
+cert.weak_signature?     # => false  (true for MD5/SHA-1)
+
+cert.dns_names           # => ["example.com"]
+cert.spki_fingerprint(:sha256)
+```
+
+`key_usage`, `extended_key_usage`, and `basicConstraints` are decoded from the
+DER, not from OpenSSL's display string, so their names are the stable RFC
+identifiers (`digitalSignature`, `serverAuth`) rather than the localized labels.
+
+`valid_at?`, `expired?`, and `not_yet_valid?` split what a single `expired?`
+would conflate: `expired?` is strictly "past `not_after`", and a certificate
+whose window has not begun is `not_yet_valid?`, not expired.
+
+### Certificate chains
+
+`parse_certificate` reads the first block of its input. For a `fullchain.pem`
+or any PEM bundle, use `parse_certificates` (plural), which returns one
+`Certificate` per block, in order, skipping any that don't parse:
+
+```ruby
+CsrPeek.parse_certificates(File.read("fullchain.pem")).map(&:common_name)
+# => ["example.com", "Example Intermediate CA"]
+```
+
+## Weak keys vs. acceptable keys
+
+Two different questions, kept deliberately separate:
+
+**`weak_key?` - is the key cryptographically too small to be safe?** Strength
+only, no policy:
+
+| Key type | Weak when |
+| --- | --- |
+| RSA | modulus < 2048 bits |
+| EC | curve degree < 256 bits |
+| DSA | parameter size < 2048 bits |
+| Ed25519 / Ed448 | never (these are strong) |
+| unloadable | always (cannot verify => not trusted) |
+
+**`acceptable_key?(policy)` - may I *issue* against this key?** That is a policy
+decision, and it takes a `CsrPeek::Policy`. The default is the CA/Browser Forum
+Baseline Requirements, under which an Ed25519 key is `weak_key? => false` but
+`acceptable_key? => false` (strong, but not permitted for public TLS). Raise the
+bar without monkey-patching:
+
+```ruby
+strict = CsrPeek::Policy.new(
+  min_rsa_bits: 3072,
+  allowed_curves: %w[secp384r1],
+  blocked_spki_fingerprints: known_roca_fingerprints # matched by SPKI
+)
+
+csr.acceptable_key?(strict)       # => false
+csr.key_policy_violations(strict) # => [:rsa_too_small]
+```
+
+For certificates, `acceptable?` also folds in `weak_signature?` (true for MD5/
+SHA-1), and `policy_violations` returns the combined reasons.
+
+The `spki_fingerprint` is the right value to check against known weak- or
+compromised-key lists (Debian OpenSSL, ROCA) - pass them as
+`blocked_spki_fingerprints` - because it identifies the key itself, not the
+request or certificate that happens to carry it.
+
+## Command line
+
+The gem ships a `csr_peek` executable that prints a CSR or certificate as JSON.
+Kind is auto-detected from the PEM header; `--csr` / `--cert` force it.
+
+```bash
+csr_peek request.csr            # from a file
+csr_peek --cert server.pem      # force certificate parsing
+cat request.csr | csr_peek      # from stdin
+```
+
+It exits 0 on a readable input and 1 on a parse failure.
+
+## Escape hatch
+
+Every value object keeps the underlying OpenSSL object on `#openssl`, for the
+occasional thing CsrPeek does not surface:
+
+```ruby
+cert.openssl # => OpenSSL::X509::Certificate
+csr.openssl  # => OpenSSL::X509::Request
+```
+
+## Scope
+
+CsrPeek inspects. It does not build trust chains, verify against a root store,
+or check revocation. Pair it with a proper verification step when you need
+those.
+
+## Handling untrusted input
+
+CsrPeek is built to be handed attacker-controlled PEM/DER, but two things are
+the caller's responsibility:
+
+- **Escape the values you display or log.** Every name and SAN value
+  (`common_name`, `subject`, `issuer`, `dns_names`, SAN `email`/`uri`/`other`)
+  comes straight from the input and may contain newlines, control characters,
+  or markup. CsrPeek reports them faithfully; it does not sanitize. Escape
+  before rendering into HTML, logs, or a shell.
+- **Size is bounded, not unbounded.** Input larger than `CsrPeek::MAX_INPUT_BYTES`
+  (1 MiB) is rejected up front (`parse`/`parse_certificate` return `nil`,
+  `parse!` raises), and `parse_certificates` returns at most
+  `CsrPeek::MAX_CHAIN_CERTIFICATES` (100) certificates from one bundle, so a
+  malicious paste cannot exhaust memory or CPU.
+
+Signature and self-signature checks (`signature_valid?`, `self_signed?`) run
+real crypto and are opt-in - they are not performed during parsing.
+
+## Compatibility
+
+- Ruby >= 3.2.0 (the value objects are built on `Data`)
+- Zero external dependencies (`openssl` and `ipaddr` ship with Ruby)
+- Immutable, thread-safe value objects
+- Linux, macOS, Windows
+
+## Development
+
+The repo pins a Ruby version in `.tool-versions`.
+
+```bash
+bundle install
+bundle exec rake spec      # run the tests
+bundle exec standardrb     # lint (Standard Ruby)
+```
+
+Tests generate their own keys at runtime, so there is no checked-in key
+material.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b feature/my-feature`)
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+CI runs the test suite (Ruby 3.2–3.4), Standard Ruby, and a gem build on every
+pull request.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

data/exe/csr_peek

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "csr_peek"
+require "json"
+require "time"
+
+# Peek at a CSR or certificate and print its summary as JSON.
+#
+#   csr_peek path/to/request.csr
+#   csr_peek --cert path/to/cert.pem
+#   cat request.csr | csr_peek
+#
+# Kind is auto-detected from the PEM header; --csr / --cert force it. Exits 0 on
+# a readable input, 1 on a parse failure or bad usage.
+module CsrPeek
+  module CLI
+    module_function
+
+    USAGE = <<~TXT
+      Usage: csr_peek [--csr | --cert] [FILE]
+
+      Reads a certificate signing request or an X.509 certificate (PEM or DER)
+      from FILE, or from stdin when FILE is omitted, and prints its details as
+      JSON.
+
+        --csr    force CSR parsing
+        --cert   force certificate parsing
+        -h       show this help
+    TXT
+
+    def run(argv)
+      force = nil
+      paths = []
+      argv.each do |arg|
+        case arg
+        when "--csr" then force = :csr
+        when "--cert" then force = :cert
+        when "-h", "--help" then warn USAGE
+                                 return 0
+        when /\A-/ then warn "unknown option: #{arg}\n\n#{USAGE}"
+                        return 1
+        else paths << arg
+        end
+      end
+      return usage_error("at most one FILE is allowed") if paths.size > 1
+
+      input = read_input(paths.first)
+      object = parse(input, force)
+      return failure(paths.first) if object.nil?
+
+      puts JSON.pretty_generate(jsonify(object.to_h))
+      0
+    rescue Errno::ENOENT
+      usage_error("no such file: #{paths.first}")
+    end
+
+    def read_input(path)
+      path ? File.read(path) : $stdin.read
+    end
+
+    # Force the kind when asked; otherwise sniff the PEM header, defaulting to
+    # CSR and falling back to certificate so a headerless DER still gets a try.
+    def parse(input, force)
+      case force
+      when :csr then CsrPeek.parse(input)
+      when :cert then CsrPeek.parse_certificate(input)
+      else
+        if input.include?("CERTIFICATE REQUEST")
+          CsrPeek.parse(input)
+        elsif input.include?("BEGIN CERTIFICATE")
+          CsrPeek.parse_certificate(input)
+        else
+          CsrPeek.parse(input) || CsrPeek.parse_certificate(input)
+        end
+      end
+    end
+
+    # Render Time values as ISO-8601 so the JSON is unambiguous.
+    def jsonify(hash)
+      hash.transform_values { |v| v.is_a?(Time) ? v.iso8601 : v }
+    end
+
+    def failure(path)
+      warn "could not parse #{path || "stdin"} as a CSR or certificate"
+      1
+    end
+
+    def usage_error(message)
+      warn "#{message}\n\n#{USAGE}"
+      1
+    end
+  end
+end
+
+exit CsrPeek::CLI.run(ARGV)

data/lib/csr_peek/certificate.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "openssl"
+require_relative "policy"
+require_relative "names"
+require_relative "extensions"
+require_relative "key_facts"
+require_relative "inspectable"
+
+module CsrPeek
+  # A friendly, read-only view over an OpenSSL::X509::Certificate.
+  #
+  # An immutable value object: build one with CsrPeek.parse_certificate (which
+  # returns nil for junk input) or Certificate.from_openssl. Parsed facts are
+  # resolved once into frozen members. This class inspects; it does not build
+  # trust chains or perform revocation checks.
+  Certificate = Data.define(
+    :openssl, :public_key, :key_type, :key_bits, :ec_curve,
+    :subject, :subject_components, :subject_alt_names,
+    :issuer, :key_usage, :extended_key_usage, :basic_constraints
+  ) do
+    prepend Inspectable
+
+    def self.from_openssl(cert)
+      pkey = load_public_key(cert)
+      facts = KeyFacts.of(pkey)
+      new(
+        openssl: cert,
+        public_key: pkey,
+        key_type: facts[:type],
+        key_bits: facts[:bits],
+        ec_curve: facts[:curve],
+        subject: Names.subject_to_h(cert.subject).freeze,
+        subject_components: Names.components(cert.subject).freeze,
+        subject_alt_names: Extensions.subject_alt_names(find_ext(cert, "subjectAltName")),
+        issuer: Names.subject_to_h(cert.issuer).freeze,
+        key_usage: Extensions.key_usages(find_ext(cert, "keyUsage")).freeze,
+        extended_key_usage: Extensions.extended_key_usages(find_ext(cert, "extendedKeyUsage")).freeze,
+        basic_constraints: Extensions.basic_constraints(find_ext(cert, "basicConstraints")).freeze
+      )
+    end
+
+    def self.load_public_key(cert)
+      cert.public_key
+    rescue OpenSSL::PKey::PKeyError, OpenSSL::X509::CertificateError
+      nil
+    end
+    private_class_method :load_public_key
+
+    def self.find_ext(cert, oid)
+      cert.extensions.find { |e| e.oid == oid }
+    rescue OpenSSL::X509::CertificateError
+      nil
+    end
+    private_class_method :find_ext
+
+    # Serial as lower-case hex, zero-padded to an even number of digits.
+    def serial
+      hex = openssl.serial.to_s(16).downcase
+      hex.length.odd? ? "0#{hex}" : hex
+    end
+
+    # X.509 version as the human-facing number: 1, 2, or 3 (the DER field is
+    # zero-based, so v3 is stored as 2).
+    def version
+      openssl.version + 1
+    end
+
+    def not_before
+      openssl.not_before
+    end
+
+    def not_after
+      openssl.not_after
+    end
+
+    # True when now falls within [not_before, not_after].
+    def valid_at?(now = Time.now)
+      now.between?(not_before, not_after)
+    end
+
+    # True when now is after not_after. "expired" means the window has passed;
+    # a certificate whose window has not begun is #not_yet_valid?, not expired.
+    def expired?(now = Time.now)
+      now > not_after
+    end
+
+    def not_yet_valid?(now = Time.now)
+      now < not_before
+    end
+
+    def self_signed?
+      openssl.subject == openssl.issuer && openssl.verify(public_key)
+    rescue OpenSSL::X509::CertificateError, OpenSSL::PKey::PKeyError, TypeError
+      false
+    end
+
+    # The signature algorithm name, e.g. "sha256WithRSAEncryption".
+    def signature_algorithm
+      openssl.signature_algorithm
+    rescue OpenSSL::X509::CertificateError
+      nil
+    end
+
+    # True when signed with a hash the policy rejects (MD5/SHA-1 by default).
+    def weak_signature?(policy = Policy::BASELINE)
+      policy.weak_signature?(signature_algorithm)
+    end
+
+    # True when both the key and the signature satisfy the issuance policy.
+    def acceptable?(policy = Policy::BASELINE)
+      acceptable_key?(policy) && !weak_signature?(policy)
+    end
+
+    # All policy reasons this certificate is unacceptable, as symbols; empty
+    # when it passes. Combines key violations with :weak_signature.
+    def policy_violations(policy = Policy::BASELINE)
+      violations = key_policy_violations(policy)
+      violations << :weak_signature if weak_signature?(policy)
+      violations
+    end
+
+    # Whether this certificate may act as a CA (basicConstraints CA:TRUE).
+    def ca?
+      basic_constraints[:ca]
+    end
+
+    # The pathLenConstraint from basicConstraints, or nil when unset.
+    def path_length
+      basic_constraints[:path_length]
+    end
+
+    def to_h
+      {
+        subject: subject,
+        issuer: issuer,
+        common_name: common_name,
+        serial: serial,
+        version: version,
+        not_before: not_before,
+        not_after: not_after,
+        expired: expired?,
+        not_yet_valid: not_yet_valid?,
+        self_signed: self_signed?,
+        ca: ca?,
+        path_length: path_length,
+        key_usage: key_usage,
+        extended_key_usage: extended_key_usage,
+        dns_names: dns_names,
+        ip_addresses: ip_addresses,
+        all_names: all_names,
+        key_type: key_type,
+        key_bits: key_bits,
+        weak_key: weak_key?,
+        acceptable: acceptable?,
+        signature_algorithm: signature_algorithm,
+        weak_signature: weak_signature?,
+        spki_fingerprint_sha256: spki_fingerprint(:sha256),
+        fingerprint_sha256: fingerprint(:sha256)
+      }
+    end
+  end
+end

data/lib/csr_peek/csr.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "openssl"
+require_relative "policy"
+require_relative "names"
+require_relative "extensions"
+require_relative "key_facts"
+require_relative "inspectable"
+
+module CsrPeek
+  # OIDs under which a CSR carries its requested X.509 extensions.
+  EXT_REQUEST_OIDS = %w[extReq msExtReq].freeze
+
+  # A friendly, read-only view over an OpenSSL::X509::Request.
+  #
+  # An immutable value object: build one with CsrPeek.parse (which returns nil
+  # for junk input) or Csr.from_openssl. Every fact is resolved once, in a
+  # single guarded pass, into frozen members - so no accessor can raise, and
+  # the object is safe to share across threads. The raw request stays available
+  # as #openssl for anything this wrapper does not surface.
+  Csr = Data.define(
+    :openssl, :public_key, :key_type, :key_bits, :ec_curve,
+    :subject, :subject_components, :subject_alt_names
+  ) do
+    prepend Inspectable
+
+    # Build a Csr from an OpenSSL::X509::Request, resolving every fact safely.
+    def self.from_openssl(request)
+      pkey = load_public_key(request)
+      facts = KeyFacts.of(pkey)
+      new(
+        openssl: request,
+        public_key: pkey,
+        key_type: facts[:type],
+        key_bits: facts[:bits],
+        ec_curve: facts[:curve],
+        subject: Names.subject_to_h(request.subject).freeze,
+        subject_components: Names.components(request.subject).freeze,
+        subject_alt_names: Extensions.subject_alt_names(san_extension(request))
+      )
+    end
+
+    def self.load_public_key(request)
+      request.public_key
+    rescue OpenSSL::PKey::PKeyError, OpenSSL::X509::RequestError
+      nil
+    end
+    private_class_method :load_public_key
+
+    # Dig the requested subjectAltName out of the requested-extensions
+    # attribute, or nil. Any structural surprise yields nil, not an exception.
+    def self.san_extension(request)
+      attr = request.attributes.find { |a| EXT_REQUEST_OIDS.include?(a.oid) }
+      return nil if attr.nil?
+
+      Array(attr.value.first&.value).each do |ext_asn1|
+        ext = OpenSSL::X509::Extension.new(ext_asn1)
+        return ext if ext.oid == "subjectAltName"
+      end
+      nil
+    rescue
+      nil
+    end
+    private_class_method :san_extension
+
+    # True when the CSR's self-signature checks out against its own key.
+    def signature_valid?
+      key = public_key
+      return false if key.nil?
+
+      openssl.verify(key)
+    rescue OpenSSL::X509::RequestError, OpenSSL::PKey::PKeyError
+      false
+    end
+    alias_method :valid?, :signature_valid?
+
+    # True when the requested key satisfies the issuance policy (Baseline
+    # Requirements by default). See CsrPeek::Policy.
+    def acceptable?(policy = Policy::BASELINE)
+      acceptable_key?(policy)
+    end
+
+    def to_h
+      {
+        subject: subject,
+        common_name: common_name,
+        dns_names: dns_names,
+        ip_addresses: ip_addresses,
+        all_names: all_names,
+        key_type: key_type,
+        key_bits: key_bits,
+        ec_curve: ec_curve,
+        weak_key: weak_key?,
+        acceptable: acceptable?,
+        signature_valid: signature_valid?,
+        spki_fingerprint_sha256: spki_fingerprint(:sha256),
+        fingerprint_sha256: fingerprint(:sha256)
+      }
+    end
+  end
+end