blocks|key|1864167|text|我认为CRC的大小与您需要的CRC有多独特有关，而不是输入数据的大小。这与计算CRC的特定用途和项目数量有关。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1864168|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I think the size of the CRC has more to do with how unique of a CRC you need instead of of the size of the input data. This is related to the particular usage and number of items on which you're calculating a CRC.

blocks|key|889702|text|这不是个研究课题。这是很好理解的：http://en.wikipedia.org/wiki/Cyclic_redundancy_check|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|889703|数学很简单。8位CRC将所有消息归结为256个值中的一个.如果您的消息长度超过几个字节，则具有相同哈希值的多条消息的可能性越来越高。|889704|类似地，一个16位的CRC为您提供了65,536个可用哈希值中的一个.有这些值之一的任何两条消息的概率是多少？|889705|32位CRC为您提供了大约40亿可用的哈希值.|889706|维基百科的文章中写道：“最大总封锁长度等于2**r+−+1”。是零碎的。你不需要做太多的研究就能看到2**9+-+1是511位。使用CRC-8，超过64个字节的多条消息将具有相同的CRC校验和值。|style|CODE|889707|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Cyclic_redundancy_check^0|H|1G|0|0|0|0|0|L|8|1E|8|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|12|8|@$A|13|B|14|L|M]|$A|15|B|16|L|M]]|9|@]|C|$]]|$1|N|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]]]

It's not a research topic. It's really well understood: <a href="http://en.wikipedia.org/wiki/Cyclic_redundancy_check" rel="noreferrer">http://en.wikipedia.org/wiki/Cyclic_redundancy_check</a>

The math is pretty simple. An 8-bit CRC boils all messages down to one of 256 values. If your message is more than a few bytes long, the possibility of multiple messages having the same hash value goes up higher and higher.

A 16-bit CRC, similarly, gives you one of the 65,536 available hash values. What are the odds of any two messages having one of these values? 

A 32-bit CRC gives you about 4 billion available hash values.

From the wikipedia article: "maximal total blocklength is equal to <code>2**r − 1</code>". That's in bits. You don't need to do much research to see that <code>2**9 - 1</code> is 511 bits. Using CRC-8, multiple messages longer than 64 bytes will have the same CRC checksum value.

blocks|key|886144|text|应该根据消息的长度来选择CRC，这不仅仅是CRC的大小问题：http://www.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|886145|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf^0|U|23|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

The CRC should be chosen specifically for the length of the messages, it is not just a question of the size of the CRC: <a href="http://www.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf" rel="nofollow noreferrer"><a href="http://www.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf" rel="nofollow noreferrer">http://www.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf</a></a>

blocks|key|1864301|text|儿童权利委员会的有效性取决于多种因素。您不仅需要选择CRC的大小，还要选择要使用的生成多项式。有复杂和非直观的权衡取决于：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1864302|channel.|1864303|Whether的预期误码率错误倾向于突发或扩展(突发是常见的)|unordered-list-item|1864304|
|1864305|要保护的数据的长度-最大长度、最小长度和分布。|1864306|1864307|论文由Philip+Koopman和Tridib+Chakravarty撰写，发表在2004年国际可靠系统和网络会议记录中，给出了一个很好的概述，并作了一些参考。它还为进一步了解提供了参考书目。|1864308|http://www.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf|offset|length|1864309|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|0|0|0|23|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|11|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|12|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|14|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|15|8|@]|9|@$P|16|Q|17|1|18]]|A|$]]|$1|R|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|O]]]]

The effectiveness of a CRC is dependent on multiple factors. You not only need to select the SIZE of the CRC but also the GENERATING POLYNOMIAL to use. There are complicated and non-intuitive trade-offs depending on:

<ul>
<li>The expected bit error rate of the channel.</li>
<li>Whether the errors tend to occur in bursts or tend to be spread out (burst is common)</li>
<li>The length of the data to be protected - maximum length, minimum length and distribution.</li>
</ul>

The paper Cyclic Redundancy Code Polynominal Selection For Embedded Networks, by Philip Koopman and Tridib Chakravarty, publised in the proceedings of the 2004 International Conference on Dependable Systems and Networks gives a very good overview and makes several recomendations. It also provides a bibliography for further understanding.

<a href="http://www.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf" rel="noreferrer">http://www.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf</a>

