文字列

【C#】SHA-256で文字列を安全にハッシュ化する方法とソルト実装のポイント

2025-05-07更新日: 2025-05-07

SHA-256は一方向ハッシュ関数です。

C#ではSHA256.Create()とComputeHashで32バイトの固定長値を取得できます。

同じ入力は常に同じ結果になるためパスワードにはソルトを加え、レインボーテーブル対策を取るのが定番です。

処理が高速なため暗号化用途より改ざん検知や署名検証に向いています。

目次から探す

SHA-256とC#での役割
- ハッシュ関数の特徴
- 衝突耐性と一方向性
暗号APIの基礎知識
基本のハッシュ化フロー
入力データ別サンプル実装
ソルトでセキュリティを高める
比較時の注意点
- タイミング攻撃への対策
- 固定時間比較メソッドの実装
高計算コストハッシュとの違い
- SHA-256単体の限界
- PBKDF2・bcryptとの使い分け
パフォーマンスと最適化
HMAC-SHA256の応用
- 共有キーとメッセージ認証コード
- API署名への展開例
よくある落とし穴
テストと検証のポイント
- 既知値との比較テスト
- 異常系動作のハンドリング
まとめ

SHA-256とC#での役割

SHA-256は、セキュリティ分野で広く使われている暗号学的ハッシュ関数の一つです。

C#でSHA-256を利用することで、文字列やファイルなどのデータを安全にハッシュ化し、改ざん検知やパスワードの保護に役立てることができます。

このセクションでは、SHA-256の基本的な特徴と、C#での役割についてわかりやすく解説いたします。

ハッシュ関数の特徴

ハッシュ関数とは、任意の長さの入力データを固定長のハッシュ値に変換する関数です。

SHA-256はその中でも特に安全性が高いとされる関数で、以下のような特徴を持っています。

固定長の出力

SHA-256は常に256ビット(32バイト)のハッシュ値を生成します。

入力データのサイズに関わらず、出力は一定の長さであるため、比較や保存が容易です。

一方向性

ハッシュ関数は「一方向性」が重要な性質です。

これは、ハッシュ値から元の入力データを復元することが極めて困難であることを意味します。

つまり、ハッシュ化したデータは元に戻せないため、パスワードの保存などに適しています。

高速な計算

SHA-256は計算が高速であるため、大量のデータを短時間で処理できます。

ただし、この高速性は逆にブルートフォース攻撃に対して弱点となる場合もありますので、後述のソルトや他の手法と組み合わせて使うことが推奨されます。

入力のわずかな違いで大きく変わる出力

入力データが1ビットでも異なると、生成されるハッシュ値は全く異なるものになります。

これを「アバランチ効果」と呼び、データの整合性検証に役立ちます。

これらの特徴により、SHA-256はデータの整合性チェックやパスワードのハッシュ化、デジタル署名の生成など、さまざまなセキュリティ用途で利用されています。

衝突耐性と一方向性

SHA-256の安全性を支える重要な要素として、「衝突耐性」と「一方向性」があります。

これらは暗号学的ハッシュ関数の基本的な要件であり、セキュリティを確保する上で欠かせません。

衝突耐性(Collision Resistance)

衝突とは、異なる2つの入力データが同じハッシュ値を生成してしまう現象です。

衝突耐性とは、このような衝突を見つけることが非常に難しい性質を指します。

SHA-256は現在のところ、実用的な時間内に衝突を見つけることが困難であるとされています。

衝突耐性が高いことで、攻撃者が意図的に同じハッシュ値を持つ別のデータを作成し、システムを騙すリスクを減らせます。

例えば、ファイルの改ざん検知において、衝突が起きると改ざんを見逃してしまう可能性があるため、衝突耐性は非常に重要です。

一方向性(Preimage Resistance)

一方向性は、ハッシュ値から元の入力データを逆算することが極めて難しい性質です。

これにより、パスワードなどの機密情報をハッシュ化して保存しても、ハッシュ値から元のパスワードを推測されにくくなります。

一方向性が弱いと、攻撃者がハッシュ値を解析して元のデータを特定できてしまい、セキュリティが破られる恐れがあります。

SHA-256はこの一方向性を強く備えているため、パスワードのハッシュ化に適しています。

これらの特徴を踏まえ、C#ではSystem.Security.Cryptography名前空間のSHA256クラスを使って簡単にSHA-256ハッシュを計算できます。

暗号APIの基礎知識

System.Security.Cryptographyの位置づけ

C#で暗号処理を行う際の中心的なAPIは、System.Security.Cryptography名前空間に含まれています。

この名前空間は、ハッシュ関数、対称鍵暗号、公開鍵暗号、デジタル署名、乱数生成など、幅広い暗号機能を提供しています。

SHA-256のようなハッシュアルゴリズムもここに含まれており、標準ライブラリとして.NET環境に組み込まれているため、外部ライブラリを追加せずに利用可能です。

System.Security.Cryptographyは、セキュリティ関連の処理を安全かつ効率的に実装できるよう設計されており、以下のような特徴があります。

プラットフォームに依存しない実装

Windowsだけでなく、LinuxやmacOSなどのクロスプラットフォーム環境でも同じAPIで動作します。

マネージコードとネイティブコードの橋渡し

内部的にはOSの暗号サービスプロバイダー(CSP)やネイティブライブラリを利用しつつ、C#のマネージコードから簡単に呼び出せるようになっています。

セキュリティのベストプラクティスに準拠

安全な乱数生成やメモリのクリア処理など、セキュリティ上の注意点が考慮されています。

このため、SHA-256をはじめとした暗号処理を行う際は、まずSystem.Security.CryptographyのAPIを活用することが推奨されます。

SHA256クラスと派生アルゴリズム

System.Security.Cryptography名前空間には、SHA-256を実装したSHA256クラスが用意されています。

このクラスは抽象クラスHashAlgorithmを継承しており、ComputeHashメソッドを使って簡単にハッシュ値を計算できます。

SHA256クラスは直接インスタンス化せず、SHA256.Create()メソッドを使って生成するのが一般的です。

これにより、環境に最適な実装が自動的に選択されます。

また、SHA-256の他にもSHA-1やSHA-384、SHA-512などの派生アルゴリズムが同じ名前空間に存在し、用途に応じて使い分けが可能です。

