.Net Developer and Architect

Realizar firmas XAdES desde .Net (5)

2011-11-14T14:56:00+00:00

Lamento los problemas que habéis podido tener los lectores del blog con el ejemplo del último artículo de XAdES. He arreglado el enlace para que podáis acceder al ejemplo. Podéis acceder al adjunto en el mismo artículo, en http://www.devarch.net/post/2011/03/31/realizar-firmas-xades-desde-net-4.aspx

Realizar firmas XAdES desde .Net (4)

2011-03-31T14:01:00+00:00

En el artículo anterior hemos codificado un método que permite realizar la firma XAdES. Sin embargo, al tratar de ejecutar su prueba unitaria, observamos que el método de firma nos devuelve una CryptographicException: Malformed reference element. Esta excepción es levantada por el objeto SignedXml al no conseguir encontrar el nodo con atributo Id y el valor especificado en las diferentes referencias. Vamos a ver cómo solucionar este problema y por fin, conseguir realizar la firma completa.

En concreto, las referencias que nos están dando problemas son las referencias al nodo con Id “KeyInfo” (la clave pública de firma) y la referencia al nodo “XADES-Properties” (el objeto XAdES). Para poder adaptar el objeto SignedXml y lograr realizar estas referencias, deberemos crearnos un objeto que herede de SignedXml. En nuestro ejemplo lo llamaremos XAdESSignedXml. En este objeto, sobrescribiremos el método GetIdElement, que se encarga de buscar los nodos a los que se realizan las referencias, encargándonos en este objeto de buscar manualmente en el Xml los nodos que nos hacen falta:

sealed class XAdESSignedXml: SignedXml
{
    private readonly List<DataObject> _dataObjects = new List<DataObject>();

    public const string XadesSignaturePropertiesNamespace = "http://uri.etsi.org/01903/v1.2.2#SignedProperties";

    public XAdESSignedXml(XmlDocument document) : base(document) { }

    public override XmlElement GetIdElement(XmlDocument doc, string id)
    {
        if (String.IsNullOrEmpty(id)) return null;

        XmlElement xmlElement = base.GetIdElement(doc, id);
        if (xmlElement != null) return xmlElement;

        //Search XAdES node
        foreach (DataObject dataObject in _dataObjects)
        {
            XmlElement nodeWithSameId = findNodeWithAttributeValueIn(dataObject.Data, "Id", id);
            if (nodeWithSameId != null) 
                return nodeWithSameId;
        }

        //Search the KeyInfo node
        if (KeyInfo != null)
        {
            XmlElement nodeWithSameId = findNodeWithAttributeValueIn(KeyInfo.GetXml().SelectNodes("."), "Id", id);
            if (nodeWithSameId != null) 
                return nodeWithSameId;
        }
        return null;
    }
    [... métodos auxiliares...}
}

Sobrescribiendo este método, logramos poder buscar las referencias no solamente en el Xml que se va a firmar, sino también en los objetos que van a formar parte del Xml de firma (dentro del nodo Signature). De esta manera, primero se busca el nodo referenciado mediante la clase SignedXml, y si no se encuentra se pasa a nuestro código propio. Primero se busca, en la colección de objetos _dataObjects el objeto correspondiente al objeto XAdES. Si se encuentra, se devuelve, y si no, se busca el objeto KeyInfo.

De esta manera, SignedXml es capaz de calcular del DigestValue para cada referencia, para posteriormente calcular la firma.

Pero para poder usarlo, tendremos que modificar el método de firma, para emplear nuestro objeto en lugar del SignedXml. Para ello, en el método de firma, sustituiremos:

SignedXml signer = new SignedXml(toSign);

Por lo siguiente:

XAdESSignedXml signer = new XAdESSignedXml(toSign);

Ejecutaremos nuestra prueba unitaria. Si hemos hecho todo bien, obtendremos una prueba correcta, obteniendo el siguiente resultado:

