Schlüsselanbieter — sgcSign

ANBIETER 1 / 10

`TsgcPFXKeyProvider`

PFX/PKCS#12-Dateien. Lokaler, passwortgeschützter Schlüssel. Ideal für Entwicklung, kleinere Deployments und jeden Workflow, bei dem das Zertifikat als einzelne .pfx/.p12-Datei ausgeliefert wird.

Import über Windows CNG mit PKCS12_PREFER_CNG_KSP — SHA-256/384/512-Signaturen funktionieren unabhängig vom ursprünglichen CSP.
Multi-Zert-.pfx-Dateien werden automatisch durchlaufen, bis das Zertifikat mit dem privaten Schlüssel gefunden ist.

pfx.pas

var
  vPFX: TsgcPFXKeyProvider;
begin
  vPFX := TsgcPFXKeyProvider.Create(nil);
  try
    vPFX.FileName := 'certificate.pfx';
    vPFX.Password := 'mypassword';
    vPFX.LoadFromFile;
    // vSigner.KeyProvider := vPFX;
  finally
    vPFX.Free;
  end;
end;

ANBIETER 2 / 10

`TsgcPEMKeyProvider`

PEM-Dateien. Verschlüsseltes PKCS#8 mit nativer Unterstützung für PBES2/PBKDF2/AES-CBC sowie das alte RSA-Privatschlüsselformat DEK-Info. Ideal für OpenSSL-basierte Pipelines.

BEGIN CERTIFICATE, BEGIN RSA PRIVATE KEY, BEGIN PRIVATE KEY, BEGIN ENCRYPTED PRIVATE KEY werden alle unterstützt.
Kombinierte PEMs (Zertifikat + Schlüssel in einer Datei) werden automatisch erkannt — lass PrivateKeyFile einfach leer.

pem.pas

var
  vPEM: TsgcPEMKeyProvider;
begin
  vPEM := TsgcPEMKeyProvider.Create(nil);
  try
    vPEM.CertificateFile := 'cert.pem';
    vPEM.PrivateKeyFile  := 'key.pem';
    vPEM.PrivateKeyPassword := 'secret';
    vPEM.LoadFromFile;
    // vSigner.KeyProvider := vPEM;
  finally
    vPEM.Free;
  end;
end;

ANBIETER 3 / 10

`TsgcWindowsCertStoreProvider`

Windows-Zertifikatsspeicher. Local-Machine- und Current-User-Speicher. Ideal für Desktop-Apps, die bestehende AD-ausgestellte Zertifikate nutzen, oder für Deployments, in denen Windows den Lebenszyklus der Zertifikate bereits verwaltet.

Die Signatur erfolgt über Windows CNG — der private Schlüssel verlässt den Speicher nie.
Auswahl über CN-Substring im Subject oder über SHA-1-Thumbprint.

winstore.pas

var
  vStore: TsgcWindowsCertStoreProvider;
begin
  vStore := TsgcWindowsCertStoreProvider.Create(nil);
  try
    vStore.StoreName := 'MY';
    vStore.StoreLocation := cslCurrentUser;
    vStore.SelectCertificateBySubject('My Company');
    // vSigner.KeyProvider := vStore;
  finally
    vStore.Free;
  end;
end;

ANBIETER 4 / 10

`TsgcPKCS11Provider`

PKCS#11/Hardware-Tokens. Smartcards, USB-Tokens, HSMs — SafeNet, YubiKey, Nitrokey, Thales. Für Qualifizierte Elektronische Signaturen in den meisten EU-Staaten erforderlich.

CKM_RSA_PKCS- und CKM_ECDSA_SHA256-Mechanismen werden unterstützt.
Helfer EnumerateSlots/EnumerateCertificates zur Auswahl des richtigen Slots zur Laufzeit.

pkcs11.pas

var
  vTok: TsgcPKCS11Provider;
begin
  vTok := TsgcPKCS11Provider.Create(nil);
  try
    vTok.LibraryPath := 'C:\token\pkcs11.dll';
    vTok.SlotIndex := 0;
    vTok.PIN := '1234';
    vTok.CertificateLabel := 'MyCert';
    vTok.Connect;
    // vSigner.KeyProvider := vTok;
  finally
    vTok.Free;
  end;
end;

ANBIETER 5 / 10

