ci-bonfire / Sprint

index.php

Indentation +27 added lines, -27 removed lines

@@ -57,29 +57,29 @@ 
  */
 	$domain = ! empty($_SERVER['HTTP_HOST']) ? strtolower($_SERVER['HTTP_HOST']) : 'cli';
 
-    /**
-     * A simple method to automatically determine the environment that
-     * the script is running on. Modify to support your needs.
-     *
-     * To handle Travis-ci testing, we check for an environment
-     * variable called TRAVIS which is set in the .travis.yml file.
-     * This allows a database-specific setup for Travis testing.
-     */
-    if (isset($_ENV['TRAVIS']))
-    {
-        define('ENVIRONMENT', 'travis');
-    }
-    else if (isset($_ENV['TESTING']))
-    {
-	    define('ENVIRONMENT', 'testing');
-    }
-    else if (strpos($domain, '.dev') !== false || $domain == 'cli')
-    {
-        define('ENVIRONMENT', 'development');
-    }
-    else {
-        define('ENVIRONMENT', 'production');
-    }
+	/**
+	 * A simple method to automatically determine the environment that
+	 * the script is running on. Modify to support your needs.
+	 *
+	 * To handle Travis-ci testing, we check for an environment
+	 * variable called TRAVIS which is set in the .travis.yml file.
+	 * This allows a database-specific setup for Travis testing.
+	 */
+	if (isset($_ENV['TRAVIS']))
+	{
+		define('ENVIRONMENT', 'travis');
+	}
+	else if (isset($_ENV['TESTING']))
+	{
+		define('ENVIRONMENT', 'testing');
+	}
+	else if (strpos($domain, '.dev') !== false || $domain == 'cli')
+	{
+		define('ENVIRONMENT', 'development');
+	}
+	else {
+		define('ENVIRONMENT', 'production');
+	}
 
 /*
  *---------------------------------------------------------------
@@ -92,7 +92,7 @@ 
 switch (ENVIRONMENT)
 {
 	case 'development':
-    case 'travis':
+	case 'travis':
 	case 'testing':
 		error_reporting(-1);
 		ini_set('display_errors', 1);
@@ -150,7 +150,7 @@ 
  * Include the path if the folder is not in the same directory
  * as this file.
  */
-    $myth_folder = 'myth';
+	$myth_folder = 'myth';
 
 /*
  *---------------------------------------------------------------
@@ -267,8 +267,8 @@ 
 	// Name of the "system folder"
 	define('SYSDIR', trim(strrchr(trim(BASEPATH, '/'), '/'), '/'));
 
-    // Path to the myth folder
-    define('MYTHPATH', rtrim( str_replace('\\', '/', $myth_folder), '/ ') .'/' );
+	// Path to the myth folder
+	define('MYTHPATH', rtrim( str_replace('\\', '/', $myth_folder), '/ ') .'/' );
 
 	// The path to the "application" folder
 	if (is_dir($application_folder))

Switch Indentation +1 added lines, -1 removed lines

@@ -92,7 +92,7 @@
 switch (ENVIRONMENT)
 {
 	case 'development':
-    case 'travis':
+    	case 'travis':
 	case 'testing':
 		error_reporting(-1);
 		ini_set('display_errors', 1);

Spacing +1 added lines, -1 removed lines

@@ -268,7 +268,7 @@
 	define('SYSDIR', trim(strrchr(trim(BASEPATH, '/'), '/'), '/'));
 
     // Path to the myth folder
-    define('MYTHPATH', rtrim( str_replace('\\', '/', $myth_folder), '/ ') .'/' );
+    define('MYTHPATH', rtrim(str_replace('\\', '/', $myth_folder), '/ ').'/');
 
 	// The path to the "application" folder
 	if (is_dir($application_folder))

Braces +9 added lines, -18 removed lines

@@ -68,16 +68,13 @@ 
     if (isset($_ENV['TRAVIS']))
     {
         define('ENVIRONMENT', 'travis');
-    }
-    else if (isset($_ENV['TESTING']))
+    } else if (isset($_ENV['TESTING']))
     {
 	    define('ENVIRONMENT', 'testing');
-    }
-    else if (strpos($domain, '.dev') !== false || $domain == 'cli')
+    } else if (strpos($domain, '.dev') !== false || $domain == 'cli')
     {
         define('ENVIRONMENT', 'development');
-    }
-    else {
+    } else {
         define('ENVIRONMENT', 'production');
     }
 
@@ -103,8 +100,7 @@ 
 		if (version_compare(PHP_VERSION, '5.3', '>='))
 		{
 			error_reporting(E_ALL & ~E_NOTICE & ~E_DEPRECATED & ~E_STRICT & ~E_USER_NOTICE & ~E_USER_DEPRECATED);
-		}
-		else
+		} else
 		{
 			error_reporting(E_ALL & ~E_NOTICE & ~E_STRICT & ~E_USER_NOTICE);
 		}
@@ -235,8 +231,7 @@ 
 	if (($_temp = realpath($system_path)) !== FALSE)
 	{
 		$system_path = $_temp.'/';
-	}
-	else
+	} else
 	{
 		// Ensure there's a trailing slash
 		$system_path = rtrim($system_path, '/').'/';
@@ -279,8 +274,7 @@ 
 		}
 
 		define('APPPATH', $application_folder.DIRECTORY_SEPARATOR);
-	}
-	else
+	} else
 	{
 		if ( ! is_dir(BASEPATH.$application_folder.DIRECTORY_SEPARATOR))
 		{
@@ -298,14 +292,12 @@ 
 		if ( ! empty($view_folder) && is_dir(APPPATH.$view_folder.DIRECTORY_SEPARATOR))
 		{
 			$view_folder = APPPATH.$view_folder;
-		}
-		elseif ( ! is_dir(APPPATH.'views'.DIRECTORY_SEPARATOR))
+		} elseif ( ! is_dir(APPPATH.'views'.DIRECTORY_SEPARATOR))
 		{
 			header('HTTP/1.1 503 Service Unavailable.', TRUE, 503);
 			echo 'Your view folder path does not appear to be set correctly. Please open the following file and correct this: '.SELF;
 			exit(3); // EXIT_CONFIG
-		}
-		else
+		} else
 		{
 			$view_folder = APPPATH.'views';
 		}
@@ -314,8 +306,7 @@ 
 	if (($_temp = realpath($view_folder)) !== FALSE)
 	{
 		$view_folder = $_temp.DIRECTORY_SEPARATOR;
-	}
-	else
+	} else
 	{
 		$view_folder = rtrim($view_folder, '/\\').DIRECTORY_SEPARATOR;
 	}

myth/Api/Auth/APIAuthentication.php

Indentation +3 added lines, -3 removed lines

@@ -74,7 +74,7 @@ 
 	 */
 	public function setRealm($realm)
 	{
-	    $this->realm = $realm;
+		$this->realm = $realm;
 		return $this;
 	}
 
@@ -116,7 +116,7 @@ 
 			'password'  => $password
 		];
 
-	    $user = $this->validate($data, true);
+		$user = $this->validate($data, true);
 
 		$this->user = $user;
 
