eventespresso / event-espresso-core

core/services/encryption/EncryptionKeyManagerInterface.php

Indentation +81 added lines, -81 removed lines

@@ -12,85 +12,85 @@
  */
 interface EncryptionKeyManagerInterface
 {
-    /**
-     * add an encryption key
-     *
-     * @param string $encryption_key_identifier - name of the encryption key to use
-     * @param string $encryption_key            - cryptographically secure passphrase. will generate if necessary
-     * @param bool   $overwrite                 - prevents accidental overwriting of an existing key which would be bad
-     * @return bool
-     */
-    public function addEncryptionKey($encryption_key_identifier, $encryption_key = '', $overwrite = false);
-
-
-    /**
-     * returns true if encryption key has already been generated
-     *
-     * @param string $encryption_key_identifier - encryption key name
-     * @return bool
-     */
-    public function encryptionKeyExists($encryption_key_identifier = '');
-
-
-    /**
-     * returns cryptographically secure passphrase. will use default if necessary
-     *
-     * @param string $encryption_key_identifier - encryption key name. will use default if necessary
-     * @param bool   $generate                  - will generate a new key if the requested one does not exist
-     * @param bool   $throw_exception           - if TRUE (default), will throw an exception if key is not found
-     * @return string
-     */
-    public function getEncryptionKey($encryption_key_identifier = '', $generate = false, $throw_exception = true);
-
-
-    /**
-     * creates a new encryption key
-     *
-     * @param bool $strong if true (default) will attempt to generate a cryptographically secure key
-     * @return string
-     */
-    public function generateEncryptionKey($strong = true);
-
-
-    /**
-     * @return int
-     */
-    public function bitDepth();
-
-
-    /**
-     * @param int $bit_depth options are 64, 128, 192, or 256
-     */
-    public function setBitDepth($bit_depth);
-
-
-    /**
-     * @return int
-     */
-    public function keyLength();
-
-
-    /**
-     * @param int $key_length
-     */
-    public function setKeyLength($key_length);
-
-
-    /**
-     * deletes ALL existing encryption keys from the db
-     *
-     * @return bool true if keys successfully deleted, false otherwise.
-     */
-    public function removeAllEncryptionKeys();
-
-
-    /**
-     * deletes an existing encryption key from those saved in the db
-     *
-     * @param string $encryption_key_identifier encryption key name
-     * @return int  1: key removed successfully.
-     *              0: key did not exist.
-     *             -1: failed to remove key
-     */
-    public function removeEncryptionKey($encryption_key_identifier = '');
+	/**
+	 * add an encryption key
+	 *
+	 * @param string $encryption_key_identifier - name of the encryption key to use
+	 * @param string $encryption_key            - cryptographically secure passphrase. will generate if necessary
+	 * @param bool   $overwrite                 - prevents accidental overwriting of an existing key which would be bad
+	 * @return bool
+	 */
+	public function addEncryptionKey($encryption_key_identifier, $encryption_key = '', $overwrite = false);
+
+
+	/**
+	 * returns true if encryption key has already been generated
+	 *
+	 * @param string $encryption_key_identifier - encryption key name
+	 * @return bool
+	 */
+	public function encryptionKeyExists($encryption_key_identifier = '');
+
+
+	/**
+	 * returns cryptographically secure passphrase. will use default if necessary
+	 *
+	 * @param string $encryption_key_identifier - encryption key name. will use default if necessary
+	 * @param bool   $generate                  - will generate a new key if the requested one does not exist
+	 * @param bool   $throw_exception           - if TRUE (default), will throw an exception if key is not found
+	 * @return string
+	 */
+	public function getEncryptionKey($encryption_key_identifier = '', $generate = false, $throw_exception = true);
+
+
+	/**
+	 * creates a new encryption key
+	 *
+	 * @param bool $strong if true (default) will attempt to generate a cryptographically secure key
+	 * @return string
+	 */
+	public function generateEncryptionKey($strong = true);
+
+
+	/**
+	 * @return int
+	 */
+	public function bitDepth();
+
+
+	/**
+	 * @param int $bit_depth options are 64, 128, 192, or 256
+	 */
+	public function setBitDepth($bit_depth);
+
+
+	/**
+	 * @return int
+	 */
+	public function keyLength();
+
+
+	/**
+	 * @param int $key_length
+	 */
+	public function setKeyLength($key_length);
+
+
+	/**
+	 * deletes ALL existing encryption keys from the db
+	 *
+	 * @return bool true if keys successfully deleted, false otherwise.
+	 */
+	public function removeAllEncryptionKeys();
+
+
+	/**
+	 * deletes an existing encryption key from those saved in the db
+	 *
+	 * @param string $encryption_key_identifier encryption key name
+	 * @return int  1: key removed successfully.
+	 *              0: key did not exist.
+	 *             -1: failed to remove key
+	 */
+	public function removeEncryptionKey($encryption_key_identifier = '');
 }

core/services/encryption/EncryptionKeyManager.php

Indentation +297 added lines, -297 removed lines

