public function verify($password, $hash)
 {
     $key = hash(self::HASH_PRIMITIVE, $password, true);
     $hash = base64_decode($hash);
     $header = substr($hash, 0, self::HEADER_SIZE);
     $iv = substr($hash, self::HEADER_SIZE, self::IV_LENGTH);
     $ciphertext = substr($hash, self::HEADER_SIZE + self::IV_LENGTH);
     $decrypted = openssl_decrypt($ciphertext, self::CIPHER_PRIMITIVE, $key, OPENSSL_RAW_DATA | OPENSSL_ZERO_PADDING, $iv);
     list(, $version, $rounds, $pointerSize, $dataSize) = unpack('C*', $header);
     $iterationCount = pow(2, $rounds);
     $dataSizeDecoded = pow(2, $dataSize);
     if ($version !== 1) {
         throw new \RuntimeException("Unknown version encountered");
     }
     if (strlen($decrypted) !== self::HASH_LENGTH + $iterationCount * $pointerSize) {
         throw new \RuntimeException("Invalid data payload, was it truncated?");
     }
     $h = hash_init(self::HASH_PRIMITIVE);
     for ($i = 0; $i < $iterationCount; $i++) {
         $pointer = substr($decrypted, $i * $pointerSize, $pointerSize);
         hash_update($h, $this->read($pointer, $dataSizeDecoded));
     }
     $test = hash_final($h, true);
     return hash_equals($test, substr($decrypted, $iterationCount * $pointerSize));
 }

 public static function create_hash($data)
 {
     $hash = Config::get('hash');
     $context = hash_init($hash['hash_algorithm'], HASH_HMAC, $hash['hash_general_key']);
     hash_update($context, $data);
     return hash_final($context);
 }

 /**
  * Update a given hash with the sha1 hash of an individual asset
  *
  * @param AssetInterface $asset
  * @param $hash
  */
 protected function hashAsset(AssetInterface $asset, $hash)
 {
     $sourcePath = $asset->getSourcePath();
     $sourceRoot = $asset->getSourceRoot();
     $data = $sourcePath && $sourceRoot && file_exists($sourceRoot . "/" . $sourcePath) ? hash_file('sha1', $sourceRoot . "/" . $sourcePath) : $sourcePath;
     hash_update($hash, $data);
 }

 public function getBaseMaterial($seedBytes)
 {
     $mac = hash_init('sha256', HASH_HMAC, $this->key);
     hash_update($mac, $seedBytes);
     $data = hash_final($mac, true);
     return $data;
 }

 public static function create($algo, $data, $salt)
 {
     $context = hash_init($algo, HASH_HMAC, $salt);
     //$salt => $key
     hash_update($context, $data);
     return hash_final($context);
 }

 public function update($data)
 {
     if ($this->hash !== null) {
         $this->reset();
     }
     hash_update($this->getContext(), $data);
 }

function test_hash($algo, $init)
{
    echo "\n{$algo}, incremental: ";
    $h = hash_init($algo);
    for ($i = 0; $i < 10; ++$i) {
        hash_update($h, '' . $init * 2 + $i * 17);
    }
    echo '(copying state) ';
    $h2 = hash_copy($h);
    for ($i = 0; $i < 10; ++$i) {
        hash_update($h, '' . $init * 2 + $i * 19);
    }
    var_dump(hash_final($h));
    echo "\n{$algo}, from copied state: ";
    var_dump(hash_final($h2));
    echo "\n{$algo}, HMAC, incremental: ";
    $h = hash_init($algo, HASH_HMAC, 'HMAC key. It can be very long, but in this case it will be rehashed to fit the block size of the hashing algorithm...' . $init * 147);
    for ($i = 0; $i < 10; ++$i) {
        hash_update($h, '' . $init * 4 + $i * 7);
    }
    //echo '(copying state) ';
    //$h2 = hash_copy($h);// causes PHP crashes sometimes, reported as PHP Bug #52240
    for ($i = 0; $i < 10; ++$i) {
        hash_update($h, '' . $init * 3 + $i * 11);
    }
    var_dump(hash_final($h));
    //echo "\n$algo, HMAC, from copied state: ";
    //var_dump(hash_final($h2));// BUG IN PHP, HMAC key is not copied, but only referenced ... hash_final on $h clears the HMAC key in $h2 too...  reported as PHP Bug #52240
    echo "\n{$algo}, at once, short data: ";
    var_dump(hash($algo, 'some string to be hashed ... ' . $init * 123 . ' ...'));
    echo "\n{$algo}, at once, HMAC: ";
    var_dump(hash_hmac($algo, 'some string to be hashed ... ' . $init * 123 . ' ...', 'HMAC key. It can be very long, but in this case it will be rehashed to fit the block size of the hashing algorithm.'));
}

