Yoshi2889 / SMF2.1

Sources/Profile-Modify.php

Braces +1 added lines, -1 removed lines

@@ -498,7 +498,7 @@
 						log_error(sprintf($txt['smiley_set_dir_not_found'], $set_names[array_search($set, $context['smiley_sets'])]));
 
 						$context['smiley_sets'] = array_filter($context['smiley_sets'], function($v) use ($set)
-							{
+						{
 								return $v != $set;
 							});
 					}

Sources/random_compat/random_bytes_libsodium.php

Indentation +57 added lines, -57 removed lines

@@ -27,65 +27,65 @@
  */
 
 if (!is_callable('random_bytes')) {
-    /**
-     * If the libsodium PHP extension is loaded, we'll use it above any other
-     * solution.
-     *
-     * libsodium-php project:
-     * @ref https://github.com/jedisct1/libsodium-php
-     *
-     * @param int $bytes
-     *
-     * @throws Exception
-     *
-     * @return string
-     */
-    function random_bytes($bytes)
-    {
-        try {
-            /** @var int $bytes */
-            $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_bytes(): $bytes must be an integer'
-            );
-        }
+	/**
+	 * If the libsodium PHP extension is loaded, we'll use it above any other
+	 * solution.
+	 *
+	 * libsodium-php project:
+	 * @ref https://github.com/jedisct1/libsodium-php
+	 *
+	 * @param int $bytes
+	 *
+	 * @throws Exception
+	 *
+	 * @return string
+	 */
+	function random_bytes($bytes)
+	{
+		try {
+			/** @var int $bytes */
+			$bytes = RandomCompat_intval($bytes);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_bytes(): $bytes must be an integer'
+			);
+		}
 
-        if ($bytes < 1) {
-            throw new Error(
-                'Length must be greater than 0'
-            );
-        }
+		if ($bytes < 1) {
+			throw new Error(
+				'Length must be greater than 0'
+			);
+		}
 
-        /**
-         * \Sodium\randombytes_buf() doesn't allow more than 2147483647 bytes to be
-         * generated in one invocation.
-         */
-        /** @var string|bool $buf */
-        if ($bytes > 2147483647) {
-            $buf = '';
-            for ($i = 0; $i < $bytes; $i += 1073741824) {
-                $n = ($bytes - $i) > 1073741824
-                    ? 1073741824
-                    : $bytes - $i;
-                $buf .= \Sodium\randombytes_buf($n);
-            }
-        } else {
-            /** @var string|bool $buf */
-            $buf = \Sodium\randombytes_buf($bytes);
-        }
+		/**
+		 * \Sodium\randombytes_buf() doesn't allow more than 2147483647 bytes to be
+		 * generated in one invocation.
+		 */
+		/** @var string|bool $buf */
+		if ($bytes > 2147483647) {
+			$buf = '';
+			for ($i = 0; $i < $bytes; $i += 1073741824) {
+				$n = ($bytes - $i) > 1073741824
+					? 1073741824
+					: $bytes - $i;
+				$buf .= \Sodium\randombytes_buf($n);
+			}
+		} else {
+			/** @var string|bool $buf */
+			$buf = \Sodium\randombytes_buf($bytes);
+		}
 
-        if (is_string($buf)) {
-            if (RandomCompat_strlen($buf) === $bytes) {
-                return $buf;
-            }
-        }
+		if (is_string($buf)) {
+			if (RandomCompat_strlen($buf) === $bytes) {
+				return $buf;
+			}
+		}
 
-        /**
-         * If we reach here, PHP has failed us.
-         */
-        throw new Exception(
-            'Could not gather sufficient random data'
-        );
-    }
+		/**
+		 * If we reach here, PHP has failed us.
+		 */
+		throw new Exception(
+			'Could not gather sufficient random data'
+		);
+	}
 }

Braces +20 added lines, -9 removed lines

@@ -26,7 +26,8 @@ 
  * SOFTWARE.
  */
 
