<?php

declare(strict_types=1);

/**
 * Decrypt.php
 *
 * @since     2026-04-30
 * @category  Library
 * @package   PdfEncrypt
 * @author    Nicola Asuni <info@tecnick.com>
 * @copyright 2011-2026 Nicola Asuni - Tecnick.com LTD
 * @license   https://www.gnu.org/copyleft/lesser.html GNU-LGPL v3 (see LICENSE.TXT)
 * @link      https://github.com/tecnickcom/tc-lib-pdf-encrypt
 *
 * This file is part of tc-lib-pdf-encrypt software library.
 */

namespace Com\Tecnick\Pdf\Encrypt;

use Com\Tecnick\Pdf\Encrypt\Type\AESnopad;

/**
 * Com\Tecnick\Pdf\Encrypt\Decrypt
 *
 * Authenticates a password (or private key for public-key mode) against a PDF
 * encryption dictionary and recovers the document file-encryption key.
 *
 * Usage:
 *   $dec = new Decrypt($encrypt->getEncryptionData());
 *   if ($dec->authenticate('userpass')) {
 *       $plaintext = $dec->decryptString($ciphertext, $objnum);
 *   }
 *
 * After successful authentication the derived key is stored internally and:
 *   - decryptString() decrypts PDF string/stream objects.
 *   - getObjectKey()   returns the per-object key for AES-128 streams.
 *   - getDocumentKey() returns the raw 32-byte (or shorter) file key.
 *
 * @since     2026-04-30
 * @category  Library
 * @package   PdfEncrypt
 * @author    Nicola Asuni <info@tecnick.com>
 * @copyright 2011-2026 Nicola Asuni - Tecnick.com LTD
 * @license   https://www.gnu.org/copyleft/lesser.html GNU-LGPL v3 (see LICENSE.TXT)
 * @link      https://github.com/tecnickcom/tc-lib-pdf-encrypt
 *
 * @phpstan-import-type TEncryptData from Output
 *
 * @phpstan-type TDecryptInput TEncryptData|array{
 *     'V': int,
 *     'Length': int,
 *     'O': string,
 *     'U': string,
 *     'P': int,
 *     'fileid': string,
 *     'mode': int,
 *     'OE'?: string,
 *     'UE'?: string,
 *     'EncryptMetadata'?: bool,
 *     'pubkey'?: bool,
 *     'Recipients'?: array<array-key, string>,
 * }
 *
 * @SuppressWarnings("PHPMD.ExcessiveClassComplexity")
 */
class Decrypt extends \Com\Tecnick\Pdf\Encrypt\Compute
{
    /**
     * Initialise the decryptor from an encryption dictionary.
     *
     * Accepts the array returned by Encrypt::getEncryptionData() or any array
     * that satisfies the TDecryptInput shape.  All fields not present in the
     * input are filled with the defaults defined in Output::$encryptdata.
     *
     * @param TDecryptInput $input Encryption dictionary fields.
     */
    public function __construct(array $input)
    {
        $this->encryptdata['V'] = (int) $input['V'];
        $this->encryptdata['Length'] = (int) $input['Length'];
        $this->encryptdata['O'] = $input['O'];
        $this->encryptdata['U'] = $input['U'];
        $this->encryptdata['P'] = (int) $input['P'];
        $this->encryptdata['fileid'] = $input['fileid'];
        $this->encryptdata['mode'] = (int) $input['mode'];
        $this->encryptdata['EncryptMetadata'] = $input['EncryptMetadata'] ?? $this->encryptdata['EncryptMetadata'];
        $this->encryptdata['pubkey'] = $input['pubkey'] ?? $this->encryptdata['pubkey'];
        if (\array_key_exists('Recipients', $input)) {
            $this->encryptdata['Recipients'] = $input['Recipients'];
        }

        if (\array_key_exists('OE', $input)) {
            $this->encryptdata['OE'] = $input['OE'];
        }

        if (\array_key_exists('UE', $input)) {
            $this->encryptdata['UE'] = $input['UE'];
        }

        // Ensure encrypt()-based primitives (RC4, MD5-16) are active for key derivation.
        $this->encryptdata['encrypted'] = true;
        // Clear the key — it must be recovered by a successful authenticate() call.
        $this->encryptdata['key'] = '';
    }

