ecdsa-signedxml.cs

#error THIS IS UNTESTED AND UNVERIFIED CODE. IT IS FOR DEMONSTRATION PURPOSES ONLY
using System;
using System.Security.Cryptography;
using System.Security.Cryptography.Xml;
using System.Xml;

namespace scratch
{
    public class ECDsaP256SHA256SignatureDeformatter : AsymmetricSignatureDeformatter
    {
        private ECDsa _ecdsa;

        public ECDsaP256SHA256SignatureDeformatter(ECDsa ecdsa)
        {
            _ecdsa = ecdsa;
        }

        public override void SetHashAlgorithm(string strName)
        {
            if (!strName.Equals("sha256", StringComparison.OrdinalIgnoreCase))
            {
                throw new ArgumentException(nameof(strName));
            }
        }

        public override void SetKey(AsymmetricAlgorithm key)
        {
            _ecdsa = (key as ECDsa) ?? throw new ArgumentException(nameof(key));
        }

        public override bool VerifySignature(byte[] rgbHash, byte[] rgbSignature)
        {
            return _ecdsa.VerifyHash(rgbHash, rgbSignature);
        }
    }


    public class ECDsaP256SHA256SignatureFormatter : AsymmetricSignatureFormatter
    {
        private ECDsa _ecdsa;

        public ECDsaP256SHA256SignatureFormatter(ECDsa ecdsa)
        {
            _ecdsa = ecdsa;
        }

        public override byte[] CreateSignature(byte[] rgbHash)
        {
            return _ecdsa.SignHash(rgbHash ?? throw new InvalidOperationException());
        }

        public override void SetHashAlgorithm(string strName)
        {

            if (!strName.Equals("sha256", StringComparison.OrdinalIgnoreCase))
            {
                throw new ArgumentException(nameof(strName));
            }
        }

        public override void SetKey(AsymmetricAlgorithm key)
        {
            _ecdsa = (key as ECDsa) ?? throw new ArgumentException(nameof(key));
        }
    }

    public class ECDsaP256SHA256SignatureDescription : SignatureDescription
    {
        public ECDsaP256SHA256SignatureDescription()
        {
            KeyAlgorithm = typeof(ECDsa).AssemblyQualifiedName;
        }

        public override HashAlgorithm CreateDigest() => SHA256.Create();
        public override AsymmetricSignatureFormatter CreateFormatter(AsymmetricAlgorithm key)
        {
            if (!(key is ECDsa ecdsa))
            {
                throw new InvalidOperationException();
            }

            return new ECDsaP256SHA256SignatureFormatter(ecdsa);
        }

        public override AsymmetricSignatureDeformatter CreateDeformatter(AsymmetricAlgorithm key)
        {
            if (!(key is ECDsa ecdsa))
            {
                throw new InvalidOperationException();
            }

            return new ECDsaP256SHA256SignatureDeformatter(ecdsa);
        }
    }

    class EntryPoint {
        static void Main()
        {
            CryptoConfig.AddAlgorithm(typeof(ECDsaP256SHA256SignatureDescription), "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256");
            XmlDocument doc = GetDocument();
            SignedXml sxml = new SignedXml(doc);
            sxml.SignedInfo.SignatureMethod = "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256";
            using var ecdsa = ECDsa.Create(ECCurve.NamedCurves.nistP256);
            sxml.SigningKey = ecdsa;
            Reference reference = new Reference();
            reference.Uri = "";
            XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform();
            reference.AddTransform(env);
            sxml.AddReference(reference);
            sxml.ComputeSignature();
            Console.WriteLine(sxml.GetXml().OuterXml);
            Console.WriteLine("Valid: " + sxml.CheckSignature(ecdsa));
        }

        static XmlDocument GetDocument()
        {
            var doc = new XmlDocument();
            doc.LoadXml("<root><tree><leaf>test</leaf></tree></root>");
            return doc;
        }
    }
}