El Código de Redundancia Cíclica (CRC) es un método de verificación de

errores utilizado en redes y dispositivos de almacenamiento para

detectar cambios accidentales en los datos. Es una técnica que se basa
en la teoría de la división polinómica y se utiliza para asegurar la
integridad de los datos transmitidos o almacenados.

### ¿Cómo funciona el CRC?

El CRC se calcula mediante un algoritmo que trata los datos como un

gran número binario. Este número se divide por un polinomio generador
predefinido, y el residuo de esta división es el CRC. Este residuo se
adjunta a los datos originales antes de la transmisión o almacenamiento.
Cuando los datos se reciben o se leen, se realiza la misma operación de
división. Si el residuo calculado coincide con el CRC recibido, se asume
que los datos no han sido alterados.

### Aplicaciones del CRC

El CRC se utiliza en diversas aplicaciones, incluyendo:

- **Redes de comunicación**: Para detectar errores en los datos

transmitidos a través de redes.

- **Dispositivos de almacenamiento**: Para asegurar la integridad de los

datos almacenados en discos duros, CDs, DVDs, etc.

- **Protocolos de comunicación**: Como el protocolo Modbus, que utiliza

CRC para verificar la integridad de los mensajes.

### Ventajas y Limitaciones

**Ventajas**:

- **Eficiencia**: El cálculo del CRC es rápido y eficiente, lo que lo hace

adecuado para aplicaciones en tiempo real.
- **Detección de errores**: Es muy efectivo para detectar errores
comunes en la transmisión de datos, como bits invertidos o perdidos.

**Limitaciones**:

- **No corrige errores**: El CRC solo detecta errores, pero no puede

corregirlos.

- **Colisiones**: Aunque es raro, es posible que diferentes datos generen

el mismo CRC, lo que se conoce como colisión.

### Ejemplo de Cálculo del CRC

Supongamos que tenemos un mensaje de datos y un polinomio

generador. El proceso de cálculo del CRC sería el siguiente:

1. **Inicialización**: Se carga un registro de 16 bits con todos unos (FFFF

en hexadecimal).

2. **División**: Se realiza una división binaria del mensaje por el

polinomio generador.

3. **Residuo**: El residuo de esta división es el CRC, que se adjunta al

final del mensaje.

El CRC es una herramienta fundamental en la detección de errores en la

transmisión y almacenamiento de datos, proporcionando una capa
adicional de seguridad y confiabilidad en los sistemas de comunicación y
almacenamiento.

Espero que esta explicación te haya sido útil. ¿Hay algo más que te
gustaría saber sobre el CRC o algún otro tema?
¡Absolutamente! Elaborar un ensayo sobre el código de redundancia
cíclica (CRC) es una excelente manera de profundizar en esta importante
herramienta de detección de errores en redes. Aquí te presento una
estructura y algunos puntos clave que puedes considerar para tu
ensayo:

Ensayo: Código de Redundancia Cíclica (CRC)

Introducción

 Definición: Inicia definiendo qué es un CRC de manera clara y

concisa. Explica que es una técnica matemática utilizada para
detectar errores en la transmisión de datos.

 Importancia: Resalta la importancia del CRC en la comunicación

digital, donde la integridad de los datos es crucial. Menciona
algunos ejemplos de aplicaciones donde se utiliza el CRC, como en
redes de computadoras, almacenamiento de datos y protocolos de
comunicación.

 Objetivo del ensayo: Indica claramente cuál será el enfoque

principal del ensayo. Por ejemplo, puedes optar por explicar el
funcionamiento del CRC en detalle, comparar diferentes tipos de
CRC o analizar su eficiencia en distintos escenarios.

Funcionamiento del CRC

 Conceptos básicos: Explica los conceptos fundamentales que

sustentan el CRC:

o Polinomio generador: Describe qué es un polinomio

generador y cómo se utiliza en el cálculo del CRC.

o División binaria: Explica el proceso de división binaria, que

es la base del cálculo del CRC.

o Resto de la división: Indica que el resto de la división binaria

es el valor CRC que se adjunta a los datos originales.

 Proceso de cálculo: Describe paso a paso cómo se calcula el CRC:

o Adición de bits de relleno.

o División binaria.

o Obtención del CRC.

  Verificación del CRC: Explica cómo se verifica el CRC en el receptor
para detectar posibles errores en los datos.

Tipos de CRC y sus aplicaciones

 Diferentes estándares: Presenta los diferentes estándares de CRC

que existen (CRC-8, CRC-16, CRC-32, etc.) y menciona las
aplicaciones típicas de cada uno.

 Polinomios generadores: Explica cómo la elección del polinomio

generador afecta a la capacidad de detección de errores del CRC.

 Comparación de rendimiento: Realiza una breve comparación de

los diferentes tipos de CRC en términos de eficiencia y capacidad
de detección de errores.

Ventajas y desventajas del CRC

 Ventajas:

o Detección de errores: Resalta la capacidad del CRC para

detectar una amplia variedad de errores de transmisión.

o Sencillez de implementación: Menciona que el CRC es

relativamente fácil de implementar tanto en hardware como
en software.

o Eficiencia: Indica que el CRC es un método eficiente para

detectar errores, con un bajo sobrecarga en términos de
datos adicionales.

 Desventajas:

o Solo detección: Señala que el CRC solo permite detectar

errores, pero no corregirlos.

o Limitaciones en la detección de ciertos tipos de errores:

Explica que el CRC puede no detectar todos los posibles
patrones de error.

Conclusiones

 Resumen de los principales puntos: Recapitula los aspectos más

importantes del CRC que se han tratado en el ensayo.

 Importancia del CRC en la comunicación digital: Reenfatiza la

