Delphi, C++ Builder e .NET Libreria e server di firma

Azure Trusted Signing da Delphi, .NET e CI/CD

Firma le applicazioni Windows con Azure Trusted Signing da Delphi o .NET.

Firma Authenticode di file EXE e DLL
La chiave privata resta in Azure
Nessun PFX locale, nessun token USB
Gli agenti di build firmano senza segreti Azure
TsgcAzureTrustedSigningProviderCredenziali client OAuth2Certificato di fiducia pubblica emesso da MicrosoftServer di firma remoto

Firma da una pipeline CI → · Vedi i prezzi →

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;

Come sgcSign usa Azure Trusted Signing

Firma le applicazioni Windows con Azure Trusted Signing dal tuo codice Delphi o .NET, o da qualsiasi pipeline CI tramite sgcSign Server, mentre la chiave privata resta in Azure.

Un solo provider di chiavi, tre punti da cui firmare: la tua applicazione Delphi, il tuo codice .NET, o la pipeline di build tramite il server di firma.

Azure Trusted Signing (in precedenza Azure Code Signing) è il servizio di firma del codice di Microsoft. Microsoft possiede il certificato e predispone la chiave di firma per te, e la chiave privata vive interamente in Azure. sgcSign dialoga con esso tramite TsgcAzureTrustedSigningProvider, che si autentica con le credenziali client OAuth2.

Ogni provider di chiavi di sgcSign implementa IsgcKeyProvider, quindi il codice di firma non si preoccupa di dove si trovi la chiave. Sviluppa con un PFX locale, testa con l'archivio certificati di Windows e rilascia con Azure Trusted Signing cambiando un solo provider. Le altre opzioni sono elencate nella pagina dei provider di chiavi.

Da Delphi e C++ Builder

TsgcAuthenticodeSigner prende il provider Azure come KeyProvider e firma file .exe, .dll, .sys, .ocx, .cpl e .scr in-process, su Windows, senza alcuno strumento di firma esterno.

Da .NET

Il pacchetto NuGet esegece.sgcSign ha la stessa classe TsgcAzureTrustedSigningProvider con le stesse proprietà, assegnata al KeyProvider di un firmatario in C#.

Da CI/CD

Il sgcSign Server conserva le credenziali Azure come provider AzureTS. Gli agenti di build firmano via HTTPS con una chiave API e non vedono mai tenant, client o segreto.

Cosa devi configurare

Tre passaggi nel portale Azure, poi i valori del provider in sgcSign. Gli stessi valori alimentano il provider Delphi e .NET e la configurazione del server.

Dall'account Azure alla prima firma

  1. Crea un account Azure Trusted Signing nel portale Azure.
  2. Crea un profilo di certificato e annota il nome del profilo.
  3. Registra un'applicazione Azure AD e assegnale il ruolo Trusted Signing Certificate Profile Signer.
  4. Configura il provider con tenant ID, client ID, client secret, nome dell'account e nome del profilo di certificato. Endpoint imposta l'URL dell'endpoint di firma del tuo account.

Chiama Connect sul provider prima di firmare. Nel server, il client secret può provenire da una variabile d'ambiente, così non viene mai scritto nel file di configurazione.

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

Opzioni Authenticode in Delphi

Il codice nella sezione iniziale qui sopra è tutto il lavoro. Queste proprietà di TsgcAuthenticodeSigner modellano la firma che produce.

Firme con marca temporale

Level è alT per impostazione predefinita, il che aggiunge una marca temporale RFC 3161 tramite un TsgcTSAClient assegnato a TSAClient. alBES firma senza marca temporale.

Hash e dettagli dell'editore

Hash è per impostazione predefinita ahSHA256. Description e URL incorporano nella firma il nome del programma e un link per ulteriori informazioni.

Firme doppie

Imposta AppendSignature su True per aggiungere una firma annidata a un file già firmato, per esempio SHA-1 per i vecchi Windows e SHA-256 per i Windows attuali.

File, stream e memoria

SignFile legge e scrive file, SignStream lavora sugli stream e SignBytes firma un binario tenuto in memoria.

