问题：

使用iTextSharp外部签名PDF-更改/损坏的文档

公孙志

2023-03-14

目标是实现一个PDF签名过程，在该过程中，服务器（.NET核心服务）根据请求（Electronic）向客户端提供要签名的散列。然后，客户端使用通过PKCS#11接口从智能卡获得的私钥对给定散列进行签名。然后将签名发送回服务器，以便使用iTextSharp将其附加到PDF文件中。

使用node-webcrypto-p11使用智能卡令牌签名哈希的过程目前非常简单（需要进行大量的尝试和错误）。采用的算法是RSASSA-PKCS1-V1_5。我可以成功地对哈希签名并在之后进行验证。

我最近在使用iTextsharp(3)的外部签名PDF的帮助下构建了以前的实现，其中我使用了getAuthenticatedAttributeBytes来获取要签名的散列（如mkl所建议的）。

在查看Acrobat Reader中的签名时，我看到了一个可怕的文件，该文件已被修改/损坏，与oppgkdev相同。如上所述，客户端的签署过程很简单，我不怀疑会出现任何问题（不过，我愿意对此进行审查）。

pgkdev提到了Priyanka的问题，在这个问题上，我发现我可能在签署文档的两步过程中遇到了问题，在这个过程中，散列值不再相同。

如果您检查Grazina的问题，我们可以看到这样的实现是成功的，当您在一个步骤中完成该过程。

mkl进一步提到了一种在两个步骤中成功实现它的方法，但我没有更多关于如何实现它的解释。

注意：没有办法我（我知道）做什么我想在1步，因为签名是由一个电子应用程序中的客户发起。

单击“证书详细信息”显示我的完整证书详细信息。

