［PHP］hash_init関数完全ガイド：インクリメンタルハッシュ計算をマスターする方法

大容量データのハッシュ計算や、複数のデータソースから段階的にハッシュを構築したい場合、PHPのhash_init関数は非常に強力なツールです。今回は、インクリメンタル（段階的）ハッシュ計算の起点となるこの関数について、基本概念から高度な実装まで詳しく解説していきます。

hash_init関数とは？
1. 基本構文
  1. パラメータ
  2. 戻り値
インクリメンタルハッシュの基本フロー
実践的な使用例
hash_initのフラグオプション
1. HASH_HMACフラグ
パフォーマンス比較とベンチマーク
実用的なアプリケーション例
1. ファイル同期システム
まとめ

hash_init関数とは？

hash_init関数は、インクリメンタルハッシュ計算のためのハッシュコンテキストを初期化する関数です。一度に全データを処理するのではなく、データを段階的に追加してハッシュを計算できるため、メモリ効率とパフォーマンスの両面でメリットがあります。

基本構文

phpresource hash_init(string $algo, int $flags = 0, string $key = "")

パラメータ

$algo: 使用するハッシュアルゴリズム（md5, sha1, sha256など）
$flags: オプションフラグ（HASH_HMACなど）
$key: HMAC計算を行う場合の秘密鍵

戻り値

ハッシュコンテキストリソース（hash_updateやhash_finalで使用）

インクリメンタルハッシュの基本フロー

インクリメンタルハッシュ計算は以下の3段階で構成されます：

初期化: hash_init() – ハッシュコンテキストを作成
データ追加: hash_update() – データを段階的に追加（複数回実行可能）
最終化: hash_final() – 最終的なハッシュ値を取得

実践的な使用例

例1：基本的な使用法

php// 基本的なインクリメンタルハッシュ
$context = hash_init('sha256');

// データを段階的に追加
hash_update($context, 'Hello, ');
hash_update($context, 'World!');

// 最終的なハッシュ値を取得
$hash = hash_final($context);
echo "SHA-256 ハッシュ: $hash";

// 比較用：一度に計算した場合
$directHash = hash('sha256', 'Hello, World!');
echo "直接計算: $directHash";

// 結果は同じになる
var_dump($hash === $directHash); // true

例2：大容量ファイルの効率的な処理

phpclass LargeFileHasher {
    private $algorithm;
    private $chunkSize;
    
    public function __construct($algorithm = 'sha256', $chunkSize = 1024 * 1024) {
        $this->algorithm = $algorithm;
        $this->chunkSize = $chunkSize; // 1MB chunks
    }
    
    // 大容量ファイルのハッシュ計算
    public function hashLargeFile($filename) {
        if (!file_exists($filename)) {
            throw new Exception("ファイルが存在しません: $filename");
        }
        
        $context = hash_init($this->algorithm);
        $handle = fopen($filename, 'rb');
        
        if (!$handle) {
            throw new Exception("ファイルを開けません: $filename");
        }
        
        $totalBytes = 0;
        $startTime = microtime(true);
        
        while (!feof($handle)) {
            $chunk = fread($handle, $this->chunkSize);
            if ($chunk !== false) {
                hash_update($context, $chunk);
                $totalBytes += strlen($chunk);
            }
        }
        
        fclose($handle);
        
        $hash = hash_final($context);
        $endTime = microtime(true);
        
        return [
            'hash' => $hash,
            'algorithm' => $this->algorithm,
            'file_size' => $totalBytes,
            'processing_time' => $endTime - $startTime,
            'throughput' => $totalBytes / ($endTime - $startTime)
        ];
    }
    
    // 進捗付きハッシュ計算
    public function hashFileWithProgress($filename, $progressCallback = null) {
        $fileSize = filesize($filename);
        $context = hash_init($this->algorithm);
        $handle = fopen($filename, 'rb');
        
        $processedBytes = 0;
        
        while (!feof($handle)) {
            $chunk = fread($handle, $this->chunkSize);
            if ($chunk !== false) {
                hash_update($context, $chunk);
                $processedBytes += strlen($chunk);
                
                // 進捗コールバック実行
                if ($progressCallback && is_callable($progressCallback)) {
                    $progress = ($processedBytes / $fileSize) * 100;
                    $progressCallback($progress, $processedBytes, $fileSize);
                }
            }
        }
        
        fclose($handle);
        return hash_final($context);
    }
}