    // -------------------------------------------------------------------------
    // Public API
    // -------------------------------------------------------------------------

    /**
     * Authenticate using a password and/or private key.
     *
     * Tries the supplied string first as the user password, then as the owner
     * password.  For public-key mode, $privkeyPath must be the path to a PEM
     * file containing the recipient's certificate and private key; $password is
     * ignored in that case.
     *
     * On success the derived file-encryption key is stored internally.
     *
     * @param string $password    UTF-8 password to test (ignored for pubkey mode).
     * @param string $privkeyPath Path to PEM file for public-key mode.
     *
     * @return bool True when authentication succeeds.
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    public function authenticate(#[\SensitiveParameter] string $password, string $privkeyPath = ''): bool
    {
        if ($this->encryptdata['pubkey']) {
            return $this->authenticatePublicKey($privkeyPath);
        }

        if ($this->encryptdata['mode'] >= 3) {
            return $this->authenticatePasswordR5R6($password);
        }

        return $this->authenticatePasswordR24($password);
    }

    /**
     * Decrypt a PDF string or stream object.
     *
     * Must be called after a successful authenticate() call.
     *
     * For RC4 modes (0, 1) the operation is symmetric — the same method that
     * encrypts also decrypts.  For AES modes (2, 3, 4) the first 16 bytes of
     * $data are the random IV; the remainder is the ciphertext.  The PKCS#7
     * padding applied during encryption is stripped, so the exact original
     * plaintext is returned.
     *
     * @param string $data   Encrypted string/stream data.
     * @param int    $objnum PDF object number (used for per-object key derivation
     *                       in RC4 and AES-128 modes).
     *
     * @return string Decrypted data.
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    public function decryptString(string $data, int $objnum = 0): string
    {
        if (!$this->encryptdata['encrypted'] || $this->encryptdata['key'] === '') {
            return $data;
        }

        $mode = $this->encryptdata['mode'];

        if ($mode < 2) {
            // RC4 is symmetric: the same encrypt() call decrypts.
            return $this->encrypt($mode, $data, '', $objnum);
        }

        return $this->decryptAes($data, $objnum);
    }

    /**
     * Return the recovered file-encryption key.
     *
     * @return string Raw binary key (empty string before authenticate() succeeds).
     */
    public function getDocumentKey(): string
    {
        return $this->encryptdata['key'];
    }

    // -------------------------------------------------------------------------
    // RC4 / R2–R4 authentication (modes 0, 1, 2)
    // -------------------------------------------------------------------------

    /**
     * Authenticate a password for R2–R4 (RC4-40, RC4-128, AES-128).
     *
     * First tries the password as the user password; on failure tries it as the
     * owner password.
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function authenticatePasswordR24(#[\SensitiveParameter] string $password): bool
    {
        $paddedPass = \substr($password . self::ENCPAD, 0, 32);

        if ($this->authenticateUserR24($paddedPass)) {
            return true;
        }

        return $this->authenticateOwnerR24($password);
    }

    /**
     * Authenticate $paddedPass as the user password for R2–R4.
     *
     * Derives a candidate encryption key from the padded password and verifies
     * it against the stored U value using Algorithm 6 (PDF spec §7.6.3.4).
     * On success the verified key remains stored in $encryptdata['key'].
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function authenticateUserR24(string $paddedPass): bool
    {
        $savedKey = $this->encryptdata['key'];
        $this->encryptdata['key'] = $this->deriveKeyR24($paddedPass);

        $computedU = $this->getUValue();

        if ($this->compareUserHashR24($computedU)) {
            return true;
        }

        $this->encryptdata['key'] = $savedKey;
        return false;
    }

    /**
     * Authenticate $password as the owner password for R2–R4.
     *
     * Derives the owner key, decrypts the O entry to recover the candidate user
     * password, then delegates to authenticateUserR24.
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function authenticateOwnerR24(#[\SensitiveParameter] string $password): bool
    {
        $paddedOwner = \substr($password . self::ENCPAD, 0, 32);
        $ownerKey = $this->deriveOwnerKeyR24($paddedOwner);
        $candidateUserPass = $this->decryptOToUserPass($ownerKey);
        return $this->authenticateUserR24($candidateUserPass);
    }

    /**
     * Derive the file encryption key for R2–R4 from a 32-byte padded user password.
     *
     * Implements Algorithm 2 from PDF spec §7.6.3.3.
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function deriveKeyR24(string $paddedPass): string
    {
        $keybytelen = (int) ($this->encryptdata['Length'] / 8);
        $permBytes = $this->getEncPermissionsString($this->encryptdata['P']);

        $tmp = $this->encrypt(
            'MD5-16',
            $paddedPass . $this->encryptdata['O'] . $permBytes . $this->encryptdata['fileid'],
        );

        if ($this->encryptdata['mode'] > 0) {
            for ($idx = 0; $idx < 50; ++$idx) {
                $tmp = $this->encrypt('MD5-16', \substr($tmp, 0, $keybytelen));
            }
        }

        return \substr($tmp, 0, $keybytelen);
    }

    /**
     * Compare a freshly computed U value against the stored one for R2–R4.
     *
     * R2 requires an exact 32-byte match; R3/R4 compare only the first 16 bytes.
     */
    protected function compareUserHashR24(string $computedU): bool
    {
        if ($this->encryptdata['mode'] === 0) {
            return $computedU === $this->encryptdata['U'];
        }

        return \substr($computedU, 0, 16) === \substr($this->encryptdata['U'], 0, 16);
    }

