Delphi, C++ Builder und .NET Bibliothek und Signaturserver

Azure Trusted Signing aus Delphi, .NET und CI/CD

Windows-Anwendungen mit Azure Trusted Signing aus Delphi oder .NET signieren.

EXE- und DLL-Dateien per Authenticode signieren
Der private Schlüssel bleibt in Azure
Keine lokale PFX, kein USB-Token
Build-Agents signieren ohne Azure-Geheimnisse
TsgcAzureTrustedSigningProviderOAuth2-Client-CredentialsVon Microsoft ausgestelltes Public-Trust-ZertifikatSignaturserver für die Fernsignierung

Aus einer CI-Pipeline signieren → · Preise ansehen →

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;

Wie sgcSign Azure Trusted Signing nutzt

Signiere Windows-Anwendungen mit Azure Trusted Signing aus deinem eigenen Delphi- oder .NET-Code oder aus jeder CI-Pipeline über den sgcSign Server, während der private Schlüssel in Azure bleibt.

Ein Schlüsselanbieter, drei Orte zum Signieren: deine Delphi-Anwendung, dein .NET-Code oder die Build-Pipeline über den Signaturserver.

Azure Trusted Signing (früher Azure Code Signing) ist der Code-Signing-Dienst von Microsoft. Microsoft besitzt das Zertifikat und stellt den Signaturschlüssel für dich bereit, und der private Schlüssel liegt vollständig in Azure. sgcSign spricht mit ihm über TsgcAzureTrustedSigningProvider, der sich mit OAuth2-Client-Credentials authentifiziert.

Jeder sgcSign-Schlüsselanbieter implementiert IsgcKeyProvider, sodass dem Signaturcode egal ist, wo der Schlüssel liegt. Entwickle mit einer lokalen PFX, teste mit dem Windows-Zertifikatspeicher und veröffentliche mit Azure Trusted Signing, indem du einen Anbieter austauschst. Die weiteren Optionen stehen auf der Seite Schlüsselanbieter.

Aus Delphi und C++ Builder

TsgcAuthenticodeSigner nimmt den Azure-Anbieter als KeyProvider und signiert .exe-, .dll-, .sys-, .ocx-, .cpl- und .scr-Dateien im Prozess unter Windows, ohne externes Signaturwerkzeug.

Aus .NET

Das NuGet-Paket esegece.sgcSign hat dieselbe Klasse TsgcAzureTrustedSigningProvider mit denselben Eigenschaften, in C# dem KeyProvider eines Signierers zugewiesen.

Aus CI/CD

Der sgcSign Server hält die Azure-Zugangsdaten als AzureTS-Anbieter. Build-Agents signieren über HTTPS mit einem API-Schlüssel und sehen nie den Tenant, den Client oder das Geheimnis.

Was du konfigurierst

Drei Schritte im Azure-Portal, dann die Anbieterwerte in sgcSign. Dieselben Werte speisen den Anbieter für Delphi und .NET und die Serverkonfiguration.

Vom Azure-Konto zur ersten Signatur

  1. Erstelle im Azure-Portal ein Azure-Trusted-Signing-Konto.
  2. Erstelle ein Zertifikatsprofil und notiere den Profilnamen.
  3. Registriere eine Azure-AD-Anwendung und weise ihr die Rolle Trusted Signing Certificate Profile Signer zu.
  4. Konfiguriere den Anbieter mit Tenant-ID, Client-ID, Client-Geheimnis, Kontoname und Name des Zertifikatsprofils. Endpoint legt die URL des Signaturendpunkts deines Kontos fest.

Rufe vor dem Signieren Connect am Anbieter auf. Im Server kann das Client-Geheimnis aus einer Umgebungsvariablen stammen, sodass es nie in die Konfigurationsdatei geschrieben wird.

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

Authenticode-Optionen in Delphi

Der Code im Hero oben ist die ganze Arbeit. Diese Eigenschaften von TsgcAuthenticodeSigner bestimmen die Signatur, die er erzeugt.

Signaturen mit Zeitstempel

Level ist standardmäßig alT, was über einen TsgcTSAClient, der TSAClient zugewiesen ist, einen RFC-3161-Zeitstempel hinzufügt. alBES signiert ohne einen solchen.

Hash und Herausgeberangaben

Hash ist standardmäßig ahSHA256. Description und URL betten den Programmnamen und einen Link für weitere Informationen in die Signatur ein.

Doppelte Signaturen

Setze AppendSignature auf True, um einer bereits signierten Datei eine verschachtelte Signatur hinzuzufügen, zum Beispiel SHA-1 für altes Windows und SHA-256 für aktuelles Windows.

Dateien, Streams und Speicher

SignFile liest und schreibt Dateien, SignStream arbeitet mit Streams, und SignBytes signiert eine im Speicher gehaltene Binärdatei.

Derselbe Anbieter in C#

