Delphi, C++ Builder et .NET Bibliothèque et serveur de signature

Azure Trusted Signing depuis Delphi, .NET et CI/CD

Signe des applications Windows avec Azure Trusted Signing depuis Delphi ou .NET.

Signature Authenticode des fichiers EXE et DLL
La clé privée reste dans Azure
Pas de PFX local, pas de jeton USB
Les agents de build signent sans secrets Azure
TsgcAzureTrustedSigningProviderIdentifiants client OAuth2Certificat de confiance publique émis par MicrosoftServeur de signature distant

Signer depuis un pipeline CI → · Voir les tarifs →

SignWithAzure.pas
// Authenticode-sign with Azure Trusted Signing
var
  vKeyProvider: TsgcAzureTrustedSigningProvider;
  vSigner: TsgcAuthenticodeSigner;
begin
  vKeyProvider := TsgcAzureTrustedSigningProvider.Create(nil);
  vSigner := TsgcAuthenticodeSigner.Create(nil);
  try
    vKeyProvider.TenantId := '00000000-0000-0000-0000-000000000000';
    vKeyProvider.ClientId := '11111111-1111-1111-1111-111111111111';
    vKeyProvider.ClientSecret := 'my-client-secret';
    vKeyProvider.AccountName := 'my-trusted-signing-account';
    vKeyProvider.CertificateProfileName := 'public-trust';
    vKeyProvider.Endpoint := 'https://eus.codesigning.azure.net';
    vKeyProvider.Connect;

    vSigner.KeyProvider := vKeyProvider;
    vSigner.Level := alBES;   // alT additionally requires a TSAClient
    vSigner.SignFile('myapp.exe', 'myapp-signed.exe');
  finally
    vSigner.Free;
    vKeyProvider.Free;
  end;
end;

Comment sgcSign utilise Azure Trusted Signing

Signe des applications Windows avec Azure Trusted Signing depuis ton propre code Delphi ou .NET, ou depuis n'importe quel pipeline CI via le serveur sgcSign, pendant que la clé privée reste dans Azure.

Un seul fournisseur de clés, trois endroits d'où signer : ton application Delphi, ton code .NET, ou le pipeline de build via le serveur de signature.

Azure Trusted Signing (anciennement Azure Code Signing) est le service de signature de code de Microsoft. Microsoft possède le certificat et provisionne la clé de signature pour toi, et la clé privée vit entièrement dans Azure. sgcSign dialogue avec lui via TsgcAzureTrustedSigningProvider, qui s'authentifie avec les identifiants client OAuth2.

Chaque fournisseur de clés sgcSign implémente IsgcKeyProvider, donc le code de signature ne se soucie pas de l'endroit où vit la clé. Développe avec un PFX local, teste avec le magasin de certificats Windows, et livre avec Azure Trusted Signing en changeant un seul fournisseur. Les autres options sont listées sur la page des fournisseurs de clés.

Depuis Delphi et C++ Builder

TsgcAuthenticodeSigner prend le fournisseur Azure comme KeyProvider et signe les fichiers .exe, .dll, .sys, .ocx, .cpl et .scr dans le processus, sous Windows, sans outil de signature externe.

Depuis .NET

Le package NuGet esegece.sgcSign a la même classe TsgcAzureTrustedSigningProvider avec les mêmes propriétés, assignée en C# au KeyProvider d'un signataire.

Depuis CI/CD

Le serveur sgcSign détient les identifiants Azure comme fournisseur AzureTS. Les agents de build signent via HTTPS avec une clé d'API et ne voient jamais le tenant, le client ni le secret.

Ce que tu configures

Trois étapes dans le portail Azure, puis les valeurs du fournisseur dans sgcSign. Les mêmes valeurs alimentent le fournisseur Delphi et .NET et la configuration du serveur.

Du compte Azure à la première signature

  1. Crée un compte Azure Trusted Signing dans le portail Azure.
  2. Crée un profil de certificat et note le nom du profil.
  3. Enregistre une application Azure AD et accorde-lui le rôle Trusted Signing Certificate Profile Signer.
  4. Configure le fournisseur avec l'ID du tenant, l'ID du client, le secret du client, le nom du compte et le nom du profil de certificat. Endpoint définit l'URL du point de terminaison de signature de ton compte.

Appelle Connect sur le fournisseur avant de signer. Dans le serveur, le secret du client peut venir d'une variable d'environnement, donc il n'est jamais écrit dans le fichier de configuration.

settings.txt
Delphi / .NET property     Server param (AzureTS)
TenantId                   tenant_id
ClientId                   client_id
ClientSecret               client_secret_env
AccountName                account
CertificateProfileName     certificate_profile
Endpoint                   endpoint

Options Authenticode dans Delphi

Le code du bandeau ci-dessus fait tout le travail. Ces propriétés de TsgcAuthenticodeSigner façonnent la signature produite.

Signatures horodatées

Level vaut alT par défaut, ce qui ajoute un horodatage RFC 3161 via un TsgcTSAClient assigné à TSAClient. alBES signe sans horodatage.

Hachage et informations sur l'éditeur

Hash vaut ahSHA256 par défaut. Description et URL intègrent dans la signature le nom du programme et un lien d'informations complémentaires.

Signatures doubles

Mets AppendSignature à True pour ajouter une signature imbriquée à un fichier déjà signé, par exemple SHA-1 pour les anciens Windows et SHA-256 pour les Windows actuels.

Fichiers, flux et mémoire

