sop / gcm

lib/GCM/GHASH.php

Indentation +88 added lines, -88 removed lines

@@ -13,97 +13,97 @@
  */
 class GHASH
 {
-    /**
-     * Fixed R-block.
-     *
-     * @var string
-     */
-    const R = "\xE1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+	/**
+	 * Fixed R-block.
+	 *
+	 * @var string
+	 */
+	const R = "\xE1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
 
-    /**
-     * Hash subkey.
-     *
-     * @var string
-     */
-    protected $_subkey;
+	/**
+	 * Hash subkey.
+	 *
+	 * @var string
+	 */
+	protected $_subkey;
 
-    /**
-     * Constructor.
-     *
-     * @param string $subkey Hash subkey
-     */
-    public function __construct(string $subkey)
-    {
-        if (16 !== strlen($subkey)) {
-            throw new \LengthException('Subkey must be 128 bits.');
-        }
-        $this->_subkey = $subkey;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param string $subkey Hash subkey
+	 */
+	public function __construct(string $subkey)
+	{
+		if (16 !== strlen($subkey)) {
+			throw new \LengthException('Subkey must be 128 bits.');
+		}
+		$this->_subkey = $subkey;
+	}
 
-    /**
-     * Functor method for `compute`.
-     *
-     * @param string $arg
-     *
-     * @return string
-     */
-    public function __invoke(string $arg): string
-    {
-        return $this->compute($arg);
-    }
+	/**
+	 * Functor method for `compute`.
+	 *
+	 * @param string $arg
+	 *
+	 * @return string
+	 */
+	public function __invoke(string $arg): string
+	{
+		return $this->compute($arg);
+	}
 
-    /**
-     * Compute hash.
-     *
-     * @param string $X Input string
-     *
-     * @return string Hash
-     */
-    public function compute(string $X): string
-    {
-        $len = strlen($X);
-        if (0 !== $len % 16) {
-            throw new \UnexpectedValueException(
-                'Input string must be a multiple of 128 bits.');
-        }
-        $Y = GCM::ZB_128;
-        // number of 128-bit blocks
-        $m = $len >> 4;
-        for ($i = 0; $i < $m; ++$i) {
-            $xi = substr($X, $i << 4, 16);
-            $Y = $this->_mult($Y ^ $xi, $this->_subkey);
-        }
-        return $Y;
-    }
+	/**
+	 * Compute hash.
+	 *
+	 * @param string $X Input string
+	 *
+	 * @return string Hash
+	 */
+	public function compute(string $X): string
+	{
+		$len = strlen($X);
+		if (0 !== $len % 16) {
+			throw new \UnexpectedValueException(
+				'Input string must be a multiple of 128 bits.');
+		}
+		$Y = GCM::ZB_128;
+		// number of 128-bit blocks
+		$m = $len >> 4;
+		for ($i = 0; $i < $m; ++$i) {
+			$xi = substr($X, $i << 4, 16);
+			$Y = $this->_mult($Y ^ $xi, $this->_subkey);
+		}
+		return $Y;
+	}
 
-    /**
-     * Apply block multiplication operation.
-     *
-     * See NIST SP-800-38D, chapter 6.3 for the details.
-     *
-     * @param string $X
-     * @param string $Y
-     *
-     * @return string
-     */
-    private function _mult(string $X, string $Y): string
-    {
-        $x = GCM::strToGMP($X);
-        $Z = GCM::strToGMP(GCM::ZB_128);
-        $V = GCM::strToGMP($Y);
-        $R = GCM::strToGMP(self::R);
-        for ($i = 0; $i < 128; ++$i) {
-            // if bit at X[i] is set
-            if (gmp_testbit($x, 127 - $i)) {
-                $Z ^= $V;
-            }
-            // if LSB(Vi) = 0
-            if (!gmp_testbit($V, 0)) {
-                $V >>= 1;
-            } else {
-                $V = ($V >> 1) ^ $R;
-            }
-        }
-        return GCM::gmpToStr($Z, 16);
-    }
+	/**
+	 * Apply block multiplication operation.
+	 *
+	 * See NIST SP-800-38D, chapter 6.3 for the details.
+	 *
+	 * @param string $X
+	 * @param string $Y
+	 *
+	 * @return string
+	 */
+	private function _mult(string $X, string $Y): string
+	{
+		$x = GCM::strToGMP($X);
+		$Z = GCM::strToGMP(GCM::ZB_128);
+		$V = GCM::strToGMP($Y);
+		$R = GCM::strToGMP(self::R);
+		for ($i = 0; $i < 128; ++$i) {
+			// if bit at X[i] is set
+			if (gmp_testbit($x, 127 - $i)) {
+				$Z ^= $V;
+			}
+			// if LSB(Vi) = 0
+			if (!gmp_testbit($V, 0)) {
+				$V >>= 1;
+			} else {
+				$V = ($V >> 1) ^ $R;
+			}
+		}
+		return GCM::gmpToStr($Z, 16);
+	}
 }

lib/GCM/Cipher/AES/AES256Cipher.php

Indentation +21 added lines, -21 removed lines

@@ -9,27 +9,27 @@
  */
 class AES256Cipher extends AESCipher
 {
-    /**
-     * {@inheritdoc}
-     */
-    protected function _cipherName(): string
-    {
-        return 'aes-256-ecb';
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	protected function _cipherName(): string
+	{
+		return 'aes-256-ecb';
+	}
 
-    /**
-     * {@inheritdoc}
-     */
-    protected function _nativeCipherName(): string
-    {
-        return 'aes-256-gcm';
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	protected function _nativeCipherName(): string
+	{
+		return 'aes-256-gcm';
+	}
 
-    /**
-     * {@inheritdoc}
-     */
-    protected function _keySize(): int
-    {
-        return 32;
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	protected function _keySize(): int
+	{
+		return 32;
+	}
 }

lib/GCM/Cipher/AES/AES128Cipher.php

Indentation +21 added lines, -21 removed lines

@@ -9,27 +9,27 @@
  */
 class AES128Cipher extends AESCipher
 {
-    /**
-     * {@inheritdoc}
-     */
-    protected function _cipherName(): string
-    {
-        return 'aes-128-ecb';
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	protected function _cipherName(): string
+	{
+		return 'aes-128-ecb';
+	}
 
-    /**
-     * {@inheritdoc}
-     */
-    protected function _nativeCipherName(): string
-    {
-        return 'aes-128-gcm';
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	protected function _nativeCipherName(): string
+	{
+		return 'aes-128-gcm';
+	}
 
-    /**
-     * {@inheritdoc}
-     */
-    protected function _keySize(): int
-    {
-        return 16;
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	protected function _keySize(): int
+	{
+		return 16;
+	}
 }

lib/GCM/Cipher/AES/AES192Cipher.php

Indentation +21 added lines, -21 removed lines

@@ -9,27 +9,27 @@
  */
 class AES192Cipher extends AESCipher
 {
-    /**
-     * {@inheritdoc}
-     */
-    protected function _cipherName(): string
-    {
-        return 'aes-192-ecb';
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	protected function _cipherName(): string
+	{
+		return 'aes-192-ecb';
+	}
 
-    /**
-     * {@inheritdoc}
-     */
-    protected function _nativeCipherName(): string
-    {
-        return 'aes-192-gcm';
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	protected function _nativeCipherName(): string
+	{
+		return 'aes-192-gcm';
+	}
 
-    /**
-     * {@inheritdoc}
-     */
-    protected function _keySize(): int
-    {
-        return 24;
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	protected function _keySize(): int
+	{
+		return 24;
+	}
 }

lib/GCM/Cipher/AES/AESCipher.php

Indentation +144 added lines, -144 removed lines

@@ -12,158 +12,158 @@
  */
 abstract class AESCipher implements Cipher
 {
-    /**
-     * Mapping from key size in bits to AES cipher implementation class name.
-     *
-     * @internal
-     *
-     * @var array
-     */
-    const MAP_KEYSIZE_TO_CLS = [
-        128 => AES128Cipher::class,
-        192 => AES192Cipher::class,
-        256 => AES256Cipher::class,
-    ];
+	/**
+	 * Mapping from key size in bits to AES cipher implementation class name.
+	 *
+	 * @internal
+	 *
+	 * @var array
+	 */
+	const MAP_KEYSIZE_TO_CLS = [
+		128 => AES128Cipher::class,
+		192 => AES192Cipher::class,
+		256 => AES256Cipher::class,
+	];
 
-    /**
-     * Get AES cipher instance by key length.
-     *
-     * @param int $len Key length in bytes
-     *
-     * @throws \UnexpectedValueException
-     *
-     * @return self
-     */
-    public static function fromKeyLength(int $len): self
-    {
-        $bits = $len << 3;
-        if (!array_key_exists($bits, self::MAP_KEYSIZE_TO_CLS)) {
-            throw new \UnexpectedValueException(
-                "No AES implementation for {$bits}-bit key size.");
-        }
-        $cls = self::MAP_KEYSIZE_TO_CLS[$bits];
-        return new $cls();
-    }
+	/**
+	 * Get AES cipher instance by key length.
+	 *
+	 * @param int $len Key length in bytes
+	 *
+	 * @throws \UnexpectedValueException
+	 *
+	 * @return self
+	 */
+	public static function fromKeyLength(int $len): self
+	{
+		$bits = $len << 3;
+		if (!array_key_exists($bits, self::MAP_KEYSIZE_TO_CLS)) {
+			throw new \UnexpectedValueException(
+				"No AES implementation for {$bits}-bit key size.");
+		}
+		$cls = self::MAP_KEYSIZE_TO_CLS[$bits];
+		return new $cls();
+	}
 
-    /**
-     * {@inheritdoc}
-     *
-     * @throws \UnexpectedValueException If key size is incorrect
-     * @throws \RuntimeException         For generic errors
-     */
-    public function encrypt(string $data, string $key): string
-    {
-        $this->_checkKeySize($key);
-        $result = openssl_encrypt($data, $this->_cipherName(), $key,
-            OPENSSL_RAW_DATA | OPENSSL_ZERO_PADDING);
-        if (false === $result) {
-            throw new \RuntimeException(
-                'openssl_encrypt() failed: ' . self::_getLastOpenSSLError());
-        }
-        return $result;
-    }
+	/**
+	 * {@inheritdoc}
+	 *
+	 * @throws \UnexpectedValueException If key size is incorrect
+	 * @throws \RuntimeException         For generic errors
+	 */
+	public function encrypt(string $data, string $key): string
+	{
+		$this->_checkKeySize($key);
+		$result = openssl_encrypt($data, $this->_cipherName(), $key,
+			OPENSSL_RAW_DATA | OPENSSL_ZERO_PADDING);
+		if (false === $result) {
+			throw new \RuntimeException(
+				'openssl_encrypt() failed: ' . self::_getLastOpenSSLError());
+		}
+		return $result;
+	}
 
-    /**
-     * Check whether OpenSSL has native AES-GCM cipher available.
-     *
-     * @return bool
-     */
-    public function hasNativeCipher(): bool
-    {
-        static $supported_methods;
-        if (!isset($supported_methods)) {
-            $supported_methods = array_flip(openssl_get_cipher_methods(false));
-        }
-        $method = $this->_nativeCipherName();
-        return isset($supported_methods[$method]);
-    }
+	/**
+	 * Check whether OpenSSL has native AES-GCM cipher available.
+	 *
+	 * @return bool
+	 */
+	public function hasNativeCipher(): bool
+	{
+		static $supported_methods;
+		if (!isset($supported_methods)) {
+			$supported_methods = array_flip(openssl_get_cipher_methods(false));
+		}
+		$method = $this->_nativeCipherName();
+		return isset($supported_methods[$method]);
+	}
 
-    /**
-     * Encrypt plaintext using native OpenSSL.
-     *
-     * @param string $plaintext  Plaintext to encrypt
-     * @param string $aad        Additional authenticated data
-     * @param string $key        Encryption key
-     * @param string $iv         Initialization vector
-     * @param int    $tag_length Authentication tag length in bytes
-     *
-     * @return array Tuple of ciphertext and authentication tag
-     */
-    public function nativeEncrypt(string $plaintext, string $aad, string $key,
-        string $iv, int $tag_length = 16): array
-    {
-        $this->_checkKeySize($key);
-        $ciphertext = @openssl_encrypt($plaintext, $this->_nativeCipherName(),
-            $key, OPENSSL_RAW_DATA | OPENSSL_ZERO_PADDING, $iv, $tag, $aad, $tag_length);
-        // should never fail, since key size is already checked
-        if (false === $ciphertext) {
-            throw new \RuntimeException(
-                'openssl_encrypt() failed: ' . self::_getLastOpenSSLError());
-        }
-        return [$ciphertext, $tag];
-    }
+	/**
+	 * Encrypt plaintext using native OpenSSL.
+	 *
+	 * @param string $plaintext  Plaintext to encrypt
+	 * @param string $aad        Additional authenticated data
+	 * @param string $key        Encryption key
+	 * @param string $iv         Initialization vector
+	 * @param int    $tag_length Authentication tag length in bytes
+	 *
+	 * @return array Tuple of ciphertext and authentication tag
+	 */
+	public function nativeEncrypt(string $plaintext, string $aad, string $key,
+		string $iv, int $tag_length = 16): array
+	{
+		$this->_checkKeySize($key);
+		$ciphertext = @openssl_encrypt($plaintext, $this->_nativeCipherName(),
+			$key, OPENSSL_RAW_DATA | OPENSSL_ZERO_PADDING, $iv, $tag, $aad, $tag_length);
+		// should never fail, since key size is already checked
+		if (false === $ciphertext) {
+			throw new \RuntimeException(
+				'openssl_encrypt() failed: ' . self::_getLastOpenSSLError());
+		}
+		return [$ciphertext, $tag];
+	}
 
-    /**
-     * Decrypt ciphertext using native OpenSSL.
-     *
-     * @param string $ciphertext Ciphertext to decrypt
-     * @param string $auth_tag   Authentication tag to verify
-     * @param string $aad        Additional authenticated data
-     * @param string $key        Encryption key
-     * @param string $iv         Initialization vector
-     *
-     * @return string Plaintext
-     */
-    public function nativeDecrypt(string $ciphertext, string $auth_tag,
-        string $aad, string $key, string $iv): string
-    {
-        $this->_checkKeySize($key);
-        $plaintext = openssl_decrypt($ciphertext, $this->_nativeCipherName(),
-            $key, OPENSSL_RAW_DATA | OPENSSL_ZERO_PADDING, $iv, $auth_tag, $aad);
-        if (false === $plaintext) {
-            throw new AuthenticationException('Authentication failed.');
-        }
-        return $plaintext;
-    }
+	/**
+	 * Decrypt ciphertext using native OpenSSL.
+	 *
+	 * @param string $ciphertext Ciphertext to decrypt
+	 * @param string $auth_tag   Authentication tag to verify
+	 * @param string $aad        Additional authenticated data
+	 * @param string $key        Encryption key
+	 * @param string $iv         Initialization vector
+	 *
+	 * @return string Plaintext
+	 */
+	public function nativeDecrypt(string $ciphertext, string $auth_tag,
+		string $aad, string $key, string $iv): string
+	{
+		$this->_checkKeySize($key);
+		$plaintext = openssl_decrypt($ciphertext, $this->_nativeCipherName(),
+			$key, OPENSSL_RAW_DATA | OPENSSL_ZERO_PADDING, $iv, $auth_tag, $aad);
+		if (false === $plaintext) {
+			throw new AuthenticationException('Authentication failed.');
+		}
+		return $plaintext;
+	}
 
-    /**
-     * Get the AES-ECB cipher method name recognized by OpenSSL.
-     *
-     * @return string
-     */
-    abstract protected function _cipherName(): string;
+	/**
+	 * Get the AES-ECB cipher method name recognized by OpenSSL.
+	 *
+	 * @return string
+	 */
+	abstract protected function _cipherName(): string;
 
-    /**
-     * Get the AES-GCM cipher method recognized by OpenSSL.
-     */
-    abstract protected function _nativeCipherName(): string;
+	/**
+	 * Get the AES-GCM cipher method recognized by OpenSSL.
+	 */
+	abstract protected function _nativeCipherName(): string;
 
-    /**
-     * Get the key size in bytes.
-     *
-     * @return int
-     */
-    abstract protected function _keySize(): int;
+	/**
+	 * Get the key size in bytes.
+	 *
+	 * @return int
+	 */
+	abstract protected function _keySize(): int;
 
-    protected function _checkKeySize(string $key): void
-    {
-        if (strlen($key) !== $this->_keySize()) {
-            throw new \UnexpectedValueException('Key size must be ' .
-                $this->_keySize() . ' bytes.');
-        }
-    }
+	protected function _checkKeySize(string $key): void
+	{
+		if (strlen($key) !== $this->_keySize()) {
+			throw new \UnexpectedValueException('Key size must be ' .
+				$this->_keySize() . ' bytes.');
+		}
+	}
 
-    /**
-     * Get latest OpenSSL error message.
-     *
-     * @return string
-     */
-    protected static function _getLastOpenSSLError(): string
-    {
-        $msg = '';
-        while (false !== ($err = openssl_error_string())) {
-            $msg = $err;
-        }
-        return $msg;
-    }
+	/**
+	 * Get latest OpenSSL error message.
+	 *
+	 * @return string
+	 */
+	protected static function _getLastOpenSSLError(): string
+	{
+		$msg = '';
+		while (false !== ($err = openssl_error_string())) {
+			$msg = $err;
+		}
+		return $msg;
+	}
 }

lib/GCM/GCM.php

Indentation +262 added lines, -262 removed lines

@@ -15,281 +15,281 @@
  */
 class GCM
 {
-    /**
-     * Block of 64 zero bits.
-     *
-     * @var string
-     */
-    const ZB_64 = "\0\0\0\0\0\0\0\0";
+	/**
+	 * Block of 64 zero bits.
+	 *
+	 * @var string
+	 */
+	const ZB_64 = "\0\0\0\0\0\0\0\0";
 
-    /**
-     * Block of 128 zero bits.
-     *
-     * @var string
-     */
-    const ZB_128 = self::ZB_64 . self::ZB_64;
+	/**
+	 * Block of 128 zero bits.
+	 *
+	 * @var string
+	 */
+	const ZB_128 = self::ZB_64 . self::ZB_64;
 
-    /**
-     * Array of supported t-values, that is, the bit length of the
-     * authentication tag.
-     *
-     * See NIST SP-800-38D section 5.2.1.2 for the details.
-     *
-     * @internal
-     *
-     * @var array
-     */
-    const SUPPORTED_T_LEN = [128, 120, 112, 104, 96, 64, 32];
+	/**
+	 * Array of supported t-values, that is, the bit length of the
+	 * authentication tag.
+	 *
+	 * See NIST SP-800-38D section 5.2.1.2 for the details.
+	 *
+	 * @internal
+	 *
+	 * @var array
+	 */
+	const SUPPORTED_T_LEN = [128, 120, 112, 104, 96, 64, 32];
 
-    /**
-     * Cipher.
-     *
-     * @var Cipher
-     */
-    protected $_cipher;
+	/**
+	 * Cipher.
+	 *
+	 * @var Cipher
+	 */
+	protected $_cipher;
 
-    /**
-     * Authentication tag length in bytes.
-     *
-     * @var int
-     */
-    protected $_tagLength;
+	/**
+	 * Authentication tag length in bytes.
+	 *
+	 * @var int
+	 */
+	protected $_tagLength;
 
-    /**
-     * Constructor.
-     *
-     * @param Cipher $cipher     Cipher implementation
-     * @param int    $tag_length Authentication tag length in bytes
-     *
-     * @throws \DomainException If tag length is not supported
-     */
-    public function __construct(Cipher $cipher, int $tag_length = 16)
-    {
-        if (!in_array($tag_length << 3, self::SUPPORTED_T_LEN)) {
-            throw new \DomainException(
-                "Tag length {$tag_length} is not supported.");
-        }
-        $this->_cipher = $cipher;
-        $this->_tagLength = $tag_length;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param Cipher $cipher     Cipher implementation
+	 * @param int    $tag_length Authentication tag length in bytes
+	 *
+	 * @throws \DomainException If tag length is not supported
+	 */
+	public function __construct(Cipher $cipher, int $tag_length = 16)
+	{
+		if (!in_array($tag_length << 3, self::SUPPORTED_T_LEN)) {
+			throw new \DomainException(
+				"Tag length {$tag_length} is not supported.");
+		}
+		$this->_cipher = $cipher;
+		$this->_tagLength = $tag_length;
+	}
 
-    /**
-     * Encrypt plaintext.
-     *
-     * @param string $P  Plaintext
-     * @param string $A  Additional authenticated data
-     * @param string $K  Encryption key
-     * @param string $IV Initialization vector
-     *
-     * @throws \RuntimeException For generic errors
-     *
-     * @return array Tuple of ciphertext `C` and authentication tag `T`
-     */
-    public function encrypt(string $P, string $A, string $K, string $IV): array
-    {
-        $ghash = new GHASH($this->_cipher->encrypt(self::ZB_128, $K));
-        // generate pre-counter block
-        $J0 = $this->_generateJ0($IV, $ghash);
-        // encrypt
-        $C = $this->_gctr(self::_inc32($J0), $P, $K);
-        // generate authentication tag
-        $T = $this->_computeAuthTag($A, $C, $J0, $K, $ghash);
-        return [$C, $T];
-    }
+	/**
+	 * Encrypt plaintext.
+	 *
+	 * @param string $P  Plaintext
+	 * @param string $A  Additional authenticated data
+	 * @param string $K  Encryption key
+	 * @param string $IV Initialization vector
+	 *
+	 * @throws \RuntimeException For generic errors
+	 *
+	 * @return array Tuple of ciphertext `C` and authentication tag `T`
+	 */
+	public function encrypt(string $P, string $A, string $K, string $IV): array
+	{
+		$ghash = new GHASH($this->_cipher->encrypt(self::ZB_128, $K));
+		// generate pre-counter block
+		$J0 = $this->_generateJ0($IV, $ghash);
+		// encrypt
+		$C = $this->_gctr(self::_inc32($J0), $P, $K);
+		// generate authentication tag
+		$T = $this->_computeAuthTag($A, $C, $J0, $K, $ghash);
+		return [$C, $T];
+	}
 
-    /**
-     * Decrypt ciphertext.
-     *
-     * @param string $C  Ciphertext
-     * @param string $T  Authentication tag
-     * @param string $A  Additional authenticated data
-     * @param string $K  Encryption key
-     * @param string $IV Initialization vector
-     *
-     * @throws AuthenticationException If message authentication fails
-     * @throws \RuntimeException       For generic errors
-     *
-     * @return string Plaintext `P`
-     */
-    public function decrypt(string $C, string $T, string $A, string $K, string $IV): string
-    {
-        $ghash = new GHASH($this->_cipher->encrypt(self::ZB_128, $K));
-        // generate pre-counter block
-        $J0 = $this->_generateJ0($IV, $ghash);
-        // generate authentication tag
-        $T2 = $this->_computeAuthTag($A, $C, $J0, $K, $ghash);
-        // check that authentication tag matches
-        if (!hash_equals($T2, $T)) {
-            throw new AuthenticationException('Authentication failed.');
-        }
-        // decrypt
-        return $this->_gctr(self::_inc32($J0), $C, $K);
-    }
+	/**
+	 * Decrypt ciphertext.
+	 *
+	 * @param string $C  Ciphertext
+	 * @param string $T  Authentication tag
+	 * @param string $A  Additional authenticated data
+	 * @param string $K  Encryption key
+	 * @param string $IV Initialization vector
+	 *
+	 * @throws AuthenticationException If message authentication fails
+	 * @throws \RuntimeException       For generic errors
+	 *
+	 * @return string Plaintext `P`
+	 */
+	public function decrypt(string $C, string $T, string $A, string $K, string $IV): string
+	{
+		$ghash = new GHASH($this->_cipher->encrypt(self::ZB_128, $K));
+		// generate pre-counter block
+		$J0 = $this->_generateJ0($IV, $ghash);
+		// generate authentication tag
+		$T2 = $this->_computeAuthTag($A, $C, $J0, $K, $ghash);
+		// check that authentication tag matches
+		if (!hash_equals($T2, $T)) {
+			throw new AuthenticationException('Authentication failed.');
+		}
+		// decrypt
+		return $this->_gctr(self::_inc32($J0), $C, $K);
+	}
 
-    /**
-     * Convert string to GMP number.
-     *
-     * String is interpreted as an unsigned integer with big endian order and
-     * the most significant byte first.
-     *
-     * @param string $data Binary data
-     *
-     * @return \GMP
-     */
-    public static function strToGMP(string $data): \GMP
-    {
-        $num = gmp_import($data, 1, GMP_MSW_FIRST | GMP_BIG_ENDIAN);
-        assert($num instanceof \GMP, new \RuntimeException('gmp_import() failed.'));
-        return $num;
-    }
+	/**
+	 * Convert string to GMP number.
+	 *
+	 * String is interpreted as an unsigned integer with big endian order and
+	 * the most significant byte first.
+	 *
+	 * @param string $data Binary data
+	 *
+	 * @return \GMP
+	 */
+	public static function strToGMP(string $data): \GMP
+	{
+		$num = gmp_import($data, 1, GMP_MSW_FIRST | GMP_BIG_ENDIAN);
+		assert($num instanceof \GMP, new \RuntimeException('gmp_import() failed.'));
+		return $num;
+	}
 
-    /**
-     * Convert GMP number to string.
-     *
-     * Returned string represents an unsigned integer with big endian order and
-     * the most significant byte first.
-     *
-     * @param \GMP $num  GMP number
-     * @param int  $size Width of the string in bytes
-     *
-     * @return string Binary data
-     */
-    public static function gmpToStr(\GMP $num, int $size): string
-    {
-        $data = gmp_export($num, 1, GMP_MSW_FIRST | GMP_BIG_ENDIAN);
-        $len = strlen($data);
-        if ($len < $size) {
-            $data = str_repeat("\0", $size - $len) . $data;
-        }
-        return $data;
-    }
+	/**
+	 * Convert GMP number to string.
+	 *
+	 * Returned string represents an unsigned integer with big endian order and
+	 * the most significant byte first.
+	 *
+	 * @param \GMP $num  GMP number
+	 * @param int  $size Width of the string in bytes
+	 *
+	 * @return string Binary data
+	 */
+	public static function gmpToStr(\GMP $num, int $size): string
+	{
+		$data = gmp_export($num, 1, GMP_MSW_FIRST | GMP_BIG_ENDIAN);
+		$len = strlen($data);
+		if ($len < $size) {
+			$data = str_repeat("\0", $size - $len) . $data;
+		}
+		return $data;
+	}
 
-    /**
-     * Generate pre-counter block.
-     *
-     * See NIST SP-300-38D section 7.1 step 2 for the details.
-     *
-     * @param string $IV    Initialization vector
-     * @param GHASH  $ghash GHASH functor
-     *
-     * @return string
-     */
-    private function _generateJ0(string $IV, GHASH $ghash): string
-    {
-        // if len(IV) = 96
-        if (12 === strlen($IV)) {
-            return $IV . "\0\0\0\1";
-        }
-        $data = self::_pad128($IV) . self::ZB_64 . self::_uint64(strlen($IV) << 3);
-        return $ghash($data);
-    }
+	/**
+	 * Generate pre-counter block.
+	 *
+	 * See NIST SP-300-38D section 7.1 step 2 for the details.
+	 *
+	 * @param string $IV    Initialization vector
+	 * @param GHASH  $ghash GHASH functor
+	 *
+	 * @return string
+	 */
+	private function _generateJ0(string $IV, GHASH $ghash): string
+	{
+		// if len(IV) = 96
+		if (12 === strlen($IV)) {
+			return $IV . "\0\0\0\1";
+		}
+		$data = self::_pad128($IV) . self::ZB_64 . self::_uint64(strlen($IV) << 3);
+		return $ghash($data);
+	}
 
-    /**
-     * Apply GCTR algorithm.
-     *
-     * See NIST SP-300-38D section 6.5 for the details.
-     *
-     * @param string $ICB Initial counter block
-     * @param string $X   Input data
-     * @param string $K   Encryption key
-     *
-     * @return string Output data
-     */
-    private function _gctr(string $ICB, string $X, string $K): string
-    {
-        // if data is an empty string, return an empty string
-        if ('' === $X) {
-            return '';
-        }
-        // number of blocks
-        $n = ceil(strlen($X) / 16);
-        $CB = $ICB;
-        $Y = '';
-        for ($i = 0; $i < $n - 1; ++$i) {
-            // plaintext block
-            $xi = substr($X, $i << 4, 16);
-            // encrypt block and append to Y
-            $Y .= $xi ^ $this->_cipher->encrypt($CB, $K);
-            // increment counter block
-            $CB = self::_inc32($CB);
-        }
-        // final block
-        $xn = substr($X, $i << 4);
-        // XOR against partial block
-        $Y .= $xn ^ substr($this->_cipher->encrypt($CB, $K), 0, strlen($xn));
-        return $Y;
-    }
+	/**
+	 * Apply GCTR algorithm.
+	 *
+	 * See NIST SP-300-38D section 6.5 for the details.
+	 *
+	 * @param string $ICB Initial counter block
+	 * @param string $X   Input data
+	 * @param string $K   Encryption key
+	 *
+	 * @return string Output data
+	 */
+	private function _gctr(string $ICB, string $X, string $K): string
+	{
+		// if data is an empty string, return an empty string
+		if ('' === $X) {
+			return '';
+		}
+		// number of blocks
+		$n = ceil(strlen($X) / 16);
+		$CB = $ICB;
+		$Y = '';
+		for ($i = 0; $i < $n - 1; ++$i) {
+			// plaintext block
+			$xi = substr($X, $i << 4, 16);
+			// encrypt block and append to Y
+			$Y .= $xi ^ $this->_cipher->encrypt($CB, $K);
+			// increment counter block
+			$CB = self::_inc32($CB);
+		}
+		// final block
+		$xn = substr($X, $i << 4);
+		// XOR against partial block
+		$Y .= $xn ^ substr($this->_cipher->encrypt($CB, $K), 0, strlen($xn));
+		return $Y;
+	}
 
-    /**
-     * Compute authentication tag.
-     *
-     * See NIST SP-300-38D section 7.1 steps 5-6 for the details.
-     *
-     * @param string $A     Additional authenticated data
-     * @param string $C     Ciphertext
-     * @param string $J0    Pre-counter block
-     * @param string $K     Encryption key
-     * @param GHASH  $ghash GHASH functor
-     *
-     * @return string Authentication tag `T`
-     */
-    private function _computeAuthTag(string $A, string $C, string $J0, string $K,
-        GHASH $ghash): string
-    {
-        $data = self::_pad128($A) . self::_pad128($C) .
-             self::_uint64(strlen($A) << 3) . self::_uint64(strlen($C) << 3);
-        $S = $ghash($data);
-        return substr($this->_gctr($J0, $S, $K), 0, $this->_tagLength);
-    }
+	/**
+	 * Compute authentication tag.
+	 *
+	 * See NIST SP-300-38D section 7.1 steps 5-6 for the details.
+	 *
+	 * @param string $A     Additional authenticated data
+	 * @param string $C     Ciphertext
+	 * @param string $J0    Pre-counter block
+	 * @param string $K     Encryption key
+	 * @param GHASH  $ghash GHASH functor
+	 *
+	 * @return string Authentication tag `T`
+	 */
+	private function _computeAuthTag(string $A, string $C, string $J0, string $K,
+		GHASH $ghash): string
+	{
+		$data = self::_pad128($A) . self::_pad128($C) .
+			 self::_uint64(strlen($A) << 3) . self::_uint64(strlen($C) << 3);
+		$S = $ghash($data);
+		return substr($this->_gctr($J0, $S, $K), 0, $this->_tagLength);
+	}
 
-    /**
-     * Pad data to 128 bit block boundary.
-     *
-     * @param string $data
-     *
-     * @return string
-     */
-    private static function _pad128(string $data): string
-    {
-        $padlen = 16 - strlen($data) % 16;
-        if (16 !== $padlen) {
-            $data .= str_repeat("\0", $padlen);
-        }
-        return $data;
-    }
+	/**
+	 * Pad data to 128 bit block boundary.
+	 *
+	 * @param string $data
+	 *
+	 * @return string
+	 */
+	private static function _pad128(string $data): string
+	{
+		$padlen = 16 - strlen($data) % 16;
+		if (16 !== $padlen) {
+			$data .= str_repeat("\0", $padlen);
+		}
+		return $data;
+	}
 
-    /**
-     * Increment 32 rightmost bits of the counter block.
-     *
-     * See NIST SP-300-38D section 6.2 for the details.
-     *
-     * @param string $X
-     *
-     * @return string
-     */
-    private static function _inc32(string $X): string
-    {
-        $Y = substr($X, 0, -4);
-        // increment counter
-        $n = self::strToGMP(substr($X, -4)) + 1;
-        // wrap by using only the 32 rightmost bits
-        $Y .= substr(self::gmpToStr($n, 4), -4);
-        return $Y;
-    }
+	/**
+	 * Increment 32 rightmost bits of the counter block.
+	 *
+	 * See NIST SP-300-38D section 6.2 for the details.
+	 *
+	 * @param string $X
+	 *
+	 * @return string
+	 */
+	private static function _inc32(string $X): string
+	{
+		$Y = substr($X, 0, -4);
+		// increment counter
+		$n = self::strToGMP(substr($X, -4)) + 1;
+		// wrap by using only the 32 rightmost bits
+		$Y .= substr(self::gmpToStr($n, 4), -4);
+		return $Y;
+	}
 
-    /**
-     * Convert integer to 64 bit big endian binary string.
-     *
-     * @param int $num
-     *
-     * @return string
-     */
-    private static function _uint64(int $num): string
-    {
-        // truncate on 32 bit hosts
-        if (PHP_INT_SIZE < 8) {
-            return "\0\0\0\0" . pack('N', $num);
-        }
-        return pack('J', $num);
-    }
+	/**
+	 * Convert integer to 64 bit big endian binary string.
+	 *
+	 * @param int $num
+	 *
+	 * @return string
+	 */
+	private static function _uint64(int $num): string
+	{
+		// truncate on 32 bit hosts
+		if (PHP_INT_SIZE < 8) {
+			return "\0\0\0\0" . pack('N', $num);
+		}
+		return pack('J', $num);
+	}
 }

lib/GCM/AESGCM.php

Indentation +56 added lines, -56 removed lines

@@ -11,62 +11,62 @@
  */
 abstract class AESGCM
 {
-    /**
-     * Encrypt plaintext.
-     *
-     * @param string $plaintext  Plaintext to encrypt
-     * @param string $aad        Additional authenticated data
-     * @param string $key        Encryption key
-     * @param string $iv         Initialization vector
-     * @param int    $tag_length Authentication tag length in bytes
-     *
-     * @return array Tuple of ciphertext and authentication tag
-     */
-    public static function encrypt(string $plaintext, string $aad, string $key,
-        string $iv, int $tag_length = 16): array
-    {
-        $cipher = AESCipher::fromKeyLength(strlen($key));
-        if ($cipher->hasNativeCipher()) {
-            return $cipher->nativeEncrypt($plaintext, $aad, $key, $iv, $tag_length);
-        }
-        return self::_getGCM($cipher, $tag_length)
-            ->encrypt($plaintext, $aad, $key, $iv);
-    }
+	/**
+	 * Encrypt plaintext.
+	 *
+	 * @param string $plaintext  Plaintext to encrypt
+	 * @param string $aad        Additional authenticated data
+	 * @param string $key        Encryption key
+	 * @param string $iv         Initialization vector
+	 * @param int    $tag_length Authentication tag length in bytes
+	 *
+	 * @return array Tuple of ciphertext and authentication tag
+	 */
+	public static function encrypt(string $plaintext, string $aad, string $key,
+		string $iv, int $tag_length = 16): array
+	{
+		$cipher = AESCipher::fromKeyLength(strlen($key));
+		if ($cipher->hasNativeCipher()) {
+			return $cipher->nativeEncrypt($plaintext, $aad, $key, $iv, $tag_length);
+		}
+		return self::_getGCM($cipher, $tag_length)
+			->encrypt($plaintext, $aad, $key, $iv);
+	}
 
-    /**
-     * Decrypt ciphertext.
-     *
-     * @param string $ciphertext Ciphertext to decrypt
-     * @param string $auth_tag   Authentication tag to verify
-     * @param string $aad        Additional authenticated data
-     * @param string $key        Encryption key
-     * @param string $iv         Initialization vector
-     *
-     * @throws \Sop\GCM\Exception\AuthenticationException If message authentication fails
-     *
-     * @return string Plaintext
-     */
-    public static function decrypt(string $ciphertext, string $auth_tag,
-        string $aad, string $key, string $iv): string
-    {
-        $cipher = AESCipher::fromKeyLength(strlen($key));
-        if ($cipher->hasNativeCipher()) {
-            return $cipher->nativeDecrypt($ciphertext, $auth_tag, $aad, $key, $iv);
-        }
-        return self::_getGCM($cipher, strlen($auth_tag))
-            ->decrypt($ciphertext, $auth_tag, $aad, $key, $iv);
-    }
+	/**
+	 * Decrypt ciphertext.
+	 *
+	 * @param string $ciphertext Ciphertext to decrypt
+	 * @param string $auth_tag   Authentication tag to verify
+	 * @param string $aad        Additional authenticated data
+	 * @param string $key        Encryption key
+	 * @param string $iv         Initialization vector
+	 *
+	 * @throws \Sop\GCM\Exception\AuthenticationException If message authentication fails
+	 *
+	 * @return string Plaintext
+	 */
+	public static function decrypt(string $ciphertext, string $auth_tag,
+		string $aad, string $key, string $iv): string
+	{
+		$cipher = AESCipher::fromKeyLength(strlen($key));
+		if ($cipher->hasNativeCipher()) {
+			return $cipher->nativeDecrypt($ciphertext, $auth_tag, $aad, $key, $iv);
+		}
+		return self::_getGCM($cipher, strlen($auth_tag))
+			->decrypt($ciphertext, $auth_tag, $aad, $key, $iv);
+	}
 
-    /**
-     * Get GCM instance.
-     *
-     * @param AESCipher $cipher     Cipher instance
-     * @param int       $tag_length Authentication tag length
-     *
-     * @return GCM
-     */
-    protected static function _getGCM(AESCipher $cipher, int $tag_length): GCM
-    {
-        return new GCM($cipher, $tag_length);
-    }
+	/**
+	 * Get GCM instance.
+	 *
+	 * @param AESCipher $cipher     Cipher instance
+	 * @param int       $tag_length Authentication tag length
+	 *
+	 * @return GCM
+	 */
+	protected static function _getGCM(AESCipher $cipher, int $tag_length): GCM
+	{
+		return new GCM($cipher, $tag_length);
+	}
 }