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);
}
/**
* 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;
}
/**
* 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);
}
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;
}
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 onClose()
{
// $this->params points to an instance of MD5FilterOutput,
// owned by caller, that caller will use to read out the hash:
$this->params->hash = hash_final($this->ctx);
return true;
}
/**
* {@inheritdoc}
*/
public function close()
{
if ($this->stream !== NULL) {
$this->hash = hash_final($this->md5);
}
parent::close();
}
public function getBaseMaterial($seedBytes)
{
$mac = hash_init('sha256', HASH_HMAC, $this->key);
hash_update($mac, $seedBytes);
$data = hash_final($mac, true);
return $data;
}
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);
}
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.'));
}
public static function create($algo, $data, $salt)
{
$context = hash_init($algo, HASH_HMAC, $salt);
//$salt => $key
hash_update($context, $data);
return hash_final($context);
}
/**
* @return Hash
*/
public function getHash() : Hash
{
$hash = new Hash();
$hash->setAlgorithm($this->getAlgorithm());
$hash->setValue(hash_final(hash_copy($this->getHandle()), true));
return $hash;
}
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 testBindWithPlaceholder_Constant()
{
$context = hash_init('md2');
$hash = partial_any('hash_update', $context, …());
$hash('oh hi');
$this->assertSame('6f24cbf6005b9bfc0176abbbe309f0d0', hash_final($context));
}
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;
}
}
}
public function getHash()
{
if (!isset($this->_hashFinal)) {
$this->_hashFinal = hash_final($this->getHashContext());
}
return $this->_hashFinal;
}
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'];
}
/**
* @param $resource
*
* @return string
*/
public function hash($resource)
{
rewind($resource);
$context = hash_init($this->algo);
hash_update_stream($context, $resource);
fclose($resource);
return hash_final($context);
}
private function generateChannelSign($secret, $user, $channel, $info = '')
{
$ctx = hash_init('sha256', HASH_HMAC, $secret);
hash_update($ctx, (string) $user);
hash_update($ctx, (string) $channel);
hash_update($ctx, (string) $info);
return hash_final($ctx);
}
/**
* 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);
}
/**
* Generate hash value from string
* @param merchant_id
* @param merchant_hash_key
* @param order_id
* @return hash value
*/
public static function generate($merchant_id, $merchant_hash_key, $order_id)
{
$ctx = hash_init('sha512');
$str = $merchant_hash_key . "," . $merchant_id . "," . $order_id;
hash_update($ctx, $str);
$hash = hash_final($ctx, true);
return bin2hex($hash);
}
/**
* 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);
}
private function sign(array $message_list)
{
$hm = hash_init($this->hashAlgorithm, HASH_HMAC, $this->key);
foreach ($message_list as $item) {
hash_update($hm, $item);
}
return hash_final($hm);
}
public function hash()
{
$hasher = hash_init('sha256');
hash_update($hasher, $this->kind());
hash_update($hasher, $this->name);
hash_update($hasher, hashComplex($this->t_args));
return hash_final($hasher);
}
/**
* {@inheritdoc}
*/
public function getHash($returnBinaryForm = false)
{
if (!$this->hash) {
$this->hashRaw = hash_final($this->context, true);
$this->hash = HashUtils::binToHex($this->hashRaw);
$this->context = null;
}
return $returnBinaryForm ? $this->hashRaw : $this->hash;
}
/**
* Hash
*
* @param string $data
* @param string $algo
* @return string
*/
public function password($data, $algo = "sha256")
{
if (!$this->CI->config->item("encryption_key")) {
show_error('Encryption key not found');
}
$hash = hash_init($algo, HASH_HMAC, $this->CI->config->item("encryption_key"));
hash_update($hash, $data);
return hash_final($hash);
}
private function computeMac($buffer, $offset, $length)
{
$hmac = hash_init("sha1", HASH_HMAC, $this->macKey);
hash_update($hmac, substr($buffer, $offset, $length));
$array = chr($this->seq >> 24) . chr($this->seq >> 16) . chr($this->seq >> 8) . chr($this->seq);
hash_update($hmac, $array);
$this->seq++;
return hash_final($hmac, true);
}
public function ckey()
{
$ctx = hash_init('sha256', HASH_HMAC, env('CENTRIFUGO_KEY'));
hash_update($ctx, Auth::user()->id);
$timestamp = time();
hash_update($ctx, $timestamp);
$result_hash = hash_final($ctx);
return response()->json(['hash' => $result_hash, 'timestamp' => (string) $timestamp, 'user_id' => (string) Auth::user()->id]);
}