`TsgcAzureTrustedSigningProvider`

Azure Trusted Signing. Microsofts qualifizierter Code-Signing-Dienst. Authenticode ohne den Kauf eines EV-Zertifikats — Microsoft ist Eigentümer des Zertifikats und stellt den Signaturschlüssel für dich bereit.

OAuth2 Client Credentials — Tenant-ID + Client-ID + Client Secret.
Private Schlüssel verbleiben vollständig in Azure und nie auf dem Build-Agent.

azure-ts.pas

var
  vAzure: TsgcAzureTrustedSigningProvider;
begin
  vAzure := TsgcAzureTrustedSigningProvider.Create(nil);
  try
    vAzure.TenantId := 'your-tenant-id';
    vAzure.ClientId := 'your-client-id';
    vAzure.ClientSecret := 'your-client-secret';
    vAzure.AccountName := 'mySigningAccount';
    vAzure.CertificateProfileName := 'default';
    vAzure.Connect;
    // vSigner.KeyProvider := vAzure;
  finally
    vAzure.Free;
  end;
end;

ANBIETER 6 / 10

`TsgcAWSKMSKeyProvider`

AWS Key Management Service. Amazons HSM-gestützter Schlüsselverwahrdienst. Kombiniere ihn mit einem AWS-ausgestellten Zertifikat für In-Cloud-Signaturen, ohne den privaten Schlüssel offenzulegen.

AWS Signature Version 4-Authentifizierung, im Prozess berechnet.
KeyId akzeptiert Key-ID, Key-ARN oder Alias-ARN.

aws-kms.pas

var
  vAWS: TsgcAWSKMSKeyProvider;
begin
  vAWS := TsgcAWSKMSKeyProvider.Create(nil);
  try
    vAWS.AccessKeyId := 'AKIAIOSFODNN7EXAMPLE';
    vAWS.SecretAccessKey := 'wJalrXUtnFEMI/K7MDENG/...';
    vAWS.Region := 'us-east-1';
    vAWS.KeyId := 'arn:aws:kms:us-east-1:...:key/my-key';
    vAWS.Connect;
    // vSigner.KeyProvider := vAWS;
  finally
    vAWS.Free;
  end;
end;

ANBIETER 7 / 10

`TsgcGCloudKMSKeyProvider`

Google Cloud KMS. Dasselbe Betriebsmodell wie AWS KMS. Die JSON-Datei des Dienstkontos authentifiziert sich per JWT-Austausch gegen ein OAuth2-Access-Token und signiert dann über die Cloud KMS API.

ProjectId + Location + KeyRing + Key + Version — entspricht 1:1 der GCP-Ressourcenhierarchie.
Nur asymmetrische KMS-Schlüssel — HSM-gestützt, sofern verfügbar, ansonsten softwaregeschützt.

gcloud-kms.pas

var
  vGCloud: TsgcGCloudKMSKeyProvider;
begin
  vGCloud := TsgcGCloudKMSKeyProvider.Create(nil);
  try
    vGCloud.ProjectId := 'my-project';
    vGCloud.LocationId := 'global';
    vGCloud.KeyRingId := 'my-key-ring';
    vGCloud.KeyId := 'my-signing-key';
    vGCloud.KeyVersion := '1';
    vGCloud.ServiceAccountJSON := 'C:\keys\sa.json';
    vGCloud.Connect;
    // vSigner.KeyProvider := vGCloud;
  finally
    vGCloud.Free;
  end;
end;

ANBIETER 8 / 10

`TsgcHashiCorpVaultKeyProvider`

HashiCorp Vault. Die Transit-Secrets-Engine von Vault führt die Signatur aus. Ideal für selbst gehostete, richtlinienbasierte Schlüsselverwahrung, wenn Vault bereits Teil des Stacks ist.

Die Transit-Engine verwaltet nur den Schlüssel — das Zertifikat lieferst du über SetCertificateFromFile.
Token-basierte Authentifizierung; der Mount-Pfad ist standardmäßig 'transit'.

vault.pas

var
  vVault: TsgcHashiCorpVaultKeyProvider;
