### List Available Signature and Digest Methods

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

This snippet demonstrates how to retrieve and display the names and URIs/OIDs of supported signature and digest methods. It also shows how to get a DigestMethod instance by its OID and how to compute a hash using a specific algorithm.

```csharp
using FirmaXadesNet.Crypto;
using System;

// Métodos de firma disponibles
Console.WriteLine("Métodos de firma disponibles:");
Console.WriteLine($"  RSA-SHA1:   {SignatureMethod.RSAwithSHA1.Name} - {SignatureMethod.RSAwithSHA1.URI}");
Console.WriteLine($"  RSA-SHA256: {SignatureMethod.RSAwithSHA256.Name} - {SignatureMethod.RSAwithSHA256.URI}");
Console.WriteLine($"  RSA-SHA512: {SignatureMethod.RSAwithSHA512.Name} - {SignatureMethod.RSAwithSHA512.URI}");

// Métodos de digest disponibles
Console.WriteLine("\nMétodos de digest disponibles:");
Console.WriteLine($"  SHA1:   {DigestMethod.SHA1.Name} - OID: {DigestMethod.SHA1.Oid}");
Console.WriteLine($"  SHA256: {DigestMethod.SHA256.Name} - OID: {DigestMethod.SHA256.Oid}");
Console.WriteLine($"  SHA512: {DigestMethod.SHA512.Name} - OID: {DigestMethod.SHA512.Oid}");

// Obtener DigestMethod por OID
DigestMethod digestPorOid = DigestMethod.GetByOid("2.16.840.1.101.3.4.2.1");
Console.WriteLine($"\nDigest por OID: {digestPorOid.Name}");

// Obtener instancia de HashAlgorithm
using (var hashAlgorithm = DigestMethod.SHA256.GetHashAlgorithm())
{
    byte[] datos = System.Text.Encoding.UTF8.GetBytes("Texto de prueba");
    byte[] hash = hashAlgorithm.ComputeHash(datos);
    Console.WriteLine($"Hash SHA256: {Convert.ToBase64String(hash)}");
}
```

--------------------------------

### Initialize Signer with X.509 Certificates

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

Instantiate the Signer class using certificates obtained interactively, from a PFX file, or by thumbprint from the certificate store. Ensure the PFX file has the correct password and the thumbprint is accurate.

```csharp
using FirmaXadesNet.Crypto;
using FirmaXadesNet.Utils;
using System;
using System.Security.Cryptography.X509Certificates;

// Crear Signer desde certificado seleccionado interactivamente
using (Signer signer = new Signer(CertUtil.SelectCertificate()))
{
    Console.WriteLine($"Firmante configurado:");
    Console.WriteLine($"  Certificado: {signer.Certificate.Subject}");
    Console.WriteLine($"  Algoritmo de clave: {signer.SigningKey.SignatureAlgorithm}");
}

// Crear Signer desde archivo PFX/PKCS#12
X509Certificate2 certFromFile = new X509Certificate2(
    "certificado.pfx",
    "contraseña",
    X509KeyStorageFlags.Exportable
);

using (Signer signerFromFile = new Signer(certFromFile))
{
    Console.WriteLine($"Firmante desde archivo: {signerFromFile.Certificate.Subject}");
}

// Crear Signer desde almacén de certificados por thumbprint
X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly);
X509Certificate2Collection certs = store.Certificates.Find(
    X509FindType.FindByThumbprint,
    "THUMBPRINT_DEL_CERTIFICADO",
    validOnly: true
);
store.Close();

if (certs.Count > 0)
{
    using (Signer signerByThumbprint = new Signer(certs[0]))
    {
        Console.WriteLine($"Firmante por thumbprint: {signerByThumbprint.Certificate.Subject}");
    }
}
```

--------------------------------

### Sign XML with XadesService

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

Demonstrates the basic workflow for signing an XML document using the ENVELOPED packaging format.

