PdfSigningContext.h

 
#ifndef PDF_SIGNING_CONTEXT_H
#define PDF_SIGNING_CONTEXT_H
 
#include "PdfSigner.h"
 
namespace PoDoFo
{
    class PODOFO_API PdfSignerId final
    {
    public:
        PdfSignerId();
        PdfSignerId(const PdfReference& ref, unsigned signerIndex);
 
        const PdfReference& GetSignatureRef() const { return m_SignatureRef; }
        unsigned GetSignerIndex() const { return m_SignerIndex; }
 
        bool operator==(const PdfSignerId& rhs) const
        {
            return m_SignatureRef == rhs.m_SignatureRef && m_SignerIndex == rhs.m_SignerIndex;
        }
 
        bool operator!=(const PdfSignerId& rhs) const
        {
            return m_SignatureRef != rhs.m_SignatureRef || m_SignerIndex != rhs.m_SignerIndex;
        }
 
    private:
        PdfReference m_SignatureRef;
        unsigned m_SignerIndex;
    };
}
 
namespace std
{
    template<>
    struct hash<PoDoFo::PdfSignerId>
    {
        std::size_t operator()(const PoDoFo::PdfSignerId& id) const noexcept
        {
            return id.GetSignatureRef().ObjectNumber() ^ (id.GetSignatureRef().GenerationNumber() << 16)
                ^ ((size_t)id.GetSignerIndex() << 24);
        }
    };
}
 
namespace PoDoFo
{
    struct PODOFO_API PdfSigningResults final
    {
        std::unordered_map<PdfSignerId, charbuff> Intermediate;
    };
 
    class PODOFO_API PdfSigningContext final
    {
        friend PODOFO_API void SignDocument(PdfMemDocument& doc, StreamDevice& device, PdfSigner& signer,
            PdfSignature& signature, PdfSaveOptions saveOptions);
    public:
        PdfSigningContext();
 
        std::unique_ptr<PdfMemDocument> Restore(std::shared_ptr<StreamDevice> device);
 
        PdfSignerId AddSigner(const PdfSignature& signature, std::shared_ptr<PdfSigner> signer);
 
        void Sign(PdfMemDocument& doc, StreamDevice& device, PdfSaveOptions options = PdfSaveOptions::None);
 
        void StartSigning(PdfMemDocument& doc, std::shared_ptr<StreamDevice> device, PdfSigningResults& results,
            PdfSaveOptions saveOptions = PdfSaveOptions::None);
 
        void FinishSigning(const PdfSigningResults& processedResults);
 
        void DumpInPlace();
 
        std::shared_ptr<PdfSigner> GetSignerEntry(const PdfReference& signatureRef);
 
        std::shared_ptr<PdfSigner> GetSignerEntry(const std::string_view& fullName,
            PdfReference& signatureRef);
 
        bool IsEmpty() const;
 
    private:
        struct SignerDescriptors
        {
            std::string SignatureFullName;              // Signature field full name
            unsigned SignaturePageIndex = 0u - 1u;      // Necessary to correctly recover the PdfSignature field
            unsigned ContextIndex = 0u - 1u;            // Index in the context list
            PdfSigner* Signer;
            std::shared_ptr<PdfSigner> SignerStorage; // Unnecessary for PoDoFo::SignDocument()
        };
 
        // Context data for signing operations
        struct SignerContext
        {
            // Buffer for the final signature /Contents
            charbuff Contents;
            size_t BeaconSize = 0;
            PdfSignatureBeacons Beacons;
            PdfArray ByteRangeArr;
        };
 
        enum class Status
        {
            Config,     
            Started,    
            Finished,   
            Dumped,     
            Restored,   
        };
 
    private:
        // Used by PoDoFo::SignDocument
        void AddSignerUnsafe(const PdfSignature& signature, PdfSigner& signer);
 
    private:
        PdfSignerId addSigner(const PdfSignature& signature, PdfSigner* signer,
            std::shared_ptr<PdfSigner>&& storage);
        void ensureNotStarted() const;
        std::vector<SignerContext> prepareSignatureContexts(PdfMemDocument& doc, bool deferredSigning);
        void saveDocForSigning(PdfMemDocument& doc, StreamDevice& device, PdfSaveOptions saveOptions);
        void appendDataForSigning(PdfMemDocument& doc, StreamDevice& device, std::vector<SignerContext>& contexts,
            std::unordered_map<PdfSignerId, charbuff>* intermediateResults, charbuff& tmpbuff);
        void computeSignatures(std::vector<SignerContext>& contexts, PdfMemDocument& doc, StreamDevice& device,
            const PdfSigningResults* processedResults, charbuff& tmpbuff);
 
    private:
        PdfSigningContext(const PdfSigningContext&) = delete;
        PdfSigningContext& operator==(const PdfSigningContext&) = delete;
 
    private:
        std::unordered_map<PdfReference, SignerDescriptors> m_signers;
        // Used during deferred signing
        PdfMemDocument* m_doc;
        std::shared_ptr<StreamDevice> m_device;
        // Signer contexts used when preparing/finish signing operations
        std::vector<SignerContext> m_contexts;
        Status m_status;
    };
}
 
#endif // PDF_SIGNING_CONTEXT_H