Apporte ta propre clé — 10 fournisseurs

Tous les fournisseurs implémentent l'interface IsgcKeyProvider — le même code de signature fonctionne contre des fichiers locaux, des cartes à puce, des HSM, des KMS cloud ou des QTSP distants. Bascule en une ligne.

Fichiers locaux (PFX, PEM)
Matériel (PKCS#11)
KMS cloud (Azure, AWS, GCP)
QTSP (Certum, CSC v2)
FOURNISSEUR 1 / 10

TsgcPFXKeyProvider

Fichiers PFX / PKCS#12. Clé locale protégée par mot de passe. Idéal pour le développement, les petits déploiements et tout workflow où le certificat est livré sous forme de fichier .pfx/.p12 unique.

  • Importé via Windows CNG avec PKCS12_PREFER_CNG_KSP — la signature SHA-256/384/512 fonctionne quel que soit le CSP d'origine.
  • Les fichiers .pfx multi-certificats sont parcourus automatiquement jusqu'à trouver le certificat avec la clé privée.
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;
FOURNISSEUR 2 / 10

TsgcPEMKeyProvider

Fichiers PEM. PKCS#8 chiffré avec prise en charge native PBES2 / PBKDF2 / AES-CBC, plus l'ancien format de clé privée RSA DEK-Info. Idéal pour les pipelines basés sur OpenSSL.

  • BEGIN CERTIFICATE, BEGIN RSA PRIVATE KEY, BEGIN PRIVATE KEY, BEGIN ENCRYPTED PRIVATE KEY tous pris en charge.
  • Les PEM combinés (certificat + clé dans un seul fichier) sont détectés automatiquement — laisse PrivateKeyFile vide.
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;
FOURNISSEUR 3 / 10

TsgcWindowsCertStoreProvider

Magasin de certificats Windows. Magasins local-machine et current-user. Idéal pour les apps de bureau qui utilisent des certificats existants émis par AD, ou tout déploiement où Windows gère déjà le cycle de vie du certificat.

  • La signature se fait via Windows CNG — la clé privée ne quitte jamais le magasin.
  • Sélection par sous-chaîne CN du sujet ou par empreinte SHA-1.
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;
FOURNISSEUR 4 / 10

TsgcPKCS11Provider

PKCS#11 / tokens matériels. Cartes à puce, tokens USB, HSM — SafeNet, YubiKey, Nitrokey, Thales. Requis pour les signatures électroniques qualifiées dans la plupart des juridictions UE.

  • Mécanismes CKM_RSA_PKCS et CKM_ECDSA_SHA256 pris en charge.
  • Helpers EnumerateSlots / EnumerateCertificates pour choisir le bon slot au runtime.
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;
FOURNISSEUR 5 / 10

TsgcAzureTrustedSigningProvider

Azure Trusted Signing. Service de signature de code qualifié de Microsoft. Authenticode sans acheter de certificat EV — Microsoft possède le certificat et te provisionne la clé de signature.

  • Client credentials OAuth2 — Tenant ID + Client ID + Client Secret.
  • Les clés privées résident entièrement dans Azure, jamais sur l'agent de build.
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;
FOURNISSEUR 6 / 10

TsgcAWSKMSKeyProvider

AWS Key Management Service. Le service de conservation de clés soutenu par HSM d'Amazon. Associe-le à un certificat émis par AWS pour la signature dans le cloud sans exposer la clé privée.

  • Authentification AWS Signature Version 4, calculée en cours de processus.
  • KeyId accepte un ID de clé, un ARN de clé ou un ARN d'alias.
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;
FOURNISSEUR 7 / 10

TsgcGCloudKMSKeyProvider

Google Cloud KMS. Même modèle opérationnel qu'AWS KMS. Le fichier JSON de compte de service s'authentifie via un échange JWT vers un access token OAuth2, puis signe via l'API Cloud KMS.

  • ProjectId + Location + KeyRing + Key + Version — correspond 1:1 à la hiérarchie des ressources GCP.
  • Clés KMS asymétriques uniquement — soutenues par HSM quand disponible, protégées par logiciel sinon.
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;
FOURNISSEUR 8 / 10

TsgcHashiCorpVaultKeyProvider

HashiCorp Vault. Le moteur de secrets Transit de Vault effectue la signature. Idéal pour une conservation de clés auto-hébergée et pilotée par politiques où Vault fait déjà partie de la stack.

  • Le moteur Transit ne gère que la clé — fournis le certificat via SetCertificateFromFile.
  • Auth par token ; le mount path est 'transit' par défaut.
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;
FOURNISSEUR 9 / 10

TsgcCertumSimplySignProvider

Certum SimplySign. QTSP polonais. Signatures électroniques qualifiées via PIN autorisé par application mobile, aucun token USB requis. Choix courant pour les workflows polonais KSeF et ZUS.

  • Client credentials OAuth2 + nom d'utilisateur/mot de passe du compte SimplySign + PIN.
  • ListCertificates expose chaque certificat disponible dans le compte.
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;
FOURNISSEUR 10 / 10

TsgcCSCKeyProvider

Cloud Signature Consortium API v2. Interface générique vers tout QTSP qui implémente CSC v2 — Universign, D-Trust sign-me, A-Trust, FNMT Cl@ve Firma, Evrotrust, Intesi Group. Le fournisseur conserve la clé qualifiée dans un QSCD distant ; sgcSign n'envoie que le hachage du document.

  • Trois modes d'auth : cscBasic, cscOAuth2, cscOTP (mot de passe à usage unique pour le double facteur).
  • Appelle credentials/authorize + signatures/signHash selon la spec CSC v2.
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;
INTERFACE COMMUNE

Permute en une ligne

Chaque fournisseur implémente IsgcKeyProvider. Le code du signataire ne sait jamais si la clé réside sur disque, sur un token, dans Azure ou derrière une API CSC v2.

Un signataire, dix fournisseurs

  • Développe avec un PFX local. Teste avec le magasin Windows. Déploie sur Azure Trusted Signing.
  • Profils par pays, niveaux de signature, OCSP, horodatages — tout le reste demeure identique.
  • sgcSign Server utilise les mêmes fournisseurs en interne — centralise localement d'abord, passe à l'échelle vers un daemon ensuite.
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;

// L'appelant choisit le fournisseur ; le signataire s'en fiche.
SignWithAnyProvider(vPFX, vXML);
SignWithAnyProvider(vAzure, vXML);
SignWithAnyProvider(vCSC, vXML);

Choisis le bon fournisseur pour ton modèle de confiance

D'un .pfx local à un HSM sur un autre continent — le code de signature reste le même.

Démarrage rapide sgcSign Server