std.pgp — OpenPGP (RFC 4880)

Das std.pgp-Paket implementiert OpenPGP-Format-Parsing und ASCII-Armor nach RFC 4880. Es ist eine reine Parser- und Codec-Bibliothek: Kein Schlüssel-Generieren, kein Verschlüsseln, kein Entschlüsseln, kein Signieren, kein Verifizieren — nur das Lesen und Kodieren von PGP-Datenstrukturen.

Typische Einsatzfälle: .asc-Dateien dekodieren, öffentliche Schlüssel aus Keyrings lesen, Key-IDs und Fingerprints extrahieren, PGP-Paket-Ströme inspizieren.

→ Units-Übersicht · Lyx-Sprache

RFC 4880 §6.1 schreibt CRC-24 als Prüfsumme im ASCII-Armor vor. Init: 0xB704CE, Polynom: 0x1864CFB.

import std.pgp.core;
import std.alloc;

fn main(): int64 {
    var data: pchar := "Hallo OpenPGP"c;
    var crc: int64 := PgpCrc24(data as int64, 13);
    // crc = 24-Bit Wert (Bits 23..0)
    return 0;
}

PgpArmorEncode ruft PgpCrc24 intern auf — bei normalem Armor-Workflow muss die Funktion nicht direkt aufgerufen werden.

ASCII-Armor kodiert beliebige Binärdaten als druckbaren Text im —–BEGIN PGP …—–-Format. PGP-Schlüssel und Signaturen werden fast immer in diesem Format ausgetauscht.

import std.pgp.armor;
import std.pgp.core;
import std.alloc;
import std.io;

fn EncodePublicKey(rawKey: int64, keyLen: int64): void {
    // Worst-Case: ca. 4/3 × Rohdaten + Header/Footer (~100 Bytes) + CRC
    var outMax: int64 := (keyLen * 4 / 3) + 200;
    var out: int64 := alloc(outMax);

    var encLen: int64 := PgpArmorEncode(rawKey, keyLen, PGP_ARMOR_PUBLIC_KEY, out, outMax);
    // out enthält jetzt:
    // -----BEGIN PGP PUBLIC KEY BLOCK-----
    //
    // <base64, 76 Zeichen/Zeile>
    // =<CRC4>
    // -----END PGP PUBLIC KEY BLOCK-----

    PrintLn(out as pchar);
    free(out, outMax);
}

PgpArmorEncode gibt die tatsächliche Ausgabelänge (ohne NUL-Byte) zurück. Die 76-Zeichen-Zeilen entstehen, weil immer 57 Eingangsbytes → 76 Base64-Zeichen kodiert werden.

import std.pgp.armor;
import std.pgp.core;
import std.alloc;

// Gibt rohe Binärdaten zurück (muss mit free freigegeben werden),
// oder 0 bei CRC-Fehler / ungültigem Armor.
fn DecodeArmor(armText: int64, armLen: int64, outLen: int64): int64 {
    var outMax: int64 := armLen;   // dekodiert immer kleiner als Armor-Text
    var out: int64 := alloc(outMax);

    var n: int64 := PgpArmorDecode(armText, armLen, out, outMax);
    if (n < 0) {
        free(out, outMax);
        return 0;   // CRC-Fehler oder kein gültiger Armor
    }

    poke64(outLen, n);
    return out;   // Aufrufer: free(out, outMax) nach Gebrauch
}

PgpArmorDecode überspringt Header-Attributzeilen (z. B. Version: GnuPG v2), liest alle Base64-Zeilen und verifiziert die CRC-24-Prüfsumme. Bei CRC-Fehler oder fehlendem BEGIN PGP-Header wird -1 zurückgegeben.

import std.pgp.armor;
import std.pgp.core;
import std.io;

fn PrintArmorType(arm: int64, armLen: int64): void {
    var tp: int64 := PgpArmorType(arm, armLen);
    if (tp == PGP_ARMOR_PUBLIC_KEY)  { PrintLn("Öffentlicher Schlüssel"); }
    if (tp == PGP_ARMOR_PRIVATE_KEY) { PrintLn("Privater Schlüssel"); }
    if (tp == PGP_ARMOR_MESSAGE)     { PrintLn("Nachricht"); }
    if (tp == PGP_ARMOR_SIGNATURE)   { PrintLn("Signatur"); }
    if (tp == PGP_ARMOR_UNKNOWN)     { PrintLn("Unbekannt"); }
}

PgpArmorType sucht nur nach dem BEGIN PGP …-Header, ohne die Daten zu dekodieren.