begin
  vVault := TsgcHashiCorpVaultKeyProvider.Create(nil);
  try
    vVault.VaultAddress := 'https://vault.example.com:8200';
    vVault.Token := 's.myVaultToken';
    vVault.MountPath := 'transit';
    vVault.KeyName := 'my-signing-key';
    vVault.Connect;
    vVault.SetCertificateFromFile('C:\certs\signing-cert.pem');
    // vSigner.KeyProvider := vVault;
  finally
    vVault.Free;
  end;
end;

ANBIETER 9 / 10

`TsgcCertumSimplySignProvider`

Certum SimplySign. Polnischer QTSP. Qualifizierte elektronische Signaturen über eine per Mobile App autorisierte PIN, ohne USB-Token. Häufige Wahl für polnische KSeF- und ZUS-Workflows.

OAuth2 Client Credentials + SimplySign-Konto Benutzername/Passwort + PIN.
ListCertificates gibt jedes im Konto verfügbare Zertifikat aus.

certum.pas

var
  vCertum: TsgcCertumSimplySignProvider;
begin
  vCertum := TsgcCertumSimplySignProvider.Create(nil);
  try
    vCertum.ClientId := 'your-client-id';
    vCertum.ClientSecret := 'your-client-secret';
    vCertum.Username := 'user@example.com';
    vCertum.Password := 'account-password';
    vCertum.PIN := '123456';
    vCertum.BaseURL := 'https://cloudsign.certum.pl';
    vCertum.Connect;
    // vSigner.KeyProvider := vCertum;
  finally
    vCertum.Free;
  end;
end;

ANBIETER 10 / 10

`TsgcCSCKeyProvider`

Cloud Signature Consortium API v2. Generisches Interface zu jedem QTSP, der CSC v2 implementiert — Universign, D-Trust sign-me, A-Trust, FNMT Cl@ve Firma, Evrotrust, Intesi Group. Der Anbieter hält den qualifizierten Schlüssel in einem entfernten QSCD; sgcSign sendet nur den Dokumenten-Hash.

Drei Auth-Modi: cscBasic, cscOAuth2, cscOTP (Einmalpasswort für 2FA).
Ruft credentials/authorize + signatures/signHash gemäß CSC v2-Spezifikation auf.

csc-v2.pas

var
  vCSC: TsgcCSCKeyProvider;
  vCreds: TStringArray;
begin
  vCSC := TsgcCSCKeyProvider.Create(nil);
  try
    vCSC.BaseURL := 'https://api.qtsp.example/csc/v2';
    vCSC.AuthMethod := cscBasic;
    vCSC.Username := 'alice';
    vCSC.Password := 'secret';
    vCreds := vCSC.ListCredentials;
    vCSC.CredentialID := vCreds[0];
    vCSC.PIN := '123456';
    vCSC.OTP := '987654';
    vCSC.LoadCredentialInfo;
    // vSigner.KeyProvider := vCSC;
  finally
    vCSC.Free;
  end;
end;

GEMEINSAMES INTERFACE

Mit einer Zeile austauschen

Jeder Anbieter implementiert IsgcKeyProvider. Der Signiercode erfährt nie, ob der Schlüssel auf der Festplatte, auf einem Token, in Azure oder hinter einer CSC v2-API liegt.

Ein Signer, zehn Anbieter

Entwickle mit einem lokalen PFX. Teste mit dem Windows-Speicher. Deploye mit Azure Trusted Signing.
Länderprofile, Signatur-Level, OCSP, Zeitstempel — alles andere bleibt gleich.
Der sgcSign Server nutzt intern dieselben Anbieter — zentralisiere zuerst lokal und skaliere später zu einem Daemon.

swap-providers.pas

function SignWithAnyProvider(
  aProvider: IsgcKeyProvider; const aXML: string): string;
var
  vSigner: TsgcXAdESSigner;
begin
  vSigner := TsgcXAdESSigner.Create(nil);
  try
    vSigner.KeyProvider := aProvider;
    vSigner.Profile.LoadProfile(spEmploymentDE);
    Result := vSigner.SignXML(aXML);
  finally
    vSigner.Free;
  end;
end;

// Der Aufrufer wählt den Anbieter; den Signer interessiert das nicht.
SignWithAnyProvider(vPFX, vXML);
SignWithAnyProvider(vAzure, vXML);
SignWithAnyProvider(vCSC, vXML);

Bring dein eigenes Schlüsselmaterial mit — 10 Anbieter