クラス名	ハッシュ長(ビット)	用途例
SHA1	160	古いシステムとの互換性、非推奨
SHA256	256	現代的なセキュリティ要件に適合
SHA384	384	高いセキュリティが必要な場合
SHA512	512	さらに強力なハッシュが必要な場合

SHA-256はバランスの良い安全性とパフォーマンスを持つため、パスワードのハッシュ化やデータ整合性チェックで広く使われています。

.NET 6以降の新機能

.NET 6以降では、暗号APIにいくつかの改善と新機能が追加されています。

特にパフォーマンスと使いやすさの向上が図られており、SHA-256の利用においても恩恵があります。

TryComputeHashメソッドの追加

従来のComputeHashは新しいバイト配列を返すため、頻繁に呼び出すとメモリ割り当てが増えがちでした。

TryComputeHashは呼び出し元が用意したバッファに直接ハッシュ値を書き込むため、メモリの再割り当てを抑制できます。

これにより、パフォーマンスが向上し、ガベージコレクションの負荷も軽減されます。

Span<T>やMemory<T>との連携強化

.NET 6以降はSpan<byte>やReadOnlySpan<byte>を使ったAPIが充実し、バッファのコピーを減らして効率的にデータを扱えます。

これにより、特に大きなデータやストリームのハッシュ化で高速化が期待できます。

プラットフォーム固有の最適化

ARMやx64などのCPUアーキテクチャに合わせた最適化が進み、ハードウェアアクセラレーションを活用した高速なハッシュ計算が可能になっています。

これらの新機能を活用することで、C#でのSHA-256ハッシュ化はより効率的かつ安全に行えます。

例えば、TryComputeHashを使ったコードは以下のようになります。

using System;
using System.Security.Cryptography;
using System.Text;
class Program
{
    static void Main()
    {
        string input = "ExampleText";
        byte[] inputBytes = Encoding.UTF8.GetBytes(input);
        byte[] hashBuffer = new byte[32]; // SHA-256は32バイト
        using (SHA256 sha256 = SHA256.Create())
        {
            if (sha256.TryComputeHash(inputBytes, hashBuffer, out int bytesWritten))
            {
                Console.WriteLine($"ハッシュ値(16進数): {BitConverter.ToString(hashBuffer).Replace("-", "")}");
                Console.WriteLine($"書き込まれたバイト数: {bytesWritten}");
            }
            else
            {
                Console.WriteLine("ハッシュ計算に失敗しました。");
            }
        }
    }
}

ハッシュ値(16進数): A82BBCE7F59F77A5F4126D274731214B0125AB1D8D46CA1441AB42D286F465FF
書き込まれたバイト数: 32

このように、.NET 6以降のAPIを使うことで、メモリ効率を高めつつ安全にSHA-256ハッシュを計算できます。

基本のハッシュ化フロー

SHA-256で文字列をハッシュ化する際の基本的な流れは、入力文字列をバイト列に変換し、SHA-256のインスタンスを生成してハッシュ値を計算し、最後にそのハッシュ値を人間が読みやすい16進数の文字列に変換するというステップで構成されています。

ここでは、それぞれの処理を詳しく解説し、C#のコード例を交えて説明いたします。

文字列をバイト列へ変換するエンコーディング

ハッシュ関数はバイト列を入力として処理を行うため、まず文字列をバイト配列に変換する必要があります。

C#ではSystem.Text.Encodingクラスを使ってエンコーディングを指定し、文字列をバイト列に変換します。

一般的にUTF-8エンコーディングが推奨されており、国際化対応や互換性の面で優れています。

以下のコードは文字列をUTF-8のバイト配列に変換する例です。

using System;
using System.Text;
class Program
{
    static void Main()
    {
        string originalText = "パスワード123";
        byte[] byteValue = Encoding.UTF8.GetBytes(originalText);
        Console.WriteLine("元の文字列: " + originalText);
        Console.WriteLine("バイト配列の長さ: " + byteValue.Length);
    }
}

元の文字列: パスワード123
バイト配列の長さ: 18

このように、Encoding.UTF8.GetBytesメソッドで文字列をバイト配列に変換します。

エンコーディングを間違えると、同じ文字列でも異なるバイト列になり、結果として異なるハッシュ値が生成されるため注意が必要です。

SHA256.Create()でのインスタンス生成

SHA-256のハッシュ計算を行うには、System.Security.Cryptography名前空間のSHA256クラスのインスタンスを生成します。

直接コンストラクタを呼び出すのではなく、SHA256.Create()メソッドを使うのが一般的です。

これにより、環境に最適な実装が自動的に選択されます。

using System;
using System.Security.Cryptography;
class Program
{
    static void Main()
    {
        using (SHA256 sha256 = SHA256.Create())
        {
            Console.WriteLine("SHA256インスタンスを生成しました。");
        }
    }
}

using文を使うことで、ハッシュ計算後にリソースが確実に解放されます。

SHA256はIDisposableを実装しているため、使い終わったら必ず破棄することが推奨されます。

ComputeHashでハッシュ値を取得

生成したSHA256インスタンスのComputeHashメソッドにバイト配列を渡すと、SHA-256のハッシュ値が計算され、バイト配列として返されます。

using System;
using System.Security.Cryptography;
using System.Text;
class Program
{
    static void Main()
    {
        string originalText = "パスワード123";
        byte[] byteValue = Encoding.UTF8.GetBytes(originalText);
        using (SHA256 sha256 = SHA256.Create())
        {
            byte[] hashValue = sha256.ComputeHash(byteValue);
            Console.WriteLine("ハッシュ値のバイト配列の長さ: " + hashValue.Length);
        }
    }
}

ハッシュ値のバイト配列の長さ: 32

SHA-256のハッシュ値は常に32バイト(256ビット)で固定されます。

ComputeHashは入力のバイト配列を受け取り、対応するハッシュ値を返すシンプルなメソッドです。

ハッシュ値を16進数文字列へ変換する処理

ハッシュ値はバイト配列のままだと人間には読みづらいため、16進数の文字列に変換して表示や保存を行います。

C#ではStringBuilderを使って効率的に変換できます。