<?xml version="1.0" encoding="UTF-8"?>
<documento id="documento">
	<titulo id="titulo">Documento de pruebas</titulo>
	<descripcion id="descripcion">Documento destinado a realizar pruebas de firma</descripcion>
	<Signature Id="SignatureUsuario" xmlns="http://www.w3.org/2000/09/xmldsig#">
		<SignedInfo>
			<CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#" />
			<SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1" />
			<Reference URI="">
				<Transforms>
					<Transform Algorithm="http://www.w3.org/TR/1999/REC-xpath-19991116">
						<XPath xmlns:ds="http://www.w3.org/2000/09/xmldsig#">not(ancestor-or-self::ds:Signature)</XPath>
					</Transform>
					<Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#" />
				</Transforms>
				<DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" />
				<DigestValue>EhaeWtAs6PEFAMHhHlJDT509kNE=</DigestValue>
			</Reference>
			<Reference Id="SignatureUsuario-XADES-Properties-Ref" URI="#XADES-Properties" Type="http://uri.etsi.org/01903/v1.2.2#SignedProperties">
				<Transforms>
					<Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#" />
				</Transforms>
				<DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" />
				<DigestValue>lBINUyb1H5+S/ufalq/oBHd3Z0E=</DigestValue>
			</Reference>
			<Reference Id="SignatureUsuario-KeyInfo-Ref" URI="#KeyInfo">
				<Transforms>
					<Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#" />
				</Transforms>
				<DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" />
				<DigestValue>VFx0acqOZinC2c+Dv07GiRx9+LE=</DigestValue>
			</Reference>
		</SignedInfo>
		<SignatureValue>EukSphW1wBeWo4X0TwVNj8sPFUafQDQT6aGlKeuRYFSRH83NJU+v4Rk6EKa8VlOmx8UwIBEY/I2B+6T/IF6UYCWvNhuX+W6r7GdlNldBE50Vjo8XLX36L1HiyTXuh1hNc2qOpvlFuR6h4xlfHD8XqQ6XXpu6ScCLdMqJjAVb/Co=</SignatureValue>
		<KeyInfo Id="KeyInfo">
			<X509Data>
				<X509SubjectName>CN=TestCertificate, OU=Testing, OU=local</X509SubjectName>
				<X509Certificate>MIIB2TCCAYegAwIBAgIQZfvBf6QChY9MxURe7gvy3jAJBgUrDgMCHQUAMBYxFDASBgNVBAMTC1Jvb3QgQWdlbmN5MB4XDTExMDMyOTA5MTQyNFoXDTM5MTIzMTIzNTk1OVowPDEOMAwGA1UECxMFbG9jYWwxEDAOBgNVBAsTB1Rlc3RpbmcxGDAWBgNVBAMTD1Rlc3RDZXJ0aWZpY2F0ZTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAyCpLpQjTmY1rymBnrBMj48gVWwseQdqLj47baOX5/dSRNMi8DdTBWV9eHryi4l1ivoG65AD8GHWcMoqiEQ2ZyjhHD/yR2CX5sd6Dm26e+caZIZ7mqm+wD4brR6NpNcJtIPBR2HYiHLPctCHffFmr16hOI6DlYJ5UoBm5TElw7HkCAwEAAaNLMEkwRwYDVR0BBEAwPoAQEuQJLQYdHU8AjWEh3BZkY6EYMBYxFDASBgNVBAMTC1Jvb3QgQWdlbmN5ghAGN2wAqgBkihHPuNSqXDX0MAkGBSsOAwIdBQADQQBTpAn4LfxKfCosDnDQDu6A4GhG8QWKjo9faHkS2xqajiYAiWf76oCIqj1hudcS94xfCp3gaRtajaUaB/ceVa5s</X509Certificate>
			</X509Data>
		</KeyInfo>
		<Object Id="XADES">
			<etsi:QualifyingProperties Target="SignatureUsuario" xmlns:etsi="http://uri.etsi.org/01903/v1.3.2#">
				<etsi:SignedProperties Id="XADES-Properties">
					<etsi:SignedSignatureProperties>
						<etsi:SigningTime>2011-03-31T10:56:13Z</etsi:SigningTime>
						<etsi:SigningCertificate>
							<etsi:Cert>
								<etsi:CertDigest>
									<ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" />
									<ds:DigestValue xmlns:ds="http://www.w3.org/2000/09/xmldsig#">kRV4rHiKIE3iM5ZKx5DBNsDbrd8=</ds:DigestValue>
								</etsi:CertDigest>
								<etsi:IssuerSerial>
									<ds:X509IssuerName xmlns:ds="http://www.w3.org/2000/09/xmldsig#">CN=Root Agency</ds:X509IssuerName>
									<ds:X509SerialNumber xmlns:ds="http://www.w3.org/2000/09/xmldsig#">65FBC17FA402858F4CC5445EEE0BF2DE</ds:X509SerialNumber>
								</etsi:IssuerSerial>
							</etsi:Cert>
						</etsi:SigningCertificate>
					</etsi:SignedSignatureProperties>
				</etsi:SignedProperties>
			</etsi:QualifyingProperties>
		</Object>
	</Signature>
</documento>

Descarga el proyecto de ejemplo de firma

En esta serie de cuatro artículos hemos podido ver, de una manera eminentemente práctica, de que manera realizar una firma mediante el estándar XAdES-BES. Hemos podido ver que la solución al problema es relativamente sencilla, con algún que otro problema que tiene fácil solución. Espero que sea de ayuda para la comunidad.

Realizar firmas XAdES desde .Net (3)

2011-03-31T09:56:04+00:00

En los anteriores artículos de esta serie pudimos ver la estructura de un XML fimado mediante XAdES, y el modo de validar una firma y generar un certificado de pruebas. Por fin, en este tercer artículo de la serie, vamos a firmar documentos. Primero realizaremos una firma XmlDSig y posteriormente ampliaremos esta firma para obtener una firma XAdES correcta.

Para realizar una firma compatible con XmlDSig no tenemos más que emplear la clase SignedXml de .Net, y proporcionarle el Xml que queremos firmar, la clave privada con la que firmaremos y una referencia al nodo que queremos firmar. Haremos una prueba unitaria que nos valide esta operativa:

[TestMethod]
public void TestXmlDSigSignature()
{
    Signature sig = new Signature();
    X509Certificate2 cert = sig.GetCertificateFromStore(StoreLocation.CurrentUser, StoreName.My,
        "91 15 78 ac 78 8a 20 4d e2 33 96 4a c7 90 c1 36 c0 db ad df");

    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<?xml version=\"1.0\" encoding=\"UTF-8\"?><documento id=\"documento\"><titulo id=\"titulo\">Documento de pruebas</titulo><descripcion id=\"descripcion\">Documento destinado a realizar pruebas de firma</descripcion></documento>");

    XmlDocument signed = sig.SignDocument(cert, doc);
    sig.Validate(signed);            
}

Vamos a realizar una firma Enveloped. Para ello implementamos el siguiente método:

public XmlDocument SignDocument(X509Certificate2 cert, XmlDocument doc)
{
    SignedXml signer = new SignedXml(doc);

    //Set the key to sign
    signer.SigningKey = cert.PrivateKey;
    signer.KeyInfo = getKeyInfo(signer, cert);

    //Set nodes idetifiers
    signer.Signature.Id = "SignatureUsuario";
    signer.KeyInfo.Id = "KeyInfo";

    //Set canonicalization method for signature
    signer.SignedInfo.CanonicalizationMethod = SignedXml.XmlDsigExcC14NTransformUrl;

    //Set the reference to sign
    signer.AddReference(setCertificationReference(signer));

    //Compute signature
    signer.ComputeSignature();

    //Construct the Signed Xml and return it
    doc.DocumentElement.AppendChild(doc.ImportNode(signer.GetXml(), true));
    return doc;
}

El método es bastante sencillo de seguir con los comentarios, con lo que no me extenderé en describir cada paso realizado. Tenemos que tener en cuenta que queremos incluir en la firma todo el XML excluyendo el nodo Signature de la firma, de modo que creamos una referencia al contenido del XML mediante una sentencia Xpath. Para ello, vamos a crear el método que nos realizará esta referencia:

private Reference setCertificationReference(SignedXml signer)
{
    Reference reference = new Reference(String.Empty);

    // create the XML that represents the transform
    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<XPath xmlns:ds=\"http://www.w3.org/2000/09/xmldsig#\">not(ancestor-or-self::ds:Signature)</XPath>");

    XmlDsigXPathTransform xform = new XmlDsigXPathTransform();
    xform.LoadInnerXml(doc.DocumentElement.SelectNodes("."));

    reference.TransformChain = new TransformChain();
    reference.TransformChain.Add(xform);
    reference.TransformChain.Add(new XmlDsigExcC14NTransform());

    return reference;
}

private KeyInfo getKeyInfo(SignedXml signer, X509Certificate2 cert)
{
    KeyInfo keyInfo = new KeyInfo();
    KeyInfoX509Data keyInfoClause = new KeyInfoX509Data(cert);
    keyInfoClause.AddSubjectName(cert.SubjectName.Name);
    keyInfo.AddClause(keyInfoClause);
    return keyInfo;
}

Ejecutamos la prueba unitaria y comprobaremos que la firma ser ealiza y se valida correctamente. Este es el XML resultante (tras formatearlo con un editor de texto):

<?xml version="1.0" encoding="UTF-8"?>
<documento id="documento">
	<titulo id="titulo">Documento de pruebas</titulo>
	<descripcion id="descripcion">Documento destinado a realizar pruebas de firma</descripcion>
	<Signature Id="SignatureUsuario" xmlns="http://www.w3.org/2000/09/xmldsig#">
		<SignedInfo>
			<CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#" />
			<SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1" />
			<Reference URI="">
				<Transforms>
					<Transform Algorithm="http://www.w3.org/TR/1999/REC-xpath-19991116">
						<XPath xmlns:ds="http://www.w3.org/2000/09/xmldsig#">not(ancestor-or-self::ds:Signature)</XPath>
					</Transform>
					<Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#" />
				</Transforms>
				<DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" />
				<DigestValue>EhaeWtAs6PEFAMHhHlJDT509kNE=</DigestValue>
			</Reference>
		</SignedInfo>
		<SignatureValue>vN+qTDrnITHaRy94qCJhur1/fZHNJPXh5eT6bkEFh6EQRigI3ZFywO0fllnegX3CBoRhLFiaGbwB2upbpRLMEovzKTjZ4xB/DXmym5KZSPcyO7Fh25iq4L3VIETkGf4zV4cef7ZtDTN2lvKdoKnPkNFNQXXYcxS7WxIIvLKSg2c=</SignatureValue>
		<KeyInfo Id="KeyInfo">
			<X509Data>
				<X509SubjectName>CN=TestCertificate, OU=Testing, OU=local</X509SubjectName>
				<X509Certificate>MIIB2TCCAYegAwIBAgIQZfvBf6QChY9MxURe7gvy3jAJBgUrDgMCHQUAMBYxFDASBgNVBAMTC1Jvb3QgQWdlbmN5MB4XDTExMDMyOTA5MTQyNFoXDTM5MTIzMTIzNTk1OVowPDEOMAwGA1UECxMFbG9jYWwxEDAOBgNVBAsTB1Rlc3RpbmcxGDAWBgNVBAMTD1Rlc3RDZXJ0aWZpY2F0ZTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAyCpLpQjTmY1rymBnrBMj48gVWwseQdqLj47baOX5/dSRNMi8DdTBWV9eHryi4l1ivoG65AD8GHWcMoqiEQ2ZyjhHD/yR2CX5sd6Dm26e+caZIZ7mqm+wD4brR6NpNcJtIPBR2HYiHLPctCHffFmr16hOI6DlYJ5UoBm5TElw7HkCAwEAAaNLMEkwRwYDVR0BBEAwPoAQEuQJLQYdHU8AjWEh3BZkY6EYMBYxFDASBgNVBAMTC1Jvb3QgQWdlbmN5ghAGN2wAqgBkihHPuNSqXDX0MAkGBSsOAwIdBQADQQBTpAn4LfxKfCosDnDQDu6A4GhG8QWKjo9faHkS2xqajiYAiWf76oCIqj1hudcS94xfCp3gaRtajaUaB/ceVa5s</X509Certificate>
			</X509Data>
		</KeyInfo>
	</Signature>
</documento>

Podemos comprobar entonces la sencillez de .Net para realizar una firma en .Net, ya que el objeto SignedXml nos construye para nosotros todo el XML de firma, teniendo solamente que incrustar manualmente el nodo Signature dentro del Xml.

Como vimos en el primer artículo de la serie, XAdES es un protocolo que se basa en XmlDsig, por lo que simplemente tendremos que añadir las partes que necesitamos para cumplimentar el estándar. En concreto, necesitamos:

Añadir un objeto en el cual se describa el certificado y su emisor.
Añadir referencias a este objeto recién creado, así como al nodo KeyInfo.

Empezamos como antes, realizando una prueba unitaria que nos permita validar nuestro desarrollo:

[TestMethod]
public void TestXAdESSignature()
{
    Signature sig = new Signature();
    X509Certificate2 cert = sig.GetCertificateFromStore(StoreLocation.CurrentUser, StoreName.My,
        "91 15 78 ac 78 8a 20 4d e2 33 96 4a c7 90 c1 36 c0 db ad df");

    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<?xml version=\"1.0\" encoding=\"UTF-8\"?><documento id=\"documento\"><titulo id=\"titulo\">Documento de pruebas</titulo><descripcion id=\"descripcion\">Documento destinado a realizar pruebas de firma</descripcion></documento>");

    XmlDocument signed = sig.SignDocumentXAdES(cert, doc);
    sig.Validate(signed);
}

Y desarrollamos el método de firma XAdES, que como se puede observar, es muy similar al que ya desarrollamos antes:

private static XmlDocument SignDocument(X509Certificate2 cert, XmlDocument toSign)
{
    SignedXml signer = new SignedXml(toSign);

    //Set the key to sign
    signer.SigningKey = cert.PrivateKey;
    signer.KeyInfo = getKeyInfo(signer, cert);

    //Set nodes idetifiers
    signer.Signature.Id = "SignatureUsuario";
    signer.KeyInfo.Id = "KeyInfo";

    //Set canonicalization method for signature
    signer.SignedInfo.CanonicalizationMethod = SignedXml.XmlDsigExcC14NTransformUrl;

    //Add XAdES node
    addXAdESNodes(signer, toSign, cert);

    //Set the references to sign
    signer.AddReference(setCertificationReference(signer));
    signer.AddReference(setXAdESReference(signer));
    signer.AddReference(setKeyInfoReference(signer));

    //Compute signature
    signer.ComputeSignature();

    //Construct the Signed Xml and return it 
    toSign.DocumentElement.AppendChild(toSign.ImportNode(signer.GetXml(), true));
    return toSign;
}