relevancia del CRC en la comunicación digital actual.
  Posibles desarrollos futuros: Menciona algunas áreas de
investigación o aplicaciones futuras relacionadas con el CRC.

Consejos adicionales:

 Ejemplos prácticos: Incluye ejemplos concretos para ilustrar los

conceptos teóricos.

 Gráficos y diagramas: Utiliza diagramas de flujo o ilustraciones

para facilitar la comprensión del proceso de cálculo del CRC.

 Referencias: Cita las fuentes utilizadas para realizar el ensayo.

Temas adicionales que puedes explorar:

 CRC y códigos correctores de errores: Compara el CRC con otros

códigos de detección y corrección de errores.

 CRC y seguridad de la información: Analiza el papel del CRC en la

detección de ataques a la integridad de los datos.

 Implementación del CRC en diferentes protocolos de

comunicación: Explora cómo se utiliza el CRC en protocolos como
Ethernet, TCP/IP, etc.

Espero que esta estructura te sea útil para elaborar tu ensayo sobre el
CRC. ¡No dudes en preguntar si tienes alguna otra duda!
¡Claro! Con gusto te explico qué es un CRC.

CRC son las siglas de Verificación de Redundancia Cíclica (en inglés, Cyclic
Redundancy Check). Es un método matemático utilizado para detectar errores en
la transmisión de datos. Imagina que estás enviando un mensaje por un canal
ruidoso, como una línea telefónica o una conexión a internet. Es posible que
algunos bits del mensaje se alteren durante el camino, lo que podría cambiar el
significado del mensaje.
¿Cómo funciona?
1. Cálculo del CRC:
o El emisor trata los datos como un número binario (una secuencia de
ceros y unos).

o Divide ese número entre un número divisor preestablecido (llamado

polinomio generador).

o El resto de esa división se añade al final de los datos originales. Este

resto es el CRC.

2. Transmisión:
o El mensaje original junto con el CRC se envía al receptor.

3. Verificación:
o El receptor realiza la misma división usando el mismo polinomio
generador.

o Si el resto de la división es cero, significa que los datos no se han

corrompido durante la transmisión. Si el resto es diferente de cero,
se detecta un error.

¿Para qué sirve?

 Detección de errores: Es muy efectivo para detectar errores comunes en la
transmisión de datos, como cambios en un solo bit o ráfagas de errores.
 Integridad de datos: Garantiza que los datos recibidos sean los mismos que
los enviados.
  Ampliamente utilizado: Se emplea en redes, almacenamiento de datos,
comunicaciones digitales, etc.


Ejemplo simple:
Imagina que quieres enviar el número binario 1101011. El
polinomio generador es 1011. Realizas la división y
obtienes un resto de 101. Añades este resto al mensaje
original, obteniendo 1101011101. El receptor realiza la
división y, si obtiene un resto de cero, confirma que los
datos son correctos.

En resumen, el CRC es como un código de barras que se

añade a los datos para verificar su integridad. Es una
herramienta fundamental para garantizar la fiabilidad de
la transmisión de información digital.
¿Tienes alguna otra pregunta sobre el CRC? Por ejemplo,
puedo explicarte con más detalle cómo se calcula el
polinomio generador o cómo se utilizan los CRC en
protocolos de comunicación específicos.
Comprobación de
redundancia cíclica de 16
bits
CRC16-CCITT es una verificación de redundancia cíclica (CRC) de 16 bits1. Se
utiliza para la detección de errores en la transmisión de datos. El algoritmo
CRC16-CCITT calcula una suma de comprobación única para un conjunto de
datos determinado2. El polinomio utilizado es x^16 + x^15 + x^2 + 1 3. Detecta
errores simples, errores de doble bit y errores con ráfagas de menos de 16 bits de
lon
Una comprobación de redundancia cíclica (CRC) es un código de
detección de errores comúnmente utilizado en redes digitales y
dispositivos de almacenamiento para detectar cambios accidentales en
los datos digitales. Los bloques de datos que ingresan a estos sistemas
obtienen un breve valor de verificación adjunto, basado en el resto de
una división polinomial de sus contenidos. En la recuperación, el cálculo
se repite y, en caso de que los valores de verificación no coincidan, se
pueden tomar medidas correctivas contra la corrupción de datos. Los
CRC se pueden utilizar para la corrección de errores (ver filtros de bits).

Los CRC se denominan así porque el valor check (verificación de datos)

es una redundancia (amplía el mensaje sin agregar información) y el
algoritmo se basa en códigos cíclicos. Los CRC son populares porque son
fáciles de implementar en hardware binario, fáciles de analizar
matemáticamente y particularmente buenos para detectar errores
comunes causados por el ruido en los canales de transmisión. Debido a
que el valor de verificación tiene una longitud fija, la función que lo
genera se usa ocasionalmente como una función hash.

Introducción

Los CRC se basan en la teoría de los códigos de corrección de errores

cíclicos. W. Wesley Peterson propuso por primera vez en 1961 el uso de
códigos cíclicos sistemáticos, que codifican mensajes agregando un
valor de verificación de longitud fija, con el fin de detectar errores en las
redes de comunicación. Los códigos cíclicos no solo son fáciles de
implementar, sino que tienen la ventaja de ser particularmente
adecuados para la detección de errores de ráfaga: secuencias contiguas
de símbolos de datos erróneos en los mensajes. Esto es importante
porque los errores de ráfaga son errores de transmisión comunes en
muchos canales de comunicación, incluidos los dispositivos de
almacenamiento óptico y magnético. Por lo general, un CRC de n bits
aplicado a un bloque de datos de longitud arbitraria detectará cualquier
ráfaga de error única que no supere los n bits, y la fracción de todas las
ráfagas de error más largas que detectará es (1 − 2−n).

