Delphi, C++ Builder y .NET Biblioteca y servidor de firma

Azure Trusted Signing desde Delphi, .NET y CI/CD

Firma aplicaciones de Windows con Azure Trusted Signing desde Delphi o .NET.

Firma con Authenticode archivos EXE y DLL
La clave privada se queda en Azure
Sin PFX local, sin token USB
Los agentes de compilación firman sin secretos de Azure
TsgcAzureTrustedSigningProviderCredenciales de cliente OAuth2Certificado de confianza pública emitido por MicrosoftServidor de firma remoto

Firma desde un pipeline de CI → · Ver precios →

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;

Cómo usa sgcSign Azure Trusted Signing

Firma aplicaciones de Windows con Azure Trusted Signing desde tu propio código Delphi o .NET, o desde cualquier pipeline de CI a través de sgcSign Server, mientras la clave privada se queda en Azure.

Un proveedor de claves, tres lugares desde los que firmar: tu aplicación Delphi, tu código .NET o el pipeline de compilación mediante el servidor de firma.

Azure Trusted Signing (antes Azure Code Signing) es el servicio de firma de código de Microsoft. Microsoft es propietaria del certificado y aprovisiona la clave de firma por ti, y la clave privada vive por completo en Azure. sgcSign se comunica con él mediante TsgcAzureTrustedSigningProvider, que se autentica con credenciales de cliente OAuth2.

Todos los proveedores de claves de sgcSign implementan IsgcKeyProvider, así que el código de firma no se preocupa de dónde está la clave. Desarrolla con un PFX local, prueba con el almacén de certificados de Windows y publica con Azure Trusted Signing cambiando un solo proveedor. Las demás opciones aparecen en la página de proveedores de claves.

Desde Delphi y C++ Builder

TsgcAuthenticodeSigner toma el proveedor de Azure como su KeyProvider y firma archivos .exe, .dll, .sys, .ocx, .cpl y .scr en el propio proceso, en Windows, sin ninguna herramienta de firma externa.

Desde .NET

El paquete NuGet esegece.sgcSign tiene la misma clase TsgcAzureTrustedSigningProvider con las mismas propiedades, asignada al KeyProvider de un firmante en C#.

Desde CI/CD

El sgcSign Server guarda las credenciales de Azure como un proveedor AzureTS. Los agentes de compilación firman por HTTPS con una clave de API y nunca ven el tenant, el cliente ni el secreto.

Qué configuras

Tres pasos en el portal de Azure, y después los valores del proveedor en sgcSign. Los mismos valores alimentan el proveedor de Delphi y .NET y la configuración del servidor.

De la cuenta de Azure a la primera firma

  1. Crea una cuenta de Azure Trusted Signing en el portal de Azure.
  2. Crea un perfil de certificado y anota el nombre del perfil.
  3. Registra una aplicación de Azure AD y concédele el rol Trusted Signing Certificate Profile Signer.
  4. Configura el proveedor con el ID de tenant, el ID de cliente, el secreto de cliente, el nombre de la cuenta y el nombre del perfil de certificado. Endpoint establece la URL del endpoint de firma de tu cuenta.

Llama a Connect en el proveedor antes de firmar. En el servidor, el secreto de cliente puede venir de una variable de entorno, así que nunca se escribe en el archivo de configuración.

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

Opciones de Authenticode en Delphi

El código de la portada de arriba es todo el trabajo. Estas propiedades de TsgcAuthenticodeSigner dan forma a la firma que produce.

Firmas con marca de tiempo

Level es alT por defecto, lo que añade una marca de tiempo RFC 3161 mediante un TsgcTSAClient asignado a TSAClient. alBES firma sin ella.

Hash y datos del editor

Hash es ahSHA256 por defecto. Description y URL incrustan en la firma el nombre del programa y un enlace de más información.

Firmas duales

Establece AppendSignature en True para añadir una firma anidada a un archivo que ya está firmado, por ejemplo SHA-1 para Windows antiguo y SHA-256 para Windows actual.

Archivos, flujos y memoria

SignFile lee y escribe archivos, SignStream trabaja con flujos y SignBytes firma un binario guardado en memoria.

El mismo proveedor en C#