La principal peculiaridad es que hay que construir el objeto XAdES a mano, esto es, construir el nodo XML mediante DOM. De esto se encarga el método addXAdESNode (cuyas “tripas”, por su extensión, no reflejaré aquí por brevedad, sólo la parte importante del mismo):

DataObject dataObject = new DataObject();
XmlElement result = document.CreateElement("etsi", "QualifyingProperties", "http://uri.etsi.org/01903/v1.3.2#");

//You must add all the nodes into result XmlElement with DOM 
//Set the attributes and add to SignedXml class 
result.SetAttribute("Target", signedXml.Signature.Id); 
dataObject.Data = result.SelectNodes("."); 
dataObject.Id = "XADES"; signedXml.AddObject(dataObject);

En este trozo de código estamos creando un objeto dentro del cual introduciremos el nodo XAdES construido a mano. El XML resultante (generado con los métodos auxiliares omitidos) queda como sigue:

<Object Id="XADES">
	<etsi:QualifyingProperties Target="SignatureUsuario" xmlns:etsi="http://uri.etsi.org/01903/v1.3.2#">
		<etsi:SignedProperties Id="XADES-Properties">
			<etsi:SignedSignatureProperties>
				<etsi:SigningTime>2011-03-31T10:56:13Z</etsi:SigningTime>
				<etsi:SigningCertificate>
					<etsi:Cert>
						<etsi:CertDigest>
							<ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" />
							<ds:DigestValue xmlns:ds="http://www.w3.org/2000/09/xmldsig#">kRV4rHiKIE3iM5ZKx5DBNsDbrd8=</ds:DigestValue>
						</etsi:CertDigest>
						<etsi:IssuerSerial>
							<ds:X509IssuerName xmlns:ds="http://www.w3.org/2000/09/xmldsig#">CN=Root Agency</ds:X509IssuerName>
							<ds:X509SerialNumber xmlns:ds="http://www.w3.org/2000/09/xmldsig#">65FBC17FA402858F4CC5445EEE0BF2DE</ds:X509SerialNumber>
						</etsi:IssuerSerial>
					</etsi:Cert>
				</etsi:SigningCertificate>
			</etsi:SignedSignatureProperties>
		</etsi:SignedProperties>
	</etsi:QualifyingProperties>
</Object>

No te preocupes, los métodos auxiliares podrás verlos en el adjunto del último artículo de la serie. Simplemente están omitidos por mejorar la legibilidad del mismo. Lo importante es entender que este XML hay que montarlo manualmente.

Posteriormente, necesitaremos implementar los dos métodos que crean las referencias a la clave de firma y al objeto XADES:

private static Reference setXAdESReference(SignedXml signer)
{
    Reference reference = new Reference("#XADES-Properties");
    reference.Id = "SignatureUsuario-XADES-Properties-Ref";
    reference.Type = "http://uri.etsi.org/01903/v1.2.2#SignedProperties";
    reference.AddTransform(new XmlDsigExcC14NTransform());
    return reference;
}

private static Reference setKeyInfoReference(SignedXml signedXml)
{
    Reference reference = new Reference("#" + signedXml.KeyInfo.Id);
    reference.AddTransform(new XmlDsigExcC14NTransform());
    reference.Id = "SignatureUsuario-KeyInfo-Ref";
    return reference;
}

Una vez que terminamos de implementar estos dos métodos, podremos ejecutar la prueba unitaria, puesto que prácticamente tenemos acabado el método de firma. Sin embargo, podemos comprobar que la prueba unitaria no funciona, debido a que obtenemos una excepcion CryptographicException: Malformed reference element. Esta excepción indica que los nodos que estamos referenciando en los métodos setXAdESReference y setKeyinforeference no se encuentran por el objeto SignedXml.

En el próximo artículo veremos como solucionar este problema. Sin embargo, ya hemos avanzado en la solución de la realización de la firma en gran medida.

Realizar firmas XAdES desde .Net (2)

2011-03-28T15:53:00+00:00

En el anterior artículo he introducido el concepto de la firma digital mediante los estándares XAdES y XML-DSig. En este artículo vamos a ver cómo validar una firma mediante XML-DSig, empleando las clases nativas facilitadas en .Net, en modo Enveloped, así como vamos a generar un certificado X509 para poder realizar la firma y ver cómo accedemos al mismo.

Para realizar esta firma vamos a utilizar un certificado de usuario. Un certificado de usuario válido puede ser cualquiera de los expedidos por entidades certificadoras como por ejemplo la Fábrica Nacional de Moneda y Timbre. Para hacer este pequeño ejemplo, emplearemos un certificado de pruebas generado en .Net, tomando como referencia las instrucciones que indico en este artículo. Del mismo artículo podemos tomar el método para recuperar un objeto X509Certificate2 con el contenido del certificado digital.

Primero vamos a escribir un método que nos permita realizar una validación de una firma empleando el objeto SignedXml. Este método podrá validar cualquier XML con firma Enveloped, ya que la clave pública con la que está firmado el XML debería estar presente en el nodo Signature del XML.

public void Validate(XmlDocument document)
{
     XmlNamespaceManager nsMgr = new XmlNamespaceManager(document.NameTable);
     nsMgr.AddNamespace("ds", "http://www.w3.org/2000/09/xmldsig#");

     //Cargamos el XML en el objeto SignedXML
     SignedXml verifier = new SignedXml(document);      

     //Obtenemos el nodo de la firma y se lo porporcionamos al objeto SignedXml para poder realizar la validación
     XmlElement signatureElement = document.DocumentElement.SelectSingleNode("//ds:Signature", nsMgr) as XmlElement;
     verifier.LoadXml(signatureElement);
     
     //Realizamos la comprobación
     if (!verifier.CheckSignature())
         throw new InvalidSignatureException();
}