using System;
using System.Security.Cryptography;
using System.Text;
class Program
{
    static void Main()
    {
        string originalText = "パスワード123";
        byte[] byteValue = Encoding.UTF8.GetBytes(originalText);
        using (SHA256 sha256 = SHA256.Create())
        {
            byte[] hashValue = sha256.ComputeHash(byteValue);
            StringBuilder hashedText = new StringBuilder();
            foreach (byte b in hashValue)
            {
                // 16進数2桁で文字列に変換(大文字)
                hashedText.AppendFormat("{0:X2}", b);
            }
            Console.WriteLine("元の文字列: " + originalText);
            Console.WriteLine("SHA-256ハッシュ値: " + hashedText.ToString());
        }
    }
}

元の文字列: パスワード123
SHA-256ハッシュ値: 53F12936F99105F7FC40460480D2A19135E51D0C73ECC061DE9DEFEB85ECC58E

(※出力は例示です。

実際のハッシュ値は異なります)

AppendFormat("{0:X2}", b)は、バイト値を2桁の16進数(大文字)に変換し、連結しています。

これにより、ハッシュ値が64文字の16進数文字列として表現されます。

以上が、C#でSHA-256を使って文字列をハッシュ化する基本的な流れです。

文字列のエンコーディングから始まり、ハッシュ計算、そして結果の文字列化までの一連の処理を理解することで、安全なハッシュ化を実装できます。

入力データ別サンプル実装

SHA-256でハッシュ化する対象は文字列だけでなく、ファイルやバイナリデータ、大容量のストリームなど多岐にわたります。

ここでは、代表的な入力データごとにC#での具体的なサンプルコードを示しながら解説いたします。

パスワード文字列

パスワードのハッシュ化はセキュリティ上非常に重要です。

文字列をUTF-8でバイト配列に変換し、SHA256クラスでハッシュ化します。

以下はパスワード文字列をハッシュ化し、16進数文字列で出力する例です。

using System;
using System.Security.Cryptography;
using System.Text;
class Program
{
    static void Main()
    {
        string password = "MySecurePassword123!";
        byte[] passwordBytes = Encoding.UTF8.GetBytes(password);
        using (SHA256 sha256 = SHA256.Create())
        {
            byte[] hashBytes = sha256.ComputeHash(passwordBytes);
            StringBuilder hashString = new StringBuilder();
            foreach (byte b in hashBytes)
            {
                hashString.AppendFormat("{0:x2}", b);
            }
            Console.WriteLine("パスワード: " + password);
            Console.WriteLine("SHA-256ハッシュ: " + hashString.ToString());
        }
    }
}

パスワード: MySecurePassword123!
SHA-256ハッシュ: 3d0efb0e3071066fa0807984c1b3ebe21915ad246309f8e3e642eb6931fc2434

このコードはパスワードを安全にハッシュ化し、保存や比較に使いやすい16進数文字列に変換しています。

実際の運用ではソルトを加えることが推奨されます。

テキストファイル

テキストファイルの内容をSHA-256でハッシュ化する場合は、ファイル全体を読み込み、バイト配列に変換してからハッシュ計算を行います。

File.ReadAllBytesを使うと簡単です。

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
class Program
{
    static void Main()
    {
        string filePath = "sample.txt";
        if (!File.Exists(filePath))
        {
            Console.WriteLine("ファイルが存在しません: " + filePath);
            return;
        }
        byte[] fileBytes = File.ReadAllBytes(filePath);
        using (SHA256 sha256 = SHA256.Create())
        {
            byte[] hashBytes = sha256.ComputeHash(fileBytes);
            StringBuilder hashString = new StringBuilder();
            foreach (byte b in hashBytes)
            {
                hashString.AppendFormat("{0:x2}", b);
            }
            Console.WriteLine("ファイルパス: " + filePath);
            Console.WriteLine("SHA-256ハッシュ: " + hashString.ToString());
        }
    }
}

ファイルパス: sample.txt
SHA-256ハッシュ: 2d025b743851889a7f53a33b5c5ffd2c80fcb64f66d6c76de6b2753619c0ff03

ファイルサイズが大きい場合はメモリ消費が増えるため、後述のストリーム処理を検討してください。

バイナリデータ

画像や音声、圧縮ファイルなどのバイナリデータも同様にバイト配列として扱い、SHA-256でハッシュ化できます。

以下は任意のバイナリデータをハッシュ化する例です。

using System;
using System.Security.Cryptography;
class Program
{
    static void Main()
    {
        // 例としてバイナリデータを直接定義
        byte[] binaryData = new byte[] { 0x01, 0x02, 0xFF, 0xA0, 0xB1, 0xC2 };
        using (SHA256 sha256 = SHA256.Create())
        {
            byte[] hashBytes = sha256.ComputeHash(binaryData);
            Console.WriteLine("バイナリデータのSHA-256ハッシュ:");
            foreach (byte b in hashBytes)
            {
                Console.Write($"{b:x2}");
            }
            Console.WriteLine();
        }
    }
}

バイナリデータのSHA-256ハッシュ:
18787c08b3b1afd7a8554c7bfe3ac28057aed4543afa97a11301b4afe4391235

(※出力は例示です)

バイナリデータはそのままComputeHashに渡せるため、ファイルの読み込みやネットワークから受け取ったデータの検証などに活用できます。

大容量ストリーム

大きなファイルやネットワークストリームを一度にメモリに読み込むのは非効率であり、メモリ不足の原因にもなります。

SHA256クラスはTransformBlockやTransformFinalBlockメソッドを使ってストリームを分割して処理できますが、より簡単にCryptoStreamを使う方法が一般的です。

以下はファイルをストリームとして読み込み、バッファ単位でSHA-256ハッシュを計算する例です。

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
class Program
{
    static void Main()
    {
        string filePath = "largefile.bin";
        if (!File.Exists(filePath))
        {
            Console.WriteLine("ファイルが存在しません: " + filePath);
            return;
        }
        using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
        using (SHA256 sha256 = SHA256.Create())
        {
            byte[] hashBytes = sha256.ComputeHash(fs);
            StringBuilder hashString = new StringBuilder();
            foreach (byte b in hashBytes)
            {
                hashString.AppendFormat("{0:x2}", b);
            }
            Console.WriteLine("大容量ファイルのSHA-256ハッシュ:");
            Console.WriteLine(hashString.ToString());
        }
    }
}