```csharp
using FirmaXadesNet;
using FirmaXadesNet.Crypto;
using FirmaXadesNet.Signature;
using FirmaXadesNet.Signature.Parameters;
using FirmaXadesNet.Utils;
using System;
using System.IO;

// Crear instancia del servicio de firma
XadesService xadesService = new XadesService();

// Configurar parámetros de firma
SignatureParameters parametros = new SignatureParameters();
parametros.SignatureMethod = SignatureMethod.RSAwithSHA512;
parametros.DigestMethod = DigestMethod.SHA256;
parametros.SigningDate = DateTime.Now;

// Añadir compromiso de firma (prueba de origen)
var signatureCommitment = new SignatureCommitment(SignatureCommitmentType.ProofOfOrigin);
parametros.SignatureCommitments.Add(signatureCommitment);

// Configurar formato de firma Enveloped
parametros.SignaturePackaging = SignaturePackaging.ENVELOPED;

// Firmar documento XML
SignatureDocument signatureDocument;
using (parametros.Signer = new Signer(CertUtil.SelectCertificate()))
{
    using (FileStream fs = new FileStream("documento.xml", FileMode.Open))
    {
        signatureDocument = xadesService.Sign(fs, parametros);
    }
}

// Guardar documento firmado
signatureDocument.Save("documento_firmado.xml");
Console.WriteLine("Documento firmado correctamente.");
```

--------------------------------

### Perform Bulk Document Signing

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

Shows how to efficiently sign multiple files by reusing a single Signer instance and configuring signature parameters for internally detached signatures.

```csharp
using FirmaXadesNet;
using FirmaXadesNet.Crypto;
using FirmaXadesNet.Signature;
using FirmaXadesNet.Signature.Parameters;
using FirmaXadesNet.Utils;
using System;
using System.Collections.Generic;
using System.IO;

// Obtener lista de archivos a firmar
string carpetaDocumentos = @"C:\documentos\pendientes";
List<FileInfo> archivos = new List<FileInfo>(
    new DirectoryInfo(carpetaDocumentos).EnumerateFiles("*.pdf")
);

Console.WriteLine($"Archivos a firmar: {archivos.Count}");

// Configurar parámetros de firma (reutilizables)
SignatureParameters parametros = new SignatureParameters();
parametros.SignaturePackaging = SignaturePackaging.INTERNALLY_DETACHED;
parametros.SignatureMethod = SignatureMethod.RSAwithSHA256;
parametros.DataFormat = new DataFormat();
parametros.DataFormat.MimeType = "application/pdf";

// Configurar política de firma si es necesaria
parametros.SignaturePolicyInfo = new SignaturePolicyInfo();
parametros.SignaturePolicyInfo.PolicyIdentifier = "https://ejemplo.com/politica";

XadesService xadesService = new XadesService();
int exitosos = 0;
int errores = 0;

// Seleccionar certificado una sola vez y reutilizarlo
using (Signer signer = new Signer(CertUtil.SelectCertificate("Certificado para firma masiva", "Firma Masiva")))
{
    parametros.Signer = signer;

    foreach (var archivo in archivos)
    {
        try
        {
            using (FileStream fs = archivo.OpenRead())
            {
                SignatureDocument sigDocument = xadesService.Sign(fs, parametros);

                // Guardar con extensión .xsig
                string rutaFirmado = Path.Combine(
                    carpetaDocumentos,
                    Path.GetFileNameWithoutExtension(archivo.Name) + ".xsig"
                );
                sigDocument.Save(rutaFirmado);

                exitosos++;
                Console.WriteLine($"✓ Firmado: {archivo.Name}");
            }
        }
        catch (Exception ex)
        {
            errores++;
            Console.WriteLine($"✗ Error en {archivo.Name}: {ex.Message}");
        }
    }
}

Console.WriteLine($"\nResumen: {exitosos} exitosos, {errores} errores");
```

--------------------------------

### Select and Validate X.509 Certificates with CertUtil

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

Use CertUtil to interactively select certificates from the Windows store, retrieve their chain, and verify their validity against a root certificate. Ensure the root certificate file exists and revocation checking is configured as needed.

