# PKI Viewer — Manual

> Vollständige Funktionsbeschreibung des PKI Viewer: File Analyzer, PEM Decoder, alle Zertifikatsfelder, PKCS#7/12, MIME-Extraktion und Grenzen.

Source: https://www.jpkc.com/db/tools/pki/manual/

Zurück zur Übersicht: [PKI Viewer](https://www.jpkc.com/db/tools/pki/) · Tool live öffnen: [www.jpkc.com/tools/pki/](https://www.jpkc.com/tools/pki/)

Dieses Manual beschreibt den **PKI Viewer** vollständig: die vier Tabs, alle erkannten Dateiformate, welche Felder ein Zertifikat preisgibt und wie du sie liest, sowie die bewussten Grenzen des Tools. Die Oberfläche ist auf Englisch — die Labels stehen hier deshalb in ihrer englischen Originalschreibweise (mit deutscher Erläuterung), damit du dich im echten Interface wiederfindest.

## Aufbau der Oberfläche

Der PKI Viewer ist in vier Tabs gegliedert:

- **File Analyzer** — Dateien per Drag-and-drop oder Dateiauswahl analysieren (binär oder PEM).
- **PEM Decoder** — PEM-kodierten Text einfügen und dekodieren.
- **Help** — unterstützte Formate, Fähigkeiten und Grenzen, ein paar Tipps.
- **Reference** — Nachschlagewerk: Dateiendungen, Zertifikatsfelder, OpenSSL-Befehle, Vertrauensmodell.

Die ersten beiden Tabs sind die Arbeitsbereiche, die letzten beiden reine Dokumentation. Ein Hinweis-Banner am Seitenende fasst nochmal zusammen, dass alles im Browser bleibt.

## Tab „File Analyzer"

Hier analysierst du Dateien. Es gibt eine große **Drop-Zone** mit der Aufschrift „Drag & drop a file here" und darunter einen **Browse Files**-Knopf für den klassischen Datei-Dialog. Akzeptiert werden die Endungen `.pem`, `.crt`, `.cer`, `.der`, `.p7m`, `.p7s`, `.p7c`, `.p12`, `.pfx`, `.csr`, `.req` und `.key`.

Die Datei wird als Binärdaten eingelesen und automatisch erkannt. Die Reihenfolge der Erkennung:

1. Enthält der Inhalt `-----BEGIN …`, wird er als **PEM** verarbeitet (wie im PEM Decoder).
2. Endet der Dateiname auf `.p12`/`.pfx`, erscheint die Passwort-Zeile (siehe unten).
3. Andernfalls wird die Datei als **DER** (binär) interpretiert und nacheinander als X.509-Zertifikat, dann als PKCS#7/CMS, dann als CSR probiert.
4. Ist es zwar gültiges ASN.1, aber keines davon, meldet das Tool das ehrlich.

### Example und Clear

Über dem Ergebnisbereich liegen zwei Bedienelemente:

- Das **Example**-Dropdown lädt zwei mitgelieferte Beispiele: **Certificate Chain (2 certs)** — eine Kette aus End-Entity-Zertifikat (`www.example.com`) plus Root-CA — und **Signed P7M (with content)** — eine signierte `.p7m`-Datei mit extrahierbarem Textinhalt.
- **Clear** leert den Ergebnisbereich, das Passwortfeld und die Dateiauswahl.

### PKCS#12-Passwort

Erkennt der File Analyzer eine `.p12`- oder `.pfx`-Datei, blendet er eine Zeile **PKCS#12 Password** mit einem Passwortfeld und einem **Open**-Knopf ein. Du gibst das Container-Passwort ein und klickst **Open** (oder drückst Enter). Stimmt es, werden die enthaltenen Zertifikate und privaten Schlüssel angezeigt; stimmt es nicht, erscheint „Wrong password. Please try again.".

## Tab „PEM Decoder"

Dieser Tab nimmt **PEM-kodierten Text** in einem großen Eingabefeld entgegen. Du fügst den Text ein und klickst **Decode**. Ein **Example**-Knopf lädt ein selbstsigniertes Beispielzertifikat, **Clear** leert Ein- und Ausgabe.

Der Decoder erkennt anhand der Marker, worum es sich handelt:

- `-----BEGIN CERTIFICATE-----` → ein oder **mehrere** Zertifikate (alle Blöcke werden einzeln gerendert).
- `-----BEGIN PKCS7-----` / `-----BEGIN CMS-----` → PKCS#7/CMS-Container.
- `-----BEGIN CERTIFICATE REQUEST-----` (oder `NEW CERTIFICATE REQUEST`) → CSR.
- `-----BEGIN RSA PRIVATE KEY-----` / `-----BEGIN PRIVATE KEY-----` → privater Schlüssel.
- `-----BEGIN RSA PUBLIC KEY-----` / `-----BEGIN PUBLIC KEY-----` → öffentlicher Schlüssel.

Findet das Tool keinen bekannten Marker, meldet es „No recognized PEM markers found.". Mehrere Zertifikatsblöcke in einer Eingabe (typisch für eine Kette oder ein `.ca-bundle`) werden automatisch getrennt und gezählt.

## Was eine Zertifikatskarte zeigt

Für jedes erkannte Zertifikat rendert das Tool eine Karte. Im Kopf steht der **Common Name** des Subjects sowie — je nach Lage — die Badges **Self-signed** (Subject gleich Issuer), **CA** (laut Basic Constraints) und der Gültigkeits-Status. In der Tabelle darunter:

### Subject und Issuer

Die Distinguished Names von Inhaber (**Subject**) und Aussteller (**Issuer**), zusammengesetzt aus Komponenten wie `CN`, `O`, `OU`, `C`, `ST`, `L` und `E`. Sind Subject und Issuer identisch, ist das Zertifikat selbstsigniert.

### Serial Number

Die **Seriennummer** als großgeschriebener Hex-String mit Doppelpunkten als Trenner (z. B. `30:41:91:13:75:…`).

### Not Before / Not After

Der Gültigkeitszeitraum als ISO-8601-Zeitstempel in UTC. **Not After** wird zusätzlich farbig hervorgehoben, passend zum Status:

- **Valid** (grün) — gültig und mehr als 30 Tage entfernt vom Ablauf.
- **Expires in N days** (gelb) — läuft innerhalb der nächsten 30 Tage ab.
- **Expired** (rot) — Ablaufdatum bereits überschritten.
- **Not Yet Valid** (grau) — Beginn der Gültigkeit liegt noch in der Zukunft.

### Signature Algorithm

Der Signaturalgorithmus, übersetzt aus seinem OID. Erkannt werden u. a. `SHA-1/224/256/384/512 with RSA`, `RSA-PSS` sowie `ECDSA with SHA-1/256/384/512`. Ist der OID unbekannt, zeigt das Tool ihn als rohe Ziffernfolge.

### Public Key

Bei RSA-Schlüsseln **Typ und Bitlänge** (z. B. `RSA 2048 bit`). Für andere Schlüsseltypen — etwa EC — beschränkt sich das Tool auf eine Basis-Erkennung und zeigt unter Umständen `Unknown type`; eine vollständige Aufschlüsselung gibt es nur für RSA.

### SHA-1 und SHA-256 Fingerprint

Zwei **Fingerprints** über die DER-Kodierung des Zertifikats, als großgeschriebene Hex-Strings mit Doppelpunkten. Neben jedem steht ein Kopier-Knopf. Der Fingerprint ist der praktischste Wert, um zwei Zertifikate zweifelsfrei als identisch zu bestätigen.

### Subject Alt Names

Falls vorhanden, die **Subject Alternative Names** als Badges, je nach Typ mit Präfix `DNS:`, `URI:`, `IP:` oder `Email:`. Bei TLS-Server-Zertifikaten stehen hier die abgedeckten Hostnamen.

### Key Usage und Extended Key Usage

Die in der **Key Usage**-Erweiterung gesetzten Bits (z. B. `digitalSignature`, `keyEncipherment`, `keyCertSign`, `cRLSign`) und die **Extended Key Usage** (z. B. `serverAuth`, `clientAuth`, `codeSigning`, `emailProtection`, `timeStamping`, `OCSPSigning`), jeweils als Badges.

### Basic Constraints

Ob das Zertifikat ein CA-Zertifikat ist (`CA: Yes`/`No`) und, falls gesetzt, die Pfadlängen-Beschränkung (`Path Length`).

### PEM-Export

Im Fuß jeder Karte gibt es **Show PEM** (klappt den PEM-Block auf) und **Copy PEM** (kopiert das einzelne Zertifikat als PEM). So ziehst du etwa aus einer Kette gezielt ein einzelnes Zertifikat heraus.

## PKCS#7 / CMS und P7M-Inhalt

Bei einem PKCS#7- oder CMS-Container listet das Tool zunächst die **enthaltenen Zertifikate** (mit Anzahl) und rendert sie als Karten. Zusätzlich versucht es, den **eingekapselten Inhalt** (eContent) direkt aus der ASN.1-Struktur zu extrahieren — typisch bei signierten `.p7m`-Dateien.

Den extrahierten Inhalt erkennt das Tool über **Magic Bytes**: PDF, XML, HTML, ZIP (auch Office/OOXML), ältere MS-Office-Dateien, PNG, JPEG und GIF; alles andere wird als Text oder als Binärdaten eingestuft. Angezeigt werden Typ, Größe und ein vorgeschlagener Download-Name, bei Text zusätzlich eine Vorschau. Ein **Download**-Knopf speichert den Inhalt.

### Eingebettete MIME-E-Mail

Sieht der extrahierte Inhalt wie eine **MIME-E-Mail** aus (Header wie `From:`/`To:`/`Subject:`, ein `multipart/`-Content-Type mit Boundary o. Ä.), schlüsselt das Tool sie auf:

- **Header** — From, To, Cc, Bcc, Subject, Date, MIME-Version, Message-ID (RFC-2047-kodierte Werte werden dekodiert).
- **Text Body** und **HTML Body** — der HTML-Teil lässt sich zwischen Quelltext und einer **Preview** in einem abgeschotteten `sandbox`-iframe umschalten und kopieren.
- **Attachments** — jeder Anhang einzeln mit Name, Typ und Größe samt **Download**-Knopf; quoted-printable und Base64 werden dabei dekodiert.
- **Original (.eml)** — die rohe MIME-Quelle lässt sich als `.eml`-Datei herunterladen.

## PKCS#12 / PFX, CSR und Schlüssel

- **PKCS#12 / PFX:** Nach Eingabe des Passworts werden die enthaltenen **Zertifikate** und **privaten Schlüssel** angezeigt. Eine Schlüssel-Karte nennt bei RSA Typ und Bitlänge und bietet den PEM-Export.
- **CSR (PKCS#10):** Subject, öffentlicher Schlüssel (RSA-Bitlänge), Signaturalgorithmus und — falls im CSR enthalten — die Subject Alternative Names.
- **Privater Schlüssel:** Typ (RSA) und Bitlänge, mit PEM-Export.
- **Öffentlicher Schlüssel:** Typ (RSA) und Bitlänge.

## Tab „Help"

Reine Dokumentation im Tool: eine Tabelle der **unterstützten Formate**, je eine Liste **What This Tool Can Do** und **What This Tool Cannot Do** sowie Tipps — etwa wie du ein Zertifikat aus dem Browser exportierst (Schloss-Symbol in der Adressleiste → Zertifikatsdetails → als `.pem`/`.crt` exportieren) und nützliche OpenSSL-Befehle.

## Tab „Reference"

Ein kompaktes Nachschlagewerk: eine Tabelle gängiger **PKI-Dateiendungen** mit Standard, Kodierung und typischem Inhalt; eine **Zertifikatsfeld-Referenz** (DN-Komponenten mit OIDs und die wichtigsten X.509v3-Erweiterungen wie SAN, Key Usage, Basic Constraints, Authority/Subject Key Identifier, CRL Distribution Points, Authority Information Access, Certificate Policies); eine Sammlung **OpenSSL-Befehle** zum Ansehen, Konvertieren, Prüfen und Fingerprinten; und eine kurze Erklärung des **PKI-Vertrauensmodells** (Root-CA → Intermediate-CA → End-Entity).

## Grenzen und Datenschutz

- **Rein clientseitig:** Alles läuft über [node-forge](https://github.com/digitalbazaar/forge) (englisch) im Browser. Es gibt keinen Server, der Dateien entgegennimmt, und kein API. Zertifikate, private Schlüssel und PKCS#12-Passwörter verlassen dein Gerät nicht — überprüfbar im Netzwerk-Tab.
- **Nur Inspektion, keine Erzeugung:** Das Tool signiert und generiert nichts — keine Zertifikate, keine Schlüssel, keine CSRs.
- **Keine Vertrauensprüfung:** Es validiert **keine** Ketten gegen einen CA-Trust-Store und führt **keine** OCSP-/CRL-Sperrprüfung durch.
- **Kein Netzwerkzugriff zu Servern:** Es baut keine TLS-Verbindung auf und kann keine Server-Zertifikate aus der Ferne abrufen.
- **Passwortgeschützte private Schlüssel** kann es nicht entschlüsseln; unterstützt werden ausschließlich PKCS#12-Passwörter.
- **EC-Schlüssel:** nur Basis-Erkennung — Detailfelder gibt es derzeit nur für RSA.

Für den Einstieg und die Zielgruppen siehe die [Übersichtsseite](https://www.jpkc.com/db/tools/pki/). Konkrete Durchläufe stehen in den [Beispielen](https://www.jpkc.com/db/tools/pki/examples/), Strategie und Stolperfallen in den [Tipps & Tricks](https://www.jpkc.com/db/tools/pki/tips/). Ausprobieren kannst du alles direkt im [Tool](https://www.jpkc.com/tools/pki/).