Die .NET-Bibliothek behält die Delphi-Namen, sodass ein Team, das aus beiden Sprachen signiert, Azure Trusted Signing nur einmal konfiguriert.

Installieren, konfigurieren, zuweisen

  • Füge das Registered-Paket mit dotnet add package esegece.sgcSign hinzu.
  • Setze Tenant, Client, Geheimnis, Konto und Zertifikatsprofil an TsgcAzureTrustedSigningProvider.
  • Weise ihn dem KeyProvider des Signierers zu, genau wie in Delphi.
  • NuGet-Pakete, ClickOnce-Manifeste und VSIX-Erweiterungen werden vom sgcSign Server mit demselben Azure-Anbieter signiert.
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;

Aus einer CI-Pipeline mit Azure Trusted Signing signieren

Lege die Azure-Zugangsdaten auf einem sgcSign Server ab statt auf jedem Build-Agent. Die Runner halten einen API-Schlüssel und signieren über HTTPS.

Ein Anbietereintrag, jeder Runner

  • Füge sgcSignServer.conf.json einen AzureTS-Anbieter hinzu. Jeder Parameter, der auf _env endet, wird aus einer Umgebungsvariablen gelesen, sodass das Client-Geheimnis nicht in der Datei steht.
  • sgcSignServer --selftest-providers lädt die Konfiguration, initialisiert jeden Anbieter und beendet sich, sodass du die Azure-Werte vor dem Livegang prüfen kannst.
  • Der sgcsign-Client hasht die ausführbare Datei auf dem Runner und sendet nur den Hash. Der Server signiert ihn mit Azure Trusted Signing, und der Client bettet die Signatur ein.
  • API-Schlüssel pro Projekt, optionale Freigaben und ein hashverkettetes Audit-Log halten fest, wer was mit dem Azure-Profil signiert hat.
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

sgcSign in zwei Minuten

Code- und Dokumentsignierung aus Delphi und .NET, mit demselben Schlüsselanbietermodell, in das sich der Azure-Anbieter einfügt.

Code und Dokumente aus Delphi und .NET signieren: PAdES, XAdES, CAdES und Authenticode, mit Smartcards und HSMs.

Häufig gestellte Fragen

Erstelle einen TsgcAzureTrustedSigningProvider, setze TenantId, ClientId, ClientSecret, AccountName, CertificateProfileName und Endpoint und rufe Connect auf. Weise ihn dem KeyProvider eines TsgcAuthenticodeSigner zu und rufe SignFile mit den Ein- und Ausgabepfaden auf. Das Beispiel oben auf dieser Seite ist vollständig.

Ja. Konfiguriere einen AzureTS-Anbieter auf dem sgcSign Server und gib jedem Runner einen API-Schlüssel. Der Runner ruft sgcsign sign oder die REST-API auf, der Server signiert mit Azure Trusted Signing, und das Azure-Client-Geheimnis erreicht den Build-Agent nie.

Ja, über den sgcSign Server. Er signiert .exe- und .dll-Dateien mit Authenticode, .nupkg-Pakete über POST /api/v1/sign/nuget, ClickOnce-Manifeste und VSIX-Erweiterungen, alles mit dem Schlüsselanbieter, den du konfigurierst, Azure Trusted Signing eingeschlossen. In deinem eigenen .NET-Code bietet das Paket esegece.sgcSign dieselbe Azure-Anbieterklasse.

Nein. Bei Azure Trusted Signing besitzt Microsoft das Zertifikat und stellt den Signaturschlüssel bereit, und der private Schlüssel liegt vollständig in Azure. sgcSign signiert damit über OAuth2-Client-Credentials, sodass auf dem Build-Rechner weder ein Zertifikat noch eine Schlüsseldatei liegt.

Ein Azure-Trusted-Signing-Konto, ein Zertifikatsprofil und eine Azure-AD-Anwendung mit der Rolle Trusted Signing Certificate Profile Signer. Daraus nimmst du die Tenant-ID, die Client-ID, ein Client-Geheimnis, den Kontonamen und den Profilnamen. Der Abschnitt zur Einrichtung ordnet jeden Wert der Delphi-Eigenschaft und dem Serverparameter zu.

Ja. Setze in Delphi Level auf alT und weise TSAClient einen TsgcTSAClient zu. Der sgcSign Server führt eine Liste von Standard-RFC-3161-Zeitstempelservern und probiert sie der Reihe nach, bis einer antwortet, mit tsa_urls-Listen pro Anbieter, wenn ein Anbieter seine eigenen braucht.

Bestes Preis-Leistungs-Verhältnis: All-AccessAlle eSeGeCe-Produkte, inklusive Premium-Support, ab €1,059 pro Jahr.
All-Access-Preise ansehen

Signiere noch heute mit Azure Trusted Signing

Aus einer Delphi-Anwendung, einem .NET-Programm oder einer Build-Pipeline, mit dem privaten Schlüssel in Azure.