La especificación de un código CRC requiere la definición de un llamado

polinomio generador. Este polinomio se convierte en el divisor en una
división larga de polinomios, que toma el mensaje como dividendo y en
la que se descarta el cociente y el resto se convierte en el resultado. La
advertencia importante es que los coeficientes polinómicos se calculan
de acuerdo con la aritmética de un campo finito, por lo que la operación
de suma siempre se puede realizar en paralelo bit a bit (no hay acarreo
entre dígitos).

En la práctica, todos los CRC de uso común emplean el campo de Galois,

o más simplemente un campo finito, de dos elementos, GF(2). Los dos
elementos generalmente se denominan 0 y 1, y coinciden cómodamente
con la arquitectura de la computadora.

Un CRC se denomina CRC de n bits cuando su valor de comprobación

tiene una longitud de n bits. Para un n dado, son posibles varios CRC,
cada uno con un polinomio diferente. Dicho polinomio tiene el grado más
alto n, lo que significa que tiene términos n + 1. En otras palabras, el
polinomio tiene una longitud de n + 1; su codificación requiere n +
1 bits. Tenga en cuenta que la mayoría de las especificaciones de
polinomios eliminan el MSB o el LSB, ya que siempre son 1. El CRC y el
polinomio asociado suelen tener un nombre de la forma CRC-n-XXX
como se muestra en la siguiente tabla.

El sistema de detección de errores más simple, el bit de paridad, es de

hecho un CRC de 1 bit: utiliza el polinomio generador x + 1 (dos
términos), y tiene el nombre CRC-1.

Solicitud

Un dispositivo habilitado para CRC calcula una secuencia binaria corta

de longitud fija, conocida como valor de verificación o CRC, para cada
bloque de datos que se enviará o almacenará y lo agrega a los datos,
formando una palabra clave.

Cuando se recibe o lee una palabra clave, el dispositivo compara su

valor de verificación con uno recién calculado a partir del bloque de
datos o, de manera equivalente, realiza un CRC en toda la palabra clave
y compara el valor de verificación resultante con un residuo
esperado constante.

Si los valores de CRC no coinciden, el bloque contiene un error de datos.

El dispositivo puede tomar medidas correctivas, como volver a leer el

bloque o solicitar que se envíe de nuevo. De lo contrario, se supone que
los datos están libres de errores (aunque, con una pequeña probabilidad,
pueden contener errores no detectados; esto es inherente a la
naturaleza de la verificación de errores).

Integridad de datos
Los CRC están diseñados específicamente para brindar protección contra
tipos comunes de errores en los canales de comunicación, donde pueden
brindar una garantía rápida y razonable de la integridad de los mensajes
entregados. Sin embargo, no son adecuados para la protección contra la
alteración intencional de datos.

En primer lugar, como no hay autenticación, un atacante puede editar

un mensaje y volver a calcular el CRC sin que se detecte la sustitución.
Cuando se almacenan junto con los datos, los CRC y las funciones hash
criptográficas por sí mismos no protegen contra la
modificación intencional de los datos. Cualquier aplicación que requiera
protección contra este tipo de ataques debe utilizar mecanismos de
autenticación criptográficos, como códigos de autenticación de
mensajes o firmas digitales (que comúnmente se basan en funciones
hash criptográficas).

En segundo lugar, a diferencia de las funciones hash criptográficas, CRC

es una función fácilmente reversible, lo que la hace inadecuada para su
uso en firmas digitales.

En tercer lugar, CRC satisface una relación similar a la de una función

lineal (o más exactamente, una función afín):

Donde depende de la longitud y . Esto también se puede

decir de la siguiente manera: , y tienen la misma longitud

como resultado, incluso si el CRC se cifra con un cifrado de flujo que usa
XOR como su operación de combinación (o un modo de cifrado de
bloque que lo convierte efectivamente en un cifrado de flujo, como OFB
o CFB), tanto el mensaje como el CRC asociado puede manipularse sin
conocimiento de la clave de cifrado; este fue uno de los defectos de
diseño más conocidos del protocolo de privacidad equivalente por cable
(WEP).

Cálculo

