standard_security.h

// Copyright (c) 2009-2025 Avanquest Software. All rights reserved.
 
#ifndef PDFSDK_CXX_PDF_STANDARD_SECURITY_H_INCLUDED_
#define PDFSDK_CXX_PDF_STANDARD_SECURITY_H_INCLUDED_
 
#include <cstring>
#include <cwchar>
#include <string>
 
#include <pdfsdk/core.h>
#include <pdfsdk/cxx/exception.h>
 
namespace PDF {
 
struct StdSecurityParams : PDStdSecurityParams {
 
    enum class PrintPermissions {
        None,           
        LowResolution,  
        HighResolution  
    };
 
    enum class EditPermissions {
        None,                   
        DocumentAssembly,       
        FormFillAndSign,        
        ReviewFormFillAndSign,  
        AnyButExtractPages      
    };
 
    enum class ExtractPermissions {
        None,           
        Accessibility,  
        Any             
    };
 
    PDStdSecurityModifyFlags modifyFlags = 0;
 
    static int GetDefaultKeyLengthByCryptMethod(PDAtom cryptMethod);
 
    static int GetDefaultVersionByCryptMethod(PDAtom cryptMethod, int keyLen);
 
    static int GetDefaultRevisionByCryptMethod(PDAtom cryptMethod, int keyLen);
 
    static PDStdPerms GetAllAllowedDefaultPermissions();
 
    StdSecurityParams();
 
    void SetPermissions(PrintPermissions printPerms, EditPermissions editPerms, ExtractPermissions extractPerms);
 
    void SetCryptMethod(PDAtom method, int keyLen = 0);
 
    void ResetToDefault();
 
    bool operator==(const StdSecurityParams& that) const;
 
    bool HasPasswords() const;
 
    std::wstring GetUserPassword() const;
 
    std::wstring GetOwnerPassword() const;
 
    void SetUserPassword(const std::wstring& newUserPassword);
 
    void SetOwnerPassword(const std::wstring& newOwnerPassword);
};
 
inline int StdSecurityParams::GetDefaultKeyLengthByCryptMethod(PDAtom cryptMethod) {
    switch (cryptMethod) {
        case kPDAtom_V2:
            return 16;
 
        case kPDAtom_AESV2:
            return 16;
 
        case kPDAtom_AESV3:
            return 32;
 
        default:
            return 5;
    }
}
 
inline int StdSecurityParams::GetDefaultVersionByCryptMethod(PDAtom cryptMethod, int keyLen) {
    switch (cryptMethod) {
        case kPDAtom_AESV2:
            return 4;
 
        case kPDAtom_AESV3:
            return 5;
 
        default:
            return keyLen > 5 ? 2 : 1;
    }
}
 
inline int StdSecurityParams::GetDefaultRevisionByCryptMethod(PDAtom cryptMethod, int keyLen) {
    switch (cryptMethod) {
        case kPDAtom_AESV2:  // AES 128 bit
            return 4;
 
        case kPDAtom_AESV3:  // AES 256 bit
            return 6;
 
        default:
            return keyLen > 5 ? 3 : 2;
    }
}
 
inline PDStdPerms StdSecurityParams::GetAllAllowedDefaultPermissions() {
    return 0xFFFFFFFC;
}
 
inline StdSecurityParams::StdSecurityParams() {
    ResetToDefault();
}
 
inline void StdSecurityParams::SetPermissions(PrintPermissions printPerms, EditPermissions editPerms, ExtractPermissions extractPerms) {
    permissions = 0xFFFFF0C0;
 
    if (printPerms == PrintPermissions::LowResolution)
        permissions |= kPDStdPermPrint;
    else if (printPerms == PrintPermissions::HighResolution)
        permissions |= kPDStdPermPrint | kPDStdPermHighPrint;
 
    if (editPerms == EditPermissions::DocumentAssembly)
        permissions |= kPDStdPermDocAssembly;
    else if (editPerms == EditPermissions::FormFillAndSign)
        permissions |= kPDStdPermFillAndSign;
    else if (editPerms == EditPermissions::ReviewFormFillAndSign)
        permissions |= kPDStdPermFillAndSign | kPDStdPermEditNotes;
    else if (editPerms == EditPermissions::AnyButExtractPages)
        permissions |= kPDStdPermFillAndSign | kPDStdPermEditNotes | kPDStdPermEdit;
 
    if (extractPerms == ExtractPermissions::Any)
        permissions |= kPDStdPermAccessible | kPDStdPermCopy;
    else if (extractPerms == ExtractPermissions::Accessibility)
        permissions |= kPDStdPermAccessible;
}
 
inline void StdSecurityParams::SetCryptMethod(PDAtom method, int keyLen) {
    cryptMethod = method;
    if (keyLen == 0)
        keyLen = GetDefaultKeyLengthByCryptMethod(method);
    keyLength = keyLen;
    version = GetDefaultVersionByCryptMethod(method, keyLen);
    revision = GetDefaultRevisionByCryptMethod(method, keyLen);
}
 
inline void StdSecurityParams::ResetToDefault() {
    SetUserPassword(std::wstring{});
    SetOwnerPassword(std::wstring{});
    permissions = GetAllAllowedDefaultPermissions();
    cryptMethod = kPDAtom_AESV3;
    keyLength = 32;
    version = 5;
    revision = 6;
    encryptMetadata = true;
    encryptAttachmentsOnly = false;
}
 
inline bool StdSecurityParams::operator==(const StdSecurityParams& that) const {
    return GetUserPassword() == that.GetUserPassword() &&
           GetOwnerPassword() == that.GetOwnerPassword() &&
           permissions == that.permissions &&
           cryptMethod == that.cryptMethod &&
           keyLength == that.keyLength &&
           version == that.version &&
           revision == that.revision &&
           encryptMetadata == that.encryptMetadata &&
           encryptAttachmentsOnly == that.encryptAttachmentsOnly;
}
 
inline bool StdSecurityParams::HasPasswords() const {
    return hasUserPassword || hasOwnerPassword;
}
 
inline std::wstring StdSecurityParams::GetUserPassword() const {
    if (hasUserPassword)
        return std::wstring(userPassword, wcsnlen(userPassword, kPDStdPasswordMaxChars));
    return std::wstring{};
}
 
inline std::wstring StdSecurityParams::GetOwnerPassword() const {
    if (hasOwnerPassword)
        return std::wstring(ownerPassword, wcsnlen(ownerPassword, kPDStdPasswordMaxChars));
    return std::wstring{};
}
 
inline void StdSecurityParams::SetUserPassword(const std::wstring& newUserPassword) {
    std::memset(userPassword, 0, sizeof(PDStdPassword));
    if (!newUserPassword.empty()) {
        PDStdPasswordSetChars(&userPassword, newUserPassword.c_str());
        hasUserPassword = true;
    } else {
        hasUserPassword = false;
    }
    modifyFlags |= kPDStdSecurityModifyUserPassword;
}
 
inline void StdSecurityParams::SetOwnerPassword(const std::wstring& newOwnerPassword) {
    std::memset(ownerPassword, 0, sizeof(PDStdPassword));
    if (!newOwnerPassword.empty()) {
        PDStdPasswordSetChars(&ownerPassword, newOwnerPassword.c_str());
        hasOwnerPassword = true;
    } else {
        hasOwnerPassword = false;
    }
    modifyFlags |= kPDStdSecurityModifyOwnerPassword;
}
 
}  // namespace PDF
 
#endif  // PDFSDK_CXX_PDF_STANDARD_SECURITY_H_INCLUDED_