La biblioteca .NET mantiene los nombres de Delphi, así que un equipo que firma desde ambos lenguajes configura Azure Trusted Signing una sola vez.

Instala, configura, asigna

  • Añade el paquete registrado con dotnet add package esegece.sgcSign.
  • Establece el tenant, el cliente, el secreto, la cuenta y el perfil de certificado en TsgcAzureTrustedSigningProvider.
  • Asígnalo al KeyProvider del firmante, exactamente como en Delphi.
  • Los paquetes NuGet, los manifiestos ClickOnce y las extensiones VSIX los firma el sgcSign Server con el mismo proveedor de 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 desde un pipeline de CI con Azure Trusted Signing

Coloca las credenciales de Azure en una sola instancia de sgcSign Server en lugar de en cada agente de compilación. Los runners tienen una clave de API y firman por HTTPS.

Una entrada de proveedor, todos los runners

  • Añade un proveedor AzureTS a sgcSignServer.conf.json. Cualquier parámetro que termine en _env se lee de una variable de entorno, así que el secreto de cliente queda fuera del archivo.
  • sgcSignServer --selftest-providers carga la configuración, inicializa cada proveedor y termina, de modo que puedes comprobar los valores de Azure antes de pasar a producción.
  • El cliente sgcsign calcula el hash del ejecutable en el runner y envía solo el hash. El servidor lo firma con Azure Trusted Signing y el cliente incrusta la firma.
  • Las claves de API por proyecto, las aprobaciones opcionales y un registro de auditoría encadenado por hash anotan quién firmó qué con el perfil de 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

Descubre sgcSign en dos minutos

Firma de código y documentos desde Delphi y .NET, con el mismo modelo de proveedor de claves al que se conecta el proveedor de Azure.

Firma código y documentos desde Delphi y .NET: PAdES, XAdES, CAdES y Authenticode, con tarjetas inteligentes y HSM.

Preguntas frecuentes

Crea un TsgcAzureTrustedSigningProvider, establece TenantId, ClientId, ClientSecret, AccountName, CertificateProfileName y Endpoint, y llama a Connect. Asígnalo al KeyProvider de un TsgcAuthenticodeSigner y llama a SignFile con las rutas de entrada y de salida. El ejemplo de la parte superior de esta página está completo.

Sí. Configura un proveedor AzureTS en el sgcSign Server y da a cada runner una clave de API. El runner llama a sgcsign sign o a la API REST, el servidor firma con Azure Trusted Signing, y el secreto de cliente de Azure nunca llega al agente de compilación.

Sí, a través del sgcSign Server. Firma archivos .exe y .dll con Authenticode, paquetes .nupkg en POST /api/v1/sign/nuget, manifiestos ClickOnce y extensiones VSIX, todo con el proveedor de claves que configures, Azure Trusted Signing incluido. En tu propio código .NET, el paquete esegece.sgcSign ofrece la misma clase de proveedor de Azure.

No. Con Azure Trusted Signing, Microsoft es propietaria del certificado y aprovisiona la clave de firma, y la clave privada vive por completo en Azure. sgcSign firma con ella mediante credenciales de cliente OAuth2, así que ningún certificado ni archivo de clave queda en la máquina de compilación.

Una cuenta de Azure Trusted Signing, un perfil de certificado y una aplicación de Azure AD con el rol Trusted Signing Certificate Profile Signer. De ellos obtienes el ID de tenant, el ID de cliente, un secreto de cliente, el nombre de la cuenta y el nombre del perfil. La sección de configuración asigna cada valor a la propiedad de Delphi y al parámetro del servidor.

Sí. En Delphi, establece Level en alT y asigna un TsgcTSAClient a TSAClient. El sgcSign Server mantiene una lista de servidores de marca de tiempo RFC 3161 por defecto y los prueba en orden hasta que uno responde, con listas tsa_urls por proveedor cuando un proveedor necesita las suyas.

La mejor opción: All-AccessTodos los productos de eSeGeCe, con Premium Support incluido, desde €1,059 al año.
Ver precios de All-Access

Firma hoy con Azure Trusted Signing

Desde una aplicación Delphi, un programa .NET o un pipeline de compilación, con la clave privada guardada en Azure.