Return password hasher object

@return \Cake\Auth\AbstractPasswordHasher Password hasher instance
@throws \RuntimeException If password hasher class not found or it does not extend AbstractPasswordHasher
420685
public function getPasswordHasher() {
		if ($this->_passwordHasher) {
			return $this->_passwordHasher;
		}

		return $this->_passwordHasher = PasswordHasherFactory::build($this->_defaultPasswordHasher);
	}
1158950
public function getHashCode() {
		if ($this->_isSupervisor) {
			return $this->getSharedComponent()->getHashCode();
		}
    	return md5(
    		  $this->_locked
    		. $this->_hidden
    		. __CLASS__
    	);
    }
878809
public function getHashCode() {
        if ($this->_dirty) {
            $this->_hash = md5( $this->_title .
                                $this->_autoFilter .
                                ($this->_protection->isProtectionEnabled() ? 't' : 'f') .
                                __CLASS__
                              );
            $this->_dirty = false;
        }
        return $this->_hash;
    }
1197162
protected function _getAuth() {
		if ($this->auth) {
			return $this->auth;
		}

		$authAllow = Cache::read($this->getConfig('allowCacheKey'), $this->getConfig('cache'));
		if (!$authAllow) {
			//TOOD make refactor to collect data at runtime? Should not be necessary if AuthComponent is used properly.
			throw new Exception('Cache for Authentication data not found. This is required for `includeAuthentication` as true. Make sure you enabled TinyAuth.AuthComponent.');
		}

		$this->auth = $authAllow;

		return $authAllow;
	}
759279
public function getHashName()
    {
        if ($this->_hashName === null) {
            $this->_hashName = sha1(get_called_class());
        }
        
        return $this->_hashName;
    }
1372748
public function hashCode()
    {
        if (null !== $this->getPrimaryKey()) {
            return crc32(serialize($this->getPrimaryKey()));
        }

        return crc32(serialize(clone $this));
    }
58341
protected function getPasswordHelper()
	{
		if( $this->helper ) {
			return $this->helper;
		}

		$classname = \Aimeos\MShop\Common\Helper\Password\Typo3::class;

		if( class_exists( $classname ) === false ) {
			throw new \Aimeos\MShop\Exception( sprintf( 'Class "%1$s" not available', $classname ) );
		}

		$context = $this->getContext();
		$object = ( method_exists( $context, 'getHasherTypo3' ) ? $context->getHasherTypo3() : null );

		$helper = new $classname( array( 'object' => $object ) );

		return $this->helper = self::checkClass( \Aimeos\MShop\Common\Helper\Password\Iface::class, $helper );
	}
428719
public function getHash()
    {
        if (null === $this->hash) {
            $this->hash = $this->calculateHash();
        }

        return $this->hash;
    }
892641
private function getHash()
    {
        return md5(implode('&', [
            'appkey=' . $this->parameters->getAuth('appkey'),
            'secret=' . $this->parameters->getAuth('secret'),
            'email=' . $this->parameters->getAuth('email'),
            'password=' . $this->parameters->getAuth('password'),
        ]));
    }
1289817
public function offsetGet($offset): PasswordHashStrategyInterface
    {
        if (!isset($this->strategies[$offset])) {
            throw new \RuntimeException('The requested password hash strategy is not available: ' . $offset);
        }
        return $this->strategies[$offset] ?? null;
    }
1288769
private function hashHashable()
    {
        $hasher = new BcryptHasher;
        $filtered = array_filter($this->attributes);

        foreach ($filtered as $key => $value)
        {
            if (in_array($key, $this->hashable) && $value != $this->getOriginal($key))
            {
                $this->attributes[$key] = $hasher->make($value);
            }
        }
    }
275486
public function getAuthentication($passphrase = null, $user = null)
    {
        if (is_null($user) && !isset($this->config['user'])) {
            throw new RuntimeException("Can not authenticate for '{$this->host}' could not find user to authenticate as");
        }
        $user = $user ?: $this->config['user'];
        if (isset($this->config['identityfile'])) {
            return new Authentication\PublicKeyFile(
                $user,
                $this->config['identityfile'] . '.pub',
                $this->config['identityfile'],
                $passphrase
            );
        } else {
            return new Authentication\None(
                $user
            );
        }
    }
564773
protected function getHandler()
    {
        $handler = $this->getConfig('unauthorizedHandler');
        if (!is_array($handler)) {
            $handler = [
                'className' => $handler,
            ];
        }
        if (!isset($handler['className'])) {
            throw new RuntimeException('Missing `className` key from handler config.');
        }

        return HandlerFactory::create($handler['className']);
    }
721058
public function loadUserByToken($hash)
    {
        try {
            return $this->innerGateway->loadUserByToken($hash);
        } catch (DBALException $e) {
            throw new \RuntimeException('Database error', 0, $e);
        } catch (\PDOException $e) {
            throw new \RuntimeException('Database error', 0, $e);
        }
    }
805056
public function getHash()
    {
        if ($this->hash === null) {
            $this->hash = sha1_file($this->getLocalPath());
        }

        return $this->hash;
    }
1008673
public function getHash()
	{
		$h = hash_init($this->_hashAlgo);
		foreach($this->_keys as &$v)
			hash_update($h, $v);
		$r = hash_final($h, true);
		unset($h);
		return $r;
	}
311626
public static function getPasshash($password)
	{
		// Get the password encryption/hashing mechanism
		$config = \Component::params('com_members');
		$type   = $config->get('passhash_mechanism', 'CRYPT_SHA512');

		switch ($type)
		{
			case 'MD5':
				$passhash = "{MD5}" . base64_encode(pack('H*', md5($password)));
				break;

			case 'CRYPT_SHA512':
			default:
				$encrypted = crypt($password, '$6$' . self::genRandomPassword(8) . '$');
				$passhash = "{CRYPT}" . $encrypted;
				break;
		}

		return $passhash;
	}