Mostrar código-fonte de CRC

{{DISPLAYTITLE:Verificação Cíclica de Redundância (CRC)}}

A '''verificação cíclica de redundância''' (do [[língua inglesa|inglês]], CRC - Cyclic Redundancy Check) é um método de [[Detecção e correção de erros|detecção de erros]] normalmente usada em [[Rede digital|redes digitais]] e [[Dispositivo de armazenamento|dispositivos de armazenamento]] para detectar mudança acidental em cadeias de dados. Mensagens de dados entrando nesses sistemas recebem um pequeno anexo com um valor de verificação baseado no resto de [[divisão polinomial]] do seu conteúdo. No ato da recuperação do dado o cálculo é refeito e comparado com o valor gerado anteriormente. Se os valores não se mostrarem semelhantes podem ser aplicadas ações para correção de dados, evitando assim a corrupção de dados. CRC pode ser usada para correção de erros a partir de alguns métodos.<ref>{{citar web|url=http://www.drdobbs.com/an-algorithm-for-error-correcting-cyclic/184401662|titulo=|data=|acessodata=|publicado=|ultimo=|primeiro=}}</ref>

O nome CRC vem da redundância do valor de verificação atrelado ao dado (A mensagem recebe um aumento em seu tamanho sem adicionar uma [[informação]]) e o [[algoritmo]] de validação é construído com [[Laço de repetição|laços de repetição]] cíclicos.

A '''verificação cíclica de redundância''' é amplamente utilizada em dispositivos binários por ser de simples implementação, é matematicamente fácil de ser analisada e apresenta bons resultados na detecção de erros comuns em canais de transmissão causados por [[ruído]]. A [[Função (matemática)|função]] utilizada para gerar o valor de verificação possui tamanho fixo, e é utilizada igualmente como uma [[função hash]].

O primeiro a propor a CRC foi W. Wesley Peterson em 1961. Hoje, a '''função CRC de 32 bits do Ethernet''' e vários outros padrões são trabalhos de vários pesquisadores e foi publicada em 1975.

== Introdução ==
'''Verificação cíclica de redundância''' é baseada na teoria de [[wikipedia:Forward_error_correction|códigos de correção de erros]] [[wikipedia:Cyclic_code|cíclicos]]. O uso de códigos cíclicos [[wikipedia:Systematic_code|sistemáticos]], que alteram a mensagem adicionando um valor de verificação de tamanho fixo, com o propósito de detecção de erros em redes de comunicação foi proposta por [[wikipedia:W._Wesley_Peterson|W. Wesley Peterson]] em 1961.<ref>{{citar periódico|ultimo=Peterson;Brown|primeiro=W.W.;D.T|data=Janeiro de 1961|titulo=Cyclic Codes for Error Detection|jornal=Proceedings of the IRE. 49 (1): 228–235|doi=10.1109/JRPROC.1961.287814|url=https://doi.org/10.1109%2FJRPROC.1961.287814|acessadoem=}}</ref> Códigos cíclicos são simples de implementar e possuem o benefício apresentar ótimas respostas na detecção de erros causados pela “Rajada” de bits: sequencias continuas de símbolos de dados errados ([[wikipedia:Burst_error|Burst Errors]]).

Eles são importantes porque Burst Errors são ocorrências comuns em [[canais de comunicação]], incluindo canais óticos ou magnéticos. Geralmente, um ''n-''bit CRC aplicado sobre uma mensagem de tamanho qualquer irá detectar cada um desses erros que forem menores que ''n'' bits e uma fração de 1/(1- 2^(-''n'')) de bits em mensagens maiores.

A determinação de um valor para o código de validação requer a definição de um [[wikipedia:Polynomial_code|Gerador Polinomial]]'''.'''

Esse polinômio será o divisor em uma [[divisão polinomial]] em que a mensagem de dados será o dividendo e o quociente é descartado, porém o resto será o código de verificação. É importante mencionar que os [[coeficiente]]s do gerador são calculados de acordo com a aritmética de campo finito, para que a operação de adição possa sempre ocorrer paralelamente bit-a-bit (sem carry entre dígitos).O tamanho do resto será sempre menor que o do gerador polinomial, com isso pode-se determinar o tamanho do código de verificação.

Na prática, a maioria dos códigos utilizam um campo [[wikipedia:Finite_field|Galois]] de 2 elementos, [[wikipedia:GF(2)|GF(2)]].Os elementos são geralmente chamados de 0 e 1 coincidentemente utilizados na arquitetura binária.

Um CRC é chamado de ''n''-bit CRC quando seu código de verificação possui tamanho de ''n'' bits. Para um dado ''n,'' múltiplos códigos de verificação são possíveis de serem construídos, cada um com um polinômio diferente. Tal polinômio possui o maior grau de valor ''n'', além de ''n'' + 1 termos. Ou seja, ele possui tamanho ''n'' + 1 bits.

Várias especificações descartam o ''MSB'' ou o ''LSB,'' pois eles sempre serão iguais a 1. Essas especificações serão encontradas mais a frente na forma de '''CRC-''n''-XXX.'''

O sistema de detecção de erro mais simples, o [[bit de paridade]], é na verdade um 1-bit CRC, de polinômio ''x'' + 1 (dois termos), de nome CRC-1.

== Aplicações ==
Um dispositivo que suporta CRC calcula uma pequena sequência binária de tamanho fixo, conhecido como código de verificação ou CRC, para cada mensagem que será enviada ou recebida e a anexa aos dados, formando uma palavra-código (codeword).

Quando uma palavra código é recebida ou lida, o dispositivo compara seu código de verificação anexado com um novo, calculado a partir da mensagem, ou aplica o CRC sobre toda a palavra-código e compara o resultado com uma constante residual pré-definida.

Se os códigos CRC não são semelhantes a mensagem contém erros de dados. O dispositivo pode realizar ações corretivas como reler a mensagem ou requisitar um novo envio da mesma.

Senão os dados podem ser tratados como corretos e sem erro. (Com uma pequena probabilidade o código pode conter erros não detectados; essa é a natureza fundamental da verificação de erros).<ref>{{citar periódico|ultimo=Ritter|primeiro=Terry|data=Fevereiro de 1986|titulo=The Great CRC Mystery|jornal=Dr. Dobb's Journal|volume=11|numero=2|paginas=26-34, 76-83|doi=|url=http://www.ciphersbyritter.com/ARTS/CRCMYST.HTM|acessadoem=05/09/2017}}</ref>

== Integridade dos dados ==
Os códigos de verificação cíclica de redundância são projetados para proteger contra erros típicos dos canais de comunicação, onde podem garantir a [[Integridade de dados|integridade]] de mensagens de forma rápida e confiável. Entretanto, eles não são aplicáveis para proteção contra alteração intencional de dados.

Não há nenhum tipo de autenticação, um invasor pode editar a mensagem e recalcular seu código de verificação sem que a substituição seja detectada. Quando as funções criptográficas de hash e a CRC são armazenadas em conjunto com os dados, elas não podem proteger contra alterações intencionais dos dados. Aplicações que requerem tal proteção devem usar mecanismos de autenticação criptográficas como [[Autenticação|códigos de autenticação]] da mensagem ou [[wikipedia:Digital_signatures|assinaturas digitais]].

Diferente das [[Função hash criptográfica|funções hash criptográficas]] , um CRC pode ser revertido facilmente, o que o torna inaplicável para uso com assinaturas digitais. <ref>{{citar periódico|ultimo=Stigge|primeiro=Martin|ultimo2=Plötz|primeiro2=Henryk|ultimo3=Müller|primeiro3=Wolf|ultimo4=Jens-Peter|primeiro4=Jens-Peter|data=Maio de 2006|titulo=Reversing CRC – Theory and Practice|jornal=|paginas=17|doi=|url=http://sar.informatik.hu-berlin.de/research/publications/SAR-PR-2006-05/SAR-PR-2006-05_.pdf|acessadoem=6/09/2017}}</ref>

Finalmente, CRC são criados a partir de [[funções lineares]], com a seguinte propriedade:<math>crc(x\oplus y \oplus z)=crc(x)\oplus crc(y) \oplus crc(z)
</math>

'''''Logo, mesmo que o CRC seja criptografado com uma [[cifra de fluxo]] (Stream cipher, um algoritmo de chave simétrica) que use a operação lógica [[Ou exclusivo|OU exclusivo]] (XOR) como sua operação combinatória, ambas mensagem e CRC associada podem ser manipuladas sem o conhecimento da chave de manipulação. Essa era uma das falhas conhecidas do protocolo [[Wired Equivalent Privacy|WEP]]. <ref name="wep">{{citar periódico|último1 =Cam-Winget|primeiro1 =Nancy|último2 =Housley|primeiro2 =Russ|último3 =Wagner|primeiro3 =David|último4 =Walker|primeiro4 =Jesse|título=Security Flaws in 802.11 Data Link Protocols|periódico=Communications of the ACM|volume=46|número=5|páginas=35–39|data=Maio de 2003|doi=10.1145/769800.769823}}</ref>'''''

== Cálculo ==
Para calcular um CRC de ''n'' bits, coloque os bits representando o dado em uma linha, e abaixo do MSB dessa linha posicione o padrão (''n'' + 1)-bit que representa o divisor CRC, também chamado de "[[polinômio]]".

Neste exemplo será utilizado uma mensagem de 14 bits, com um 3-bit CRC, e o polinômio gerador. O polinômio precisa ser escrito em binário, um polinômio de 3ª ordem possui 4 coeficientes (). Nesse caso, os coeficientes são: 1, 0, 1, 1. O resultado do cálculo tem 3 bits de tamanho.

A mensagem a ser codificada será:

<pre>
11010011101100
</pre>

Primeiro, são adicionados zeros no fim da palavra correspondentes ao tamanho ''n'' do CRC. Então é feito o primeiro cálculo para se obter o 3-bit CRC:

<pre>
11010011101100 000 <--- entrada deslocada para a direita com 3 zeros
1011               <--- divisor (4 bits) = x³ + x + 1
------------------
01100011101100 000 <--- resultado
</pre>

O algoritmo age sobre os bits diretamente acima do divisor em cada passo. O resultado para a iteração acima é a operação OU-exclusivo bit-a-bit para os bits acima do divisor polinomial. Os bits restantes são diretamente copiados para o resultado daquele passo. O Divisor é então deslocado para a direita em 1 bit e o processo é repetido até que divisor alcance o ultimo bit da mensagem. O cálculo completo pode ser visto a seguir:

<pre>
11010011101100 000 <--- entrada deslocada para a direita com 3 zeros
1011               <--- divisor
01100011101100 000 <--- resultado (note que os primeiros 4 bits são um XOR com os bits acima do divisor, o resto é copiado).
 1011              <--- divisor ...
00111011101100 000
  1011
00010111101100 000
   1011
00000001101100 000 <--- note que o divisor irá se mover mais de 1 bit para se alinhar com o próximo bit 1 do dividendo (por que o quociente da operação para aquele passo seria 0). 
       1011             (Ou seja, ele não se move apenas 1 bit necessariamente.)
00000000110100 000
        1011
00000000011000 000
         1011
00000000001110 000
          1011
00000000000101 000
           101 1
-----------------
00000000000000 100 <--- resto (3 bits). O algoritmo de divisão para neste ponto pois o dividendo é zero.
</pre>

Como o bit divisor mais à esquerda zerou todos os bits que interagiu, ao final desse processo apenas os ''n'' bits mais à direita da mensagem não serão zerados. Esses ''n'' bits correspondem ao resto da divisão polinomial, e ao valor da função CRC (a menos que a especificação do CRC escolhido exija algum processamento posterior).

A validade de uma mensagem recebida pode ser avaliada de maneira simples, aplicando o calculo acima novamente, porém o valor da função CRC será adicionado no lugar dos zeros à direita. O resto dessa operação deverá ser zero se nenhum erro for detectado.

<pre>
11010011101100 100 <--- mensagem com o CRC
1011               <--- divisor
01100011101100 100 <--- resultado passo 1
 1011              <--- divisor ...
00111011101100 100

......

00000000001110 100
          1011
00000000000101 100
           101 1
------------------
00000000000000 000 <--- resto
</pre>

== Matemática ==
A análise matemática desse processo de “divisão” demonstra como selecionar um divisor que garantirá boas propriedades de detecção de erro. Nessa análise, os dígitos da linha de bits são utilizados como coeficientes de um polinômio em uma variável qualquer ''x'' (coeficientes que são na verdade elementos do campo finito de [[GF(2)]], ao invés de números quaisquer propriamente). Esse conjunto binário polinomial é um [[Anel (matemática)|anel matemático]].

=== Determinando polinômios ===
Selecionar o polinômio gerador é a parte mais importante de um algoritmo de '''verificação cíclica de redundância'''(CRC). O polinômio deve ser escolhido a fim de maximizar a capacidade de detecção de erros e minimizar a probabilidade de resultados semelhantes se utilizado outros polinômios.

O atributo mais importante do polinômio é seu tamanho (o maior grau de qualquer termo da expressão (maior expoente) + 1), pois isso impactará diretamente sobre o tamanho do valor de verificação.

Os tamanhos mais utilizados de polinômios são:
* 9 bits (CRC-8)
* 17 bits (CRC-16)
* 33 bits (CRC-32)
* 65 bits (CRC-64)
A determinação do polinômio de CRC depende do tamanho total da mensagem de dados a ser protegida (dados + bits de verificação CRC), das propriedades de proteção contra erros desejadas e da quantidade/tipo de recursos disponíveis para a implementação do CRC, além, é claro, da performance desejada. Um erro comum é assumir que os “melhores” polinômios para CRC são encontrados a partir de [[Polinômio irredutível|polinômios irredutíveis]] ou polinômios irredutíveis multiplicados pelo fator ''1+x,'' que adiciona ao algoritmo a capacidade de detectar todos os erros que afetam um número ímpar de bits (1, 3, 5, ...).<ref name="williams93">{{citar web|url=http://www.repairfaq.org/filipg/LINK/F_crc_v3.html|título=A Painless Guide to CRC Error Detection Algorithms V3.0|acessodata=5 de junho de 2010|último =Williams|primeiro =Ross N.|data=24 de setembro de 1996}}</ref>

Na realidade, todos os fatores descritos acima devem ser considerados para a escolha do polinômio e podem levar a um polinômio redutível. Entretanto, a escolha de um polinômio redutível irá causar um aumento na quantidade de erros que não serão detectados pelo CRC, pois o quociente do anel matemático terá [[Divisor de zero|divisores nulos]].

A vantagem na escolha de um [[wikipedia:Primitive_polynomial_(field_theory)|polinômio primitivo]] como gerador para um código CRC será encontrada no resultado que terá um tamanho total de mensagem tal que todos os erros de 1-bit contidos na mensagem terão restos da divisão distintos (chamados de [[wikipedia:Syndrome_decoding|síndromes]]) e por isso, o resto será uma função linear, e o algoritmo será capaz de detectar qualquer erro de 2 bits contidos na mensagem. Se <math>r
</math> é o grau do polinômio primitivo gerador, então o tamanho máximo da mensagem de dados será <math>2^r-1
</math> , e o código de verificação anexado será capaz de detectar qualquer erro de um bit ou de um par de bits.<ref>{{citar livro|último1 =Press|primeiro1 =WH|último2 =Teukolsky|primeiro2 =SA|último3 =Vetterling|primeiro3 =WT|último4 =Flannery|primeiro4 =BP|ano=2007|título=Numerical Recipes: The Art of Scientific Computing|edição=3rd|publicado=Cambridge University Press|local-publicação=New York|isbn=978-0-521-88068-8|capítulo=Section 22.4 Cyclic Redundancy and Other Checksums|capítulourl=http://apps.nrbook.com/empanel/index.html#pg=1168}}</ref>

Isso pode ser otimizado, se for utilizado um polinômio gerador <math>g(x)=p(x)(1+x)
</math>, onde <math>p(x)

</math>'''&nbsp;'''é um polinômio primitivo de grau <math>r-1

</math> , então o tamanho máximo da mensagem será&nbsp;<math>2^{r-1}-1
</math>, e o código se tornará capaz de detectar erros de bit único, duplo, triplo e qualquer conjunto de tamanho ímpar de bits.

O polinômio <math>g(x)
</math>&nbsp;admite que fatorações possam ser escolhidas para controlar o tamanho da mensagem com p poder de detecção de erros desejado. Os algoritmos de [[wikipedia:BCH_code|BCH]] são classes de tais polinômios. Eles incluem os dois exemplos acima. Independente das propriedades de redução de um gerador polinomial de grau , se ele é expresso com o termo “+1”, o código será capaz de detectar padrões de erro contidos em uma janela de bits contínuos. Esses padrões são chamados de “rajada de erros” (errors bursts).&nbsp;

== Especificação ==
O conceito da '''verificação cíclica de redundância''' como um algoritmo de detecção de erros ganha complexidade à medida que implementações ou comitês de normas à aplicam em sistemas reais. Alguns exemplos de complicações são:
* Algumas implementações usam um '''padrão de bits prefixado''' na linha dos dados a ser verificada. Isso é especialmente útil quando erros de temporização podem inserir bits de valor 0 antes da mensagem, essa alteração não iria alterar o código de verificação.
* Há uma chance da implementação '''anexar ''n'' bits de valor 0''' (''n'' sendo o tamanho do CRC) à linha de dados que será verificada antes que a divisão polinomial ocorra. Esse tipo de anexação é demonstrada explicitamente no artigo [[wikipedia:Computation_of_cyclic_redundancy_checks|Computation of CRC]]. É conveniente que o resto da linha de dados original com o valor de verificação anexado seja exatamente zero, para que a validade do CRC possa ser avaliada simplesmente efetuando a divisão polinomial dos dados recebidos e comparar o resto dessa operação com zero. Devido a propriedade associativa e comutativa da operação OU-exclusivo, implementações que utilizam tabelas de resultados para comparação podem obter um resultado numericamente equivalente a essa anexação de bits 0 sem ser necessário que ela aconteça, usando algum algoritmo equivalente [6] que combina os dados recebidos imediatamente com dados que acabaram de ser verificados, o tornando mais rápido.
* Padrões que implementam a operação OU-exclusivo em um número fixo de bits no resto da divisão polinomial.
* '''A ordem dos bits:''' algumas arquiteturas utilizam o bit de menor ordem de cada byte como o “primeiro” bit, que implica na divisão polinomial ser realizada a partir do bit mais à direita. Essa convenção é utilizada em transmissões via porta serial são validadas em hardware, admitindo-se que o bit menos significativo é transmitido primeiro.
* '''A ordem do byte:''' com CRC aplicado à múltiplos bytes pode haver confusão se o primeiro byte transmitido será o byte mais significativo ou o menos significativo. Algumas implementações 16-bit CRC trocam os bytes que devem ser avaliados pelo código de verificação.
* '''Omissão do bit mais significativo''' do divisor polinomial: como o bit de maior grau é sempre 1, e como um ''n''-bit CRC é definido com o tamanho (''n'' + 1) bits que é [[wikipedia:Arithmetic_overflow|maior]] que um registro de ''n'' bits, alguns autores assumem que é desnecessário mencionar o bit de maior grau do divisor.
* '''Omissão do bit menos significativo''' do divisor polinomial: como o bit de menor grau é sempre 1, autores como Phillip Koopman representam polinômios com seu bit mais significativo intacto, porém o bit menos significativo ( o de termo <math>x^0
</math> ou 1 ) é descartado. Essa convenção representa o polinômio completo&nbsp;com seu grau em apenas uma variável inteira.
Essas complicações demonstram que um polinômio pode ser expresso de 3 formas diferentes: as duas primeiras são as mais encontradas em algoritmos, sendo que uma é a negação logica da outra; e a terceira é a forma encontrada nos artigos escritos por Koopman. Em cada caso, um termo é omitido. E o polinômio <math>x^4+x+1
 
 </math>&nbsp;pode ser representado como:
* 0x3 = 0b0011, representando <math>x^4+(0x^3+0x^2+1x^1+1x^0)
</math>&nbsp;(Com o bit mais significativo à esquerda)
* 0xC = 0b1100, representando&nbsp;<math>(1x^0+1x^1+0x^2+0x^3)+x^4
</math>&nbsp;(Com o bit menos significativo à esquerda)
* 0x9 = 0b1001, representando <math>(1x^4+0x^3+0x^2+1x^1)+x^0
</math>&nbsp;(notação utilizada por Koopman)

Na tabela abaixo eles são representados como:

{| class="wikitable"
|'''Nome'''
|'''Normal'''
|'''Reversa'''
|'''Reversa Reciproca'''
|-
|CRC-4
|0x3
|0xC
|0x9
|}

== Padrões e Usos ==
Vários algoritmos de '''verificação cíclica de redundância''' são regidos por Normas Técnicas. Nenhum algoritmo, ou implementação de um polinômio de qualquer grau pode ser utilizado para todas as aplicações. Koopman e Chakravarty recomendam que a seleção de um polinômio seja feita de modo a atender as necessidades da aplicação e o tamanho esperado das mensagens enviadas.<ref name="koop04">{{citar periódico|último =Koopman|primeiro =Philip|último2 =Chakravarty|primeiro2 =Tridib|título=Cyclic Redundancy Code (CRC) Polynomial Selection For Embedded Networks|periódico=The International Conference on Dependable Systems and Networks|data=junho de 2004 <!-- date from http://www.ece.cmu.edu/~koopman/pubs.html -->|url=http://www.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf|acessodata=14 de janeiro de 2011|páginas=145–154|doi=10.1109/DSN.2004.1311885|isbn=0-7695-2052-9}}</ref> O número de algoritmos de CRC que podem ser usados gera certa confusão nos desenvolvedores, esse é o problema que a maioria de autores sobre o assunto busca resolver.<ref name="williams93" /> Existem 3 polinômios utilizados para o CRC-12,<ref name="koop04" /> 19 conflitos nas definições para o CRC-16, e 7 para o CRC-32. <ref name="cook-catalogue">{{citar web|último =Cook|primeiro =Greg|url=http://reveng.sourceforge.net/crc-catalogue/all.htm|título=Catalogue of parametrised CRC algorithms|acessodata=1 de agosto de 2016|data=27 de julho de 2016}}</ref>

Os polinômios que são utilizados não são necessariamente os mais eficientes. Desde 1993, Koopman, Castagnoli e outros trabalharam com a abrangência de polinômios entre 3 e 64 bits de comprimento, <ref name="koop04" /><ref name="cast93">{{citar periódico|último =Castagnoli|primeiro =G.|último2 =Bräuer|primeiro2 =S.|último3 =Herrmann|primeiro3 =M.|data=junho de 1993|título=Optimization of Cyclic Redundancy-Check Codes with 24 and 32 Parity Bits|periódico=IEEE Transactions on Communications|volume=41|número=6|doi=10.1109/26.231911|páginas=883–892}}</ref><ref name="koop02">{{citar periódico|último =Koopman|primeiro =Philip|título=32-Bit Cyclic Redundancy Codes for Internet Applications|periódico=The International Conference on Dependable Systems and Networks|data=julho de 2002 <!-- date from http://www.ece.cmu.edu/~koopman/pubs.html -->|url=http://www.ece.cmu.edu/~koopman/networks/dsn02/dsn02_koopman.pdf|acessodata=14 de janeiro de 2011|páginas=459–468|doi=10.1109/DSN.2002.1028931|isbn=0-7695-1597-5}}</ref><ref name="koopman-best-crc-polys">{{citar web|último =Koopman|primeiro =Philip|data=21 de janeiro de 2016|título=Best CRC Polynomials|instituição=Carnegie Mellon University|local=Pittsburgh|url=https://users.ece.cmu.edu/~koopman/crc/|acessodata=26 de janeiro de 2016}}</ref> buscando exemplos que possuíam uma melhora na performance (em termos da [[Distância de Hamming]] para determinado tamanho de mensagem) em comparação com os polinômios utilizados em padrões anteriores, publicando os que apresentavam melhores resultados com o intuito de otimizar a capacidade de detecção de erros de padrões futuros. <ref name="koop02" /> Em particular, o [[iSCSI]]&nbsp;e&nbsp;[[Stream Control Transmission Protocol|SCTP]] utilizam um dos polinômios descobertos durante a pesquisa, o polinômio (Castagnoli) CRC-32C.

O projeto do polinômio de 32 bits utilizado na maioria dos padrões, o CRC-32-IEEE, foi resultado de um esforço conjunto para [[wikipedia:Rome_Laboratory|Laboratório Rome]] e a Divisão de Sistemas Eletrônicos das Forças Aéreas americanas obtido por Joseph Hammond, James Brown, Shyan-Shiang Liu, do [[Instituto de Tecnologia da Geórgia|Instituto de Tecnologia da Georgia]], e Kenneth Brayer da Corporação [[wikipedia:Mitre_Corporation|MITRE]].

As primeiras publicações sobre o polinômio de 32 bits ocorreram em 1975: no Relatório Técnico 2956 da Corporação MITRE, publicado internamente em Janeiro e divulgado para o público em Agosto pelo [[wikipedia:DTIC|DTIC]],<ref name="Brayer1975">{{citar periódico|último =Brayer|primeiro =Kenneth|data-publicação=agosto de 1975|título=Evaluation of 32 Degree Polynomials in Error Detection on the SATIN IV Autovon Error Patterns|publicado=[[National Technical Information Service]]|página=74|url=http://www.dtic.mil/srch/doc?collection=t3&id=ADA014825 <!-- http://oai.dtic.mil/oai/oai?verb=getRecord&metadataPrefix=html&identifier=ADA014825 -->|acessodata=3 de fevereiro de 2011}}</ref> além do relatório de Hammond, Brown e Liu para o laboratório de Roma publicado em Maio. <ref name="Hammond1975">{{citar periódico|último =Hammond|primeiro =Joseph L., Jr.|último2 =Brown|primeiro2 =James E.|último3 =Liu|primeiro3 =Shyan-Shiang|data-publicação=maio de 1975|título=Development of a Transmission Error Model and an Error Control Model|publicado=[[National Technical Information Service]]|url=http://www.dtic.mil/cgi-bin/GetTRDoc?AD=ADA013939&Location=U2&doc=GetTRDoc.pdf|acessodata=7 de julho de 2012|página=74|doi=|bibcode=1975STIN...7615344H|volume=76|ano=1975|periódico=Unknown}}</ref>Ambos os relatórios continham contribuições das equipes envolvidas. Em Dezembro de 1975, Brayer e Hammond apresentaram um artigo com informações sobre seu trabalho na Conferência Nacional de Telecomunicações IEEE: o CRC-32-IEE é o polinômio gerado a partir de um [[Código de Hamming|código Hamming]] e foi escolhido pela sua performance na detecção de erros. <ref name="BrayerHammond1975">{{citar conferência|último =Brayer|primeiro =Kenneth|último2 =Hammond|primeiro2 =Joseph L., Jr.|data=dezembro de 1975|título=Evaluation of error detection polynomial performance on the AUTOVON channel|conferencia=IEEE National Telecommunications Conference, New Orleans, La|títulolivro=Conference Record|volume=1|publicado=Institute of Electrical and Electronics Engineers|local=New York|páginas=8–21 to 8–25|bibcode=1975ntc.....1....8B}}</ref> No entanto, o polinômio CRC-32C de Castagnoli usado nos protocolos iSCSI ou SCTP apresenta o mesmo desempenho para mensagens com o tamanho entre 58 bits a 131k bits, e um desempenho superior para diferentes tamanhos de mensagens, incluindo os e tamanhos de pacotes mais utilizados pela internet.<ref name="koop02" /> O padrão [[Setor de Normatização das Telecomunicações|ITU-T]] [[wikipedia:G.hn|G.hn]] também faz uso do CRC-32C para detectar erros nos dados( entretanto ele utiliza o CRC-16-CCITT para outras aplicações).

A tabela abaixo lista apenas polinômios de vários algoritmos que estão em uso. Variações particulares dos protocolos podem utilizar pré-inversão, pós-inversão e ordenação reversa de bits como descrito acima. Por exemplo, o CRC32 utilizado nos padrões [[Gzip]] e Bzip2 utilizam o mesmo polinômio, porém o Gzip aplica a ordenação reversa de bits.<ref name="cook-catalogue" />

CRCs de protocolos proprietários podem utilizar valores iniciais não triviais e um operação XOR adicional para esconder seu valor, mas tais técnicas não aumentam a força da criptografia utilizada no algoritmo e podem ser desmascaradas utilizando métodos diretos de [[engenharia reversa]].<ref name="ewing-rev-eng">{{citar web|último =Ewing|primeiro =Gregory C.|data=março de 2010|título=Reverse-Engineering a CRC Algorithm|local=Christchurch|publicado=University of Canterbury|url=http://www.cosc.canterbury.ac.nz/greg.ewing/essays/CRC-Reverse-Engineering.html|acessodata=26 de julho de 2011}}</ref>

{| class="wikitable"
! rowspan="2" |Nome
! rowspan="2" |Uso
! colspan="3" |Polynomial representations
|-
!Normal
![[wikipedia:Mathematics_of_cyclic_redundancy_checks#Reversed_representations_and_reciprocal_polynomials|Reversa]]
![[wikipedia:Mathematics_of_cyclic_redundancy_checks#Reciprocal_polynomials|Reversa Reciproca]]
|-
|CRC-1
|Maioria em hardware;conhecido como ''[[wikipedia:Parity_bit|parity bit]]''
|0x1
|0x1
|0x1
|-
|CRC-3-[[wikipedia:GSM|GSM]]
|redes móveis<ref name="ts-100-909">{{citar livro|título=ETSI TS 100 909|versão=V8.9.0|data=janeiro de 2005|publicado=European Telecommunications Standards Institute|local=Sophia Antipolis, France|url=https://www.etsi.org/deliver/etsi_ts/100900_100999/100909/08.09.00_60/ts_100909v080900p.pdf|acessodata=21 de outubro de 2016}}</ref>
|0x3
|0x6
|0x5
|-
|CRC-4-ITU
|[http://www.itu.int/rec/T-REC-G.704-199810-I/en G.704]
|0x3
|0xC
|0x9
|-
|CRC-5-EPC
|[[wikipedia:Radio-frequency_identification|Gen 2 RFID]]<ref name="gen-2-spec">{{citar livro|título=Class-1 Generation-2 UHF RFID Protocol|versão=1.2.0|publicado=[[EPCglobal]]|url=http://www.gs1.org/gsmp/kc/epcglobal/uhfc1g2/uhfc1g2_1_2_0-standard-20080511.pdf|data=23 de outubro de 2008|acessodata=4 de julho de 2012|página=35}} (Table 6.12)</ref>
|0x09
|0x12
|0x14
|-
|CRC-5-ITU
|[http://www.itu.int/rec/T-REC-G.704-199810-I/en G.704]
|0x15
|0x15
|0x1A
|-
|CRC-5-USB
|[[wikipedia:Universal_Serial_Bus|USB]] pacotes de token
|0x05
|0x14
|0x12
|-
|CRC-6-[[wikipedia:CDMA2000|CDMA2000]]-A
|redes móveis<ref name="cdma2000-spec">{{citar livro|publicado=3rd Generation Partnership Project 2|data=outubro de 2005|título=Physical layer standard for cdma2000 spread spectrum systems|versão=Revision D version 2.0|páginas=2-89–2-92|url=http://www.3gpp2.org/public_html/specs/C.S0002-D_v2.0_051006.pdf|acessodata=14 de outubro de 2013}}</ref>
|0x27
|0x39
|0x33
|-
|CRC-6-[[wikipedia:CDMA2000|CDMA2000]]-B
|redes móveis<ref name="cdma2000-spec" />
|0x07
|0x38
|0x23
|-
|CRC-6-DARC
|[[wikipedia:Data_Radio_Channel|Canal de Dados via Rádio]]<ref name="en-300-751">{{citar livro|título=ETSI EN 300 751|versão=V1.2.1|data=janeiro de 2003|publicado=European Telecommunications Standards Institute|local=Sophia Antipolis, France|url=http://www.etsi.org/deliver/etsi_en/300700_300799/300751/01.02.01_60/en_300751v010201p.pdf|seção=11. Error correction strategy|páginas=67–8|acessodata=26 de janeiro de 2016}}</ref>
|0x19
|0x26
|0x2C
|-
|CRC-6-[[wikipedia:GSM|GSM]]
|redes móveis<ref name="ts-100-909" />
|0x2F
|0x3D
|0x37
|-
|CRC-6-ITU
|[http://www.itu.int/rec/T-REC-G.704-199810-I/en G.704]
|0x03
|0x30
|0x21
|-
|CRC-7
|sistemas de telecomunicação, [http://www.itu.int/rec/T-REC-G.707/en G.707], [http://www.itu.int/rec/T-REC-G.832/en G.832], [[wikipedia:MultiMediaCard|MMC]], [[wikipedia:Secure_Digital_card|SD]]
|0x09
|0x48
|0x44
|-
|CRC-7-MVB
|[[wikipedia:Train_Communication_Network|Rede de Comunicação Ferroviária]], [[wikipedia:IEC_60870-5|IEC 60870-5]]<ref name="chakravarty-thesis">{{citar tese|último =Chakravarty|primeiro =Tridib|others=Philip Koopman, advisor|data=dezembro de 2001|título=Performance of Cyclic Redundancy Codes for Embedded Networks|publicado=Carnegie Mellon University|local=Pittsburgh|url=http://www.ece.cmu.edu/~koopman/thesis/chakravarty.pdf|acessodata=8 de julho de 2013|páginas=5,18}}</ref>
|0x65
|0x53
|0x72
|-
|CRC-8
|[[wikipedia:DVB-S2|DVB-S2]]<ref name="en-302-307">{{citar livro|título=EN 302 307|versão=V1.3.1|data=março de 2013|publicado=European Telecommunications Standards Institute|local=Sophia Antipolis, France|url=https://www.etsi.org/deliver/etsi_en/302300_302399/302307/01.03.01_60/en_302307v010301p.pdf|seção=5.1.4 CRC-8 encoder (for packetized streams only)|página=17|acessodata=29 de julho de 2016}}</ref>
|0xD5
|0xAB
|0xEA<ref name="koop042">{{citar periódico|último =Koopman|primeiro =Philip|último2 =Chakravarty|primeiro2 =Tridib|título=Cyclic Redundancy Code (CRC) Polynomial Selection For Embedded Networks|periódico=The International Conference on Dependable Systems and Networks|data=junho de 2004 <!-- date from http://www.ece.cmu.edu/~koopman/pubs.html -->|url=http://www.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf|acessodata=14 de janeiro de 2011|páginas=145–154|doi=10.1109/DSN.2004.1311885|isbn=0-7695-2052-9}}</ref>
|-
|CRC-8-[[wikipedia:AUTOSAR|AUTOSAR]]
|Integração Automotiva,<ref name="autosar-crc">{{citar livro|título=Specification of CRC Routines|versão=4.2.2|data=22 de julho de 2015|publicado=AUTOSAR|local=Munich|url=https://www.autosar.org/fileadmin/files/releases/4-2/software-architecture/safety-and-security/standard/AUTOSAR_SWS_CRCLibrary.pdf|seção=7.2.1.2 8-bit 0x2F polynomial CRC Calculation|página=24|acessodata=24 de julho de 2016}}</ref> [[wikipedia:OpenSafety|OpenSafety]]<ref name="opensafety-profile">{{citar livro|título=openSAFETY Safety Profile Specification: EPSG Working Draft Proposal 304|versão=1.4.0|data=13 de março de 2013|publicado=Ethernet POWERLINK Standardisation Group|local=Berlin|url=http://www.ethernet-powerlink.org/en/downloads/technical-documents/action/open-download/download/epsg-wdp-304-v-1-4-0/?no_cache=1|seção=5.1.1.8 Cyclic Redundancy Check field (CRC-8 / CRC-16)|página=42|acessodata=22 de julho de 2016}}</ref>
|0x2F
|0xF4
|0x97<ref name="koop042" />
|-
|CRC-8-[[wikipedia:Bluetooth|Bluetooth]]
|Conectividade Wireless<ref name="core-4.2">{{citar livro|título=Specification of the Bluetooth System|volume=2|seção=B.7.1.1 HEC generation|páginas=144–5|publicado=Bluetooth SIG|data=2 de dezembro de 2014|url=https://www.bluetooth.org/DocMan/handlers/DownloadDoc.ashx?doc_id=286439|acessodata=20 de outubro de 2014}}</ref>
|0xA7
|0xE5
|0xD3
|-
|CRC-8-[[wikipedia:CCITT|CCITT]]
|[http://www.itu.int/rec/T-REC-I.432.1-199902-I/en I.432.1]; [[wikipedia:Asynchronous_Transfer_Mode|ATM]] [[wikipedia:CRC-based_framing|HEC]], [[wikipedia:ISDN|ISDN]] HEC e fronteiras de células
|0x07
|0xE0
|0x83
|-
|CRC-8-[[wikipedia:Dallas_Semiconductor|Dallas]]/[[wikipedia:Maxim_Integrated_Products|Maxim]]
|[[wikipedia:1-Wire|1-Wire]] [[wikipedia:Bus_(computing)|bus]]
|0x31
|0x8C
|0x98
|-
|CRC-8-DARC
|[[wikipedia:Data_Radio_Channel|Canal de Dados via Rádio]]<ref name="en-300-751" />
|0x39
|0x9C
|0x9C
|-
|CRC-8-[[wikipedia:GSM|GSM]]-B
|redes móveis<ref name="ts-100-909" />
|0x49
|0x92
|0xA4
|-
|CRC-8-[[wikipedia:SAE_J1850|SAE J1850]]
|[[wikipedia:AES3|AES3]]
|0x1D
|0xB8
|0x8E
|-
|CRC-8-[[wikipedia:W-CDMA_(UMTS)|WCDMA]]
|redes móveis<ref name="cdma2000-spec" /><ref name="richardson-wcdma">{{citar livro|último =Richardson|primeiro =Andrew|título=WCDMA Handbook|local=Cambridge, UK|publicado=Cambridge University Press|data=17 de março de 2005|isbn=0-521-82815-5|página=223|url=https://books.google.com/books?id=yN5lve5L4vwC&lpg=PA223&dq=&pg=PA223#v=onepage&q&f=false}}</ref>
|0x9B
|0xD9
|0xCD<ref name="koop042" />
|-
|CRC-10
|ATM; [http://www.itu.int/rec/T-REC-I.610/en I.610]
|0x233
|0x331
|0x319
|-
|CRC-10-[[wikipedia:CDMA2000|CDMA2000]]
|redes móveis<ref name="cdma2000-spec" />
|0x3D9
|0x26F
|0x3EC
|-
|CRC-10-[[wikipedia:GSM|GSM]]
|redes móveis<ref name="ts-100-909" />
|0x175
|0x2BA
|0x2BA
|-
|CRC-11
|[[wikipedia:FlexRay|FlexRay]]<ref name="flexray-spec">{{citar livro|título=FlexRay Protocol Specification|versão=3.0.1|publicado=Flexray Consortium|data=outubro de 2010|página=114}} (4.2.8 Header CRC (11 bits))</ref>
|0x385
|0x50E
|0x5C2
|-
|CRC-12
|sistemas de telecomunicação<ref>{{citar periódico|último =Perez|primeiro =A.|título=Byte-Wise CRC Calculations|periódico=IEEE Micro|volume=3|número=3|páginas=40–50|ano=1983|doi=10.1109/MM.1983.291120}}</ref><ref>{{citar periódico|último =Ramabadran|primeiro =T.V.|último2 =Gaitonde|primeiro2 =S.S.|título=A tutorial on CRC computations|periódico=IEEE Micro|volume=8|número=4|ano=1988|páginas=62–75|doi=10.1109/40.7773}}</ref>
|0x80F
|0xF01
|0xC07<ref name="koop042" />
|-
|CRC-12-[[wikipedia:CDMA2000|CDMA2000]]
|redes móveis<ref name="cdma2000-spec" />
|0xF13
|0xC8F
|0xF89
|-
|CRC-12-[[wikipedia:GSM|GSM]]
|redes móveis<ref name="ts-100-909" />
|0xD31
|0x8CB
|0xE98
|-
|CRC-13-BBC
|Sinal Temporizado, [[wikipedia:Radio_teleswitch|Radio teleswitch]]<ref>{{citar livro|último =Ely|primeiro =S.R.|último2 =Wright|primeiro2 =D.T.|título=L.F. Radio-Data: specification of BBC experimental transmissions 1982|publicado=Research Department, Engineering Division, The British Broadcasting Corporation|data=março de 1982|página=9|url=http://downloads.bbc.co.uk/rd/pubs/reports/1982-02.pdf|acessodata=11 de outubro de 2013}}</ref>
|0x1CF5
|0x15E7
|0x1E7A
|-
|CRC-14-DARC
|[[wikipedia:Data_Radio_Channel|Canal de Dados via Rádio]]<ref name="en-300-751" />
|0x0805
|0x2804
|0x2402
|-
|CRC-14-[[wikipedia:GSM|GSM]]
|redes móveis<ref name="ts-100-909" />
|0x202D
|0x2D01
|0x3016
|-
|CRC-15-[[wikipedia:Controller_Area_Network|CAN]]
|
|0x4599<ref name="cypress-psoc">{{citar livro|data=20 de fevereiro de 2013|instituição=Cypress Semiconductor|título=Cyclic Redundancy Check (CRC): PSoC Creator™ Component Datasheet|página=4|url=http://www.cypress.com/file/128066/download|acessodata=26 de janeiro de 2016}}</ref><ref name="cia-can-crc">{{citar web|url=http://www.can-cia.org/can-knowledge/can/crc/|título=Cyclic redundancy check (CRC) in CAN frames|acessodata=26 de janeiro de 2016|website=CAN in Automation}}</ref>
|0x4CD1
|0x62CC
|-
|CRC-15-[[wikipedia:MPT1327|MPT1327]]
|<ref name="mpt1327">{{citar livro|data=junho de 1997|título=A signalling standard for trunked private land mobile radio systems (MPT 1327)|edição=3rd|publicado=[[Ofcom]]|seção=3.2.3 Encoding and error checking|página=3-3|url=http://www.ofcom.org.uk/static/archive/ra/publication/mpt/mpt_pdf/mpt1327.pdf|acessodata=16 de julho de 2012}}</ref>
|0x6815
|0x540B
|0x740A
|-
|CRC-16-Chakravarty
|Otimizado para mensagens ≤64 bits<ref name="chakravarty-thesis" />
|0x2F15
|0xA8F4
|0x978A
|-
|CRC-16-[[wikipedia:ARINC|ARINC]]
|[[wikipedia:Aircraft_Communications_Addressing_and_Reporting_System|ACARS]] aplicações<ref name="rehmann-acars">{{citar periódico|url=http://ntl.bts.gov/lib/1000/1200/1290/tn95_66.pdf|título=Air Ground Data Link VHF Airline Communications and Reporting System (ACARS) Preliminary Test Report|data=fevereiro de 1995|página=5|último1 =Rehmann|primeiro1 =Albert|último2 =Mestre|primeiro2 =José D.|publicado=Federal Aviation Authority Technical Center|acessodata=7 de julho de 2012}}</ref>
|0xA02B
|0xD405
|0xD015
|-
|CRC-16-CCITT
|[[wikipedia:X.25|X.25]], [[wikipedia:V.41|V.41]], [[wikipedia:HDLC|HDLC]] ''FCS'', [[wikipedia:XMODEM|XMODEM]], [[wikipedia:Bluetooth|Bluetooth]], [[wikipedia:PACTOR|PACTOR]], [[wikipedia:Secure_Digital_card|SD]], [[wikipedia:DigRF|DigRF]], Vários outros; conhecido como ''CRC-CCITT''
|0x1021
|0x8408
|0x8810<ref name="koop042" />
|-
|CRC-16-[[wikipedia:CDMA2000|CDMA2000]]
|redes móveis<ref name="cdma2000-spec" />
|0xC867
|0xE613
|0xE433
|-
|CRC-16-[[wikipedia:Digital_Enhanced_Cordless_Telecommunications|DECT]]
|Telefones Sem Fio<ref name="en-300-175-3">{{citar livro|título=ETSI EN 300 175-3|versão=V2.5.1|data=agosto de 2013|publicado=European Telecommunications Standards Institute|local=Sophia Antipolis, France|url=http://www.etsi.org/deliver/etsi_en/300100_300199/30017503/02.05.01_60/en_30017503v020501p.pdf|seção=6.2.5 Error control|páginas=99,101|acessodata=26 de janeiro de 2016}}</ref>
|0x0589
|0x91A0
|0x82C4
|-
|CRC-16-[[wikipedia:International_Committee_for_Information_Technology_Standards|T10]]-[[wikipedia:Data_Integrity_Field|DIF]]
|[[wikipedia:SCSI|SCSI]] DIF
|0x8BB7<ref name="thaler-t10-selection">{{citar periódico|último =Thaler|primeiro =Pat|título=16-bit CRC polynomial selection|publicado=INCITS T10|data=28 de agosto de 2003|url=http://www.t10.org/ftp/t10/document.03/03-290r0.pdf|acessodata=11 de agosto de 2009}}</ref>
|0xEDD1
|0xC5DB
|-
|CRC-16-[[wikipedia:DNP3|DNP]]
|DNP, [[wikipedia:IEC_60870-5|IEC 870]], [[wikipedia:Meter-Bus|M-Bus]]
|0x3D65
|0xA6BC
|0x9EB2
|-
|CRC-16-[[wikipedia:IBM|IBM]]
|[[wikipedia:Binary_Synchronous_Communications|Bisync]], [[wikipedia:Modbus|Modbus]], [[wikipedia:Universal_Serial_Bus|USB]], [[wikipedia:ANSI|ANSI]] [http://www.incits.org/press/1997/pr97020.htm X3.28], SIA DC-07, Vários outros; também conhecido como ''CRC-16'' e ''CRC-16-ANSI''
|0x8005
|0xA001
|0xC002
|-
|CRC-16-[[wikipedia:OpenSafety|OpenSafety]]-A
|bateria de testes seguros<ref name="opensafety-profile" />
|0x5935
|0xAC9A
|0xAC9A<ref name="koop042" />
|-
|CRC-16-[[wikipedia:OpenSafety|OpenSafety]]-B
|bateria de testes seguros<ref name="opensafety-profile" />
|0x755B
|0xDAAE
|0xBAAD<ref name="koop042" />
|-
|CRC-16-[[wikipedia:Profibus|Profibus]]
|redes de testes seguros<ref name="profibus-spec">{{citar livro|título=PROFIBUS Specification Normative Parts|versão=1.0|publicado=Profibus International|data=março de 1998|volume=9|seção=8.8.4 Check Octet (FCS)|página=906|url=https://www.kuebler.com/PDFs/Feldbus_Multiturn/specification_DP.pdf|acessodata=9 de julho de 2016}}</ref>
|0x1DCF
|0xF3B8
|0x8EE7
|-
|CRC-17-CAN
|CAN FD<ref name="can-fd-spec">{{citar livro|título=CAN with Flexible Data-Rate Specification|versão=1.0|publicado=Robert Bosch GmbH|data=17 de abril de 2012|página=13|url=http://www.bosch-semiconductors.de/media/pdf_1/canliteratur/can_fd_spec.pdf|deadurl=yes|arquivourl=https://web.archive.org/web/20130822124728/http://www.bosch-semiconductors.de/media/pdf_1/canliteratur/can_fd_spec.pdf|arquivodata=22 de agosto de 2013|df=dmy-all}} (3.2.1 DATA FRAME)</ref>
|0x1685B
|0x1B42D
|0x1B42D
|-
|CRC-21-CAN
|CAN FD<ref name="can-fd-spec" />
|0x102899
|0x132281
|0x18144C
|-
|CRC-24
|[[wikipedia:FlexRay|FlexRay]]<ref name="flexray-spec" />
|0x5D6DCB
|0xD3B6BA
|0xAEB6E5
|-
|CRC-24-[[wikipedia:Radix-64|Radix-64]]
|[[wikipedia:Pretty_Good_Privacy#OpenPGP|OpenPGP]], [[wikipedia:RTCM|RTCM104v3]]
|0x864CFB
|0xDF3261
|0xC3267D
|-
|CRC-30
|[[wikipedia:CDMA|CDMA]]
|0x2030B9C7
|0x38E74301
|0x30185CE3
|-
|CRC-32
|[[wikipedia:High-Level_Data_Link_Control|HDLC]], [[wikipedia:ANSI|ANSI]] X3.66 ([[wikipedia:ADCCP|ADCCP]]), ITU-T [[wikipedia:V.42|V.42]], ISO/IEC/IEEE 8802-3 ([[wikipedia:Ethernet|Ethernet]]), [[wikipedia:Serial_ATA|Serial ATA]], [[wikipedia:MPEG-2|MPEG-2]], [[wikipedia:PKZIP|PKZIP]], [[wikipedia:Gzip|Gzip]], [[wikipedia:Bzip2|Bzip2]], [[wikipedia:POSIX|POSIX]] [[wikipedia:Cksum|cksum]],<ref>http://pubs.opengroup.org/onlinepubs/9699919799/utilities/cksum.html</ref> [[wikipedia:Portable_Network_Graphics|PNG]],<ref>{{citar web|último =Boutell|primeiro =Thomas|último2 =Randers-Pehrson|primeiro2 =Glenn|data=14 de julho de 1998|título=PNG (Portable Network Graphics) Specification, Version 1.2|url=http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html|publicado=Libpng.org|acessodata=3 de fevereiro de 2011|display-authors=etal}}</ref> Vários outros
|0x04C11DB7
|0xEDB88320
|0x82608EDB<ref name="koop022">{{citar periódico|último =Koopman|primeiro =Philip|título=32-Bit Cyclic Redundancy Codes for Internet Applications|periódico=The International Conference on Dependable Systems and Networks|data=julho de 2002 <!-- date from http://www.ece.cmu.edu/~koopman/pubs.html -->|url=http://www.ece.cmu.edu/~koopman/networks/dsn02/dsn02_koopman.pdf|acessodata=14 de janeiro de 2011|páginas=459–468|doi=10.1109/DSN.2002.1028931|isbn=0-7695-1597-5}}</ref>
|-
|CRC-32C (Castagnoli)
|[[wikipedia:ISCSI|iSCSI]], [[wikipedia:SCTP|SCTP]], [[wikipedia:G.hn|G.hn]] payload, [[wikipedia:SSE4#SSE4.2|SSE4.2]], [[wikipedia:Btrfs|Btrfs]], [[wikipedia:Ext4|ext4]], [[wikipedia:Ceph_(software)|Ceph]]
|0x1EDC6F41
|0x82F63B78
|0x8F6E37A0<ref name="koop022" />
|-
|CRC-32K (Koopman {1,3,28})
|
|0x741B8CD7
|0xEB31D82E
|0xBA0DC66B<ref name="koop022" />
|-
|CRC-32K<sub>2</sub> (Koopman {1,1,30})
|
|0x32583499
|0x992C1A4C
|0x992C1A4C<ref name="koop022" />
|-
|CRC-32Q
|aviação; [[wikipedia:AIXM|AIXM]]<ref name="aixm-primer">{{citar livro|título=AIXM Primer|url=http://www.eurocontrol.int/sites/default/files/content/documents/information-management/20060320-aixm-primer.pdf|versão=4.5|publicado=[[European Organisation for the Safety of Air Navigation]]|data=20 de março de 2006|acessodata=4 de julho de 2012}}</ref>
|0x814141AB
|0xD5828281
|0xC0A0A0D5
|-
|CRC-40-[[wikipedia:GSM|GSM]]
|Canal de Controle GSM<ref name="gammel">{{citar livro|último =Gammel|primeiro =Berndt M.|data=31 de outubro de 2005|título=Matpack documentation: Crypto - Codes <!-- |unusedurl=http://users.physik.tu-muenchen.de/gammel/matpack/html/LibDoc/Crypto/MpCRC.html long-time home, gone-->|url=http://www.matpack.de/index.html#DOWNLOAD|publicado=Matpack.de|acessodata=21 de abril de 2013}} (Note: MpCRC.html is included with the Matpack compressed software source code, under /html/LibDoc/Crypto)</ref><ref name="geremia">{{citar periódico|último =Geremia|primeiro =Patrick|data=abril de 1999|título=Cyclic redundancy check computation: an implementation using the TMS320C54x|número=SPRA530|publicado=Texas Instruments|página=5|url=http://www.ti.com/lit/an/spra530/spra530.pdf|acessodata=4 de julho de 2012}}</ref>
|0x0004820009
|0x9000412000
|0x8002410004
|-
|CRC-64-[[wikipedia:Ecma_International|ECMA]]
|[http://www.ecma-international.org/publications/standards/Ecma-182.htm ECMA-182], [[wikipedia:XZ_Utils|XZ Utils]]
|0x42F0E1EBA9EA3693
|0xC96C5795D7870F42
|0xA17870F5D4F51B49
|-
|CRC-64-ISO
|[[wikipedia:High-Level_Data_Link_Control|HDLC]], [[wikipedia:Swiss-Prot|Swiss-Prot]]/[[wikipedia:TrEMBL|TrEMBL]]; considerado fraco para hashing<ref name="jones-improved64">{{citar periódico|último =Jones|primeiro =David T.|título=An Improved 64-bit Cyclic Redundancy Check for Protein Sequences|publicado=University College London|url=http://www.cs.ucl.ac.uk/staff/d.jones/crcnote.pdf|acessodata=15 de dezembro de 2009}}<!-- date of PDF=1 Dec 2009; date of referenced C file=2 Mar 2006; date in C file comments=28 Sep 2002 --></ref>
|0x000000000000001B
|0xD800000000000000
|0x800000000000000D
|}

== Ver também ==
* [[Detecção e correção de erros#Redundância cíclica (CRC)]]

== Referências ==
<references />

== Ligações externas ==
{{refbegin|}}*{{citar periódico|data=Dezembro de 2013|primeiro =Rodrigo Maximiano Antunes de|último =Almeida|título=Troca de contexto segura em sistemas operacionais embarcados utilizando técnicas de detecção e correção de erros|url=https://saturno.unifei.edu.br/bim/0043798.pdf}}Exemplos e análises sobre o comportamento de códigos CRC e de Hamming aplicado à embarcados
*{{citar periódico|primeiro =Jubin|último =Mitra|primeiro2 =Tapan|último2 =Nayak|título=Reconfigurable very high throughput low latency VLSI (FPGA) design architecture of CRC 32|periódico=Integration, the VLSI Journal|volume=56|número=|páginas=1–14|data=Janeiro de 2017|doi=10.1016/j.vlsi.2016.09.005|url=http://www.sciencedirect.com/science/article/pii/S0167926016300669|via=}}
* [http://www.mathpages.com/home/kmath458.htm Cyclic Redundancy Checks], MathPages, visão geral da detecção de erro de alguns polinômios
*{{citar web|primeiro =Ross|último =Williams|título=A Painless Guide to CRC Error Detection Algorithms|data=1993|obra=The Blue Book|publicado=Systems Research Group, Computer Laboratory, University of Cambridge|url=http://www.ross.net/crc/crcpaper.html|acessodata=|arquivourl=|arquivodata=|dead-url=}}
*{{citar web|primeiro =Richard|último =Black|título=Fast CRC32 in Software|data=1994|obra=The Blue Book|publicado=|url=http://www.cl.cam.ac.uk/Research/SRG/bluebook/21/crc/crc.html|acessodata=|arquivourl=|arquivodata=|dead-url=}}algoritmo 4 é usado em Linux e Bzip2.
*{{citar web|último =Kounavis|primeiro =M.|último2 =Berry|primeiro2 =F.|título=A Systematic Approach to Building High Performance, Software-based, CRC generators|ano=2005|publicado=Intel|url=http://www.intel.com/technology/comms/perfnet/download/CRC_generators.pdf|data=|acessodata=|website=|arquivourl=|arquivodata=|dead-url=}}, algoritmos de corte por 4 e 8 *{{citar web|primeiro =W.|último =Kowalk|título=CRC Cyclic Redundancy Check Analysing and Correcting Errors|data=Agosto de 2006|publicado=Universität Oldenburg|url=http://einstein.informatik.uni-oldenburg.de/papers/CRC-BitfilterEng.pdf|formato=PDF|acessodata=|website=|arquivourl=|arquivodata=|dead-url=}} — filtros de bit
*{{citar livro|primeiro =Henry S., Jr.|último =Warren|capítulo=Cyclic Redundancy Check|título=[[Hacker's Delight]]|publicado=|capítulourl=http://www.hackersdelight.org/crc.pdf|formato=PDF|ano=|isbn=|local=|páginas=}} — teoria, prática, hardware e software com enfase no CRC-32.
*[http://www.cosc.canterbury.ac.nz/greg.ewing/essays/CRC-Reverse-Engineering.html Reverse-Engineering a CRC Algorithm]
*{{citar web|primeiro =Greg|último =Cook|título=Catalogue of parameterised CRC algorithms|data=|obra=CRC RevEng|url=http://reveng.sourceforge.net/crc-catalogue/all.htm|acessodata=|arquivourl=|arquivodata=|dead-url=|publicado=}}
*{{citar web|último =Koopman|primeiro =Phil|título=Blog: Checksum and CRC Central|url=http://checksumcrc.blogspot.com/|data=|acessodata=|website=|arquivourl=|arquivodata=|dead-url=|publicado=}} — inclui links para PDFs sobre 16 e 32-bit CRC [[Distância de Hamming]]
*{{citar web|primeiro =Philip|último =Koopman|primeiro2 =Kevin|último2 =Driscoll|primeiro3 =Brendan|último3 =Hall|título=Cyclic Redundancy Code and Checksum Algorithms to Ensure Critical Data Integrity|data=Março de 2015|id=DOT/FAA/TC-14/49|publicado=Federal Aviation Administration|url=http://www.tc.faa.gov/its/worldpac/techrpt/tc14-49.pdf|formato=PDF|acessodata=|website=|arquivourl=|arquivodata=|dead-url=}}
{{refend}}


== Ver também ==
* [[Tolerância a Falhas]]
* [[Falha (computação)]]
* [[TMR]]
[[Categoria:Algoritmos]]
{{DEFAULTSORT:Verificacao Ciclica de Redundancia}}