-if (!is_callable('random_bytes')) {
+if (!is_callable('random_bytes'))
+{
     /**
      * If the libsodium PHP extension is loaded, we'll use it above any other
      * solution.
@@ -42,16 +43,20 @@ 
      */
     function random_bytes($bytes)
     {
-        try {
+        try
+        {
             /** @var int $bytes */
             $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
+        }
+        catch (TypeError $ex)
+        {
             throw new TypeError(
                 'random_bytes(): $bytes must be an integer'
             );
         }
 
-        if ($bytes < 1) {
+        if ($bytes < 1)
+        {
             throw new Error(
                 'Length must be greater than 0'
             );
@@ -62,21 +67,27 @@ 
          * generated in one invocation.
          */
         /** @var string|bool $buf */
-        if ($bytes > 2147483647) {
+        if ($bytes > 2147483647)
+        {
             $buf = '';
-            for ($i = 0; $i < $bytes; $i += 1073741824) {
+            for ($i = 0; $i < $bytes; $i += 1073741824)
+            {
                 $n = ($bytes - $i) > 1073741824
                     ? 1073741824
                     : $bytes - $i;
                 $buf .= \Sodium\randombytes_buf($n);
             }
-        } else {
+        }
+        else
+        {
             /** @var string|bool $buf */
             $buf = \Sodium\randombytes_buf($bytes);
         }
 
-        if (is_string($buf)) {
-            if (RandomCompat_strlen($buf) === $bytes) {
+        if (is_string($buf))
+        {
+            if (RandomCompat_strlen($buf) === $bytes)
+            {
                 return $buf;
             }
         }

Sources/random_compat/random_bytes_dev_urandom.php

Indentation +130 added lines, -130 removed lines

@@ -27,146 +27,146 @@
  */
 
 if (!defined('RANDOM_COMPAT_READ_BUFFER')) {
-    define('RANDOM_COMPAT_READ_BUFFER', 8);
+	define('RANDOM_COMPAT_READ_BUFFER', 8);
 }
 
 if (!is_callable('random_bytes')) {
-    /**
-     * Unless open_basedir is enabled, use /dev/urandom for
-     * random numbers in accordance with best practices
-     *
-     * Why we use /dev/urandom and not /dev/random
-     * @ref http://sockpuppet.org/blog/2014/02/25/safely-generate-random-numbers
-     *
-     * @param int $bytes
-     *
-     * @throws Exception
-     *
-     * @return string
-     */
-    function random_bytes($bytes)
-    {
-        /** @var resource $fp */
-        static $fp = null;
+	/**
+	 * Unless open_basedir is enabled, use /dev/urandom for
+	 * random numbers in accordance with best practices
+	 *
+	 * Why we use /dev/urandom and not /dev/random
+	 * @ref http://sockpuppet.org/blog/2014/02/25/safely-generate-random-numbers
+	 *
+	 * @param int $bytes
+	 *
+	 * @throws Exception
+	 *
+	 * @return string
+	 */
+	function random_bytes($bytes)
+	{
+		/** @var resource $fp */
+		static $fp = null;
 
-        /**
-         * This block should only be run once
-         */
-        if (empty($fp)) {
-            /**
-             * We use /dev/urandom if it is a char device.
-             * We never fall back to /dev/random
-             */
-            /** @var resource|bool $fp */
-            $fp = fopen('/dev/urandom', 'rb');
-            if (is_resource($fp)) {
-                /** @var array<string, int> $st */
-                $st = fstat($fp);
-                if (($st['mode'] & 0170000) !== 020000) {
-                    fclose($fp);
-                    $fp = false;
-                }
-            }
+		/**
+		 * This block should only be run once
+		 */
+		if (empty($fp)) {
+			/**
+			 * We use /dev/urandom if it is a char device.
+			 * We never fall back to /dev/random
+			 */
+			/** @var resource|bool $fp */
+			$fp = fopen('/dev/urandom', 'rb');
+			if (is_resource($fp)) {
+				/** @var array<string, int> $st */
+				$st = fstat($fp);
+				if (($st['mode'] & 0170000) !== 020000) {
+					fclose($fp);
+					$fp = false;
+				}
+			}
 
-            if (is_resource($fp)) {
-                /**
-                 * stream_set_read_buffer() does not exist in HHVM
-                 *
-                 * If we don't set the stream's read buffer to 0, PHP will
-                 * internally buffer 8192 bytes, which can waste entropy
-                 *
-                 * stream_set_read_buffer returns 0 on success
-                 */
-                if (is_callable('stream_set_read_buffer')) {
-                    stream_set_read_buffer($fp, RANDOM_COMPAT_READ_BUFFER);
-                }
-                if (is_callable('stream_set_chunk_size')) {
-                    stream_set_chunk_size($fp, RANDOM_COMPAT_READ_BUFFER);
-                }
-            }
-        }
+			if (is_resource($fp)) {
+				/**
+				 * stream_set_read_buffer() does not exist in HHVM
+				 *
+				 * If we don't set the stream's read buffer to 0, PHP will
+				 * internally buffer 8192 bytes, which can waste entropy
+				 *
+				 * stream_set_read_buffer returns 0 on success
+				 */
+				if (is_callable('stream_set_read_buffer')) {
+					stream_set_read_buffer($fp, RANDOM_COMPAT_READ_BUFFER);
+				}
+				if (is_callable('stream_set_chunk_size')) {
+					stream_set_chunk_size($fp, RANDOM_COMPAT_READ_BUFFER);
+				}
+			}
+		}
 
-        try {
-            /** @var int $bytes */
-            $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_bytes(): $bytes must be an integer'
-            );
-        }
+		try {
+			/** @var int $bytes */
+			$bytes = RandomCompat_intval($bytes);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_bytes(): $bytes must be an integer'
+			);
+		}
 
-        if ($bytes < 1) {
-            throw new Error(
-                'Length must be greater than 0'
-            );
-        }
+		if ($bytes < 1) {
+			throw new Error(
+				'Length must be greater than 0'
+			);
+		}
 
-        /**
-         * This if() block only runs if we managed to open a file handle
-         *
-         * It does not belong in an else {} block, because the above
-         * if (empty($fp)) line is logic that should only be run once per
-         * page load.
-         */
-        if (is_resource($fp)) {
-            /**
-             * @var int
-             */
-            $remaining = $bytes;
+		/**
+		 * This if() block only runs if we managed to open a file handle
+		 *
+		 * It does not belong in an else {} block, because the above
+		 * if (empty($fp)) line is logic that should only be run once per
+		 * page load.
+		 */
+		if (is_resource($fp)) {
+			/**
+			 * @var int
+			 */
+			$remaining = $bytes;
 
-            /**
-             * @var string|bool
-             */
-            $buf = '';
+			/**
+			 * @var string|bool
+			 */
+			$buf = '';
 
-            /**
-             * We use fread() in a loop to protect against partial reads
-             */
-            do {
-                /**
-                 * @var string|bool
-                 */
-                $read = fread($fp, $remaining);
-                if (!is_string($read)) {
-                    if ($read === false) {
-                        /**
-                         * We cannot safely read from the file. Exit the
-                         * do-while loop and trigger the exception condition
-                         *
-                         * @var string|bool
-                         */
-                        $buf = false;
-                        break;
-                    }
-                }
-                /**
-                 * Decrease the number of bytes returned from remaining
-                 */
-                $remaining -= RandomCompat_strlen($read);
-                /**
-                 * @var string|bool
-                 */
-                $buf = $buf . $read;
-            } while ($remaining > 0);
+			/**
+			 * We use fread() in a loop to protect against partial reads
+			 */
+			do {
+				/**
+				 * @var string|bool
+				 */
+				$read = fread($fp, $remaining);
+				if (!is_string($read)) {
+					if ($read === false) {
+						/**
+						 * We cannot safely read from the file. Exit the
+						 * do-while loop and trigger the exception condition
+						 *
+						 * @var string|bool
+						 */
+						$buf = false;
+						break;
+					}
+				}
+				/**
+				 * Decrease the number of bytes returned from remaining
+				 */
+				$remaining -= RandomCompat_strlen($read);
+				/**
+				 * @var string|bool
+				 */
+				$buf = $buf . $read;
+			} while ($remaining > 0);
 
-            /**
-             * Is our result valid?
-             */
-            if (is_string($buf)) {
-                if (RandomCompat_strlen($buf) === $bytes) {
-                    /**
-                     * Return our random entropy buffer here:
-                     */
-                    return $buf;
-                }
-            }
-        }
+			/**
+			 * Is our result valid?
+			 */
+			if (is_string($buf)) {
+				if (RandomCompat_strlen($buf) === $bytes) {
+					/**
+					 * Return our random entropy buffer here:
+					 */
+					return $buf;
+				}
+			}
+		}
 
-        /**
-         * If we reach here, PHP has failed us.
-         */
-        throw new Exception(
-            'Error reading from source device'
-        );
-    }
+		/**
+		 * If we reach here, PHP has failed us.
+		 */
+		throw new Exception(
+			'Error reading from source device'
+		);
+	}
 }

Braces +33 added lines, -16 removed lines

@@ -26,11 +26,13 @@ 
  * SOFTWARE.
  */
 
-if (!defined('RANDOM_COMPAT_READ_BUFFER')) {
+if (!defined('RANDOM_COMPAT_READ_BUFFER'))
+{
     define('RANDOM_COMPAT_READ_BUFFER', 8);
 }
 
-if (!is_callable('random_bytes')) {
+if (!is_callable('random_bytes'))
+{
     /**
      * Unless open_basedir is enabled, use /dev/urandom for
      * random numbers in accordance with best practices
@@ -52,23 +54,27 @@ 
         /**
          * This block should only be run once
          */
-        if (empty($fp)) {
+        if (empty($fp))
+        {
             /**
              * We use /dev/urandom if it is a char device.
              * We never fall back to /dev/random
              */
             /** @var resource|bool $fp */
             $fp = fopen('/dev/urandom', 'rb');
-            if (is_resource($fp)) {
+            if (is_resource($fp))
+            {
                 /** @var array<string, int> $st */
                 $st = fstat($fp);
-                if (($st['mode'] & 0170000) !== 020000) {
+                if (($st['mode'] & 0170000) !== 020000)
+                {
                     fclose($fp);
                     $fp = false;
                 }
             }
 
-            if (is_resource($fp)) {
+            if (is_resource($fp))
+            {
                 /**
                  * stream_set_read_buffer() does not exist in HHVM
                  *
@@ -77,25 +83,31 @@ 
                  *
                  * stream_set_read_buffer returns 0 on success
                  */
-                if (is_callable('stream_set_read_buffer')) {
+                if (is_callable('stream_set_read_buffer'))
+                {
                     stream_set_read_buffer($fp, RANDOM_COMPAT_READ_BUFFER);
                 }
-                if (is_callable('stream_set_chunk_size')) {
+                if (is_callable('stream_set_chunk_size'))
+                {
                     stream_set_chunk_size($fp, RANDOM_COMPAT_READ_BUFFER);
                 }
             }
         }
 
-        try {
+        try
+        {
             /** @var int $bytes */
             $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
+        }
+        catch (TypeError $ex)
+        {
             throw new TypeError(
                 'random_bytes(): $bytes must be an integer'
             );
         }
 
-        if ($bytes < 1) {
+        if ($bytes < 1)
+        {
             throw new Error(
                 'Length must be greater than 0'
             );
@@ -108,7 +120,8 @@ 
          * if (empty($fp)) line is logic that should only be run once per
          * page load.
          */
-        if (is_resource($fp)) {
+        if (is_resource($fp))
+        {
             /**
              * @var int
              */
@@ -127,8 +140,10 @@ 
                  * @var string|bool
                  */
                 $read = fread($fp, $remaining);
-                if (!is_string($read)) {
-                    if ($read === false) {
+                if (!is_string($read))
+                {
+                    if ($read === false)
+                    {
                         /**
                          * We cannot safely read from the file. Exit the
                          * do-while loop and trigger the exception condition
@@ -152,8 +167,10 @@ 
             /**
              * Is our result valid?
              */
-            if (is_string($buf)) {
-                if (RandomCompat_strlen($buf) === $bytes) {
+            if (is_string($buf))
+            {
+                if (RandomCompat_strlen($buf) === $bytes)
+                {
                     /**
                      * Return our random entropy buffer here:
                      */

Sources/random_compat/byte_safe_strings.php

Indentation +149 added lines, -149 removed lines

@@ -27,169 +27,169 @@
  */
 
 if (!is_callable('RandomCompat_strlen')) {
-    if (
-        defined('MB_OVERLOAD_STRING')
-            &&
-        ((int) ini_get('mbstring.func_overload')) & MB_OVERLOAD_STRING
-    ) {
-        /**
-         * strlen() implementation that isn't brittle to mbstring.func_overload
-         *
-         * This version uses mb_strlen() in '8bit' mode to treat strings as raw
-         * binary rather than UTF-8, ISO-8859-1, etc
-         *
-         * @param string $binary_string
-         *
-         * @throws TypeError
-         *
-         * @return int
-         */
-        function RandomCompat_strlen($binary_string)
-        {
-            if (!is_string($binary_string)) {
-                throw new TypeError(
-                    'RandomCompat_strlen() expects a string'
-                );
-            }
+	if (
+		defined('MB_OVERLOAD_STRING')
+			&&
+		((int) ini_get('mbstring.func_overload')) & MB_OVERLOAD_STRING
+	) {
+		/**
+		 * strlen() implementation that isn't brittle to mbstring.func_overload
+		 *
+		 * This version uses mb_strlen() in '8bit' mode to treat strings as raw
+		 * binary rather than UTF-8, ISO-8859-1, etc
+		 *
+		 * @param string $binary_string
+		 *
+		 * @throws TypeError
+		 *
+		 * @return int
+		 */
+		function RandomCompat_strlen($binary_string)
+		{
+			if (!is_string($binary_string)) {
+				throw new TypeError(
+					'RandomCompat_strlen() expects a string'
+				);
+			}
 
-            return (int) mb_strlen($binary_string, '8bit');
-        }
+			return (int) mb_strlen($binary_string, '8bit');
+		}
 
-    } else {
-        /**
-         * strlen() implementation that isn't brittle to mbstring.func_overload
-         *
-         * This version just used the default strlen()
-         *
-         * @param string $binary_string
-         *
-         * @throws TypeError
-         *
-         * @return int
-         */
-        function RandomCompat_strlen($binary_string)
-        {
-            if (!is_string($binary_string)) {
-                throw new TypeError(
-                    'RandomCompat_strlen() expects a string'
-                );
-            }
-            return (int) strlen($binary_string);
-        }
-    }
+	} else {
+		/**
+		 * strlen() implementation that isn't brittle to mbstring.func_overload
+		 *
+		 * This version just used the default strlen()
+		 *
+		 * @param string $binary_string
+		 *
+		 * @throws TypeError
+		 *
+		 * @return int
+		 */
+		function RandomCompat_strlen($binary_string)
+		{
+			if (!is_string($binary_string)) {
+				throw new TypeError(
+					'RandomCompat_strlen() expects a string'
+				);
+			}
+			return (int) strlen($binary_string);
+		}
+	}
 }
 
 if (!is_callable('RandomCompat_substr')) {
 
-    if (
-        defined('MB_OVERLOAD_STRING')
-            &&
-        ((int) ini_get('mbstring.func_overload')) & MB_OVERLOAD_STRING
-    ) {
-        /**
-         * substr() implementation that isn't brittle to mbstring.func_overload
-         *
-         * This version uses mb_substr() in '8bit' mode to treat strings as raw
-         * binary rather than UTF-8, ISO-8859-1, etc
-         *
-         * @param string $binary_string
-         * @param int $start
-         * @param int|null $length (optional)
-         *
-         * @throws TypeError
-         *
-         * @return string
-         */
-        function RandomCompat_substr($binary_string, $start, $length = null)
-        {
-            if (!is_string($binary_string)) {
-                throw new TypeError(
-                    'RandomCompat_substr(): First argument should be a string'
-                );
-            }
+	if (
+		defined('MB_OVERLOAD_STRING')
+			&&
+		((int) ini_get('mbstring.func_overload')) & MB_OVERLOAD_STRING
+	) {
+		/**
+		 * substr() implementation that isn't brittle to mbstring.func_overload
+		 *
+		 * This version uses mb_substr() in '8bit' mode to treat strings as raw
+		 * binary rather than UTF-8, ISO-8859-1, etc
+		 *
+		 * @param string $binary_string
+		 * @param int $start
+		 * @param int|null $length (optional)
+		 *
+		 * @throws TypeError
+		 *
+		 * @return string
+		 */
+		function RandomCompat_substr($binary_string, $start, $length = null)
+		{
+			if (!is_string($binary_string)) {
+				throw new TypeError(
+					'RandomCompat_substr(): First argument should be a string'
+				);
+			}
 
-            if (!is_int($start)) {
-                throw new TypeError(
-                    'RandomCompat_substr(): Second argument should be an integer'
-                );
-            }
+			if (!is_int($start)) {
+				throw new TypeError(
+					'RandomCompat_substr(): Second argument should be an integer'
+				);
+			}
 
-            if ($length === null) {
-                /**
-                 * mb_substr($str, 0, NULL, '8bit') returns an empty string on
-                 * PHP 5.3, so we have to find the length ourselves.
-                 */
-                /** @var int $length */
-                $length = RandomCompat_strlen($binary_string) - $start;
-            } elseif (!is_int($length)) {
-                throw new TypeError(
-                    'RandomCompat_substr(): Third argument should be an integer, or omitted'
-                );
-            }
+			if ($length === null) {
+				/**
+				 * mb_substr($str, 0, NULL, '8bit') returns an empty string on
+				 * PHP 5.3, so we have to find the length ourselves.
+				 */
+				/** @var int $length */
+				$length = RandomCompat_strlen($binary_string) - $start;
+			} elseif (!is_int($length)) {
+				throw new TypeError(
+					'RandomCompat_substr(): Third argument should be an integer, or omitted'
+				);
+			}
 
-            // Consistency with PHP's behavior
-            if ($start === RandomCompat_strlen($binary_string) && $length === 0) {
-                return '';
-            }
-            if ($start > RandomCompat_strlen($binary_string)) {
-                return '';
-            }
+			// Consistency with PHP's behavior
+			if ($start === RandomCompat_strlen($binary_string) && $length === 0) {
+				return '';
+			}
+			if ($start > RandomCompat_strlen($binary_string)) {
+				return '';
+			}
 
-            return (string) mb_substr(
-                (string) $binary_string,
-                (int) $start,
-                (int) $length,
-                '8bit'
-            );
-        }
+			return (string) mb_substr(
+				(string) $binary_string,
+				(int) $start,
+				(int) $length,
+				'8bit'
+			);
+		}
 
-    } else {
+	} else {
 
-        /**
-         * substr() implementation that isn't brittle to mbstring.func_overload
-         *
-         * This version just uses the default substr()
-         *
-         * @param string $binary_string
-         * @param int $start
-         * @param int|null $length (optional)
-         *
-         * @throws TypeError
-         *
-         * @return string
-         */
-        function RandomCompat_substr($binary_string, $start, $length = null)
-        {
-            if (!is_string($binary_string)) {
-                throw new TypeError(
-                    'RandomCompat_substr(): First argument should be a string'
-                );
-            }
+		/**
+		 * substr() implementation that isn't brittle to mbstring.func_overload
+		 *
+		 * This version just uses the default substr()
+		 *
+		 * @param string $binary_string
+		 * @param int $start
+		 * @param int|null $length (optional)
+		 *
+		 * @throws TypeError
+		 *
+		 * @return string
+		 */
+		function RandomCompat_substr($binary_string, $start, $length = null)
+		{
+			if (!is_string($binary_string)) {
+				throw new TypeError(
+					'RandomCompat_substr(): First argument should be a string'
+				);
+			}
 
-            if (!is_int($start)) {
-                throw new TypeError(
-                    'RandomCompat_substr(): Second argument should be an integer'
-                );
-            }
+			if (!is_int($start)) {
+				throw new TypeError(
+					'RandomCompat_substr(): Second argument should be an integer'
+				);
+			}
 
-            if ($length !== null) {
-                if (!is_int($length)) {
-                    throw new TypeError(
-                        'RandomCompat_substr(): Third argument should be an integer, or omitted'
-                    );
-                }
+			if ($length !== null) {
+				if (!is_int($length)) {
+					throw new TypeError(
+						'RandomCompat_substr(): Third argument should be an integer, or omitted'
+					);
+				}
 
-                return (string) substr(
-                    (string )$binary_string,
-                    (int) $start,
-                    (int) $length
-                );
-            }
+				return (string) substr(
+					(string )$binary_string,
+					(int) $start,
+					(int) $length
+				);
+			}
 
-            return (string) substr(
-                (string) $binary_string,
-                (int) $start
-            );
-        }
-    }
+			return (string) substr(
+				(string) $binary_string,
+				(int) $start
+			);
+		}
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -180,7 +180,7 @@
                 }
 
                 return (string) substr(
-                    (string )$binary_string,
+                    (string) $binary_string,
                     (int) $start,
                     (int) $length
                 );

Braces +35 added lines, -16 removed lines

@@ -26,7 +26,8 @@ 
  * SOFTWARE.
  */
 
-if (!is_callable('RandomCompat_strlen')) {
+if (!is_callable('RandomCompat_strlen'))
+{
     if (
         defined('MB_OVERLOAD_STRING')
             &&
@@ -46,7 +47,8 @@ 
          */
         function RandomCompat_strlen($binary_string)
         {
-            if (!is_string($binary_string)) {
+            if (!is_string($binary_string))
+            {
                 throw new TypeError(
                     'RandomCompat_strlen() expects a string'
                 );
@@ -55,7 +57,9 @@ 
             return (int) mb_strlen($binary_string, '8bit');
         }
 
-    } else {
+    }
+    else
+    {
         /**
          * strlen() implementation that isn't brittle to mbstring.func_overload
          *
@@ -69,7 +73,8 @@ 
          */
         function RandomCompat_strlen($binary_string)
         {
-            if (!is_string($binary_string)) {
+            if (!is_string($binary_string))
+            {
                 throw new TypeError(
                     'RandomCompat_strlen() expects a string'
                 );
@@ -79,7 +84,8 @@ 
     }
 }
 
-if (!is_callable('RandomCompat_substr')) {
+if (!is_callable('RandomCompat_substr'))
+{
 
     if (
         defined('MB_OVERLOAD_STRING')
@@ -102,36 +108,43 @@ 
          */
         function RandomCompat_substr($binary_string, $start, $length = null)
         {
-            if (!is_string($binary_string)) {
+            if (!is_string($binary_string))
+            {
                 throw new TypeError(
                     'RandomCompat_substr(): First argument should be a string'
                 );
             }
 
-            if (!is_int($start)) {
+            if (!is_int($start))
+            {
                 throw new TypeError(
                     'RandomCompat_substr(): Second argument should be an integer'
                 );
             }
 
-            if ($length === null) {
+            if ($length === null)
+            {
                 /**
                  * mb_substr($str, 0, NULL, '8bit') returns an empty string on
                  * PHP 5.3, so we have to find the length ourselves.
                  */
                 /** @var int $length */
                 $length = RandomCompat_strlen($binary_string) - $start;
-            } elseif (!is_int($length)) {
+            }
+            elseif (!is_int($length))
+            {
                 throw new TypeError(
                     'RandomCompat_substr(): Third argument should be an integer, or omitted'
                 );
             }
 
             // Consistency with PHP's behavior
-            if ($start === RandomCompat_strlen($binary_string) && $length === 0) {
+            if ($start === RandomCompat_strlen($binary_string) && $length === 0)
+            {
                 return '';
             }
-            if ($start > RandomCompat_strlen($binary_string)) {
+            if ($start > RandomCompat_strlen($binary_string))
+            {
                 return '';
             }
 
@@ -143,7 +156,9 @@ 
             );
         }
 
-    } else {
+    }
+    else
+    {
 
         /**
          * substr() implementation that isn't brittle to mbstring.func_overload
@@ -160,20 +175,24 @@ 
          */
         function RandomCompat_substr($binary_string, $start, $length = null)
         {
-            if (!is_string($binary_string)) {
+            if (!is_string($binary_string))
+            {
                 throw new TypeError(
                     'RandomCompat_substr(): First argument should be a string'
                 );
             }
 
-            if (!is_int($start)) {
+            if (!is_int($start))
+            {
                 throw new TypeError(
                     'RandomCompat_substr(): Second argument should be an integer'
                 );
             }
 
-            if ($length !== null) {
-                if (!is_int($length)) {
+            if ($length !== null)
+            {
+                if (!is_int($length))
+                {
                     throw new TypeError(
                         'RandomCompat_substr(): Third argument should be an integer, or omitted'
                     );

Sources/random_compat/random_bytes_mcrypt.php

Indentation +46 added lines, -46 removed lines

@@ -27,53 +27,53 @@
  */
 
 if (!is_callable('random_bytes')) {
-    /**
-     * Powered by ext/mcrypt (and thankfully NOT libmcrypt)
-     *
-     * @ref https://bugs.php.net/bug.php?id=55169
-     * @ref https://github.com/php/php-src/blob/c568ffe5171d942161fc8dda066bce844bdef676/ext/mcrypt/mcrypt.c#L1321-L1386
-     *
-     * @param int $bytes
-     *
-     * @throws Exception
-     *
-     * @return string
-     */
-    function random_bytes($bytes)
-    {
-        try {
-            /** @var int $bytes */
-            $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_bytes(): $bytes must be an integer'
-            );
-        }
+	/**
+	 * Powered by ext/mcrypt (and thankfully NOT libmcrypt)
+	 *
+	 * @ref https://bugs.php.net/bug.php?id=55169
+	 * @ref https://github.com/php/php-src/blob/c568ffe5171d942161fc8dda066bce844bdef676/ext/mcrypt/mcrypt.c#L1321-L1386
+	 *
+	 * @param int $bytes
+	 *
+	 * @throws Exception
+	 *
+	 * @return string
+	 */
+	function random_bytes($bytes)
+	{
+		try {
+			/** @var int $bytes */
+			$bytes = RandomCompat_intval($bytes);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_bytes(): $bytes must be an integer'
+			);
+		}
 
-        if ($bytes < 1) {
-            throw new Error(
-                'Length must be greater than 0'
-            );
-        }
+		if ($bytes < 1) {
+			throw new Error(
+				'Length must be greater than 0'
+			);
+		}
 
-        /** @var string|bool $buf */
-        $buf = @mcrypt_create_iv((int) $bytes, (int) MCRYPT_DEV_URANDOM);
-        if (
-            is_string($buf)
-                &&
-            RandomCompat_strlen($buf) === $bytes
-        ) {
-            /**
-             * Return our random entropy buffer here:
-             */
-            return $buf;
-        }
+		/** @var string|bool $buf */
+		$buf = @mcrypt_create_iv((int) $bytes, (int) MCRYPT_DEV_URANDOM);
+		if (
+			is_string($buf)
+				&&
+			RandomCompat_strlen($buf) === $bytes
+		) {
+			/**
+			 * Return our random entropy buffer here:
+			 */
+			return $buf;
+		}
 
-        /**
-         * If we reach here, PHP has failed us.
-         */
-        throw new Exception(
-            'Could not gather sufficient random data'
-        );
-    }
+		/**
+		 * If we reach here, PHP has failed us.
+		 */
+		throw new Exception(
+			'Could not gather sufficient random data'
+		);
+	}
 }

Braces +9 added lines, -4 removed lines

@@ -26,7 +26,8 @@ 
  * SOFTWARE.
  */
 
-if (!is_callable('random_bytes')) {
+if (!is_callable('random_bytes'))
+{
     /**
      * Powered by ext/mcrypt (and thankfully NOT libmcrypt)
      *
@@ -41,16 +42,20 @@ 
      */
     function random_bytes($bytes)
     {
-        try {
+        try
+        {
             /** @var int $bytes */
             $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
+        }
+        catch (TypeError $ex)
+        {
             throw new TypeError(
                 'random_bytes(): $bytes must be an integer'
             );
         }
 
-        if ($bytes < 1) {
+        if ($bytes < 1)
+        {
             throw new Error(
                 'Length must be greater than 0'
             );

Sources/random_compat/random_bytes_com_dotnet.php

Indentation +57 added lines, -57 removed lines

@@ -27,65 +27,65 @@
  */
 
 if (!is_callable('random_bytes')) {
-    /**
-     * Windows with PHP < 5.3.0 will not have the function
-     * openssl_random_pseudo_bytes() available, so let's use
-     * CAPICOM to work around this deficiency.
-     *
-     * @param int $bytes
-     *
-     * @throws Exception
-     *
-     * @return string
-     */
-    function random_bytes($bytes)
-    {
-        try {
-            /** @var int $bytes */
-            $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_bytes(): $bytes must be an integer'
-            );
-        }
+	/**
+	 * Windows with PHP < 5.3.0 will not have the function
+	 * openssl_random_pseudo_bytes() available, so let's use
+	 * CAPICOM to work around this deficiency.
+	 *
+	 * @param int $bytes
+	 *
+	 * @throws Exception
+	 *
+	 * @return string
+	 */
+	function random_bytes($bytes)
+	{
+		try {
+			/** @var int $bytes */
+			$bytes = RandomCompat_intval($bytes);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_bytes(): $bytes must be an integer'
+			);
+		}
 
-        if ($bytes < 1) {
-            throw new Error(
-                'Length must be greater than 0'
-            );
-        }
+		if ($bytes < 1) {
+			throw new Error(
+				'Length must be greater than 0'
+			);
+		}
 
-        /** @var string $buf */
-        $buf = '';
-        if (!class_exists('COM')) {
-            throw new Error(
-                'COM does not exist'
-            );
-        }
-        /** @var COM $util */
-        $util = new COM('CAPICOM.Utilities.1');
-        $execCount = 0;
+		/** @var string $buf */
+		$buf = '';
+		if (!class_exists('COM')) {
+			throw new Error(
+				'COM does not exist'
+			);
+		}
+		/** @var COM $util */
+		$util = new COM('CAPICOM.Utilities.1');
+		$execCount = 0;
 
-        /**
-         * Let's not let it loop forever. If we run N times and fail to
-         * get N bytes of random data, then CAPICOM has failed us.
-         */
-        do {
-            $buf .= base64_decode((string) $util->GetRandom($bytes, 0));
-            if (RandomCompat_strlen($buf) >= $bytes) {
-                /**
-                 * Return our random entropy buffer here:
-                 */
-                return (string) RandomCompat_substr($buf, 0, $bytes);
-            }
-            ++$execCount;
-        } while ($execCount < $bytes);
+		/**
+		 * Let's not let it loop forever. If we run N times and fail to
+		 * get N bytes of random data, then CAPICOM has failed us.
+		 */
+		do {
+			$buf .= base64_decode((string) $util->GetRandom($bytes, 0));
+			if (RandomCompat_strlen($buf) >= $bytes) {
+				/**
+				 * Return our random entropy buffer here:
+				 */
+				return (string) RandomCompat_substr($buf, 0, $bytes);
+			}
+			++$execCount;
+		} while ($execCount < $bytes);
 
-        /**
-         * If we reach here, PHP has failed us.
-         */
-        throw new Exception(
-            'Could not gather sufficient random data'
-        );
-    }
+		/**
+		 * If we reach here, PHP has failed us.
+		 */
+		throw new Exception(
+			'Could not gather sufficient random data'
+		);
+	}
 }
\ No newline at end of file

Braces +13 added lines, -6 removed lines

@@ -26,7 +26,8 @@ 
  * SOFTWARE.
  */
 
-if (!is_callable('random_bytes')) {
+if (!is_callable('random_bytes'))
+{
     /**
      * Windows with PHP < 5.3.0 will not have the function
      * openssl_random_pseudo_bytes() available, so let's use
@@ -40,16 +41,20 @@ 
      */
     function random_bytes($bytes)
     {
-        try {
+        try
+        {
             /** @var int $bytes */
             $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
+        }
+        catch (TypeError $ex)
+        {
             throw new TypeError(
                 'random_bytes(): $bytes must be an integer'
             );
         }
 
-        if ($bytes < 1) {
+        if ($bytes < 1)
+        {
             throw new Error(
                 'Length must be greater than 0'
             );
@@ -57,7 +62,8 @@ 
 
         /** @var string $buf */
         $buf = '';
-        if (!class_exists('COM')) {
+        if (!class_exists('COM'))
+        {
             throw new Error(
                 'COM does not exist'
             );
@@ -72,7 +78,8 @@ 
          */
         do {
             $buf .= base64_decode((string) $util->GetRandom($bytes, 0));
-            if (RandomCompat_strlen($buf) >= $bytes) {
+            if (RandomCompat_strlen($buf) >= $bytes)
+            {
                 /**
                  * Return our random entropy buffer here:
                  */

Sources/random_compat/random_int.php

Indentation +200 added lines, -200 removed lines

@@ -1,204 +1,204 @@
 <?php
 
 if (!is_callable('random_int')) {
-    /**
-     * Random_* Compatibility Library
-     * for using the new PHP 7 random_* API in PHP 5 projects
-     *
-     * The MIT License (MIT)
-     *
-     * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
-     *
-     * Permission is hereby granted, free of charge, to any person obtaining a copy
-     * of this software and associated documentation files (the "Software"), to deal
-     * in the Software without restriction, including without limitation the rights
-     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-     * copies of the Software, and to permit persons to whom the Software is
-     * furnished to do so, subject to the following conditions:
-     *
-     * The above copyright notice and this permission notice shall be included in
-     * all copies or substantial portions of the Software.
-     *
-     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-     * SOFTWARE.
-     */
-
-    /**
-     * Fetch a random integer between $min and $max inclusive
-     *
-     * @param int $min
-     * @param int $max
-     *
-     * @throws Exception
-     *
-     * @return int
-     */
-    function random_int($min, $max)
-    {
-        /**
-         * Type and input logic checks
-         *
-         * If you pass it a float in the range (~PHP_INT_MAX, PHP_INT_MAX)
-         * (non-inclusive), it will sanely cast it to an int. If you it's equal to
-         * ~PHP_INT_MAX or PHP_INT_MAX, we let it fail as not an integer. Floats
-         * lose precision, so the <= and => operators might accidentally let a float
-         * through.
-         */
-
-        try {
-            /** @var int $min */
-            $min = RandomCompat_intval($min);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_int(): $min must be an integer'
-            );
-        }
-
-        try {
-            /** @var int $max */
-            $max = RandomCompat_intval($max);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_int(): $max must be an integer'
-            );
-        }
-
-        /**
-         * Now that we've verified our weak typing system has given us an integer,
-         * let's validate the logic then we can move forward with generating random
-         * integers along a given range.
-         */
-        if ($min > $max) {
-            throw new Error(
-                'Minimum value must be less than or equal to the maximum value'
-            );
-        }
-
-        if ($max === $min) {
-            return (int) $min;
-        }
-
-        /**
-         * Initialize variables to 0
-         *
-         * We want to store:
-         * $bytes => the number of random bytes we need
-         * $mask => an integer bitmask (for use with the &) operator
-         *          so we can minimize the number of discards
-         */
-        $attempts = $bits = $bytes = $mask = $valueShift = 0;
-        /** @var int $attempts */
-        /** @var int $bits */
-        /** @var int $bytes */
-        /** @var int $mask */
-        /** @var int $valueShift */
-
-        /**
-         * At this point, $range is a positive number greater than 0. It might
-         * overflow, however, if $max - $min > PHP_INT_MAX. PHP will cast it to
-         * a float and we will lose some precision.
-         *
-         * @var int|float $range
-         */
-        $range = $max - $min;
-
-        /**
-         * Test for integer overflow:
-         */
-        if (!is_int($range)) {
-
-            /**
-             * Still safely calculate wider ranges.
-             * Provided by @CodesInChaos, @oittaa
-             *
-             * @ref https://gist.github.com/CodesInChaos/03f9ea0b58e8b2b8d435
-             *
-             * We use ~0 as a mask in this case because it generates all 1s
-             *
-             * @ref https://eval.in/400356 (32-bit)
-             * @ref http://3v4l.org/XX9r5  (64-bit)
-             */
-            $bytes = PHP_INT_SIZE;
-            /** @var int $mask */
-            $mask = ~0;
-
-        } else {
-
-            /**
-             * $bits is effectively ceil(log($range, 2)) without dealing with
-             * type juggling
-             */
-            while ($range > 0) {
-                if ($bits % 8 === 0) {
-                    ++$bytes;
-                }
-                ++$bits;
-                $range >>= 1;
-                /** @var int $mask */
-                $mask = $mask << 1 | 1;
-            }
-            $valueShift = $min;
-        }
-
-        /** @var int $val */
-        $val = 0;
-        /**
-         * Now that we have our parameters set up, let's begin generating
-         * random integers until one falls between $min and $max
-         */
-        /** @psalm-suppress RedundantCondition */
-        do {
-            /**
-             * The rejection probability is at most 0.5, so this corresponds
-             * to a failure probability of 2^-128 for a working RNG
-             */
-            if ($attempts > 128) {
-                throw new Exception(
-                    'random_int: RNG is broken - too many rejections'
-                );
-            }
-
-            /**
-             * Let's grab the necessary number of random bytes
-             */
-            $randomByteString = random_bytes($bytes);
-
-            /**
-             * Let's turn $randomByteString into an integer
-             *
-             * This uses bitwise operators (<< and |) to build an integer
-             * out of the values extracted from ord()
-             *
-             * Example: [9F] | [6D] | [32] | [0C] =>
-             *   159 + 27904 + 3276800 + 201326592 =>
-             *   204631455
-             */
-            $val &= 0;
-            for ($i = 0; $i < $bytes; ++$i) {
-                $val |= ord($randomByteString[$i]) << ($i * 8);
-            }
-            /** @var int $val */
-
-            /**
-             * Apply mask
-             */
-            $val &= $mask;
-            $val += $valueShift;
-
-            ++$attempts;
-            /**
-             * If $val overflows to a floating point number,
-             * ... or is larger than $max,
-             * ... or smaller than $min,
-             * then try again.
-             */
-        } while (!is_int($val) || $val > $max || $val < $min);
-
-        return (int) $val;
-    }
+	/**
+	 * Random_* Compatibility Library
+	 * for using the new PHP 7 random_* API in PHP 5 projects
+	 *
+	 * The MIT License (MIT)
+	 *
+	 * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
+	 *
+	 * Permission is hereby granted, free of charge, to any person obtaining a copy
+	 * of this software and associated documentation files (the "Software"), to deal
+	 * in the Software without restriction, including without limitation the rights
+	 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+	 * copies of the Software, and to permit persons to whom the Software is
+	 * furnished to do so, subject to the following conditions:
+	 *
+	 * The above copyright notice and this permission notice shall be included in
+	 * all copies or substantial portions of the Software.
+	 *
+	 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+	 * SOFTWARE.
+	 */
+
+	/**
+	 * Fetch a random integer between $min and $max inclusive
+	 *
+	 * @param int $min
+	 * @param int $max
+	 *
+	 * @throws Exception
+	 *
+	 * @return int
+	 */
+	function random_int($min, $max)
+	{
+		/**
+		 * Type and input logic checks
+		 *
+		 * If you pass it a float in the range (~PHP_INT_MAX, PHP_INT_MAX)
+		 * (non-inclusive), it will sanely cast it to an int. If you it's equal to
+		 * ~PHP_INT_MAX or PHP_INT_MAX, we let it fail as not an integer. Floats
+		 * lose precision, so the <= and => operators might accidentally let a float
+		 * through.
+		 */
+
+		try {
+			/** @var int $min */
+			$min = RandomCompat_intval($min);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_int(): $min must be an integer'
+			);
+		}
+
+		try {
+			/** @var int $max */
+			$max = RandomCompat_intval($max);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_int(): $max must be an integer'
+			);
+		}
+
+		/**
+		 * Now that we've verified our weak typing system has given us an integer,
+		 * let's validate the logic then we can move forward with generating random
+		 * integers along a given range.
+		 */
+		if ($min > $max) {
+			throw new Error(
+				'Minimum value must be less than or equal to the maximum value'
+			);
+		}
+
+		if ($max === $min) {
+			return (int) $min;
+		}
+
+		/**
+		 * Initialize variables to 0
+		 *
+		 * We want to store:
+		 * $bytes => the number of random bytes we need
+		 * $mask => an integer bitmask (for use with the &) operator
+		 *          so we can minimize the number of discards
+		 */
+		$attempts = $bits = $bytes = $mask = $valueShift = 0;
+		/** @var int $attempts */
+		/** @var int $bits */
+		/** @var int $bytes */
+		/** @var int $mask */
+		/** @var int $valueShift */
+
+		/**
+		 * At this point, $range is a positive number greater than 0. It might
+		 * overflow, however, if $max - $min > PHP_INT_MAX. PHP will cast it to
+		 * a float and we will lose some precision.
+		 *
+		 * @var int|float $range
+		 */
+		$range = $max - $min;
+
+		/**
+		 * Test for integer overflow:
+		 */
+		if (!is_int($range)) {
+
+			/**
+			 * Still safely calculate wider ranges.
+			 * Provided by @CodesInChaos, @oittaa
+			 *
+			 * @ref https://gist.github.com/CodesInChaos/03f9ea0b58e8b2b8d435
+			 *
+			 * We use ~0 as a mask in this case because it generates all 1s
+			 *
+			 * @ref https://eval.in/400356 (32-bit)
+			 * @ref http://3v4l.org/XX9r5  (64-bit)
+			 */
+			$bytes = PHP_INT_SIZE;
+			/** @var int $mask */
+			$mask = ~0;
+
+		} else {
+
+			/**
+			 * $bits is effectively ceil(log($range, 2)) without dealing with
+			 * type juggling
+			 */
+			while ($range > 0) {
+				if ($bits % 8 === 0) {
+					++$bytes;
+				}
+				++$bits;
+				$range >>= 1;
+				/** @var int $mask */
+				$mask = $mask << 1 | 1;
+			}
+			$valueShift = $min;
+		}
+
+		/** @var int $val */
+		$val = 0;
+		/**
+		 * Now that we have our parameters set up, let's begin generating
+		 * random integers until one falls between $min and $max
+		 */
+		/** @psalm-suppress RedundantCondition */
+		do {
+			/**
+			 * The rejection probability is at most 0.5, so this corresponds
+			 * to a failure probability of 2^-128 for a working RNG
+			 */
+			if ($attempts > 128) {
+				throw new Exception(
+					'random_int: RNG is broken - too many rejections'
+				);
+			}
+
+			/**
+			 * Let's grab the necessary number of random bytes
+			 */
+			$randomByteString = random_bytes($bytes);
+
+			/**
+			 * Let's turn $randomByteString into an integer
+			 *
+			 * This uses bitwise operators (<< and |) to build an integer
+			 * out of the values extracted from ord()
+			 *
+			 * Example: [9F] | [6D] | [32] | [0C] =>
+			 *   159 + 27904 + 3276800 + 201326592 =>
+			 *   204631455
+			 */
+			$val &= 0;
+			for ($i = 0; $i < $bytes; ++$i) {
+				$val |= ord($randomByteString[$i]) << ($i * 8);
+			}
+			/** @var int $val */
+
+			/**
+			 * Apply mask
+			 */
+			$val &= $mask;
+			$val += $valueShift;
+
+			++$attempts;
+			/**
+			 * If $val overflows to a floating point number,
+			 * ... or is larger than $max,
+			 * ... or smaller than $min,
+			 * then try again.
+			 */
+		} while (!is_int($val) || $val > $max || $val < $min);
+
+		return (int) $val;
+	}
 }

Braces +29 added lines, -13 removed lines

@@ -1,6 +1,7 @@ 
 <?php
 
-if (!is_callable('random_int')) {
+if (!is_callable('random_int'))
+{
     /**
      * Random_* Compatibility Library
      * for using the new PHP 7 random_* API in PHP 5 projects
@@ -50,19 +51,25 @@ 
          * through.
          */
 
-        try {
+        try
+        {
             /** @var int $min */
             $min = RandomCompat_intval($min);
-        } catch (TypeError $ex) {
+        }
+        catch (TypeError $ex)
+        {
             throw new TypeError(
                 'random_int(): $min must be an integer'
             );
         }
 
-        try {
+        try
+        {
             /** @var int $max */
             $max = RandomCompat_intval($max);
-        } catch (TypeError $ex) {
+        }
+        catch (TypeError $ex)
+        {
             throw new TypeError(
                 'random_int(): $max must be an integer'
             );
@@ -73,13 +80,15 @@ 
          * let's validate the logic then we can move forward with generating random
          * integers along a given range.
          */
-        if ($min > $max) {
+        if ($min > $max)
+        {
             throw new Error(
                 'Minimum value must be less than or equal to the maximum value'
             );
         }
 
-        if ($max === $min) {
+        if ($max === $min)
+        {
             return (int) $min;
         }
 
@@ -110,7 +119,8 @@ 
         /**
          * Test for integer overflow:
          */
-        if (!is_int($range)) {
+        if (!is_int($range))
+        {
 
             /**
              * Still safely calculate wider ranges.
@@ -127,14 +137,18 @@ 
             /** @var int $mask */
             $mask = ~0;
 
-        } else {
+        }
+        else
+        {
 
             /**
              * $bits is effectively ceil(log($range, 2)) without dealing with
              * type juggling
              */
-            while ($range > 0) {
-                if ($bits % 8 === 0) {
+            while ($range > 0)
+            {
+                if ($bits % 8 === 0)
+                {
                     ++$bytes;
                 }
                 ++$bits;
@@ -157,7 +171,8 @@ 
              * The rejection probability is at most 0.5, so this corresponds
              * to a failure probability of 2^-128 for a working RNG
              */
-            if ($attempts > 128) {
+            if ($attempts > 128)
+            {
                 throw new Exception(
                     'random_int: RNG is broken - too many rejections'
                 );
@@ -179,7 +194,8 @@ 
              *   204631455
              */
             $val &= 0;
-            for ($i = 0; $i < $bytes; ++$i) {
+            for ($i = 0; $i < $bytes; ++$i)
+            {
                 $val |= ord($randomByteString[$i]) << ($i * 8);
             }
             /** @var int $val */

Sources/random_compat/error_polyfill.php

Indentation +13 added lines, -13 removed lines

@@ -27,23 +27,23 @@
  */
 
 if (!class_exists('Error', false)) {
-    // We can't really avoid making this extend Exception in PHP 5.
-    class Error extends Exception
-    {
+	// We can't really avoid making this extend Exception in PHP 5.
+	class Error extends Exception
+	{
 
-    }
+	}
 }
 
 if (!class_exists('TypeError', false)) {
-    if (is_subclass_of('Error', 'Exception')) {
-        class TypeError extends Error
-        {
+	if (is_subclass_of('Error', 'Exception')) {
+		class TypeError extends Error
+		{
 
-        }
-    } else {
-        class TypeError extends Exception
-        {
+		}
+	} else {
+		class TypeError extends Exception
+		{
 
-        }
-    }
+		}
+	}
 }

Braces +9 added lines, -4 removed lines

@@ -26,7 +26,8 @@ 
  * SOFTWARE.
  */
 
-if (!class_exists('Error', false)) {
+if (!class_exists('Error', false))
+{
     // We can't really avoid making this extend Exception in PHP 5.
     class Error extends Exception
     {
@@ -34,13 +35,17 @@ 
     }
 }
 
-if (!class_exists('TypeError', false)) {
-    if (is_subclass_of('Error', 'Exception')) {
+if (!class_exists('TypeError', false))
+{
+    if (is_subclass_of('Error', 'Exception'))
+    {
         class TypeError extends Error
         {
 
         }
-    } else {
+    }
+    else
+    {
         class TypeError extends Exception
         {
 

Sources/random_compat/random_bytes_libsodium_legacy.php

Indentation +58 added lines, -58 removed lines

@@ -27,67 +27,67 @@
  */
 
 if (!is_callable('random_bytes')) {
-    /**
-     * If the libsodium PHP extension is loaded, we'll use it above any other
-     * solution.
-     *
-     * libsodium-php project:
-     * @ref https://github.com/jedisct1/libsodium-php
-     *
-     * @param int $bytes
-     *
-     * @throws Exception
-     *
-     * @return string
-     */
-    function random_bytes($bytes)
-    {
-        try {
-            /** @var int $bytes */
-            $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
-            throw new TypeError(
-                'random_bytes(): $bytes must be an integer'
-            );
-        }
+	/**
+	 * If the libsodium PHP extension is loaded, we'll use it above any other
+	 * solution.
+	 *
+	 * libsodium-php project:
+	 * @ref https://github.com/jedisct1/libsodium-php
+	 *
+	 * @param int $bytes
+	 *
+	 * @throws Exception
+	 *
+	 * @return string
+	 */
+	function random_bytes($bytes)
+	{
+		try {
+			/** @var int $bytes */
+			$bytes = RandomCompat_intval($bytes);
+		} catch (TypeError $ex) {
+			throw new TypeError(
+				'random_bytes(): $bytes must be an integer'
+			);
+		}
 
-        if ($bytes < 1) {
-            throw new Error(
-                'Length must be greater than 0'
-            );
-        }
+		if ($bytes < 1) {
+			throw new Error(
+				'Length must be greater than 0'
+			);
+		}
 
-        /**
-         * @var string
-         */
-        $buf = '';
+		/**
+		 * @var string
+		 */
+		$buf = '';
 
-        /**
-         * \Sodium\randombytes_buf() doesn't allow more than 2147483647 bytes to be
-         * generated in one invocation.
-         */
-        if ($bytes > 2147483647) {
-            for ($i = 0; $i < $bytes; $i += 1073741824) {
-                $n = ($bytes - $i) > 1073741824
-                    ? 1073741824
-                    : $bytes - $i;
-                $buf .= Sodium::randombytes_buf((int) $n);
-            }
-        } else {
-            $buf .= Sodium::randombytes_buf((int) $bytes);
-        }
+		/**
+		 * \Sodium\randombytes_buf() doesn't allow more than 2147483647 bytes to be
+		 * generated in one invocation.
+		 */
+		if ($bytes > 2147483647) {
+			for ($i = 0; $i < $bytes; $i += 1073741824) {
+				$n = ($bytes - $i) > 1073741824
+					? 1073741824
+					: $bytes - $i;
+				$buf .= Sodium::randombytes_buf((int) $n);
+			}
+		} else {
+			$buf .= Sodium::randombytes_buf((int) $bytes);
+		}
 
-        if (is_string($buf)) {
-            if (RandomCompat_strlen($buf) === $bytes) {
-                return $buf;
-            }
-        }
+		if (is_string($buf)) {
+			if (RandomCompat_strlen($buf) === $bytes) {
+				return $buf;
+			}
+		}
 
-        /**
-         * If we reach here, PHP has failed us.
-         */
-        throw new Exception(
-            'Could not gather sufficient random data'
-        );
-    }
+		/**
+		 * If we reach here, PHP has failed us.
+		 */
+		throw new Exception(
+			'Could not gather sufficient random data'
+		);
+	}
 }

Braces +20 added lines, -9 removed lines

@@ -26,7 +26,8 @@ 
  * SOFTWARE.
  */
 
-if (!is_callable('random_bytes')) {
+if (!is_callable('random_bytes'))
+{
     /**
      * If the libsodium PHP extension is loaded, we'll use it above any other
      * solution.
@@ -42,16 +43,20 @@ 
      */
     function random_bytes($bytes)
     {
-        try {
+        try
+        {
             /** @var int $bytes */
             $bytes = RandomCompat_intval($bytes);
-        } catch (TypeError $ex) {
+        }
+        catch (TypeError $ex)
+        {
             throw new TypeError(
                 'random_bytes(): $bytes must be an integer'
             );
         }
 
-        if ($bytes < 1) {
+        if ($bytes < 1)
+        {
             throw new Error(
                 'Length must be greater than 0'
             );
@@ -66,19 +71,25 @@ 
          * \Sodium\randombytes_buf() doesn't allow more than 2147483647 bytes to be
          * generated in one invocation.
          */
-        if ($bytes > 2147483647) {
-            for ($i = 0; $i < $bytes; $i += 1073741824) {
+        if ($bytes > 2147483647)
+        {
+            for ($i = 0; $i < $bytes; $i += 1073741824)
+            {
                 $n = ($bytes - $i) > 1073741824
                     ? 1073741824
                     : $bytes - $i;
                 $buf .= Sodium::randombytes_buf((int) $n);
             }
-        } else {
+        }
+        else
+        {
             $buf .= Sodium::randombytes_buf((int) $bytes);
         }
 
-        if (is_string($buf)) {
-            if (RandomCompat_strlen($buf) === $bytes) {
+        if (is_string($buf))
+        {
+            if (RandomCompat_strlen($buf) === $bytes)
+            {
                 return $buf;
             }
         }