Add raw signature to original PDF.

[Ort0x36]

I have the raw signature of the SHA256 hash that I obtain when returning from the API, but I want to know how I can insert it into the PDF and validate it.

Example of request:

 {
     "hash": "Mjyw2pii29w6hg9XQca50xr3FzgJ/bmy5kpK1skMvOw="
 }

Example of response:

 {
     {"raw_signature": "-----BEGIN PKCS7-----\nMIAGCSqGSIb3DQEHAqCAMIACAQExDzANBglghkgBZQMEAgEFADCABgkqhkiG9w0BBwEAAKCAMIIHFjCCBP6gA\n-----END PKCS7-----"
 }

How can I add this raw signature to my original document? I was trying with API PdfCMSEmbedder and
in the section about interrupted subscription.

I'm saving my raw signature to a .p7s file. Here is the code I was testing:

from datetime import datetime
from pyhanko.sign import signers, fields
from pyhanko.sign.signers import cms_embedder
from pyhanko.pdf_utils.incremental_writer import IncrementalPdfFileWriter
import base64
from io import BytesIO

file = open('doc.pdf', 'rb')
input_buf = BytesIO(file.read())
w = IncrementalPdfFileWriter(input_buf)

cms_writer = cms_embedder.PdfCMSEmbedder().write_cms(
    field_name='Signature', writer=w
)
sig_field_ref = next(cms_writer)

assert sig_field_ref.get_object()['/T'] == 'Signature'


timestamp = datetime.now()
sig_obj = signers.SignatureObject(timestamp=timestamp, bytes_reserved=11916)

md_algorithm = 'sha256'

cms_writer.send(
    cms_embedder.SigObjSetup(
        sig_placeholder=sig_obj,
        mdp_setup=cms_embedder.SigMDPSetup(
            md_algorithm=md_algorithm, 
            certify=True,
            docmdp_perms=fields.MDPPerm.NO_CHANGES
        )
    )
)


prep_digest, output = cms_writer.send(
    cms_embedder.SigIOSetup(md_algorithm=md_algorithm, in_place=True)
)

hashb64 = base64.b64encode(prep_digest.document_digest).decode()

cms_bytes = open('documento.p7s', mode='rb').read()
sig_contents = cms_writer.send(cms_bytes)

with open("out_assinado.pdf", "wb") as outfile:
    outfile.write(output.getbuffer())    

[MatthiasValvekens]

Hi @Ort0x36,

That response string looks like a PEM-encoded PKCS#7/CMS message. So if you "unarmor" it with asn1crypto, you'll get the DER payload that PdfCMSEmbedder expects.

asn1crypto is a core dependency of pyHanko, so you should already have it installed.

[Ort0x36]

Explaining the code, the API expects the base64 hash of the document to perform the signature, which is why I use base64 encode in document_digest.

For each execution, I send the digital document in base64 for signature in the service and save the return in the document.p7s file. So theoretically for each execution a new hash is generated and signed.

When the API returns, I can receive the signed hash in RAW/PKCS1 or CMS/PKCS7 format, depending on the parameter I send.

I must be making some confusion with the return of this signed hash, as I can't put it inside the PDF.

My first question is, can I put any of these formats in the original PDF?

If yes, my second question, how do I load this signed hash in the right format to put in the PDF and transform it into a Signed PDF?

[Ort0x36]

Explaining the raw signature part better, assuming I use Pyhanko's internal "sign_raw" function, which returns the raw signature of a given hash, that is, this is practically what the API theoretically does internally.

from pyhanko.pdf_utils.incremental_writer import IncrementalPdfFileWriter
from pyhanko.sign import signers

signer = signers.SimpleSigner.sign_raw(data=b'', digest_algorithm='') # # get raw_signature

What do I need to embed this raw signature inside my PDF?

[MatthiasValvekens]

(on mobile, sorry for any typos/curtness)

Actually it's not; you get back a full PKCS#7/CMS payload. sign_raw would imply only returning the serialised signature of the signed attributes (there are remote signers that do that, but from your previous comments yours seems to be different).

I think you're getting overly hung up on "embedding the signature into the original PDF". That's just not how PDF signing works: the process of preparing the document for signing cannot be decoupled from the document hash computation.

You can't "prefetch" the signature and then expect to be able to embed it into the original file from scratch. PyHanko's interrupted signing API supplies a "prepared" PDF data stream together with the document hash. You have to use that hash to retrieve the signature (that's the vendor-dependent part), and you have to insert it into the prepared stream that you got together with that hash.

[Ort0x36]

In that case, what should I do then? my situation is extremely similar to the discussion: #90

I also have a vendor API endpoint to retrieve the user's certificate that returns a PEM string, I don't know if this works for me, but really this is all a big headache. What would you recommend me?

[MatthiasValvekens]

Have you taken a look at this example in the documentation? Essentially, the step that you'd have to implement is call_external_service to obtain the signature from your external service given the hash pyHanko computes for you. Assuming the response is of the form you specified in your first post, e.g.

 {
     {"raw_signature": "-----BEGIN PKCS7-----\nMIAGCSqGSIb3DQEHAqCAMIACAQExDzANBglghkgBZQMEAgEFADCABgkqhkiG9w0BBwEAAKCAMIIHFjCCBP6gA\n-----END PKCS7-----"
 }

the only transformation you have to apply is extracting the DER from this raw_signature value (using pem.unarmor from asn1crypto, as we discussed above). The value resulting from that is the signature_container in the code sample.

I suggest doing your first implementation without trying to optimise resource usage--just fetch the signature from the service while keeping all pyHanko objects in memory, don't try to save anything other than the final output to disk. Once you get that working, you can start thinking about how to persist the document's state while waiting for the response.