Para calcular un CRC binario de n bits, alinee los bits que representan la
entrada en una fila y coloque (n + Patrón de 1 bit que representa el
divisor del CRC (llamado "polinomio") debajo del extremo izquierdo de la
fila.

En este ejemplo, codificaremos 14 bits de mensaje con un CRC de 3 bits,

con un polinomio x3 + x + 1. El polinomio se escribe en binario como los
coeficientes; un polinomio de tercer grado tiene 4 coeficientes (1x3 +
0x2 + 1x + 1). En este caso, los coeficientes son 1, 0, 1 y 1. El resultado
del cálculo tiene una longitud de 3 bits, por lo que se denomina CRC de
3 bits. Sin embargo, necesita 4 bits para indicar explícitamente el
polinomio.

Comience con el mensaje a codificar:

11010011101100

Esto se rellena primero con ceros correspondientes a la longitud de

bit n del CRC. Esto se hace para que la palabra de código resultante esté
en forma sistemática. Aquí está el primer cálculo para calcular un CRC
de 3 bits:

11010011101100 000 --- entrada derecho acolchado por 3 bits

1011 ---- divisor (4 bits) = x3 + x + 1

- Sí.

01100011101100 000

El algoritmo actúa sobre los bits directamente encima del divisor en

cada paso. El resultado de esa iteración es el XOR bit a bit del divisor
polinomial con los bits encima. Los bits que no están arriba del divisor
simplemente se copian directamente debajo para ese paso. Luego, el
divisor se desplaza a la derecha para alinearse con el bit restante más
alto en la entrada, y el proceso se repite hasta que el divisor alcanza el
extremo derecho de la fila de entrada. Aquí está el cálculo completo:

11010011101100 000 --- entrada derecho acolchado por 3 bits

1011 - Divisor

01100011101100 000 - resultado (nota los primeros cuatro bits son el

XOR con el divisor debajo, el resto de los bits no se cambian)

1011 - Divisor...

00111011101100 000

1011
000

1011

00000001101100 000 --- note que el divisor se mueve para alinearse

con el próximo 1 en el dividendo (ya que el cociente para ese paso era
cero)

1011 (en otras palabras, no necesariamente mueve un poco por

iteración)

00000000110100 000

1011

000

1011

00000001110 000

1011

00000000101 000

101 1

- Sí.

00000000000000000 100 --- resto (3 bits). El algoritmo de división se

detiene aquí como dividendo es igual a cero.

Dado que el bit divisor más a la izquierda puso a cero todos los bits de
entrada que tocó, cuando este proceso finaliza, los únicos bits en la fila
de entrada que pueden ser distintos de cero son los n bits en el extremo
derecho de la fila. Estos n bits son el resto del paso de división y
también serán el valor de la función CRC (a menos que la especificación
CRC elegida requiera algún procesamiento posterior).

La validez de un mensaje recibido se puede verificar fácilmente

realizando el cálculo anterior nuevamente, esta vez con el valor de
verificación agregado en lugar de ceros. El resto debe ser igual a cero si
no hay errores detectables.

11010011101100 100

1011 - Divisor

01100011101100 100
1011 - Divisor...

00111011101100 100

...

00000001110 100

1011

00000000101 100

101 1

- Sí.

00000000000000000000000000000000000000000000000000000

El siguiente código de Python describe una función que devolverá el

resto CRC inicial para una entrada y un polinomio seleccionados, con 1 o
0 como relleno inicial. Tenga en cuenta que este código funciona con
entradas de cadena en lugar de números sin procesar:

def crc_remainder()input_bitstring, polinomial_bitstring, inicial_filler):

"""Calcula la CRC permanece de una cadena de bits usando un polinomio
elegido. inicial_filler debe ser '1' o '0'. " polinomial_bitstring =
polinomial_bitstring.Istrip()'0') len_input = Len()input_bitstring)
inicial_padding = ()Len()polinomial_bitstring) - 1) * inicial_filler
input_padded_array = lista()input_bitstring + inicial_padding) mientras
'1 ' dentro input_padded_array[:len_input]: cur_shift =
input_padded_array.índice()'1 ') para i dentro
rango()Len()polinomial_bitstring) input_padded_array[cur_shift + i]

= str()int()polinomial_bitstring[i] ! input_padded_array[cur_shift + i])

retorno ' '.Únase()input_padded_array[len_input:def
crc_check()input_bitstring, polinomial_bitstring, check_value): """Calcular
el cheque de CRC de una cadena de bits usando un polinomio elegido.""
polinomial_bitstring = polinomial_bitstring.Istrip()'0') len_input =
Len()input_bitstring) inicial_padding = check_value input_padded_array
= lista()input_bitstring + inicial_padding) mientras '1 ' dentro
input_padded_array[:len_input]: cur_shift =
input_padded_array.índice()'1 ') para i dentro
rango()Len()polinomial_bitstring) input_padded_array[cur_shift + i]
 = str()int()polinomial_bitstring[i] ! input_padded_array[cur_shift + i])
retorno ()'1 ' no dentro ' '.Únase()input_padded_array[len_input:)

, titulado crc_remainder()'11010011101100 ', '1011 ', '0')'100 ', titulado

crc_check()'11010011101100 ', '1011 ', '100 ')Cierto.

Algoritmo CRC-32

Este es un algoritmo práctico para la variante CRC-32 de CRC. La

CRCTable es una memorización de un cálculo que tendría que repetirse
para cada byte del mensaje (Cálculo de verificaciones de redundancia
cíclica § Cómputo de bits múltiples).

Función CRC32

Entrada:datos: Bytes // Array of bytes Producto:crc32: UInt32 // 32

bits sin signed CRC-32 valor
// Inicializar CRC-32 al valor inicialcrc32 ← 0xFFFF
para cada uno byte dentro datos donLookupIndex ← (crc32 xor byte) y
0x FF

crc32 ← (crc32 shr 8) xor CRCTable[nLookupIndex] // CRCTable es una

serie de 256 constantes de 32 bits
// Finalizar el valor CRC-32 invirtiendo todos los bitscrc32 ← crc32
xor 0xFFFF

retorno crc32

En C, el algoritmo se ve así:

#include Identificaciones.h // uint32_t, uint8_tuint32_t CRC32()const

uint8_t datos[], size_t data_length) {}uint32_t crc32 = 0xFFFFFFu;para
()size_t i = 0; i . data_length; i++) {}const uint32_t LookupIndex =
()crc32 ^ datos[i]) " 0xff;crc32 = ()crc32 > 8) ^
CRCTable[LookupIndex]; // CRCTable es una serie de 256 constantes de
32 bits}// Finalizar el valor CRC-32 invirtiendo todos los bitscrc32 ^=
0xFFFFFFu;retorno crc32;}

Matemáticas

El análisis matemático de este proceso similar a una división revela

cómo seleccionar un divisor que garantice buenas propiedades de
detección de errores. En este análisis, los dígitos de las cadenas de bits
se toman como los coeficientes de un polinomio en alguna variable x,
coeficientes que son elementos del campo finito GF(2) (los enteros
módulo 2, es decir, un cero o un uno), en lugar de números más
familiares. El conjunto de polinomios binarios es un anillo matemático.