// 使用例
$hasher = new LargeFileHasher('sha256');

try {
    // 進捗表示付きでハッシュ計算
    $hash = $hasher->hashFileWithProgress('large_video.mp4', function($progress, $processed, $total) {
        echo sprintf("\r進捗: %.1f%% (%s / %s)", 
            $progress, 
            formatBytes($processed), 
            formatBytes($total)
        );
    });
    
    echo "\n完了! ハッシュ: $hash\n";
    
} catch (Exception $e) {
    echo "エラー: " . $e->getMessage();
}

function formatBytes($size, $precision = 2) {
    $units = ['B', 'KB', 'MB', 'GB', 'TB'];
    for ($i = 0; $size > 1024 && $i < count($units) - 1; $i++) {
        $size /= 1024;
    }
    return round($size, $precision) . ' ' . $units[$i];
}

例3：HMAC計算の実装

phpclass IncrementalHMAC {
    private $context;
    private $algorithm;
    private $key;
    
    public function __construct($algorithm, $key) {
        $this->algorithm = $algorithm;
        $this->key = $key;
        $this->context = hash_init($algorithm, HASH_HMAC, $key);
    }
    
    // データを段階的に追加
    public function update($data) {
        if ($this->context === null) {
            throw new Exception("HMACコンテキストが無効です");
        }
        
        hash_update($this->context, $data);
        return $this;  // メソッドチェーンを可能にする
    }
    
    // 最終HMAC値を取得
    public function finalize() {
        if ($this->context === null) {
            throw new Exception("HMACコンテキストが無効です");
        }
        
        $hmac = hash_final($this->context);
        $this->context = null; // コンテキストを無効化
        
        return $hmac;
    }
    
    // ファイルに対するHMAC計算
    public function updateFromFile($filename, $chunkSize = 8192) {
        $handle = fopen($filename, 'rb');
        if (!$handle) {
            throw new Exception("ファイルを開けません: $filename");
        }
        
        while (!feof($handle)) {
            $chunk = fread($handle, $chunkSize);
            if ($chunk !== false) {
                $this->update($chunk);
            }
        }
        
        fclose($handle);
        return $this;
    }
    
    // 複数のデータソースからHMAC計算
    public static function calculateFromMultipleSources($algorithm, $key, $sources) {
        $hmac = new self($algorithm, $key);
        
        foreach ($sources as $source) {
            if (is_string($source)) {
                $hmac->update($source);
            } elseif (is_array($source) && isset($source['type'])) {
                switch ($source['type']) {
                    case 'string':
                        $hmac->update($source['data']);
                        break;
                    case 'file':
                        $hmac->updateFromFile($source['path']);
                        break;
                    default:
                        throw new Exception("不明なソースタイプ: " . $source['type']);
                }
            }
        }
        
        return $hmac->finalize();
    }
}

// 使用例
try {
    // 基本的な使用
    $hmac = new IncrementalHMAC('sha256', 'my-secret-key');
    $result = $hmac->update('Part 1: ')
                   ->update('Part 2: ')
                   ->update('Part 3')
                   ->finalize();
    
    echo "HMAC結果: $result\n";
    
    // 複数ソースからの計算
    $sources = [
        ['type' => 'string', 'data' => 'Header data'],
        ['type' => 'file', 'path' => 'data.txt'],
        ['type' => 'string', 'data' => 'Footer data']
    ];
    
    $combinedHmac = IncrementalHMAC::calculateFromMultipleSources(
        'sha256', 
        'multi-source-key', 
        $sources
    );
    
    echo "複数ソースHMAC: $combinedHmac\n";
    
} catch (Exception $e) {
    echo "エラー: " . $e->getMessage();
}

例4：ストリーミングデータの処理

