Auth_File
› Kohana_Auth_File
› Auth
› Kohana_Auth

Class Contents

Class declared in MODPATH/auth/classes/auth/file.php on line 3.

Methods

public function __construct($config = array())
{
	parent::__construct($config);

	// Load user list
	$this->_users = Arr::get($config, 'users', array());
}

protected function _login($username, $password, $remember)
{
	if (isset($this->_users[$username]) AND $this->_users[$username] === $password)
	{
		// Complete the login
		return $this->complete_login($username);
	}

	// Login failed
	return FALSE;
}

public function check_password($password)
{
	$username = $this->get_user();

	if ($username === FALSE)
	{
		return FALSE;
	}

	return ($password === $this->password($username));
}

public function force_login($username)
{
	// Complete the login
	return $this->complete_login($username);
}

public function password($username)
{
	return Arr::get($this->_users, $username, FALSE);
}

protected function complete_login($user)
{
	// Regenerate session_id
	$this->_session->regenerate();

	// Store username in session
	$this->_session->set($this->_config['session_key'], $user);

	return TRUE;
}

public static function factory($config = array())
{
	return new Auth($config);
}

public function find_salt($password)
{
	$salt = '';

	foreach ($this->_config['salt_pattern'] as $i => $offset)
	{
		// Find salt characters, take a good long look...
		$salt .= substr($password, $offset + $i, 1);
	}

	return $salt;
}

public function get_user()
{
	return $this->_session->get($this->_config['session_key'], FALSE);
}

public function hash($str)
{
	return hash($this->_config['hash_method'], $str);
}

public function hash_password($password, $salt = FALSE)
{
	if ($salt === FALSE)
	{
		// Create a salt seed, same length as the number of offsets in the pattern
		$salt = substr($this->hash(uniqid(NULL, TRUE)), 0, count($this->_config['salt_pattern']));
	}

	// Password hash that the salt will be inserted into
	$hash = $this->hash($salt.$password);

	// Change salt to an array
	$salt = str_split($salt, 1);

	// Returned password
	$password = '';

	// Used to calculate the length of splits
	$last_offset = 0;

	foreach ($this->_config['salt_pattern'] as $offset)
	{
		// Split a new part of the hash off
		$part = substr($hash, 0, $offset - $last_offset);

		// Cut the current part out of the hash
		$hash = substr($hash, $offset - $last_offset);

		// Add the part to the password, appending the salt character
		$password .= $part.array_shift($salt);

		// Set the last offset to the current offset
		$last_offset = $offset;
	}

	// Return the password, with the remaining hash appended
	return $password.$hash;
}

public static function instance()
{
	if ( ! isset(Auth::$_instance))
	{
		// Load the configuration for this type
		$config = Kohana::config('auth');

		if ( ! $type = $config->get('driver'))
		{
			$type = 'ORM';
		}

		// Set the session class name
		$class = 'Auth_'.ucfirst($type);

		// Create a new session instance
		Auth::$_instance = new $class($config);
	}

	return Auth::$_instance;
}

public function logged_in($role = NULL)
{
	return FALSE !== $this->get_user();
}

public function login($username, $password, $remember = FALSE)
{
	if (empty($password))
		return FALSE;

	if (is_string($password))
	{
		// Get the salt from the stored password
		$salt = $this->find_salt($this->password($username));

		// Create a hashed password using the salt from the stored password
		$password = $this->hash_password($password, $salt);
	}

	return $this->_login($username, $password, $remember);
}

public function logout($destroy = FALSE, $logout_all = FALSE)
{
	if ($destroy === TRUE)
	{
		// Destroy the session completely
		$this->_session->destroy();
	}
	else
	{
		// Remove the user from the session
		$this->_session->delete($this->_config['session_key']);

		// Regenerate session_id
		$this->_session->regenerate();
	}

	// Double check
	return ! $this->logged_in();
}