```csharp
using FirmaXadesNet.Utils;
using System;
using System.Security.Cryptography.X509Certificates;

// Seleccionar certificado del almacén de Windows con diálogo interactivo
X509Certificate2 certificado = CertUtil.SelectCertificate(
    message: "Seleccione el certificado para firmar",
    title: "Firma Digital"
);

if (certificado != null)
{
    Console.WriteLine($"Certificado seleccionado:");
    Console.WriteLine($"  Sujeto: {certificado.Subject}");
    Console.WriteLine($"  Emisor: {certificado.Issuer}");
    Console.WriteLine($"  Válido desde: {certificado.NotBefore}");
    Console.WriteLine($"  Válido hasta: {certificado.NotAfter}");
    Console.WriteLine($"  Número de serie: {certificado.SerialNumber}");
    Console.WriteLine($"  Tiene clave privada: {certificado.HasPrivateKey}");
}

// Obtener cadena de certificación
X509Chain chain = CertUtil.GetCertChain(certificado);
Console.WriteLine($"\nCadena de certificación ({chain.ChainElements.Count} elementos):");
foreach (X509ChainElement element in chain.ChainElements)
{
    Console.WriteLine($"  - {element.Certificate.Subject}");
}

// Verificar certificado contra un certificado raíz específico
X509Certificate2 rootCert = new X509Certificate2("certificado_raiz.cer");
try
{
    bool isValid = CertUtil.VerifyCertificate(
        certificado,
        rootCert,
        X509RevocationMode.Online  // Verificar revocación online
    );
    Console.WriteLine($"Certificado válido: {isValid}");
}
catch (Exception ex)
{
    Console.WriteLine($"Error de validación: {ex.Message}");
}
```

--------------------------------

### Sign Files with Internally Detached Format

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

Shows how to sign arbitrary files by embedding them into the signature document using the INTERNALLY_DETACHED packaging format.

```csharp
using FirmaXadesNet;
using FirmaXadesNet.Crypto;
using FirmaXadesNet.Signature;
using FirmaXadesNet.Signature.Parameters;
using FirmaXadesNet.Utils;
using System;
using System.IO;

XadesService xadesService = new XadesService();
SignatureParameters parametros = new SignatureParameters();

// Configurar firma Internally Detached
parametros.SignaturePackaging = SignaturePackaging.INTERNALLY_DETACHED;
parametros.SignatureMethod = SignatureMethod.RSAwithSHA256;
parametros.SigningDate = DateTime.Now;

// Especificar formato de datos (obligatorio para Internally Detached)
parametros.DataFormat = new DataFormat();
parametros.DataFormat.MimeType = "application/pdf";  // O "text/xml", "application/octet-stream", etc.

// Configurar política de firma (opcional, para XAdES-EPES)
parametros.SignaturePolicyInfo = new SignaturePolicyInfo();
parametros.SignaturePolicyInfo.PolicyIdentifier = "https://ejemplo.com/politica-firma";
parametros.SignaturePolicyInfo.PolicyHash = "hash_de_la_politica_en_base64";
parametros.SignaturePolicyInfo.PolicyUri = "https://ejemplo.com/politica-firma.pdf";

SignatureDocument signatureDocument;
using (parametros.Signer = new Signer(CertUtil.SelectCertificate()))
{
    using (FileStream fs = new FileStream("archivo.pdf", FileMode.Open))
    {
        signatureDocument = xadesService.Sign(fs, parametros);
    }
}

signatureDocument.Save("archivo_firmado.xsig");
Console.WriteLine("Archivo PDF firmado con formato Internally Detached.");
```

--------------------------------

### Sign and Manage XML Documents with SignatureDocument

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

Demonstrates creating an enveloped XAdES signature, accessing the signed XML structure, and saving the output to files or streams.

```csharp
using FirmaXadesNet;
using FirmaXadesNet.Crypto;
using FirmaXadesNet.Signature;
using FirmaXadesNet.Signature.Parameters;
using FirmaXadesNet.Utils;
using System;
using System.IO;
using System.Xml;

XadesService xadesService = new XadesService();

// Crear una firma
SignatureParameters parametros = new SignatureParameters();
parametros.SignaturePackaging = SignaturePackaging.ENVELOPED;
parametros.SignatureMethod = SignatureMethod.RSAwithSHA256;

SignatureDocument signatureDocument;
using (parametros.Signer = new Signer(CertUtil.SelectCertificate()))
{
    using (FileStream fs = new FileStream("documento.xml", FileMode.Open))
    {
        signatureDocument = xadesService.Sign(fs, parametros);
    }
}

// Acceder al documento XML firmado
XmlDocument xmlDoc = signatureDocument.Document;
Console.WriteLine($"Documento XML firmado:");
Console.WriteLine($"  Elemento raíz: {xmlDoc.DocumentElement.Name}");

// Acceder a propiedades de la firma XAdES
var xadesSignature = signatureDocument.XadesSignature;
Console.WriteLine($"  ID de firma: {xadesSignature.Signature.Id}");
Console.WriteLine($"  ID del valor de firma: {xadesSignature.SignatureValueId}");

// Guardar en archivo
signatureDocument.Save("documento_firmado.xml");

// Guardar en Stream
using (MemoryStream ms = new MemoryStream())
{
    signatureDocument.Save(ms);
    Console.WriteLine($"  Tamaño del documento: {ms.Length} bytes");
}

// Obtener bytes del documento directamente
byte[] documentBytes = signatureDocument.GetDocumentBytes();
Console.WriteLine($"  Bytes del documento: {documentBytes.Length}");
```

