用新比利时ID卡（EID中间件和ITEXT）签名PDF

Question

我试图用比利时身份证签署一些PDF。 为了获得这一点，我正在使用比利时开斋节中间件签名数据和ITEXT7，用签名将PDF盖章。

我使用pdfsigner（itext），并且已经实现了一个iexternalsignature来调用EID中间件来签署消息。

所有人都适合使用加密RSA和Hash SHA256的比利时ID卡1.7

。由Adobe Reader（或其他阅读器）。 “该文件已被更改或损坏”。

在哈希（Hashing）或...我搜索几天的某个地方似乎是不匹配的

，但是我不再想知道……

有人对出了什么问题有所了解吗？

事先感谢您的帮助。

这里有一些其他信息。

外部签名类别：

    internal sealed class BeIDSignature : IExternalSignature
    {
        public string GetEncryptionAlgorithm()
        {
            return eidWrapper.Instance.GetEncryptionAlgorithm().ToString();
        }

        public string GetHashAlgorithm()
        {
            switch (EidWrapper.Instance.GetEncryptionAlgorithm())
            {
                case EidWrapper.EncryptionAmgorithm.RSA:
                    return DigestAlgorithms.SHA256;
                case EidWrapper.EncryptionAmgorithm.ECDSA:
                    return DigestAlgorithms.SHA384;
                default:
                    return null;
            }
        }
    
        public byte[] Sign(byte[] message)
        {
            return EidWrapper.Instance.SignData(message);
        }
    }

getEncryptionalgorithm将根据芯片的返回RSA或ECDSA。 符号方法将使用eid-mw packege生成签名。

EidWrapper的符号方法的一小部分代码：

    if (key.KeyType.KeyType == CKK.EC)
    {
        session.SignInit(new Mechanism(CKM.ECDSA_SHA384), key);
        return session.Sign(data);
    }
    else if (key.KeyType.KeyType == CKK.RSA)
    {
        session.SignInit(new Mechanism(CKM.SHA256_RSA_PKCS), key);
        return session.Sign(data);
    }

您可以在这里找到一个带有3个pdf文件的邮政编码：

• 原始文件
• 直接用Adobe签名（可以是Siganture）（可以）
• 一个用eid-mw签名的邮政编码（siganture是可以的）（签名不正常）。但是请记住 对于RSA/SHA256 SIGANTURE而言。

https://easyupload.io/yzscsu

再次感谢您的时间。

Answer 1

这是比利时EID SmartCard的外部容器的样本。

该代码尚未完全实施，但是您可以正确地在ECDSA/SHA384中制作Siganture。

希望这会帮助某人:)

