PdfEncrypt.h

// SPDX-FileCopyrightText: 2006 Dominik Seichter <domseichter@web.de>
// SPDX-FileCopyrightText: 2020 Francesco Pretto <ceztko@gmail.com>
// SPDX-License-Identifier: LGPL-2.0-or-later OR MPL-2.0
 
#ifndef PDF_ENCRYPT_H
#define PDF_ENCRYPT_H
 
#include "PdfString.h"
#include "PdfReference.h"
 
// Define an opaque type for the internal PoDoFo encryption context
#ifndef PODOFO_CRYPT_CTX
#define PODOFO_CRYPT_CTX void
#endif // PODOFO_CRYPT_CTX
 
namespace PoDoFo
{
 
class PdfDictionary;
class InputStream;
class PdfObject;
class OutputStream;
 
/* Class representing PDF encryption methods. (For internal use only)
 * Based on code from Ulrich Telle: http://wxcode.sourceforge.net/components/wxpdfdoc/
 * Original Copyright header:
 * Name:        pdfencrypt.h
 * Purpose:
 * Author:      Ulrich Telle
 * Modified by:
 * Created:     2005-08-16
 * Copyright:   (c) Ulrich Telle
 * Licence:     wxWindows licence
 */
 
enum class PdfKeyLength : uint16_t
{
    Unknown = 0,
    L40 = 40,
    L48 = 48,
    L56 = 56,
    L64 = 64,
    L72 = 72,
    L80 = 80,
    L88 = 88,
    L96 = 96,
    L104 = 104,
    L112 = 112,
    L120 = 120,
    L128 = 128,
    L256 = 256
};
 
// ISO 32000-2:2020 7.6.4.2 "Standard encryption dictionary":
// "The value of the P entry shall be interpreted as an unsigned
// 32-bit quantity containing a set of flags."
enum class PdfPermissions : uint32_t
{
    None = 0,
    Print = 0x00000004,  
    Edit = 0x00000008,  
    Copy = 0x00000010,  
    EditNotes = 0x00000020,  
    FillAndSign = 0x00000100,  
    Accessible = 0x00000200,  
    DocAssembly = 0x00000400,  
    HighPrint = 0x00000800,   
    Default = Print
        | Edit
        | Copy
        | EditNotes
        | FillAndSign
        | Accessible
        | DocAssembly
        | HighPrint
};
 
enum class PdfEncryptionAlgorithm : uint8_t
{
    None = 0,
    RC4V1 = 1,      
    RC4V2 = 2,      
    AESV2 = 4,      
    AESV3R5 = 8,    
    AESV3R6 = 16,   
};
 
enum class PdfAuthResult : uint8_t
{
    Unknown = 0,
    Unkwnon = 0,
    Failed,     
    User,       
    Owner,      
};
 
class PdfEncryptContext;
 
class PODOFO_API PdfEncrypt
{
    friend class PdfEncryptMD5Base;
    friend class PdfEncryptAESV3;
    PODOFO_PRIVATE_FRIEND(class PdfEncryptSession);
 
public:
    virtual ~PdfEncrypt();
 
    static std::unique_ptr<PdfEncrypt> Create(const std::string_view& userPassword,
        const std::string_view& ownerPassword,
        PdfPermissions protection = PdfPermissions::Default,
        PdfEncryptionAlgorithm algorithm = PdfEncryptionAlgorithm::AESV3R6,
        PdfKeyLength keyLength = PdfKeyLength::Unknown);
 
    static std::unique_ptr<PdfEncrypt> CreateFromObject(const PdfObject& obj);
 
    static PdfEncryptionAlgorithm GetEnabledEncryptionAlgorithms();
 
    static bool IsEncryptionEnabled(PdfEncryptionAlgorithm algorithm);
 
    void EnsureEncryptionInitialized(const PdfString& documentId, PdfEncryptContext& context);
 
    void Authenticate(const std::string_view& password, const PdfString& documentId, PdfEncryptContext& context) const;
 