Diseño de polinomios

La selección del polinomio generador es la parte más importante de la

implementación del algoritmo CRC. El polinomio debe elegirse para
maximizar las capacidades de detección de errores mientras se
minimizan las probabilidades generales de colisión.

El atributo más importante del polinomio es su longitud (mayor grado

(exponente) +1 de cualquier término en el polinomio), debido a su
influencia directa en la longitud del valor de verificación calculado.

Las longitudes polinómicas más utilizadas son 9 bits (CRC-8), 17 bits

(CRC-16), 33 bits (CRC-32) y 65 bits (CRC-64).

Un CRC se denomina CRC de n bits cuando su valor de comprobación

es n bits. Para un n dado, son posibles varios CRC, cada uno con un
polinomio diferente. Dicho polinomio tiene el grado más alto n y, por lo
tanto, n + 1 términos (el polinomio tiene una longitud de n + 1). El resto
tiene una longitud n. El CRC tiene un nombre de la forma CRC-n-XXX.

El diseño del polinomio CRC depende de la longitud total máxima del

bloque a proteger (datos + bits CRC), las funciones de protección contra
errores deseadas y el tipo de recursos para implementar el CRC, así
como el rendimiento deseado. Un concepto erróneo común es que el
"mejor" Los polinomios CRC se derivan de polinomios irreducibles o
polinomios irreducibles multiplicados por el factor 1 + x, lo que agrega al
código la capacidad de detectar todos los errores que afectan a un
número impar de bits. En realidad, todos los factores descritos
anteriormente deberían entrar en la selección del polinomio y pueden
conducir a un polinomio reducible. Sin embargo, elegir un polinomio
reducible dará como resultado una cierta proporción de errores perdidos,
debido a que el anillo del cociente tiene divisores cero.

La ventaja de elegir un polinomio primitivo como generador para un

código CRC es que el código resultante tiene la longitud máxima total
del bloque en el sentido de que todos los errores de 1 bit dentro de esa
longitud del bloque tienen diferentes restos (también llamados
síndromes) y por lo tanto, ya que el resto es una función lineal del
bloque, el código puede detectar todos los errores de 2 bits dentro de

esa longitud del bloque. Si es el grado del generador primitivo

polinomio, entonces la longitud total del bloque maximal es , y el
código asociado es capaz de detectar cualquier error de un solo bit o de
doble bit. Podemos mejorar esta situación. Si utilizamos el polinomio del

generador , donde es un polinomio primitivo de grado ,

entonces la longitud total de bloque maximal es , y el código es

capaz de detectar un número único, doble, triple y cualquier número
impar de errores.

Un polinomio que admite otras factorizaciones puede ser elegido

entonces para equilibrar el bloqueo total máximo con un poder de
detección de errores deseado. Los códigos BCH son una clase poderosa
de tales polinomios. Suman los dos ejemplos anteriores.
Independientemente de las propiedades de reducibilidad de un
generador polinomio de grador, si incluye el término "+1", el código será
capaz de detectar patrones de error que se limitan a una ventana
de r bits contiguos. Estos patrones se llaman "rupciones terroristas".

Especificación

El concepto de CRC como un código de detección de errores se complica

cuando un implementador o un comité de estándares lo usa para
diseñar un sistema práctico. Estas son algunas de las complicaciones:

 A veces una aplicación prefijos un patrón de bit fijo al

bitstream para ser revisado. Esto es útil cuando los errores de
relojería pueden insertar 0 bits delante de un mensaje, una
alteración que de otra manera dejaría sin cambios el valor de
verificación.

 Normalmente, pero no siempre, una

implementación apéndices n 0-bits ()n ser el tamaño de la CRC)
en el bitstream que se revisará antes de que se produzca la
división polinomio. Este gasto se demuestra explícitamente en el
artículo de la Convención sobre los Derechos del Niño. Esto tiene
la conveniencia de que el resto del bitstream original con el valor
de verificación anexado sea exactamente cero, por lo que el CRC
se puede comprobar simplemente realizando la división polinomio
en el bitstream recibido y comparando el resto con cero. Debido a
las propiedades asociativas y comunicativas de la operación
 exclusiva, las implementaciones prácticas impulsadas por tablas
pueden obtener un resultado numéricamente equivalente a cero-
appendiendo sin incluir explícitamente ningún cero, utilizando un
algoritmo equivalente y más rápido que combina el bitstream del
mensaje con el flujo que se desplaza fuera del registro de CRC.

 A veces una aplicación exclusiva-ORs un patrón de bit fijo en

el resto de la división polinomio.

 Orden: Algunos esquemas ven el pedazo de orden bajo de cada

byte como "primero", que entonces durante la división polinomio
significa "izquierda", que es contraria a nuestro entendimiento
consuetudinario de "bajo orden". Esta convención tiene sentido
cuando las transmisiones de puerto serie son revisadas por CRC en
hardware, ya que algunas convenciones de transmisión en serie
transmiten bytes menos significativos primero.

 Orden Byte: Con los CRC de múltiples bytes, puede haber

confusión sobre si el byte transmitido primero (o almacenado en el
byte de memoria más bajo abordado) es el byte menos
significativo (LSB) o el byte más significativo (MSB). Por ejemplo,
algunos esquemas de 16 bits de CRC intercambian los bytes del
valor de verificación.

 Omisión del bit de alto orden del polinomio divisor: Puesto que
la parte de alto orden es siempre 1, y desde n-bit CRC debe
definirse por unn + 1)-bit divisor que desborda un n- registro de
bits, algunos escritores asumen que es innecesario mencionar la
parte de alto orden del divisor.

 Omisión del bit bajo pedido del polinomio divisor: Puesto que el