@@ -272,7 +272,7 @@ 
 	 */
 	public function checkIPBlacklist()
 	{
-	    $blacklist = explode(',', config_item('api.ip_blacklist'));
+		$blacklist = explode(',', config_item('api.ip_blacklist'));
 
 		array_walk($blacklist, function (&$item, $key) {
 			$item = trim($item);

Spacing +22 added lines, -22 removed lines

@@ -41,7 +41,7 @@ 
 
 	//--------------------------------------------------------------------
 
-	public function __construct($ci=null)
+	public function __construct($ci = null)
 	{
 		parent::__construct($ci);
 
@@ -107,7 +107,7 @@ 
 		// so request authorization by the client.
 		if (empty($username) || empty($password))
 		{
-			$this->ci->output->set_header('WWW-Authenticate: Basic realm="'. config_item('api.realm') .'"');
+			$this->ci->output->set_header('WWW-Authenticate: Basic realm="'.config_item('api.realm').'"');
 			return false;
 		}
 
@@ -157,7 +157,7 @@ 
 		// No digest string? Then you're done. Go home.
 		if (empty($digest_string))
 		{
-			$this->ci->output->set_header( sprintf('WWW-Authenticate: Digest realm="%s", nonce="%s", opaque="%s"', config_item('api.realm'), $nonce, $opaque) );
+			$this->ci->output->set_header(sprintf('WWW-Authenticate: Digest realm="%s", nonce="%s", opaque="%s"', config_item('api.realm'), $nonce, $opaque));
 			return false;
 		}
 
@@ -167,18 +167,18 @@ 
 		preg_match_all('@(username|nonce|uri|nc|cnonce|qop|response)=[\'"]?([^\'",]+)@', $digest_string, $matches);
 		$digest = (empty($matches[1]) || empty($matches[2])) ? array() : array_combine($matches[1], $matches[2]);
 
-		if (! array_key_exists('username', $digest))
+		if ( ! array_key_exists('username', $digest))
 		{
-			$this->ci->output->set_header( sprintf('WWW-Authenticate: Digest realm="%s", nonce="%s", opaque="%s"', config_item('api.realm'), $nonce, $opaque) );
+			$this->ci->output->set_header(sprintf('WWW-Authenticate: Digest realm="%s", nonce="%s", opaque="%s"', config_item('api.realm'), $nonce, $opaque));
 			return false;
 		}
 
 		// Grab the user that corresponds to that "username"
 		// exact field determined in the api config file - api.auth_field setting.
-		$user = $this->user_model->as_array()->find_by( config_item('api.auth_field'), $digest['username'] );
-		if (!  $user)
+		$user = $this->user_model->as_array()->find_by(config_item('api.auth_field'), $digest['username']);
+		if ( ! $user)
 		{
-			$this->ci->output->set_header( sprintf('WWW-Authenticate: Digest realm="%s", nonce="%s", opaque="%s"', config_item('api.realm'), $nonce, $opaque) );
+			$this->ci->output->set_header(sprintf('WWW-Authenticate: Digest realm="%s", nonce="%s", opaque="%s"', config_item('api.realm'), $nonce, $opaque));
 			return false;
 		}
 
@@ -187,16 +187,16 @@ 
 
 		if ($digest['qop'] == 'auth')
 		{
-			$A2 = md5( strtoupper( $_SERVER['REQUEST_METHOD'] ) .':'. $digest['uri'] );
+			$A2 = md5(strtoupper($_SERVER['REQUEST_METHOD']).':'.$digest['uri']);
 		} else {
 			$body = file_get_contents('php://input');
-			$A2 = md5( strtoupper( $_SERVER['REQUEST_METHOD'] ) .':'. $digest['uri'] .':'. md5($body) );
+			$A2 = md5(strtoupper($_SERVER['REQUEST_METHOD']).':'.$digest['uri'].':'.md5($body));
 		}
-		$valid_response = md5($A1 .':'. $digest['nonce'].':'. $digest['nc'] .':'. $digest['cnonce'] .':'. $digest['qop'] .':'. $A2);
+		$valid_response = md5($A1.':'.$digest['nonce'].':'.$digest['nc'].':'.$digest['cnonce'].':'.$digest['qop'].':'.$A2);
 
 		if ($digest['response'] != $valid_response)
 		{
-			$this->ci->output->set_header( sprintf('WWW-Authenticate: Digest realm="%s", nonce="%s", opaque="%s"', config_item('api.realm'), $nonce, $opaque) );
+			$this->ci->output->set_header(sprintf('WWW-Authenticate: Digest realm="%s", nonce="%s", opaque="%s"', config_item('api.realm'), $nonce, $opaque));
 			return false;
 		}
 
@@ -233,7 +233,7 @@ 
 				break;
 		}
 
-		if (! $user)
+		if ( ! $user)
 		{
 			$this->user = null;
 			return $user;
@@ -246,7 +246,7 @@ 
 
 		// If throttling time is above zero, we can't allow
 		// logins now.
-		if ($time = (int)$this->isThrottled($user['email']) > 0)
+		if ($time = (int) $this->isThrottled($user['email']) > 0)
 		{
 			$this->error = sprintf(lang('api.throttled'), $time);
 			return false;
@@ -274,13 +274,13 @@ 
 	{
 	    $blacklist = explode(',', config_item('api.ip_blacklist'));
 
-		array_walk($blacklist, function (&$item, $key) {
+		array_walk($blacklist, function(&$item, $key) {
 			$item = trim($item);
 		});
 
 		if (in_array($this->ci->input->ip_address(), $blacklist))
 		{
-			throw new \Exception( lang('api.ip_denied'), 401);
+			throw new \Exception(lang('api.ip_denied'), 401);
 		}
 
 		return true;
@@ -299,13 +299,13 @@ 
 
 		array_push($whitelist, '127.0.0.1', '0.0.0.0');
 
-		array_walk($whitelist, function (&$item, $key) {
+		array_walk($whitelist, function(&$item, $key) {
 			$item = trim($item);
 		});
 
-		if (! in_array($this->ci->input->ip_address(), $whitelist))
+		if ( ! in_array($this->ci->input->ip_address(), $whitelist))
 		{
-			throw new \Exception( lang('api.ip_denied'), 401);
+			throw new \Exception(lang('api.ip_denied'), 401);
 		}
 
 		return true;
@@ -362,9 +362,9 @@ 
 	 *
 	 * @return bool|mixed|void
 	 */
-	public function login($credentials, $remember=false)
+	public function login($credentials, $remember = false)
 	{
-		throw new \BadMethodCallException( lang('api.unused_method') );
+		throw new \BadMethodCallException(lang('api.unused_method'));
 	}
 
 	//--------------------------------------------------------------------
@@ -379,7 +379,7 @@ 
 	 */
 	public function logout()
 	{
-		throw new \BadMethodCallException( lang('api.unused_method') );
+		throw new \BadMethodCallException(lang('api.unused_method'));
 	}
 
 	//--------------------------------------------------------------------

Braces +1 added lines, -2 removed lines

@@ -145,8 +145,7 @@
 		if ($this->ci->input->server('PHP_AUTH_DIGEST'))
 		{
 			$digest_string = $this->ci->input->server('PHP_AUTH_DIGEST');
-		}
-		elseif ($this->ci->input->server('HTTP_AUTHORIZATION'))
+		} elseif ($this->ci->input->server('HTTP_AUTHORIZATION'))
 		{
 			$digest_string = $this->ci->input->server('HTTP_AUTHORIZATION');
 		}

myth/Api/Server/LogModel.php

Spacing +2 added lines, -2 removed lines

@@ -55,11 +55,11 @@
 		$time = date('Y-m-d H:00:00');
 
 		$query = $this->db->select('id')
-						  ->where('user_id', (int)$user_id)
+						  ->where('user_id', (int) $user_id)
 						  ->where('created_on >=', $time)
 						  ->get($this->table_name);
 
-		return (int)$query->num_rows();
+		return (int) $query->num_rows();
 	}
 
 	//--------------------------------------------------------------------

myth/Auth/AuthenticateInterface.php

Indentation +191 added lines, -191 removed lines

@@ -42,196 +42,196 @@
  */
 interface AuthenticateInterface {
 
-    /**
-     * Attempt to log a user into the system.
-     *
-     * $credentials is an array of key/value pairs needed to log the user in.
-     * This is often email/password, or username/password.
-     *
-     * @param $credentials
-     * @param bool $remember
-     */
-    public function login($credentials, $remember=false);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Validates user login information without logging them in.
-     *
-     * $credentials is an array of key/value pairs needed to log the user in.
-     * This is often email/password, or username/password.
-     *
-     * @param $credentials
-     * @param bool $return_user
-     * @return mixed
-     */
-    public function validate($credentials, $return_user=false);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Logs a user out and removes all session information.
-     *
-     * @return mixed
-     */
-    public function logout();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Checks whether a user is logged in or not.
-     *
-     * @return bool
-     */
-    public function isLoggedIn();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Attempts to log a user in based on the "remember me" cookie.
-     *
-     * @return bool
-     */
-    public function viaRemember();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Registers a new user and handles activation method.
-     *
-     * @param $user_data
-     * @return bool
-     */
-    public function registerUser($user_data);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Used to verify the user values and activate a user so they can
-     * visit the site.
-     *
-     * @param $data
-     * @return bool
-     */
-    public function activateUser($data);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Used to allow manual activation of a user with a known ID.
-     *
-     * @param $id
-     * @return bool
-     */
-    public function activateUserById($id);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Grabs the current user object. Returns NULL if nothing found.
-     *
-     * @return array|null
-     */
-    public function user();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * A convenience method to grab the current user's ID.
-     *
-     * @return int|null
-     */
-    public function id();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Tells the system to start throttling a user. This may vary by implementation,
-     * but will often add additional time before another login is allowed.
-     *
-     * @param $email
-     * @return mixed
-     */
-    public function isThrottled($email);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Sends a password reminder email to the user associated with
-     * the passed in $email.
-     *
-     * @param $email
-     * @return mixed
-     */
-    public function remindUser($email);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Validates the credentials provided and, if valid, resets the password.
-     *
-     * @param $credentials
-     * @param $password
-     * @param $passConfirm
-     * @return mixed
-     */
-    public function resetPassword($credentials, $password, $passConfirm);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Provides a way for implementations to allow new statuses to be set
-     * on the user. The details will vary based upon implementation, but
-     * will often allow for banning or suspending users.
-     *
-     * @param $newStatus
-     * @param null $message
-     * @return mixed
-     */
-    public function changeStatus($newStatus, $message=null);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Allows the consuming application to pass in a reference to the
-     * model that should be used.
-     *
-     * The model MUST extend Myth\Models\CIDbModel.
-     *
-     * @param $model
-     * @return mixed
-     */
-    public function useModel($model);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Returns the current error string.
-     *
-     * @return mixed
-     */
-    public function error();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Purges all login attempt records from the database.
-     *
-     * @param $email
-     */
-    public function purgeLoginAttempts($email);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Purges all remember tokens for a single user. Effectively logs
-     * a user out of all devices. Intended to allow users to log themselves
-     * out of all devices as a security measure.
-     *
-     * @param $email
-     */
-    public function purgeRememberTokens($email);
-
-    //--------------------------------------------------------------------
+	/**
+	 * Attempt to log a user into the system.
+	 *
+	 * $credentials is an array of key/value pairs needed to log the user in.
+	 * This is often email/password, or username/password.
+	 *
+	 * @param $credentials
+	 * @param bool $remember
+	 */
+	public function login($credentials, $remember=false);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Validates user login information without logging them in.
+	 *
+	 * $credentials is an array of key/value pairs needed to log the user in.
+	 * This is often email/password, or username/password.
+	 *
+	 * @param $credentials
+	 * @param bool $return_user
+	 * @return mixed
+	 */
+	public function validate($credentials, $return_user=false);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Logs a user out and removes all session information.
+	 *
+	 * @return mixed
+	 */
+	public function logout();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks whether a user is logged in or not.
+	 *
+	 * @return bool
+	 */
+	public function isLoggedIn();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Attempts to log a user in based on the "remember me" cookie.
+	 *
+	 * @return bool
+	 */
+	public function viaRemember();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Registers a new user and handles activation method.
+	 *
+	 * @param $user_data
+	 * @return bool
+	 */
+	public function registerUser($user_data);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Used to verify the user values and activate a user so they can
+	 * visit the site.
+	 *
+	 * @param $data
+	 * @return bool
+	 */
+	public function activateUser($data);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Used to allow manual activation of a user with a known ID.
+	 *
+	 * @param $id
+	 * @return bool
+	 */
+	public function activateUserById($id);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Grabs the current user object. Returns NULL if nothing found.
+	 *
+	 * @return array|null
+	 */
+	public function user();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * A convenience method to grab the current user's ID.
+	 *
+	 * @return int|null
+	 */
+	public function id();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Tells the system to start throttling a user. This may vary by implementation,
+	 * but will often add additional time before another login is allowed.
+	 *
+	 * @param $email
+	 * @return mixed
+	 */
+	public function isThrottled($email);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Sends a password reminder email to the user associated with
+	 * the passed in $email.
+	 *
+	 * @param $email
+	 * @return mixed
+	 */
+	public function remindUser($email);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Validates the credentials provided and, if valid, resets the password.
+	 *
+	 * @param $credentials
+	 * @param $password
+	 * @param $passConfirm
+	 * @return mixed
+	 */
+	public function resetPassword($credentials, $password, $passConfirm);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Provides a way for implementations to allow new statuses to be set
+	 * on the user. The details will vary based upon implementation, but
+	 * will often allow for banning or suspending users.
+	 *
+	 * @param $newStatus
+	 * @param null $message
+	 * @return mixed
+	 */
+	public function changeStatus($newStatus, $message=null);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Allows the consuming application to pass in a reference to the
+	 * model that should be used.
+	 *
+	 * The model MUST extend Myth\Models\CIDbModel.
+	 *
+	 * @param $model
+	 * @return mixed
+	 */
+	public function useModel($model);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns the current error string.
+	 *
+	 * @return mixed
+	 */
+	public function error();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Purges all login attempt records from the database.
+	 *
+	 * @param $email
+	 */
+	public function purgeLoginAttempts($email);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Purges all remember tokens for a single user. Effectively logs
+	 * a user out of all devices. Intended to allow users to log themselves
+	 * out of all devices as a security measure.
+	 *
+	 * @param $email
+	 */
+	public function purgeRememberTokens($email);
+
+	//--------------------------------------------------------------------
 
 }

Spacing +3 added lines, -3 removed lines

@@ -51,7 +51,7 @@ 
      * @param $credentials
      * @param bool $remember
      */
-    public function login($credentials, $remember=false);
+    public function login($credentials, $remember = false);
 
     //--------------------------------------------------------------------
 
@@ -65,7 +65,7 @@ 
      * @param bool $return_user
      * @return mixed
      */
-    public function validate($credentials, $return_user=false);
+    public function validate($credentials, $return_user = false);
 
     //--------------------------------------------------------------------
 
@@ -188,7 +188,7 @@ 
      * @param null $message
      * @return mixed
      */
-    public function changeStatus($newStatus, $message=null);
+    public function changeStatus($newStatus, $message = null);
 
     //--------------------------------------------------------------------
 

myth/Auth/AuthorizeInterface.php

Spacing +5 added lines, -5 removed lines

@@ -30,7 +30,7 @@ 
  * @since       Version 1.0
  */
 
-interface AuthorizeInterface  {
+interface AuthorizeInterface {
 
 	/**
 	 * Returns the latest error string.
@@ -150,7 +150,7 @@ 
 	 *
 	 * @return mixed
 	 */
-	public function createGroup($name, $description='');
+	public function createGroup($name, $description = '');
 
 	//--------------------------------------------------------------------
 
@@ -174,7 +174,7 @@ 
 	 *
 	 * @return mixed
 	 */
-	public function updateGroup($id, $name, $description='');
+	public function updateGroup($id, $name, $description = '');
 
 	//--------------------------------------------------------------------
 
@@ -210,7 +210,7 @@ 
 	 *
 	 * @return mixed
 	 */
-	public function createPermission($name, $description='');
+	public function createPermission($name, $description = '');
 
 	//--------------------------------------------------------------------
 
@@ -234,7 +234,7 @@ 
 	 *
 	 * @return bool
 	 */
-	public function updatePermission($id, $name, $description='');
+	public function updatePermission($id, $name, $description = '');
 
 	//--------------------------------------------------------------------
 

myth/Auth/Flat/FlatGroupsModel.php

Indentation +22 added lines, -22 removed lines

@@ -85,10 +85,10 @@ 
 	 */
 	public function addUserToGroup($user_id, $group_id)
 	{
-	    $data = [
-		    'user_id'   => (int)$user_id,
-		    'group_id'  => (int)$group_id
-	    ];
+		$data = [
+			'user_id'   => (int)$user_id,
+			'group_id'  => (int)$group_id
+		];
 
 		return $this->db->insert('auth_groups_users', $data);
 	}
@@ -105,10 +105,10 @@ 
 	 */
 	public function removeUserFromGroup($user_id, $group_id)
 	{
-	    return $this->where([
-		    'user_id' => (int)$user_id,
-		    'group_id' => (int)$group_id
-	    ])->delete('auth_groups_users');
+		return $this->where([
+			'user_id' => (int)$user_id,
+			'group_id' => (int)$group_id
+		])->delete('auth_groups_users');
 	}
 
 	//--------------------------------------------------------------------
@@ -122,8 +122,8 @@ 
 	 */
 	public function removeUserFromAllGroups($user_id)
 	{
-	    return $this->db->where('user_id', (int)$user_id)
-		                ->delete('auth_groups_users');
+		return $this->db->where('user_id', (int)$user_id)
+						->delete('auth_groups_users');
 	}
 
 	//--------------------------------------------------------------------
@@ -137,11 +137,11 @@ 
 	 */
 	public function getGroupsForUser($user_id)
 	{
-	    return $this->select('auth_groups_users.*, auth_groups.name, auth_groups.description')
-		            ->join('auth_groups_users', 'auth_groups_users.group_id = auth_groups.id', 'left')
-		            ->where('user_id', $user_id)
-		            ->as_array()
-		            ->find_all();
+		return $this->select('auth_groups_users.*, auth_groups.name, auth_groups.description')
+					->join('auth_groups_users', 'auth_groups_users.group_id = auth_groups.id', 'left')
+					->where('user_id', $user_id)
+					->as_array()
+					->find_all();
 	}
 
 	//--------------------------------------------------------------------
@@ -160,7 +160,7 @@ 
 			'group_id'      => (int)$group_id
 		];
 
-	    return $this->db->insert('auth_groups_permissions', $data);
+		return $this->db->insert('auth_groups_permissions', $data);
 	}
 
 	//--------------------------------------------------------------------
@@ -176,10 +176,10 @@ 
 	 */
 	public function removePermissionFromGroup($permission_id, $group_id)
 	{
-	    return $this->db->where([
-		    'permission_id' => $permission_id,
-		    'group_id'      => $group_id
-	    ])->delete('auth_groups_permissions');
+		return $this->db->where([
+			'permission_id' => $permission_id,
+			'group_id'      => $group_id
+		])->delete('auth_groups_permissions');
 	}
 
 	//--------------------------------------------------------------------
@@ -193,8 +193,8 @@ 
 	 */
 	public function removePermissionFromAllGroups($permission_id)
 	{
-	    return $this->db->where('permission_id', $permission_id)
-		                ->delete('auth_groups_permissions');
+		return $this->db->where('permission_id', $permission_id)
+						->delete('auth_groups_permissions');
 	}
 
 	//--------------------------------------------------------------------

Spacing +7 added lines, -7 removed lines

@@ -86,8 +86,8 @@ 
 	public function addUserToGroup($user_id, $group_id)
 	{
 	    $data = [
-		    'user_id'   => (int)$user_id,
-		    'group_id'  => (int)$group_id
+		    'user_id'   => (int) $user_id,
+		    'group_id'  => (int) $group_id
 	    ];
 
 		return $this->db->insert('auth_groups_users', $data);
@@ -106,8 +106,8 @@ 
 	public function removeUserFromGroup($user_id, $group_id)
 	{
 	    return $this->where([
-		    'user_id' => (int)$user_id,
-		    'group_id' => (int)$group_id
+		    'user_id' => (int) $user_id,
+		    'group_id' => (int) $group_id
 	    ])->delete('auth_groups_users');
 	}
 
@@ -122,7 +122,7 @@ 
 	 */
 	public function removeUserFromAllGroups($user_id)
 	{
-	    return $this->db->where('user_id', (int)$user_id)
+	    return $this->db->where('user_id', (int) $user_id)
 		                ->delete('auth_groups_users');
 	}
 
@@ -156,8 +156,8 @@ 
 	public function addPermissionToGroup($permission_id, $group_id)
 	{
 		$data = [
-			'permission_id' => (int)$permission_id,
-			'group_id'      => (int)$group_id
+			'permission_id' => (int) $permission_id,
+			'group_id'      => (int) $group_id
 		];
 
 	    return $this->db->insert('auth_groups_permissions', $data);

myth/Auth/Flat/FlatPermissionsModel.php

Spacing +2 added lines, -2 removed lines

@@ -84,11 +84,11 @@
 	{
 		$permissions = $this->join('auth_groups_permissions', 'auth_groups_permissions.permission_id = auth_permissions.id', 'inner')
 							->join('auth_groups_users', 'auth_groups_users.group_id = auth_groups_permissions.group_id', 'inner')
-							->where('auth_groups_users.user_id', (int)$user_id)
+							->where('auth_groups_users.user_id', (int) $user_id)
 							->as_array()
 							->find_all();
 
-		if (! $permissions)
+		if ( ! $permissions)
 		{
 			return false;
 		}

myth/Auth/LocalAuthentication.php

Spacing +60 added lines, -60 removed lines

@@ -62,21 +62,21 @@ 
 
     //--------------------------------------------------------------------
 
-    public function __construct( $ci=null )
+    public function __construct($ci = null)
     {
         if ($ci)
         {
-            $this->ci= $ci;
+            $this->ci = $ci;
         }
         else
         {
-            $this->ci =& get_instance();
+            $this->ci = & get_instance();
         }
 
         // Get our compatibility password file loaded up.
-        if (! function_exists('password_hash'))
+        if ( ! function_exists('password_hash'))
         {
-            require_once dirname(__FILE__) .'password.php';
+            require_once dirname(__FILE__).'password.php';
         }
 
         if (empty($this->ci->session))
@@ -101,18 +101,18 @@ 
      * @param bool  $remember
      * @return bool|mixed
      */
-    public function login($credentials, $remember=false)
+    public function login($credentials, $remember = false)
     {
         $user = $this->validate($credentials, true);
 
-        if (! $user)
+        if ( ! $user)
         {
 	        // We need to send an error even if no
 	        // user was found!
 	        $this->error = lang('auth.invalid_user');
 
 	        // If an email is present, log the attempt
-	        if (! empty($credentials['email']) )
+	        if ( ! empty($credentials['email']))
 	        {
 		        $this->ci->login_model->recordLoginAttempt($credentials['email']);
 	        }
@@ -128,7 +128,7 @@ 
 
         // If throttling time is above zero, we can't allow
         // logins now.
-        $time = (int)$this->isThrottled($user['email']);
+        $time = (int) $this->isThrottled($user['email']);
         if ($time > 0)
         {
             $this->error = sprintf(lang('auth.throttled'), $time);
@@ -159,7 +159,7 @@ 
      * @param bool $return_user
      * @return mixed
      */
-    public function validate($credentials, $return_user=false)
+    public function validate($credentials, $return_user = false)
     {
         // Can't validate without a password.
         if (empty($credentials['password']) || count($credentials) < 2)
@@ -179,7 +179,7 @@ 
 	    }
 
         // Ensure that the fields are allowed validation fields
-	    if (! in_array(key($credentials), config_item('auth.valid_fields')) )
+	    if ( ! in_array(key($credentials), config_item('auth.valid_fields')))
 	    {
 		    $this->error = lang('auth.invalid_credentials');
 		    return false;
@@ -187,7 +187,7 @@ 
 
         // We do not want to force case-sensitivity on things
         // like username and email for usability sake.
-        if (! empty($credentials['email']))
+        if ( ! empty($credentials['email']))
         {
             $credentials['email'] = strtolower($credentials['email']);
         }
@@ -197,16 +197,16 @@ 
                                  ->where($credentials)
                                  ->first();
 
-        if (! $user)
+        if ( ! $user)
         {
             $this->error = lang('auth.invalid_user');
             return false;
         }
 
         // Now, try matching the passwords.
-        $result =  password_verify($password, $user['password_hash']);
+        $result = password_verify($password, $user['password_hash']);
 
-        if (! $result)
+        if ( ! $result)
         {
             $this->error = lang('auth.invalid_password');
             $this->ci->login_model->recordLoginAttempt($user['email']);
@@ -217,7 +217,7 @@ 
         // This would be due to the hash algorithm or hash
         // cost changing since the last time that a user
         // logged in.
-        if (password_needs_rehash($user['password_hash'], PASSWORD_DEFAULT, ['cost' => config_item('auth.hash_cost')] ))
+        if (password_needs_rehash($user['password_hash'], PASSWORD_DEFAULT, ['cost' => config_item('auth.hash_cost')]))
         {
             $new_hash = Password::hashPassword($password);
             $this->user_model->skip_validation()
@@ -226,7 +226,7 @@ 
         }
 
         // Is the user active?
-        if (! $user['active'])
+        if ( ! $user['active'])
         {
             $this->error = lang('auth.inactive_account');
             return false;
@@ -246,7 +246,7 @@ 
     {
         $this->ci->load->helper('cookie');
 
-        if (! Events::trigger('beforeLogout', [$this->user]))
+        if ( ! Events::trigger('beforeLogout', [$this->user]))
         {
             return false;
         }
@@ -255,10 +255,10 @@ 
         // available for flash messages, etc.
         if (isset($_SESSION))
         {
-            foreach ( $_SESSION as $key => $value )
+            foreach ($_SESSION as $key => $value)
             {
-                $_SESSION[ $key ] = NULL;
-                unset( $_SESSION[ $key ] );
+                $_SESSION[$key] = NULL;
+                unset($_SESSION[$key]);
             }
         }
         // Also, regenerate the session ID for a touch of added safety.
@@ -284,7 +284,7 @@ 
     {
         $id = $this->ci->session->userdata('logged_in');
 
-        if (! $id)
+        if ( ! $id)
         {
             return false;
         }
@@ -292,10 +292,10 @@ 
         // If the user var hasn't been filled in, we need to fill it in,
         // since this method will typically be used as the only method
         // to determine whether a user is logged in or not.
-        if (! $this->user)
+        if ( ! $this->user)
         {
             $this->user = $this->user_model->as_array()
-                                           ->find_by('id', (int)$id);
+                                           ->find_by('id', (int) $id);
 
             if (empty($this->user))
             {
@@ -319,14 +319,14 @@ 
      */
     public function viaRemember()
     {
-        if (! config_item('auth.allow_remembering'))
+        if ( ! config_item('auth.allow_remembering'))
         {
             return false;
         }
 
         $this->ci->load->helper('cookie');
 
-        if (! $token = get_cookie('remember'))
+        if ( ! $token = get_cookie('remember'))
         {
             return false;
         }
@@ -335,7 +335,7 @@ 
         $query = $this->ci->db->where('hash', $this->ci->login_model->hashRememberToken($token))
                               ->get('auth_tokens');
 
-        if (! $query->num_rows())
+        if ( ! $query->num_rows())
         {
             return false;
         }
@@ -373,16 +373,16 @@ 
         // If via email, we need to generate a hash
         $this->ci->load->helper('string');
         $token = random_string('alnum', 24);
-        $user_data['activate_hash'] = hash('sha1', config_item('auth.salt') . $token);
+        $user_data['activate_hash'] = hash('sha1', config_item('auth.salt').$token);
 
         // Email should NOT be case sensitive.
-        if (! empty($user_data['email']))
+        if ( ! empty($user_data['email']))
         {
             $user_data['email'] = strtolower($user_data['email']);
         }
 
         // Save the user
-        if (! $id = $this->user_model->insert($user_data))
+        if ( ! $id = $this->user_model->insert($user_data))
         {
             $this->error = $this->user_model->error();
             return false;
@@ -413,25 +413,25 @@ 
     {
         $post = [
             'email'         => $data['email'],
-            'activate_hash' => hash('sha1', config_item('auth.salt') . $data['code'])
+            'activate_hash' => hash('sha1', config_item('auth.salt').$data['code'])
         ];
 
         $user = $this->user_model->where($post)
                                  ->first();
 
-        if (! $user) {
+        if ( ! $user) {
             $this->error = $this->user_model->error() ? $this->user_model->error() : lang('auth.activate_no_user');
 
             return false;
         }
 
-        if (! $this->user_model->update($user->id, ['active' => 1, 'activate_hash' => null]))
+        if ( ! $this->user_model->update($user->id, ['active' => 1, 'activate_hash' => null]))
         {
             $this->error = $this->user_model->error();
             return false;
         }
 
-        Events::trigger('didActivate', [(array)$user]);
+        Events::trigger('didActivate', [(array) $user]);
 
         return true;
     }
@@ -446,7 +446,7 @@ 
      */
     public function activateUserById($id)
     {
-        if (! $this->user_model->update($id, ['active' => 1, 'activate_hash' => null]))
+        if ( ! $this->user_model->update($id, ['active' => 1, 'activate_hash' => null]))
         {
             $this->error = $this->user_model->error();
             return false;
@@ -478,12 +478,12 @@ 
      */
     public function id()
     {
-        if (! is_array($this->user) || empty($this->user['id']))
+        if ( ! is_array($this->user) || empty($this->user['id']))
         {
             return null;
         }
 
-        return (int)$this->user['id'];
+        return (int) $this->user['id'];
     }
 
     //--------------------------------------------------------------------
@@ -500,7 +500,7 @@ 
     public function isThrottled($email)
     {
         // Not throttling? Get outta here!
-        if (! config_item('auth.allow_throttling'))
+        if ( ! config_item('auth.allow_throttling'))
         {
             return false;
         }
@@ -564,7 +564,7 @@ 
         {
             $this->error = lang('auth.bruteBan_notice');
 
-            $ban_time = 60 * 15;    // 15 minutes
+            $ban_time = 60 * 15; // 15 minutes
             $_SESSION['bruteBan'] = time() + $ban_time;
             return $ban_time;
         }
@@ -612,7 +612,7 @@ 
         // Is it a valid user?
         $user = $this->user_model->find_by('email', $email);
 
-        if (! $user)
+        if ( ! $user)
         {
             $this->error = lang('auth.invalid_email');
             return false;
@@ -621,17 +621,17 @@ 
         // Generate/store our codes
         $this->ci->load->helper('string');
         $token = random_string('alnum', 24);
-        $hash = hash('sha1', config_item('auth.salt') .$token);
+        $hash = hash('sha1', config_item('auth.salt').$token);
 
         $result = $this->user_model->update($user->id, ['reset_hash' => $hash]);
 
-        if (! $result)
+        if ( ! $result)
         {
             $this->error = $this->user_model->error();
             return false;
         }
 
-        Events::trigger('didRemindUser', [(array)$user, $token]);
+        Events::trigger('didRemindUser', [(array) $user, $token]);
 
         return true;
     }
@@ -658,10 +658,10 @@ 
         }
 
         // Generate a hash to match against the table.
-        $credentials['reset_hash'] = hash('sha1', config_item('auth.salt') .$credentials['code']);
+        $credentials['reset_hash'] = hash('sha1', config_item('auth.salt').$credentials['code']);
         unset($credentials['code']);
 
-        if (! empty($credentials['email']))
+        if ( ! empty($credentials['email']))
         {
             $credentials['email'] = strtolower($credentials['email']);
         }
@@ -669,7 +669,7 @@ 
         // Is there a matching user?
         $user = $this->user_model->find_by($credentials);
 
-        if (! $user)
+        if ( ! $user)
         {
             $this->error = lang('auth.reset_no_user');
             return false;
@@ -682,13 +682,13 @@ 
             'reset_hash'   => null
         ];
 
-        if (! $this->user_model->update($user->id, $data))
+        if ( ! $this->user_model->update($user->id, $data))
         {
             $this->error = $this->user_model->error();
             return false;
         }
 
-        Events::trigger('didResetPassword', [(array)$user]);
+        Events::trigger('didResetPassword', [(array) $user]);
 
         return true;
     }
@@ -704,7 +704,7 @@ 
      * @param null $message
      * @return mixed
      */
-    public function changeStatus($newStatus, $message=null)
+    public function changeStatus($newStatus, $message = null)
     {
         // todo actually record new users status!
     }
@@ -721,14 +721,14 @@ 
      * @param bool $allow_any_parent
      * @return mixed
      */
-    public function useModel($model, $allow_any_parent=false)
+    public function useModel($model, $allow_any_parent = false)
     {
-        if (! $allow_any_parent && get_parent_class($model) != 'Myth\Models\CIDbModel')
+        if ( ! $allow_any_parent && get_parent_class($model) != 'Myth\Models\CIDbModel')
         {
             throw new \RuntimeException('Models passed into LocalAuthenticate MUST extend Myth\Models\CIDbModel');
         }
 
-        $this->user_model =& $model;
+        $this->user_model = & $model;
 
         return $this;
     }
@@ -800,7 +800,7 @@ 
      */
     protected function rememberUser($user)
     {
-        if (! config_item('auth.allow_remembering'))
+        if ( ! config_item('auth.allow_remembering'))
         {
             log_message('debug', 'Auth library set to refuse "Remember Me" functionality.');
             return false;
@@ -819,13 +819,13 @@ 
      * @param null $token
      * @return mixed
      */
-    protected function refreshRememberCookie($user, $token=null)
+    protected function refreshRememberCookie($user, $token = null)
     {
         $this->ci->load->helper('cookie');
 
         // If a token is passed in, we know we're removing the
         // old one.
-        if (! empty($token))
+        if ( ! empty($token))
         {
             $this->invalidateRememberCookie($user['email'], $token);
         }
@@ -835,7 +835,7 @@ 
         // Save the token to the database.
         $data = [
             'email'   => $user['email'],
-            'hash'    => sha1(config_item('auth.salt') . $new_token),
+            'hash'    => sha1(config_item('auth.salt').$new_token),
             'created' => date('Y-m-d H:i:s')
         ];
 
@@ -843,13 +843,13 @@ 
 
         // Create the cookie
         set_cookie(
-            'remember',                             // Cookie Name
-            $new_token,                             // Value
-            config_item('auth.remember_length'),    // # Seconds until it expires
+            'remember', // Cookie Name
+            $new_token, // Value
+            config_item('auth.remember_length'), // # Seconds until it expires
             config_item('cookie_domain'),
             config_item('cookie_path'),
             config_item('cookie_prefix'),
-            false,                                  // Only send over HTTPS?
+            false, // Only send over HTTPS?
             true                                    // Hide from Javascript?
         );
 

Braces +1 added lines, -2 removed lines

@@ -253,8 +253,7 @@
             {
                 $this->vars[$k] = $escape ? esc($v, $context, $this->escaper) : $v;
             }
-        }
-        else
+        } else
         {
             $this->vars[$name] = $escape ? esc($value, $context, $this->escaper) : $value;
         }

Indentation +887 added lines, -887 removed lines

@@ -52,893 +52,893 @@
  */
 class LocalAuthentication implements AuthenticateInterface {
 
-    protected $ci;
-
-    protected $user = null;
-
-    public $user_model = null;
-
-    public $error = null;
-
-    //--------------------------------------------------------------------
-
-    public function __construct( $ci=null )
-    {
-        if ($ci)
-        {
-            $this->ci= $ci;
-        }
-        else
-        {
-            $this->ci =& get_instance();
-        }
-
-        // Get our compatibility password file loaded up.
-        if (! function_exists('password_hash'))
-        {
-            require_once dirname(__FILE__) .'password.php';
-        }
-
-        if (empty($this->ci->session))
-        {
-            $this->ci->load->library('session');
-        }
-
-        $this->ci->config->load('auth');
-        $this->ci->load->model('auth/login_model');
-        $this->ci->load->language('auth/auth');
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Attempt to log a user into the system.
-     *
-     * $credentials is an array of key/value pairs needed to log the user in.
-     * This is often email/password, or username/password.
-     *
-     * @param array $credentials
-     * @param bool  $remember
-     * @return bool|mixed
-     */
-    public function login($credentials, $remember=false)
-    {
-        $user = $this->validate($credentials, true);
-
-        if (! $user)
-        {
-	        // We need to send an error even if no
-	        // user was found!
-	        $this->error = lang('auth.invalid_user');
-
-	        // If an email is present, log the attempt
-	        if (! empty($credentials['email']) )
-	        {
-		        $this->ci->login_model->recordLoginAttempt($credentials['email']);
-	        }
-
-            $this->user = null;
-            return $user;
-        }
-
-        // If the user is throttled due to too many invalid logins
-        // or the system is under attack, kick them back.
-        // We need to test for this after validation because we
-        // don't want it to affect a valid login.
-
-        // If throttling time is above zero, we can't allow
-        // logins now.
-        $time = (int)$this->isThrottled($user['email']);
-        if ($time > 0)
-        {
-            $this->error = sprintf(lang('auth.throttled'), $time);
-            return false;
-        }
-
-        $this->loginUser($user);
-
-        if ($remember)
-        {
-            $this->rememberUser($user);
-        }
-
-        Events::trigger('didLogin', [$user]);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Validates user login information without logging them in.
-     *
-     * $credentials is an array of key/value pairs needed to log the user in.
-     * This is often email/password, or username/password.
-     *
-     * @param $credentials
-     * @param bool $return_user
-     * @return mixed
-     */
-    public function validate($credentials, $return_user=false)
-    {
-        // Can't validate without a password.
-        if (empty($credentials['password']) || count($credentials) < 2)
-        {
-            return null;
-        }
-
-        $password = $credentials['password'];
-        unset($credentials['password']);
-
-	    // We should only be allowed 1 single other credential to
-	    // test against.
-	    if (count($credentials) > 1)
-	    {
-		    $this->error = lang('auth.too_many_credentials');
-		    return false;
-	    }
-
-        // Ensure that the fields are allowed validation fields
-	    if (! in_array(key($credentials), config_item('auth.valid_fields')) )
-	    {
-		    $this->error = lang('auth.invalid_credentials');
-		    return false;
-	    }
-
-        // We do not want to force case-sensitivity on things
-        // like username and email for usability sake.
-        if (! empty($credentials['email']))
-        {
-            $credentials['email'] = strtolower($credentials['email']);
-        }
-
-        // Can we find a user with those credentials?
-        $user = $this->user_model->as_array()
-                                 ->where($credentials)
-                                 ->first();
-
-        if (! $user)
-        {
-            $this->error = lang('auth.invalid_user');
-            return false;
-        }
-
-        // Now, try matching the passwords.
-        $result =  password_verify($password, $user['password_hash']);
-
-        if (! $result)
-        {
-            $this->error = lang('auth.invalid_password');
-            $this->ci->login_model->recordLoginAttempt($user['email']);
-            return false;
-        }
-
-        // Check to see if the password needs to be rehashed.
-        // This would be due to the hash algorithm or hash
-        // cost changing since the last time that a user
-        // logged in.
-        if (password_needs_rehash($user['password_hash'], PASSWORD_DEFAULT, ['cost' => config_item('auth.hash_cost')] ))
-        {
-            $new_hash = Password::hashPassword($password);
-            $this->user_model->skip_validation()
-                             ->update($user['id'], ['password_hash' => $new_hash]);
-            unset($new_hash);
-        }
-
-        // Is the user active?
-        if (! $user['active'])
-        {
-            $this->error = lang('auth.inactive_account');
-            return false;
-        }
-
-        return $return_user ? $user : true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Logs a user out and removes all session information.
-     *
-     * @return mixed
-     */
-    public function logout()
-    {
-        $this->ci->load->helper('cookie');
-
-        if (! Events::trigger('beforeLogout', [$this->user]))
-        {
-            return false;
-        }
-
-        // Destroy the session data - but ensure a session is still
-        // available for flash messages, etc.
-        if (isset($_SESSION))
-        {
-            foreach ( $_SESSION as $key => $value )
-            {
-                $_SESSION[ $key ] = NULL;
-                unset( $_SESSION[ $key ] );
-            }
-        }
-        // Also, regenerate the session ID for a touch of added safety.
-        $this->ci->session->sess_regenerate(true);
-
-        // Take care of any rememberme functionality.
-        if (config_item('auth.allow_remembering'))
-        {
-            $token = get_cookie('remember');
-
-            $this->invalidateRememberCookie($this->user['email'], $token);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Checks whether a user is logged in or not.
-     *
-     * @return bool
-     */
-    public function isLoggedIn()
-    {
-        $id = $this->ci->session->userdata('logged_in');
-
-        if (! $id)
-        {
-            return false;
-        }
-
-        // If the user var hasn't been filled in, we need to fill it in,
-        // since this method will typically be used as the only method
-        // to determine whether a user is logged in or not.
-        if (! $this->user)
-        {
-            $this->user = $this->user_model->as_array()
-                                           ->find_by('id', (int)$id);
-
-            if (empty($this->user))
-            {
-                return false;
-            }
-        }
-
-        // If logged in, ensure cache control
-        // headers are in place
-        $this->setHeaders();
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Attempts to log a user in based on the "remember me" cookie.
-     *
-     * @return bool
-     */
-    public function viaRemember()
-    {
-        if (! config_item('auth.allow_remembering'))
-        {
-            return false;
-        }
-
-        $this->ci->load->helper('cookie');
-
-        if (! $token = get_cookie('remember'))
-        {
-            return false;
-        }
-
-        // Attempt to match the token against our auth_tokens table.
-        $query = $this->ci->db->where('hash', $this->ci->login_model->hashRememberToken($token))
-                              ->get('auth_tokens');
-
-        if (! $query->num_rows())
-        {
-            return false;
-        }
-
-        // Grab the user
-        $email = $query->row()->email;
-
-        $user = $this->user_model->as_array()
-                                 ->find_by('email', $email);
-
-        $this->loginUser($user);
-
-        // We only want our remember me tokens to be valid
-        // for a single use.
-        $this->refreshRememberCookie($user, $token);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Registers a new user and handles activation method.
-     *
-     * @param $user_data
-     * @return bool
-     */
-    public function registerUser($user_data)
-    {
-        // Anything special needed for Activation?
-        $method = config_item('auth.activation_method');
-
-        $user_data['active'] = $method == 'auto' ? 1 : 0;
-
-        // If via email, we need to generate a hash
-        $this->ci->load->helper('string');
-        $token = random_string('alnum', 24);
-        $user_data['activate_hash'] = hash('sha1', config_item('auth.salt') . $token);
-
-        // Email should NOT be case sensitive.
-        if (! empty($user_data['email']))
-        {
-            $user_data['email'] = strtolower($user_data['email']);
-        }
-
-        // Save the user
-        if (! $id = $this->user_model->insert($user_data))
-        {
-            $this->error = $this->user_model->error();
-            return false;
-        }
-
-        $data = [
-            'user_id' => $id,
-            'email'   => $user_data['email'],
-            'token'   => $token,
-            'method'  => $method
-        ];
-
-        Events::trigger('didRegisterUser', [$data]);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Used to verify the user values and activate a user so they can
-     * visit the site.
-     *
-     * @param $data
-     * @return bool
-     */
-    public function activateUser($data)
-    {
-        $post = [
-            'email'         => $data['email'],
-            'activate_hash' => hash('sha1', config_item('auth.salt') . $data['code'])
-        ];
-
-        $user = $this->user_model->where($post)
-                                 ->first();
-
-        if (! $user) {
-            $this->error = $this->user_model->error() ? $this->user_model->error() : lang('auth.activate_no_user');
-
-            return false;
-        }
-
-        if (! $this->user_model->update($user->id, ['active' => 1, 'activate_hash' => null]))
-        {
-            $this->error = $this->user_model->error();
-            return false;
-        }
-
-        Events::trigger('didActivate', [(array)$user]);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Used to allow manual activation of a user with a known ID.
-     *
-     * @param $id
-     * @return bool
-     */
-    public function activateUserById($id)
-    {
-        if (! $this->user_model->update($id, ['active' => 1, 'activate_hash' => null]))
-        {
-            $this->error = $this->user_model->error();
-            return false;
-        }
-
-        Events::trigger('didActivate', [$this->user_model->as_array()->find($id)]);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Grabs the current user object. Returns NULL if nothing found.
-     *
-     * @return array|null
-     */
-    public function user()
-    {
-        return $this->user;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * A convenience method to grab the current user's ID.
-     *
-     * @return int|null
-     */
-    public function id()
-    {
-        if (! is_array($this->user) || empty($this->user['id']))
-        {
-            return null;
-        }
-
-        return (int)$this->user['id'];
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Checks to see if the user is currently being throttled.
-     *
-     *  - If they are NOT, will return FALSE.
-     *  - If they ARE, will return the number of seconds until they can try again.
-     *
-     * @param $email
-     * @return mixed
-     */
-    public function isThrottled($email)
-    {
-        // Not throttling? Get outta here!
-        if (! config_item('auth.allow_throttling'))
-        {
-            return false;
-        }
-
-        // Emails should NOT be case sensitive.
-        $email = strtolower($email);
-
-        // Have any attempts been made?
-        $attempts = $this->ci->login_model->countLoginAttempts($email);
-
-        // Grab the amount of time to add if the system thinks we're
-        // under a distributed brute force attack.
-        // Affect users that have at least 1 failure login attempt
-        $dbrute_time = ($attempts === 0) ? 0 : $this->ci->login_model->distributedBruteForceTime();
-
-        // If this user was found to possibly be under a brute
-        // force attack, their account would have been banned
-        // for 15 minutes.
-        if ($time = isset($_SESSION['bruteBan']) ? $_SESSION['bruteBan'] : false)
-        {
-            // If the current time is less than the
-            // the ban expiration, plus any distributed time
-            // then the user can't login just yet.
-            if ($time + $dbrute_time > time())
-            {
-                // The user is banned still...
-                $this->error = lang('auth.bruteBan_notice');
-                return ($time + $dbrute_time) - time();
-            }
-
-            // Still here? The the ban time is over...
-            unset($_SESSION['bruteBan']);
-        }
-
-        // Grab the time of last attempt and
-        // determine if we're throttled by amount of time passed.
-        $last_time = $this->ci->login_model->lastLoginAttemptTime($email);
-
-        $allowed = config_item('auth.allowed_login_attempts');
-
-        // We're not throttling if there are 0 attempts or
-        // the number is less than or equal to the allowed free attempts
-        if ($attempts === 0 || $attempts <= $allowed)
-        {
-            // Before we can say there's nothing up here,
-            // we need to check dbrute time.
-            $time_left = $last_time + $dbrute_time - time();
-
-            if ($time_left > 0)
-            {
-                return $time_left;
-            }
-
-            return false;
-        }
-
-        // If the number of attempts is excessive (above 100) we need
-        // to check the elapsed time of all of these attacks. If they are
-        // less than 1 minute it's obvious this is a brute force attack,
-        // so we'll set a session flag and block that user for 15 minutes.
-        if ($attempts > 100 && $this->ci->login_model->isBruteForced($email))
-        {
-            $this->error = lang('auth.bruteBan_notice');
-
-            $ban_time = 60 * 15;    // 15 minutes
-            $_SESSION['bruteBan'] = time() + $ban_time;
-            return $ban_time;
-        }
-
-        // Get our allowed attempts out of the picture.
-        $attempts = $attempts - $allowed;
-
-        $max_time = config_item('auth.max_throttle_time');
-
-        $add_time = pow(5, $attempts);
-
-        if ($add_time > $max_time)
-        {
-            $add_time = $max_time;
-        }
-
-        $next_time = $last_time + $add_time + $dbrute_time;
-
-        $current = time();
-
-        // We are NOT throttled if we are already
-        // past the allowed time.
-        if ($current > $next_time)
-        {
-            return false;
-        }
-
-        return $next_time - $current;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Sends a password reset link email to the user associated with
-     * the passed in $email.
-     *
-     * @param $email
-     * @return mixed
-     */
-    public function remindUser($email)
-    {
-        // Emails should NOT be case sensitive.
-        $email = strtolower($email);
-
-        // Is it a valid user?
-        $user = $this->user_model->find_by('email', $email);
-
-        if (! $user)
-        {
-            $this->error = lang('auth.invalid_email');
-            return false;
-        }
-
-        // Generate/store our codes
-        $this->ci->load->helper('string');
-        $token = random_string('alnum', 24);
-        $hash = hash('sha1', config_item('auth.salt') .$token);
-
-        $result = $this->user_model->update($user->id, ['reset_hash' => $hash]);
-
-        if (! $result)
-        {
-            $this->error = $this->user_model->error();
-            return false;
-        }
-
-        Events::trigger('didRemindUser', [(array)$user, $token]);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Validates the credentials provided and, if valid, resets the password.
-     *
-     * The $credentials array MUST contain a 'code' key with the string to
-     * hash and check against the reset_hash.
-     *
-     * @param $credentials
-     * @param $password
-     * @param $passConfirm
-     * @return mixed
-     */
-    public function resetPassword($credentials, $password, $passConfirm)
-    {
-        if (empty($credentials['code']))
-        {
-            $this->error = lang('auth.need_reset_code');
-            return false;
-        }
-
-        // Generate a hash to match against the table.
-        $credentials['reset_hash'] = hash('sha1', config_item('auth.salt') .$credentials['code']);
-        unset($credentials['code']);
-
-        if (! empty($credentials['email']))
-        {
-            $credentials['email'] = strtolower($credentials['email']);
-        }
-
-        // Is there a matching user?
-        $user = $this->user_model->find_by($credentials);
-
-        if (! $user)
-        {
-            $this->error = lang('auth.reset_no_user');
-            return false;
-        }
-
-        // Update their password and reset their reset_hash
-        $data = [
-            'password'     => $password,
-            'pass_confirm' => $passConfirm,
-            'reset_hash'   => null
-        ];
-
-        if (! $this->user_model->update($user->id, $data))
-        {
-            $this->error = $this->user_model->error();
-            return false;
-        }
-
-        Events::trigger('didResetPassword', [(array)$user]);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Provides a way for implementations to allow new statuses to be set
-     * on the user. The details will vary based upon implementation, but
-     * will often allow for banning or suspending users.
-     *
-     * @param $newStatus
-     * @param null $message
-     * @return mixed
-     */
-    public function changeStatus($newStatus, $message=null)
-    {
-        // todo actually record new users status!
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Allows the consuming application to pass in a reference to the
-     * model that should be used.
-     *
-     * The model MUST extend Myth\Models\CIDbModel.
-     *
-     * @param $model
-     * @param bool $allow_any_parent
-     * @return mixed
-     */
-    public function useModel($model, $allow_any_parent=false)
-    {
-        if (! $allow_any_parent && get_parent_class($model) != 'Myth\Models\CIDbModel')
-        {
-            throw new \RuntimeException('Models passed into LocalAuthenticate MUST extend Myth\Models\CIDbModel');
-        }
-
-        $this->user_model =& $model;
-
-        return $this;
-    }
-
-    //--------------------------------------------------------------------
-
-    public function error()
-    {
-        if (validation_errors())
-        {
-            return validation_errors();
-        }
-
-        return $this->error;
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Login Records
-    //--------------------------------------------------------------------
-
-    /**
-     * Purges all login attempt records from the database.
-     *
-     * @param $email
-     */
-    public function purgeLoginAttempts($email)
-    {
-        // Emails should NOT be case sensitive.
-        $email = strtolower($email);
-
-        $this->ci->login_model->purgeLoginAttempts($email);
-
-        // @todo record activity of login attempts purge.
-        Events::trigger('didPurgeLoginAttempts', [$email]);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Purges all remember tokens for a single user. Effectively logs
-     * a user out of all devices. Intended to allow users to log themselves
-     * out of all devices as a security measure.
-     *
-     * @param $email
-     */
-    public function purgeRememberTokens($email)
-    {
-        // Emails should NOT be case sensitive.
-        $email = strtolower($email);
-
-        $this->ci->login_model->purgeRememberTokens($email);
-
-        // todo record activity of remember me purges.
-        Events::trigger('didPurgeRememberTokens', [$email]);
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Protected Methods
-    //--------------------------------------------------------------------
-
-    /**
-     * Check if Allow Persistent Login Cookies is enable
-     *
-     * @param $user
-     */
-    protected function rememberUser($user)
-    {
-        if (! config_item('auth.allow_remembering'))
-        {
-            log_message('debug', 'Auth library set to refuse "Remember Me" functionality.');
-            return false;
-        }
-
-        $this->refreshRememberCookie($user);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Invalidates the current rememberme cookie/database entry, creates
-     * a new one, stores it and returns the new value.
-     *
-     * @param $user
-     * @param null $token
-     * @return mixed
-     */
-    protected function refreshRememberCookie($user, $token=null)
-    {
-        $this->ci->load->helper('cookie');
-
-        // If a token is passed in, we know we're removing the
-        // old one.
-        if (! empty($token))
-        {
-            $this->invalidateRememberCookie($user['email'], $token);
-        }
-
-        $new_token = $this->ci->login_model->generateRememberToken($user);
-
-        // Save the token to the database.
-        $data = [
-            'email'   => $user['email'],
-            'hash'    => sha1(config_item('auth.salt') . $new_token),
-            'created' => date('Y-m-d H:i:s')
-        ];
-
-        $this->ci->db->insert('auth_tokens', $data);
-
-        // Create the cookie
-        set_cookie(
-            'remember',                             // Cookie Name
-            $new_token,                             // Value
-            config_item('auth.remember_length'),    // # Seconds until it expires
-            config_item('cookie_domain'),
-            config_item('cookie_path'),
-            config_item('cookie_prefix'),
-            false,                                  // Only send over HTTPS?
-            true                                    // Hide from Javascript?
-        );
-
-        return $new_token;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Deletes any current remember me cookies and database entries.
-     *
-     * @param $email
-     * @param $token
-     * @return string The new token (not the hash).
-     */
-    protected function invalidateRememberCookie($email, $token)
-    {
-        // Emails should NOT be case sensitive.
-        $email = strtolower($email);
-
-        // Remove from the database
-        $this->ci->login_model->deleteRememberToken($email, $token);
-
-        // Remove the cookie
-        delete_cookie(
-            'remember',
-            config_item('cookie_domain'),
-            config_item('cookie_path'),
-            config_item('cookie_prefix')
-        );
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Handles the nitty gritty of actually logging our user into the system.
-     * Does NOT perform the authentication, just sets the system up so that
-     * it knows we're here.
-     *
-     * @param $user
-     */
-    protected function loginUser($user)
-    {
-        // Save the user for later access
-        $this->user = $user;
-
-        // Regenerate the session ID to help protect
-        // against session fixation
-        $this->ci->session->sess_regenerate();
-
-        // Let the session know that we're logged in.
-        $this->ci->session->set_userdata('logged_in', $user['id']);
-
-        // Clear our login attempts
-        $this->ci->login_model->purgeLoginAttempts($user['email']);
-
-        // Record a new Login
-        $this->ci->login_model->recordLogin($user);
-
-        // If logged in, ensure cache control
-        // headers are in place
-        $this->setHeaders();
-
-        // We'll give a 20% chance to need to do a purge since we
-        // don't need to purge THAT often, it's just a maintenance issue.
-        // to keep the table from getting out of control.
-        if (mt_rand(1, 100) < 20)
-        {
-            $this->ci->login_model->purgeOldRememberTokens();
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Sets the headers to ensure that pages are not cached when a user
-     * is logged in, helping to protect against logging out and then
-     * simply hitting the Back button on the browser and getting private
-     * information because the page was loaded from cache.
-     */
-    protected function setHeaders()
-    {
-        $this->ci->output->set_header('Cache-Control: no-store, no-cache, must-revalidate');
-        $this->ci->output->set_header('Cache-Control: post-check=0, pre-check=0');
-        $this->ci->output->set_header('Pragma: no-cache');
-    }
-
-    //--------------------------------------------------------------------
+	protected $ci;
+
+	protected $user = null;
+
+	public $user_model = null;
+
+	public $error = null;
+
+	//--------------------------------------------------------------------
+
+	public function __construct( $ci=null )
+	{
+		if ($ci)
+		{
+			$this->ci= $ci;
+		}
+		else
+		{
+			$this->ci =& get_instance();
+		}
+
+		// Get our compatibility password file loaded up.
+		if (! function_exists('password_hash'))
+		{
+			require_once dirname(__FILE__) .'password.php';
+		}
+
+		if (empty($this->ci->session))
+		{
+			$this->ci->load->library('session');
+		}
+
+		$this->ci->config->load('auth');
+		$this->ci->load->model('auth/login_model');
+		$this->ci->load->language('auth/auth');
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Attempt to log a user into the system.
+	 *
+	 * $credentials is an array of key/value pairs needed to log the user in.
+	 * This is often email/password, or username/password.
+	 *
+	 * @param array $credentials
+	 * @param bool  $remember
+	 * @return bool|mixed
+	 */
+	public function login($credentials, $remember=false)
+	{
+		$user = $this->validate($credentials, true);
+
+		if (! $user)
+		{
+			// We need to send an error even if no
+			// user was found!
+			$this->error = lang('auth.invalid_user');
+
+			// If an email is present, log the attempt
+			if (! empty($credentials['email']) )
+			{
+				$this->ci->login_model->recordLoginAttempt($credentials['email']);
+			}
+
+			$this->user = null;
+			return $user;
+		}
+
+		// If the user is throttled due to too many invalid logins
+		// or the system is under attack, kick them back.
+		// We need to test for this after validation because we
+		// don't want it to affect a valid login.
+
+		// If throttling time is above zero, we can't allow
+		// logins now.
+		$time = (int)$this->isThrottled($user['email']);
+		if ($time > 0)
+		{
+			$this->error = sprintf(lang('auth.throttled'), $time);
+			return false;
+		}
+
+		$this->loginUser($user);
+
+		if ($remember)
+		{
+			$this->rememberUser($user);
+		}
+
+		Events::trigger('didLogin', [$user]);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Validates user login information without logging them in.
+	 *
+	 * $credentials is an array of key/value pairs needed to log the user in.
+	 * This is often email/password, or username/password.
+	 *
+	 * @param $credentials
+	 * @param bool $return_user
+	 * @return mixed
+	 */
+	public function validate($credentials, $return_user=false)
+	{
+		// Can't validate without a password.
+		if (empty($credentials['password']) || count($credentials) < 2)
+		{
+			return null;
+		}
+
+		$password = $credentials['password'];
+		unset($credentials['password']);
+
+		// We should only be allowed 1 single other credential to
+		// test against.
+		if (count($credentials) > 1)
+		{
+			$this->error = lang('auth.too_many_credentials');
+			return false;
+		}
+
+		// Ensure that the fields are allowed validation fields
+		if (! in_array(key($credentials), config_item('auth.valid_fields')) )
+		{
+			$this->error = lang('auth.invalid_credentials');
+			return false;
+		}
+
+		// We do not want to force case-sensitivity on things
+		// like username and email for usability sake.
+		if (! empty($credentials['email']))
+		{
+			$credentials['email'] = strtolower($credentials['email']);
+		}
+
+		// Can we find a user with those credentials?
+		$user = $this->user_model->as_array()
+								 ->where($credentials)
+								 ->first();
+
+		if (! $user)
+		{
+			$this->error = lang('auth.invalid_user');
+			return false;
+		}
+
+		// Now, try matching the passwords.
+		$result =  password_verify($password, $user['password_hash']);
+
+		if (! $result)
+		{
+			$this->error = lang('auth.invalid_password');
+			$this->ci->login_model->recordLoginAttempt($user['email']);
+			return false;
+		}
+
+		// Check to see if the password needs to be rehashed.
+		// This would be due to the hash algorithm or hash
+		// cost changing since the last time that a user
+		// logged in.
+		if (password_needs_rehash($user['password_hash'], PASSWORD_DEFAULT, ['cost' => config_item('auth.hash_cost')] ))
+		{
+			$new_hash = Password::hashPassword($password);
+			$this->user_model->skip_validation()
+							 ->update($user['id'], ['password_hash' => $new_hash]);
+			unset($new_hash);
+		}
+
+		// Is the user active?
+		if (! $user['active'])
+		{
+			$this->error = lang('auth.inactive_account');
+			return false;
+		}
+
+		return $return_user ? $user : true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Logs a user out and removes all session information.
+	 *
+	 * @return mixed
+	 */
+	public function logout()
+	{
+		$this->ci->load->helper('cookie');
+
+		if (! Events::trigger('beforeLogout', [$this->user]))
+		{
+			return false;
+		}
+
+		// Destroy the session data - but ensure a session is still
+		// available for flash messages, etc.
+		if (isset($_SESSION))
+		{
+			foreach ( $_SESSION as $key => $value )
+			{
+				$_SESSION[ $key ] = NULL;
+				unset( $_SESSION[ $key ] );
+			}
+		}
+		// Also, regenerate the session ID for a touch of added safety.
+		$this->ci->session->sess_regenerate(true);
+
+		// Take care of any rememberme functionality.
+		if (config_item('auth.allow_remembering'))
+		{
+			$token = get_cookie('remember');
+
+			$this->invalidateRememberCookie($this->user['email'], $token);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks whether a user is logged in or not.
+	 *
+	 * @return bool
+	 */
+	public function isLoggedIn()
+	{
+		$id = $this->ci->session->userdata('logged_in');
+
+		if (! $id)
+		{
+			return false;
+		}
+
+		// If the user var hasn't been filled in, we need to fill it in,
+		// since this method will typically be used as the only method
+		// to determine whether a user is logged in or not.
+		if (! $this->user)
+		{
+			$this->user = $this->user_model->as_array()
+										   ->find_by('id', (int)$id);
+
+			if (empty($this->user))
+			{
+				return false;
+			}
+		}
+
+		// If logged in, ensure cache control
+		// headers are in place
+		$this->setHeaders();
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Attempts to log a user in based on the "remember me" cookie.
+	 *
+	 * @return bool
+	 */
+	public function viaRemember()
+	{
+		if (! config_item('auth.allow_remembering'))
+		{
+			return false;
+		}
+
+		$this->ci->load->helper('cookie');
+
+		if (! $token = get_cookie('remember'))
+		{
+			return false;
+		}
+
+		// Attempt to match the token against our auth_tokens table.
+		$query = $this->ci->db->where('hash', $this->ci->login_model->hashRememberToken($token))
+							  ->get('auth_tokens');
+
+		if (! $query->num_rows())
+		{
+			return false;
+		}
+
+		// Grab the user
+		$email = $query->row()->email;
+
+		$user = $this->user_model->as_array()
+								 ->find_by('email', $email);
+
+		$this->loginUser($user);
+
+		// We only want our remember me tokens to be valid
+		// for a single use.
+		$this->refreshRememberCookie($user, $token);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Registers a new user and handles activation method.
+	 *
+	 * @param $user_data
+	 * @return bool
+	 */
+	public function registerUser($user_data)
+	{
+		// Anything special needed for Activation?
+		$method = config_item('auth.activation_method');
+
+		$user_data['active'] = $method == 'auto' ? 1 : 0;
+
+		// If via email, we need to generate a hash
+		$this->ci->load->helper('string');
+		$token = random_string('alnum', 24);
+		$user_data['activate_hash'] = hash('sha1', config_item('auth.salt') . $token);
+
+		// Email should NOT be case sensitive.
+		if (! empty($user_data['email']))
+		{
+			$user_data['email'] = strtolower($user_data['email']);
+		}
+
+		// Save the user
+		if (! $id = $this->user_model->insert($user_data))
+		{
+			$this->error = $this->user_model->error();
+			return false;
+		}
+
+		$data = [
+			'user_id' => $id,
+			'email'   => $user_data['email'],
+			'token'   => $token,
+			'method'  => $method
+		];
+
+		Events::trigger('didRegisterUser', [$data]);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Used to verify the user values and activate a user so they can
+	 * visit the site.
+	 *
+	 * @param $data
+	 * @return bool
+	 */
+	public function activateUser($data)
+	{
+		$post = [
+			'email'         => $data['email'],
+			'activate_hash' => hash('sha1', config_item('auth.salt') . $data['code'])
+		];
+
+		$user = $this->user_model->where($post)
+								 ->first();
+
+		if (! $user) {
+			$this->error = $this->user_model->error() ? $this->user_model->error() : lang('auth.activate_no_user');
+
+			return false;
+		}
+
+		if (! $this->user_model->update($user->id, ['active' => 1, 'activate_hash' => null]))
+		{
+			$this->error = $this->user_model->error();
+			return false;
+		}
+
+		Events::trigger('didActivate', [(array)$user]);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Used to allow manual activation of a user with a known ID.
+	 *
+	 * @param $id
+	 * @return bool
+	 */
+	public function activateUserById($id)
+	{
+		if (! $this->user_model->update($id, ['active' => 1, 'activate_hash' => null]))
+		{
+			$this->error = $this->user_model->error();
+			return false;
+		}
+
+		Events::trigger('didActivate', [$this->user_model->as_array()->find($id)]);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Grabs the current user object. Returns NULL if nothing found.
+	 *
+	 * @return array|null
+	 */
+	public function user()
+	{
+		return $this->user;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * A convenience method to grab the current user's ID.
+	 *
+	 * @return int|null
+	 */
+	public function id()
+	{
+		if (! is_array($this->user) || empty($this->user['id']))
+		{
+			return null;
+		}
+
+		return (int)$this->user['id'];
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks to see if the user is currently being throttled.
+	 *
+	 *  - If they are NOT, will return FALSE.
+	 *  - If they ARE, will return the number of seconds until they can try again.
+	 *
+	 * @param $email
+	 * @return mixed
+	 */
+	public function isThrottled($email)
+	{
+		// Not throttling? Get outta here!
+		if (! config_item('auth.allow_throttling'))
+		{
+			return false;
+		}
+
+		// Emails should NOT be case sensitive.
+		$email = strtolower($email);
+
+		// Have any attempts been made?
+		$attempts = $this->ci->login_model->countLoginAttempts($email);
+
+		// Grab the amount of time to add if the system thinks we're
+		// under a distributed brute force attack.
+		// Affect users that have at least 1 failure login attempt
+		$dbrute_time = ($attempts === 0) ? 0 : $this->ci->login_model->distributedBruteForceTime();
+
+		// If this user was found to possibly be under a brute
+		// force attack, their account would have been banned
+		// for 15 minutes.
+		if ($time = isset($_SESSION['bruteBan']) ? $_SESSION['bruteBan'] : false)
+		{
+			// If the current time is less than the
+			// the ban expiration, plus any distributed time
+			// then the user can't login just yet.
+			if ($time + $dbrute_time > time())
+			{
+				// The user is banned still...
+				$this->error = lang('auth.bruteBan_notice');
+				return ($time + $dbrute_time) - time();
+			}
+
+			// Still here? The the ban time is over...
+			unset($_SESSION['bruteBan']);
+		}
+
+		// Grab the time of last attempt and
+		// determine if we're throttled by amount of time passed.
+		$last_time = $this->ci->login_model->lastLoginAttemptTime($email);
+
+		$allowed = config_item('auth.allowed_login_attempts');
+
+		// We're not throttling if there are 0 attempts or
+		// the number is less than or equal to the allowed free attempts
+		if ($attempts === 0 || $attempts <= $allowed)
+		{
+			// Before we can say there's nothing up here,
+			// we need to check dbrute time.
+			$time_left = $last_time + $dbrute_time - time();
+
+			if ($time_left > 0)
+			{
+				return $time_left;
+			}
+
+			return false;
+		}
+
+		// If the number of attempts is excessive (above 100) we need
+		// to check the elapsed time of all of these attacks. If they are
+		// less than 1 minute it's obvious this is a brute force attack,
+		// so we'll set a session flag and block that user for 15 minutes.
+		if ($attempts > 100 && $this->ci->login_model->isBruteForced($email))
+		{
+			$this->error = lang('auth.bruteBan_notice');
+
+			$ban_time = 60 * 15;    // 15 minutes
+			$_SESSION['bruteBan'] = time() + $ban_time;
+			return $ban_time;
+		}
+
+		// Get our allowed attempts out of the picture.
+		$attempts = $attempts - $allowed;
+
+		$max_time = config_item('auth.max_throttle_time');
+
+		$add_time = pow(5, $attempts);
+
+		if ($add_time > $max_time)
+		{
+			$add_time = $max_time;
+		}
+
+		$next_time = $last_time + $add_time + $dbrute_time;
+
+		$current = time();
+
+		// We are NOT throttled if we are already
+		// past the allowed time.
+		if ($current > $next_time)
+		{
+			return false;
+		}
+
+		return $next_time - $current;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Sends a password reset link email to the user associated with
+	 * the passed in $email.
+	 *
+	 * @param $email
+	 * @return mixed
+	 */
+	public function remindUser($email)
+	{
+		// Emails should NOT be case sensitive.
+		$email = strtolower($email);
+
+		// Is it a valid user?
+		$user = $this->user_model->find_by('email', $email);
+
+		if (! $user)
+		{
+			$this->error = lang('auth.invalid_email');
+			return false;
+		}
+
+		// Generate/store our codes
+		$this->ci->load->helper('string');
+		$token = random_string('alnum', 24);
+		$hash = hash('sha1', config_item('auth.salt') .$token);
+
+		$result = $this->user_model->update($user->id, ['reset_hash' => $hash]);
+
+		if (! $result)
+		{
+			$this->error = $this->user_model->error();
+			return false;
+		}
+
+		Events::trigger('didRemindUser', [(array)$user, $token]);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Validates the credentials provided and, if valid, resets the password.
+	 *
+	 * The $credentials array MUST contain a 'code' key with the string to
+	 * hash and check against the reset_hash.
+	 *
+	 * @param $credentials
+	 * @param $password
+	 * @param $passConfirm
+	 * @return mixed
+	 */
+	public function resetPassword($credentials, $password, $passConfirm)
+	{
+		if (empty($credentials['code']))
+		{
+			$this->error = lang('auth.need_reset_code');
+			return false;
+		}
+
+		// Generate a hash to match against the table.
+		$credentials['reset_hash'] = hash('sha1', config_item('auth.salt') .$credentials['code']);
+		unset($credentials['code']);
+
+		if (! empty($credentials['email']))
+		{
+			$credentials['email'] = strtolower($credentials['email']);
+		}
+
+		// Is there a matching user?
+		$user = $this->user_model->find_by($credentials);
+
+		if (! $user)
+		{
+			$this->error = lang('auth.reset_no_user');
+			return false;
+		}
+
+		// Update their password and reset their reset_hash
+		$data = [
+			'password'     => $password,
+			'pass_confirm' => $passConfirm,
+			'reset_hash'   => null
+		];
+
+		if (! $this->user_model->update($user->id, $data))
+		{
+			$this->error = $this->user_model->error();
+			return false;
+		}
+
+		Events::trigger('didResetPassword', [(array)$user]);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Provides a way for implementations to allow new statuses to be set
+	 * on the user. The details will vary based upon implementation, but
+	 * will often allow for banning or suspending users.
+	 *
+	 * @param $newStatus
+	 * @param null $message
+	 * @return mixed
+	 */
+	public function changeStatus($newStatus, $message=null)
+	{
+		// todo actually record new users status!
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Allows the consuming application to pass in a reference to the
+	 * model that should be used.
+	 *
+	 * The model MUST extend Myth\Models\CIDbModel.
+	 *
+	 * @param $model
+	 * @param bool $allow_any_parent
+	 * @return mixed
+	 */
+	public function useModel($model, $allow_any_parent=false)
+	{
+		if (! $allow_any_parent && get_parent_class($model) != 'Myth\Models\CIDbModel')
+		{
+			throw new \RuntimeException('Models passed into LocalAuthenticate MUST extend Myth\Models\CIDbModel');
+		}
+
+		$this->user_model =& $model;
+
+		return $this;
+	}
+
+	//--------------------------------------------------------------------
+
+	public function error()
+	{
+		if (validation_errors())
+		{
+			return validation_errors();
+		}
+
+		return $this->error;
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Login Records
+	//--------------------------------------------------------------------
+
+	/**
+	 * Purges all login attempt records from the database.
+	 *
+	 * @param $email
+	 */
+	public function purgeLoginAttempts($email)
+	{
+		// Emails should NOT be case sensitive.
+		$email = strtolower($email);
+
+		$this->ci->login_model->purgeLoginAttempts($email);
+
+		// @todo record activity of login attempts purge.
+		Events::trigger('didPurgeLoginAttempts', [$email]);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Purges all remember tokens for a single user. Effectively logs
+	 * a user out of all devices. Intended to allow users to log themselves
+	 * out of all devices as a security measure.
+	 *
+	 * @param $email
+	 */
+	public function purgeRememberTokens($email)
+	{
+		// Emails should NOT be case sensitive.
+		$email = strtolower($email);
+
+		$this->ci->login_model->purgeRememberTokens($email);
+
+		// todo record activity of remember me purges.
+		Events::trigger('didPurgeRememberTokens', [$email]);
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Protected Methods
+	//--------------------------------------------------------------------
+
+	/**
+	 * Check if Allow Persistent Login Cookies is enable
+	 *
+	 * @param $user
+	 */
+	protected function rememberUser($user)
+	{
+		if (! config_item('auth.allow_remembering'))
+		{
+			log_message('debug', 'Auth library set to refuse "Remember Me" functionality.');
+			return false;
+		}
+
+		$this->refreshRememberCookie($user);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Invalidates the current rememberme cookie/database entry, creates
+	 * a new one, stores it and returns the new value.
+	 *
+	 * @param $user
+	 * @param null $token
+	 * @return mixed
+	 */
+	protected function refreshRememberCookie($user, $token=null)
+	{
+		$this->ci->load->helper('cookie');
+
+		// If a token is passed in, we know we're removing the
+		// old one.
+		if (! empty($token))
+		{
+			$this->invalidateRememberCookie($user['email'], $token);
+		}
+
+		$new_token = $this->ci->login_model->generateRememberToken($user);
+
+		// Save the token to the database.
+		$data = [
+			'email'   => $user['email'],
+			'hash'    => sha1(config_item('auth.salt') . $new_token),
+			'created' => date('Y-m-d H:i:s')
+		];
+
+		$this->ci->db->insert('auth_tokens', $data);
+
+		// Create the cookie
+		set_cookie(
+			'remember',                             // Cookie Name
+			$new_token,                             // Value
+			config_item('auth.remember_length'),    // # Seconds until it expires
+			config_item('cookie_domain'),
+			config_item('cookie_path'),
+			config_item('cookie_prefix'),
+			false,                                  // Only send over HTTPS?
+			true                                    // Hide from Javascript?
+		);
+
+		return $new_token;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Deletes any current remember me cookies and database entries.
+	 *
+	 * @param $email
+	 * @param $token
+	 * @return string The new token (not the hash).
+	 */
+	protected function invalidateRememberCookie($email, $token)
+	{
+		// Emails should NOT be case sensitive.
+		$email = strtolower($email);
+
+		// Remove from the database
+		$this->ci->login_model->deleteRememberToken($email, $token);
+
+		// Remove the cookie
+		delete_cookie(
+			'remember',
+			config_item('cookie_domain'),
+			config_item('cookie_path'),
+			config_item('cookie_prefix')
+		);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Handles the nitty gritty of actually logging our user into the system.
+	 * Does NOT perform the authentication, just sets the system up so that
+	 * it knows we're here.
+	 *
+	 * @param $user
+	 */
+	protected function loginUser($user)
+	{
+		// Save the user for later access
+		$this->user = $user;
+
+		// Regenerate the session ID to help protect
+		// against session fixation
+		$this->ci->session->sess_regenerate();
+
+		// Let the session know that we're logged in.
+		$this->ci->session->set_userdata('logged_in', $user['id']);
+
+		// Clear our login attempts
+		$this->ci->login_model->purgeLoginAttempts($user['email']);
+
+		// Record a new Login
+		$this->ci->login_model->recordLogin($user);
+
+		// If logged in, ensure cache control
+		// headers are in place
+		$this->setHeaders();
+
+		// We'll give a 20% chance to need to do a purge since we
+		// don't need to purge THAT often, it's just a maintenance issue.
+		// to keep the table from getting out of control.
+		if (mt_rand(1, 100) < 20)
+		{
+			$this->ci->login_model->purgeOldRememberTokens();
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Sets the headers to ensure that pages are not cached when a user
+	 * is logged in, helping to protect against logging out and then
+	 * simply hitting the Back button on the browser and getting private
+	 * information because the page was loaded from cache.
+	 */
+	protected function setHeaders()
+	{
+		$this->ci->output->set_header('Cache-Control: no-store, no-cache, must-revalidate');
+		$this->ci->output->set_header('Cache-Control: post-check=0, pre-check=0');
+		$this->ci->output->set_header('Pragma: no-cache');
+	}
+
+	//--------------------------------------------------------------------
 
 
 }

myth/Auth/Password.php

Indentation +321 added lines, -321 removed lines

@@ -51,325 +51,325 @@
  */
 class Password {
 
-    /**
-     * A standardized method for hasing a password before storing
-     * in the database.
-     *
-     * @param $password
-     * @return bool|mixed|string
-     */
-    public static function hashPassword($password)
-    {
-        if (! config_item('auth.hash_cost'))
-        {
-            get_instance()->load->config('auth');
-        }
-
-        return password_hash($password, PASSWORD_DEFAULT, ['cost' => config_item('auth.hash_cost')]);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Determines the number of entropy bits a password has based on
-     *
-     *
-     * @param $password
-     * @param bool $repeatcalc
-     * @return int
-     */
-    public static function getNISTNumBits($password, $repeatcalc = false)
-    {
-        $y = strlen($password);
-        if ($repeatcalc)
-        {
-            // Variant on NIST rules to reduce long sequences of repeated characters.
-            $result = 0;
-            $charmult = array_fill(0, 256, 1);
-            for ($x = 0; $x < $y; $x++)
-            {
-                $tempchr = ord(substr($password, $x, 1));
-                if ($x > 19)  $result += $charmult[$tempchr];
-                else if ($x > 7)  $result += $charmult[$tempchr] * 1.5;
-                else if ($x > 0)  $result += $charmult[$tempchr] * 2;
-                else  $result += 4;
-
-                $charmult[$tempchr] *= 0.75;
-            }
-
-            return $result;
-        }
-        else
-        {
-            if ($y > 20)  return 4 + (7 * 2) + (12 * 1.5) + $y - 20;
-            if ($y > 8)  return 4 + (7 * 2) + (($y - 8) * 1.5);
-            if ($y > 1)  return 4 + (($y - 1) * 2);
-
-            return ($y == 1 ? 4 : 0);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Determines whether a password is strong enough to use. You should check
-     * the password against this method and reject it if the password is not
-     * strong enough.
-     *
-     * The following guidelines come from the author's tests against 10.4 million actual passwords
-     * ( see post: http://cubicspot.blogspot.com/2012/01/how-to-calculate-password-strength-part.html )
-     * and represents the suggested minimum entropy bits for different types of sites:
-     *
-     *      - 18 bits of entropy = minimum for ANY website.
-     *      - 25 bits of entropy = minimum for a general purpose web service used relatively widely (e.g. Hotmail).
-     *      - 30 bits of entropy = minimum for a web service with business critical applications (e.g. SAAS).
-     *      - 40 bits of entropy = minimum for a bank or other financial service.
-     *
-     * The algorithm is based upon a modified version of the NIST rules which suggest the following:
-     *
-     *      - The first byte counts as 4 bits.
-     *      - The next 7 bytes count as 2 bits each.
-     *      - The next 12 bytes count as 1.5 bits each.
-     *      - Anything beyond that counts as 1 bit each.
-     *      - Mixed case + non-alphanumeric = up to 6 extra bits.
-     *
-     * @param string    $password   - The password to check
-     * @param int       $minbits    - Minimum "entropy bits" that is allowed
-     * @param bool      $usedict    - Should we check the password against a 300,000 word English dictionary?
-     * @param int       $minwordlen -
-     * @return bool
-     */
-    public static function isStrongPassword($password, $minbits = 18, $usedict = false, $minwordlen = 4)
-    {
-        // NIST password strength rules allow up to 6 extra bits for mixed case and non-alphabetic.
-        $upper = false;
-        $lower = false;
-        $numeric = false;
-        $other = false;
-        $space = false;
-        $y = strlen($password);
-        for ($x = 0; $x < $y; $x++)
-        {
-            $tempchr = ord(substr($password, $x, 1));
-            if ($tempchr >= ord("A") && $tempchr <= ord("Z"))  $upper = true;
-            else if ($tempchr >= ord("a") && $tempchr <= ord("z"))  $lower = true;
-            else if ($tempchr >= ord("0") && $tempchr <= ord("9"))  $numeric = true;
-            else if ($tempchr == ord(" "))  $space = true;
-            else  $other = true;
-        }
-        $extrabits = ($upper && $lower && $other ? ($numeric ? 6 : 5) : ($numeric && !$upper && !$lower ? ($other ? -2 : -6) : 0));
-        if (!$space)  $extrabits -= 2;
-        else if (count(explode(" ", preg_replace('/\s+/', " ", $password))) > 3)  $extrabits++;
-        $result = self::getNISTNumBits($password, true) + $extrabits;
-
-        $password = strtolower($password);
-        $revpassword = strrev($password);
-        $numbits = self::getNISTNumBits($password) + $extrabits;
-        if ($result > $numbits)  $result = $numbits;
-
-        // Remove QWERTY strings.
-        $qwertystrs = array(
-            "1234567890-qwertyuiopasdfghjkl;zxcvbnm,./",
-            "1qaz2wsx3edc4rfv5tgb6yhn7ujm8ik,9ol.0p;/-['=]:?_{\"+}",
-            "1qaz2wsx3edc4rfv5tgb6yhn7ujm8ik9ol0p",
-            "qazwsxedcrfvtgbyhnujmik,ol.p;/-['=]:?_{\"+}",
-            "qazwsxedcrfvtgbyhnujmikolp",
-            "]\"/=[;.-pl,0okm9ijn8uhb7ygv6tfc5rdx4esz3wa2q1",
-            "pl0okm9ijn8uhb7ygv6tfc5rdx4esz3wa2q1",
-            "]\"/[;.pl,okmijnuhbygvtfcrdxeszwaq",
-            "plokmijnuhbygvtfcrdxeszwaq",
-            "014725836914702583697894561230258/369*+-*/",
-            "abcdefghijklmnopqrstuvwxyz"
-        );
-        foreach ($qwertystrs as $qwertystr)
-        {
-            $qpassword = $password;
-            $qrevpassword = $revpassword;
-            $z = 6;
-            do
-            {
-                $y = strlen($qwertystr) - $z;
-                for ($x = 0; $x < $y; $x++)
-                {
-                    $str = substr($qwertystr, $x, $z);
-                    $qpassword = str_replace($str, "*", $qpassword);
-                    $qrevpassword = str_replace($str, "*", $qrevpassword);
-                }
-
-                $z--;
-            } while ($z > 2);
-
-            $numbits = self::getNISTNumBits($qpassword) + $extrabits;
-            if ($result > $numbits)  $result = $numbits;
-            $numbits = self::getNISTNumBits($qrevpassword) + $extrabits;
-            if ($result > $numbits)  $result = $numbits;
-
-            if ($result < $minbits)  return false;
-        }
-
-        if ($usedict && $result >= $minbits)
-        {
-            $passwords = array();
-
-            // Add keyboard shifting password variants.
-            $keyboardmap_down_noshift = array(
-                "z" => "", "x" => "", "c" => "", "v" => "", "b" => "", "n" => "", "m" => "", "," => "", "." => "", "/" => "", "<" => "", ">" => "", "?" => ""
-            );
-            if ($password == str_replace(array_keys($keyboardmap_down_noshift), array_values($keyboardmap_down_noshift), $password))
-            {
-                $keyboardmap_downright = array(
-                    "a" => "z",
-                    "q" => "a",
-                    "1" => "q",
-                    "s" => "x",
-                    "w" => "s",
-                    "2" => "w",
-                    "d" => "c",
-                    "e" => "d",
-                    "3" => "e",
-                    "f" => "v",
-                    "r" => "f",
-                    "4" => "r",
-                    "g" => "b",
-                    "t" => "g",
-                    "5" => "t",
-                    "h" => "n",
-                    "y" => "h",
-                    "6" => "y",
-                    "j" => "m",
-                    "u" => "j",
-                    "7" => "u",
-                    "i" => "k",
-                    "8" => "i",
-                    "o" => "l",
-                    "9" => "o",
-                    "0" => "p",
-                );
-
-                $keyboardmap_downleft = array(
-                    "2" => "q",
-                    "w" => "a",
-                    "3" => "w",
-                    "s" => "z",
-                    "e" => "s",
-                    "4" => "e",
-                    "d" => "x",
-                    "r" => "d",
-                    "5" => "r",
-                    "f" => "c",
-                    "t" => "f",
-                    "6" => "t",
-                    "g" => "v",
-                    "y" => "g",
-                    "7" => "y",
-                    "h" => "b",
-                    "u" => "h",
-                    "8" => "u",
-                    "j" => "n",
-                    "i" => "j",
-                    "9" => "i",
-                    "k" => "m",
-                    "o" => "k",
-                    "0" => "o",
-                    "p" => "l",
-                    "-" => "p",
-                );
-
-                $password2 = str_replace(array_keys($keyboardmap_downright), array_values($keyboardmap_downright), $password);
-                $passwords[] = $password2;
-                $passwords[] = strrev($password2);
-
-                $password2 = str_replace(array_keys($keyboardmap_downleft), array_values($keyboardmap_downleft), $password);
-                $passwords[] = $password2;
-                $passwords[] = strrev($password2);
-            }
-
-            // Deal with LEET-Speak substitutions.
-            $leetspeakmap = array(
-                "@" => "a",
-                "!" => "i",
-                "$" => "s",
-                "1" => "i",
-                "2" => "z",
-                "3" => "e",
-                "4" => "a",
-                "5" => "s",
-                "6" => "g",
-                "7" => "t",
-                "8" => "b",
-                "9" => "g",
-                "0" => "o"
-            );
-
-            $password2 = str_replace(array_keys($leetspeakmap), array_values($leetspeakmap), $password);
-            $passwords[] = $password2;
-            $passwords[] = strrev($password2);
-
-            $leetspeakmap["1"] = "l";
-            $password3 = str_replace(array_keys($leetspeakmap), array_values($leetspeakmap), $password);
-            if ($password3 != $password2)
-            {
-                $passwords[] = $password3;
-                $passwords[] = strrev($password3);
-            }
-
-            // Process the password, while looking for words in the dictionary.
-            $a = ord("a");
-            $z = ord("z");
-            $data = file_get_contents(DICTIONARY_PATH);
-            foreach ($passwords as $num => $password)
-            {
-                $y = strlen($password);
-                for ($x = 0; $x < $y; $x++)
-                {
-                    $tempchr = ord(substr($password, $x, 1));
-                    if ($tempchr >= $a && $tempchr <= $z)
-                    {
-                        for ($x2 = $x + 1; $x2 < $y; $x2++)
-                        {
-                            $tempchr = ord(substr($password, $x2, 1));
-                            if ($tempchr < $a || $tempchr > $z)  break;
-                        }
-
-                        $found = false;
-                        while (!$found && $x2 - $x >= $minwordlen)
-                        {
-                            $word = "/\\n" . substr($password, $x, $minwordlen);
-                            for ($x3 = $x + $minwordlen; $x3 < $x2; $x3++)  $word .= "(" . $password{$x3};
-                            for ($x3 = $x + $minwordlen; $x3 < $x2; $x3++)  $word .= ")?";
-                            $word .= "\\n/";
-
-                            preg_match_all($word, $data, $matches);
-                            if (!count($matches[0]))
-                            {
-                                $password{$x} = "*";
-                                $x++;
-                                $numbits = self::getNISTNumBits(substr($password, 0, $x)) + $extrabits;
-                                if ($numbits >= $minbits)  $found = true;
-                            }
-                            else
-                            {
-                                foreach ($matches[0] as $match)
-                                {
-                                    $password2 = str_replace(trim($match), "*", $password);
-                                    $numbits = self::getNISTNumBits($password2) + $extrabits;
-                                    if ($result > $numbits)  $result = $numbits;
-
-                                    if ($result < $minbits)  return false;
-                                }
-
-                                $found = true;
-                            }
-                        }
-
-                        if ($found)  break;
-
-                        $x = $x2 - 1;
-                    }
-                }
-            }
-        }
-
-        return $result >= $minbits;
-    }
+	/**
+	 * A standardized method for hasing a password before storing
+	 * in the database.
+	 *
+	 * @param $password
+	 * @return bool|mixed|string
+	 */
+	public static function hashPassword($password)
+	{
+		if (! config_item('auth.hash_cost'))
+		{
+			get_instance()->load->config('auth');
+		}
+
+		return password_hash($password, PASSWORD_DEFAULT, ['cost' => config_item('auth.hash_cost')]);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Determines the number of entropy bits a password has based on
+	 *
+	 *
+	 * @param $password
+	 * @param bool $repeatcalc
+	 * @return int
+	 */
+	public static function getNISTNumBits($password, $repeatcalc = false)
+	{
+		$y = strlen($password);
+		if ($repeatcalc)
+		{
+			// Variant on NIST rules to reduce long sequences of repeated characters.
+			$result = 0;
+			$charmult = array_fill(0, 256, 1);
+			for ($x = 0; $x < $y; $x++)
+			{
+				$tempchr = ord(substr($password, $x, 1));
+				if ($x > 19)  $result += $charmult[$tempchr];
+				else if ($x > 7)  $result += $charmult[$tempchr] * 1.5;
+				else if ($x > 0)  $result += $charmult[$tempchr] * 2;
+				else  $result += 4;
+
+				$charmult[$tempchr] *= 0.75;
+			}
+
+			return $result;
+		}
+		else
+		{
+			if ($y > 20)  return 4 + (7 * 2) + (12 * 1.5) + $y - 20;
+			if ($y > 8)  return 4 + (7 * 2) + (($y - 8) * 1.5);
+			if ($y > 1)  return 4 + (($y - 1) * 2);
+
+			return ($y == 1 ? 4 : 0);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Determines whether a password is strong enough to use. You should check
+	 * the password against this method and reject it if the password is not
+	 * strong enough.
+	 *
+	 * The following guidelines come from the author's tests against 10.4 million actual passwords
+	 * ( see post: http://cubicspot.blogspot.com/2012/01/how-to-calculate-password-strength-part.html )
+	 * and represents the suggested minimum entropy bits for different types of sites:
+	 *
+	 *      - 18 bits of entropy = minimum for ANY website.
+	 *      - 25 bits of entropy = minimum for a general purpose web service used relatively widely (e.g. Hotmail).
+	 *      - 30 bits of entropy = minimum for a web service with business critical applications (e.g. SAAS).
+	 *      - 40 bits of entropy = minimum for a bank or other financial service.
+	 *
+	 * The algorithm is based upon a modified version of the NIST rules which suggest the following:
+	 *
+	 *      - The first byte counts as 4 bits.
+	 *      - The next 7 bytes count as 2 bits each.
+	 *      - The next 12 bytes count as 1.5 bits each.
+	 *      - Anything beyond that counts as 1 bit each.
+	 *      - Mixed case + non-alphanumeric = up to 6 extra bits.
+	 *
+	 * @param string    $password   - The password to check
+	 * @param int       $minbits    - Minimum "entropy bits" that is allowed
+	 * @param bool      $usedict    - Should we check the password against a 300,000 word English dictionary?
+	 * @param int       $minwordlen -
+	 * @return bool
+	 */
+	public static function isStrongPassword($password, $minbits = 18, $usedict = false, $minwordlen = 4)
+	{
+		// NIST password strength rules allow up to 6 extra bits for mixed case and non-alphabetic.
+		$upper = false;
+		$lower = false;
+		$numeric = false;
+		$other = false;
+		$space = false;
+		$y = strlen($password);
+		for ($x = 0; $x < $y; $x++)
+		{
+			$tempchr = ord(substr($password, $x, 1));
+			if ($tempchr >= ord("A") && $tempchr <= ord("Z"))  $upper = true;
+			else if ($tempchr >= ord("a") && $tempchr <= ord("z"))  $lower = true;
+			else if ($tempchr >= ord("0") && $tempchr <= ord("9"))  $numeric = true;
+			else if ($tempchr == ord(" "))  $space = true;
+			else  $other = true;
+		}
+		$extrabits = ($upper && $lower && $other ? ($numeric ? 6 : 5) : ($numeric && !$upper && !$lower ? ($other ? -2 : -6) : 0));
+		if (!$space)  $extrabits -= 2;
+		else if (count(explode(" ", preg_replace('/\s+/', " ", $password))) > 3)  $extrabits++;
+		$result = self::getNISTNumBits($password, true) + $extrabits;
+
+		$password = strtolower($password);
+		$revpassword = strrev($password);
+		$numbits = self::getNISTNumBits($password) + $extrabits;
+		if ($result > $numbits)  $result = $numbits;
+
+		// Remove QWERTY strings.
+		$qwertystrs = array(
+			"1234567890-qwertyuiopasdfghjkl;zxcvbnm,./",
+			"1qaz2wsx3edc4rfv5tgb6yhn7ujm8ik,9ol.0p;/-['=]:?_{\"+}",
+			"1qaz2wsx3edc4rfv5tgb6yhn7ujm8ik9ol0p",
+			"qazwsxedcrfvtgbyhnujmik,ol.p;/-['=]:?_{\"+}",
+			"qazwsxedcrfvtgbyhnujmikolp",
+			"]\"/=[;.-pl,0okm9ijn8uhb7ygv6tfc5rdx4esz3wa2q1",
+			"pl0okm9ijn8uhb7ygv6tfc5rdx4esz3wa2q1",
+			"]\"/[;.pl,okmijnuhbygvtfcrdxeszwaq",
+			"plokmijnuhbygvtfcrdxeszwaq",
+			"014725836914702583697894561230258/369*+-*/",
+			"abcdefghijklmnopqrstuvwxyz"
+		);
+		foreach ($qwertystrs as $qwertystr)
+		{
+			$qpassword = $password;
+			$qrevpassword = $revpassword;
+			$z = 6;
+			do
+			{
+				$y = strlen($qwertystr) - $z;
+				for ($x = 0; $x < $y; $x++)
+				{
+					$str = substr($qwertystr, $x, $z);
+					$qpassword = str_replace($str, "*", $qpassword);
+					$qrevpassword = str_replace($str, "*", $qrevpassword);
+				}
+
+				$z--;
+			} while ($z > 2);
+
+			$numbits = self::getNISTNumBits($qpassword) + $extrabits;
+			if ($result > $numbits)  $result = $numbits;
+			$numbits = self::getNISTNumBits($qrevpassword) + $extrabits;
+			if ($result > $numbits)  $result = $numbits;
+
+			if ($result < $minbits)  return false;
+		}
+
+		if ($usedict && $result >= $minbits)
+		{
+			$passwords = array();
+
+			// Add keyboard shifting password variants.
+			$keyboardmap_down_noshift = array(
+				"z" => "", "x" => "", "c" => "", "v" => "", "b" => "", "n" => "", "m" => "", "," => "", "." => "", "/" => "", "<" => "", ">" => "", "?" => ""
+			);
+			if ($password == str_replace(array_keys($keyboardmap_down_noshift), array_values($keyboardmap_down_noshift), $password))
+			{
+				$keyboardmap_downright = array(
+					"a" => "z",
+					"q" => "a",
+					"1" => "q",
+					"s" => "x",
+					"w" => "s",
+					"2" => "w",
+					"d" => "c",
+					"e" => "d",
+					"3" => "e",
+					"f" => "v",
+					"r" => "f",
+					"4" => "r",
+					"g" => "b",
+					"t" => "g",
+					"5" => "t",
+					"h" => "n",
+					"y" => "h",
+					"6" => "y",
+					"j" => "m",
+					"u" => "j",
+					"7" => "u",
+					"i" => "k",
+					"8" => "i",
+					"o" => "l",
+					"9" => "o",
+					"0" => "p",
+				);
+
+				$keyboardmap_downleft = array(
+					"2" => "q",
+					"w" => "a",
+					"3" => "w",
+					"s" => "z",
+					"e" => "s",
+					"4" => "e",
+					"d" => "x",
+					"r" => "d",
+					"5" => "r",
+					"f" => "c",
+					"t" => "f",
+					"6" => "t",
+					"g" => "v",
+					"y" => "g",
+					"7" => "y",
+					"h" => "b",
+					"u" => "h",
+					"8" => "u",
+					"j" => "n",
+					"i" => "j",
+					"9" => "i",
+					"k" => "m",
+					"o" => "k",
+					"0" => "o",
+					"p" => "l",
+					"-" => "p",
+				);
+
+				$password2 = str_replace(array_keys($keyboardmap_downright), array_values($keyboardmap_downright), $password);
+				$passwords[] = $password2;
+				$passwords[] = strrev($password2);
+
+				$password2 = str_replace(array_keys($keyboardmap_downleft), array_values($keyboardmap_downleft), $password);
+				$passwords[] = $password2;
+				$passwords[] = strrev($password2);
+			}
+
+			// Deal with LEET-Speak substitutions.
+			$leetspeakmap = array(
+				"@" => "a",
+				"!" => "i",
+				"$" => "s",
+				"1" => "i",
+				"2" => "z",
+				"3" => "e",
+				"4" => "a",
+				"5" => "s",
+				"6" => "g",
+				"7" => "t",
+				"8" => "b",
+				"9" => "g",
+				"0" => "o"
+			);
+
+			$password2 = str_replace(array_keys($leetspeakmap), array_values($leetspeakmap), $password);
+			$passwords[] = $password2;
+			$passwords[] = strrev($password2);
+
+			$leetspeakmap["1"] = "l";
+			$password3 = str_replace(array_keys($leetspeakmap), array_values($leetspeakmap), $password);
+			if ($password3 != $password2)
+			{
+				$passwords[] = $password3;
+				$passwords[] = strrev($password3);
+			}
+
+			// Process the password, while looking for words in the dictionary.
+			$a = ord("a");
+			$z = ord("z");
+			$data = file_get_contents(DICTIONARY_PATH);
+			foreach ($passwords as $num => $password)
+			{
+				$y = strlen($password);
+				for ($x = 0; $x < $y; $x++)
+				{
+					$tempchr = ord(substr($password, $x, 1));
+					if ($tempchr >= $a && $tempchr <= $z)
+					{
+						for ($x2 = $x + 1; $x2 < $y; $x2++)
+						{
+							$tempchr = ord(substr($password, $x2, 1));
+							if ($tempchr < $a || $tempchr > $z)  break;
+						}
+
+						$found = false;
+						while (!$found && $x2 - $x >= $minwordlen)
+						{
+							$word = "/\\n" . substr($password, $x, $minwordlen);
+							for ($x3 = $x + $minwordlen; $x3 < $x2; $x3++)  $word .= "(" . $password{$x3};
+							for ($x3 = $x + $minwordlen; $x3 < $x2; $x3++)  $word .= ")?";
+							$word .= "\\n/";
+
+							preg_match_all($word, $data, $matches);
+							if (!count($matches[0]))
+							{
+								$password{$x} = "*";
+								$x++;
+								$numbits = self::getNISTNumBits(substr($password, 0, $x)) + $extrabits;
+								if ($numbits >= $minbits)  $found = true;
+							}
+							else
+							{
+								foreach ($matches[0] as $match)
+								{
+									$password2 = str_replace(trim($match), "*", $password);
+									$numbits = self::getNISTNumBits($password2) + $extrabits;
+									if ($result > $numbits)  $result = $numbits;
+
+									if ($result < $minbits)  return false;
+								}
+
+								$found = true;
+							}
+						}
+
+						if ($found)  break;
+
+						$x = $x2 - 1;
+					}
+				}
+			}
+		}
+
+		return $result >= $minbits;
+	}
 }

Spacing +8 added lines, -8 removed lines

@@ -30,7 +30,7 @@ 
  * @since       Version 1.0
  */
 
-define('DICTIONARY_PATH', dirname(__FILE__) .'/dictionary.txt');
+define('DICTIONARY_PATH', dirname(__FILE__).'/dictionary.txt');
 
 /**
  * Class Password
@@ -60,7 +60,7 @@ 
      */
     public static function hashPassword($password)
     {
-        if (! config_item('auth.hash_cost'))
+        if ( ! config_item('auth.hash_cost'))
         {
             get_instance()->load->config('auth');
         }
@@ -157,8 +157,8 @@ 
             else if ($tempchr == ord(" "))  $space = true;
             else  $other = true;
         }
-        $extrabits = ($upper && $lower && $other ? ($numeric ? 6 : 5) : ($numeric && !$upper && !$lower ? ($other ? -2 : -6) : 0));
-        if (!$space)  $extrabits -= 2;
+        $extrabits = ($upper && $lower && $other ? ($numeric ? 6 : 5) : ($numeric && ! $upper && ! $lower ? ($other ? -2 : -6) : 0));
+        if ( ! $space)  $extrabits -= 2;
         else if (count(explode(" ", preg_replace('/\s+/', " ", $password))) > 3)  $extrabits++;
         $result = self::getNISTNumBits($password, true) + $extrabits;
 
@@ -332,15 +332,15 @@ 
                         }
 
                         $found = false;
-                        while (!$found && $x2 - $x >= $minwordlen)
+                        while ( ! $found && $x2 - $x >= $minwordlen)
                         {
-                            $word = "/\\n" . substr($password, $x, $minwordlen);
-                            for ($x3 = $x + $minwordlen; $x3 < $x2; $x3++)  $word .= "(" . $password{$x3};
+                            $word = "/\\n".substr($password, $x, $minwordlen);
+                            for ($x3 = $x + $minwordlen; $x3 < $x2; $x3++)  $word .= "(".$password{$x3};
                             for ($x3 = $x + $minwordlen; $x3 < $x2; $x3++)  $word .= ")?";
                             $word .= "\\n/";
 
                             preg_match_all($word, $data, $matches);
-                            if (!count($matches[0]))
+                            if ( ! count($matches[0]))
                             {
                                 $password{$x} = "*";
                                 $x++;

Braces +69 added lines, -29 removed lines

@@ -89,21 +89,31 @@ 
             for ($x = 0; $x < $y; $x++)
             {
                 $tempchr = ord(substr($password, $x, 1));
-                if ($x > 19)  $result += $charmult[$tempchr];
-                else if ($x > 7)  $result += $charmult[$tempchr] * 1.5;
-                else if ($x > 0)  $result += $charmult[$tempchr] * 2;
-                else  $result += 4;
+                if ($x > 19) {
+                	$result += $charmult[$tempchr];
+                } else if ($x > 7) {
+                	$result += $charmult[$tempchr] * 1.5;
+                } else if ($x > 0) {
+                	$result += $charmult[$tempchr] * 2;
+                } else {
+                	$result += 4;
+                }
 
                 $charmult[$tempchr] *= 0.75;
             }
 
             return $result;
-        }
-        else
+        } else
         {
-            if ($y > 20)  return 4 + (7 * 2) + (12 * 1.5) + $y - 20;
-            if ($y > 8)  return 4 + (7 * 2) + (($y - 8) * 1.5);
-            if ($y > 1)  return 4 + (($y - 1) * 2);
+            if ($y > 20) {
+            	return 4 + (7 * 2) + (12 * 1.5) + $y - 20;
+            }
+            if ($y > 8) {
+            	return 4 + (7 * 2) + (($y - 8) * 1.5);
+            }
+            if ($y > 1) {
+            	return 4 + (($y - 1) * 2);
+            }
 
             return ($y == 1 ? 4 : 0);
         }
@@ -151,21 +161,32 @@ 
         for ($x = 0; $x < $y; $x++)
         {
             $tempchr = ord(substr($password, $x, 1));
-            if ($tempchr >= ord("A") && $tempchr <= ord("Z"))  $upper = true;
-            else if ($tempchr >= ord("a") && $tempchr <= ord("z"))  $lower = true;
-            else if ($tempchr >= ord("0") && $tempchr <= ord("9"))  $numeric = true;
-            else if ($tempchr == ord(" "))  $space = true;
-            else  $other = true;
+            if ($tempchr >= ord("A") && $tempchr <= ord("Z")) {
+            	$upper = true;
+            } else if ($tempchr >= ord("a") && $tempchr <= ord("z")) {
+            	$lower = true;
+            } else if ($tempchr >= ord("0") && $tempchr <= ord("9")) {
+            	$numeric = true;
+            } else if ($tempchr == ord(" ")) {
+            	$space = true;
+            } else {
+            	$other = true;
+            }
         }
         $extrabits = ($upper && $lower && $other ? ($numeric ? 6 : 5) : ($numeric && !$upper && !$lower ? ($other ? -2 : -6) : 0));
-        if (!$space)  $extrabits -= 2;
-        else if (count(explode(" ", preg_replace('/\s+/', " ", $password))) > 3)  $extrabits++;
+        if (!$space) {
+        	$extrabits -= 2;
+        } else if (count(explode(" ", preg_replace('/\s+/', " ", $password))) > 3) {
+        	$extrabits++;
+        }
         $result = self::getNISTNumBits($password, true) + $extrabits;
 
         $password = strtolower($password);
         $revpassword = strrev($password);
         $numbits = self::getNISTNumBits($password) + $extrabits;
-        if ($result > $numbits)  $result = $numbits;
+        if ($result > $numbits) {
+        	$result = $numbits;
+        }
 
         // Remove QWERTY strings.
         $qwertystrs = array(
@@ -200,11 +221,17 @@ 
             } while ($z > 2);
 
             $numbits = self::getNISTNumBits($qpassword) + $extrabits;
-            if ($result > $numbits)  $result = $numbits;
+            if ($result > $numbits) {
+            	$result = $numbits;
+            }
             $numbits = self::getNISTNumBits($qrevpassword) + $extrabits;
-            if ($result > $numbits)  $result = $numbits;
+            if ($result > $numbits) {
+            	$result = $numbits;
+            }
 
-            if ($result < $minbits)  return false;
+            if ($result < $minbits) {
+            	return false;
+            }
         }
 
         if ($usedict && $result >= $minbits)
@@ -328,15 +355,21 @@ 
                         for ($x2 = $x + 1; $x2 < $y; $x2++)
                         {
                             $tempchr = ord(substr($password, $x2, 1));
-                            if ($tempchr < $a || $tempchr > $z)  break;
+                            if ($tempchr < $a || $tempchr > $z) {
+                            	break;
+                            }
                         }
 
                         $found = false;
                         while (!$found && $x2 - $x >= $minwordlen)
                         {
                             $word = "/\\n" . substr($password, $x, $minwordlen);
-                            for ($x3 = $x + $minwordlen; $x3 < $x2; $x3++)  $word .= "(" . $password{$x3};
-                            for ($x3 = $x + $minwordlen; $x3 < $x2; $x3++)  $word .= ")?";
+                            for ($x3 = $x + $minwordlen; $x3 < $x2; $x3++) {
+                            	$word .= "(" . $password{$x3};
+                            }
+                            for ($x3 = $x + $minwordlen; $x3 < $x2; $x3++) {
+                            	$word .= ")?";
+                            }
                             $word .= "\\n/";
 
                             preg_match_all($word, $data, $matches);
@@ -345,24 +378,31 @@ 
                                 $password{$x} = "*";
                                 $x++;
                                 $numbits = self::getNISTNumBits(substr($password, 0, $x)) + $extrabits;
-                                if ($numbits >= $minbits)  $found = true;
-                            }
-                            else
+                                if ($numbits >= $minbits) {
+                                	$found = true;
+                                }
+                            } else
                             {
                                 foreach ($matches[0] as $match)
                                 {
                                     $password2 = str_replace(trim($match), "*", $password);
                                     $numbits = self::getNISTNumBits($password2) + $extrabits;
-                                    if ($result > $numbits)  $result = $numbits;
+                                    if ($result > $numbits) {
+                                    	$result = $numbits;
+                                    }
 
-                                    if ($result < $minbits)  return false;
+                                    if ($result < $minbits) {
+                                    	return false;
+                                    }
                                 }
 
                                 $found = true;
                             }
                         }
 
-                        if ($found)  break;
+                        if ($found) {
+                        	break;
+                        }
 
                         $x = $x2 - 1;
                     }