@@ -16,301 +16,301 @@
  */
 class EncryptionKeyManager implements EncryptionKeyManagerInterface
 {
-    /**
-     * @var Base64Encoder
-     */
-    protected $base64_encoder;
-
-    /**
-     * name used for a default encryption key in case no others are set
-     *
-     * @var string
-     */
-    private $default_encryption_key_id;
-
-    /**
-     * name used for saving encryption keys to the wp_options table
-     *
-     * @var string
-     */
-    private $encryption_keys_option_name;
-
-    /**
-     * @var array
-     */
-    private $encryption_keys = null;
-
-    /**
-     * number of bits used when generating cryptographically secure keys
-     *
-     * @var int
-     */
-    private $bit_depth = 128;
-
-    /**
-     * @var int[]
-     */
-    private $bit_depth_options = [64, 128, 192, 256];
-
-    /**
-     * number of characters used when generating cryptographically weak keys
-     *
-     * @var int
-     */
-    private $key_length = 40;
-
-
-    /**
-     * @param Base64Encoder $base64_encoder
-     * @param string        $default_encryption_key_id
-     * @param string        $encryption_keys_option_name
-     */
-    public function __construct(Base64Encoder $base64_encoder, $default_encryption_key_id, $encryption_keys_option_name)
-    {
-        $this->base64_encoder              = $base64_encoder;
-        $this->default_encryption_key_id   = $default_encryption_key_id;
-        $this->encryption_keys_option_name = $encryption_keys_option_name;
-    }
-
-
-    /**
-     * add an encryption key
-     *
-     * @param string $encryption_key_identifier - name of the encryption key to use
-     * @param string $encryption_key            - cryptographically secure passphrase. will generate if necessary
-     * @param bool   $overwrite                 - prevents accidental overwriting of an existing key which would be bad
-     * @return bool
-     * @throws Exception
-     */
-    public function addEncryptionKey($encryption_key_identifier, $encryption_key = '', $overwrite = false)
-    {
-        $encryption_key_identifier = $encryption_key_identifier ?: $this->default_encryption_key_id;
-        if ($this->encryptionKeyExists($encryption_key_identifier) && ! $overwrite) {
-            // WOAH!!! that key already exists and we don't want to overwrite it
-            throw new RuntimeException(
-                sprintf(
-                    esc_html__(
-                        'The "%1$s" encryption key already exists and can not be overwritten because previously encrypted values would no longer be capable of being decrypted.',
-                        'event_espresso'
-                    ),
-                    $encryption_key_identifier
-                )
-            );
-        }
-        $this->encryption_keys[ $encryption_key_identifier ] = $encryption_key ?: $this->generateEncryptionKey();
-        return $this->saveEncryptionKeys();
-    }
-
-
-    /**
-     * returns true if encryption key has already been generated
-     *
-     * @param string $encryption_key_identifier - encryption key name
-     * @return bool
-     * @throws Exception
-     * @throws OutOfBoundsException
-     */
-    public function encryptionKeyExists($encryption_key_identifier = '')
-    {
-        // ensure keys are loaded
-        $this->retrieveEncryptionKeys();
-        return isset($this->encryption_keys[ $encryption_key_identifier ]);
-    }
-
-
-    /**
-     * returns cryptographically secure passphrase. will use default if necessary
-     *
-     * @param string $encryption_key_identifier - encryption key name. will use default if necessary
-     * @param bool   $generate                  - will generate a new key if the requested one does not exist
-     * @param bool   $throw_exception           - if TRUE (default), will throw an exception if key is not found
-     * @return string
-     * @throws Exception
-     */
-    public function getEncryptionKey($encryption_key_identifier = '', $generate = true, $throw_exception = true)
-    {
-        $encryption_key_identifier = $encryption_key_identifier ?: $this->default_encryption_key_id;
-        // if encryption key has not been set
-        if (! $this->encryptionKeyExists($encryption_key_identifier)) {
-            if ($generate) {
-                $this->addEncryptionKey($encryption_key_identifier);
-            } else {
-                if (! $throw_exception) {
-                    return '';
-                }
-                throw new OutOfBoundsException(
-                    sprintf(
-                        esc_html__('The "%1$s" encryption key was not found or is invalid.', 'event_espresso'),
-                        $encryption_key_identifier
-                    )
-                );
-            }
-        }
-        return $this->encryption_keys[ $encryption_key_identifier ];
-    }
-
-
-    /**
-     * creates a new encryption key
-     *
-     * @param bool $strong if true (default) will attempt to generate a cryptographically secure key
-     * @return string
-     * @throws Exception
-     */
-    public function generateEncryptionKey($strong = true)
-    {
-        return $strong && PHP_VERSION_ID >= 70100
-            ? $this->generateStrongEncryptionKey()
-            : $this->generateWeakEncryptionKey();
-    }
-
-
-    /**
-     * creates a new cryptographically secure encryption key
-     *
-     * @return string
-     * @throws Exception
-     */
-    protected function generateStrongEncryptionKey()
-    {
-        // bit_depth needs to be divided by 8 to convert to bytes
-        return $this->base64_encoder->encodeString(random_bytes($this->bit_depth / 8));
-    }
-
-
-    /**
-     * creates a new encryption key that should not be trusted to be cryptographically secure
-     *
-     * @return string
-     * @throws Exception
-     */
-    protected function generateWeakEncryptionKey()
-    {
-        // @see http://stackoverflow.com/questions/637278/what-is-the-best-way-to-generate-a-random-key-within-php
-        $iterations    = ceil($this->key_length / 40);
-        $random_string = '';
-        for ($i = 0; $i < $iterations; $i++) {
-            $random_string .= sha1(microtime(true) . mt_rand(10000, 90000));
-        }
-        $random_string = (string) substr($random_string, 0, $this->key_length);
-        return $this->base64_encoder->encodeString($random_string);
-    }
-
-
-    /**
-     * @return int
-     */
-    public function bitDepth()
-    {
-        return $this->bit_depth;
-    }
-
-
-    /**
-     * @param int $bit_depth options are 64, 128, 192, or 256
-     */
-    public function setBitDepth($bit_depth)
-    {
-        $bit_depth       = absint($bit_depth);
-        $this->bit_depth = in_array($bit_depth, $this->bit_depth_options, true) ? $bit_depth : 128;
-    }
-
-
-    /**
-     * @return int
-     */
-    public function keyLength()
-    {
-        return $this->key_length;
-    }
-
-
-    /**
-     * @param int $key_length
-     */
-    public function setKeyLength($key_length)
-    {
-        // let's not let the key length go below 8 or above 128
-        $this->key_length = min(max(absint($key_length), 8), 128);
-    }
-
-
-    /**
-     * deletes ALL existing encryption keys from the db
-     *
-     * @return bool true if keys successfully deleted, false otherwise.
-     */
-    public function removeAllEncryptionKeys()
-    {
-        return delete_option($this->encryption_keys_option_name);
-    }
-
-
-    /**
-     * deletes an existing encryption key from those saved in the db
-     *
-     * @param string $encryption_key_identifier encryption key name
-     * @return int  1: key removed successfully.
-     *              0: key did not exist.
-     *             -1: failed to remove key
-     * @throws Exception
-     */
-    public function removeEncryptionKey($encryption_key_identifier = '')
-    {
-        // if encryption key has not been set
-        if (! $this->encryptionKeyExists($encryption_key_identifier)) {
-            return 0;
-        }
-        unset($this->encryption_keys[ $encryption_key_identifier ]);
-        return $this->saveEncryptionKeys() ? 1 : -1;
-    }
-
-
-    /**
-     * retrieves encryption keys from db
-     *
-     * @return array
-     * @throws Exception
-     * @throws RuntimeException
-     */
-    protected function retrieveEncryptionKeys()
-    {
-        // if encryption key has not been set
-        if (empty($this->encryption_keys)) {
-            // retrieve encryption_key from db
-            $this->encryption_keys = get_option($this->encryption_keys_option_name, null);
-            // WHAT?? No encryption keys in the db ??
-            if ($this->encryption_keys === null) {
-                $this->encryption_keys = [];
-                // let's create the default key and save it
-                $new_key                                                   = $this->generateEncryptionKey();
-                $this->encryption_keys[ $this->default_encryption_key_id ] = $new_key;
-                if (! $this->saveEncryptionKeys(true)) {
-                    throw new RuntimeException(
-                        sprintf(
-                            esc_html__(
-                                'Failed to save the "%1$s" encryption keys array to the database.',
-                                'event_espresso'
-                            ),
-                            $this->encryption_keys_option_name
-                        )
-                    );
-                }
-            }
-        }
-        return $this->encryption_keys;
-    }
-
-
-    /**
-     * saves encryption keys from db
-     *
-     * @return bool
-     */
-    protected function saveEncryptionKeys($initialize = false)
-    {
-        return $initialize
-            ? add_option($this->encryption_keys_option_name, $this->encryption_keys, '', false)
-            : update_option($this->encryption_keys_option_name, $this->encryption_keys, false);
-    }
+	/**
+	 * @var Base64Encoder
+	 */
+	protected $base64_encoder;
+
+	/**
+	 * name used for a default encryption key in case no others are set
+	 *
+	 * @var string
+	 */
+	private $default_encryption_key_id;
+
+	/**
+	 * name used for saving encryption keys to the wp_options table
+	 *
+	 * @var string
+	 */
+	private $encryption_keys_option_name;
+
+	/**
+	 * @var array
+	 */
+	private $encryption_keys = null;
+
+	/**
+	 * number of bits used when generating cryptographically secure keys
+	 *
+	 * @var int
+	 */
+	private $bit_depth = 128;
+
+	/**
+	 * @var int[]
+	 */
+	private $bit_depth_options = [64, 128, 192, 256];
+
+	/**
+	 * number of characters used when generating cryptographically weak keys
+	 *
+	 * @var int
+	 */
+	private $key_length = 40;
+
+
+	/**
+	 * @param Base64Encoder $base64_encoder
+	 * @param string        $default_encryption_key_id
+	 * @param string        $encryption_keys_option_name
+	 */
+	public function __construct(Base64Encoder $base64_encoder, $default_encryption_key_id, $encryption_keys_option_name)
+	{
+		$this->base64_encoder              = $base64_encoder;
+		$this->default_encryption_key_id   = $default_encryption_key_id;
+		$this->encryption_keys_option_name = $encryption_keys_option_name;
+	}
+
+
+	/**
+	 * add an encryption key
+	 *
+	 * @param string $encryption_key_identifier - name of the encryption key to use
+	 * @param string $encryption_key            - cryptographically secure passphrase. will generate if necessary
+	 * @param bool   $overwrite                 - prevents accidental overwriting of an existing key which would be bad
+	 * @return bool
+	 * @throws Exception
+	 */
+	public function addEncryptionKey($encryption_key_identifier, $encryption_key = '', $overwrite = false)
+	{
+		$encryption_key_identifier = $encryption_key_identifier ?: $this->default_encryption_key_id;
+		if ($this->encryptionKeyExists($encryption_key_identifier) && ! $overwrite) {
+			// WOAH!!! that key already exists and we don't want to overwrite it
+			throw new RuntimeException(
+				sprintf(
+					esc_html__(
+						'The "%1$s" encryption key already exists and can not be overwritten because previously encrypted values would no longer be capable of being decrypted.',
+						'event_espresso'
+					),
+					$encryption_key_identifier
+				)
+			);
+		}
+		$this->encryption_keys[ $encryption_key_identifier ] = $encryption_key ?: $this->generateEncryptionKey();
+		return $this->saveEncryptionKeys();
+	}
+
+
+	/**
+	 * returns true if encryption key has already been generated
+	 *
+	 * @param string $encryption_key_identifier - encryption key name
+	 * @return bool
+	 * @throws Exception
+	 * @throws OutOfBoundsException
+	 */
+	public function encryptionKeyExists($encryption_key_identifier = '')
+	{
+		// ensure keys are loaded
+		$this->retrieveEncryptionKeys();
+		return isset($this->encryption_keys[ $encryption_key_identifier ]);
+	}
+
+
+	/**
+	 * returns cryptographically secure passphrase. will use default if necessary
+	 *
+	 * @param string $encryption_key_identifier - encryption key name. will use default if necessary
+	 * @param bool   $generate                  - will generate a new key if the requested one does not exist
+	 * @param bool   $throw_exception           - if TRUE (default), will throw an exception if key is not found
+	 * @return string
+	 * @throws Exception
+	 */
+	public function getEncryptionKey($encryption_key_identifier = '', $generate = true, $throw_exception = true)
+	{
+		$encryption_key_identifier = $encryption_key_identifier ?: $this->default_encryption_key_id;
+		// if encryption key has not been set
+		if (! $this->encryptionKeyExists($encryption_key_identifier)) {
+			if ($generate) {
+				$this->addEncryptionKey($encryption_key_identifier);
+			} else {
+				if (! $throw_exception) {
+					return '';
+				}
+				throw new OutOfBoundsException(
+					sprintf(
+						esc_html__('The "%1$s" encryption key was not found or is invalid.', 'event_espresso'),
+						$encryption_key_identifier
+					)
+				);
+			}
+		}
+		return $this->encryption_keys[ $encryption_key_identifier ];
+	}
+
+
+	/**
+	 * creates a new encryption key
+	 *
+	 * @param bool $strong if true (default) will attempt to generate a cryptographically secure key
+	 * @return string
+	 * @throws Exception
+	 */
+	public function generateEncryptionKey($strong = true)
+	{
+		return $strong && PHP_VERSION_ID >= 70100
+			? $this->generateStrongEncryptionKey()
+			: $this->generateWeakEncryptionKey();
+	}
+
+
+	/**
+	 * creates a new cryptographically secure encryption key
+	 *
+	 * @return string
+	 * @throws Exception
+	 */
+	protected function generateStrongEncryptionKey()
+	{
+		// bit_depth needs to be divided by 8 to convert to bytes
+		return $this->base64_encoder->encodeString(random_bytes($this->bit_depth / 8));
+	}
+
+
+	/**
+	 * creates a new encryption key that should not be trusted to be cryptographically secure
+	 *
+	 * @return string
+	 * @throws Exception
+	 */
+	protected function generateWeakEncryptionKey()
+	{
+		// @see http://stackoverflow.com/questions/637278/what-is-the-best-way-to-generate-a-random-key-within-php
+		$iterations    = ceil($this->key_length / 40);
+		$random_string = '';
+		for ($i = 0; $i < $iterations; $i++) {
+			$random_string .= sha1(microtime(true) . mt_rand(10000, 90000));
+		}
+		$random_string = (string) substr($random_string, 0, $this->key_length);
+		return $this->base64_encoder->encodeString($random_string);
+	}
+
+
+	/**
+	 * @return int
+	 */
+	public function bitDepth()
+	{
+		return $this->bit_depth;
+	}
+
+
+	/**
+	 * @param int $bit_depth options are 64, 128, 192, or 256
+	 */
+	public function setBitDepth($bit_depth)
+	{
+		$bit_depth       = absint($bit_depth);
+		$this->bit_depth = in_array($bit_depth, $this->bit_depth_options, true) ? $bit_depth : 128;
+	}
+
+
+	/**
+	 * @return int
+	 */
+	public function keyLength()
+	{
+		return $this->key_length;
+	}
+
+
+	/**
+	 * @param int $key_length
+	 */
+	public function setKeyLength($key_length)
+	{
+		// let's not let the key length go below 8 or above 128
+		$this->key_length = min(max(absint($key_length), 8), 128);
+	}
+
+
+	/**
+	 * deletes ALL existing encryption keys from the db
+	 *
+	 * @return bool true if keys successfully deleted, false otherwise.
+	 */
+	public function removeAllEncryptionKeys()
+	{
+		return delete_option($this->encryption_keys_option_name);
+	}
+
+
+	/**
+	 * deletes an existing encryption key from those saved in the db
+	 *
+	 * @param string $encryption_key_identifier encryption key name
+	 * @return int  1: key removed successfully.
+	 *              0: key did not exist.
+	 *             -1: failed to remove key
+	 * @throws Exception
+	 */
+	public function removeEncryptionKey($encryption_key_identifier = '')
+	{
+		// if encryption key has not been set
+		if (! $this->encryptionKeyExists($encryption_key_identifier)) {
+			return 0;
+		}
+		unset($this->encryption_keys[ $encryption_key_identifier ]);
+		return $this->saveEncryptionKeys() ? 1 : -1;
+	}
+
+
+	/**
+	 * retrieves encryption keys from db
+	 *
+	 * @return array
+	 * @throws Exception
+	 * @throws RuntimeException
+	 */
+	protected function retrieveEncryptionKeys()
+	{
+		// if encryption key has not been set
+		if (empty($this->encryption_keys)) {
+			// retrieve encryption_key from db
+			$this->encryption_keys = get_option($this->encryption_keys_option_name, null);
+			// WHAT?? No encryption keys in the db ??
+			if ($this->encryption_keys === null) {
+				$this->encryption_keys = [];
+				// let's create the default key and save it
+				$new_key                                                   = $this->generateEncryptionKey();
+				$this->encryption_keys[ $this->default_encryption_key_id ] = $new_key;
+				if (! $this->saveEncryptionKeys(true)) {
+					throw new RuntimeException(
+						sprintf(
+							esc_html__(
+								'Failed to save the "%1$s" encryption keys array to the database.',
+								'event_espresso'
+							),
+							$this->encryption_keys_option_name
+						)
+					);
+				}
+			}
+		}
+		return $this->encryption_keys;
+	}
+
+
+	/**
+	 * saves encryption keys from db
+	 *
+	 * @return bool
+	 */
+	protected function saveEncryptionKeys($initialize = false)
+	{
+		return $initialize
+			? add_option($this->encryption_keys_option_name, $this->encryption_keys, '', false)
+			: update_option($this->encryption_keys_option_name, $this->encryption_keys, false);
+	}
 }