    virtual void CreateEncryptionDictionary(PdfDictionary& dictionary) const = 0;
 
    virtual std::unique_ptr<InputStream> CreateEncryptionInputStream(InputStream& inputStream, size_t inputLen,
        PdfEncryptContext& context, const PdfReference& objref) const = 0;
 
    virtual std::unique_ptr<OutputStream> CreateEncryptionOutputStream(OutputStream& outputStream,
        PdfEncryptContext& context, const PdfReference& objref) const = 0;
 
    inline PdfEncryptionAlgorithm GetEncryptAlgorithm() const { return m_Algorithm; }
 
    bool IsOwnerPasswordSet() const;
 
    bool IsPrintAllowed() const;
 
    bool IsEditAllowed() const;
 
    bool IsCopyAllowed() const;
 
    bool IsEditNotesAllowed() const;
 
    bool IsFillAndSignAllowed() const;
 
    bool IsAccessibilityAllowed() const;
 
    bool IsDocAssemblyAllowed() const;
 
    bool IsHighPrintAllowed() const;
 
    void EncryptTo(charbuff& out, const bufferview& view, PdfEncryptContext& context, const PdfReference& objref) const;
 
    void DecryptTo(charbuff& out, const bufferview& view, PdfEncryptContext& context, const PdfReference& objref) const;
 
    virtual size_t CalculateStreamLength(size_t length) const = 0;
 
    virtual size_t CalculateStreamOffset() const = 0;
 
    unsigned GetKeyLengthBytes() const;
 
    bufferview GetUValue() const;
 
    bufferview GetOValue() const;
 
public:
    PdfKeyLength GetKeyLength() const { return m_KeyLength; }
 
    inline PdfPermissions GetPValue() const { return m_pValue; }
 
    inline unsigned GetRevision() const { return m_rValue; }
 
    inline bool IsMetadataEncrypted() const { return m_EncryptMetadata; }
 
    inline bool IsParsed() const { return m_IsParsed; }
 
protected:
    inline const unsigned char* GetUValueRaw() const { return m_uValue; }
 
    inline const unsigned char* GetOValueRaw() const { return m_oValue; }
 
    inline const std::string& GetUserPassword() const { return m_userPass; }
 
    inline const std::string& GetOwnerPassword() const { return m_ownerPass; }
 
    int64_t GetPValueForSerialization() const;
 
protected:
    void InitFromValues(PdfEncryptionAlgorithm algorithm, PdfKeyLength keyLength, unsigned char revision,
        PdfPermissions pValue, const bufferview& uValue, const bufferview& oValue,
        bool encryptedMetadata);
 
    void InitFromScratch(const std::string_view& userPassword, const std::string_view& ownerPassword,
        PdfEncryptionAlgorithm algorithm, PdfKeyLength keyLength, unsigned char revision,
        PdfPermissions pValue, bool encryptedMetadata);
 
    virtual void Decrypt(const char* inStr, size_t inLen, PdfEncryptContext& context,
        const PdfReference& objref, char* outStr, size_t& outLen) const = 0;
 
    virtual void Encrypt(const char* inStr, size_t inLen, PdfEncryptContext& context,
        const PdfReference& objref, char* outStr, size_t outLen) const = 0;
 
    virtual PdfAuthResult Authenticate(const std::string_view& password, const std::string_view& documentId,
        PODOFO_CRYPT_CTX* ctx, unsigned char encryptionKey[32]) const = 0;
 
    virtual void GenerateEncryptionKey(
        const std::string_view& documentId, PdfAuthResult authResult, PODOFO_CRYPT_CTX* ctx,
        unsigned char uValue[48], unsigned char oValue[48], unsigned char encryptionKey[32]) = 0;
 
    // Check two keys for equality
    bool CheckKey(const unsigned char key1[32], const unsigned char key2[32]) const;
 
    enum class PdfRC4Revision : uint8_t
    {
        R2 = 2,
        R3 = 3,
    };
 