--------------------------------

### Select Signature Packaging Type

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

This snippet illustrates how to select the appropriate signature packaging type based on document characteristics such as size, whether the original document should be maintained, and the document's format. It uses an if-else if structure to determine the best packaging strategy.

```csharp
using FirmaXadesNet.Signature.Parameters;
using System;

// Tipos de empaquetado disponibles
Console.WriteLine("Tipos de empaquetado de firma:");

Console.WriteLine("\n1. ENVELOPED:");
Console.WriteLine("   - La firma se inserta dentro del documento XML");
Console.WriteLine("   - El documento original se mantiene, la firma es un elemento hijo");
Console.WriteLine("   - Uso: SignaturePackaging.ENVELOPED");

Console.WriteLine("\n2. ENVELOPING:");
Console.WriteLine("   - El documento se envuelve dentro de la firma");
Console.WriteLine("   - La firma contiene el objeto firmado como elemento Object");
Console.WriteLine("   - Uso: SignaturePackaging.ENVELOPING");

Console.WriteLine("\n3. INTERNALLY_DETACHED:");
Console.WriteLine("   - El contenido y la firma están en el mismo archivo");
Console.WriteLine("   - El contenido puede ser cualquier tipo (XML, binario)");
Console.WriteLine("   - Requiere especificar DataFormat.MimeType");
Console.WriteLine("   - Uso: SignaturePackaging.INTERNALLY_DETACHED");

Console.WriteLine("\n4. EXTERNALLY_DETACHED:");
Console.WriteLine("   - La firma está separada del contenido");
Console.WriteLine("   - Mantiene una referencia URI al archivo original");
Console.WriteLine("   - Requiere especificar ExternalContentUri");
Console.WriteLine("   - Uso: SignaturePackaging.EXTERNALLY_DETACHED");

Console.WriteLine("\n5. HASH_INTERNALLY_DETACHED:");
Console.WriteLine("   - Solo se firma el hash del contenido");
Console.WriteLine("   - El contenido original no se incluye");
Console.WriteLine("   - Útil para archivos muy grandes");
Console.WriteLine("   - Uso: SignaturePackaging.HASH_INTERNALLY_DETACHED");

// Ejemplo de selección de empaquetado según caso de uso
SignaturePackaging packaging;
string tipoDocumento = "pdf";
bool archivoGrande = true;
bool mantenerOriginal = false;

if (archivoGrande)
{
    packaging = SignaturePackaging.HASH_INTERNALLY_DETACHED;
}
else if (mantenerOriginal)
{
    packaging = SignaturePackaging.EXTERNALLY_DETACHED;
}
else if (tipoDocumento == "xml")
{
    packaging = SignaturePackaging.ENVELOPED;
}
else
{
    packaging = SignaturePackaging.INTERNALLY_DETACHED;
}

Console.WriteLine($"\nEmpaquetado seleccionado: {packaging}");
```

--------------------------------

### Load and Validate Signatures in a Document

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

This snippet demonstrates how to load existing signed documents and validate the integrity of their signatures, including verifying timestamps if present. It iterates through all found signatures and reports their validity status.