    /**
     * Derive the owner key from a 32-byte padded owner password for R2–R4.
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function deriveOwnerKeyR24(string $paddedOwnerPass): string
    {
        $keybytelen = (int) ($this->encryptdata['Length'] / 8);
        $tmp = $this->encrypt('MD5-16', $paddedOwnerPass);

        if ($this->encryptdata['mode'] > 0) {
            for ($idx = 0; $idx < 50; ++$idx) {
                $tmp = $this->encrypt('MD5-16', \substr($tmp, 0, $keybytelen));
            }
        }

        return \substr($tmp, 0, $keybytelen);
    }

    /**
     * Decrypt the O entry using the owner key to recover the candidate user password.
     *
     * Reverses the iterative RC4 encryption applied by getOValue() in Compute.
     *
     * @SuppressWarnings("PHPMD.CyclomaticComplexity")
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function decryptOToUserPass(string $ownerKey): string
    {
        if ($this->encryptdata['mode'] === 0) {
            return $this->encrypt('RC4', $this->encryptdata['O'], $ownerKey);
        }

        $keyLen = \strlen($ownerKey);
        $candidate = $this->encryptdata['O'];

        for ($idx = 19; $idx >= 1; --$idx) {
            $xoredKey = '';
            for ($jdx = 0; $jdx < $keyLen; ++$jdx) {
                $xoredKey .= \chr((\ord($ownerKey[$jdx]) ^ $idx) & 0xFF);
            }

            $candidate = $this->encrypt('RC4', $candidate, $xoredKey);
        }

        return $this->encrypt('RC4', $candidate, $ownerKey);
    }

    // -------------------------------------------------------------------------
    // AES-256 / R5–R6 authentication (modes 3, 4)
    // -------------------------------------------------------------------------

    /**
     * Authenticate a password for R5 (mode 3) or R6 (mode 4).
     *
     * Tries the password as the user password, then as the owner password.
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function authenticatePasswordR5R6(#[\SensitiveParameter] string $password): bool
    {
        if ($this->authenticateUserR5R6($password)) {
            $this->recoverKeyFromUser($password);
            return true;
        }

        if ($this->authenticateOwnerR5R6($password)) {
            $this->recoverKeyFromOwner($password);
            return true;
        }

        return false;
    }

    /**
     * Verify $password as the user password for R5/R6 (Algorithm 11/13).
     *
     * Computes hash(password ∥ U[32..39]) and compares to U[0..32].
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function authenticateUserR5R6(#[\SensitiveParameter] string $password): bool
    {
        $uvs = \substr($this->encryptdata['U'], 32, 8);
        $expected = \substr($this->encryptdata['U'], 0, 32);
        return $this->hashR5R6($password, $uvs) === $expected;
    }

    /**
     * Verify $password as the owner password for R5/R6 (Algorithm 13/15).
     *
     * Computes hash(password ∥ O[32..39] ∥ U[0..48]) and compares to O[0..32].
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function authenticateOwnerR5R6(#[\SensitiveParameter] string $password): bool
    {
        $ovs = \substr($this->encryptdata['O'], 32, 8);
        $userHash = \substr($this->encryptdata['U'], 0, 48);
        $expected = \substr($this->encryptdata['O'], 0, 32);
        return $this->hashR5R6($password, $ovs, $userHash) === $expected;
    }

    /**
     * Recover the file encryption key using the verified user password (Algorithm 12/14).
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function recoverKeyFromUser(#[\SensitiveParameter] string $password): void
    {
        $uks = \substr($this->encryptdata['U'], 40, 8);
        $hashkey = $this->hashR5R6($password, $uks);
        $aesnopad = new AESnopad();
        $this->encryptdata['key'] = $aesnopad->decrypt($this->encryptdata['UE'], $hashkey);
    }

    /**
     * Recover the file encryption key using the verified owner password (Algorithm 14/16).
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function recoverKeyFromOwner(#[\SensitiveParameter] string $password): void
    {
        $oks = \substr($this->encryptdata['O'], 40, 8);
        $userHash = \substr($this->encryptdata['U'], 0, 48);
        $hashkey = $this->hashR5R6($password, $oks, $userHash);
        $aesnopad = new AESnopad();
        $this->encryptdata['key'] = $aesnopad->decrypt($this->encryptdata['OE'], $hashkey);
    }

    /**
     * Compute the R5/R6 password hash.
     *
     * R5 (mode 3): SHA-256(password ∥ salt ∥ userHash).
     * R6 (mode 4): Algorithm 2.B (ISO 32000-2 §7.6.4.3.4).
     *
     * @param string $password  UTF-8 password (truncated to ≤ 127 bytes by caller).
     * @param string $salt      8-byte validation or key salt.
     * @param string $userHash  48-byte U value for owner-side; empty for user-side.
     *
     * @return string 32-byte binary hash.
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function hashR5R6(#[\SensitiveParameter] string $password, string $salt, string $userHash = ''): string
    {
        if ($this->encryptdata['mode'] === 4) {
            return $this->hash2B($password, $salt, $userHash);
        }

        return \hash('sha256', $password . $salt . $userHash, true);
    }

    // -------------------------------------------------------------------------
    // AES stream/string decryption helper
    // -------------------------------------------------------------------------

    /**
     * Decrypt an AES-encrypted PDF string or stream (modes 2, 3, 4).
     *
     * The ciphertext is prefixed with a 16-byte random IV as required by the
     * PDF specification (§7.6.3).  Returns an empty string when the data is
     * shorter than the IV length.
     *
     * The string/stream ciphertext is produced with PKCS#7 block padding
     * (AESV2/AESV3 crypt filters, ISO 32000), so decryption is performed
     * WITHOUT OPENSSL_ZERO_PADDING: OpenSSL validates and strips the PKCS#7
     * padding, recovering the exact original plaintext.  Returns an empty
     * string when the padding is invalid (e.g. wrong key or corrupted data).
     *
     * @throws \Com\Tecnick\Pdf\Encrypt\Exception
     */
    protected function decryptAes(string $data, int $objnum): string
    {
        if (\strlen($data) <= AESnopad::BLOCKSIZE) {
            return '';
        }

        $ivect = \substr($data, 0, AESnopad::BLOCKSIZE);
        $ciphertext = \substr($data, AESnopad::BLOCKSIZE);
        $mode = $this->encryptdata['mode'];
        $key = $mode < 3 ? $this->getObjectKey($objnum) : $this->encryptdata['key'];
        $cipher = $mode === 2 ? 'aes-128-cbc' : 'aes-256-cbc';

        $dec = \openssl_decrypt($ciphertext, $cipher, $key, OPENSSL_RAW_DATA, $ivect);

        return $dec === false ? '' : $dec;
    }

