从官网下载一个系统镜像,页面上写着 SHA256 是 d7a8fbb3...,本地算出来却是另一串字符。文件能打开,安装也能跑,但校验值就是不对。有人觉得“能用就行”,有人坚持重下。到底该信谁?再比如,一个 zip 解压到一半报“CRC 错误”,是压缩包坏了、硬盘坏了,还是内存坏了?这两个场景,背后是同一类问题:怎么用一小段额外的信息,判断一大段数据有没有被改过。

这篇从奇偶校验讲起,经过简单校验和、CRC,最后到 SHA-256 这类密码学哈希。重点不是记算法,而是弄明白每种手段能发现什么错、发现不了什么错,以及在真实系统里该选哪一种。

现象:校验值对不上,文件到底坏没坏

校验值(checksum)可以理解成数据的“指纹”。发送方和接收方用同一套算法算一遍,如果结果一致,就认为数据大概率没变。注意这里说的是“大概率”,不是“绝对”。不同算法的保证强度不同:奇偶校验只能发现奇数个位翻转,简单求和连两位同时变化都可能漏掉,CRC 对突发错误很强,SHA-256 则强到可以对抗刻意构造的碰撞。

下载场景里,校验值对不上通常有三种原因。第一,传输过程中真的坏了,比如网络丢包、代理篡改、下载中断;第二,你算的不是同一个文件,比如下到了旧版本、被重定向到了镜像站、或者文件被解压过;第三,算法或格式不一致,官网给的是 SHA-256,你算的是 MD5,或者复制哈希值时漏了字符、混入了空格。排查时先确认算法和文件,再怀疑数据损坏。顺序很重要,因为前两种原因占的比例远高于真正的位翻转,先按这个顺序排除,再动手查硬件、内存和驱动,能少走很多弯路,也不容易把软件问题误判成硬件故障,这一点很关键,别急着换硬件,先做软件层面的排除。

压缩包的 CRC 错误更直接。zip、gzip、xz 这些格式在压缩数据块里存了 CRC32,解压时边解边算,对不上就报错。它说明这个数据块的字节在写入或传输时出了问题,可能来自坏盘、坏内存、下载不完整,也可能来自压缩软件本身的 bug。CRC 只覆盖数据块,不覆盖整个文件结构,所以“某个文件报错、其他文件正常”很常见,不能据此断定整块硬盘坏了。

断点续传和多线程下载也会制造“看起来完整、其实拼错”的文件。下载器把文件分成几段并发拉取,如果某一段的响应被代理缓存了旧版本,或者合并时偏移算错,最终文件的长度可能和原文件一样,内容却在中间错了一段。只看文件大小发现不了,只有逐字节比对或哈希才能暴露。遇到“能打开但校验不对”,先怀疑分段合并,再怀疑磁盘。

场景走查:从一位奇偶到一段哈希

最原始的校验是奇偶校验(parity)。发送方在数据后面加一位,让整个字节或整段数据里 1 的个数保持奇数(奇校验)或偶数(偶校验)。接收方数一遍,如果奇偶性不对,就知道出错了。它只需要一位,硬件成本几乎为零,串口通信里常见 8N1、8E1 这样的配置,N 表示无校验,E 表示偶校验,O 表示奇校验。

奇偶校验的局限很明显:它能发现奇数个位翻转,发现不了偶数个。两个位同时翻转,1 的个数变化是 0 或 2,奇偶性不变,校验就通过了。它也不知道哪一位错了,只能要求重传。所以它适合“错误很少、重传便宜”的场景,不适合“错了就完蛋”的场景。

简单校验和(checksum)把数据按字节或按字相加,取低若干位作为结果。它比一位奇偶强一些,能发现更多组合,但仍有结构性弱点:两个字节一增一减、总和不变,就检测不到;数据块顺序调换,总和也可能不变。TCP/IP 的头部校验和、UDP 校验和都属于这一类,它们追求的是计算快、硬件实现简单,不是强对抗。

CRC(循环冗余校验,Cyclic Redundancy Check)把数据看成一个多项式,用一个固定的生成多项式去除,取余数作为校验值。它在数学上比简单求和严谨,能检测出一定长度内的所有突发错误,也能检测大部分随机错误。CRC32 是常见变体,以太网帧、zip、gzip、PNG 都用它。它的计算可以用移位和异或实现,硬件里一条指令就能算,速度非常快。

CRC 不是只有一种。不同的生成多项式、初值、输入是否反转、输出是否异或,组合出很多变体,常见的有 CRC32、CRC32C、CRC16-IBM、CRC16-CCITT 等。两个系统都用“CRC32”,如果参数不一样,同一个数据算出的结果就不同。对接协议时,文档要写明多项式、初值、反射和异或值,不能只写一个名字。以太网帧尾的 FCS 用的是 CRC32,但它的参数和 zip 里的 CRC32 也不完全一样。

密码学哈希(cryptographic hash)是另一条路线。SHA-256 把任意长度的输入压成 256 位输出,要求“从输出反推输入”在计算上不可行,要求“找到两个不同输入得到同一输出”也很难。它不追求“检测某几位翻转”,而是追求“任何改动都会让输出面目全非”,这叫雪崩效应。改一个字节,输出的 256 位大约有一半会变,完全看不出规律。

奇偶校验加 1 位,保证 1 的个数为奇或为偶。只能发现奇数个位翻转,不能定位。
简单校验和按字节或字相加取低位。快,但存在“一增一减”和重排的盲区。
CRC多项式除法取余,擅长发现突发错误。硬件便宜,广泛用于存储和网络帧。
密码学哈希SHA-256 等,抗碰撞、抗反推。用于完整性验证、签名和内容寻址。

CRC 和哈希到底强在哪

CRC 的强项是“突发错误”。假设一段数据连续几个字节被破坏,CRC 的生成多项式能把这段错误映射成一个非零余数,只要突发长度不超过多项式阶数,就一定能发现。它也能发现所有单比特、双比特错误,以及奇数个错误。这些性质有数学证明,不是经验之谈。但它不是密码学安全的:攻击者可以构造两段不同数据,让它们的 CRC32 相同,所以不能用 CRC 防篡改。

哈希的强项是“雪崩”和“抗碰撞”。SHA-256 的输出有 256 位,暴力找碰撞的难度约为 2 的 128 次方(生日攻击),目前认为不可行。它把输入分成块,经过多轮位运算、模加、消息扩展,每一轮都把上一轮的状态打散。输入改一位,后续所有轮的状态都会变,最终输出完全不同。这种设计让它既能做文件校验,也能做数字签名、证书、内容寻址。

但“哈希值一致”只说明字节一致,不说明内容安全。一个文件可以哈希值正确但内容恶意,只要发布者给的哈希本身就是恶意的。哈希保证的是“你拿到的和我算的是同一段字节”,不是“这段字节是好的”。要防篡改,需要签名或可信渠道;要防下载被替换,需要 HTTPS 和证书体系。校验值是完整性工具,不是信任工具。

哈希还有一类使用陷阱,叫长度扩展。SHA-256 用的是 Merkle-Damgard 结构,如果直接把它当“密钥加消息”的认证码用,攻击者可以在不知道密钥的情况下,把已知消息延长,算出新的合法哈希。正确做法是用 HMAC,把密钥用两层哈希包起来。这个细节和文件校验关系不大,但一旦把哈希用于接口签名、令牌校验,就必须注意。不要自己拼“密钥加数据再哈希”的方案。

实测:同一个字符串,三种指纹

用 Python 对字符串 abc 分别算 MD5、SHA-1、SHA-256 和 CRC32,输出都是本机 3.15 实跑的结果:

import hashlib, zlib

data = b'abc'
print(hashlib.md5(data).hexdigest())
print(hashlib.sha1(data).hexdigest())
print(hashlib.sha256(data).hexdigest())
print(zlib.crc32(data))
print(format(zlib.crc32(data), '08x'))

实际输出:

900150983cd24fb0d6963f7d28e17f72
a9993e364706816aba3e25717850c26c9cd0d89d
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
891568578
352441c2

同一段数据,MD5 出 32 个十六进制字符,SHA-1 出 40 个,SHA-256 出 64 个。位数不同,抗碰撞强度也不同。CRC32 的结果是一个 32 位整数,本机十进制是 891568578,十六进制是 352441c2。CRC 的输出短,适合塞进数据帧;哈希的输出长,适合做全局标识。

再验证“改一个字节,指纹全变”。取一句英文,末尾加一个句号,分别算 SHA-256:

a = b'The quick brown fox jumps over the lazy dog'
b = a + b'.'
print(hashlib.sha256(a).hexdigest())
print(hashlib.sha256(b).hexdigest())
print(zlib.crc32(a), zlib.crc32(b))

实际输出:第一行 d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592,第二行 ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c,CRC32 分别是 1095738169 和 1368401385。只多了一个句号,两个哈希值从头到尾都不一样,CRC 也变了。这就是雪崩效应:改动再小,输出也看不出关联。

现象对照表

现象真实原因第一步查什么
下载后 SHA256 和官网不一致传输损坏、下载不完整,或文件根本不是同一个版本核对文件名、大小、来源,再重新下载并对比官方值
zip 解压报 CRC 错误压缩块的数据字节损坏,或下载不完整换一个源重新下载,再检查磁盘和内存
串口偶尔出现一个错字没有校验位,或校验方式、波特率和对方不匹配核对 8N1、8E1 等串口参数和线缆质量
两个字节同时变化,校验却通过简单求和对“一增一减”不敏感换 CRC 或哈希,别用求和做关键校验
两个文件的哈希长度不同用了不同算法,或被截断显示确认算法名称和完整输出,不要只比对前缀
只改一个字节,哈希全变雪崩效应,属于正常现象确认比较的是同一算法、同一编码下的完整值
哈希通过,但文件仍然有问题哈希只保证字节一致,不保证内容正确或安全继续做格式校验、签名验证和来源确认
大文件校验很慢全量读取加算法开销,磁盘本身也慢用流式分块计算,选与安全需求匹配的算法

