sgcSign 2026.5 — Authenticode, EU-eIDAS-Paket & 9 Arbeitsverhältnis-Profile

· Versionen

Nur einen Monat nach dem ursprünglichen Launch liefert sgcSign 2026.5 eine umfangreiche Erweiterung der Bibliothek. Diese Version ergänzt die Microsoft-Authenticode-Signierung für Windows-Binärdateien, drei neue Signierer für die Code-Verteilung (ClickOnce, NuGet, VSIX), ein vollständiges EU-eIDAS-Konformitätspaket (ASiC-Container, LOTL-/EUTL-Vertrauensliste, Fernsignierung über das Cloud Signature Consortium), neun vorkonfigurierte länderspezifische Arbeitsverhältnis-Profile, ein bulgarisches Peppol BIS Billing 3.0-Profil, einen nativen QR-Code-Generator, Unterstützung für ECDSA P-256/384/521 sowie RSA-PSS, vollständige CI/CD-Integrationen und einen umfangreichen Satz an XAdES-/PFX-Konformitätsfehlerbehebungen.

Dieser Beitrag stellt die wichtigsten Neuerungen vor, mit sofort einsetzbaren Delphi-Codeausschnitten für jede neue Komponente.

Microsoft Authenticode

TsgcAuthenticodeSigner signiert Windows-PE-Dateien (.exe, .dll, .sys) gemäß der Authenticode-Spezifikation. Der Signierer analysiert die PE-Datei, bildet den Hash mit dem Authenticode-Algorithmus (wobei die Prüfsumme und die vorhandene Zertifikatstabelle übersprungen werden), erstellt einen vollständigen PKCS#7-SignedData-Block mit dem SPC-Indirect-Data-Inhalt und hängt ihn an die Zertifikatstabelle der Binärdatei an.

Hashes von SHA-1 bis SHA-512 werden unterstützt, RFC-3161-Zeitstempel werden als unsignierte Attribute eingebettet, und AppendSignature := True erzeugt verschachtelte Signaturen (z. B. SHA-1 + SHA-256 als Doppelsignatur für die Kompatibilität mit älteren Windows-Versionen).

uses
  sgcSign_Authenticode, sgcSign_KeyProvider_PFX, sgcSign_TSAClient;

var
  oSigner: TsgcAuthenticodeSigner;
  oPFX: TsgcPFXKeyProvider;
  oTSA: TsgcTSAClient;
begin
  oPFX := TsgcPFXKeyProvider.Create(nil);
  oPFX.FileName := 'codesign.pfx';
  oPFX.Password := 'secret';

  oTSA := TsgcTSAClient.Create(nil);
  oTSA.URL := 'http://timestamp.digicert.com';

  oSigner := TsgcAuthenticodeSigner.Create(nil);
  try
    oSigner.KeyProvider := oPFX;
    oSigner.TSAClient   := oTSA;
    oSigner.Hash        := ahSHA256;     // ahSHA1 / ahSHA256 / ahSHA384 / ahSHA512
    oSigner.Level       := alT;          // alBES or alT (with timestamp)
    oSigner.Description := 'My Application';
    oSigner.URL         := 'https://www.example.com';
    oSigner.SignFile('MyApp.exe', 'MyApp-signed.exe');
  finally
    oSigner.Free; oTSA.Free; oPFX.Free;
  end;
end;

Die Verifizierung erfolgt symmetrisch. TsgcAuthenticodeVerifier.Verify liefert einen Record mit dem Ergebnis, den berechneten und eingebetteten Hashes, dem Subject/Issuer des Signierers sowie der Information, ob ein Zeitstempel vorhanden ist:

var
  oVer: TsgcAuthenticodeVerifier;
  oRes: TsgcAuthenticodeVerifyResult;
begin
  oVer := TsgcAuthenticodeVerifier.Create(nil);
  try
    oRes := oVer.Verify('MyApp-signed.exe');
    if oRes.Valid then
      ShowMessage('Signed by ' + oRes.SubjectName)
    else
      ShowMessage('Invalid: ' + oRes.ErrorMessage);
  finally
    oVer.Free;
  end;
end;

Authenticode-Signierung nur über Hash

Bei großen CI-Artefakten (Installer, Laufzeitumgebungen, Treiber) ist das Hochladen der vollständigen PE-Datei an einen Remote-Signierer mühsam. Der neue Hash-only-Signierfluss erlaubt es dem Client, den Authenticode-Hash lokal zu berechnen und nur den 32 Byte langen Digest an den sgcSign-Server zu senden. Der Server liefert den nicht angehängten PKCS#7-Block zurück, und der Client bettet diesen wieder in die Binärdatei ein — was Uploads von mehreren Megabyte auf wenige KB reduziert, ein Vorteil auf Agenten mit eingeschränkter Bandbreite.