    // -------------------------------------------------------------------------
    // Public-key mode authentication
    // -------------------------------------------------------------------------

    /**
     * Authenticate using a recipient's PEM private-key file (public-key mode).
     *
     * Iterates over all Recipients entries, tries to decrypt each PKCS#7 envelope
     * with the supplied certificate/key, extracts the seed, and derives the
     * document encryption key.
     *
     * @param string $privkeyPath Path to the recipient's PEM file (cert + key).
     *
     * @return bool True when a matching recipient is found and the key is derived.
     */
    protected function authenticatePublicKey(string $privkeyPath): bool
    {
        if ($privkeyPath === '' || !\is_readable($privkeyPath)) {
            return false;
        }

        $certPem = \file_get_contents($privkeyPath);
        if ($certPem === false) {
            return false;
        }

        $seed = $this->findDecryptedRecipientSeed($certPem);
        if ($seed === null) {
            return false;
        }

        $this->derivePublicKey($seed);
        return true;
    }

    /**
     * Iterate over all Recipients and return the 20-byte seed from the first
     * envelope that can be decrypted with $certPem, or null on failure.
     *
     * @return string|null 20-byte seed, or null when no matching recipient found.
     */
    protected function findDecryptedRecipientSeed(string $certPem): ?string
    {
        foreach ($this->encryptdata['Recipients'] as $hexRecipient) {
            // Silence native warning noise for malformed recipient entries;
            // false is handled explicitly by the guard below.
            \set_error_handler(static fn(): bool => true);
            try {
                $derData = \hex2bin($hexRecipient);
            } finally {
                \restore_error_handler();
            }

            if ($derData === false) {
                continue;
            }

            $envelope = $this->tryDecryptRecipient($derData, $certPem);
            if ($envelope !== null && \strlen($envelope) >= 24) {
                // envelope = seed (20 bytes) + permissions (4 bytes)
                return \substr($envelope, 0, 20);
            }
        }

        return null;
    }