Generaremos el certificado de pruebas con la siguiente sentencia, para crearnos un certificado en la carpeta Personal del almacén de certificados del usuario que ha iniciado la sesión:

makecert -sr CurrentUser -ss My -a sha1 -n CN=TestCertificate,OU=Testing,OU=local -sky exchange –pe

Lo podremos ver si accedemos a Internet Explorer, abrimos las Opciones de Internet, vamos a la pestaña Contenido y pulsamos el botón Certificados…

Tengamos en cuenta que este certificado sólo nos va a valer para hacer pruebas en la máquina local, si necesitamos hacer pruebas en varias máquinas tendremos que o bien instalar este mismo certificado en ellas, o bien instalar un certificado válido.

Para poder emplear este certificado, modificamos el método para obtener el certificado para que realice la carga del mismo desde el almacén de certificados del usuario:

public X509Certificate2 GetCertificateFromStore(StoreLocation storeLocation, 
    StoreName storeName, string thumbprint)
{
    X509Store store = new X509Store(storeName, storeLocation);
    store.Open(OpenFlags.ReadOnly);
    X509Certificate2Collection certs =
        store.Certificates.Find(X509FindType.FindByThumbprint,
        thumbprint, false);
    store.Close();
    return certs[0];
}

Si hiciéramos una prueba unitaria de este método podríamos comprobar como efectivamente recuperamos el certificado de usuario:

[TestMethod]
public void TestGetCertificate()
{
    Signature sig = new Signature();
    X509Certificate2 cert = sig.GetCertificateFromStore(StoreLocation.CurrentUser, StoreName.My,
        "91 15 78 ac 78 8a 20 4d e2 33 96 4a c7 90 c1 36 c0 db ad df");
    Assert.IsNotNull(cert);
}

Para acceder al certificado empleamos la propiedad Thumbprint (Huella dactilar) del mismo, que podemos ver en las propiedades del certificado:

En el próximo artículo realizaremos una firma con SignedXml y el certificado recuperado.

Realizar firmas XAdES desde .Net (1)

2011-03-25T16:35:33+00:00

Es raro que hasta hace poco, trabajando tanto tiempo con BizTalk y con XML, no haya tenido que trabajar con protocolos de firma de XML. En esta serie de artículos voy a hablar acerca de cómo realizar una firma mediante XAdES (XML Advanced Electronic Signatures). XAdES consiste en una capa superior al estándar de firma XML Xml-DSig (o XML Signature). Pero más raro aún, buscando en internet, es no haber logrado encontrar ningún artículo que hable de conseguir realizar firmas mediante este estándar con .Net, e incluso algunos afirmando que este tipo de firma sólo puede realizarse en Java. Pero nada más lejos de la realidad.

Al finalizar este artículo seremos capaces de realizar firmas compatibles con el estándar XAdES-BES (es el nivel básico de seguridad ofrecido por el estándar, como se puede leer en el artículo de la wikipedia que he enlazado más arriba). Fundamentalmente, un XML con firma XAdES-BES consiste en un documento XML con una firma Enveloped. Este tipo de firma consiste en un XML con nuestros datos, en el cual al final del mismo existe un nodo Signature (establecido en el estándar Xml-DSig) dentro del cual se encuentra la firma del mismo.

Vamos a trabajar con los siguientes objetos en .Net, con lo cual, estaría bien tener ciertas nociones en el uso de los mismos para poder seguir el artículo:

X509Certificate2: Realizaremos la firma mediante un certificado instalado en el almacén de certificados Windows de la máquina. Este objeto representa toda la información del mismo: Clave pública y privada (si existe), emisor del certificado, caducidad, etc etc…
SignedXml: Este objeto es la implementación de Microsoft en .Net del estándar de firma XML Signature. Es clave para poder realizar las firmas correctamente.
XmlDocument (y en general todo el DOM XML de Microsoft): Estos objetos hacen accesible el XML a firmar (y el firmado) mediante el modelo de objetos DOM.
Reference, DataObject: Objetos auxiliares, que nos permitirán generar la estructura de la firma correctamente.

Adicionalmente, también estaría bien conocer las bases de la criptografía, al menos las bases de la firma mediante claves asíncronas. Y conocer el uso de certificados de usuario X509.

Comenzaremos esta introducción, analizando un XML firmado mediante el estándar XAdES-BES. Por ejemplo, si tenemos este XML que necesitamos firmar:

<?xml version="1.0" encoding="UTF-8"?>
<documento id="documento">
  <titulo id="titulo">Documento de pruebas</titulo>
  <descripcion id="descripcion">Documento destinado a realizar pruebas de firma</descripcion>
</documento>

Este sería el XML firmado (el ejemplo está acortado para aportar claridad al artículo):