function test_hash_init()
{
    $ctx = hash_init("md5");
    hash_update($ctx, "The quick brown fox ");
    hash_update($ctx, "jumped over the lazy dog.");
    var_dump(hash_final($ctx));
}

 public function hash()
 {
     $hasher = hash_init('sha256');
     hash_update($hasher, 'identifier');
     hash_update($hasher, $this->val);
     return hash_final($hasher);
 }

 /**
  * Аутентификация пользователя
  *
  * @param   String    $login
  * @param   String    $password
  * @param   Bool      $admin
  * @return  Bool
  */
 protected function _auth($login, $password, $admin, $protocol)
 {
     $packet = $this->packet();
     while (!feof($this->_socket)) {
         $packet->clean();
         $this->read($packet);
         switch ($this->_code) {
             case 192:
                 $digest = $packet->attr[6]['data'];
                 $ctx = hash_init('md5');
                 hash_update($ctx, $digest);
                 hash_update($ctx, $password);
                 $hash = hash_final($ctx, true);
                 $packet->clean();
                 $this->_code = 193;
                 $packet->set_attr_string($login, 2);
                 $packet->set_attr_string($digest, 8);
                 $packet->set_attr_string($hash, 9);
                 $packet->set_attr_int($protocol === 'tls' ? 6 : ($admin ? 4 : 2), 10);
                 $packet->set_attr_int(2, 1);
                 $this->write($packet);
                 break;
             case 194:
                 $attr_protocol = $packet->get_attr_int(10);
                 if ($attr_protocol === 6) {
                     stream_socket_enable_crypto($this->_socket, TRUE, STREAM_CRYPTO_METHOD_TLS_CLIENT);
                 } elseif ($attr_protocol) {
                     stream_socket_enable_crypto($this->_socket, TRUE, STREAM_CRYPTO_METHOD_SSLv3_CLIENT);
                 }
                 return TRUE;
             case 195:
                 return FALSE;
         }
     }
 }

 function challengeCheck($call, $host1, $pass)
 {
     $h = hash_init('md5');
     hash_update($h, CallRegister::$calls[$host1][$call->fields['dcalli']]['challenge']);
     hash_update($h, $pass);
     return hash_final($h) == CallRegister::$calls[$host1][$call->fields['dcalli']]['challenge_response'];
 }

 /**
  * Build a response header
  *
  * @param $buffer
  *    data to be used in response header
  * @return
  *    response header
  */
 static function getResponseHeaders($buffer = '', $uniqueOrigin = FALSE)
 {
     list($resource, $host, $origin, $strkey1, $strkey2, $data) = self::getRequestHeaders($buffer);
     if (!self::validOrigin($origin, $uniqueOrigin)) {
         self::console('Refusing connection from origin %s. Allowed origin(s): %s', array($origin, implode(', ', $uniqueOrigin)));
         return FALSE;
     }
     // find numbers
     $pattern = '/[^\\d]*/';
     $replacement = '';
     $numkey1 = preg_replace($pattern, $replacement, $strkey1);
     $numkey2 = preg_replace($pattern, $replacement, $strkey2);
     // find spaces
     $pattern = '/[^ ]*/';
     $replacement = '';
     $spaces1 = strlen(preg_replace($pattern, $replacement, $strkey1));
     $spaces2 = strlen(preg_replace($pattern, $replacement, $strkey2));
     if ($spaces1 == 0 || $spaces2 == 0 || $numkey1 % $spaces1 != 0 || $numkey2 % $spaces2 != 0) {
         WSHelpers::console('Handshake failed');
         return FALSE;
     }
     $ctx = hash_init('md5');
     hash_update($ctx, pack("N", $numkey1 / $spaces1));
     hash_update($ctx, pack("N", $numkey2 / $spaces2));
     hash_update($ctx, $data);
     $hash_data = hash_final($ctx, TRUE);
     return "HTTP/1.1 101 WebSocket Protocol Handshake\r\n" . "Upgrade: WebSocket\r\n" . "Connection: Upgrade\r\n" . "Sec-WebSocket-Origin: " . $origin . "\r\n" . "Sec-WebSocket-Location: ws://" . $host . $resource . "\r\n" . "\r\n" . $hash_data;
 }