    enum class PdfAESV3Revision : uint8_t
    {
        R5 = 5,
        R6 = 6,
    };
 
private:
    PdfEncrypt();
 
    PdfEncrypt(const PdfEncrypt& rhs) = default;
 
    PdfEncrypt& operator=(PdfEncrypt& rhs) = delete;
 
private:
    static std::unique_ptr<PdfEncrypt> CreateFromEncrypt(const PdfEncrypt& rhs);
 
    void clearSensitiveInfo();
 
private:
    PdfEncryptionAlgorithm m_Algorithm;   // The used encryption algorithm
    unsigned char m_rValue;            // Revision
    PdfKeyLength m_KeyLength;          // The encryption key length, as enum value
    PdfPermissions m_pValue;           // P entry in pdf document
    unsigned char m_uValue[48];        // U entry in pdf document
    unsigned char m_oValue[48];        // O entry in pdf document
    unsigned char m_uValueSize;
    unsigned char m_oValueSize;
    bool m_EncryptMetadata;            // Is metadata encrypted
    bool m_IsParsed;                   // True if the object is created from parsed values
    bool m_initialized;                // True if the object O/U values were filled
    std::string m_userPass;            // User password
    std::string m_ownerPass;           // Owner password
 
};
 
class PODOFO_API PdfEncryptContext final
{
    friend class PdfEncrypt;
    friend class PdfEncryptRC4;
    friend class PdfEncryptAESV2;
    friend class PdfEncryptAESV3;
 
public:
    PdfEncryptContext();
 
    ~PdfEncryptContext();
 
    PdfEncryptContext(const PdfEncryptContext&);
 
    PdfEncryptContext& operator=(const PdfEncryptContext&);
 
public:
    inline PdfAuthResult GetAuthResult() { return m_AuthResult; }
 
    inline const std::string GetDocumentId() { return m_documentId; }
 
    bool IsAuthenticated() const;
 
private:
    inline const unsigned char* GetEncryptionKey() const { return m_encryptionKey; }
 
    PODOFO_CRYPT_CTX* GetCryptCtx();
 
    template <typename T>
    T& GetCustomCtx()
    {
        if (m_customCtx == nullptr)
        {
            m_customCtx = ::operator new(sizeof(T));
            m_customCtxSize = sizeof(T);
        }
 
        return *(T*)m_customCtx;
    }
 
private:
    unsigned char m_encryptionKey[32]; // Encryption key
    std::string m_documentId;          // DocumentID of the current document
    PdfAuthResult m_AuthResult;
    PODOFO_CRYPT_CTX* m_cryptCtx;
    void* m_customCtx;
    size_t m_customCtxSize;
};
 
 
class PdfEncryptMD5Base : public PdfEncrypt
{
    friend class PdfEncryptRC4;
    friend class PdfEncryptAESV2;
 
private:
    PdfEncryptMD5Base();
 
    PdfEncryptMD5Base(const PdfEncryptMD5Base& rhs);
 
public:
    void CreateEncryptionDictionary(PdfDictionary& dictionary) const override;
 
    // NOTE: We must declare again without body otherwise the other Authenticate overload hides it
    PdfAuthResult Authenticate(const std::string_view& password, const std::string_view& documentId,
        PODOFO_CRYPT_CTX* ctx, unsigned char encryptionKey[32]) const override = 0;
 
protected:
    // Compute owner key
    static void ComputeOwnerKey(const unsigned char userPad[32], const unsigned char ownerPad[32],
        unsigned keylength, unsigned revision, bool authenticate, PODOFO_CRYPT_CTX* ctx, unsigned char ownerKey[32]);
 
    // Pad a password to 32 characters
    static void PadPassword(const std::string_view& password, unsigned char pswd[32]);
 
    // Compute encryption key and user key
    static void ComputeEncryptionKey(const std::string_view& documentID,
        const unsigned char userPad[32], const unsigned char ownerKey[32],
        PdfPermissions pValue, unsigned keyLength, unsigned revision,
        bool encryptMetadata, PODOFO_CRYPT_CTX* ctx,
        unsigned char userKey[32], unsigned char encryptionKey[32]);
 