private const string SIG_FIELD_NAME = "sigField1";

    private byte[] GetPDFHash(string pdfFilePath, byte[] certificateValue)
    {
        var preparedSigPdfFilePath = $"{pdfFilePath}.tempsig.pdf";

        //Get certificates chain from certificate value
        ICollection<X509Certificate> certificatesChain = GetCertificatesChain(certificateValue);

        byte[] hash = CreatePDFEmptySignature(pdfFilePath, preparedSigPdfFilePath, certificatesChain);
        return hash;
    }

    private void SignPDFHash(string pdfFilePath, byte[] hash, byte[] signedHash, byte[] certificateValue)
    {
        var preparedSigPdfFilePath = $"{pdfFilePath}.tempsig.pdf";
        var signedPdfFilePath = $"{pdfFilePath}.signed.pdf";

        //Get certificates chain from certificate value
        ICollection<X509Certificate> certificatesChain = GetCertificatesChain(certificateValue);

        CreateFinalSignature(preparedSigPdfFilePath, signedPdfFilePath, hash, signedHash, certificatesChain);
    }

    private byte[] CreatePDFEmptySignature(string pdfFilePath, string preparedSigPdfFilePath, ICollection<X509Certificate> certificatesChain)
    {
        byte[] hash;

        using (PdfReader reader = new PdfReader(pdfFilePath))
        {
            using (FileStream baos = System.IO.File.OpenWrite(preparedSigPdfFilePath))
            {
                PdfStamper pdfStamper = PdfStamper.CreateSignature(reader, baos, '\0', null, true);
                PdfSignatureAppearance sap = pdfStamper.SignatureAppearance;
                sap.SetVisibleSignature(new Rectangle(36, 720, 160, 780), 1, SIG_FIELD_NAME);

                sap.Certificate = certificatesChain.First();

                var externalEmptySigContainer = new MyExternalEmptySignatureContainer(PdfName.ADOBE_PPKMS, PdfName.ADBE_PKCS7_DETACHED, preparedSigPdfFilePath, certificatesChain);

                MakeSignature.SignExternalContainer(sap, externalEmptySigContainer, 8192);

                hash = externalEmptySigContainer.PdfHash;
            }
        }
        return hash;
    }

    private void CreateFinalSignature(string preparedSigPdfFilePath, string signedPdfFilePath, 
        byte[] hash, byte[] signedHash, ICollection<X509Certificate> certificatesChain)
    {
        using (PdfReader reader = new PdfReader(preparedSigPdfFilePath))
        {
            using (FileStream baos = System.IO.File.OpenWrite(signedPdfFilePath))
            {
                IExternalSignatureContainer externalSigContainer = new MyExternalSignatureContainer(hash, signedHash, certificatesChain);
                MakeSignature.SignDeferred(reader, SIG_FIELD_NAME, baos, externalSigContainer);
            }
        }
    }

    public class MyExternalEmptySignatureContainer : ExternalBlankSignatureContainer
    {
        public string PdfTempFilePath { get; set; }
        public byte[] PdfHash { get; private set; }

        public ICollection<X509Certificate> CertificatesList { get; set; }

        public MyExternalEmptySignatureContainer(PdfName filter, PdfName subFilter, string pdfTempFilePath,
            ICollection<X509Certificate> certificatesChain) : base(filter, subFilter)
        {
            PdfTempFilePath = pdfTempFilePath;
            CertificatesList = certificatesChain;
        }

        override public byte[] Sign(Stream data)
        {
            byte[] sigContainer = base.Sign(data);

            //Get the hash
            IDigest messageDigest = DigestUtilities.GetDigest("SHA-256");
            byte[] messageHash = DigestAlgorithms.Digest(data, messageDigest);

            #region Log
            var messageHashFilePath = $"{PdfTempFilePath}.messageHash-b64.txt";
            System.IO.File.WriteAllText(messageHashFilePath, Convert.ToBase64String(messageHash));
            #endregion Log

            //Add hash prefix
            byte[] sha256Prefix = { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20 };
            byte[] digestInfo = new byte[sha256Prefix.Length + messageHash.Length];
            sha256Prefix.CopyTo(digestInfo, 0);
            messageHash.CopyTo(digestInfo, sha256Prefix.Length);

            #region Log
            var messageHashWithPrefixFilePath = $"{PdfTempFilePath}.messageHash-with-prefix-b64.txt";
            System.IO.File.WriteAllText(messageHashWithPrefixFilePath, Convert.ToBase64String(digestInfo));
            #endregion Log

            var sgn = new PdfPKCS7(null, this.CertificatesList, "SHA256", false);
            var authenticatedAttributeBytes =
                sgn.getAuthenticatedAttributeBytes(messageHash, null, null, CryptoStandard.html" target="_blank">CMS);

            PdfHash = authenticatedAttributeBytes;

            return sigContainer;
        }
    }

    public class MyExternalSignatureContainer : IExternalSignatureContainer
    {
        public byte[] Hash { get; set; }
        public byte[] SignedHash { get; set; }
        public ICollection<X509Certificate> CertificatesList { get; set; }

        public MyExternalSignatureContainer(byte[] hash, byte[] signedHash, ICollection<X509Certificate> certificatesList)
        {
            Hash = hash;
            SignedHash = signedHash;
            CertificatesList = certificatesList;
        }

        public byte[] Sign(Stream data)
        {
            PdfPKCS7 sgn = new PdfPKCS7(null, this.CertificatesList, "SHA256", false);
            sgn.SetExternalDigest(this.SignedHash, null, "RSA");    
            return sgn.GetEncodedPKCS7(this.Hash, null, null, null, CryptoStandard.CMS);         
        }

        public void ModifySigningDictionary(PdfDictionary signDic)  {   }
    }

    private ICollection<X509Certificate> GetCertificatesChain(byte[] certByteArray)
    {
        ICollection<X509Certificate> certChain = new Collection<X509Certificate>();

        X509Certificate2 cert = new X509Certificate2(certByteArray);

        X509Certificate regularCert = new X509CertificateParser()
            .ReadCertificate(cert.GetRawCertData());

        certChain.Add(regularCert);

        return certChain;
    }

编辑：签名PDF

private void CreateFinalSignature(string preparedSigPdfFilePath, string signedPdfFilePath, byte[] signedHash, ICollection<X509Certificate> certificatesChain)
    {
        var messageHashFilePath = $"{preparedSigPdfFilePath}.messageHash-b64.txt";
        string hashString = System.IO.File.ReadAllText(messageHashFilePath);
        byte[] hash = Convert.FromBase64String(hashString);

        using (PdfReader reader = new PdfReader(preparedSigPdfFilePath))
        {
            using (FileStream baos = System.IO.File.OpenWrite(signedPdfFilePath))
            {
                IExternalSignatureContainer externalSigContainer = new MyExternalSignatureContainer(hash, signedHash, certificatesChain);
                MakeSignature.SignDeferred(reader, SIG_FIELD_NAME, baos, externalSigContainer);
            }
        }
    }

保存前的字节数组：

[0] = {byte} 133
[1] = {byte} 170
[2] = {byte} 124
[3] = {byte} 73
[4] = {byte} 225
[5] = {byte} 104
[6] = {byte} 242
[7] = {byte} 79
[8] = {byte} 44
[9] = {byte} 52
[10] = {byte} 173
[11] = {byte} 6
[12] = {byte} 7
[13] = {byte} 250
[14] = {byte} 171
[15] = {byte} 50
[16] = {byte} 226
[17] = {byte} 132
[18] = {byte} 113
[19] = {byte} 31
[20] = {byte} 125
[21] = {byte} 174
[22] = {byte} 53
[23] = {byte} 98
[24] = {byte} 68
[25] = {byte} 117
[26] = {byte} 102
[27] = {byte} 191
[28] = {byte} 109
[29] = {byte} 180
[30] = {byte} 88
[31] = {byte} 133

从CreateFinalSignature中的.txt文件中读取的字节数组：

[0] = {byte} 133
[1] = {byte} 170
[2] = {byte} 124
[3] = {byte} 73
[4] = {byte} 225
[5] = {byte} 104
[6] = {byte} 242
[7] = {byte} 79
[8] = {byte} 44
[9] = {byte} 52
[10] = {byte} 173
[11] = {byte} 6
[12] = {byte} 7
[13] = {byte} 250
[14] = {byte} 171
[15] = {byte} 50
[16] = {byte} 226
[17] = {byte} 132
[18] = {byte} 113
[19] = {byte} 31
[20] = {byte} 125
[21] = {byte} 174
[22] = {byte} 53
[23] = {byte} 98
[24] = {byte} 68
[25] = {byte} 117
[26] = {byte} 102
[27] = {byte} 191
[28] = {byte} 109
[29] = {byte} 180
[30] = {byte} 88
[31] = {byte} 133

编辑：对authenticatedAttributeBytes进行哈希，然后返回要由客户端签名的哈希。

PdfHash=DigestAlgorithms.Digest（新建MemoryStream（authenticatedAttributeBytes）,messageDigest）

PdfHash=SHA256.CREATE().ComputeHash（authenticatedAttributeBytes）

PdfHash=SHA256Managed.Create().ComputeHash（authenticatedAttributeBytes）

GetPDFHash的用法

byte[] bytesToSign = GetPDFHash(Path.Combine(_configuration["documentFileSystemStore:DocumentFolder"], "SignMeMightySigner.pdf"), Convert.FromBase64String(dto.base64certificateValue));

SignPDFHash的用法

SignPDFHash(Path.Combine(_configuration["documentFileSystemStore:DocumentFolder"], "SignMeMightySigner.pdf"),Convert.FromBase64String(dto.base64signature), Convert.FromBase64String(dto.base64certificateValue));

编辑(29.3.2020):我已经检查了我的客户端，找不到任何有问题的东西。选择RSASSA-PKCS1-v1_5 alg进行签名验证。在其他一些问题中，我发现在服务器和客户机之间传输字节数组可能是一个问题，但我已经检查过，结果是base64和字节数组的值都是相同的。

我还能提供什么其他可能的进一步分析吗？我已经看到了一种趋势，即堆栈溢出的人无法通过这个问题，有些人甚至完全放弃了它。我不想也不能做那件事，我想把事情弄个水落石出。

直接通过Adobe Reader与iText延迟签名进行签名

编辑30.3.2020:如上所述，我对AuthenticatedAttributeBytes进行哈希

PdfHash = SHA256Managed.Create().ComputeHash(authenticatedAttributeBytes);

49 75 48 24 6 9 42 134 72 134 247 13 1 9 3 49 11 6 9 42 134 72 134 247 13 1 7 1 48 47 6 9 42 134 72 134 247 13 1 9 4 49 34 4 32 122 115 111 54 139 240 60 168 176 67 64 158 55 107 233 48 77 220 19 208 139 187 42 1 141 149 20 241 151 80 31 79

33 25 105 92 244 51 72 93 179 135 158 84 249 178 103 91 236 247 253 35 232 124 169 112 108 214 63 206 206 2 88 107

IRlpXPQzSF2zh55U+bJnW+z3/SPofKlwbNY/zs4CWGs=

哈希签名（签名）

76 13 184 229 123 212 2 8 140 24 34 88 95 31 255 142 105 220 204 186 172 110 61 75 156 44 185 62 81 209 238 226 67 133 115 247 76 24 182 144 38 164 71 92 124 140 77 16 212 43 52 156 173 90 163 116 0 124 119 119 103 8 12 74 147 1 207 51 156 104 52 231 112 125 115 140 28 105 160 117 235 199 224 166 30 220 111 35 165 49 18 85 253 194 112 254 142 117 46 58 87 13 110 161 151 228 95 238 115 171 70 117 203 103 204 222 233 42 163 37 105 91 177 117 190 238 135 137 162 6 54 125 108 64 148 219 7 198 93 117 12 164 130 123 213 197 233 173 145 77 209 11 166 91 29 137 142 25 20 96 90 130 251 169 234 9 44 245 230 20 46 243 254 98 179 98 148 87 104 151 228 246 231 23 94 134 144 84 177 219 235 90 11 130 33 139 94 155 73 112 60 88 53 150 59 49 184 100 210 82 32 71 66 168 21 167 91 141 94 239 221 156 96 23 132 147 237 15 237 232 112 214 224 61 117 46 143 208 41 64 13 128 44 69 135 172 113 58 8 85 5 176 192 254 107 92

（从客户端接收）已签名的哈希（签名）-base64

TA245XvUAgiMGCJYXx//jmnczLqsbj1LnCy5PlHR7uJDhXP3TBi2kCakR1x8jE0Q1Cs0nK1ao3QAfHd3ZwgMSpMBzzOcaDTncH1zjBxpoHXrx+CmHtxvI6UxElX9wnD+jnUuOlcNbqGX5F/uc6tGdctnzN7pKqMlaVuxdb7uh4miBjZ9bECU2wfGXXUMpIJ71cXprZFN0QumWx2JjhkUYFqC+6nqCSz15hQu8/5is2KUV2iX5PbnF16GkFSx2+taC4Ihi16bSXA8WDWWOzG4ZNJSIEdCqBWnW41e792cYBeEk+0P7ehw1uA9dS6P0ClADYAsRYescToIVQWwwP5rXA==

共有1个答案

尹凌龙

2023-03-14

在MyExternalEmptySignatureContainer.sign中，您可以使用PDF范围流的裸散列正确地确定经过身份验证的属性：

var authenticatedAttributeBytes = sgn.getAuthenticatedAttributeBytes(messageHash, null, null, CryptoStandard.CMS);

但是，在检查示例文件时，我发现signed Message Digest属性包含嵌入在DigestInfo对象中的哈希，而在其他工作中，您将SHA256Prefix应用于MyExternalEmptySignatureContainer.sign中的消息摘要的副本。

因此，显然，当您在MyExternalSignatureContainer.sign中重新创建autheticated属性时

return sgn.GetEncodedPKCS7(this.Hash, null, null, null, CryptoStandard.CMS);

您在this.hash中使用了错误的值。这有两个影响，一方面，消息摘要属性的值现在显然是不正确的，另一方面，为原始的、正确的、经过身份验证的属性创建的签名值与不正确的签名值不匹配。因此，得到的PDF签名加倍不正确。

要解决这个问题，请在这里使用正确的散列值，即PDF范围流中没有该前缀的散列值。

由于您没有显示如何准确地使用getpdfhash和signpdfhash方法，因此我无法更精确地指出错误。

实际上，现在正确的哈希在Message Digest属性中，但签名仍然是错误的哈希，如您的新示例所示：

Signed Attributes Hash: 54B2F135A542EEAA55270AB19210E363D00A7684405403E89B170591A7BCAB5F
Decrypted signature digest: 22D906E686A83FA1A490895A21CD6F9A9272C13FB9B16D8A6E862168458F3640

原因可能是MyExternalEmptySignatureContainer属性PDFHash的内容不是哈希，而是完整的经过身份验证的属性字节。MyExternalEmptySignatureContainer.sign:

var authenticatedAttributeBytes = sgn.getAuthenticatedAttributeBytes(messageHash, null, null, CryptoStandard.CMS);

PdfHash = authenticatedAttributeBytes;

您可能必须计算authenticatedattributeBytes的哈希值，并将其放入pdfhash中。

但是，由于您没有展示如何准确地使用getPDFHash和signPDFHash方法，所以只能猜测。

3月30日，您共享了一次传输的相关数据的日志。特别是：

AuthenticatedAttributeBytes-哈希

33 25 105 92 244 51 72 93 179 135 158 84 249 178 103 91 236 247 253 35 232 124 169 112 108 214 63 206 206 2 88 107

而且

76 13 184 229 123 212 2 8 140 24 34 88 95 31 255 142 105 220 204 186 172 110 61 75 156 44 185 62 81 209 238 226 67 133 115 247 76 24 182 144 38 164 71 92 124 140 77 16 212 43 52 156 173 90 163 116 0 124 119 119 103 8 12 74 147 1 207 51 156 104 52 231 112 125 115 140 28 105 160 117 235 199 224 166 30 220 111 35 165 49 18 85 253 194 112 254 142 117 46 58 87 13 110 161 151 228 95 238 115 171 70 117 203 103 204 222 233 42 163 37 105 91 177 117 190 238 135 137 162 6 54 125 108 64 148 219 7 198 93 117 12 164 130 123 213 197 233 173 145 77 209 11 166 91 29 137 142 25 20 96 90 130 251 169 234 9 44 245 230 20 46 243 254 98 179 98 148 87 104 151 228 246 231 23 94 134 144 84 177 219 235 90 11 130 33 139 94 155 73 112 60 88 53 150 59 49 184 100 210 82 32 71 66 168 21 167 91 141 94 239 221 156 96 23 132 147 237 15 237 232 112 214 224 61 117 46 143 208 41 64 13 128 44 69 135 172 113 58 8 85 5 176 192 254 107 92

136 138 205 115 82 228 115 151 231 220 177 93 171 239 123 224 245 180 234 166 132 201 244 54 69 22 18 16 115 223 70 193

因此，无论客户端代码做什么，它都不会为预散列的AuthenticatedattributeBytes创建签名。它可能会再次对散列字节进行散列，可能会对它们的base64表示进行散列，可能会使用一些随机数，但它并不是您所期望的那样。

您应该找出您的客户机代码实际做了什么，并修复它或向它提供它所需的数据。

例如。如果无法阻止客户端代码对数据进行重新散列，则向其提供未散列的、经过身份验证的属性字节。

类似资料：

使用iTextSharp的外部签名PDF（签名延迟）-签名无效问题（更改/损坏的文档）

目标是实现一个PDF签名过程，其中服务器根据请求向客户端提供要签名的哈希。然后，客户端使用通过PKCS#11接口从智能卡获得的私钥对给定哈希进行签名。然后，签名被发送回服务器，以便使用iTextSharp 5.5.4附加到PDF文件中。在Acrobat Reader中查看签名时，我发现错误“自签名应用以来，文档已被更改或损坏”。下面是我在服务器上计算哈希的方法。客户端对给定的哈希签名后，我将
用iTextSharp签名pdf文件后更改签名外观

我正在编写一个服务，其中我用一个空容器预签名pdf文件，从pdf文件中提取一个字节范围的散列，并将其发送到另一个服务，这将允许用户使用移动电话对散列进行签名。我拿回一个证书，我将注入到预签名pdf文件中的签名容器中。签名本身起作用，数字签名是有效的，但我只需要更改可见签名本身的文本。我认为这是可能的，因为可见签名实际上与证书本身没有任何关系，所以显示来自证书的名称只是一种方便，特别是在多个签名的
使用iTextsharp外部签名PDF（3）

需要通过使用外部webservice对文档哈希进行签名来签署PDF，该过程必须在2个步骤中完成，并使用临时空签名。在Priyanka问题和Grazina问题之后，阅读了那些帖子上的mkl答案，我现在有一个无效的签名，即使像Grazina那样添加了哈希前缀。 iTextSharp版本:5.5.13.1 这个节目是我上一个问题的另一个问题。当前代码（编译并开始调用SignPDF方法）：获得的结果
ITextSharp压模损坏pdf

我试图使用ITextSharp旋转PDF文档中的各个页面。它看起来很有效，因为当我在土坯上打开时，一切看起来都很好。然而，当试图在itextSharp中重新打开时，会抛出各种异常。我可以看出文档出了问题，因为adobe总是问我是否要保存更改时，打开一个与itextSharp操纵的文档，这表明它修复了损坏。疯狂的是，我甚至不必对文档进行任何操作，只需创建一个新的压模并关闭它。下面是代码，被剥离到仍
Java IText7 PDF签名问题-文档在签名后已被更改或损坏

我试图对pdf文件进行签名，但在Adobe中打开签名的pdf文件时，遇到“文档自签名后已被更改或损坏”错误。这个错误不是那么描述性的，我不确定应该在哪里查看，因为代码对我来说似乎很好，但显然不是。。我使用的代码是：签名的哈希的Base64格式为（tmp文件sha_前缀）：签名（AMA）的Base64格式为：有人能帮忙吗？
文档签名后已被更改或损坏

使用iTextSharp外部签名PDF-更改/损坏的文档

共有1个答案

相关问答

相关文章

相关阅读

相关工具

相关文档