// Local: compute the hash with sgcSign_PE_Hasher, POST it to the server,
// receive the SignedData blob, then append it to the PE's certificate table.
var
  oSigner: TsgcAuthenticodeSigner;
  vHash, vPKCS7: TBytes;
begin
  // vHash := ComputePEHash('MyApp.exe', haSHA256);
  vPKCS7 := oSigner.SignHash(vHash, ahSHA256);
  // EmbedPKCS7IntoPE('MyApp.exe', vPKCS7, 'MyApp-signed.exe');
end;

Derselbe Vorgang wird über den Endpunkt POST /api/v1/sign/authenticode/hash des Servers, das CLI-Flag sgcsign sign --prehash und die Methode TsgcSignClient.SignAuthenticodeHashAsync im .NET-SDK bereitgestellt.

ClickOnce-, NuGet- und VSIX-Signierer

Drei neue Signierer decken das Microsoft-Entwicklerverteilungs-Ökosystem ab.

TsgcClickOnceSigner signiert Bereitstellungsmanifeste .application und Anwendungsmanifeste .exe.manifest mit eingebettetem W3C-XML-DSig und liefert dieselbe Ausgabe wie Microsofts mage.exe. Der Signierer überschreibt den Knoten publisherIdentity mit dem issuerKeyHash des Zertifikats.

uses sgcSign_ClickOnce;

var oCO: TsgcClickOnceSigner;
begin
  oCO := TsgcClickOnceSigner.Create(nil);
  try
    oCO.KeyProvider   := oPFX;
    oCO.Hash          := haSHA256;
    oCO.PublisherName := 'My Company';
    oCO.SignManifestFile('MyApp.application', 'MyApp-signed.application');
  finally
    oCO.Free;
  end;
end;

TsgcNuGetSigner signiert Author-Pakete .nupkg und erzeugt einen CMS-/PKCS#7-SignedData-Block (Signing Certificate v2, Commitment-Type "proof of origin") mit optionaler RFC-3161-Gegensignatur.

uses sgcSign_NuGet;

var oNu: TsgcNuGetSigner;
begin
  oNu := TsgcNuGetSigner.Create(nil);
  try
    oNu.KeyProvider := oPFX;
    oNu.TSAClient   := oTSA;
    oNu.Hash        := haSHA256;
    oNu.SignPackageFile('MyLib.1.0.0.nupkg', 'MyLib.1.0.0.signed.nupkg');
  finally
    oNu.Free;
  end;
end;

TsgcVSIXSigner implementiert digitale OPC-Signaturen (Open Packaging Convention) für Visual-Studio-Erweiterungen, berechnet je Teil XML-DSig-Referenzen und schreibt [Content_Types].xml sowie die Datei _rels/.rels des Pakets neu.

uses sgcSign_VSIX;

var oVX: TsgcVSIXSigner;
begin
  oVX := TsgcVSIXSigner.Create(nil);
  try
    oVX.KeyProvider := oPFX;
    oVX.Hash        := haSHA256;
    oVX.SignPackageFile('MyExt.vsix', 'MyExt-signed.vsix');
  finally
    oVX.Free;
  end;
end;

Alle drei verwenden dieselbe IsgcKeyProvider-Schnittstelle wie die bestehenden XAdES-/PAdES-/CAdES-Signierer, sodass ein für die Rechnungssignierung konfiguriertes AWS-KMS-, Azure-Trusted-Signing- oder PKCS#11-Token ohne zusätzlichen Aufwand auch für die Binärsignierung wiederverwendet werden kann.

EU-eIDAS-/Konformitätspaket

Diese Version führt das eIDAS-Paket ein — drei neue Units, die es einer Delphi-Anwendung gemeinsam ermöglichen, eine Signatur anhand des offiziellen EU-Vertrauensrahmens zu validieren und Container für die Langzeitarchivierung zu erzeugen.

ASiC-Container (ETSI EN 319 162-1)

sgcSign_ASiC erstellt und parst ASiC-S-Container (ein Dokument) und ASiC-E-Container (mehrere Dokumente), jeweils in XAdES- und CAdES-Variante. Die Ausgabe ist ein deterministisches ZIP-Archiv, bei dem der Eintrag mimetype zuerst steht und die Signatur unter META-INF/ abgelegt wird.

uses sgcSign_ASiC;

var
  oDocs: TsgcASiCDocumentArray;
  vBytes: TBytes;