bit de bajo orden es siempre 1, autores como Philip Koopman
representan polinomios con su bit de alto orden intacto, pero sin el

bit de bajo orden (el o 1 término). Esta convención codifica el

polinomio completo con su grado en un entero.

Estas complicaciones significan que hay tres formas comunes de

expresar un polinomio como un entero: los dos primeros, que son
imágenes espejo en binario, son las constantes encontradas en código;
el tercero es el número encontrado en los papeles de Koopman. En cada
caso, se omite un término. Así que el polinomio puede ser transcrito
como:

 0x3 = 0b0011, que representa (MSB-primer código)

 0xC = 0b1100, representación (LB-primer código)

 0x9 = 0b1001, que representa (Notación Koopman)

En la siguiente tabla se muestran como:

Ejemplos de representaciones de la CRC

Nomb Norm Inver Reciprocalidad

re al sa inversa

CRC-4 0x3 0xC 0x9

Ofuscación

Los CRC en protocolos propietarios pueden ofuscarse mediante el uso de

un valor inicial no trivial y un XOR final, pero estas técnicas no agregan
fuerza criptográfica al algoritmo y se pueden aplicar ingeniería inversa
utilizando métodos sencillos.

Estándares y uso común

Se han incorporado numerosas variedades de comprobaciones de

redundancia cíclica en las normas técnicas. De ninguna manera un
algoritmo, o uno de cada grado, sirve para todos los propósitos;
Koopman y Chakravarty recomiendan seleccionar un polinomio según los
requisitos de la aplicación y la distribución esperada de la longitud de los
mensajes. La cantidad de CRC distintos en uso ha confundido a los
desarrolladores, una situación que los autores han tratado de abordar.
Hay tres polinomios informados para CRC-12, veintidós definiciones
contradictorias de CRC-16 y siete de CRC-32.

Los polinomios comúnmente aplicados no son los más eficientes

posibles. Desde 1993, Koopman, Castagnoli y otros han investigado el
espacio de polinomios entre 3 y 64 bits de tamaño, encontrando
ejemplos que tienen un rendimiento mucho mejor (en términos de
distancia de Hamming para un tamaño de mensaje dado) que los
polinomios de protocolos anteriores y publicando la mejor de ellas con el
objetivo de mejorar la capacidad de detección de errores de los futuros
estándares. En particular, iSCSI y SCTP han adoptado uno de los
hallazgos de esta investigación, el polinomio CRC-32C (Castagnoli).

El diseño del polinomio de 32 bits más utilizado por los organismos de

estándares, CRC-32-IEEE, fue el resultado de un esfuerzo conjunto del
Laboratorio de Roma y la División de Sistemas Electrónicos de la Fuerza
Aérea por parte de Joseph Hammond, James Brown y Shyan. -Shiang Liu
del Instituto de Tecnología de Georgia y Kenneth Brayer de Mitre
Corporation. Las primeras apariciones conocidas del polinomio de 32 bits
fueron en sus publicaciones de 1975: Technical Report 2956 de Brayer
para Mitre, publicado en enero y publicado para difusión pública a través
de DTIC en agosto, y el informe de Hammond, Brown y Liu para el
Laboratorio de Roma, publicado en mayo. Ambos informes contenían
contribuciones del otro equipo. Durante diciembre de 1975, Brayer y
Hammond presentaron su trabajo en un documento en la Conferencia
Nacional de Telecomunicaciones de IEEE: el polinomio IEEE CRC-32 es el
polinomio generador de un código de Hamming y fue seleccionado por
su rendimiento de detección de errores. Aun así, el polinomio Castagnoli
CRC-32C utilizado en iSCSI o SCTP iguala su rendimiento en mensajes de
58 bits a 131 kbits y lo supera en varios rangos de tamaño, incluidos los
dos tamaños más comunes de paquetes de Internet. El estándar ITU-T
G.hn también usa CRC-32C para detectar errores en la carga útil
(aunque usa CRC-16-CCITT para encabezados PHY).

El cálculo CRC-32C se implementa en el hardware como una operación

( CRC32) del conjunto de instrucciones SSE4.2, introducido por primera
vez en los procesadores Intel' Microarquitectura Nehalem. La
arquitectura ARM AArch64 también proporciona aceleración de hardware
para las operaciones CRC-32 y CRC-32C.

Representaciones polinómicas de comprobaciones de redundancia

cíclica

La tabla siguiente lista sólo los polinomios de los diversos algoritmos en

uso. Las variaciones de un protocolo particular pueden imponer pre-
inversión, post-inversión y pedidos de bits revertidos como se describe
anteriormente. Por ejemplo, el CRC32 utilizado en Gzip y Bzip2 utiliza el
mismo polinomio, pero Gzip emplea el pedido de bits invertidos,
mientras que Bzip2 no. Tenga en cuenta que incluso los polinomios de
paridad en GF(2) con grado mayor a 1 nunca son primitivos. Incluso el
polinomio de paridad marcado como primitivo en esta tabla representa

un polinomio primitivo multiplicado por . El pedazo más significativo

de un polinomio es siempre 1, y no se muestra en las representaciones
hexagonales.

Montones máximos
Representaciones
de carga por
polinómicas P
Pr distancia Hamming
No ar
mbr Usos Recip id im
≥
e rocali a iti
Norm Invers Recip vo 1111119876 5 4 3 2
dad d
al a rocal 1543210
invers
6
a

más 0x1 0x1 0x1 0x1

hardw
are;
tambi in
CRC- én cl
1 conoci us
do o
como
Parity
bit