大容量ファイルのSHA-256ハッシュ:
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855

この方法はファイル全体をメモリに読み込まずに済むため、数GBのファイルでも安全かつ効率的にハッシュ化できます。

ComputeHashはStreamを受け取るオーバーロードが用意されているため、ストリームの先頭から末尾まで自動的に読み込みながらハッシュ計算を行います。

これらのサンプルを活用することで、用途に応じたSHA-256ハッシュ化をC#で簡単に実装できます。

特に大容量データはストリーム処理を使うことでメモリ効率を高められるため、実務での利用に適しています。

ソルトでセキュリティを高める

パスワードのハッシュ化において、単純にパスワードをSHA-256でハッシュ化するだけではセキュリティ上のリスクが残ります。

そこで「ソルト」と呼ばれるランダムなデータを加えることで、同じパスワードでも異なるハッシュ値を生成し、攻撃に対する耐性を強化します。

ここではソルトの役割や生成方法、管理方法について詳しく説明いたします。

同一パスワードに異なるハッシュを生成する理由

もしソルトを使わずにパスワードをハッシュ化すると、同じパスワードは常に同じハッシュ値になります。

これには以下のような問題があります。

複数ユーザーが同じパスワードを使っていることがわかる

例えば、ユーザーAとユーザーBが同じパスワードを使っている場合、ハッシュ値も同じになるため、攻撃者にパスワードの共通利用が露見します。

レインボーテーブル攻撃に弱い

事前に計算されたハッシュ値の一覧(レインボーテーブル)を使って、ハッシュ値から元のパスワードを高速に推測されるリスクがあります。

ソルトを加えることで、同じパスワードでもユーザーごとに異なるハッシュ値が生成され、これらの問題を防げます。

ソルトはパスワードに付加するランダムなバイト列で、ハッシュ化の入力としてパスワードと結合して使います。

レインボーテーブル攻撃の回避

レインボーテーブル攻撃は、あらかじめ大量のパスワードとそのハッシュ値を計算して保存したテーブルを使い、ハッシュ値から元のパスワードを逆算する手法です。

ソルトを使うことで、この攻撃を効果的に防げます。

理由は以下の通りです。

ソルトが異なれば、同じパスワードでも異なるハッシュ値になるため、レインボーテーブルを使い回せません
攻撃者はソルトごとにテーブルを作成し直す必要があり、計算コストと時間が膨大になります

つまり、ソルトはパスワードのハッシュ化に「個別の秘密鍵」のような役割を果たし、攻撃の難易度を大幅に上げます。

乱数品質とソルト生成

ソルトはランダムであることが重要です。

予測可能なソルトを使うと、攻撃者に利用される恐れがあります。

C#では高品質な乱数を生成するためにRandomNumberGeneratorクラスを使います。

RandomNumberGenerator.GetBytesの活用

RandomNumberGenerator.GetBytesメソッドは、暗号学的に安全な乱数を生成し、指定したバイト配列に埋め込みます。

これを使ってソルトを生成する例を示します。

using System;
using System.Security.Cryptography;
class Program
{
    static void Main()
    {
        byte[] salt = new byte[16]; // 16バイトのソルトを生成
        RandomNumberGenerator.Fill(salt);
        Console.WriteLine("生成したソルト(16進数):");
        foreach (byte b in salt)
        {
            Console.Write($"{b:x2}");
        }
        Console.WriteLine();
    }
}

生成したソルト(16進数):
ffb54fd2116e71ebd736cc72bd32c26e

このように、RandomNumberGenerator.Fillを使うと簡単に安全なソルトを作成できます。

ソルトの長さは一般的に16バイト(128ビット)以上が推奨されます。

ユーザーごとのソルト管理

ソルトはユーザーごとに異なる値を生成し、パスワードのハッシュ化時に必ず使用します。

生成したソルトはハッシュ値とセットで保存し、認証時に同じソルトを使って入力パスワードのハッシュを計算して比較します。

管理方法のポイントは以下の通りです。

ソルトは秘密にする必要はない

ソルトは攻撃者に知られても問題ありません。

重要なのはランダムで一意であることです。

ハッシュ値と一緒に保存する

データベースのユーザーテーブルにソルト用のカラムを設け、ハッシュ値と並べて保存します。

ソルトの長さと形式を統一する

例えば16バイトのバイナリデータをBase64や16進数文字列に変換して保存することが多いです。

ソルトとハッシュ値の保存形式

ソルトとハッシュ値はセットで保存し、認証時に両方を使ってパスワードの検証を行います。

保存形式は以下のような方法があります。

保存形式例	説明
別々のカラムに保存	`Salt`カラムと`PasswordHash`カラムを分けて保存
連結して1つの文字列で保存	ソルトとハッシュ値を連結し、区切り文字や固定長で分割可能にする

例えば、16バイトのソルトと32バイトのSHA-256ハッシュを16進数文字列に変換し、ソルトとハッシュをコロンで区切って保存する例です。

a1b2c3d4e5f60718293a4b5c6d7e8f90:9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08

認証時はこの文字列を分割し、ソルトを取り出して入力パスワードに付加し、ハッシュ計算を行います。

ソルトを適切に生成・管理し、ハッシュ値と組み合わせて保存することで、パスワードの安全性を大幅に向上させられます。

これにより、同じパスワードでも異なるハッシュ値となり、攻撃者の解析を困難にします。

比較時の注意点

パスワードやデータのハッシュ値を比較する際には、単純なバイト列や文字列の比較ではなく、セキュリティ上のリスクを考慮した方法を用いる必要があります。

特に「タイミング攻撃」と呼ばれる攻撃手法に対する対策が重要です。

ここではタイミング攻撃の概要と、それを防ぐための固定時間比較メソッドの実装方法を解説します。

タイミング攻撃への対策

タイミング攻撃とは、比較処理にかかる時間の差を測定し、その差から情報を推測する攻撃手法です。

例えば、ハッシュ値の比較を行う際に、先頭から一致するバイト数だけ比較を続け、異なる箇所で処理を中断するような実装だと、比較にかかる時間が入力によって微妙に変化します。

攻撃者はこの時間差を何度も測定し、どのバイトまで一致しているかを推測することで、最終的に正しいハッシュ値やパスワードを特定できる可能性があります。

