Go crypto/sha1.New 怎样把分块输入累计成摘要

如果输入不是一次性完整拿到，而是来自文件、网络响应或多个业务分片，sha1.New() 的正确用法是只创建一个 hash.Hash，让所有分块按顺序写入，再在需要时调用 Sum(nil) 取出当前摘要。Write 会继续累积状态，Sum 只读取快照，不会清空它；输入切换到下一条独立消息时，才调用 Reset。

官方地址：https://pkg.go.dev/crypto/sha1#New

记住一句话：同一条消息的分块共享一个 sha1.New() 实例；Sum 是取结果，不是结算；Reset 才是开始下一条消息。SHA-1 已不适合新的安全应用。

先分清 sha1.New、Write 和 Sum 的职责

sha1.New() 返回的是 hash.Hash 接口。它提供 Write、Sum、Reset、Size 和 BlockSize 等能力，调用方不需要也不能直接操作内部摘要状态。

当前标准库文档给出的两个关键常量是：sha1.Size 为 20，表示 Sum 追加的摘要长度；sha1.BlockSize 为 64，表示底层算法的块大小。块大小不是“每次 Write 必须传入的长度”，小块、大块和不整齐的分块都可以写入。

hash.Hash.Sum(b) 的语义是把当前摘要追加到 b 后返回结果；它不会改变底层哈希状态。因此，读取摘要不等于结束输入，后面仍可以继续 Write。

把多个分块写入同一个哈希状态

流式摘要最容易犯的错误，是在循环里对每个分块重新调用 sha1.New()。那样得到的是多份独立摘要，而不是整条消息的摘要。正确做法是把实例放在循环外，让分块按原始顺序进入同一状态。

package main

import (
	"crypto/sha1"
	"fmt"
)

func main() {
	// 一个实例代表一条消息，循环中的所有分块都必须写入它。
	h := sha1.New()
	chunks := [][]byte{
		[]byte("header:"),
		[]byte("part-a|"),
		[]byte("part-b"),
	}

	for i, chunk := range chunks {
		// hash.Hash 的 Write 按接口返回 n 和 error；保留检查便于替换为其他 Writer。
		written, err := h.Write(chunk)
		if err != nil {
			panic(fmt.Errorf("写入第 %d 个分块失败: %w", i+1, err))
		}
		if written != len(chunk) {
			// 对摘要输入而言，短写意味着消息没有完整进入哈希状态。
			panic(fmt.Errorf("第 %d 个分块写入不完整: got %d, want %d", i+1, written, len(chunk)))
		}
	}

	// Sum(nil) 取出当前摘要；它不会清空 h，后续仍可继续 Write。
	digest := h.Sum(nil)
	fmt.Printf("摘要长度: %d 字节\\n摘要: %x\\n", len(digest), digest)
}

这里的 Write 次序就是摘要输入次序。即使某个分块来自网络读取，也不要把“收到的顺序”交给多个哈希实例分别处理；应该先由上层明确消息顺序，再持续写入同一个 hash.Hash。

用 Sum 读取当前摘要而不破坏状态

Sum(nil) 是最直观的取值方式，但 Sum 还接受一个前缀切片。它会把摘要追加到前缀后面，所以 h.Sum(prefix) 的返回值可能复用 prefix 的底层数组；如果调用方还要保留原始前缀，应按自己的所有权规则分配容量或复制结果。

更重要的是，Sum 不会把 h 变成“已关闭”状态。下面的代码先取一次中间摘要，再写入尾部数据，第二次取到的是完整消息摘要。

package main

import (
	"crypto/sha1"
	"fmt"
)

func main() {
	h := sha1.New()
	_, _ = h.Write([]byte("header|"))

	// prefix 只是输出容器；Sum 会在它后面追加当前摘要。
	prefix := []byte("sha1=")
	checkpoint := h.Sum(prefix)
	fmt.Printf("中间结果: %x\\n", checkpoint)

	// 读取中间结果没有清空 h，所以尾部数据仍会接在 header| 后面。
	_, _ = h.Write([]byte("body"))
	finalDigest := h.Sum(nil)
	fmt.Printf("完整摘要: %x\\n", finalDigest)
}

如果只想判断当前摘要是否等于某个已知值，可以把 Sum(nil) 的结果拿到外层比较；不要把“调用了 Sum”误认为已经完成了哈希生命周期。需要保留多个检查点时，也可以分别复制返回的字节切片，避免后续业务修改同一底层数组。

用 Reset 划分下一条独立消息

当一条消息结束、同一个处理器准备继续处理下一条消息时，调用 Reset() 把哈希恢复到初始状态。若遗漏这一步，下一条消息会接在旧消息后面，得到的是两条消息拼接后的摘要。

package main

import (
	"crypto/sha1"
	"fmt"
)

func digestMessage(h interface {
	Write([]byte) (int, error)
	Sum([]byte) []byte
	Reset()
}, message string) []byte {
	// 调用方在进入函数前保证 h 已经处于本条消息的起点。
	if _, err := h.Write([]byte(message)); err != nil {
		panic(fmt.Errorf("写入消息失败: %w", err))
	}
	return h.Sum(nil)
}

func main() {
	h := sha1.New()

	first := digestMessage(h, "第一条消息")
	// Reset 明确切断两条消息的输入关系。
	h.Reset()
	second := digestMessage(h, "第二条消息")

	fmt.Printf("第一条: %x\\n第二条: %x\\n", first, second)
}

生产代码也可以为每条消息直接创建新的 sha1.New()，这样生命周期更直观；只有在对象需要复用、或上层已经把哈希作为依赖注入时，才适合显式调用 Reset。无论选哪种方式，边界都应由调用方明确表达。

在安全边界内选择 SHA-1

Go 官方文档明确提醒：SHA-1 在密码学上已经被攻破，不应把它用于新的安全应用。因此，这篇文章讨论的“分块累计”只说明 API 的输入模型，不代表 SHA-1 适合签名校验、密码存储、认证令牌或新的完整性安全设计。

如果需求只是兼容已有协议、读取历史文件格式或生成非安全场景的稳定摘要，可以按旧系统约束使用；如果是新系统的安全摘要，应改用 crypto/sha256 或其他符合需求的现代算法，并重新确认输出长度、密钥化方式和对手模型。

常见问题

每个分块都调用一次 sha1.Sum 可以吗？

可以得到每个分块各自的摘要，但那不等于整条消息的摘要。要计算拼接后消息的摘要，应把分块顺序写入同一个 hash.Hash。

调用 Sum 后还可以继续 Write 吗？

可以。Sum 不改变底层状态，后续 Write 会继续在已有输入之后累计。

Sum(prefix) 会修改 prefix 吗？

它会返回“前缀加摘要”的切片，并可能复用前缀的底层数组。若后续代码依赖前缀保持不变，应给前缀留出合适的所有权边界，或在需要时复制结果。

Reset 后能不能继续使用同一个 hash.Hash？

可以。Reset 把实例恢复到初始状态，之后的 Write 会从下一条独立消息开始累计。

小结

sha1.New() 返回的 hash.Hash 适合接收连续分块：把同一条消息的所有片段按顺序 Write 到同一个实例，使用 Sum 读取当前 20 字节摘要，结束后用 Reset 或新建实例隔离下一条消息。Sum 是快照，Reset 才是边界；而 SHA-1 的安全限制必须在新系统设计时优先考虑。