Wie kann ich mithilfe von OpenSSL eine einfache bidirektionale Verschlüsselung in PHP implementieren?

Einfachste Zwei-Wege-Verschlüsselung in PHP

Wichtiger Hinweis:

Bevor Sie fortfahren, ist es wichtig, diesen Artikel hervorzuheben Ziel ist es, ein vereinfachtes Verständnis der nicht authentifizierten Verschlüsselung zu vermitteln. Für einen robusten Datenschutz sollten Sie immer in Betracht ziehen, authentifizierte Verschlüsselungsbibliotheken nach Industriestandard oder bcrypt/argon2 für die Passwortspeicherung zu verwenden.

Native kryptografische Methoden

Wenn Sie PHP 5.4 oder höher verwenden, sollten Sie die Verwendung der openssl_*-Funktionen in Betracht ziehen für kryptografische Operationen. Diese bieten robuste Verschlüsselungsfunktionen mit nativer Unterstützung.

Einfache Verschlüsselung und Entschlüsselung

Die OpenSSL-Funktionen openssl_encrypt() und openssl_decrypt() bieten eine zugängliche Möglichkeit, Daten zu ver- und entschlüsseln. Der empfohlene Verschlüsselungsalgorithmus ist AES-CTR in seinen 128-, 192- oder 256-Bit-Varianten.

Achtung: Vermeiden Sie die Verwendung von mcrypt aufgrund seiner veralteten Funktion und potenzieller Sicherheitsrisiken.

Einfacher Verschlüsselungs-/Entschlüsselungs-Wrapper

Um den Verschlüsselungs- und Entschlüsselungsprozess zu vereinfachen, können Sie Folgendes tun Verwenden Sie die folgende Wrapper-Klasse:

class UnsafeCrypto
{
    // Encryption method (CTR mode)
    const METHOD = 'aes-256-ctr';

    /**
     * Encrypts data using the specified key.
     *
     * @param string $message Plaintext message
     * @param string $key Encryption key
     * @param bool $encode Whether to encode the result
     *
     * @return string Ciphertext
     */
    public static function encrypt($message, $key, $encode = false)
    {
        // Generate random IV
        $ivSize = openssl_cipher_iv_length(self::METHOD);
        $iv = openssl_random_pseudo_bytes($ivSize);

        // Encrypt using OpenSSL
        $ciphertext = openssl_encrypt($message, self::METHOD, $key, OPENSSL_RAW_DATA, $iv);

        // Concatenate IV and ciphertext
        if ($encode) {
            return base64_encode($iv . $ciphertext);
        }
        return $iv . $ciphertext;
    }

    /**
     * Decrypts data using the specified key.
     *
     * @param string $message Ciphertext
     * @param string $key Encryption key
     * @param bool $encoded Whether the message is encoded
     *
     * @return string Decrypted message
     */
    public static function decrypt($message, $key, $encoded = false)
    {
        if ($encoded) {
            $message = base64_decode($message, true);
            if ($message === false) {
                throw new Exception('Encryption failure');
            }
        }

        // Extract IV and ciphertext
        $ivSize = openssl_cipher_iv_length(self::METHOD);
        $iv = substr($message, 0, $ivSize);
        $ciphertext = substr($message, $ivSize);

        // Decrypt using OpenSSL
        $plaintext = openssl_decrypt($ciphertext, self::METHOD, $key, OPENSSL_RAW_DATA, $iv);

        return $plaintext;
    }
}

Authentifizierte Verschlüsselung

Der obige Ansatz bietet nur Verschlüsselung, sodass Daten anfällig für Manipulationen sind. Um dieses Problem zu beheben, implementieren Sie ein authentifiziertes Verschlüsselungsschema:

class SaferCrypto extends UnsafeCrypto
{
    // MAC algorithm
    const HASH_ALGO = 'sha256';

    /**
     * Encrypts and authenticates data using the specified key.
     *
     * @param string $message Plaintext message
     * @param string $key Encryption key
     * @param bool $encode Whether to encode the result
     *
     * @return string Encrypted and authenticated data
     */
    public static function encrypt($message, $key, $encode = false)
    {
        // Split key into encryption and authentication keys
        list($encKey, $authKey) = self::splitKeys($key);

        // Encrypt using UnsafeCrypto::encrypt
        $ciphertext = parent::encrypt($message, $encKey);

        // Calculate MAC
        $mac = hash_hmac(self::HASH_ALGO, $ciphertext, $authKey, true);

        // Concatenate MAC and ciphertext
        if ($encode) {
            return base64_encode($mac . $ciphertext);
        }
        return $mac . $ciphertext;
    }

    /**
     * Decrypts and authenticates data using the specified key.
     *
     * @param string $message Encrypted and authenticated data
     * @param string $key Encryption key
     * @param bool $encoded Whether the message is encoded
     *
     * @throws Exception
     *
     * @return string Decrypted message
     */
    public static function decrypt($message, $key, $encoded = false)
    {
        // Split key
        list($encKey, $authKey) = self::splitKeys($key);

        // Decode message if necessary
        if ($encoded) {
            $message = base64_decode($message, true);
            if ($message === false) {
                throw new Exception('Encryption failure');
            }
        }

        // Extract MAC and ciphertext
        $hs = strlen(hash(self::HASH_ALGO, '', true), '8bit');
        $mac = substr($message, 0, $hs);
        $ciphertext = substr($message, $hs);

        // Calculate expected MAC
        $expectedMac = hash_hmac(self::HASH_ALGO, $ciphertext, $authKey, true);

        // Verify MAC
        if (!self::hashEquals($mac, $expectedMac)) {
            throw new Exception('Encryption failure');
        }

        // Decrypt message using UnsafeCrypto::decrypt
        $plaintext = parent::decrypt($ciphertext, $encKey);

        return $plaintext;
    }

    /**
     * Splits a key into two separate keys for encryption and authentication.
     *
     * @param string $masterKey Master key
     *
     * @return string[] Array of encryption and authentication keys
     */
    protected static function splitKeys($masterKey)
    {
        return [
            hash_hmac(self::HASH_ALGO, 'ENCRYPTION', $masterKey, true),
            hash_hmac(self::HASH_ALGO, 'AUTHENTICATION', $masterKey, true)
        ];
    }

    /**
     * Compares two strings without leaking timing information
     * (PHP 7+).
     *
     * @param string $a
     * @param string $b
     *
     * @return bool
     */
    protected static function hashEquals($a, $b)
    {
        if (function_exists('hash_equals')) {
            return hash_equals($a, $b);
        }

        $nonce = openssl_random_pseudo_bytes(32);
        return hash_hmac(self::HASH_ALGO, $a, $nonce) === hash_hmac(self::HASH_ALGO, $b, $nonce);
    }
}

Denken Sie daran, für eine robuste Sicherheit die Verwendung seriöser Verschlüsselungsbibliotheken in Betracht zu ziehen.

Das obige ist der detaillierte Inhalt vonWie kann ich mithilfe von OpenSSL eine einfache bidirektionale Verschlüsselung in PHP implementieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!