    /**
     * Attempt to decrypt a single DER-encoded PKCS#7 recipient envelope.
     *
     * Reconstructs the S/MIME message (as produced by openssl_pkcs7_encrypt),
     * writes it to a temporary file, calls openssl_pkcs7_decrypt with the
     * supplied certificate/key, and returns the raw decrypted bytes on success.
     *
     * @param string $derData Raw DER binary (one entry from Recipients[]).
     * @param string $certPem PEM certificate + private key of the recipient.
     *
     * @return string|null Decrypted envelope bytes, or null on failure.
     */
    protected function tryDecryptRecipient(string $derData, string $certPem): ?string
    {
        $smime =
            "MIME-Version: 1.0\r\n"
            . 'Content-Type: application/pkcs7-mime;'
            . " smime-type=enveloped-data; name=\"smime.p7m\"\r\n"
            . "Content-Transfer-Encoding: base64\r\n\r\n"
            . \chunk_split(\base64_encode($derData));

        $tmpIn = \tempnam(\sys_get_temp_dir(), '__tcpdf_dec_in_');
        $tmpOut = \tempnam(\sys_get_temp_dir(), '__tcpdf_dec_out_');

        if ($tmpIn === false || $tmpOut === false) {
            return null;
        }

        if (\file_put_contents($tmpIn, $smime) === false) {
            return null;
        }

        \set_error_handler(static fn(): bool => true);
        try {
            $decOk = \openssl_pkcs7_decrypt($tmpIn, $tmpOut, $certPem, $certPem);
        } finally {
            \restore_error_handler();
        }

        $result = $decOk ? \file_get_contents($tmpOut) : null;

        \unlink($tmpIn);
        \unlink($tmpOut);

        return $result === false ? null : $result;
    }

    /**
     * Derive the document encryption key from the recovered seed.
     *
     * Mirrors generatePublicEncryptionKey(): the key is SHA-256 (modes ≥ 3) or
     * SHA-1 (modes 0–2) of the seed concatenated with all Recipients' raw bytes.
     *
     * @param string $seed 20-byte random seed extracted from the recipient envelope.
     */
    protected function derivePublicKey(string $seed): void
    {
        $keybytelen = (int) ($this->encryptdata['Length'] / 8);
        $recipientBytes = '';

        foreach ($this->encryptdata['Recipients'] as $hexRecipient) {
            $binary = \hex2bin($hexRecipient);
            if ($binary !== false) {
                $recipientBytes .= $binary;
            }
        }

        if ($this->encryptdata['mode'] >= 3) {
            $this->encryptdata['key'] = \substr(\hash('sha256', $seed . $recipientBytes, true), 0, $keybytelen);

            return;
        }

        $this->encryptdata['key'] = \substr(\sha1($seed . $recipientBytes, true), 0, $keybytelen);
    }
}