internal sealed class BeIdExternalSignatureContainer : IExternalSignatureContainer
    {
        private IX509Store _crls = null;
        private readonly IHttpClientFactory _httpClientFactory;
        private int _crlsSize = 0;

        public BeIdExternalSignatureContainer(IHttpClientFactory httpClientFactory)
        {
            this._httpClientFactory = httpClientFactory;
        }

        public void ModifySigningDictionary(PdfDictionary signDic)
        {
            signDic.Put(PdfName.Filter, PdfName.Adobe_PPKLite);
            signDic.Put(PdfName.SubFilter, PdfName.ETSI_CAdES_DETACHED);
        }

        public int ComputeEstimateSize()
        {
            // Base on itext estimation
            if (this._crlsSize == 0)
            {
                this.InitializeCrls();
            }

            return (8192 + this._crlsSize + 4192) * 2 + 2;
        }

        public byte[] Sign(Stream data)
        {
            IReadOnlyDictionary<string, byte[]> certificatesBinaries = EidWrapper.Instance.GetCertificateFiles(new string[] {
                        Constants.SIGNATURE_CERTIFICATE_NAME,
                        Constants.CA_CERTIFICATE_NAME,
                        Constants.ROOT_CERTIFICATE_NAME
                    });

            X509Certificate signCertificate = new(X509CertificateStructure.GetInstance(certificatesBinaries[Constants.SIGNATURE_CERTIFICATE_NAME]));
            EidWrapper.EncryptionAlgorithms encryptionAlgorithm = EidWrapper.Instance.GetEncryptionAlgorithm();

            SignerInfoGenerator signerGenerator = new SignerInfoGeneratorBuilder()
                .WithSignedAttributeGenerator(new PadesSignedAttributeGenerator { SigningCertificate = signCertificate })
                .WithUnsignedAttributeGenerator(new PadesUnsignedAttributeGenerator(this._httpClientFactory))
                .Build(new BeIdSignatureFactory(encryptionAlgorithm), signCertificate);

            CmsSignedDataGenerator gen = new();
            gen.AddSignerInfoGenerator(signerGenerator);

            IX509Store x509CertStore = X509StoreFactory.Create(
                "Certificate/Collection",
                new X509CollectionStoreParameters(certificatesBinaries.Values.Select(b => new X509Certificate(X509CertificateStructure.GetInstance(b))).ToList()));

            gen.AddCertificates(x509CertStore);
            gen.AddCrls(this.Crls);

            CmsProcessableInputStream cmsProcessableInputStream = new(data);
            CmsSignedData signedData = gen.Generate(cmsProcessableInputStream, false);
            return signedData.GetEncoded();
        }

        private IX509Store Crls
        {
            get
            {
                if (this._crls == null)
                {
                    this.InitializeCrls();
                }

                return this._crls;
            }
        }

        private void InitializeCrls()
        {
            this._crlsSize = 0;
            List<X509Crl> crls = new();
            X509CrlParser crlParser = new();
            HttpClient httpClient = this._httpClientFactory.CreateClient();
            foreach (var crlUrl in BeIdSignatureConstants.CRL_URL_COLLECTION)
            {
                using HttpResponseMessage response = httpClient.Send(new HttpRequestMessage { Method = HttpMethod.Get, RequestUri = new Uri(crlUrl) });
                if (response.IsSuccessStatusCode)
                {
                    using MemoryStream ms = new MemoryStream();
                    response.Content.ReadAsStream().CopyTo(ms);
                    byte[] crlBytes = ms.ToArray();
                    this._crlsSize += crlBytes.Length;
                    crls.Add(crlParser.ReadCrl(crlBytes));
                }
            }

            this._crls = X509StoreFactory.Create(
                "CRL/Collection",
                new X509CollectionStoreParameters(crls));
        }
    }

internal class BeIdSignatureFactory : ISignatureFactory
    {
        private readonly EidWrapper.EncryptionAlgorithms _encryptionAlgorithm;
        public BeIdSignatureFactory(EidWrapper.EncryptionAlgorithms encryptionAlgorithm)
        {
            this._encryptionAlgorithm = encryptionAlgorithm;
        }

        public IStreamCalculator CreateCalculator()
        {
            BeIdSigner signer = new(this._encryptionAlgorithm);
            signer.Init(true, null);
            return new DefaultSignatureCalculator(signer);
        }

        public object AlgorithmDetails
        {
            get
            {
                return MapAlgorithm(this._encryptionAlgorithm);
            }
        }

        public static AlgorithmIdentifier MapAlgorithm(EidWrapper.EncryptionAlgorithms encryptionAlgorithm)
        {
            switch (encryptionAlgorithm)
            {
                case EidWrapper.EncryptionAlgorithms.RSA:
                    return new AlgorithmIdentifier(PkcsObjectIdentifiers.Sha256WithRsaEncryption, DerNull.Instance);
                case EidWrapper.EncryptionAlgorithms.ECDSA:
                    return new AlgorithmIdentifier(X9ObjectIdentifiers.ECDsaWithSha384, DerNull.Instance);
                default:
                    throw new ArgumentException($"Unsupported encryption algorithm: {encryptionAlgorithm}");
            }
        }
    }