0x3 0x6 0x5 0x5 ex JU

CRC- redes
tr E
3- móvil Sí. ––––––––– – – – – 4
añ G
GSM es
o O

UIT-T 0x3 0xC 0x9 0x9 ex

CRC-
G.704 tr
4-
, pág. añ
ITU
12 o

0x09 0x12 0x05 0x14 ex

CRC-
Gen 2 tr
5-
RFID añ
EPC
o
 UIT-T 0x15 0x15 0x0B 0x1A in
CRC-
G.704 cl
5-
, pág. us
ITU
9 o

Paque 0x05 0x14 0x09 0x12 ex

CRC-
tes de tr
5-
token añ
USB
USB o

CRC-
ex
6- redes
tr
CDM móvil 0x27 0x39 0x33 0x33
añ
A20 es
o
00-A

CRC-
in
6- redes
cl
CDM móvil 0x07 0x38 0x31 0x23
us
A20 es
o
00-B

Canal
CRC- in
de
6- cl
radio 0x19 0x26 0x0D 0x2C
DAR us
de
C o
datos

0x2F 0x3D 0x3B 0x37 in JU

CRC- redes
cl E
6- móvil Sí. ––––––––– – 1 1 25 25
us G
GSM es
o O

UIT-T 0x03 0x30 0x21 0x21 ex

CRC-
G.704 tr
6-
, pág. añ
ITU
3 o

CRC- siste 0x09 0x48 0x11 0x44 ex

7 mas tr
de añ
teleco
 munic o
acion
es,
UIT-T
G.707
,Train
UIT-T
Com
munic
ex
CRC- ation
tr
7- Netwo 0x65 0x53 0x27 0x72
añ
MVB rk,
o
IEC
60870
-5

0xD5 0xAB 0x57 0xEA in JU

CRC- DVB- cl E
no ––––––––– – 2 2 85 85
8 S2 us G
o O

integr 0x2F 0xF4 0xE9 0x97

CRC-
ación in JU
8-
autom cl E
AUT Sí. ––––––––– – 3 3 119 119
otriz, us G
OSA
Open o O
R
Safety

conec 0xA7 0xE5 0xCB 0xD3

CRC-
tivida in
8-
d cl
Blue
inalá us
toot
mbric o
h
a

CRC- ITU-T 0x07 0xE0 0xC1 0x83 in

 I.432.
1
(02/9
9);
ATM
HEC,
8- cl
ISDN
CCIT us
HEC y
T o
deline
ación
celula
r,
SMBu
s PEC

CRC- 0x31 0x8C 0x19 0x98

8- in
Autob
Dalla cl
ús de
s/ us
1-Wire
Maxi o
m

Canal 0x39 0x9C 0x39 0x9C

CRC- ex
de
8- tr
radio
DAR añ
de
C o
datos

CRC- 0x49 0x92 0x25 0xA4 in

redes
8- cl
móvil
GSM us
es
-B o

CRC- 0x1D 0xB8 0x71 0x8E

ex
8-
AES3; tr
SAE
OBD añ
J185
o
0

CRC- redes 0x9B 0xD9 0xB3 0xCD in

8- cl
móvil
WCD us
es
MA o

0x233 0x331 0x263 0x319 in

ATM;
CRC- cl
ITU-T
10 us
I.610
o

CRC-
in
10- redes
cl
CDM móvil 0x3D9 0x26F 0x0DF 0x3EC
us
A20 es
o
00

ex
CRC- redes
tr
10- móvil 0x175 0x2BA 0x175 0x2BA
añ
GSM es
o

0x385 0x50E 0x21D 0x5C2 in

CRC- FlexR cl
11 ay us
o

siste 0x80F 0xF01 0xE03 0xC07

mas
in
de
CRC- cl
teleco
12 us
munic
o
acion
es

CRC-
in
12- redes
cl
CDM móvil 0xF13 0xC8F 0x91F 0xF89
us
A20 es
o
00

CRC- redes ex
12- móvil 0xD31 0x8CB 0x197 0xE98 tr
GSM es añ
 o

Hora 0x1CF 0x0BC 0x1E7

0x15E7
de la 5 F A in
CRC-
señal, cl
13-
Radio us
BBC
Teles o
witch

Canal
CRC- in
de
14- 0x080 0x100 0x240 cl
radio 0x2804
DAR 5 9 2 us
de
C o
datos

in
CRC- redes
0x202 0x1A0 0x301 cl
14- móvil 0x2D01
D 3 6 us
GSM es
o

0xC59 0x19A 0x62C in

CRC- 0x4CD1
9 3 C cl
15-
us
CAN
o

CRC- ex
15- 0x681 0x281 0x740 tr
0x540B
MPT 5 7 A añ
1327 o

Optim
CRC-
al for ex
16-
paylo 0x2F1 0x51E 0x978 tr
Chak 0xA8F4
ads 5 9 A añ
rava
≤64 o
rty
bits

CRC- Aplica ex
16- ciones 0xA02 0xA80 0xD01 tr
0xD405
ARIN ACAR B B 5 añ
C S o
 X.25, 0x102 0x881
0x8408 0x811
V.41, 1 0
HDLC
FCS,
XMOD
EM,
Blueto
oth,
PACT
CRC- in
OR,
16- cl
SD,
CCIT us
DigRF
T o
,
much
os
otros;
conoci
do
como
CRC-
CCITT

CRC-
ex
16- redes
0xC86 0xCC2 0xE43 tr
CDM móvil 0xE613
7 7 3 añ
A20 es
o
00

Teléfo 0x058 0x234 0x82C