SignFile lit et écrit des fichiers, SignStream travaille sur des flux et SignBytes signe un binaire en mémoire.

Le même fournisseur en C#

La bibliothèque .NET garde les noms Delphi, donc une équipe qui signe depuis les deux langages configure Azure Trusted Signing une seule fois.

Installer, configurer, assigner

  • Ajoute le package Registered avec dotnet add package esegece.sgcSign.
  • Renseigne le tenant, le client, le secret, le compte et le profil de certificat sur TsgcAzureTrustedSigningProvider.
  • Assigne-le au KeyProvider du signataire, exactement comme dans Delphi.
  • Les packages NuGet, les manifestes ClickOnce et les extensions VSIX sont signés par le serveur sgcSign avec le même fournisseur Azure.
AzureProvider.cs
var azure = new TsgcAzureTrustedSigningProvider();
azure.TenantId = "your-tenant-id";
azure.ClientId = "your-client-id";
azure.ClientSecret = "your-client-secret";
azure.AccountName = "your-account-name";
azure.CertificateProfileName = "your-profile";

// Assign it to the KeyProvider of an sgcSign signer
signer.KeyProvider = azure;

Signe depuis un pipeline CI avec Azure Trusted Signing

Place les identifiants Azure sur un seul serveur sgcSign au lieu de chaque agent de build. Les runners détiennent une clé d'API et signent via HTTPS.

Une seule entrée de fournisseur, tous les runners

  • Ajoute un fournisseur AzureTS à sgcSignServer.conf.json. Tout paramètre se terminant par _env est lu depuis une variable d'environnement, donc le secret du client reste hors du fichier.
  • sgcSignServer --selftest-providers charge la configuration, initialise chaque fournisseur et se termine, pour que tu puisses vérifier les valeurs Azure avant la mise en production.
  • Le client sgcsign calcule le hachage de l'exécutable sur le runner et n'envoie que le hachage. Le serveur le signe avec Azure Trusted Signing et le client intègre la signature.
  • Des clés d'API par projet, des approbations facultatives et un journal d'audit chaîné par hachage enregistrent qui a signé quoi avec le profil Azure.
sgcSignServer.conf.json
"providers": [
  {
    "name": "release",
    "type": "AzureTS",
    "params": {
      "tenant_id": "00000000-0000-0000-0000-000000000000",
      "client_id": "00000000-0000-0000-0000-000000000000",
      "client_secret_env": "SGCSIGN_AZURE_TS_SECRET",
      "account": "your-account",
      "certificate_profile": "your-profile",
      "endpoint": "https://eus.codesigning.azure.net/"
    }
  }
]

rem On the build agent
set SGCSIGN_SERVER=https://sign.example.com:8443
set SGCSIGN_APIKEY=%SIGNING_API_KEY%
sgcsign sign -f authenticode -p release -o MyApp-signed.exe MyApp.exe

Découvre sgcSign en deux minutes

Signature de code et de documents depuis Delphi et .NET, avec le même modèle de fournisseur de clés auquel se branche le fournisseur Azure.

Signe du code et des documents depuis Delphi et .NET : PAdES, XAdES, CAdES et Authenticode, avec des cartes à puce et des HSM.

Foire aux questions

Crée un TsgcAzureTrustedSigningProvider, renseigne TenantId, ClientId, ClientSecret, AccountName, CertificateProfileName et Endpoint, et appelle Connect. Assigne-le au KeyProvider d'un TsgcAuthenticodeSigner et appelle SignFile avec les chemins d'entrée et de sortie. L'exemple en haut de cette page est complet.

Oui. Configure un fournisseur AzureTS sur le serveur sgcSign et donne à chaque runner une clé d'API. Le runner appelle sgcsign sign ou l'API REST, le serveur signe avec Azure Trusted Signing, et le secret client Azure n'atteint jamais l'agent de build.

Oui, via le serveur sgcSign. Il signe les fichiers .exe et .dll avec Authenticode, les packages .nupkg sur POST /api/v1/sign/nuget, les manifestes ClickOnce et les extensions VSIX, le tout avec le fournisseur de clés que tu configures, Azure Trusted Signing compris. Dans ton propre code .NET, le package esegece.sgcSign offre la même classe de fournisseur Azure.

Non. Avec Azure Trusted Signing, Microsoft possède le certificat et provisionne la clé de signature, et la clé privée vit entièrement dans Azure. sgcSign signe avec elle via les identifiants client OAuth2, donc aucun fichier de certificat ou de clé ne se trouve sur la machine de build.

D'un compte Azure Trusted Signing, d'un profil de certificat et d'une application Azure AD avec le rôle Trusted Signing Certificate Profile Signer. Tu en tires l'ID du tenant, l'ID du client, un secret client, le nom du compte et le nom du profil. La section de configuration associe chaque valeur à la propriété Delphi et au paramètre du serveur.

Oui. Dans Delphi, mets Level à alT et assigne un TsgcTSAClient à TSAClient. Le serveur sgcSign garde une liste de serveurs d'horodatage RFC 3161 par défaut et les essaie dans l'ordre jusqu'à ce que l'un réponde, avec des listes tsa_urls par fournisseur quand un fournisseur a besoin des siennes.

Meilleur rapport qualité-prix : All-AccessTous les produits eSeGeCe, Support Premium inclus, à partir de €1,059/an.
Voir les tarifs All-Access

Signe dès aujourd'hui avec Azure Trusted Signing

Depuis une application Delphi, un programme .NET ou un pipeline de build, avec la clé privée conservée dans Azure.