边界与代价

第一组边界是“检测能力”。奇偶校验只能发现奇数个位翻转;简单校验和存在补偿和重排盲区;CRC32 对短突发很强,但可以被刻意构造碰撞;SHA-256 抗碰撞,但不是加密,不能保密。选算法时要看威胁模型:如果只是防线路噪声,CRC 足够;如果要防恶意篡改,必须用哈希加签名或可信传输。

第二组边界是“哈希不等于签名”。哈希是公开算法,任何人都能对任意文件算出一个值。攻击者如果同时替换文件和页面上的哈希值,你比对通过也没用。签名用私钥生成,公钥验证,攻击者没有私钥就伪造不了;HTTPS 通过证书和密钥交换保护传输,防止中间人替换。校验值要和签名、HTTPS、可信发布渠道一起用,单独一个 SHA-256 只能防意外,防不了蓄意。

第三组边界是“算法寿命”。MD5 已经被证实可以构造碰撞,SHA-1 在 2017 年也被实际攻破,两者都不应该再用于安全场景。它们算得快,仍有人拿来做非安全的去重或缓存键,但这类用途也要注意:如果输入可能来自攻击者,碰撞可能导致缓存污染或越权。新系统一律用 SHA-256 或更强的算法,别为了省一点 CPU 留旧算法。

第四组边界是“覆盖范围”。CRC 通常只覆盖数据块,不覆盖文件头、文件名、元数据;哈希通常覆盖整个文件内容,但不覆盖权限、时间戳、扩展属性。攻击者可以改元数据而不破坏哈希,也可以利用解析器的漏洞,让“哈希正确”的文件在打开时执行恶意内容。完整性校验要明确“校验的是什么”,不能默认它保护了一切。

第五组边界是“实现细节”。哈希计算要分块流式读取,不能把几个 G 的文件一次性读进内存;比较时要比较完整值,不能只比前几位;从网页复制哈希值时,要去掉空格、换行和不可见字符;大小写通常不敏感,但有些工具输出大写,比较前先统一。CRC 还有多种变体,初值、异或输出、位序都可能不同,同一个数据在不同实现下结果不一致,跨系统对接时要确认参数。

最后是性能代价。SHA-256 在有硬件指令的 CPU 上能跑到每秒几个 G,纯软件实现慢一些;CRC32 更便宜,网卡和存储控制器常把它做进硬件。对高吞吐链路,校验会成为瓶颈,所以协议会选择“硬件能加速的算法”,而不是“最强的算法”。安全性和性能要按场景平衡,不是无脑上最贵的。

版本控制系统把哈希用到了极致。Git 的每个对象都用内容哈希命名,文件内容、目录树、提交信息各算一个哈希,对象之间通过哈希引用串成一棵树。好处是内容寻址:同样的文件只存一份,校验和去重一步完成;坏掉的对象一读就能发现,因为重新算的哈希对不上。代价是哈希算法一旦要迁移,整个仓库的对象名都要变,历史上从 SHA-1 迁移到 SHA-256 就花了很长时间。

当天能自己验证的练习

  1. 用 Python 对同一个文件算 MD5、SHA-1、SHA-256,记录长度和耗时;再改一个字节,重新算,确认三个值都变了。
  2. 用 zlib.crc32 和 zlib.adler32 对同一段数据计算,比较结果;再调换两个字节的顺序,看哪个算法更容易发现。
  3. 写一个奇偶校验函数,统计字节里 1 的个数;翻转一位,校验失败;翻转两位,校验通过,亲手验证它的盲区。
  4. 从网上下载一个带官方 SHA256 的文件,本地算一遍并比对。注意从官方页面复制,不要从第三方转载里抄。真实下载链路未在本机实测。
  5. 用 hashlib 分块读取一个大文件计算 SHA-256,比较一次性读入和流式读取的内存占用。Linux 的 sha256sum 命令未在本机实测。

小结与下一篇

校验的本质是用少量冗余信息判断数据有没有变。奇偶校验最便宜,只能发现奇数个位翻转;简单校验和快,但有补偿和重排盲区;CRC 擅长突发错误,广泛用于存储和网络;SHA-256 抗碰撞、雪崩明显,适合完整性验证,但不等于签名,也不等于可信。选型看威胁模型,别拿 CRC 防篡改,也别拿 MD5 做安全。

校验值本身也占空间。一个 256 位的哈希对单个文件不算什么,但对海量小数据、日志、备份,冗余就很可观。数据里还有大量重复和可预测的模式,能不能利用这些模式把体积压小?下一篇讲一段文本为什么能被压到三分之一:压缩的基本原理,看看冗余是怎么被找出来并消掉的。