phpclass StreamingHashProcessor {
    private $contexts = [];
    
    // 複数のアルゴリズムを同時に初期化
    public function initializeAlgorithms($algorithms) {
        foreach ($algorithms as $algo) {
            $this->contexts[$algo] = hash_init($algo);
        }
    }
    
    // 全てのコンテキストにデータを追加
    public function processChunk($data) {
        foreach ($this->contexts as $algo => $context) {
            hash_update($context, $data);
        }
    }
    
    // 全てのハッシュ値を取得
    public function getAllHashes() {
        $results = [];
        
        foreach ($this->contexts as $algo => $context) {
            $results[$algo] = hash_final($context);
        }
        
        // コンテキストをクリア
        $this->contexts = [];
        
        return $results;
    }
    
    // ネットワークストリームからの処理
    public function processNetworkStream($url, $algorithms = ['md5', 'sha1', 'sha256']) {
        $this->initializeAlgorithms($algorithms);
        
        $context = stream_context_create([
            'http' => [
                'timeout' => 30,
                'user_agent' => 'StreamingHashProcessor/1.0'
            ]
        ]);
        
        $stream = fopen($url, 'r', false, $context);
        
        if (!$stream) {
            throw new Exception("ストリームを開けません: $url");
        }
        
        $totalBytes = 0;
        $startTime = microtime(true);
        
        while (!feof($stream)) {
            $chunk = fread($stream, 8192);
            if ($chunk !== false && strlen($chunk) > 0) {
                $this->processChunk($chunk);
                $totalBytes += strlen($chunk);
            }
        }
        
        fclose($stream);
        
        $hashes = $this->getAllHashes();
        $endTime = microtime(true);
        
        return [
            'hashes' => $hashes,
            'total_bytes' => $totalBytes,
            'processing_time' => $endTime - $startTime,
            'url' => $url
        ];
    }
}

// 使用例
$processor = new StreamingHashProcessor();

try {
    // オンラインファイルのハッシュ計算
    $result = $processor->processNetworkStream(
        'https://example.com/large-file.zip',
        ['md5', 'sha256', 'sha512']
    );
    
    echo "処理完了:\n";
    echo "URL: " . $result['url'] . "\n";
    echo "サイズ: " . formatBytes($result['total_bytes']) . "\n";
    echo "処理時間: " . number_format($result['processing_time'], 2) . "秒\n";
    echo "ハッシュ値:\n";
    
    foreach ($result['hashes'] as $algo => $hash) {
        echo "  $algo: $hash\n";
    }
    
} catch (Exception $e) {
    echo "エラー: " . $e->getMessage();
}

hash_initのフラグオプション

HASH_HMACフラグ

php// 通常のハッシュ
$normalContext = hash_init('sha256');

// HMAC計算用
$hmacContext = hash_init('sha256', HASH_HMAC, 'secret-key');

// データ追加
hash_update($normalContext, 'test data');
hash_update($hmacContext, 'test data');

// 結果取得
$normalHash = hash_final($normalContext);
$hmacHash = hash_final($hmacContext);

echo "通常のハッシュ: $normalHash\n";
echo "HMACハッシュ: $hmacHash\n";

// HMAC結果の比較検証
$directHmac = hash_hmac('sha256', 'test data', 'secret-key');
var_dump($hmacHash === $directHmac); // true

パフォーマンス比較とベンチマーク

phpclass HashPerformanceTester {
    
    public function benchmarkHashMethods($data, $algorithm = 'sha256', $iterations = 1000) {
        $results = [];
        
        // 直接ハッシュ計算
        $start = microtime(true);
        for ($i = 0; $i < $iterations; $i++) {
            hash($algorithm, $data);
        }
        $results['direct'] = microtime(true) - $start;
        
        // インクリメンタルハッシュ（一括追加）
        $start = microtime(true);
        for ($i = 0; $i < $iterations; $i++) {
            $context = hash_init($algorithm);
            hash_update($context, $data);
            hash_final($context);
        }
        $results['incremental_single'] = microtime(true) - $start;
        
        // インクリメンタルハッシュ（分割追加）
        $chunks = str_split($data, strlen($data) / 4);
        $start = microtime(true);
        for ($i = 0; $i < $iterations; $i++) {
            $context = hash_init($algorithm);
            foreach ($chunks as $chunk) {
                hash_update($context, $chunk);
            }
            hash_final($context);
        }
        $results['incremental_chunked'] = microtime(true) - $start;
        
        return $results;
    }
    
    public function displayBenchmarkResults($results, $iterations) {
        echo "ベンチマーク結果 ($iterations 回実行):\n";
        echo str_repeat("-", 40) . "\n";
        
        foreach ($results as $method => $time) {
            $avgTime = ($time / $iterations) * 1000; // ミリ秒
            echo sprintf("%-20s: %.3f ms/回 (総計: %.3f秒)\n", 
                $method, $avgTime, $time);
        }
        
        // 最速メソッドとの比較
        $fastest = min($results);
        echo "\n相対パフォーマンス:\n";
        foreach ($results as $method => $time) {
            $ratio = $time / $fastest;
            echo sprintf("%-20s: %.2fx%s\n", 
                $method, $ratio, $ratio == 1.0 ? ' (最速)' : '');
        }
    }
}

