PHP hash_init函数代码示例

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

 protected function doBackup($stream, $tables, $gzip = false)
 {
     $db = Am_Di::getInstance()->db;
     $stream_filter = null;
     $hash = null;
     $len = 0;
     if ($gzip) {
         $hash = hash_init('crc32b');
         // gzip file header
         fwrite($stream, $this->getGzHeader());
         if (!($stream_filter = stream_filter_append($stream, "zlib.deflate", STREAM_FILTER_WRITE, self::COMPRESSION_LEVEL))) {
             throw new Am_Exception_InternalError("Could not attach gzencode filter to output stream");
         }
     }
     $this->out($stream, "### aMember Pro " . AM_VERSION . " database backup\n", $len, $hash);
     $this->out($stream, "### Created: " . date('Y-m-d H:i:s') . "\n", $len, $hash);
     foreach ($tables as $table) {
         $this->out($stream, "\n\nDROP TABLE IF EXISTS {$table};\n", $len, $hash);
         $r = $db->selectRow("SHOW CREATE TABLE {$table}");
         $this->out($stream, $r['Create Table'] . ";\n", $len, $hash);
         $q = $db->queryResultOnly("SELECT * FROM {$table}");
         while ($a = $db->fetchRow($q)) {
             $fields = join(',', array_keys($a));
             $values = join(',', array_map(array($db, 'escape'), array_values($a)));
             $this->out($stream, "INSERT INTO {$table} ({$fields}) VALUES ({$values});\n", $len, $hash);
         }
         $db->freeResult($q);
     }
     if ($stream_filter) {
         stream_filter_remove($stream_filter);
         fwrite($stream, $this->getGzFooter($len, $hash));
     }
     return $stream;
 }

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

 /**
  * Аутентификация пользователя
  *
  * @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 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);
 }

 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 hash()
 {
     $hasher = hash_init('sha256');
     hash_update($hasher, 'identifier');
     hash_update($hasher, $this->val);
     return hash_final($hasher);
 }

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 getHashContext()
 {
     if (!isset($this->_hashContext)) {
         $this->_hashContext = hash_init("md5");
     }
     return $this->_hashContext;
 }

 public function testBindWithPlaceholder_Constant()
 {
     $context = hash_init('md2');
     $hash = partial_any('hash_update', $context, …());
     $hash('oh hi');
     $this->assertSame('6f24cbf6005b9bfc0176abbbe309f0d0', hash_final($context));
 }

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.'));
}

 /**
  * 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 create($algo, $data, $salt)
 {
     $context = hash_init($algo, HASH_HMAC, $salt);
     //$salt => $key
     hash_update($context, $data);
     return hash_final($context);
 }

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