begin
  SetLength(oDocs, 1);
  oDocs[0].Name := 'invoice.xml';
  oDocs[0].Data := TFile.ReadAllBytes('invoice.xml');

  // aSignatureXML comes from TsgcXAdESSigner (detached signature over the doc)
  vBytes := TsgcASiCContainer.BuildXAdES(apASiCE, oDocs, vXAdESSignature);
  TFile.WriteAllBytes('invoice.asice', vBytes);
end;

LOTL-/EUTL-Vertrauensliste

sgcSign_TrustList lädt die EU-Liste vertrauenswürdiger Listen herunter, folgt den Zeigern auf die Vertrauenslisten der einzelnen Mitgliedstaaten und parst jeden TSPService-Eintrag. Das Ergebnis ist ein In-Memory-Katalog mit ca. 3.600 Diensten aus 31 Mitgliedstaaten. Die Abfrage IsQualifiedAtTime klassifiziert jedes Zertifikat zu einem bestimmten Signaturzeitpunkt als "von einem qualifizierten TSP ausgestellt" — die Operation, die für die Hochstufung einer Signatur von fortgeschritten (AdES) zu qualifiziert (QES) gemäß Artikel 25 der eIDAS-Verordnung erforderlich ist.

Cloud Signature Consortium (CSC v2)

TsgcCSCKeyProvider ist eine IsgcKeyProvider-Implementierung für die API v2 des Cloud Signature Consortium — der europäische Standard für die qualifizierte Fernsignierung, der von Buypass, Certinomis, Globalsign EU, InfoCert, Namirial, Trust Pro und anderen QTSPs verwendet wird. Der Provider unterstützt Basic-/OAuth2-/OTP-Authentifizierung, listet die Anmeldedaten des Benutzers auf, ruft die Zertifikatskette ab und führt mithilfe der SAD-Autorisierung eine Hash-only-Fernsignierung durch.

uses sgcSign_KeyProvider_CSC, sgcSign_XAdES;

var oCSC: TsgcCSCKeyProvider; oX: TsgcXAdESSigner;
begin
  oCSC := TsgcCSCKeyProvider.Create(nil);
  oCSC.BaseURL    := 'https://csc.example-qtsp.eu/csc/v2';
  oCSC.AuthMethod := cscOAuth2;
  oCSC.OAuthClientID     := 'my-client-id';
  oCSC.OAuthClientSecret := 'my-client-secret';
  oCSC.CredentialID      := oCSC.ListCredentials[0];
  oCSC.PIN := '1234';
  oCSC.OTP := '987654';      // pushed via SMS / app
  oCSC.LoadCredentialInfo;

  oX := TsgcXAdESSigner.Create(nil);
  oX.KeyProvider := oCSC;
  oX.Profile     := spEIDAS;
  oX.SignXML(vXML);
end;

Neun Arbeitsverhältnis-Profile

Neun vorkonfigurierte Profile zielen auf europäische arbeitsrechtliche Dokumente ab (Arbeitsverträge, Lohnabrechnungen, Übertragungsvereinbarungen):

ProfilLandStufeC14NTSAOCSP
spEmploymentDEDeutschlandB-LTExclusiveJaJa
spEmploymentITItalienB-LTC14N 1.0JaJa
spEmploymentESSpanienB-TExclusiveJaNein
spEmploymentFRFrankreichB-TExclusiveJaNein
spEmploymentPLPolenB-TExclusiveJaNein
spEmploymentATÖsterreichB-LTExclusiveJaJa
spEmploymentBEBelgienB-LTExclusiveJaJa
spEmploymentPTPortugalB-LTExclusiveJaJa
spEmploymentNLNiederlandeB-TExclusiveJaNein

Eine neue EU_Employment-Demo liefert die vollständige Pipeline (Signieren → ASiC-E-Paket → LOTL-Verifizierung → QTSP-Klassifizierung).

Bulgarisches Peppol BIS Billing 3.0

Das neue Profil TsgcProfilePeppolBG signiert bulgarische UBL-2.1-Rechnungen (Währung BGN, 20 % Mehrwertsteuer, BG-USt-ID/EIK, BG-IBAN, Endpunkt mit Schema-ID 9926) mit XAdES B-T und Exclusive C14N. Die Delphi- und C++Builder-Demos enthalten eine vollständig ausgefüllte Rechnungsvorlage.

uses sgcSign_XAdES, sgcSign_Types;

var oSigner: TsgcXAdESSigner;
begin
  oSigner := TsgcXAdESSigner.Create(nil);
  try
    oSigner.KeyProvider := oPFX;
    oSigner.TSAClient   := oTSA;
    oSigner.Profile     := spPeppolBG;
    oSigner.SignXMLFile('invoice_bg.xml', 'invoice_bg_signed.xml');
  finally
    oSigner.Free;
  end;
