Is valid hash

@param string $storeKey

@return bool
547644
public function isValidHash() : Bool
    {
        $hash   = $_POST['HASHPARAMS'];
        $hashEx = explode(':', $hash);
        $real   = NULL;

        foreach( $hashEx as $part )
        {
            if( ! empty($_POST[$part]) )
            {
                $real .= $_POST[$part];
            }
        }

        return $real === $_POST['HASHPARAMSVAL'] && $_POST['HASH'] === base64_encode(pack('H*',sha1($real . $_POST['storeKey'])));
    }
667045
public static function isHash(string $strategy) : bool
    {
        return $strategy === ClassMetadata::STORAGE_STRATEGY_SET || $strategy === ClassMetadata::STORAGE_STRATEGY_ATOMIC_SET;
    }
232723
public static function hashVerify($hashed, $hash) : bool {
      $hasher = new \Nuki\Handlers\Security\Hasher(
          self::getAppAlgorithm(),
          self::getAppKey()
      );
      
      return $hasher->verify($hashed, $hash);
    }
723954
public function has($key)
	{
		$key = $this->id($key);

		if (!isset($this->data[$key]))
		{
			return false;
		}

		$value = $this->data[$key];

		if ($this->isDataExpired($value))
		{
			unset($this->data[$key]);
			return false;
		}

		return true;
	}
1075553
public function has($key): bool
    {
        $this->checkKey($key);
        return (bool) $this->getRedis()->keys($this->filterKey($key));
    }
300714
public function hasKey($key)
    {
        if ($this->started !== true) {
            throw new Exception\SessionNotStartedException('Tried to check a session data entry, but the session has not been started yet.', 1352488661);
        }
        return $this->storageCache->has($this->storageIdentifier . md5($key));
    }
1085407
public function isCached($key) {
        // The actual working horse. The method does not only check existence of the key. It retrieves the value and stores
        // it in the local reference pool, so following cache queries can use the local reference.

        // check local reference pool
        if ($this->getReferencePool()->isCached($key))
            return true;

        // query APC cache
        $data = apc_fetch($this->namespace.'::'.$key);
        if (!$data)                                     // cache miss
            return false;

        // cache hit
        $created = $data[0];                            // data: [created, expires, serialized([$value, $dependency])]
        $expires = $data[1];

        // check expiration
        if ($expires && $created+$expires < time()) {
            $this->drop($key);
            return false;
        }

        // unpack serialized value
        $data[2]    = unserialize($data[2]);
        $value      = $data[2][0];
        $dependency = $data[2][1];

        // check dependency
        if ($dependency) {
            $minValid = $dependency->getMinValidity();

            if ($minValid) {
                if (time() > $created+$minValid) {
                    if (!$dependency->isValid()) {
                        $this->drop($key);
                        return false;
                    }
                    // reset the creation time by writing back to the cache (resets $minValid period)
                    return $this->set($key, $value, $expires, $dependency);
                }
            }
            elseif (!$dependency->isValid()) {
                $this->drop($key);
                return false;
            }
        }

        // store the validated value in the local reference pool
        $this->getReferencePool()->set($key, $value, Cache::EXPIRES_NEVER, $dependency);
        return true;
    }
1061627
public function isInCache($key)
  {
    $value = $this->memcache->get($this->buildMKey($key));
    if ($value) {
      return true;
    }
    return false;
  }
224072
public function isValid($key)
    {
        if (! isset ($this['sso'], $this['sig'])) {
            return false;
        }

        return $this['sig'] === Secret::create($key)->sign($this['sso']);
    }
353640
public function exists($key) {
        if (!array_key_exists($key, $this->storage))
            return false;

        if ($this->storage[$key]['expires'] > 0 && time() > $this->storage[$key]['expires'])
            return false;

        return true;
    }
636374
public function has($key)
    {
        return (isset($this->headers[$this->normalizeKey($key)])) ? true : false;
    }
984930
public function isValid($api_key)
    {
        if (!$api_key) {
            return false;
        }

        return ($this->event_hash == $this->calculateHash($api_key))
            ? true : false;
    }
794782
protected function isArray($key) : bool
    {
        if (is_array($this->param[$key]) && !$this->hasAttribute($key)) {
            $this->errors[$key.self::ERROR] = $this->convertToFieldName($key).' value must be valid array.';
            return false;
        }

        return true;
    }
1181887
public function hasCell($columnKey, $rowKey) : bool
    {
        $this->validateColumnKey(__METHOD__, $columnKey);
        $this->validateRowKey(__METHOD__, $rowKey);

        $this->loadColumns();
        $this->loadRows();

        $columnHash = ValueHasher::hash($columnKey);
        if (!isset($this->columns[$columnHash])) {
            return false;
        }

        $rowHash = ValueHasher::hash($rowKey);
        if (!isset($this->rows[$rowHash])) {
            return false;
        }

        return true;
    }
829787
public function has($key, $strict = false)
    {
        // When $strict is true, he check $key not how a key but a value.
        $isset = isset($this->storage[$key]);

        if ($isset) {
            if ($strict === true) {
                $isset = $isset && !empty($this->storage[$key]);
            }
        }

        return $isset;
    }
374306
public static function validateKey ($key)
    {
        $hash = substr($key, 0, 2);
        $encrypted = substr($key, 2);
        if ($hash != substr(md5(Pluf::f('secret_key') . $encrypted), 0, 2)) {
            throw new Pluf_Form_Invalid(
                    __(
                            'The validation key is not valid. Please copy/paste it from your confirmation email.'));
        }
        $cr = new Pluf_Crypt(md5(Pluf::f('secret_key')));
        return explode(':', $cr->decrypt($encrypted), 3);
    }
680534
public function canValidateProperty( $key )
    {
        return isset( $this->data[$key] ) and is_object( $this->data[$key] ) and $this->data[$key] instanceof Base;
    }