255 lines
7.1 KiB
Go
255 lines
7.1 KiB
Go
package sha256x_test
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"code.yun.ink/pkg/encryptx/sha256x"
|
|
)
|
|
|
|
// 测试向量来源：FIPS 180-4 示例与 NIST 标准测试向量，并经 Python 3 hashlib 独立复算确认。
|
|
var vectors224 = []struct {
|
|
name string
|
|
input string
|
|
want string
|
|
}{
|
|
{"空串", "", "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"},
|
|
{"abc", "abc", "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7"},
|
|
}
|
|
|
|
var vectors256 = []struct {
|
|
name string
|
|
input string
|
|
want string
|
|
}{
|
|
{"空串", "", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
|
|
{"abc", "abc", "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"},
|
|
{"The quick brown fox jumps over the lazy dog", "The quick brown fox jumps over the lazy dog", "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592"},
|
|
}
|
|
|
|
type failingReader struct{}
|
|
|
|
func (failingReader) Read([]byte) (int, error) { return 0, errors.New("模拟读取失败") }
|
|
|
|
func TestConstants(t *testing.T) {
|
|
if sha256x.Size224 != 28 || sha256x.Size256 != 32 {
|
|
t.Fatalf("Size224 = %d, Size256 = %d, 期望 28 / 32", sha256x.Size224, sha256x.Size256)
|
|
}
|
|
if sha256x.BlockSize != 64 {
|
|
t.Fatalf("BlockSize = %d, 期望 64", sha256x.BlockSize)
|
|
}
|
|
}
|
|
|
|
func TestVectors224(t *testing.T) {
|
|
for _, v := range vectors224 {
|
|
t.Run(v.name, func(t *testing.T) {
|
|
data := []byte(v.input)
|
|
sum := sha256x.Sum224(data)
|
|
if len(sum) != sha256x.Size224 {
|
|
t.Fatalf("Sum224 长度 = %d, 期望 %d", len(sum), sha256x.Size224)
|
|
}
|
|
if got := hex.EncodeToString(sum); got != v.want {
|
|
t.Errorf("Sum224 = %s, 期望 %s", got, v.want)
|
|
}
|
|
if got := sha256x.Hex224(data); got != v.want {
|
|
t.Errorf("Hex224 = %s, 期望 %s", got, v.want)
|
|
}
|
|
if want := base64.StdEncoding.EncodeToString(sum); sha256x.Base64Sum224(data) != want {
|
|
t.Errorf("Base64Sum224 = %s, 期望 %s", sha256x.Base64Sum224(data), want)
|
|
}
|
|
h := sha256x.New224()
|
|
if _, err := h.Write(data); err != nil {
|
|
t.Fatalf("Write 失败: %v", err)
|
|
}
|
|
if got := hex.EncodeToString(h.Sum(nil)); got != v.want {
|
|
t.Errorf("New224+Write = %s, 期望 %s", got, v.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestVectors256(t *testing.T) {
|
|
for _, v := range vectors256 {
|
|
t.Run(v.name, func(t *testing.T) {
|
|
data := []byte(v.input)
|
|
sum := sha256x.Sum256(data)
|
|
if len(sum) != sha256x.Size256 {
|
|
t.Fatalf("Sum256 长度 = %d, 期望 %d", len(sum), sha256x.Size256)
|
|
}
|
|
if got := hex.EncodeToString(sum); got != v.want {
|
|
t.Errorf("Sum256 = %s, 期望 %s", got, v.want)
|
|
}
|
|
if got := sha256x.Hex256(data); got != v.want {
|
|
t.Errorf("Hex256 = %s, 期望 %s", got, v.want)
|
|
}
|
|
if want := base64.StdEncoding.EncodeToString(sum); sha256x.Base64Sum256(data) != want {
|
|
t.Errorf("Base64Sum256 = %s, 期望 %s", sha256x.Base64Sum256(data), want)
|
|
}
|
|
h := sha256x.New256()
|
|
if _, err := h.Write(data); err != nil {
|
|
t.Fatalf("Write 失败: %v", err)
|
|
}
|
|
if got := hex.EncodeToString(h.Sum(nil)); got != v.want {
|
|
t.Errorf("New256+Write = %s, 期望 %s", got, v.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDefaultAliasesMatch256(t *testing.T) {
|
|
data := []byte("encryptx alias check")
|
|
if !bytes.Equal(sha256x.Sum(data), sha256x.Sum256(data)) {
|
|
t.Error("Sum 应等价于 Sum256")
|
|
}
|
|
if sha256x.Hex(data) != sha256x.Hex256(data) {
|
|
t.Error("Hex 应等价于 Hex256")
|
|
}
|
|
if sha256x.Base64(data) != sha256x.Base64Sum256(data) {
|
|
t.Error("Base64 应等价于 Base64Sum256")
|
|
}
|
|
h := sha256x.New()
|
|
if h.Size() != sha256x.Size256 {
|
|
t.Errorf("New().Size() = %d, 期望 %d", h.Size(), sha256x.Size256)
|
|
}
|
|
}
|
|
|
|
func TestVariantsDiffer(t *testing.T) {
|
|
data := []byte("abc")
|
|
if sha256x.Hex224(data) == sha256x.Hex256(data) {
|
|
t.Error("SHA-224 与 SHA-256 的摘要不应相同")
|
|
}
|
|
}
|
|
|
|
func TestStreamingMatchesSum(t *testing.T) {
|
|
data := []byte(strings.Repeat("encryptx-sha256-", 100))
|
|
for _, tc := range []struct {
|
|
name string
|
|
h hashLike
|
|
whole []byte
|
|
}{
|
|
{"SHA-224", sha256x.New224(), sha256x.Sum224(data)},
|
|
{"SHA-256", sha256x.New256(), sha256x.Sum256(data)},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
for i := 0; i < len(data); i += 9 {
|
|
end := i + 9
|
|
if end > len(data) {
|
|
end = len(data)
|
|
}
|
|
if _, err := tc.h.Write(data[i:end]); err != nil {
|
|
t.Fatalf("Write 失败: %v", err)
|
|
}
|
|
}
|
|
if sum := tc.h.Sum(nil); !bytes.Equal(sum, tc.whole) {
|
|
t.Errorf("分块写入 = %x, 期望 %x", sum, tc.whole)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// hashLike 是测试用的最小哈希接口。
|
|
type hashLike interface {
|
|
Write([]byte) (int, error)
|
|
Sum([]byte) []byte
|
|
}
|
|
|
|
func TestReaderConsistency(t *testing.T) {
|
|
const s = "encryptx 一致性检查"
|
|
sum, err := sha256x.SumReader(strings.NewReader(s))
|
|
if err != nil {
|
|
t.Fatalf("SumReader 失败: %v", err)
|
|
}
|
|
if want := sha256x.Sum256([]byte(s)); !bytes.Equal(sum, want) {
|
|
t.Errorf("SumReader = %x, 期望 %x", sum, want)
|
|
}
|
|
hexStr, err := sha256x.HexReader(strings.NewReader(s))
|
|
if err != nil {
|
|
t.Fatalf("HexReader 失败: %v", err)
|
|
}
|
|
if want := sha256x.Hex256([]byte(s)); hexStr != want {
|
|
t.Errorf("HexReader = %s, 期望 %s", hexStr, want)
|
|
}
|
|
}
|
|
|
|
func TestReaderErrors(t *testing.T) {
|
|
if _, err := sha256x.SumReader(nil); err == nil {
|
|
t.Fatal("nil 读取器应返回 error")
|
|
}
|
|
if _, err := sha256x.HexReader(nil); err == nil {
|
|
t.Fatal("nil 读取器应返回 error")
|
|
}
|
|
if _, err := sha256x.SumReader(failingReader{}); err == nil {
|
|
t.Fatal("读取失败时应返回 error")
|
|
}
|
|
}
|
|
|
|
func TestHexFile(t *testing.T) {
|
|
dir := t.TempDir()
|
|
content := []byte("文件内容 file content\n")
|
|
path := filepath.Join(dir, "sample.bin")
|
|
if err := os.WriteFile(path, content, 0o600); err != nil {
|
|
t.Fatalf("写入测试文件失败: %v", err)
|
|
}
|
|
got, err := sha256x.HexFile(path)
|
|
if err != nil {
|
|
t.Fatalf("HexFile 失败: %v", err)
|
|
}
|
|
if want := sha256x.Hex256(content); got != want {
|
|
t.Errorf("HexFile = %s, 期望 %s", got, want)
|
|
}
|
|
}
|
|
|
|
func TestHexFileErrors(t *testing.T) {
|
|
if _, err := sha256x.HexFile(filepath.Join(t.TempDir(), "不存在.bin")); err == nil {
|
|
t.Fatal("不存在的文件应返回 error")
|
|
}
|
|
if _, err := sha256x.HexFile(""); err == nil {
|
|
t.Fatal("空路径应返回 error")
|
|
}
|
|
if _, err := sha256x.HexFile(t.TempDir()); err == nil {
|
|
t.Fatal("目录路径应返回 error")
|
|
}
|
|
}
|
|
|
|
func TestLargeInput(t *testing.T) {
|
|
data := largeData(1 << 20)
|
|
want := sha256x.Hex256(data)
|
|
if got := sha256x.Hex256(data); got != want {
|
|
t.Errorf("重复计算结果不一致: %s vs %s", got, want)
|
|
}
|
|
|
|
got, err := sha256x.HexReader(bytes.NewReader(data))
|
|
if err != nil {
|
|
t.Fatalf("HexReader 失败: %v", err)
|
|
}
|
|
if got != want {
|
|
t.Errorf("HexReader = %s, 期望 %s", got, want)
|
|
}
|
|
|
|
h := sha256x.New256()
|
|
if _, err := h.Write(data[:1<<19]); err != nil {
|
|
t.Fatalf("Write 失败: %v", err)
|
|
}
|
|
if _, err := h.Write(data[1<<19:]); err != nil {
|
|
t.Fatalf("Write 失败: %v", err)
|
|
}
|
|
if got := hex.EncodeToString(h.Sum(nil)); got != want {
|
|
t.Errorf("1MiB 分块 = %s, 期望 %s", got, want)
|
|
}
|
|
}
|
|
|
|
// largeData 生成确定性的 n 字节数据。
|
|
func largeData(n int) []byte {
|
|
b := make([]byte, n)
|
|
for i := range b {
|
|
b[i] = byte(i*31 + i/7)
|
|
}
|
|
return b
|
|
}
|