end;

CI/CD-Integrationen

sgcSign Server liefert nun erstklassige Artefakte für jede gängige Pipeline:

QR-Code-Generator

Für TicketBAI, VeriFactu und ähnliche Profile, die einen QR-Code auf der druckbaren Rechnung erfordern, liefert die neue Unit sgcSign_QRCode einen rein in Pascal geschriebenen Generator, der ISO/IEC 18004 im Byte-Modus implementiert — alle vier ECC-Stufen, Versionen 1 bis 40, GF(256) Reed-Solomon, vollständige Mask-Penalty-Bewertung — samt TBitmap-Renderer. Keine externe DLL, keine Lizenzüberraschungen.

uses sgcSign_QRCode, Graphics;

var
  oMatrix: TQRMatrix;
  oBmp: TBitmap;
begin
  oMatrix := GenerateQRCode(
    'https://tbai.eus/QURL/123456789-A?cr=42',
    qrECM);

  oBmp := TBitmap.Create;
  try
    RenderQRMatrix(oMatrix, oBmp, 5, 4);    // 5 px / module, 4-module border
    oBmp.SaveToFile('invoice_qr.bmp');
  finally
    oBmp.Free;
  end;
end;

ECDSA P-256 / P-384 / P-521 und RSA-PSS

TsgcPEMKeyProvider importiert nun EC-Private-Keys über Windows BCrypt CNG (ECCPRIVATEBLOB) und signiert mit roher r||s-Ausgabe für XML-DSig. Eine neue Methode SignDataPSS erzeugt RSA-PSS-Signaturen (SHA-256, Salt = 32 Byte) unter Verwendung von BCRYPT_PAD_PSS — erforderlich für eine wachsende Anzahl nationaler E-Rechnungsprofile.

Auf der Verifizierungsseite importiert TsgcSignatureVerifier öffentliche EC-Schlüssel aus BCRYPT_ECCPUBLIC_BLOB und validiert ECDSA-Signaturen für dieselben drei Kurven sowohl im Codepfad SignatureValue von XAdES als auch im rohen VerifyData-Pfad.

Damit dies funktioniert, parst TsgcX509Certificate nun die Erweiterung KeyUsage und stellt sie über die Eigenschaft KeyUsage sowie die Hilfsfunktionen HasKeyUsageDigitalSignature / HasKeyUsageNonRepudiation bereit; außerdem liefert die neue Eigenschaft PublicKeyParameters die rohen AlgorithmIdentifier-Parameter-TLV (die OID der benannten Kurve bei EC-Zertifikaten).

WideString-Overloads für Delphi 7

Für Aufrufer, die Nicht-ACP-Text übergeben (polnisches KSeF, griechisches myDATA, bulgarisches Peppol usw.), stellt die öffentliche Signier- und Verifizierungs-API nun WideString-Overloads für TsgcXAdESSigner.SignXML, SignXMLDetached, SignXMLEnveloping bereit (sowie die entsprechenden Methoden in TsgcDocumentSigner und TsgcSignatureVerifier). Dies garantiert verlustfreies Unicode beim Ein- und Ausgang in Delphi 7 — ohne ACP-Hin-und-Rück-Konvertierung — und entspricht den string-Overloads ab Delphi 2009.

Konformitäts- und Zuverlässigkeitsfehlerbehebungen

Der Bugfix-Batch in 2026.5 schließt eine lange Liste von XAdES-/PFX-/Verifier-Problemen, die bei Tests gegen produktive Steuerbehörden-Endpunkte aufgedeckt wurden.

Aktualisierung

2026.5 ist ein Drop-in-Upgrade für bestehende 2026.4-Projekte. Die einzige Verhaltensänderung, auf die man achten sollte, betrifft TsgcDocumentSigner: Code, der davon ausging, dass die Komponente für die AdES-Profile einfaches XML-DSig erzeugt, produziert nun korrektes XAdES — genau das, was die Steuerbehörden verlangt haben. Falls Ihre Integrationstests jedoch an die alte Ausgabe gebunden waren, müssen Sie die Referenzdateien aktualisieren.

Kunden mit aktivem Abonnement können den neuen Build im Kundenbereich herunterladen. Trial-Anwender erhalten den aktualisierten Installer unter esegece.com/products/sgcsign/sgcsign-download.

Fragen, Feedback oder Hilfe bei der Migration? Kontaktieren Sie uns — Sie erhalten eine Antwort von den Personen, die den Code geschrieben haben.