```csharp
using FirmaXadesNet;
using FirmaXadesNet.Signature;
using FirmaXadesNet.Validation;
using System;
using System.IO;

XadesService xadesService = new XadesService();

// Cargar archivo de firma (puede contener múltiples firmas)
SignatureDocument[] firmas;
using (FileStream fs = new FileStream("documento_firmado.xml", FileMode.Open))
{
    firmas = xadesService.Load(fs);
}

Console.WriteLine($"Se encontraron {firmas.Length} firma(s) en el documento.");

// Validar cada firma
foreach (var firma in firmas)
{
    ValidationResult resultado = xadesService.Validate(firma);

    if (resultado.IsValid)
    {
        Console.WriteLine($"✓ Firma válida: {resultado.Message}");

        // Obtener información del certificado firmante
        var certInfo = firma.XadesSignature.KeyInfo;
        Console.WriteLine($"  Información del firmante disponible en KeyInfo");
    }
    else
    {
        Console.WriteLine($"✗ Firma inválida: {resultado.Message}");
    }
}

// También se puede cargar desde ruta de archivo directamente
SignatureDocument[] firmasDesdeArchivo = xadesService.Load("otro_documento.xml");
```

--------------------------------

### Create Counter-Signature for an Existing Signature

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

Use this to sign an existing signature, creating a chain of trust. The counter-signature certifies that the original signature existed at a specific time. Requires loading a signed document and configuring signature parameters.

```csharp
using FirmaXadesNet;
using FirmaXadesNet.Crypto;
using FirmaXadesNet.Signature;
using FirmaXadesNet.Signature.Parameters;
using FirmaXadesNet.Utils;
using System;
using System.IO;

XadesService xadesService = new XadesService();

// Cargar documento firmado
SignatureDocument[] firmas;
using (FileStream fs = new FileStream("documento_firmado.xml", FileMode.Open))
{
    firmas = xadesService.Load(fs);
}

SignatureDocument documentoOriginal = firmas[0];

// Configurar parámetros para contrafirma
SignatureParameters parametros = new SignatureParameters();
parametros.SignatureMethod = SignatureMethod.RSAwithSHA256;
parametros.SigningDate = DateTime.Now;

// Crear contrafirma
SignatureDocument documentoContrafirmado;
using (parametros.Signer = new Signer(CertUtil.SelectCertificate("Seleccione certificado para contrafirma", "Contrafirma")))
{
    documentoContrafirmado = xadesService.CounterSign(documentoOriginal, parametros);
}

documentoContrafirmado.Save("documento_contrafirmado.xml");
Console.WriteLine("Contrafirma creada. La firma original ha sido certificada.");
```

--------------------------------

### Create Hash Signature (Hash Internally Detached)

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

This method signs only the document's hash, not the full content. It's useful for very large files or when the original content should not be included in the signature. Configures the data format for the hash.

```csharp
using FirmaXadesNet;
using FirmaXadesNet.Crypto;
using FirmaXadesNet.Signature;
using FirmaXadesNet.Signature.Parameters;
using FirmaXadesNet.Utils;
using System;
using System.IO;

XadesService xadesService = new XadesService();
SignatureParameters parametros = new SignatureParameters();

// Configurar firma de hash
parametros.SignaturePackaging = SignaturePackaging.HASH_INTERNALLY_DETACHED;
parametros.SignatureMethod = SignatureMethod.RSAwithSHA256;
parametros.SigningDate = DateTime.Now;

// Configurar formato de datos para hash
parametros.DataFormat = new DataFormat();
parametros.DataFormat.MimeType = "hash/sha256";
parametros.DataFormat.Description = "Hash value encoded in binary format";

SignatureDocument signatureDocument;
using (FileStream fs = new FileStream("archivo_grande.zip", FileMode.Open))
{
    using (parametros.Signer = new Signer(CertUtil.SelectCertificate()))
    {
        signatureDocument = xadesService.Sign(fs, parametros);
    }
}

signatureDocument.Save("hash_firmado.xsig");
Console.WriteLine("Firma de hash creada. Solo se firmó el hash SHA-256 del archivo.");
```

--------------------------------

### Create Externally Detached Signature

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

Use this for creating a signature separate from the original content, maintaining a URI reference to the signed file. The original file is not modified.

```csharp
using FirmaXadesNet;
using FirmaXadesNet.Crypto;
using FirmaXadesNet.Signature;
using FirmaXadesNet.Signature.Parameters;
using FirmaXadesNet.Utils;
using System;

XadesService xadesService = new XadesService();
SignatureParameters parametros = new SignatureParameters();

// Configurar firma Externally Detached
parametros.SignaturePackaging = SignaturePackaging.EXTERNALLY_DETACHED;
parametros.SignatureMethod = SignatureMethod.RSAwithSHA256;
parametros.SigningDate = DateTime.Now;

// Especificar URI del contenido externo (ruta del archivo a firmar)
parametros.ExternalContentUri = @"C:\documentos\contrato.xml";

SignatureDocument signatureDocument;
using (parametros.Signer = new Signer(CertUtil.SelectCertificate()))
{
    // Para Externally Detached, el stream puede ser null
    signatureDocument = xadesService.Sign(null, parametros);
}

signatureDocument.Save("contrato_firma.xsig");
Console.WriteLine("Firma Externally Detached creada. El archivo original permanece sin modificar.");
```