PGP-Binärdaten bestehen aus einer Folge von Paketen. PgpPacketFirst und PgpPacketNext iterieren über sie, ohne Kopien zu erstellen — PGP_PKT_OFF_BODY ist ein direkter Zeiger in den Quell-Buffer.

Der Aufrufer alloziert einen 32-Byte-Puffer (PGP_PKT_SIZE):

import std.pgp.core;
import std.pgp.packet;
import std.alloc;
import std.io;

fn ScanPackets(buf: int64, len: int64): void {
    var pkt: int64 := alloc(PGP_PKT_SIZE);

    if (PgpPacketFirst(buf, len, pkt) == 0) {
        PrintLn("Keine Pakete gefunden");
        free(pkt, PGP_PKT_SIZE);
        return;
    }

    var more: int64 := 1;
    while (more != 0) {
        var tag:  int64 := peek64(pkt + PGP_PKT_OFF_TAG);
        var body: int64 := peek64(pkt + PGP_PKT_OFF_BODY);
        var blen: int64 := peek64(pkt + PGP_PKT_OFF_BLEN);

        if (tag == PGP_TAG_PUBKEY)  { PrintLn("Öffentlicher Schlüssel (" + IntToStr(blen) + " Bytes)"); }
        if (tag == PGP_TAG_UID)     { PrintLn("User-ID"); }
        if (tag == PGP_TAG_SIG)     { PrintLn("Signatur"); }
        if (tag == PGP_TAG_PUBSUBKEY) { PrintLn("Öffentlicher Unterschlüssel"); }

        more := PgpPacketNext(buf, len, pkt);
    }

    free(pkt, PGP_PKT_SIZE);
}

Unterstützte Paket-Formate: Old-format (ll=0,1,2,3 gemäß RFC 4880 §4.2.1) und New-format (1-Byte-, 2-Byte-, 5-Byte-Längen gemäß §4.2.2). Partial-body-Header werden als vollständige Pakete behandelt.

Alle Funktionen arbeiten auf dem Paket-Body — d.h. dem Buffer-Bereich, der über PGP_PKT_OFF_BODY / PGP_PKT_OFF_BLEN erreichbar ist, ohne den Paket-Header (Tag-Byte + Längenfeld).

import std.pgp.core;
import std.pgp.packet;
import std.pgp.key;
import std.alloc;
import std.io;

fn PrintKeyInfo(buf: int64, len: int64): void {
    var pkt: int64 := alloc(PGP_PKT_SIZE);

    if (PgpPacketFirst(buf, len, pkt) == 0) {
        free(pkt, PGP_PKT_SIZE); return;
    }

    var more: int64 := 1;
    while (more != 0) {
        var tag:  int64 := peek64(pkt + PGP_PKT_OFF_TAG);
        var body: int64 := peek64(pkt + PGP_PKT_OFF_BODY);
        var blen: int64 := peek64(pkt + PGP_PKT_OFF_BLEN);

        if (tag == PGP_TAG_PUBKEY || tag == PGP_TAG_PUBSUBKEY) {
            var ver:  int64 := PgpKeyVersion(body, blen);
            var algo: int64 := PgpKeyAlgo(body, blen);
            var ts:   int64 := PgpKeyTimestamp(body, blen);

            PrintLn("Version: " + IntToStr(ver));
            PrintLn("Zeitstempel: " + IntToStr(ts));

            if (algo == PGP_ALG_RSA)    { PrintLn("Algorithmus: RSA"); }
            if (algo == PGP_ALG_DSA)    { PrintLn("Algorithmus: DSA"); }
            if (algo == PGP_ALG_ECDSA)  { PrintLn("Algorithmus: ECDSA"); }
            if (algo == PGP_ALG_EDDSA)  { PrintLn("Algorithmus: EdDSA"); }
            if (algo == PGP_ALG_ECDH)   { PrintLn("Algorithmus: ECDH"); }
        }

        more := PgpPacketNext(buf, len, pkt);
    }

    free(pkt, PGP_PKT_SIZE);
}

PgpKeyFingerprint und PgpKeyId funktionieren nur bei v4-Schlüsseln. Bei v3-Schlüsseln geben sie 0 zurück.

import std.pgp.core;
import std.pgp.packet;
import std.pgp.key;
import std.alloc;
import std.io;

