Quelle  PDFEncryptorR6.hxx   Sprache: C

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#pragma once

#include <rtl/ustring.hxx>
#include <string_view>
#include <vector>
#include <vcl/dllapi.h>
#include <pdf/IPDFEncryptor.hxx>

namespace vcl::pdf
{
class EncryptionHashTransporter;

/** Algorithm 2.B: Computing a hash (revision 6 and later)
 *
 * Described in ISO 32000-2:2020(E) - 7.6.4.3.4
 */
VCL_DLLPUBLIC std::vector<sal_uInt8>
computeHashR6(const sal_uInt8* pPassword, size_t nPasswordLength,
              std::vector<sal_uInt8> const& rValidationSalt,
              std::vector<sal_uInt8> const& rUserKey = std::vector<sal_uInt8>());

/** Algorithm 11: Authenticating the user password (Security handlers of revision 6)
 *
 * Described in ISO 32000-2:2020(E) - 7.6.4.4.10
 */
VCL_DLLPUBLIC bool validateUserPassword(const sal_uInt8* pUserPass, size_t nPasswordLength,
                                        std::vector<sal_uInt8>& U);

/** Algorithm 12: Authenticating the owner password (Security handlers of revision 6)
 *
 * Described in ISO 32000-2:2020(E) - 7.6.4.4.11
 */
VCL_DLLPUBLIC bool validateOwnerPassword(const sal_uInt8* pUserPass, size_t nPasswordLength,
                                         const std::vector<sal_uInt8>& U,
                                         std::vector<sal_uInt8>& O);

/** Generates the encryption key - random data 32-byte */
VCL_DLLPUBLIC std::vector<sal_uInt8> generateKey();

/** Algorithm 8: U and UE
 *
 * Computing the encryption dictionary’s U (user password) and UE (user encryption) values
 * (Security handlers of revision 6)
 *
 * Described in ISO 32000-2:2020(E) - 7.6.4.4.7
 */
VCL_DLLPUBLIC void generateUandUE(const sal_uInt8* pUserPass, size_t nPasswordLength,
                                  std::vector<sal_uInt8>& rFileEncryptionKey,
                                  std::vector<sal_uInt8>& U, std::vector<sal_uInt8>& UE);

/** Algorithm 9: O and OE
 *
 * Computing the encryption dictionary’s O (owner password) and OE (owner encryption) values
 * (Security handlers of revision 6)
 *
 * Described in ISO 32000-2:2020(E) - 7.6.4.4.8
 */
VCL_DLLPUBLIC void generateOandOE(const sal_uInt8* pUserPass, size_t nPasswordLength,
                                  std::vector<sal_uInt8>& rFileEncryptionKey,
                                  const std::vector<sal_uInt8>& U, std::vector<sal_uInt8>& O,
                                  std::vector<sal_uInt8>& OE);

/** Algorithm 8 step b) in reverse
 *
 * Described in ISO 32000-2:2020(E) - 7.6.4.4.7
 *
 * - compute the hash with password and user key salt
 * - decrypt with hash as key and zero IV
 */
VCL_DLLPUBLIC std::vector<sal_uInt8> decryptKey(const sal_uInt8* pUserPass, size_t nPasswordLength,
                                                std::vector<sal_uInt8>& U,
                                                std::vector<sal_uInt8>& UE);

/** Algorithm 13: Validating the permissions (Security handlers of revision 6)
 *
 * Described in ISO 32000-2:2020(E) - 7.6.4.4.12
 */
VCL_DLLPUBLIC std::vector<sal_uInt8> decryptPerms(std::vector<sal_uInt8>& rPermsEncrypted,
                                                  std::vector<sal_uInt8>& rFileEncryptionKey);

/** Algorithm 10 step f)
 *
 * Computing the encryption dictionary’s Perms (permissions) value (Security handlers of revision 6)
 *
 * Described in ISO 32000-2:2020(E) - 7.6.4.4.9
 */
VCL_DLLPUBLIC std::vector<sal_uInt8> encryptPerms(std::vector<sal_uInt8>& rPerms,
                                                  std::vector<sal_uInt8>& rFileEncryptionKey);

/** Algorithm 10 steps a) - e)
 *
 * Computing the encryption dictionary’s Perms (permissions) value (Security handlers of revision 6)
 *
 * Described in ISO 32000-2:2020(E) - 7.6.4.4.9
 */
VCL_DLLPUBLIC std::vector<sal_uInt8> createPerms(sal_Int32 nAccessPermissions,
                                                 bool bEncryptMetadata);

/** Padding as described in Internet RFC 8018
 *
 * Described in ISO 32000-2:2020(E) - 7.6.3.1
 */
VCL_DLLPUBLIC size_t addPaddingToVector(std::vector<sal_uInt8>& rVector, size_t nBlockSize);

class EncryptionContext;

/** IPDFEncryptor implementation of PDF encryption version 5 revision 6 added in PDF 2.0
 *
 * The complete algorithm is defined in PDF 2.0 specification ISO 32000-2:2020(E)
 */
class VCL_DLLPUBLIC PDFEncryptorR6 : public IPDFEncryptor
{
    std::unique_ptr<EncryptionContext> m_pEncryptionContext;
    sal_Int32 m_nAccessPermissions = 0;

public:
    PDFEncryptorR6();
    ~PDFEncryptorR6();

    sal_Int32 getVersion() override { return 5; }
    sal_Int32 getRevision() override { return 6; }
    sal_Int32 getAccessPermissions() override { return m_nAccessPermissions; }
    bool isMetadataEncrypted() override { return true; }
    /** Key length - AES 256 bit */
    sal_Int32 getKeyLength() override { return 256 / 8; }

    std::vector<sal_uInt8> getEncryptedAccessPermissions(std::vector<sal_uInt8>& rKey) override;

    static void initEncryption(EncryptionHashTransporter& rEncryptionHashTransporter,
                               const OUString& i_rOwnerPassword, const OUString& i_rUserPassword);

    bool prepareEncryption(
        const css::uno::Reference<css::beans::XMaterialHolder>& xEncryptionMaterialHolder,
        PDFEncryptionProperties& rProperties) override;

    void setupKeysAndCheck(PDFEncryptionProperties& rProperties) override;

    sal_uInt64 calculateSizeIncludingHeader(sal_uInt64 nSize) override;

    void setupEncryption(std::vector<sal_uInt8>& rEncryptionKey, sal_Int32 nObject) override;

    /** Encrypts using Algorithm 1.A: Encryption of data using the AES algorithms
     *
     * Described in ISO 32000-2:2020(E) - 7.6.3.3
     */
    void encrypt(const void* pInput, sal_uInt64 nInputSize, std::vector<sal_uInt8>& rOutput,
                 sal_uInt64 nOutputsSize) override;

    void encryptWithIV(const void* pInput, sal_uInt64 nInputSize, std::vector<sal_uInt8>& ;rOutput,
                       std::vector<sal_uInt8>& rIV);
};

} // end vcl::pdf

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */