<?php
// If this file is called directly, abort.
if ( ! defined( 'WPINC' ) ) {
	die;
}

class AIO_Crypto {

	/**
	 * List of all sensitive option keys that must be encrypted at rest and masked in Admin UI / Exports.
	 */
	public static function get_sensitive_keys() {
		return array(
			'txtSmtpPassword',
			'txtOAuthClientSecret',
			'txtGoogleOAuthClientSecret',
			'txtMsOAuthClientSecret',
			'optGoogleClientSecret',
			'optFacebookAppSecret',
			'optCaptchaSecretKey',
			'txtTelegramToken',
			'txtLarksuiteWebhook',
			'txtPagespeedApiKey',
			'txtObjectCachePassword',
			'optOAuthRefreshToken_google',
			'optOAuthRefreshToken_microsoft',
		);
	}

	/**
	 * Legacy v1 key (used ONLY for backward-compatible decryption of 'AIOENC:' values).
	 */
	private static function get_legacy_key() {
		$custom_key = get_option( 'aio_encryption_key' );
		if ( ! empty( $custom_key ) ) {
			return $custom_key;
		}

		if ( defined( 'SECURE_AUTH_KEY' ) && SECURE_AUTH_KEY !== 'put your unique phrase here' ) {
			return SECURE_AUTH_KEY;
		}
		if ( defined( 'AUTH_KEY' ) && AUTH_KEY !== 'put your unique phrase here' ) {
			return AUTH_KEY;
		}
		return wp_salt();
	}

	/**
	 * Derive independent 256-bit Encryption and MAC keys combining DB key + wp-config salts.
	 */
	private static function get_v2_keys() {
		$db_key = get_option( 'aio_encryption_key' );
		if ( empty( $db_key ) ) {
			$db_key = wp_generate_password( 64, true, true );
			update_option( 'aio_encryption_key', $db_key );
		}
		$master  = $db_key . '|' . wp_salt( 'auth' ) . '|' . wp_salt( 'secure_auth' );
		$enc_key = hash_hmac( 'sha256', 'aio-aes-256-cbc-enc-v2', $master, true );
		$mac_key = hash_hmac( 'sha256', 'aio-hmac-sha256-mac-v2', $master, true );

		return array(
			'enc' => $enc_key,
			'mac' => $mac_key,
		);
	}

	/**
	 * Encrypt a plain text string using AES-256-CBC + Encrypt-then-MAC (HMAC-SHA256).
	 */
	public static function encrypt( $plaintext ) {
		if ( ! is_string( $plaintext ) || $plaintext === '' ) {
			return '';
		}

		if ( strpos( $plaintext, 'AIOENCV2:' ) === 0 ) {
			return $plaintext;
		}

		// Upgrade legacy v1 ciphertext seamlessly if passed into encrypt()
		if ( strpos( $plaintext, 'AIOENC:' ) === 0 ) {
			$decrypted = self::decrypt( $plaintext );
			if ( $decrypted === '' ) {
				return $plaintext;
			}
			$plaintext = $decrypted;
		}

		if ( ! function_exists( 'openssl_encrypt' ) ) {
			return $plaintext;
		}

		$method = 'aes-256-cbc';
		$keys   = self::get_v2_keys();
		$ivlen  = openssl_cipher_iv_length( $method );
		$iv     = random_bytes( $ivlen );

		$ciphertext = openssl_encrypt( $plaintext, $method, $keys['enc'], OPENSSL_RAW_DATA, $iv );
		if ( $ciphertext === false ) {
			return '';
		}

		$hmac      = hash_hmac( 'sha256', $iv . $ciphertext, $keys['mac'], true );
		$encrypted = base64_encode( $iv . $hmac . $ciphertext );

		return 'AIOENCV2:' . $encrypted;
	}

	/**
	 * Decrypt a cipher text string (supports v2 'AIOENCV2:', v1 'AIOENC:', and legacy plaintext).
	 */
	public static function decrypt( $encrypted_text ) {
		if ( ! is_string( $encrypted_text ) || $encrypted_text === '' ) {
			return '';
		}

		if ( ! function_exists( 'openssl_decrypt' ) ) {
			return $encrypted_text;
		}

		$method = 'aes-256-cbc';
		$ivlen  = openssl_cipher_iv_length( $method );

		// v2 format: separate derived AES & HMAC keys covering IV + Ciphertext
		if ( strpos( $encrypted_text, 'AIOENCV2:' ) === 0 ) {
			$raw = base64_decode( substr( $encrypted_text, 9 ), true );
			if ( $raw === false || strlen( $raw ) <= $ivlen + 32 ) {
				return '';
			}

			$iv             = substr( $raw, 0, $ivlen );
			$hmac           = substr( $raw, $ivlen, 32 );
			$ciphertext_raw = substr( $raw, $ivlen + 32 );
			$keys           = self::get_v2_keys();
			$calcmac        = hash_hmac( 'sha256', $iv . $ciphertext_raw, $keys['mac'], true );

			if ( hash_equals( $hmac, $calcmac ) ) {
				$plain = openssl_decrypt( $ciphertext_raw, $method, $keys['enc'], OPENSSL_RAW_DATA, $iv );
				return $plain !== false ? $plain : '';
			}
			return '';
		}

		// Legacy v1 format: 'AIOENC:'
		if ( strpos( $encrypted_text, 'AIOENC:' ) === 0 ) {
			$raw = base64_decode( substr( $encrypted_text, 7 ), true );
			if ( $raw === false || strlen( $raw ) <= $ivlen + 32 ) {
				return '';
			}

			$iv             = substr( $raw, 0, $ivlen );
			$hmac           = substr( $raw, $ivlen, 32 );
			$ciphertext_raw = substr( $raw, $ivlen + 32 );
			$key            = substr( hash( 'sha256', self::get_legacy_key(), true ), 0, 32 );
			$calcmac        = hash_hmac( 'sha256', $ciphertext_raw, $key, true );

			if ( hash_equals( $hmac, $calcmac ) ) {
				$plain = openssl_decrypt( $ciphertext_raw, $method, $key, OPENSSL_RAW_DATA, $iv );
				return $plain !== false ? $plain : '';
			}
			return '';
		}

		// Plaintext from older versions prior to encryption
		return $encrypted_text;
	}
}