--------------------------------

### Upgrade Signature to XAdES-XL

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

Upgrades a signature to XAdES-XL, incorporating validation data like OCSP responses and certificates for long-term validation. Automatically includes XAdES-T if not already present.

```csharp
using FirmaXadesNet;
using FirmaXadesNet.Clients;
using FirmaXadesNet.Signature;
using FirmaXadesNet.Upgraders;
using FirmaXadesNet.Upgraders.Parameters;
using System;
using System.IO;

XadesService xadesService = new XadesService();

// Cargar firma existente
SignatureDocument[] firmas;
using (FileStream fs = new FileStream("documento_firmado.xml", FileMode.Open))
{
    firmas = xadesService.Load(fs);
}

SignatureDocument signatureDocument = firmas[0];

// Configurar parámetros de actualización completos
UpgradeParameters parametros = new UpgradeParameters();

// Servidor de sello de tiempo
parametros.TimeStampClient = new TimeStampClient("http://tss.accv.es:8318/tsa");

// Servidores OCSP para validación de certificados
parametros.OCSPServers.Add(new OcspServer("http://ocsp.ejemplo.com"));
parametros.GetOcspUrlFromCertificate = true;  // También obtener URL OCSP del certificado

// Opcionalmente, añadir listas de revocación (CRL)
// using (FileStream crlStream = new FileStream("lista_revocacion.crl", FileMode.Open))
// {
//     parametros.AddCRL(crlStream);
// }

// Actualizar a XAdES-XL (incluye XAdES-T automáticamente si no existe)
XadesUpgraderService upgrader = new XadesUpgraderService();
upgrader.Upgrade(signatureDocument, SignatureFormat.XAdES_XL, parametros);

signatureDocument.Save("documento_xades_xl.xml");
Console.WriteLine("Firma actualizada a XAdES-XL con información de validación a largo plazo.");
```

--------------------------------

### Create Enveloping Signature

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

This format wraps the XML document within the signature element, ideal for XML documents where the signature contains the signed object. Includes optional signature production place information.

```csharp
using FirmaXadesNet;
using FirmaXadesNet.Crypto;
using FirmaXadesNet.Signature;
using FirmaXadesNet.Signature.Parameters;
using FirmaXadesNet.Utils;
using System;
using System.IO;

XadesService xadesService = new XadesService();
SignatureParameters parametros = new SignatureParameters();

// Configurar firma Enveloping
parametros.SignaturePackaging = SignaturePackaging.ENVELOPING;
parametros.SignatureMethod = SignatureMethod.RSAwithSHA512;
parametros.SigningDate = DateTime.Now;

// Añadir información del lugar de firma (opcional)
parametros.SignatureProductionPlace = new SignatureProductionPlace();
parametros.SignatureProductionPlace.City = "Cartagena";
parametros.SignatureProductionPlace.StateOrProvince = "Murcia";
parametros.SignatureProductionPlace.PostalCode = "30201";
parametros.SignatureProductionPlace.CountryName = "España";

SignatureDocument signatureDocument;
using (parametros.Signer = new Signer(CertUtil.SelectCertificate()))
{
    using (FileStream fs = new FileStream("documento.xml", FileMode.Open))
    {
        signatureDocument = xadesService.Sign(fs, parametros);
    }
}

signatureDocument.Save("documento_enveloping.xml");
Console.WriteLine("Firma Enveloping creada con información de ubicación.");
```

--------------------------------

### Upgrade Signature to XAdES-T

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

Adds a time stamp to an existing XAdES-BES or XAdES-EPES signature. Requires a valid TSA URL configured in the UpgradeParameters.