これは特にネットワーク越しの認証処理などで問題となります。

したがって、ハッシュ値やパスワードの比較は、比較対象の長さに関わらず一定時間で処理が完了する「固定時間比較(constant-time comparison)」を行うことが推奨されます。

これにより、処理時間から情報が漏れるリスクを防げます。

固定時間比較メソッドの実装

C#では標準で固定時間比較を行うメソッドは用意されていませんが、簡単に実装可能です。

以下はバイト配列を固定時間で比較するサンプルコードです。

using System;
class Program
{
    static void Main()
    {
        byte[] hash1 = { 0x1a, 0x2b, 0x3c, 0x4d };
        byte[] hash2 = { 0x1a, 0x2b, 0x3c, 0x4d };
        byte[] hash3 = { 0x1a, 0x2b, 0x3c, 0x4e };
        Console.WriteLine("hash1 と hash2 の比較結果: " + FixedTimeEquals(hash1, hash2));
        Console.WriteLine("hash1 と hash3 の比較結果: " + FixedTimeEquals(hash1, hash3));
    }
    static bool FixedTimeEquals(byte[] a, byte[] b)
    {
        if (a == null || b == null || a.Length != b.Length)
            return false;
        int diff = 0;
        for (int i = 0; i < a.Length; i++)
        {
            diff |= a[i] ^ b[i];
        }
        return diff == 0;
    }
}

hash1 と hash2 の比較結果: True
hash1 と hash3 の比較結果: False

実装のポイント

長さのチェック

長さが異なる場合は即座にfalseを返します。

長さが異なる場合は比較の意味がないためです。

ビット単位の差分を累積

各バイトをXOR演算し、その結果をdiffにOR演算で累積します。

これにより、全バイトを必ず最後まで比較します。

結果判定

diffが0であれば全バイトが一致し、0以外なら不一致です。

この方法は、バイト列のどの位置で不一致があっても必ず全バイトを比較し続けるため、処理時間が一定に近くなり、タイミング攻撃を防止できます。

固定時間比較はパスワード認証やトークン検証など、セキュリティが重要な場面で必須の実装です。

単純なSequenceEqualやEqualsメソッドは早期リターンを行うため、タイミング攻撃のリスクがあることを理解しておきましょう。

高計算コストハッシュとの違い

パスワードの安全な保存には、単にSHA-256のような高速なハッシュ関数を使うだけでは不十分な場合があります。

ここでは、SHA-256単体の限界と、より安全性を高めるために用いられるPBKDF2やbcryptなどの高計算コストハッシュとの違い、使い分けについて説明します。

SHA-256単体の限界

SHA-256は高速で効率的にハッシュ値を計算できるため、データの整合性チェックやデジタル署名などに適しています。

しかし、パスワードのハッシュ化に単独で使う場合、以下のような限界があります。

高速すぎるためブルートフォース攻撃に弱い

攻撃者は大量のパスワード候補を高速にハッシュ化し、総当たり攻撃(ブルートフォース攻撃)を行いやすくなります。

特にGPUやASICを使った並列処理で計算速度が飛躍的に向上しているため、単純なSHA-256は防御力が不足します。

計算コストの調整ができない

SHA-256は固定の計算量で処理されるため、処理時間を意図的に遅くして攻撃を困難にすることができません。

ソルトだけでは不十分な場合がある

ソルトを加えても、計算速度が速いために攻撃者が大量のハッシュを生成して比較することは可能です。

これらの理由から、パスワードのハッシュ化には計算コストを意図的に高く設定できる専用のアルゴリズムが推奨されます。

PBKDF2・bcryptとの使い分け

PBKDF2(Password-Based Key Derivation Function 2)やbcryptは、パスワードのハッシュ化に特化した高計算コストのアルゴリズムです。

これらは計算に時間がかかるため、ブルートフォース攻撃の難易度を大幅に上げられます。

アルゴリズム	特徴	利用シーン例
PBKDF2	繰り返し回数(イテレーション)を設定可能です。HMACと組み合わせて安全性向上。	多くのプラットフォームで標準的に利用可能です。
bcrypt	Blowfish暗号をベースにした設計。計算コストとメモリ使用量を調整可能です。	Webアプリケーションのパスワード保存に広く利用。
Argon2	メモリ使用量も調整可能な最新のアルゴリズム。耐GPU攻撃に強い。	高セキュリティが求められる環境。

PBKDF2の特徴

PBKDF2は、SHA-256などのハッシュ関数を内部で繰り返し適用し、計算コストを高めます。

繰り返し回数(イテレーション数)を増やすことで、処理時間を調整可能です。

C#のRfc2898DeriveBytesクラスで簡単に利用できます。

bcryptの特徴

bcryptはパスワードハッシュ化専用に設計されており、計算コストの調整に加え、メモリ使用量も制御できます。

これにより、GPUやASICを使った高速攻撃に対しても耐性があります。

多くのWebフレームワークで標準的に採用されています。

使い分けのポイント

互換性や環境に応じて選択

PBKDF2は多くの環境でサポートされており、既存の.NET環境でも簡単に利用可能です。

bcryptは特にWebアプリケーションでの利用が多いです。

セキュリティ要件に応じて計算コストを調整

どちらも計算コストを設定できるため、システムの性能とセキュリティのバランスを考慮して設定します。

将来的な耐性を考慮

Argon2のような最新アルゴリズムは、より強力な攻撃に対しても耐性が高いため、可能であれば検討するとよいでしょう。

まとめると、SHA-256単体は高速で便利ですが、パスワードの安全な保存には計算コストを調整できるPBKDF2やbcryptなどの専用アルゴリズムを使うことが望ましいです。

これにより、ブルートフォース攻撃や辞書攻撃に対する耐性を大幅に向上させられます。

パフォーマンスと最適化

SHA-256のハッシュ計算は比較的高速ですが、大量のデータや高頻度の処理が求められる場合はパフォーマンスの最適化が重要になります。

ここでは、.NETの最新APIを活用した効率的なハッシュ計算方法やメモリ使用量の削減、さらに並列処理や非同期実行によるスループット向上のポイントを解説します。

TryComputeHashとSpan<T>の活用

.NET 6以降で導入されたTryComputeHashメソッドは、呼び出し元が用意したバッファに直接ハッシュ値を書き込むため、不要なメモリ割り当てを減らせます。