    void CreateObjKey(unsigned char objkey[16], unsigned& pnKeyLen,
        const unsigned char m_encryptionKey[32], const PdfReference& objref) const;
};
 
class PdfEncryptAESV2 final : public PdfEncryptMD5Base
{
    friend class PdfEncrypt;
 
private:
    PdfEncryptAESV2(PdfString oValue, PdfString uValue, PdfPermissions pValue, bool encryptMetadata);
    PdfEncryptAESV2(const std::string_view& userPassword, const std::string_view& ownerPassword,
        PdfPermissions protection);
    PdfEncryptAESV2(const PdfEncryptAESV2& rhs);
 
public:
    std::unique_ptr<InputStream> CreateEncryptionInputStream(InputStream& inputStream, size_t inputLen,
        PdfEncryptContext& context, const PdfReference& objref) const override;
    std::unique_ptr<OutputStream> CreateEncryptionOutputStream(OutputStream& outputStream,
        PdfEncryptContext& context, const PdfReference& objref) const override;
 
    size_t CalculateStreamOffset() const override;
 
    size_t CalculateStreamLength(size_t length) const override;
 
protected:
    void Encrypt(const char* inStr, size_t inLen, PdfEncryptContext& context,
        const PdfReference& objref, char* outStr, size_t outLen) const override;
    void Decrypt(const char* inStr, size_t inLen, PdfEncryptContext& context,
        const PdfReference& objref, char* outStr, size_t& outLen) const override;
 
    void GenerateEncryptionKey(const std::string_view& documentId, PdfAuthResult authResult, PODOFO_CRYPT_CTX* ctx,
        unsigned char uValue[48], unsigned char oValue[48], unsigned char encryptionKey[32]) override;
 
    PdfAuthResult Authenticate(const std::string_view& password, const std::string_view& documentId,
        PODOFO_CRYPT_CTX* ctx, unsigned char encryptionKey[32]) const override;
 
private:
    void generateInitialVector(const std::string_view& documentId, unsigned char iv[]) const;
};
 
class PdfEncryptAESV3 final : public PdfEncrypt
{
    friend class PdfEncrypt;
 
private:
    PdfEncryptAESV3(PdfString oValue, PdfString oeValue, PdfString uValue, PdfString ueValue,
        PdfPermissions pValue, PdfString permsValue, PdfAESV3Revision rev);
    PdfEncryptAESV3(const std::string_view& userPassword, const std::string_view& ownerPassword,
        PdfAESV3Revision rev, PdfPermissions protection);
    PdfEncryptAESV3(const PdfEncryptAESV3& rhs);
 
public:
    std::unique_ptr<InputStream> CreateEncryptionInputStream(InputStream& inputStream, size_t inputLen,
        PdfEncryptContext& context, const PdfReference& objref) const override;
    std::unique_ptr<OutputStream> CreateEncryptionOutputStream(OutputStream& outputStream,
        PdfEncryptContext& context, const PdfReference& objref) const override;
 
    size_t CalculateStreamOffset() const override;
 
    size_t CalculateStreamLength(size_t length) const override;
 
    void CreateEncryptionDictionary(PdfDictionary& dictionary) const override;
 
    // Get the UE object value (user)
    bufferview GetUEValue() const;
 
    // Get the OE object value (owner)
    bufferview GetOEValue() const;
 
    // Get the Perms object value (encrypted protection)
    bufferview GetPermsValue() const;
 
protected:
    // Encrypt a character string
    void Encrypt(const char* inStr, size_t inLen, PdfEncryptContext& context,
        const PdfReference& objref, char* outStr, size_t outLen) const override;
    void Decrypt(const char* inStr, size_t inLen, PdfEncryptContext& context,
        const PdfReference& objref, char* outStr, size_t& outLen) const override;
 