internal class BeIdSigner : ISigner
    {
        private byte[] _input;
        private readonly EidWrapper.EncryptionAlgorithms _encryptionAlgorithm;

        public BeIdSigner(EidWrapper.EncryptionAlgorithms encryptionAlgorithm)
        {
            this._encryptionAlgorithm = encryptionAlgorithm;
        }

        public void Init(bool forSigning, ICipherParameters parameters)
        {
            this.Reset();
        }

        public void Update(byte input)
        {
            throw new NotImplementedException("The \"ISigner.Update\" method is not implemented for the \"BeIdSigner\" class.");
        }

        public void BlockUpdate(byte[] input, int inOff, int length)
        {
            this._input = input.Skip(inOff).Take(length).ToArray();
        }

        public byte[] GenerateSignature()
        {
            return this._encryptionAlgorithm == EidWrapper.EncryptionAlgorithms.ECDSA
                ? PlainToDer(EidWrapper.Instance.SignData(this._input))
                : EidWrapper.Instance.SignData(this._input);
        }

        public bool VerifySignature(byte[] signature)
        {
            throw new NotImplementedException("The \"ISigner.VerifySignature\" method is not implemented for the \"BeIdSigner\" class.");
        }

        public void Reset()
        {
            this._input = null;
        }

        public string AlgorithmName => throw new NotImplementedException("The \"ISigner.AlgorithmName\" property is not implemented for the \"BeIdSigner\" class.");

        private static byte[] PlainToDer(byte[] plain)
        {
            int valueLength = plain.Length / 2;
            BigInteger r = new(1, plain, 0, valueLength);
            BigInteger s = new(1, plain, valueLength, valueLength);
            return new DerSequence(new DerInteger(r), new DerInteger(s)).GetEncoded(Asn1Encodable.Der);
        }
    }

Answer 2

问题。

答案总结了

此 。

此限制主要是由于Itext pdfpkcs7 类，用于创建和验证嵌入PDF中的CMS签名容器。当它用于创建签名容器时，它将其存储在 signaturealgorithm 字段中的标识符不会考虑使用过的哈希算法。例如，它使用相同的RSA值（带有PKCS1 V1.5填充）签名，无论它实际上是SHA1WITHRSA还是SHA256WITHRSA或任何组合。

对于RSA，这是可以的，因为确实有一个标识符可以用于所有这些情况。对于DSA来说，这有点不错，因为在许多情况下，DSA仅限于SHA1使用。

对于ECDSA而言，这不是 可以，只有标识符考虑了哈希算法。在所有这些情况下，Itext使用EC公共密钥标识符，这简直是错误的。几乎没有人注意到此错误的原因是Adobe Acrobat验证显然 此 sign aturalealgorithm 字段的内容：您甚至可以将RSA标识符写入ECDSA签名的该领域验证成功而没有问题。

因此，要创建适当的ECDSA签名，当前不应使用 pdfpkcs7 类。由于所有 pdfsigner.signdetached 在内部使用 pdfpkcs7 类，这又意味着一个人必须使用它们，而是 pdfsigner.signexexnexternal.signexternalcontainer 。结果，一个人不得使用 iexternalsignature 实现来检索一个人的签名值，而是 iexternalalSignatureContainer 实现，其中人们以不同的方式构建CMS签名容器，例如使用Bouncycastle类使用。

在手动的情况下 beidSignature iexternalsignature 的实现，必须相应地更换。

有关更多详细信息，请阅读本节使用哪个接口 itext知识基础文章使用ITEXT 7的数字签名。

ECDSA签名格式

有两种主要格式可以存储ECDSA签名值，要么作为两个整数的TLV（DER）编码序列，要么作为这两个整数的固定长度表示的串联。

根据所使用的格式，必须分别为ECDSA和Plain-ECDSA使用特定的算法标识符。如果一个人需要特定的标识符，则可以将签名值从一种格式转换为另一种格式。

在手工的情况下比利时ID卡以普通格式返回ECDSA签名值。要使用更常见的非平台ECDSA标识符，必须将该值转换为DER格式。可以使用此方法完成此操作：

byte[] PlainToDer(byte[] plain)
{
    int valueLength = plain.Length / 2;
    BigInteger r = new BigInteger(1, plain, 0, valueLength);
    BigInteger s = new BigInteger(1, plain, valueLength, valueLength);
    return new DerSequence(new DerInteger(r), new DerInteger(s)).GetEncoded(Asn1Encodable.Der);
}

（使用itext 7 ）

Answer 3

一些想法：

• 您确定芯片上有一个ECDSA密钥吗？我简短地看了文档（不确定它是最新的-CF。 eid-mw github ），仅提及RSA。此外，如果您可以使用RSA/SHA256签名，则获得ECDSA支持将意味着卡上有第二个密钥对 - 我对此有一些疑问；
• 尝试使用EID与Adobe阅读器中的ECDA / SHA384签名 - 检查是否可以验证签名；
• 使用：诊断数据可能会帮助您插入错误的问题（例如，生成了SHA384 Digest，但签名结构将SHA256提及为Digest Algo）。