これによりGC(ガベージコレクション)の負荷が軽減され、パフォーマンスが向上します。

また、Span<T>やReadOnlySpan<T>を使うことで、配列のコピーを避けて効率的にデータを扱えます。

これらはスタック上のメモリや既存のバッファを参照するため、ヒープ割り当てを減らせるのが特徴です。

以下はTryComputeHashとSpan<byte>を使った例です。

using System;
using System.Security.Cryptography;
using System.Text;
class Program
{
    static void Main()
    {
        string input = "OptimizePerformance";
        ReadOnlySpan<byte> inputBytes = Encoding.UTF8.GetBytes(input);
        Span<byte> hashBuffer = stackalloc byte[32]; // SHA-256は32バイト
        using (SHA256 sha256 = SHA256.Create())
        {
            bool success = sha256.TryComputeHash(inputBytes, hashBuffer, out int bytesWritten);
            if (success && bytesWritten == 32)
            {
                Console.WriteLine("ハッシュ値(16進数): " + BitConverter.ToString(hashBuffer.ToArray()).Replace("-", ""));
            }
            else
            {
                Console.WriteLine("ハッシュ計算に失敗しました。");
            }
        }
    }
}

ハッシュ値(16進数): EFB54F06BED8EA8F97146CE4E74F16EAB55FB60C66B599088B47DD97010174F4

このコードでは、stackallocでスタック上に固定長バッファを確保し、ヒープ割り当てを回避しています。

TryComputeHashはバッファのサイズが足りない場合にfalseを返すため、バッファサイズの管理が重要です。

バッファ再利用によるメモリ削減

大量のハッシュ計算を繰り返す場合、毎回新しいバイト配列を生成するとメモリ割り当てが増え、GCの負荷が高まります。

これを防ぐために、バッファを再利用する設計が効果的です。

例えば、ハッシュ計算用のバッファをクラスのフィールドやメソッドの外部で一度確保し、複数回の計算で使い回す方法があります。

これにより、メモリの断片化や割り当てコストを抑えられます。

using System;
using System.Security.Cryptography;
using System.Text;
class Hasher
{
    private readonly SHA256 sha256 = SHA256.Create();
    private readonly byte[] hashBuffer = new byte[32];
    public string ComputeHash(string input)
    {
        byte[] inputBytes = Encoding.UTF8.GetBytes(input);
        byte[] hashBytes = sha256.ComputeHash(inputBytes);
        // バッファにコピーして再利用も可能
        Array.Copy(hashBytes, hashBuffer, hashBytes.Length);
        StringBuilder sb = new StringBuilder(64);
        foreach (byte b in hashBuffer)
        {
            sb.AppendFormat("{0:x2}", b);
        }
        return sb.ToString();
    }
    public void Dispose()
    {
        sha256.Dispose();
    }
}
class Program
{
    static void Main()
    {
        var hasher = new Hasher();
        Console.WriteLine(hasher.ComputeHash("ReuseBufferExample"));
        Console.WriteLine(hasher.ComputeHash("AnotherInput"));
        hasher.Dispose();
    }
}

16582953a388f296c062819aaa914b03754d04148c25667a12861dfb3c36210f
8c2f15887e20b5243a9d68393a69f808f1a0d4a19be0940dff6104d60bcc2cf5

この例では、hashBufferを使い回すことでメモリ割り当てを抑えています。

大量のハッシュ計算を行うバッチ処理やサーバーアプリケーションで有効です。

並列処理と非同期実行

大量のデータをハッシュ化する場合、CPUのマルチコアを活用して並列処理を行うことで処理時間を短縮できます。

C#のParallel.ForやTaskを使って複数のハッシュ計算を同時に実行する方法があります。

using System;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        string[] inputs = new string[]
        {
            "Parallel1",
            "Parallel2",
            "Parallel3",
            "Parallel4"
        };
        Parallel.For(0, inputs.Length, i =>
        {
            using (SHA256 sha256 = SHA256.Create())
            {
                byte[] inputBytes = Encoding.UTF8.GetBytes(inputs[i]);
                byte[] hashBytes = sha256.ComputeHash(inputBytes);
                string hashString = BitConverter.ToString(hashBytes).Replace("-", "");
                Console.WriteLine($"Input: {inputs[i]}, Hash: {hashString}");
            }
        });
    }
}

Input: Parallel4, Hash: 84B9889F7159BD9B8D1219E5F8E10B813817AABAB47DA26E7F7B4301F5A37DCE
Input: Parallel2, Hash: 32B62409782B8FEEFE9A307B967B1538E8E8EAB18E070951E13B146C6A1F7C20
Input: Parallel3, Hash: 9292131DC0B2CD179EA3C011AD566D6EE1037753A09584BB072B195AAD23F4AB
Input: Parallel1, Hash: 97B15F828BA4476CDD6572C454905C8C354DB6BAC8CA6427C76EFEA45CF144DE

また、非同期処理を組み合わせることで、I/O待ちの間に他の処理を進めることが可能です。

ファイルの読み込みやネットワークからのデータ取得と組み合わせる場合に有効です。

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Program
{
    static async Task Main()
    {
        string filePath = "largefile.dat";
        if (!File.Exists(filePath))
        {
            Console.WriteLine("ファイルが存在しません。");
            return;
        }
        using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true))
        using (SHA256 sha256 = SHA256.Create())
        {
            byte[] hashBytes = await sha256.ComputeHashAsync(fs);
            string hashString = BitConverter.ToString(hashBytes).Replace("-", "");
            Console.WriteLine($"ファイルのSHA-256ハッシュ: {hashString}");
        }
    }
}

ファイルのSHA-256ハッシュ: E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855

このように、非同期I/Oと組み合わせることで、アプリケーションの応答性を維持しつつ効率的にハッシュ計算が可能です。

パフォーマンスを最大限に引き出すには、TryComputeHashやSpan<T>を活用したメモリ効率の良い実装、バッファの再利用、そして並列・非同期処理の適切な組み合わせが重要です。

これらを意識することで、大規模なデータ処理や高負荷環境でも安定したパフォーマンスを実現できます。

HMAC-SHA256の応用