    PdfAuthResult Authenticate(const std::string_view& password, const std::string_view& documentId,
        PODOFO_CRYPT_CTX* ctx, unsigned char encryptionKey[32]) const override;
 
    void GenerateEncryptionKey(const std::string_view& documentId, PdfAuthResult authResult, PODOFO_CRYPT_CTX* ctx,
        unsigned char uValue[48], unsigned char oValue[48], unsigned char encryptionKey[32]) override;
 
private:
    // Generate initial vector
    static void generateInitialVector(unsigned char iv[]);
 
    // Preprocess password for use in EAS-256 Algorithm
    // outBuf needs to be at least 127 bytes long
    static void preprocessPassword(const std::string_view& password, unsigned char* outBuf, unsigned& len);
 
    // Compute encryption key to be used with AES-256
    static void computeEncryptionKey(unsigned keyLength, unsigned char encryptionKey[32]);
 
    // Compute hash for password and salt with optional uValue
    static void computeHash(const unsigned char* pswd, unsigned pswdLen, unsigned revision,
        const unsigned char salt[8], const unsigned char uValue[48], unsigned char hashValue[32]);
 
    // Generate the U and UE entries
    static void computeUserKey(const unsigned char* userpswd, unsigned len, unsigned revision,
        unsigned keyLength, const unsigned char encryptionKey[32],
        unsigned char uValue[48], unsigned char ueValue[32]);
 
    // Generate the O and OE entries
    static void computeOwnerKey(const unsigned char* userpswd, unsigned len, unsigned revision,
        unsigned keyLength, const unsigned char encryptionKey[32], const unsigned char uValue[48],
        unsigned char oValue[48], unsigned char oeValue[32]);
 
private:
    unsigned char m_ueValue[32];        // UE entry in pdf document
    unsigned char m_oeValue[32];        // OE entry in pdf document
    unsigned char m_permsValue[16];     // Perms entry in pdf document
};
 
class PdfEncryptRC4 final : public PdfEncryptMD5Base
{
    friend class PdfEncrypt;
 
private:
    PdfEncryptRC4(PdfString oValue, PdfString uValue, PdfPermissions pValue,
        PdfRC4Revision revision, PdfEncryptionAlgorithm algorithm,
        unsigned keyLength, bool encryptMetadata);
    PdfEncryptRC4(const std::string_view& userPassword, const std::string_view& ownerPassword,
        PdfPermissions protection,
        PdfEncryptionAlgorithm algorithm,
        PdfKeyLength keyLength);
    PdfEncryptRC4(const PdfEncryptRC4& rhs) = default;
 
public:
    std::unique_ptr<InputStream> CreateEncryptionInputStream(InputStream& inputStream, size_t inputLen,
        PdfEncryptContext& context, const PdfReference& objref) const override;
 
    std::unique_ptr<OutputStream> CreateEncryptionOutputStream(OutputStream& outputStream,
        PdfEncryptContext& context, const PdfReference& objref) const override;
 
    size_t CalculateStreamOffset() const override;
 
    size_t CalculateStreamLength(size_t length) const override;
 
protected:
    void Encrypt(const char* inStr, size_t inLen, PdfEncryptContext& context,
        const PdfReference& objref, char* outStr, size_t outLen) const override;
 
    void Decrypt(const char* inStr, size_t inLen, PdfEncryptContext& context,
        const PdfReference& objref, char* outStr, size_t& outLen) const override;
 
    void GenerateEncryptionKey(const std::string_view& documentId, PdfAuthResult authResult, PODOFO_CRYPT_CTX* ctx,
        unsigned char uValue[48], unsigned char oValue[48], unsigned char encryptionKey[32]) override;
 
    PdfAuthResult Authenticate(const std::string_view& password, const std::string_view& documentId,
        PODOFO_CRYPT_CTX* ctx, unsigned char encryptionKey[32]) const override;
 
private:
    static unsigned normalizeKeyLength(unsigned keyLength);
};
 
}
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfPermissions);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfEncryptionAlgorithm);
 
#endif // PDF_ENCRYPT_H