blocks|key|1864345|text|CRC长度与文件大小的选择主要是在一个输入与“正确”输入有三位或更少位不同的情况下，而不是在一个大不相同的情况下。如果两种输入有很大的不同，那么在大多数形式的8位校验值(包括CRC)、1/65536与大多数16位校验值的形式(包括CRC)的情况下，错误匹配的可能性约为1/256。CRC的优势来自于对非常相似的输入的处理。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1864346|对于一个8位CRC，其多项式产生两个长度为128的周期，在短于未被检测的数据包中，单个、双或三比特错误的分数不会是1/256--它将为零。同样地，使用周期为32768的16位CRC，使用32768比特或更少的分组.|1864347|但是，如果分组比CRC周期长，那么如果错误位之间的距离是CRC周期的倍数，则将无法检测到双比特错误。虽然这似乎不是一个非常可能的情况，但CRC8在捕获长数据包中的双位错误时比捕获“数据包完全扰码”错误时要差一些。如果双位错误是第二大最常见的故障模式(仅次于单位错误)，那将是糟糕的。然而，如果有什么东西破坏了某些数据，那么带有双比特错误的CRCs的劣等行为可能不是问题。|1864348|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The choice of CRC length versus file size is mainly relevant in cases where one is more likely to have an input which differs from the "correct" input by three or fewer bits than to have a one which is massively different. Given two inputs which are massively different, the possibility of a false match will be about 1/256 with most forms of 8-bit check value (including CRC), 1/65536 with most forms of 16-bit check value (including CRC), etc. The advantage of CRC comes from its treatment of inputs which are very similar.

With an 8-bit CRC whose polynomial generates two periods of length 128, the fraction of single, double, or triple bit errors in a packet shorter than that which go undetected won't be 1/256--it will be zero. Likewise with a 16-bit CRC of period 32768, using packets of 32768 bits or less.

If packets are longer than the CRC period, however, then a double-bit error will go undetected if the distance between the erroneous bits is a multiple of the CRC period. While that might not seem like a terribly likely scenario, a CRC8 will be somewhat worse at catching double-bit errors in long packets than at catching "packet is totally scrambled" errors. If double-bit errors are the second most common failure mode (after single-bit errors), that would be bad. If anything that corrupts some data is likely to corrupt a lot of it, however, the inferior behavior of CRCs with double-bit errors may be a non-issue.

blocks|key|1864400|text|下面是对CRC-N+http://www.backplane.com/matt/crc64.html的一个很好的“真实世界”评估。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1864401|我使用CRC-32和文件大小的比较，从来没有，在数十亿的文件检查，运行一个匹配的CRC-32和文件大小的冲突。但我知道有一些存在，而不是故意强迫存在的。(被黑的诡计/利用)|1864402|在进行比较时，您还应该检查“数据大小”。在正确的大小范围内，很少会有相同的数据大小与匹配的CRC发生冲突。|1864403|故意操纵的数据，为了伪造匹配，通常通过添加额外的数据来完成，直到CRC匹配目标为止。然而，这会导致数据大小不再匹配。试图暴力，或循环随机，或序列数据，同样的大小，将留下一个真正狭窄的碰撞率。|1864404|您还可以在数据大小内发生冲突，只需要使用公式的一般限制，以及使用位/字节和基-10系统的约束，这取决于浮点值，浮点值会被截断和剪短。|1864405|当你开始看到许多无法“确认”为“原始”的碰撞时，你会想要把它变大。(当它们具有相同的数据大小时，(当向后测试时，它们有一个匹配的CRC+)。反向/字节或反向/位，或位偏移)|1864406|无论如何，它永远不应该被用作唯一的比较形式，仅仅作为一种快速的比较形式，用于索引。|1864407|您可以使用CRC-8索引整个互联网，并将所有的东西分成一个N-链接。你想要那些碰撞。现在，那些预先排序，你只需要检查一个N目录，寻找“文件大小”，或“反向CRC”，或任何其他比较，你可以做的小数据集，快速.|1864408|在同一个数据块上前后执行CRC-32比在一个方向上使用CRC-64更可靠。(或者是MD5。)|1864409|entityMap|0|LINK|mutability|MUTABLE|url|http://www.backplane.com/matt/crc64.html^0|A|14|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|6|7|15|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|16|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|17|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|18|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|19|8|@]|9|@]|C|$]]|$1|N|3|O|5|6|7|1A|8|@]|9|@]|C|$]]|$1|P|3|Q|5|6|7|1B|8|@]|9|@]|C|$]]|$1|R|3|S|5|6|7|1C|8|@]|9|@]|C|$]]|$1|T|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]]|U|$V|$5|W|X|Y|C|$Z|10]]]]

Here is a nice "real world" evaluation of CRC-N
<a href="http://www.backplane.com/matt/crc64.html" rel="nofollow noreferrer">http://www.backplane.com/matt/crc64.html</a>

I use CRC-32 and file-size comparison and have NEVER, in the billions of files checked, run into a matching CRC-32 and File-Size collision. But I know a few exist, when not purposely forced to exist. (Hacked tricks/exploits)

When doing comparison, you should ALSO be checking "data-sizes". You will rarely have a collision of the same data-size, with a matching CRC, within the correct sizes.

Purposely manipulated data, to fake a match, is usually done by adding extra-data until the CRC matches a target. However, that results in a data-size that no-longer matches. Attempting to brute-force, or cycle through random, or sequential data, of the same exact size, would leave a real narrow collision-rate.

