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]); }