```csharp
using FirmaXadesNet;
using FirmaXadesNet.Clients;
using FirmaXadesNet.Signature;
using FirmaXadesNet.Upgraders;
using FirmaXadesNet.Upgraders.Parameters;
using System;
using System.IO;

XadesService xadesService = new XadesService();

// Cargar firma existente
SignatureDocument[] firmas;
using (FileStream fs = new FileStream("documento_firmado.xml", FileMode.Open))
{
    firmas = xadesService.Load(fs);
}

SignatureDocument signatureDocument = firmas[0];

// Configurar parámetros de actualización
UpgradeParameters parametros = new UpgradeParameters();

// Configurar cliente de sello de tiempo (TSA)
// Ejemplo con servidor ACCV de España
parametros.TimeStampClient = new TimeStampClient("http://tss.accv.es:8318/tsa");

// Alternativamente, servidor con autenticación
// parametros.TimeStampClient = new TimeStampClient("https://tsa.ejemplo.com", "usuario", "contraseña");

// Crear servicio de actualización y aplicar XAdES-T
XadesUpgraderService upgrader = new XadesUpgraderService();
upgrader.Upgrade(signatureDocument, SignatureFormat.XAdES_T, parametros);

signatureDocument.Save("documento_xades_t.xml");
Console.WriteLine("Firma actualizada a XAdES-T con sello de tiempo.");
```

--------------------------------

### Interact with Time Stamp Authority

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

Demonstrates manual interaction with a TSA to obtain time stamp tokens for arbitrary data. Requires calculating the hash of the content before requesting the token.

```csharp
using FirmaXadesNet.Clients;
using FirmaXadesNet.Crypto;
using System;
using System.Security.Cryptography;
using System.Text;

// Crear cliente de sellado de tiempo
TimeStampClient tsClient = new TimeStampClient("http://tss.accv.es:8318/tsa");

// Cliente con autenticación
TimeStampClient tsClientAuth = new TimeStampClient(
    "https://tsa.ejemplo.com/timestamp",
    "usuario",
    "contraseña"
);

// Calcular hash del contenido a sellar
byte[] contenido = Encoding.UTF8.GetBytes("Documento a sellar");
byte[] hash;
using (SHA256 sha256 = SHA256.Create())
{
    hash = sha256.ComputeHash(contenido);
}

// Obtener sello de tiempo
// certReq = true para incluir el certificado del servidor TSA en la respuesta
byte[] timeStampToken = tsClient.GetTimeStamp(hash, DigestMethod.SHA256, certReq: true);

Console.WriteLine($"Sello de tiempo obtenido: {timeStampToken.Length} bytes");
Console.WriteLine($"Token en Base64: {Convert.ToBase64String(timeStampToken).Substring(0, 50)}...");
```

--------------------------------

### Add Co-Signature to a Document

Source: https://context7.com/pgiacomo69/xades.netcore/llms.txt

Use this to add an additional signature to an already signed document. All signatures refer to the same original content, useful when multiple parties need to sign the same document. Requires loading an existing signed document and configuring signature parameters.

```csharp
using FirmaXadesNet;
using FirmaXadesNet.Crypto;
using FirmaXadesNet.Signature;
using FirmaXadesNet.Signature.Parameters;
using FirmaXadesNet.Utils;
using System;
using System.IO;

XadesService xadesService = new XadesService();

// Cargar documento con firma existente
SignatureDocument[] firmas;
using (FileStream fs = new FileStream("documento_firmado.xml", FileMode.Open))
{
    firmas = xadesService.Load(fs);
}

// Seleccionar la primera firma como base para co-firmar
SignatureDocument documentoFirmado = firmas[0];

// Configurar parámetros para la co-firma
SignatureParameters parametros = new SignatureParameters();
parametros.SignatureMethod = SignatureMethod.RSAwithSHA256;
parametros.SigningDate = DateTime.Now;

var commitment = new SignatureCommitment(SignatureCommitmentType.ProofOfApproval);
parametros.SignatureCommitments.Add(commitment);

// Añadir co-firma con nuevo certificado
SignatureDocument documentoCoFirmado;
using (parametros.Signer = new Signer(CertUtil.SelectCertificate("Seleccione certificado para co-firma", "Co-Firma")))
{
    documentoCoFirmado = xadesService.CoSign(documentoFirmado, parametros);
}

documentoCoFirmado.Save("documento_cofirmado.xml");
Console.WriteLine("Co-firma añadida correctamente. El documento ahora tiene múltiples firmas.");
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.