// ベンチマーク実行
$tester = new HashPerformanceTester();
$testData = str_repeat('Sample data for hashing benchmark. ', 1000);

$results = $tester->benchmarkHashMethods($testData, 'sha256', 100);
$tester->displayBenchmarkResults($results, 100);

実用的なアプリケーション例

ファイル同期システム

phpclass FileSyncChecker {
    private $algorithm;
    
    public function __construct($algorithm = 'sha256') {
        $this->algorithm = $algorithm;
    }
    
    // ディレクトリの総合ハッシュ値を計算
    public function calculateDirectoryHash($directory) {
        $files = $this->getFileList($directory);
        sort($files); // ファイル順序を固定
        
        $context = hash_init($this->algorithm);
        
        foreach ($files as $file) {
            // ファイルパス（相対）をハッシュに含める
            $relativePath = str_replace($directory . '/', '', $file);
            hash_update($context, $relativePath . "\n");
            
            // ファイル内容をハッシュに含める
            $fileContext = hash_init($this->algorithm);
            $handle = fopen($file, 'rb');
            
            while (!feof($handle)) {
                $chunk = fread($handle, 8192);
                if ($chunk !== false) {
                    hash_update($fileContext, $chunk);
                }
            }
            fclose($handle);
            
            $fileHash = hash_final($fileContext);
            hash_update($context, $fileHash . "\n");
        }
        
        return hash_final($context);
    }
    
    private function getFileList($directory) {
        $iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($directory)
        );
        
        $files = [];
        foreach ($iterator as $file) {
            if ($file->isFile()) {
                $files[] = $file->getPathname();
            }
        }
        
        return $files;
    }
    
    // 2つのディレクトリを比較
    public function compareDirectories($dir1, $dir2) {
        $hash1 = $this->calculateDirectoryHash($dir1);
        $hash2 = $this->calculateDirectoryHash($dir2);
        
        return [
            'dir1_hash' => $hash1,
            'dir2_hash' => $hash2,
            'identical' => $hash1 === $hash2
        ];
    }
}

// 使用例
$checker = new FileSyncChecker();

$comparison = $checker->compareDirectories('/path/to/source', '/path/to/backup');

if ($comparison['identical']) {
    echo "ディレクトリは同一です\n";
} else {
    echo "ディレクトリに差異があります\n";
    echo "ソース: " . $comparison['dir1_hash'] . "\n";
    echo "バックアップ: " . $comparison['dir2_hash'] . "\n";
}

まとめ

hash_init関数は、PHPでインクリメンタルハッシュ計算を実装するための基盤となる重要な関数です。以下の特徴により、様々な高度な用途に活用できます：

主な利点：

メモリ効率: 大容量データでもメモリ使用量を抑制
柔軟性: データを段階的に追加可能
パフォーマンス: 適切な使用で高い処理効率を実現
拡張性: HMACやその他の暗号学的用途にも対応

適用シーン：

大容量ファイルのハッシュ計算
ストリーミングデータの処理
複数データソースの統合ハッシュ
リアルタイム進捗表示付きの処理
ディレクトリ同期システム

hash_initから始まるインクリメンタルハッシュは、単純な一括処理では対応困難な複雑な要件を満たすための強力な手法です。適切に活用することで、効率的で柔軟なハッシュ処理システムを構築できるでしょう。