Lo stesso provider in C#

La libreria .NET mantiene i nomi di Delphi, così un team che firma da entrambi i linguaggi configura Azure Trusted Signing una sola volta.

Installa, configura, assegna

  • Aggiungi il pacchetto registrato con dotnet add package esegece.sgcSign.
  • Imposta tenant, client, segreto, account e profilo di certificato su TsgcAzureTrustedSigningProvider.
  • Assegnalo al KeyProvider del firmatario, esattamente come in Delphi.
  • I pacchetti NuGet, i manifest ClickOnce e le estensioni VSIX sono firmati dal sgcSign Server con lo stesso provider 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;

Firma da una pipeline CI con Azure Trusted Signing

Metti le credenziali Azure su un solo sgcSign Server invece che su ogni agente di build. I runner hanno una chiave API e firmano via HTTPS.

Una voce di provider, ogni runner

  • Aggiungi un provider AzureTS a sgcSignServer.conf.json. Qualsiasi parametro che termina con _env viene letto da una variabile d'ambiente, così il client secret resta fuori dal file.
  • sgcSignServer --selftest-providers carica la configurazione, inizializza ogni provider ed esce, così puoi controllare i valori Azure prima di andare in produzione.
  • Il client sgcsign calcola l'hash dell'eseguibile sul runner e invia solo l'hash. Il server lo firma con Azure Trusted Signing e il client incorpora la firma.
  • Chiavi API per progetto, approvazioni facoltative e un registro di audit con hash concatenati registrano chi ha firmato cosa con il profilo 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

Scopri sgcSign in due minuti

Firma di codice e documenti da Delphi e .NET, con lo stesso modello di provider di chiavi in cui si inserisce il provider Azure.

Firma codice e documenti da Delphi e .NET: PAdES, XAdES, CAdES e Authenticode, con smart card e HSM.

Domande frequenti

Crea un TsgcAzureTrustedSigningProvider, imposta TenantId, ClientId, ClientSecret, AccountName, CertificateProfileName e Endpoint, e chiama Connect. Assegnalo al KeyProvider di un TsgcAuthenticodeSigner e chiama SignFile con i percorsi di input e output. L'esempio all'inizio di questa pagina è completo.

Sì. Configura un provider AzureTS sul sgcSign Server e dai a ogni runner una chiave API. Il runner chiama sgcsign sign o l'API REST, il server firma con Azure Trusted Signing, e il client secret di Azure non raggiunge mai l'agente di build.

Sì, tramite sgcSign Server. Firma file .exe e .dll con Authenticode, pacchetti .nupkg su POST /api/v1/sign/nuget, manifest ClickOnce ed estensioni VSIX, tutto con il provider di chiavi che configuri, Azure Trusted Signing incluso. Nel tuo codice .NET, il pacchetto esegece.sgcSign offre la stessa classe provider Azure.

No. Con Azure Trusted Signing, Microsoft possiede il certificato e predispone la chiave di firma, e la chiave privata vive interamente in Azure. sgcSign firma con essa tramite le credenziali client OAuth2, quindi sulla macchina di build non c'è alcun certificato o file di chiave.

Un account Azure Trusted Signing, un profilo di certificato e un'applicazione Azure AD con il ruolo Trusted Signing Certificate Profile Signer. Da questi ricavi tenant ID, client ID, un client secret, il nome dell'account e il nome del profilo. La sezione di configurazione associa ogni valore alla proprietà Delphi e al parametro del server.

Sì. In Delphi, imposta Level su alT e assegna un TsgcTSAClient a TSAClient. sgcSign Server mantiene un elenco di server di marca temporale RFC 3161 predefiniti e li prova in ordine finché uno risponde, con elenchi tsa_urls per provider quando un provider ne ha bisogno di propri.

La scelta più conveniente: All-AccessTutti i prodotti eSeGeCe, con Supporto Premium incluso, a partire da €1,059/anno.
Vedi i prezzi All-Access

Firma oggi con Azure Trusted Signing

Da un'applicazione Delphi, un programma .NET o una pipeline di build, con la chiave privata che resta in Azure.