Spacing +10 added lines, -10 removed lines

@@ -97,7 +97,7 @@ 
                 )
             );
         }
-        $this->encryption_keys[ $encryption_key_identifier ] = $encryption_key ?: $this->generateEncryptionKey();
+        $this->encryption_keys[$encryption_key_identifier] = $encryption_key ?: $this->generateEncryptionKey();
         return $this->saveEncryptionKeys();
     }
 
@@ -114,7 +114,7 @@ 
     {
         // ensure keys are loaded
         $this->retrieveEncryptionKeys();
-        return isset($this->encryption_keys[ $encryption_key_identifier ]);
+        return isset($this->encryption_keys[$encryption_key_identifier]);
     }
 
 
@@ -131,11 +131,11 @@ 
     {
         $encryption_key_identifier = $encryption_key_identifier ?: $this->default_encryption_key_id;
         // if encryption key has not been set
-        if (! $this->encryptionKeyExists($encryption_key_identifier)) {
+        if ( ! $this->encryptionKeyExists($encryption_key_identifier)) {
             if ($generate) {
                 $this->addEncryptionKey($encryption_key_identifier);
             } else {
-                if (! $throw_exception) {
+                if ( ! $throw_exception) {
                     return '';
                 }
                 throw new OutOfBoundsException(
@@ -146,7 +146,7 @@ 
                 );
             }
         }
-        return $this->encryption_keys[ $encryption_key_identifier ];
+        return $this->encryption_keys[$encryption_key_identifier];
     }
 
 
@@ -190,7 +190,7 @@ 
         $iterations    = ceil($this->key_length / 40);
         $random_string = '';
         for ($i = 0; $i < $iterations; $i++) {
-            $random_string .= sha1(microtime(true) . mt_rand(10000, 90000));
+            $random_string .= sha1(microtime(true).mt_rand(10000, 90000));
         }
         $random_string = (string) substr($random_string, 0, $this->key_length);
         return $this->base64_encoder->encodeString($random_string);
@@ -258,10 +258,10 @@ 
     public function removeEncryptionKey($encryption_key_identifier = '')
     {
         // if encryption key has not been set
-        if (! $this->encryptionKeyExists($encryption_key_identifier)) {
+        if ( ! $this->encryptionKeyExists($encryption_key_identifier)) {
             return 0;
         }
-        unset($this->encryption_keys[ $encryption_key_identifier ]);
+        unset($this->encryption_keys[$encryption_key_identifier]);
         return $this->saveEncryptionKeys() ? 1 : -1;
     }
 
@@ -284,8 +284,8 @@ 
                 $this->encryption_keys = [];
                 // let's create the default key and save it
                 $new_key                                                   = $this->generateEncryptionKey();
-                $this->encryption_keys[ $this->default_encryption_key_id ] = $new_key;
-                if (! $this->saveEncryptionKeys(true)) {
+                $this->encryption_keys[$this->default_encryption_key_id] = $new_key;
+                if ( ! $this->saveEncryptionKeys(true)) {
                     throw new RuntimeException(
                         sprintf(
                             esc_html__(

core/services/encryption/openssl/CipherMethod.php

Indentation +201 added lines, -201 removed lines

@@ -15,205 +15,205 @@
 class CipherMethod
 {
 
-    /**
-     * @var string
-     */
-    protected $cipher_method_option_name;
-
-    /**
-     * list of cipher methods that we consider usable,
-     * essentially all of the installed_cipher_methods minus weak_algorithms
-     *
-     * @var array
-     */
-    protected $cipher_methods = [];
-
-    /**
-     * @var string
-     */
-    protected $default_cipher_method;
-
-    /**
-     * list of ALL cipher methods available on the server
-     *
-     * @var array
-     */
-    protected $installed_cipher_methods;
-
-    /**
-     * the OpenSSL cipher method to use. default: AES-128-CBC
-     *
-     * @var string
-     */
-    protected $validated_cipher_method;
-
-    /**
-     * as early as Aug 2016, Openssl declared the following weak: RC2, RC4, DES, 3DES, MD5 based
-     * and ECB mode should be avoided
-     *
-     * @var array
-     */
-    protected $weak_algorithms = ['des', 'ecb', 'md5', 'rc2', 'rc4'];
-
-
-    /**
-     * @param string $default_cipher_method
-     * @param string $cipher_method_option_name
-     */
-    public function __construct($default_cipher_method, $cipher_method_option_name)
-    {
-        $this->default_cipher_method     = $default_cipher_method;
-        $this->cipher_method_option_name = $cipher_method_option_name;
-        $this->installed_cipher_methods  = openssl_get_cipher_methods();
-    }
-
-
-    /**
-     * Returns a cipher method that has been verified to work.
-     * First checks if the cached cipher has been set already and if so, returns that.
-     * Then tests the incoming default and returns that if it's good.
-     * If not, then it retrieves the previously tested and saved cipher method.
-     * But if that doesn't exist, then calls getAvailableCipherMethod()
-     * to see what is available on the server, and returns the results.
-     *
-     * @param string $cipher_method
-     * @param bool   $load_alternate [optional] if TRUE, will load the default cipher method (or any strong algorithm)
-     *                               if the requested cipher method is not installed or invalid.
-     *                               if FALSE, will throw an exception if the requested cipher method is not valid.
-     * @return string
-     * @throws RuntimeException
-     */
-    public function getCipherMethod($cipher_method = null, $load_alternate = true)
-    {
-        if (empty($cipher_method) && $this->validated_cipher_method !== null) {
-            return $this->validated_cipher_method;
-        }
-        // if nothing specific was requested and it's ok to load an alternate, then grab the system default
-        if (empty($cipher_method) && $load_alternate) {
-            $cipher_method = $this->default_cipher_method;
-        }
-        // verify that the cipher method can produce an initialization vector.
-        // but if the requested is invalid and we don't want to load an alternate, then throw an exception
-        $throw_exception = ! $load_alternate;
-        if ($this->validateCipherMethod($cipher_method, $throw_exception) === false) {
-            // nope? ... ok let's see what we can find
-            $cipher_method = $this->getAvailableCipherMethod();
-        }
-        // if nothing has been previously validated, then save the currently requested cipher which appears to be good
-        if ($this->validated_cipher_method === null) {
-            $this->validated_cipher_method = $cipher_method;
-        }
-        return $cipher_method;
-    }
-
-
-    /**
-     * returns true if the selected cipher method either uses Galois/Counter Mode (GCM)
-     * or Counter with CBC-MAC (CCM) authenticated encryption modes
-     * (also need to be using PHP 7.1 or greater to actually use authenticated encryption modes)
-     *
-     * @return bool
-     */
-    public function usesAuthenticatedEncryptionMode()
-    {
-        return PHP_VERSION_ID >= 70100
-               && (
-                   stripos($this->validated_cipher_method, 'gcm') !== false
-                   || stripos($this->validated_cipher_method, 'ccm') !== false
-               );
-    }
-
-
-    /**
-     * @param string $cipher_method
-     * @return string
-     * @throws RuntimeException
-     */
-    protected function getAvailableCipherMethod($cipher_method = null)
-    {
-        // if nothing was supplied, the get what we found in the past to work
-        $cipher_method_to_test = $cipher_method ?: get_option($this->cipher_method_option_name, '');
-        // verify that the incoming cipher method exists and can produce an initialization vector
-        if ($this->validateCipherMethod($cipher_method_to_test) === false) {
-            // what? there's no list?
-            if (empty($this->cipher_methods)) {
-                // generate that list and cache it
-                $this->cipher_methods = $this->getAvailableStrongCipherMethods();
-            }
-            // then grab the first item from the list (we'll add it back later if it is good)
-            $cipher_method_to_test = array_shift($this->cipher_methods);
-            if ($cipher_method_to_test === null) {
-                throw new RuntimeException(
-                    esc_html__(
-                        'OpenSSL support appears to be enabled on the server, but no cipher methods are available. Please contact the server administrator.',
-                        'event_espresso'
-                    )
-                );
-            }
-            // verify that the next cipher method works
-            return $this->getAvailableCipherMethod($cipher_method_to_test);
-        }
-        // if we've gotten this far, then we found an available cipher method that works
-        // so save that for next time, if it's not the same as what's there already
-        if ($cipher_method_to_test !== $cipher_method) {
-            update_option($this->cipher_method_option_name, $cipher_method_to_test);
-        }
-        // if we previously removed this cipher method from the list of valid ones, then let's put it back
-        if (! in_array($cipher_method_to_test, $this->cipher_methods, true)) {
-            array_unshift($this->cipher_methods, $cipher_method_to_test);
-        }
-        return $cipher_method_to_test;
-    }
-
-
-    /**
-     * @return array
-     */
-    protected function getAvailableStrongCipherMethods()
-    {
-        return array_filter($this->installed_cipher_methods, [$this, 'weakAlgorithmFilter']);
-    }
-
-
-    /**
-     * @param string $cipher_method
-     * @param false  $throw_exception
-     * @return bool
-     */
-    protected function validateCipherMethod($cipher_method, $throw_exception = false)
-    {
-        // verify that the requested cipher method is actually installed and can produce an initialization vector
-        if (in_array($cipher_method, $this->installed_cipher_methods, true)
-            && openssl_cipher_iv_length($cipher_method) !== false
-        ) {
-            return true;
-        }
-        if (! $throw_exception) {
-            return false;
-        }
-        throw new RuntimeException(
-            sprintf(
-                esc_html__(
-                    'The requested OpenSSL cipher method "%1$s" is invalid or not installed on the server. Please contact the server administrator.',
-                    'event_espresso'
-                ),
-                $cipher_method
-            )
-        );
-    }
-
-
-    /**
-     * @see https://www.php.net/manual/en/function.openssl-get-cipher-methods.php#example-890
-     * @param string $cipher_method
-     */
-    protected function weakAlgorithmFilter($cipher_method)
-    {
-        foreach ($this->weak_algorithms as $weak_algorithm) {
-            if (stripos($cipher_method, $weak_algorithm) !== false) {
-                return false;
-            }
-        }
-        return true;
-    }
+	/**
+	 * @var string
+	 */
+	protected $cipher_method_option_name;
+
+	/**
+	 * list of cipher methods that we consider usable,
+	 * essentially all of the installed_cipher_methods minus weak_algorithms
+	 *
+	 * @var array
+	 */
+	protected $cipher_methods = [];
+
+	/**
+	 * @var string
+	 */
+	protected $default_cipher_method;
+
+	/**
+	 * list of ALL cipher methods available on the server
+	 *
+	 * @var array
+	 */
+	protected $installed_cipher_methods;
+
+	/**
+	 * the OpenSSL cipher method to use. default: AES-128-CBC
+	 *
+	 * @var string
+	 */
+	protected $validated_cipher_method;
+
+	/**
+	 * as early as Aug 2016, Openssl declared the following weak: RC2, RC4, DES, 3DES, MD5 based
+	 * and ECB mode should be avoided
+	 *
+	 * @var array
+	 */
+	protected $weak_algorithms = ['des', 'ecb', 'md5', 'rc2', 'rc4'];
+
+
+	/**
+	 * @param string $default_cipher_method
+	 * @param string $cipher_method_option_name
+	 */
+	public function __construct($default_cipher_method, $cipher_method_option_name)
+	{
+		$this->default_cipher_method     = $default_cipher_method;
+		$this->cipher_method_option_name = $cipher_method_option_name;
+		$this->installed_cipher_methods  = openssl_get_cipher_methods();
+	}
+
+
+	/**
+	 * Returns a cipher method that has been verified to work.
+	 * First checks if the cached cipher has been set already and if so, returns that.
+	 * Then tests the incoming default and returns that if it's good.
+	 * If not, then it retrieves the previously tested and saved cipher method.
+	 * But if that doesn't exist, then calls getAvailableCipherMethod()
+	 * to see what is available on the server, and returns the results.
+	 *
+	 * @param string $cipher_method
+	 * @param bool   $load_alternate [optional] if TRUE, will load the default cipher method (or any strong algorithm)
+	 *                               if the requested cipher method is not installed or invalid.
+	 *                               if FALSE, will throw an exception if the requested cipher method is not valid.
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	public function getCipherMethod($cipher_method = null, $load_alternate = true)
+	{
+		if (empty($cipher_method) && $this->validated_cipher_method !== null) {
+			return $this->validated_cipher_method;
+		}
+		// if nothing specific was requested and it's ok to load an alternate, then grab the system default
+		if (empty($cipher_method) && $load_alternate) {
+			$cipher_method = $this->default_cipher_method;
+		}
+		// verify that the cipher method can produce an initialization vector.
+		// but if the requested is invalid and we don't want to load an alternate, then throw an exception
+		$throw_exception = ! $load_alternate;
+		if ($this->validateCipherMethod($cipher_method, $throw_exception) === false) {
+			// nope? ... ok let's see what we can find
+			$cipher_method = $this->getAvailableCipherMethod();
+		}
+		// if nothing has been previously validated, then save the currently requested cipher which appears to be good
+		if ($this->validated_cipher_method === null) {
+			$this->validated_cipher_method = $cipher_method;
+		}
+		return $cipher_method;
+	}
+
+
+	/**
+	 * returns true if the selected cipher method either uses Galois/Counter Mode (GCM)
+	 * or Counter with CBC-MAC (CCM) authenticated encryption modes
+	 * (also need to be using PHP 7.1 or greater to actually use authenticated encryption modes)
+	 *
+	 * @return bool
+	 */
+	public function usesAuthenticatedEncryptionMode()
+	{
+		return PHP_VERSION_ID >= 70100
+			   && (
+				   stripos($this->validated_cipher_method, 'gcm') !== false
+				   || stripos($this->validated_cipher_method, 'ccm') !== false
+			   );
+	}
+
+
+	/**
+	 * @param string $cipher_method
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	protected function getAvailableCipherMethod($cipher_method = null)
+	{
+		// if nothing was supplied, the get what we found in the past to work
+		$cipher_method_to_test = $cipher_method ?: get_option($this->cipher_method_option_name, '');
+		// verify that the incoming cipher method exists and can produce an initialization vector
+		if ($this->validateCipherMethod($cipher_method_to_test) === false) {
+			// what? there's no list?
+			if (empty($this->cipher_methods)) {
+				// generate that list and cache it
+				$this->cipher_methods = $this->getAvailableStrongCipherMethods();
+			}
+			// then grab the first item from the list (we'll add it back later if it is good)
+			$cipher_method_to_test = array_shift($this->cipher_methods);
+			if ($cipher_method_to_test === null) {
+				throw new RuntimeException(
+					esc_html__(
+						'OpenSSL support appears to be enabled on the server, but no cipher methods are available. Please contact the server administrator.',
+						'event_espresso'
+					)
+				);
+			}
+			// verify that the next cipher method works
+			return $this->getAvailableCipherMethod($cipher_method_to_test);
+		}
+		// if we've gotten this far, then we found an available cipher method that works
+		// so save that for next time, if it's not the same as what's there already
+		if ($cipher_method_to_test !== $cipher_method) {
+			update_option($this->cipher_method_option_name, $cipher_method_to_test);
+		}
+		// if we previously removed this cipher method from the list of valid ones, then let's put it back
+		if (! in_array($cipher_method_to_test, $this->cipher_methods, true)) {
+			array_unshift($this->cipher_methods, $cipher_method_to_test);
+		}
+		return $cipher_method_to_test;
+	}
+
+
+	/**
+	 * @return array
+	 */
+	protected function getAvailableStrongCipherMethods()
+	{
+		return array_filter($this->installed_cipher_methods, [$this, 'weakAlgorithmFilter']);
+	}
+
+
+	/**
+	 * @param string $cipher_method
+	 * @param false  $throw_exception
+	 * @return bool
+	 */
+	protected function validateCipherMethod($cipher_method, $throw_exception = false)
+	{
+		// verify that the requested cipher method is actually installed and can produce an initialization vector
+		if (in_array($cipher_method, $this->installed_cipher_methods, true)
+			&& openssl_cipher_iv_length($cipher_method) !== false
+		) {
+			return true;
+		}
+		if (! $throw_exception) {
+			return false;
+		}
+		throw new RuntimeException(
+			sprintf(
+				esc_html__(
+					'The requested OpenSSL cipher method "%1$s" is invalid or not installed on the server. Please contact the server administrator.',
+					'event_espresso'
+				),
+				$cipher_method
+			)
+		);
+	}
+
+
+	/**
+	 * @see https://www.php.net/manual/en/function.openssl-get-cipher-methods.php#example-890
+	 * @param string $cipher_method
+	 */
+	protected function weakAlgorithmFilter($cipher_method)
+	{
+		foreach ($this->weak_algorithms as $weak_algorithm) {
+			if (stripos($cipher_method, $weak_algorithm) !== false) {
+				return false;
+			}
+		}
+		return true;
+	}
 }