fn PrintFingerprint(buf: int64, len: int64): void {
    var pkt: int64 := alloc(PGP_PKT_SIZE);
    var fp:  int64 := alloc(20);
    var kid: int64 := alloc(8);

    if (PgpPacketFirst(buf, len, pkt) != 0) {
        var tag:  int64 := peek64(pkt + PGP_PKT_OFF_TAG);
        var body: int64 := peek64(pkt + PGP_PKT_OFF_BODY);
        var blen: int64 := peek64(pkt + PGP_PKT_OFF_BLEN);

        if (tag == PGP_TAG_PUBKEY && PgpKeyFingerprint(body, blen, fp) != 0) {
            // Fingerprint hex ausgeben (20 Bytes)
            var i: int64 := 0;
            while (i < 20) {
                var b: int64 := peek8(fp + i);
                Print(IntToStr((b >> 4) & 15));   // Oberes Nibble
                Print(IntToStr(b & 15));           // Unteres Nibble
                i := i + 1;
            }
            PrintLn("");
        }

        if (tag == PGP_TAG_PUBKEY && PgpKeyId(body, blen, kid) != 0) {
            // Key-ID = letzte 8 Bytes des Fingerprints
            Print("Key-ID: ");
            var i: int64 := 0;
            while (i < 8) {
                Print(IntToStr(peek8(kid + i)));
                i := i + 1;
            }
            PrintLn("");
        }
    }

    free(pkt, PGP_PKT_SIZE);
    free(fp, 20);
    free(kid, 8);
}

Der Fingerprint wird nach RFC 4880 §12.2 berechnet: SHA-1 über 0x99 || uint16_BE(blen) || body. Die Key-ID sind die letzten 8 Bytes des Fingerprints (Bytes 12–19).

import std.pgp.core;
import std.pgp.armor;
import std.pgp.packet;
import std.pgp.key;
import std.alloc;
import std.fs;
import std.io;

fn ReadAscFile(path: int64): void {
    // Datei laden
    var fsize: int64 := FileSize(path);
    if (fsize <= 0) { return; }
    var armBuf: int64 := alloc(fsize);
    ReadFile(path, armBuf, fsize);

    // Armor-Typ prüfen
    var tp: int64 := PgpArmorType(armBuf, fsize);
    if (tp != PGP_ARMOR_PUBLIC_KEY) {
        PrintLn("Kein öffentlicher Schlüssel");
        free(armBuf, fsize);
        return;
    }

    // Armor dekodieren
    var rawBuf: int64 := alloc(fsize);
    var rawLen: int64 := PgpArmorDecode(armBuf, fsize, rawBuf, fsize);
    free(armBuf, fsize);

    if (rawLen < 0) {
        PrintLn("CRC-Fehler oder ungültiger Armor");
        free(rawBuf, fsize);
        return;
    }

    // Pakete durchlaufen
    var pkt: int64 := alloc(PGP_PKT_SIZE);
    var fp:  int64 := alloc(20);
    if (PgpPacketFirst(rawBuf, rawLen, pkt) != 0) {
        var more: int64 := 1;
        while (more != 0) {
            var tag:  int64 := peek64(pkt + PGP_PKT_OFF_TAG);
            var body: int64 := peek64(pkt + PGP_PKT_OFF_BODY);
            var blen: int64 := peek64(pkt + PGP_PKT_OFF_BLEN);

            if (tag == PGP_TAG_PUBKEY) {
                PrintLn("Hauptschlüssel v" + IntToStr(PgpKeyVersion(body, blen)));
                PgpKeyFingerprint(body, blen, fp);
                // fp enthält 20-Byte SHA-1 Fingerprint
            }
            if (tag == PGP_TAG_UID) {
                // User-ID-Body ist ein UTF-8-String
                poke8(body + blen, 0);   // NUL-terminieren (temporär)
                PrintLn("UID: " + (body as pchar));
            }
            if (tag == PGP_TAG_PUBSUBKEY) {
                PrintLn("Unterschlüssel (" + IntToStr(blen) + " Bytes)");
            }
            more := PgpPacketNext(rawBuf, rawLen, pkt);
        }
    }

    free(pkt, PGP_PKT_SIZE);
    free(fp, 20);
    free(rawBuf, fsize);
}

Hinweis zum User-ID-Body: Das body-Feld zeigt direkt in den Quell-Buffer. Das temporäre NUL-Terminieren (poke8(body + blen, 0)) setzt das erste Byte des nächsten Pakets auf 0. Nur sicher, wenn der Buffer danach nicht mehr vollständig iteriert werden muss — sonst eine Kopie anlegen.

Letzte Aktualisierung: 2026-06-15