CRC- 0x91A0 in
nos 9 1 4
16- cl
inalá
DEC us
mbric
T o
os

CRC- 0xBB8 0xEDD 0xDBA 0xC5D ex

16- SCSI 7 1 3 B tr
T10- DIF añ
DIF o

CRC- DNP, 0x3D6 0xA6BC 0x4D7 0x9EB in

16- IEC 5 9 2 cl
 870, us
DNP
M-Bus o

Bisyn 0x800 0x400 0xC00

0xA001
c, 5 3 2
Modb
us,
USB,
ANSI
X3.28,
SIA
DC-
07,
in
CRC- much
cl
16- os
us
IBM otros;
o
tambi
én
conoci
do
como
CRC-
16 y
CRC-
16-
ANSI

CRC-
16- camp ex
Ope o de 0x593 0x593 0xAC9 tr
0xAC9A
nSaf seguri 5 5 A añ
ety- dad o
A

CRC-
16- camp ex
Ope o de 0x755 0xB55 0xBAA tr
0xDAAE
nSaf seguri B D D añ
ety- dad o
B
CRC- redes ex
16- de 0x1DC 0xE77 0x8EE tr
0xF3B8
Profi emple F 1 7 añ
bus o o

Se
utiliza
en los A menudo confundido para
Fletc
chequ ser un CRC, pero en realidad
her-
es un chequesum; vea la suma
16
Adler- de comprobación de Fletcher
32 A
&B

in
CRC-
CAN 0x168 0x1B42 0x168 0x1B4 cl
17-
FD 5B D 5B 2D us
CAN
o

in
CRC-
CAN 0x102 0x1322 0x064 0x181 cl
21-
FD 899 81 503 44C us
CAN
o

0x5D6 0xD3B6 0xA76 0xAEB in

CRC- FlexR DCB BA D75 6E5 cl
24 ay us
o

CRC- Open 0x864 0xDF32 0xBE6 0xC32 in

24- PGP, CFB 61 4C3 67D cl
Radi RTCM us
x-64 104v3 o

CRC- Usado 0x800 0xC600 0x8C0 0xC00 in Sí. ––––––––– – 4 4 838 838 JU
24- en 063 01 003 031 cl 858 858 E
WCD OS-9 us 3 3 G
MA RTOS. o O
Resid
uo =
0x800
 FE3.
0x203 0x38E7 0x31C 0x301 in
CRC- 0B9C7 4301 E8603 85CE3 cl
CDMA
30 us
o

CRC- ISO 0x04C 0xEDB8 0xDB7 0x826 ex Sí. –1––12359 1 2 2 916 429 JU
32 3309 11DB7 8320 10641 08EDB tr 0 21471 7 6 9 07 496 E
(HDLC añ 18 7 726 G
), o 4 3 O
ANSI
X3.66
(ADCC
P),
FIPS
PUB
71,
FED-
STD-
1003,
ITU-T
V.42,
ISO/IE
C/IEEE
802-3
(Ether
net),
SATA,
MPEG-
2,
PKZIP,
Gzip,
Bzip2,
POSIX
cksu
m,
PNG,
ZMOD
EM,
 much
os
iSCSI, 0x1ED 0x82F6 0x05E 0x8F6
SCTP, C6F41 3B78 C76F1 E37A0
G.hn
CRC-
paylo in 5 214 JU
32C 1
ad, cl 24 2 748 E
(Cas Sí. 6–8– – –7 – – –
SSE4. us 07 4 361 G
tagn 7
2, o 3 5 O
oli)
Btrfs,
ext4,
Ceph

Excel 0x741 0xEB31 0xD66 0xBA0

ente B8CD7 D82E 3B05D DC66B
en la
longit
CRC- ud del
32K marco 1
in JU
(Koo Ether 1 6
cl 11 114 E
pma net, no 2–4– – –5 – 3 – –
us 68 663 G
n mal 2 6
o O
{1,3, rendi 0
28}) mient
o con
archiv
os
largos

CRC- Excel 0x325 0x992C 0x325 0x992 in no ––3–1–2–1 – 3 – 655 – JU

32K2 ente 83499 1A4C 83499 C1A4C cl 6 6 3 2 06 E
(Koo en la us 4 7 G
pma longit o 3 O
n ud del 8
{1,1, marco
30}) Ether
net,
mal
rendi
 mient
o con
archiv
os
largos

0x814 0xD582 0xAB0 0xC0A in

aviaci 1AB 8281 50503 0A0D5 cl
CRC-
ón;
32Q us
AIXM
o

A menudo confundido para

Adler
ser un CRC, pero en realidad
-32
un chequesum; ver Adler-32

0x000 0x200 0x800

Canal 48200 0x9000 08240 24100 in
CRC- 412000
de 09 01 04 cl
40-
contro us
GSM
l GSM o

0x42F 0x92D 0xA17

ECMA- 0E1EB 0xC96C 8AF2B 870F5
CRC- in
182 p. A9EA3 5795D7 AF0E1 D4F51
64- 870F42 cl
51, 693 E85 B49
ECM us
XZ
A o
Utils

CRC- ISO 0xD800 0x800 ex

0x000 0xB00
64- 3309 000000 00000 tr
00000 00000
ISO (HDLC 000000 00000 añ
0001B 00001
), 000 00D o
Swiss-
Prot/Tr
EMBL;
consid
erado
débil
para
la
 pirate
ría
Implementaciones

 Implementación de CRC32 en Radio GNU hasta 3.6.1 (ca. 2012)

 Código de clase C para el cálculo de la suma de comprobación CRC

con muchos CRC diferentes para elegir

Catálogos CRC

 Catálogo de algoritmos parametrizados de CRC

 CRC Polynomial Zoo