You can also have collisions within the data-size, just by the generic limits of the formulas used, and constraints of using bits/bytes and base-ten systems, which depends on floating-point values, which get truncated and clipped.

The point you would want to think about going larger, is when you start to see many collisions which can not be "confirmed" as "originals". (When they both have the same data-size, and (when tested backwards, they have a matching CRC. Reverse/byte or reverse/bits, or bit-offsets)

In any event, it should NEVER be used as the ONLY form of comparison, just for a quick form of comparison, for indexing.

You can use a CRC-8 to index the whole internet, and divide everything into one of N-catagories. You WANT those collisions. Now, with those pre-sorted, you only have to check one of N-directories, looking for "file-size", or "reverse-CRC", or whatever other comparison you can do to that smaller data-set, fast...

Doing a CRC-32 forwards and backwards on the same blob of data is more reliable than using CRC-64 in just one direction. (Or an MD5, for that matter.)

blocks|key|886431|text|您可以在任意大小的数据包中使用CRC检测单个比特错误。检测双比特错误或纠正单比特错误仅限于CRC可以采取的不同值的数目，因此对于8位，即256位；对于16位，65535；等等2%5En；然而，在实践中，CRC实际上对单个比特错误具有较少的不同值。例如，我所称的'Y5‘多项式，0x5935多项式只需要对256个不同的值进行更远的重复，但另一方面，它能够纠正双比特错误的距离，这是30字节加2个字节的错误在CRC本身。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|886432|通过前向纠错可以修正的位数也受到多项式的汉明距离的限制。例如，如果Hamming距离为3，则必须翻转三位才能从一组表示具有匹配CRC的有效消息的位更改为另一组具有匹配CRC的有效消息。如果是这样的话，你可以自信地改正一点。如果汉明距离为5，你可以纠正两位。但是在纠正多个位时，实际上是索引多个位置，所以您需要两倍多的位来表示两个校正位的索引，而不是一个。|886433|通过前向纠错，您可以计算分组上的CRC和CRC，并得到一个剩余价值。一个具有零错误的好消息总是具有期望的剩余值(除非CRC寄存器有一个非零的初始值，否则为零)，并且每个错误位位置都有一个唯一的剩余值，所以使用它来标识位置。如果您曾经得到一个CRC的结果与该残余，您知道哪个位(或多位)翻转以纠正错误。|886434|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

You can detect a single bit error with a CRC in any size packet. Detecting double bit errors or correction of single bit errors is limited to the number of distinct values the CRC can take, so for 8 bits, that would 256; for 16 bits, 65535; etc. 2^n; In practice, though, CRCs actually take on fewer distinct values for single bit errors. For example what I call the 'Y5' polynomial, the 0x5935 polynomial only takes on up to 256 different values before they repeat going back farther, but on the other hand it is able to correct double bit errors that distance, which is 30 bytes plus 2 bytes for errors in the CRC itself.
The number of bits you can correct with forward error correction is also limited by the Hamming Distance of the polynomial. For example, if the Hamming distance is three, you have to flip three bits to change from a set of bits that represents one valid message with matching CRC to another valid message with its own matching CRC. If that is the case, you can correct one bit with confidence. If the Hamming distance were 5, you could correct two bits. But when correcting multiple bits, you are effectively indexing multiple positions, so you need twice as many bits to represent the indexes of two corrected bits rather than one.
With forward error correction, you calculate the CRC on a packet and CRC together, and get a residual value. A good message with zero errors will always have the expected residual value (zero unless there's a nonzero initial value for the CRC register), and each bit position of error has a unique residual value, so use it to identify the position. If you ever get a CRC result with that residual, you know which bit (or bits) to flip to correct the error.

I've seen 8-bit, 16-bit, and 32-bit CRCs.

At what point do I need to jump to a wider CRC?

My gut reaction is that it is based on the data length:

<ol>
<li>1-100 bytes: 8-bit CRC</li>
<li>101 - 1000 bytes: 16-bit CRC</li>
<li>1001 - ??? bytes: 32-bit CRC</li>
</ol>

EDIT:
Looking at the Wikipedia page about CRC and Lott's answer, here' what we have:

&lt;64 bytes: 8-bit CRC

&lt;16K bytes: 16-bit CRC

&lt;512M bytes: 32-bit CRC

Data Length vs CRC Length

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我见过8位，16位和32位的CRCs。在什么时候需要跳到更宽的CRC?我的直觉反应是基于数据长度：1~100字节:8位CRC101-1000字节:16位CRC1001？字节:32位CRC编辑:看看维基百科关于CRC和Lott的答案，这里有：<64字节:8位CRC<16K字节:16位CRC<512 m字节:32位CRC

问数据长度与CRC长度
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问数据长度与CRC长度EN