HMAC(Hash-based Message Authentication Code)は、メッセージの完全性と認証を保証するために使われる技術で、SHA-256と組み合わせたHMAC-SHA256は広く利用されています。

ここでは、共有キーを用いたメッセージ認証コードの仕組みと、API署名への具体的な応用例を解説します。

共有キーとメッセージ認証コード

HMACは、送信者と受信者が事前に共有している秘密鍵(共有キー)を使い、メッセージのハッシュ値を計算します。

これにより、メッセージが改ざんされていないことと、送信者が正当な相手であることを検証できます。

HMACの計算は以下のような流れです。

共有キーを適切な長さに調整(必要に応じてハッシュ化やパディング)
共有キーとメッセージを組み合わせてSHA-256ハッシュを計算
得られたハッシュ値がメッセージ認証コード(MAC)となる

このMACはメッセージと一緒に送信され、受信側は同じ共有キーを使ってMACを再計算し、一致すればメッセージの整合性と認証が確認できます。

C#ではSystem.Security.Cryptography.HMACSHA256クラスを使って簡単にHMACを計算できます。

using System;
using System.Security.Cryptography;
using System.Text;
class Program
{
    static void Main()
    {
        string message = "重要なメッセージ";
        string key = "共有秘密鍵";
        byte[] keyBytes = Encoding.UTF8.GetBytes(key);
        byte[] messageBytes = Encoding.UTF8.GetBytes(message);
        using (var hmac = new HMACSHA256(keyBytes))
        {
            byte[] hashBytes = hmac.ComputeHash(messageBytes);
            Console.WriteLine("メッセージ: " + message);
            Console.WriteLine("HMAC-SHA256: " + BitConverter.ToString(hashBytes).Replace("-", "").ToLower());
        }
    }
}

メッセージ: 重要なメッセージ
HMAC-SHA256: f0b6a49259723e532745815140e2e8f737ce8b85a7c7b57511abc29a14b2d154

この例では、共有キーとメッセージをUTF-8でバイト配列に変換し、HMACSHA256でMACを計算しています。

HMACは単なるハッシュとは異なり、秘密鍵を使うため、第三者がメッセージを改ざんしても正しいMACを生成できません。

API署名への展開例

HMAC-SHA256はAPIのリクエスト認証にもよく使われます。

APIクライアントはリクエストの内容(パラメータやボディ)を共有キーでHMAC計算し、その署名をHTTPヘッダーなどに付加します。

サーバー側は同じ共有キーで署名を再計算し、一致すればリクエストの正当性を検証します。

以下は簡単なAPI署名の例です。

using System;
using System.Security.Cryptography;
using System.Text;
class ApiSigner
{
    private readonly byte[] secretKey;
    public ApiSigner(string key)
    {
        secretKey = Encoding.UTF8.GetBytes(key);
    }
    public string CreateSignature(string httpMethod, string requestPath, string timestamp, string body)
    {
        string message = $"{httpMethod}\n{requestPath}\n{timestamp}\n{body}";
        byte[] messageBytes = Encoding.UTF8.GetBytes(message);
        using (var hmac = new HMACSHA256(secretKey))
        {
            byte[] hashBytes = hmac.ComputeHash(messageBytes);
            return Convert.ToBase64String(hashBytes);
        }
    }
}
class Program
{
    static void Main()
    {
        string secretKey = "API共有秘密鍵";
        var signer = new ApiSigner(secretKey);
        string httpMethod = "POST";
        string requestPath = "/api/v1/orders";
        string timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
        string body = "{\"orderId\":12345,\"amount\":1000}";
        string signature = signer.CreateSignature(httpMethod, requestPath, timestamp, body);
        Console.WriteLine("署名: " + signature);
    }
}

署名: me55v3cduoOwW6bLSFXQnziQtGjWUReI8aAZj7xhZ7M=

この例では、HTTPメソッド、リクエストパス、タイムスタンプ、リクエストボディを改行で連結し、それをHMAC-SHA256で署名しています。

サーバーは同じロジックで署名を再計算し、クライアントから送られた署名と比較して認証を行います。

API署名にHMAC-SHA256を使うことで、リクエストの改ざん防止やなりすまし防止が可能となり、安全な通信を実現できます。

よくある落とし穴

SHA-256を使ったハッシュ化やパスワード管理の実装では、細かなミスがセキュリティリスクや動作不良につながることがあります。

ここでは特に注意したい代表的な落とし穴を3つ取り上げ、それぞれの問題点と対策を解説します。

エンコーディングの不一致

文字列をバイト列に変換する際のエンコーディングが異なると、同じ文字列でも異なるバイト配列となり、結果として異なるハッシュ値が生成されます。

例えば、UTF-8とUTF-16(Unicode)でエンコードした場合、バイト列が大きく変わるため、ハッシュ値も全く異なります。

この問題は、ハッシュ化と検証の両方で同じエンコーディングを使わないと発生します。

特に以下のようなケースで注意が必要です。

ハッシュ化時はUTF-8、検証時はUTF-16でバイト変換してしまう
外部システムやAPIから受け取る文字列のエンコーディングが不明確
文字列の前後に不要な空白や改行が混入している

対策としては、必ずハッシュ化と比較の両方で同じエンコーディング(一般的にはUTF-8)を使い、入力文字列のトリムや正規化も行うことが重要です。

// 正しい例：UTF-8で統一
byte[] bytes = Encoding.UTF8.GetBytes(inputString);

ソルトを付与し忘れるミス

パスワードのハッシュ化において、ソルトを付与しないままSHA-256だけでハッシュ化してしまうケースは非常に多い落とし穴です。

ソルトなしでは、同じパスワードは常に同じハッシュ値となり、レインボーテーブル攻撃やパスワードの共通利用が容易に判明してしまいます。

また、ソルトを生成してもハッシュ化の際に正しく結合しなかったり、保存時にソルトを記録し忘れるミスもあります。

これらは認証時に正しいハッシュ値が再現できず、ログイン失敗やセキュリティホールにつながります。

必ず以下のポイントを守りましょう。

ユーザーごとにランダムなソルトを生成する
パスワードとソルトを結合してからハッシュ化する(例：hash = SHA256(password + salt))
ソルトはハッシュ値とセットで安全に保存し、認証時に必ず同じソルトを使う