<?xml version="1.0" encoding="UTF-8"?>
<documento id="documento">
  <titulo id="titulo">Documento de pruebas</titulo>
  <descripcion id="descripcion">Documento destinado a realizar pruebas de firma</descripcion>
  <Signature Id="SignatureUsuario" xmlns="http://www.w3.org/2000/09/xmldsig#">
    <SignedInfo>
      <CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#" />
      <SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1" />
      <Reference URI="">
        <Transforms>
          <Transform Algorithm="http://www.w3.org/TR/1999/REC-xpath-19991116">
            <XPath xmlns:ds="http://www.w3.org/2000/09/xmldsig#">not(ancestor-or-self::ds:Signature)</XPath>
          </Transform>
          <Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#" />
        </Transforms>
        <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" />
        <DigestValue><!-- Digest del XML completo en Base64 --></DigestValue>
      </Reference>
      <Reference Id="SignatureUsuario-XADES-Properties-Ref" URI="#XADES-Properties" Type="http://uri.etsi.org/01903/v1.2.2#SignedProperties">
        <Transforms>
          <Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#" />
        </Transforms>
        <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" />
        <DigestValue><!-- Digest del objeto XAdES en Base64 --></DigestValue>
      </Reference>
      <Reference Id="SignatureUsuario-KeyInfo-Ref" URI="#KeyInfo">
        <Transforms>
          <Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#" />
        </Transforms>
        <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" />
        <DigestValue><!-- Digest del objeto KeyInfo en Base64 --></DigestValue>
      </Reference>
    </SignedInfo>
    <SignatureValue><!-- Valor de la firma en Base64 --></SignatureValue>
    <KeyInfo Id="KeyInfo">
      <X509Data>
        <X509SubjectName><!-- Subject del certificado que realiza la firma --></X509SubjectName>
        <X509Certificate><!-- Clave pública del certificado en Base64 --></X509Certificate>
      </X509Data>
    </KeyInfo>
    <Object Id="XADES">
      <etsi:QualifyingProperties Target="SignatureUsuario" xmlns:etsi="http://uri.etsi.org/01903/v1.3.2#">
        <etsi:SignedProperties Id="XADES-Properties">
          <etsi:SignedSignatureProperties>
            <etsi:SigningTime>2011-03-28T09:56:09Z</etsi:SigningTime>
            <etsi:SigningCertificate>
              <etsi:Cert>
                <etsi:CertDigest>
                  <ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" />
                  <ds:DigestValue xmlns:ds="http://www.w3.org/2000/09/xmldsig#"><!-- Digest del certificado en Base64 --></ds:DigestValue>
                </etsi:CertDigest>
                <etsi:IssuerSerial>
                  <ds:X509IssuerName xmlns:ds="http://www.w3.org/2000/09/xmldsig#"><!-- Asunto del emisor del certificado --></ds:X509IssuerName>
                  <ds:X509SerialNumber xmlns:ds="http://www.w3.org/2000/09/xmldsig#"><!-- Número de serie del certificado emisor --></ds:X509SerialNumber>
                </etsi:IssuerSerial>
              </etsi:Cert>
            </etsi:SigningCertificate>
          </etsi:SignedSignatureProperties>
        </etsi:SignedProperties>
      </etsi:QualifyingProperties>
    </Object>
  </Signature>
</documento>

En este XML podemos observar cómo se introduce un nodo Signature como último elemento que cuelga del nodo raíz. Esta firma es por tanto, una firma Enveloped. Dentro de este nodo firma podemos diferenciar dos partes:

Parte de la firma XmlDSig: Consiste en la parte del nodo Signature comprendida entre las líneas 6 y 40 del ejemplo. Estos nodos son generados de manera nativa por el objeto SignedXml de .Net al realizar el cálculo de la misma.
Extensión XAdES: Consiste en el resto del nodo Signature, esto es, los nodos comprendidos entre las líneas 41 y 61. En estas líneas se describen ciertas propiedades del certificado de usuario que está realizando la firma.

Recordemos que el estándar XML-DSig admite tres tipos de firmas diferentes:

Enveloped: El XML que contiene la firma se incrusta en el interior del XML a firmar, como en el ejemplo anterior.
Enveloping: El documento firmado se incrusta dentro del XML de la firma.
Detached: El XML que contiene la firma es independiente del documento firmado. Por tanto, para validar la firma, es necesario transmitir separadamente el XML de la firma y el XML firmado.

Uso de tablas de cross references como almacenamiento (4)

2010-08-03T12:45:02+00:00

Una vez que hemos visto cómo obtener datos de las tablas de referencia cruzada provistas por BizTalk Server, en este artículo vamos a ver un ejemplo práctico de uso de esta funcionalidad. En este ejemplo veremos como realizar un formateo de mensaje parametrizado.

Primero deberemos establecer el texto del mensaje y sus parámetros. Para ello modificaremos los archivos XML correspondientes:

List_Of_Message_Definition.xml

<listOfMessageDef>
	<messageDef>
		<code>APP1_EMAIL_BODY</code>
		<description>Email to send in case of error in process.</description>
		<argumentName>Argument1 Id</argumentName>
		<argumentName idXRefName="APP1_APPCODE">App Code</argumentName>
	</messageDef>
</listOfMessageDef>

En este XML definimos un mensaje, de nombre APP1_EMAIL_BODY. Este mensaje tendrá dos parámetros:

El primero (Argument1 Id) será un parámetro de reemplazamiento (el valor que facilitemos en el primer parámetro será sustituido directamente en la cadena del mensaje).
El segundo parámetro (App Code) será un parámetro enlazado con una cross reference. Es decir, que se tomará el valor de la cross reference indicado por el valor suministrado al segundo parámetro, y se introducirá en el mensaje.

List_Of_Message_Text.xml

<listOfMessageText lang="es-ES">
   <messageText code="APP1_EMAIL">This is a mail message with id '%1', 
      please contact %2.</messageText>
</listOfMessageText>

En este XML definimos el texto del mensaje, en el que se puede ver que podemos, para un mismo nombre de mensaje, podríamos definir más de un literal de nombre (para su localización). En el literal, se define la posición de los dos argumentos con el literal %n, siendo n la posición del argumento.

List_Of_IdXRef.xml

<listOfIDXRef>
	<idXRef>
		<name>APP1_APPCODE</name>
		<description/>
	</idXRef>
</listOfIDXRef>

En este XML definimos el nombre de la cross reference que empleamos como argumento en el mensaje.

List_Of_IdXRef_Value.xml

<listOfIDXRefData>
	<idXRef name="APP1_APPCODE">
		<appInstance name="APP1_INSTANCE">
			<appID commonID="12">Pedro García</appID>
		</appInstance>
	</idXRef>	
</listOfIDXRefData>

En este XML definimos el valor de la cross reference Para un CommonID 12.

Para el ejemplo supondremos que hemos definido una instancia de aplicación APP1_INSTANCE, dependiente de un tipo de aplicación APP1_TYPE, en sus correspondientes archivos XML de importación.

Una vez definidos e importados los datos mediante BTSXRefImport.exe, simplemente tendremos que llamar al método FormatMessage:

//Reads message body from configuration
varAuxString = Microsoft.BizTalk.CrossReferencing.CrossReferencing.
    FormatMessage("APP1_EMAIL", "es-ES", "APP1_INSTANCE", 
    null, "Identification", "12");

O bien mediante el functoid equivalente, si necesitamos obtener el mensaje desde un mapa:

Con este ejemplo, finalizamos esta serie de artículos que hablan acerca de esta funcionalidad poco documentada de BizTalk Server 2006.

Uso de tablas de cross references como almacenamiento (3)

2010-08-03T10:27:08+00:00

Una vez que hemos descrito las bases de la funcionalidad de cross references ofrecida por BizTalk, cómo estructura internamente BizTalk estos datos en el primer artículo de la serie, y de que manera introducir los parámetros de configuración en las tablas xref en el segundo, en este artículo vamos a ver la parte más importante, de qué manera obtener estos datos para manejarlos en nuestra aplicación.

En primer lugar, tenemos que ver en que lugar debemos acceder a las tablas xref, teniendo dos posibilidades para acceder a las mismas: En mapas y en orquestaciones.

Al acceder a las tablas xref desde mapas, emplearemos una serie de functoids facilitados por BizTalk de manera nativa:

Así, podemos arrastrar los fucntoid necesarios para obtener los datos de configuración. En el ejemplo que nos ocupaba en la primera tabla del artículo 2, para obtener el CommonID de valor 123456789, deberíamos hacer la siguiente llamada al functoid Get Common ID:

Igual podemos hacer para obtener un valor por aplicación, llamando al functoid Get Application ID, o formatear un mensaje con el functoid Format Message.

También tenemos la posibilidad de obtener datos de configuración en las orquestaciones. Para ello, tenemos que referenciar el assembly Microsoft.BizTalk.CrossReferencing (localizado en la ruta de instalación de BizTalk) en el proyecto en que tengamos nuestra orquestación.

Una vez determinado el lugar donde queremos acceder a las tablas xref, emplearemos un shape Message Assignment o un shape Expression, en el que introduciremos este código:

//Reads order CommonID from configuration
varAuxString = Microsoft.BizTalk.CrossReferencing.CrossReferencing.
    GetCommonID("ORDER", "Siebel", "111");

De igual manera, podemos hacer una consulta por valores de aplicación llamando al método GetApplicationID, o formatear un mensaje con el método FormatMessage dentro de este namespace Microsoft.BizTalk.CrossReferencing.CrossReferencing.

En este artículo hemos podido ver cómo consumir los datos almacenados en las tablas xref de BizTalk, como manera de acceder a parámetros de configuración tanto de aplicación como de referencias cruzadas entre diferentes aplicaciones.

Uso de tablas de cross references como almacenamiento (2)

2010-07-15T10:38:58+00:00

En el artículo anterior vimos los pros y contras de emplear las tablas xref de BizTalk para almacenar datos de configuración. En este, vamos a describir de una manera práctica cómo introducir datos de configuración o de referencias cruzadas en BizTalk de una manera sencilla.

Para importar datos en las tablas xref de BizTalk, necesitaremos definir una serie de archivos XML. En este archivo zip tenemos un ejemplo de paquete de despliegue, el cual podemos usar como plantilla para adaptarlo a los valores que necesite nuestra aplicación:

XrefSeed.zip

Una vez modificados los XML, tenemos que llamar a una herramienta de línea de comandos con la siguiente sentencia:

BTSXRefImport.exe -file=SetupFile.xml

Este archivo SetupFile.xml contendrá una lista de archivos XML, los cuales almacenarán todos los datos que se importarán en las diferentes tablas en base de datos. Su contenido será parecido a esto:

<?xml version="1.0" encoding="UTF-8"?>
<Setup-Files xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<!-- btsxrefimport -file=setupfiles.xml-->
	<App_Type_file>List_Of_App_Type.xml</App_Type_file>
	<App_Instance_file>List_Of_App_Instance.xml</App_Instance_file>
	<IDXRef_file>List_Of_IDXRef.xml</IDXRef_file>
	<IDXRef_Data_file>List_Of_IDXRef_Data.xml</IDXRef_Data_file>
         <ValueXRef_file>List_Of_ValueXRef.xml</ValueXRef_file>
	<ValueXRef_Data_file>List_Of_ValueXRef_Data.xml</ValueXRef_Data_file>
	<Msg_Def_file>List_Of_Message_Definition.xml</Msg_Def_file>
	<Msg_Text_file>List_Of_Message_Text.xml</Msg_Text_file>
</Setup-Files>

A partir de aquí tendremos que ir modificando cada archivo XML, teniendo en cuenta que tenemos cuatro grupos de archivos:

Archivos de definición de aplicaciones:

List_Of_App_Type.xml: En este archivo se definen los tipos de aplicación que queremos declarar.
List_Of_App_Instance.xml: En este archivo se definen las diferentes instancias de aplicaciones que necesitemos declarar. Por ejemplo, para un tipo de aplicación APP1, podemos tener varias instancias como por ejemplo APP1.Config, APP1.Constants o APP1.Codes…

Archivos de definición de ID de referencias cruzadas, relacionadas con una instancia de aplicación.

List_Of_IDXRef.xml: En este archivo se definirán los nombres de las claves de configuración para las que queramos dar valores.
List_Of_IDXRef_Data.xml: En este archivo se guardan los valores de las claves de configuración, relacionando estas con las instancias de aplicación.

En la siguiente tabla podemos ver los diferentes datos que pueden almacenar estos archivos:

AppInst	IDXRef	CommonID	AppID
Siebel	ORDER	123456789	111
Oracle	ORDER	123456789	333

De esta manera, para un IDXRef ORDER y un CommonID 123456789, tenemos que para la instancia Siebel, el valor de configuración es 111, mientras que para la instancia Oracle, el valor de configuración es 333.

Archivos de definición de valores de configuración, relacionados con uno o varios tipos de aplicación.

List_Of_ValueXRef.xml: En este archivo se definirán los nombres de las claves de configuración para las que queramos dar valores.
List_Of_ValueXRef_Data.xml: En este archivo se guardan los valores de las claves de configuración.

En la siguiente tabla podemos ver los diferentes datos que pueden almacenar estos archivos:

AppType	ValXRef	CommonValue	AppValue
Siebel	OrderStatus	Open	Open
Oracle	OrderStatus	Open	ENTERED

De esta manera podemos definir un diferente valor para AppValue, dependiendo de la aplicación, para un mismo ValXRef y CommonValue.

