<?php
/**
 * Connector V2 authenticated encryption.
 */

if (!defined('ABSPATH')) {
    exit;
}

class Akkedli_V2_Crypto
{
    const AAD = 'akkedli:wordpress-connector:credential:v1';
    const PURPOSE = 'akkedli:wordpress-connector:site-key:v1';
    const CIPHER = 'aes-256-gcm';

    /**
     * Ensure the required PHP cryptography is available.
     *
     * @throws RuntimeException When a required primitive is unavailable.
     */
    public static function assert_available()
    {
        if (!extension_loaded('openssl') || !function_exists('openssl_encrypt') || !function_exists('openssl_decrypt')) {
            throw new RuntimeException('Secure credential storage is unavailable.');
        }

        $methods = openssl_get_cipher_methods(true);
        $ciphers = is_array($methods) ? array_map('strtolower', $methods) : array();
        if (!in_array(self::CIPHER, $ciphers, true) || !function_exists('hash_hkdf') || !function_exists('random_bytes')) {
            throw new RuntimeException('Secure credential storage is unavailable.');
        }

        try {
            $probe = random_bytes(1);
            unset($probe);
        } catch (Throwable $error) {
            unset($error);
            throw new RuntimeException('Secure credential storage is unavailable.');
        }
    }

    /**
     * Encrypt an already validated state value.
     */
    public static function encrypt(array $state)
    {
        self::assert_available();

        $plaintext = wp_json_encode($state, JSON_UNESCAPED_SLASHES);
        if (!is_string($plaintext)) {
            throw new RuntimeException('Credential encryption failed.');
        }

        try {
            $salt = random_bytes(32);
            $iv = random_bytes(12);
            $key = self::derive_key($salt);
            $tag = '';
            $ciphertext = openssl_encrypt(
                $plaintext,
                self::CIPHER,
                $key,
                OPENSSL_RAW_DATA,
                $iv,
                $tag,
                self::AAD,
                16
            );
        } catch (Throwable $error) {
            unset($error, $plaintext, $salt, $iv, $key, $tag, $ciphertext);
            throw new RuntimeException('Credential encryption failed.');
        }

        if (!is_string($ciphertext) || strlen($tag) !== 16) {
            unset($plaintext, $salt, $iv, $key, $tag, $ciphertext);
            throw new RuntimeException('Credential encryption failed.');
        }

        $envelope = implode(':', array(
            'v1',
            self::CIPHER,
            self::base64url_encode($salt),
            self::base64url_encode($iv),
            self::base64url_encode($ciphertext),
            self::base64url_encode($tag),
        ));

        unset($plaintext, $salt, $iv, $key, $tag, $ciphertext);
        return $envelope;
    }

    /**
     * Decrypt an envelope. Callers must validate the returned schema.
     */
    public static function decrypt($envelope)
    {
        self::assert_available();

        if (!is_string($envelope)) {
            throw new RuntimeException('Stored credential state is invalid.');
        }

        $segments = explode(':', $envelope);
        if (count($segments) !== 6 || $segments[0] !== 'v1' || $segments[1] !== self::CIPHER) {
            throw new RuntimeException('Stored credential state is invalid.');
        }

        $salt = self::base64url_decode($segments[2]);
        $iv = self::base64url_decode($segments[3]);
        $ciphertext = self::base64url_decode($segments[4]);
        $tag = self::base64url_decode($segments[5]);

        if (strlen($salt) !== 32 || strlen($iv) !== 12 || $ciphertext === '' || strlen($tag) !== 16) {
            unset($salt, $iv, $ciphertext, $tag);
            throw new RuntimeException('Stored credential state is invalid.');
        }

        $key = self::derive_key($salt);
        $plaintext = openssl_decrypt(
            $ciphertext,
            self::CIPHER,
            $key,
            OPENSSL_RAW_DATA,
            $iv,
            $tag,
            self::AAD
        );
        unset($salt, $iv, $ciphertext, $tag, $key);

        if (!is_string($plaintext)) {
            throw new RuntimeException('Stored credential state is invalid.');
        }

        $state = json_decode($plaintext, true);
        $canonical = is_array($state) ? wp_json_encode($state, JSON_UNESCAPED_SLASHES) : false;
        if (!is_array($state) || json_last_error() !== JSON_ERROR_NONE || !is_string($canonical)
            || !hash_equals($plaintext, $canonical)) {
            unset($plaintext, $canonical, $state);
            throw new RuntimeException('Stored credential state is invalid.');
        }
        unset($plaintext, $canonical);

        return $state;
    }

    public static function base64url_encode($binary)
    {
        return rtrim(strtr(base64_encode($binary), '+/', '-_'), '=');
    }

    public static function base64url_decode($encoded)
    {
        if (!is_string($encoded) || $encoded === '' || !preg_match('/^[A-Za-z0-9_-]+$/D', $encoded)) {
            throw new RuntimeException('Encoded credential data is invalid.');
        }

        $remainder = strlen($encoded) % 4;
        if ($remainder === 1) {
            throw new RuntimeException('Encoded credential data is invalid.');
        }

        $padded = strtr($encoded, '-_', '+/');
        if ($remainder > 0) {
            $padded .= str_repeat('=', 4 - $remainder);
        }
        $binary = base64_decode($padded, true);

        if (!is_string($binary) || !hash_equals($encoded, self::base64url_encode($binary))) {
            unset($binary);
            throw new RuntimeException('Encoded credential data is invalid.');
        }

        return $binary;
    }

    private static function derive_key($salt)
    {
        $context = self::PURPOSE . ':blog:' . (string) get_current_blog_id();
        $key = hash_hkdf('sha256', wp_salt('auth'), 32, $context, $salt);
        if (!is_string($key) || strlen($key) !== 32) {
            unset($key);
            throw new RuntimeException('Credential key derivation failed.');
        }
        return $key;
    }
}