// ソルトとパスワードを結合してハッシュ化
byte[] passwordBytes = Encoding.UTF8.GetBytes(password);
byte[] combined = new byte[passwordBytes.Length + salt.Length];
Buffer.BlockCopy(passwordBytes, 0, combined, 0, passwordBytes.Length);
Buffer.BlockCopy(salt, 0, combined, passwordBytes.Length, salt.Length);
byte[] hash = sha256.ComputeHash(combined);

ハッシュ値の大文字・小文字混在

ハッシュ値を16進数文字列に変換する際、大文字と小文字の混在が原因で比較が失敗することがあります。

例えば、"9E4095..."と"9e4095..."は見た目は同じですが、文字列比較では異なるものとして扱われます。

この問題は、ハッシュ値を保存・比較する際に大文字・小文字の統一がされていない場合に起こります。

特にデータベースや外部システム間でのやり取りで注意が必要です。

対策としては、ハッシュ値の文字列化時に大文字か小文字のどちらかに統一し、比較時も同様に扱うことです。

一般的には小文字に統一するケースが多いです。

// 小文字で統一して16進数文字列を生成
StringBuilder sb = new StringBuilder();
foreach (byte b in hashBytes)
{
    sb.AppendFormat("{0:x2}", b); // 小文字の16進数
}
string hashString = sb.ToString();

また、比較時に大文字・小文字を区別しない比較を行う方法もありますが、文字列の正規化が確実な方法です。

これらの落とし穴は一見些細に思えますが、実際の運用では認証失敗やセキュリティリスクにつながるため、実装時に十分注意してください。

特にエンコーディングの統一とソルトの適切な利用は基本中の基本です。

テストと検証のポイント

SHA-256を用いたハッシュ化処理を実装した際には、正確かつ安全に動作していることを確認するためのテストと検証が欠かせません。

ここでは、ハッシュ値の正当性を確認するための既知値との比較テストと、異常系の動作を適切にハンドリングするポイントについて解説します。

既知値との比較テスト

既知値との比較テストは、ハッシュ関数の実装が正しく動作しているかを検証する基本的な方法です。

具体的には、入力文字列に対して事前に計算された正しいSHA-256ハッシュ値(既知値)と、実装したコードで生成したハッシュ値を比較します。

このテストを行うことで、エンコーディングの不一致やバイト配列の変換ミス、ハッシュ計算の誤りを早期に発見できます。

以下はC#での既知値比較テストの例です。

using System;
using System.Security.Cryptography;
using System.Text;
class Program
{
    static void Main()
    {
        string input = "TestString";
        string expectedHash = "6dd79f2770a0bb38073b814a5ff000647b37be5abbde71ec9176c6ce0cb32a27";
        byte[] inputBytes = Encoding.UTF8.GetBytes(input);
        using (SHA256 sha256 = SHA256.Create())
        {
            byte[] hashBytes = sha256.ComputeHash(inputBytes);
            StringBuilder sb = new StringBuilder();
            foreach (byte b in hashBytes)
            {
                sb.AppendFormat("{0:x2}", b);
            }
            string actualHash = sb.ToString();
            Console.WriteLine("入力文字列: " + input);
            Console.WriteLine("期待されるハッシュ: " + expectedHash);
            Console.WriteLine("実際のハッシュ: " + actualHash);
            Console.WriteLine("一致: " + (actualHash == expectedHash));
        }
    }
}

入力文字列: TestString
期待されるハッシュ: 6dd79f2770a0bb38073b814a5ff000647b37be5abbde71ec9176c6ce0cb32a27
実際のハッシュ: 6dd79f2770a0bb38073b814a5ff000647b37be5abbde71ec9176c6ce0cb32a27
一致: True

このように、既知の正しいハッシュ値と一致すれば、実装が正しいことが確認できます。

なお、既知値は信頼できる公式ドキュメントやツールで生成したものを使うことが望ましいです。

異常系動作のハンドリング

ハッシュ化処理では、入力データの不正やシステムの異常により例外が発生する可能性があります。

これらの異常系を適切にハンドリングし、システムの安定性とセキュリティを保つことが重要です。

主な異常系と対策例は以下の通りです。

nullや空文字列の入力

入力がnullや空文字列の場合、Encoding.UTF8.GetBytesで例外が発生することは少ないですが、意味のあるハッシュ値を生成できないため、事前にチェックして適切に処理します。

非常に大きなデータの処理

メモリ不足やタイムアウトのリスクがあるため、ストリーム処理や分割処理を検討します。

ハッシュ計算中の例外

例えば、SHA256.Create()が失敗するケースは稀ですが、例外処理を入れてログ記録やリトライを行う設計が望ましいです。

以下は異常系を考慮した例外処理のサンプルです。

using System;
using System.Security.Cryptography;
using System.Text;
class Program
{
    static void Main()
    {
        string input = null;
        try
        {
            if (string.IsNullOrEmpty(input))
            {
                Console.WriteLine("入力がnullまたは空文字列です。処理を中止します。");
                return;
            }
            byte[] inputBytes = Encoding.UTF8.GetBytes(input);
            using (SHA256 sha256 = SHA256.Create())
            {
                byte[] hashBytes = sha256.ComputeHash(inputBytes);
                StringBuilder sb = new StringBuilder();
                foreach (byte b in hashBytes)
                {
                    sb.AppendFormat("{0:x2}", b);
                }
                Console.WriteLine("ハッシュ値: " + sb.ToString());
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("ハッシュ計算中にエラーが発生しました: " + ex.Message);
            // 必要に応じてログ出力やリトライ処理を実装
        }
    }
}

このように、異常系を想定して適切に処理することで、予期せぬクラッシュやセキュリティ上の問題を防げます。

テストと検証は安全なハッシュ化の基盤です。

既知値との比較で正確性を確認し、異常系のハンドリングで堅牢な実装を目指しましょう。

まとめ

この記事では、C#でSHA-256を使った安全なハッシュ化の基本から応用までを解説しました。

文字列のエンコーディングやソルトの重要性、固定時間比較によるタイミング攻撃対策、高計算コストハッシュとの違い、パフォーマンス最適化のポイント、さらにHMAC-SHA256を用いたAPI署名の実装例も紹介しています。

これらを理解し実践することで、堅牢で効率的なセキュリティ対策が可能になります。

参考文献