Archivos de definición de mensajes y sus literales, pudiendo especificar mensajes en diferentes idiomas.

List_Of_Message_Definition.xml: En este archivo declararemos los ID de los mensajes que necesite nuestra aplicación, así como los posibles parámetros de sustitución que pudieran tener estos.
List_Of_Message_Text.xml: En este archivo se almacenan los literales de los mensajes, especificando el idioma de estos.

Al ejecutar la herramienta BTSXRefImport.exe, se importarán los datos contenidos en estos ocho archivos en nueve tablas de la base de datos BizTalkMgmtDb:

xref_AppInstance
xref_AppType
xref_IDXRef
xref_IDXRefData
xref_MessageArgument
xref_MessageDef
xref_MessageText
xref_ValueXRef
xref_ValueXRefData

Una vez hemos visto la estructura de los archivos XML de xref y para qué sirve cada uno de ellos, en el siguiente artículo veremos cómo obtener estos datos, o bien llamando al API de BizTalk si vamos a leerlos desde código u orquestaciones, o bien empleando functoids si los leemos en mapas.

Uso de tablas de cross references como almacenamiento (1)

2010-07-13T11:27:00+00:00

Dentro de las posibilidades que tenemos de parametrizar nuestra aplicación BizTalk, vamos a ver cómo podemos usar las tablas Cross References (xref) para almacenar valores de configuración que posteriormente podemos consumir en nuestra aplicación.

Sin analizar mucho, podemos recurrir a otras alternativas para almacenar parámetros de nuestra aplicación, pero estas alternativas tienen sus inconvenientes. Por ejemplo:

Uso de archivos XML de configuración. Si tenemos una infraestructura con más de una máquina BizTalk, tendremos que tener cuidado al desplegar la aplicación y configuración (o al modificar un valor de la misma), al tener que realizar la misma modificación en todas las máquinas, es decir, que la configuración es susceptible a errores.
Uso de una base de datos propietaria. Esta solución, aun evitando los problemas de la solución anterior, requiere de un esfuerzo de desarrollo de la base de datos y del código que accede a los parámetros y sus valores.
Uso de la base de datos de Single Sign On. Aunque se puede usar esta base de datos para almacenar datos de configuración, realmente no está diseñada para esta función.
Uso de Business Rules. También se pueden usar para almacenar datos de configuración, pero no es el propósito de esta herramienta, que está diseñada para almacenar decisiones de negocio basadas en parámetros.

Sin embargo, esta solución nos permitirá salvar estos inconvenientes:

No depende de archivos de configuración, con lo que un cambio en la configuración afectará en todo momento a todas las máquinas que estén en un grupo de BizTalk.
No hay que implementar tablas o procedimientos almacenados de base de datos, ni desplegar nuevas bases de datos en el servidor de bases de datos, puesto que se emplean las tablas xref que se encuentran en la base de datos BiztalkMgmtDb.
No hay que realizar ningún desarrollo específico para acceder a estas tablas, puesto que BizTalk posee un API que ya facilita el acceso a estas. Incluso, en el caso de los mapas, ya de manera nativa tenemos functoids que nos devolverán los valores que tengamos parametrizados.

De modo que una vez analizadas las ventajas, vamos a ver cómo almacenar parámetros y valores en estas tablas:

Esta es la estructura de las tablas. Para importar valores dentro de este esquema de base de datos, BizTalk nos facilita una herramienta dentro de la ruta de instalación de BizTalk Server, a la cual tendremos que proporcionarle una serie de archivos Xml con los datos que queremos almacenar. Esta herramienta se denomina BtsXrefImport.exe, es una herramienta de línea de comandos a la cual tendremos que suministrarle un archivo xml de configuración

En el siguiente artículo analizaremos cómo introducir los datos dentro de las tablas de xref, así como obtener la información de ellos desde orquestaciones y mapas.

Certificados y permisos

2010-02-26T07:46:49+00:00

En los servicios WCF se puede establecer seguridad a nivel de mensaje. Para poderlo hacer, hay que instalar un certificado, que será el que se emplee para cifrar el contenido que se requiera.

Ahora bien, un certificado generalmente es instalado por un administrador, pero un servicio generalmente corre con credenciales de usuario restringido. Con lo que normalmente no tendrá privilegios para poder acceder al fichero de la clave privada de los certificados. Vamos a ver cómo manejar esta situación.

El error que nos dará en este caso es:

The certificate 'CN=xxxxxxxx' must have a private key that is capable of key exchange. The process must have access rights for the private key

Lo que nos hará falta es ubicar el archivo que contiene la clave privada del certificado en primer lugar. Y después conceder los permisos. Para lo 2º existe una herramienta en el sistema operativo: cacls.exe. Pero para lo 1º no existe ninguna herramienta.

En la página http://msdn.microsoft.com/en-us/library/aa717039.aspx existen aplicaciones de muestra para WCF, WF y CardSpace. Entre estas muestras hay una aplicación que se lama FindPrivateKey que sirve exactamente para esto.

Se le dice cual es el contenedor del certificado y el nombre del mismo. Por ejemplo, para si queremos obtener el certificado instalado en el almacén personal de la máquina para el nombre NOMBRE-CERTIFICADO pondremos :

FindPrivateKey My LocalMachine -n "CN=NOMBRE-CERTIFICADO" -a

La salida será la ruta del archivo con la clave privada del certificado. Por ejemplo:

C:\Documents and Settings\All Users\Application Data\Microsoft\Crypto\RSA\MachineKeys\8aeda5eb81555f14f8f9960745b5a40d_38f7de48-5ee9-452d-8a5a-92789d7110b1

Y entonces tendremos que ir a ese archivo y dar permisos de lectura al usuario del pool del servicio. Por ejemplo, si el usuario es NETWORK SERVICE, pondremos:

cacls.exe "C:\Documents and Settings\All Users\Application Data\Microsoft\Crypto\RSA\MachineKeys\8aeda5eb81555f14f8f9960745b5a40d_38f7de48-5ee9-452d-8a5a-92789d7110b1" /E /G "NETWORK SERVICE":R

He de dar las gracias a Luis de Santiago que me ha proporcionado esta entrada. Gran truco, Luiso!