~xibo-maintainers/xibo/tempel

// These constants may be changed without breaking existing hashes.

define("PBKDF2_HASH_ALGORITHM", "sha256");

define("PBKDF2_ITERATIONS", 1000);

define("PBKDF2_SALT_BYTES", 24);

define("PBKDF2_HASH_BYTES", 24);

 

define("HASH_SECTIONS", 4);

define("HASH_ALGORITHM_INDEX", 0);

define("HASH_ITERATION_INDEX", 1);

define("HASH_SALT_INDEX", 2);

define("HASH_PBKDF2_INDEX", 3);

 

        $this->password = $this->createHash($password);

        $this->CSPRNG = 1;

    }

 

    /**

     * Is the user salted?

     * @return bool

     */

    public function isSalted()

    {

        return ($this->CSPRNG == 1);

        else {

            $params = explode(":", $this->password);

            if (count($params) < HASH_SECTIONS) {

                $this->getLog()->warning('Invalid password hash stored for userId %d', $this->userId);

                throw new AccessDeniedException();

 

            $pbkdf2 = base64_decode($params[HASH_PBKDF2_INDEX]);

 

            // Check to see if the hash created from the provided password is the same as the hash we have stored already

            if (!$this->slowEquals($pbkdf2, $this->pbkdf2($params[HASH_ALGORITHM_INDEX], $password, $params[HASH_SALT_INDEX], (int)$params[HASH_ITERATION_INDEX], strlen($pbkdf2), true))) {

            $event->setChildObjectDependencies($this->displayFactory, $this->layoutFactory, $this->mediaFactory, $this->scheduleFactory);

            $event->save();

        if (!v::alnum('_')->length(1, 50)->validate($this->userName))

            throw new \InvalidArgumentException(__('User name must be between 1 and 50 characters.'));

            throw new \InvalidArgumentException(__('Please enter a Password.'));

            throw new \InvalidArgumentException(__('Library Quota must be a whole number.'));

            throw new \InvalidArgumentException(__('Please enter a valid email address or leave it empty.'));

                throw new \InvalidArgumentException(__('There is already a user with this name. Please choose another.'));

            throw new \InvalidArgumentException(__('Selected home page does not exist'));

        if (!method_exists($object, 'getId') || !method_exists($object, 'getOwnerId'))

        $permissions = $this->loadPermissions(get_class($object));

        $permissions = $this->loadPermissions(get_class($object));

        $permissions = $this->loadPermissions(get_class($object));

     * Password hashing with PBKDF2.

     * Author: havoc AT defuse.ca

     * www: https://defuse.ca/php-pbkdf2.htm

     * @param string $password

     * @return string

     */

    private function createHash($password)

    {

        // format: algorithm:iterations:salt:hash

        $salt = base64_encode(mcrypt_create_iv(PBKDF2_SALT_BYTES, MCRYPT_DEV_URANDOM));

        return PBKDF2_HASH_ALGORITHM . ":" . PBKDF2_ITERATIONS . ":" .  $salt . ":" .

        base64_encode($this->pbkdf2(

            PBKDF2_HASH_ALGORITHM,

            $password,

            $salt,

            PBKDF2_ITERATIONS,

            PBKDF2_HASH_BYTES,

            true

        ));

    }

 

    /**

     * Compares two strings $a and $b in length-constant time.

     * @param string $a

     * @param string $b

     * @return bool

     */

    private function slowEquals($a, $b)

    {

        $diff = strlen($a) ^ strlen($b);

        for($i = 0; $i < strlen($a) && $i < strlen($b); $i++)

        {

            $diff |= ord($a[$i]) ^ ord($b[$i]);

        }

        return $diff === 0;

    }

 

    /**

 

    /**

     * PBKDF2 key derivation function as defined by RSA's PKCS #5: https://www.ietf.org/rfc/rfc2898.txt

     *

     * Test vectors can be found here: https://www.ietf.org/rfc/rfc6070.txt

     *

     * This implementation of PBKDF2 was originally created by https://defuse.ca

     * With improvements by http://www.variations-of-shadow.com

     *

     * @param string $algorithm The hash algorithm to use. Recommended: SHA256

     * @param string $password The password.

     * @param string $salt A salt that is unique to the password.

     * @param int $count Iteration count. Higher is better, but slower. Recommended: At least 1000.

     * @param int $key_length The length of the derived key in bytes.

     * @param bool $raw_output If true, the key is returned in raw binary format. Hex encoded otherwise.

     * @return string A $key_length-byte key derived from the password and salt.

     */

    public function pbkdf2($algorithm, $password, $salt, $count, $key_length, $raw_output = false)

    {

        $algorithm = strtolower($algorithm);

        if (!in_array($algorithm, hash_algos(), true))

            throw new \InvalidArgumentException('PBKDF2 ERROR: Invalid hash algorithm.');

        if ($count <= 0 || $key_length <= 0)

            throw new \InvalidArgumentException('PBKDF2 ERROR: Invalid parameters.');

 

        $hash_length = strlen(hash($algorithm, "", true));

        $block_count = ceil($key_length / $hash_length);

 

        $output = "";

        for ($i = 1; $i <= $block_count; $i++) {

            // $i encoded as 4 bytes, big endian.

            $last = $salt . pack("N", $i);

            // first iteration

            $last = $xorsum = hash_hmac($algorithm, $last, $password, true);

            // perform the other $count - 1 iterations

            for ($j = 1; $j < $count; $j++) {

                $xorsum ^= ($last = hash_hmac($algorithm, $last, $password, true));

            }

            $output .= $xorsum;

        }

 

        if ($raw_output)

            return substr($output, 0, $key_length);

        else

            return bin2hex(substr($output, 0, $key_length));

    }