function create_git_object_hash( $p_file ) {
	$t_hash_context = hash_init( 'sha1' );
	hash_update( $t_hash_context, 'blob ' . filesize( $p_file ) . "\x00" );
	hash_update_file( $t_hash_context, $p_file );
	$t_object_hash = hash_final( $t_hash_context );
	return $t_object_hash;
}

 /**
  * Compute a full md5 file hash or compute a partial hash if $limit is present.
  * Returns null on failure.
  *
  * @param string  $realPath
  * @param int     $offset in bytes
  * @param int     $limit  in bytes
  * @param boolean $forcePartialHashing
  *
  * @return null|string
  */
 public function computeMd5Hash($realPath, $offset = 0, $limit = 0, $forcePartialHashing = false)
 {
     if ($limit === 0 && $offset === 0 && !$forcePartialHashing) {
         // md5_file is always faster if we don't chunk the file
         $hash = md5_file($realPath);
         return $hash !== false ? $hash : null;
     }
     $ctx = hash_init('md5');
     if (!$ctx) {
         // Fail to initialize file hashing
         return null;
     }
     // Calculate limit from file size and offset
     if ($limit === 0) {
         $limit = filesize($realPath) - $offset;
     }
     $fh = @fopen($realPath, "rb");
     if ($fh === false) {
         // Failed opening file, cleanup hash context
         hash_final($ctx);
         return null;
     }
     fseek($fh, $offset);
     while ($limit > 0) {
         // Limit chunk size to either our remaining chunk or max chunk size
         $chunkSize = $limit < $this->maxChunkByteSize ? $limit : $this->maxChunkByteSize;
         $limit -= $chunkSize;
         $chunk = fread($fh, $chunkSize);
         hash_update($ctx, $chunk);
     }
     fclose($fh);
     return hash_final($ctx);
 }

 public static function getHash($algoritmo, $data, $key)
 {
     // $key refuerza la encriptación.
     $hash = hash_init($algoritmo, HASH_HMAC, $key);
     hash_update($hash, $data);
     return hash_final($hash);
 }

 public function process(AssetInterface $asset)
 {
     $hash = hash_init('sha1');
     switch ($this->strategy) {
         case self::STRATEGY_MODIFICATION:
             hash_update($hash, $asset->getLastModified());
             break;
         case self::STRATEGY_CONTENT:
             hash_update($hash, $asset->dump());
             break;
     }
     foreach ($asset as $i => $leaf) {
         if ($sourcePath = $leaf->getSourcePath()) {
             hash_update($hash, $sourcePath);
         } else {
             hash_update($hash, $i);
         }
     }
     $hash = substr(hash_final($hash), 0, 7);
     $url = $asset->getTargetPath();
     $oldExt = pathinfo($url, PATHINFO_EXTENSION);
     $newExt = '-' . $hash . '.' . $oldExt;
     if (!$oldExt || 0 < preg_match('/' . preg_quote($newExt, '/') . '$/', $url)) {
         return;
     }
     $asset->setTargetPath(substr($url, 0, (strlen($oldExt) + 1) * -1) . $newExt);
 }

 /**
  * {@inheritdoc}
  */
 public function read($length)
 {
     $chunk = $this->stream->read($length);
     $this->offset += strlen($chunk);
     hash_update($this->md5, $chunk);
     return $chunk;
 }

 /**
  * Sign a message with a secure key.
  *
  * @param array $message_list
  *   The message list.
  *
  * @return string
  *   The signature for the message_list.
  */
 public function sign(array $message_list = array())
 {
     $hm = hash_init(static::getSignatureSchemes()[$this->getSignatureScheme()], HASH_HMAC, $this->getSecureKey());
     foreach ($message_list as $item) {
         hash_update($hm, $item);
     }
     return hash_final($hm);
 }

 public function update($data)
 {
     if ($this->ctx === null) {
         $this->ctx = hash_init($this->algo);
     }
     hash_update($this->ctx, $data);
     return $this;
 }

 /**
  * Generate hash value from string
  * @param merchantID
  * @param settlementmethod - how to settlement （Null or Blank → '00'）
  * @param orderID
  * @param amount - Total Amount
  * @return hash value
  */
 public function generate($merchantID, $merchant_hash, $settlementmethod, $orderID, $amount)
 {
     $ctx = hash_init('sha512');
     $str = $merchant_hash . "," . $merchantID . "," . (is_null($settlementmethod) || strlen($settlementmethod) == 0 ? '00' : $settlementmethod) . "," . $orderID . "," . $amount;
     hash_update($ctx, $str);
     $hash = hash_final($ctx, true);
     return bin2hex($hash);
 }