¿Cuándo es más apropiado usar CRC que MD5 / SHA1?


130

¿Cuándo es apropiado usar CRC para la detección de errores versus funciones de hashing más modernas como MD5 o SHA1? ¿Es el primero más fácil de implementar en hardware embebido?

Respuestas:


114

CRC funciona bien para detectar errores aleatorios en los datos que pueden ocurrir, por ejemplo, por interferencia de red, ruido de línea, distorsión, etc.

CRC es computacionalmente mucho menos complejo que MD5 o SHA1. El uso de una función hash como MD5 probablemente sea excesivo para la detección de errores aleatorios. Sin embargo, usar CRC para cualquier tipo de verificación de seguridad sería mucho menos seguro que una función de hashing más compleja como MD5.

Y sí, CRC es mucho más fácil de implementar en hardware integrado, incluso puede obtener diferentes soluciones empaquetadas para esto en IC.


1
@gili: siempre puedes simplemente xor las palabras d para obtener una sola palabra d resultante.
Blindy

2
@Dustin: ¿Estás completamente correcto en tu respuesta, pero quizás consideres cambiar "CRC es computacionalmente mucho más eficiente" a "CRC es computacionalmente mucho más fácil"? Los algoritmos MD5 / SHA-1 son complejos, pero en realidad no son IMO 'ineficientes'.
Coxy

1
@coxymla tienes razón, la palabra que debería haber usado es "compleja", no "ineficiente". ¡Gracias!
define el

27
Para reducir cualquier hash largo a 32 bits, solo tome los primeros 32 bits.
orip

1
Si la seguridad es su objetivo, entonces nunca debe usar MD5, SHA-1también debe evitarse, SHA-2se recomienda alguna variante .
Peter

33

CRC está diseñado contra cambios involuntarios en los datos. Es decir, es bueno para detectar errores involuntarios, pero será inútil como una forma de asegurarse de que los datos no se manejen de forma malintencionada.

También mira esto .


La parte más importante del enlace en esta respuesta: "(...) incluso un CRC de 2048 bits sería criptográficamente mucho menos seguro que un MD5 de 128 bits"
Marc.2377

3
Si bien la respuesta sigue siendo correcta, MD5 y SHA1 están en el mismo nivel de seguridad hoy en día. En otras palabras, solo es bueno para detectar errores involuntarios.
Piskvor salió del edificio

21

Encontré un estudio que muestra cuán inapropiados son los hashes CRC para las tablas hash . También explica las características reales del algoritmo. El estudio también incluye la evaluación de otros algoritmos hash y es una buena referencia para mantener.

La conclusión relevante sobre CRC para hashes:

CRC32 nunca fue diseñado para el uso de tablas hash. Realmente no hay una buena razón para usarlo para este propósito, y le recomiendo que evite hacerlo. Si decide usar CRC32, es fundamental que use los bits hash del extremo opuesto al que se introducen los octetos clave. El final depende de la implementación específica de CRC32. No trate CRC32 como una función hash de "recuadro negro", y no la use como un hash de propósito general. Asegúrese de probar la idoneidad de cada aplicación.

ACTUALIZAR

Parece que el sitio está caído. Sin embargo, el archivo de Internet tiene una copia .


El enlace está roto. ¿Quizás puedas escribir la explicación tú mismo? Si no, la respuesta es inútil.
ceving

Bien, incluiré la conclusión en mi respuesta.
Andre Luus

Extraño, de acuerdo con el punto de referencia aquí , CRC en realidad funciona bastante bien en términos de velocidad y número de colisiones.
ostrokach

Muy interesante de hecho. Tuve que revisar el estudio al que volví a vincular nuevamente, pero si tenía que adivinar, debía ser debido a las diferentes implementaciones de prueba. Si tuviera que tomar una decisión, buscaría el consejo del estudio, parece ser más científicamente sólido.
Andre Luus

En mi experiencia, hackear millones de URL, CRC64 chocó 8 veces y MD5 chocó 5. Obviamente, MD5 fue mejor, pero CRC64 fue un hash excelente, mucho más rápido y más simple.
J. Dimeo

18

Ejecuté cada línea de este código PHP en 1.000.000 de bucle. Los resultados están en comentarios (#).

hash('crc32', 'The quick brown fox jumped over the lazy dog.');#  750ms   8 chars
hash('crc32b','The quick brown fox jumped over the lazy dog.');#  700ms   8 chars
hash('md5',   'The quick brown fox jumped over the lazy dog.');#  770ms  32 chars
hash('sha1',  'The quick brown fox jumped over the lazy dog.');#  880ms  40 chars
hash('sha256','The quick brown fox jumped over the lazy dog.');# 1490ms  64 chars
hash('sha384','The quick brown fox jumped over the lazy dog.');# 1830ms  96 chars
hash('sha512','The quick brown fox jumped over the lazy dog.');# 1870ms 128 chars

Mi conclusión:

  • Use "crc32b" cuando necesite http://en.wikipedia.org/wiki/Cyclic_redundancy_check y no le importe la seguridad.
  • Use "sha256" (o superior) cuando necesite una capa de seguridad adicional.

  • No use "md5" o "sha1" porque tienen:

    1. algunos problemas de seguridad cuando te importa la seguridad
    2. cadena de hash más larga y más lenta que "crc32b" cuando todo lo que necesita es CRC

te refieres a bits, no caracteres
esskar

Realmente no. echo hash ('crc32', 'El rápido zorro marrón saltó sobre el perro perezoso'); repite "413a86af", que es una cadena larga de 8 caracteres. Por cierto, es un número de 32 bits almacenado en formato HEX. Por ejemplo, "sha256" tiene hash de 256 bits, nuevamente almacenado como HEX, lo que da una cadena larga de 64 caracteres.
Martin

45
Estos resultados son muy engañosos. Cuando estos algoritmos de hash se aplican a un gran conjunto de datos ( Guerra y paz en lugar de "The quick brown fox jumped over the lazy dog."), verá cuánto CRC es más rápido que MD5.
ubiquibacon

1
Hay un caso intermedio (verificación duplicada en las bibliotecas) donde MD5 / Sha1 son la solución correcta: no necesitan manejar el caso en el que hay un adversario que elabora cuidadosamente la colisión de hash que se desvanece poco probable, pero necesitan manejar colisiones accidentales. Entonces: Detección de errores de bit y corrupción: CRC32 Detección de colisiones en bibliotecas: MD5 / SHA1 Aplicaciones adversarias: Sha256 y superior. Por supuesto, si tiene una biblioteca con miles de millones de entradas, entonces probablemente también necesite aumentar sus bits de hash.
Dewi Morgan

PHP? en una plataforma ARM, código incrustado, 16MHz a CRC32 de 46 bytes, quizás 12 microsegundos. Eso tiene asistencia de hardware. Incluso el hardware asistido por AES sería varios cientos de veces más lento. La tabla de búsqueda no asistida CRC aún debería tener alrededor de 50 microsegundos.
ilgitano


9

Todo depende de sus requisitos y expectativas.

Aquí hay breves breves diferencias entre estos algoritmos de función hash :

CRC (CRC-8/16/32/64)

  • no es un algoritmo de cifrado criptográfico (está utilizando una función lineal basada en comprobaciones de redundancia cíclicas)
  • puede producir 9, 17, 33 o 65 bits
  • no está destinado a ser utilizado con fines criptográficos, ya que no ofrece garantías criptográficas,
  • inadecuado para su uso en firmas digitales, porque es fácilmente reversible 2006 ,
  • no debe usarse con fines de cifrado,
  • diferentes cadenas pueden generar la colisión,
  • inventado en 1961 y utilizado en Ethernet y muchos otros estándares,

MD5

  • es un algoritmo criptográfico hash,
  • producir un valor hash de 128 bits (16 bytes) (números hexadecimales de 32 dígitos)
  • es un hash criptográfico, pero se considera obsoleto si te preocupa la seguridad,
  • hay cadenas conocidas que tienen el mismo valor hash MD5
  • se puede usar con fines de cifrado,

SHA-1

  • es un algoritmo criptográfico hash,

  • produce un valor hash de 160 bits (20 bytes) conocido como resumen de mensaje

  • es un hash criptográfico y desde 2005 ya no se considera seguro,

  • se puede usar con fines de cifrado,

  • Se ha encontrado un ejemplo de colisión sha1

  • publicado por primera vez en 1993 (como SHA-0), luego 1995 como SHA-1,

  • serie: SHA-0, SHA-1, SHA-2, SHA-3,

    En resumen, el uso de SHA-1 ya no se considera seguro contra oponentes bien financiados, porque en 2005, los criptoanalistas encontraron ataques contra SHA-1, lo que sugiere que puede no ser lo suficientemente seguro para el uso continuo de schneier . US NIST aconseja que las agencias federales dejen de usar SHA1-1 para aplicaciones que requieren resistencia a colisiones y deben usar SHA-2 después de 2010 NIST .

Por lo tanto, si está buscando una solución simple y rápida para verificar la integridad de los archivos (contra la corrupción), o para algunos propósitos simples de almacenamiento en caché en términos de rendimiento, puede considerar CRC-32, para el hash que considere usar MD5, sin embargo, si está desarrollando una aplicación profesional (que debe ser segura y consistente), para evitar cualquier probabilidad de colisión, use SHA-2 y superior (como SHA-3).

Actuación

Alguna prueba de referencia simple en PHP:

# Testing static text.

$ time php -r 'for ($i=0;$i<1000000;$i++) crc32("foo");'
real    0m0.845s
user    0m0.830s
sys     0m0.008s

$ time php -r 'for ($i=0;$i<1000000;$i++) md5("foo");'
real    0m1.103s
user    0m1.089s
sys     0m0.009s

$ time php -r 'for ($i=0;$i<1000000;$i++) sha1("foo");'
real    0m1.132s
user    0m1.116s
sys   0m0.010s

# Testing random number. 

$ time php -r 'for ($i=0;$i<1000000;$i++) crc32(rand(0,$i));'
real    0m1.754s
user    0m1.735s
sys     0m0.012s\

$ time php -r 'for ($i=0;$i<1000000;$i++) md5(rand(0,$i));'
real    0m2.065s
user    0m2.042s
sys     0m0.015s

$ time php -r 'for ($i=0;$i<1000000;$i++) sha1(rand(0,$i));'
real    0m2.050s
user    0m2.021s
sys     0m0.015s

Relacionado:


8

No dices qué es lo que estás tratando de proteger.

Un CRC a menudo se usa en sistemas integrados como un control contra la corrupción accidental de datos en lugar de evitar la modificación maliciosa del sistema. Ejemplos de los lugares donde un CRC puede ser útil es validar una imagen EPROM durante la inicialización del sistema para protegerse contra la corrupción del firmware. El gestor de arranque del sistema calculará el CRC para el código de la aplicación y lo comparará con el valor almacenado antes de permitir que se ejecute el código. Esto protege contra la posibilidad de corrupción accidental del programa o una descarga fallida.

Un CRC también se puede usar de manera similar para proteger los datos de configuración almacenados en FLASH o EEPROM. Si el CRC es incorrecto, los datos se pueden marcar como no válidos y se puede usar un conjunto de datos predeterminado o de respaldo. El CRC puede no ser válido debido a una falla del dispositivo o si el usuario desconectó la alimentación durante una actualización del almacén de datos de configuración.

Ha habido comentarios de que un hash proporciona una mayor probabilidad de detectar corrupción que un CRC con errores de múltiples bits. Esto es cierto, y la decisión sobre si utilizar o no un CRC de 16 o 32 bits dependerá de las consecuencias de seguridad de un bloque de datos corrupto y de si puede justificar la posibilidad de 1 en 2 ^ 16 o 2 ^ 32 de bloque de datos incorrectamente declarado válido.

Muchos dispositivos tienen un generador CRC incorporado para algoritmos estándar. La serie MSP430F5X de Texas tiene una implementación de hardware del estándar CRC-CCITT.


6

CRC32 es más rápido y el hash tiene solo 32 bits de largo.

Úselo cuando solo desee una suma de comprobación rápida y ligera. CRC se utiliza en ethernet.

Si necesita más confiabilidad, es preferible usar una función de hashing moderna.


5

Utilice CRC solo si los recursos de cálculo son muy reducidos (es decir, algunos entornos de inserción) o si necesita almacenar / transportar muchos valores de salida y el espacio / ancho de banda es limitado (ya que los CRC son generalmente de 32 bits donde una salida MD5 es de 128 bits, SHA1 160 bit y otras variantes SHA de hasta 512 bit).

Nunca use CRC para controles de seguridad, ya que es muy fácil falsificarlo.

Incluso para la detección de errores accidentales (en lugar de la detección de cambios maliciosos) los hashes son mejores que un simple CRC. En parte debido a la forma simple en que se calcula un CRC (y en parte porque los valores de CRC son usualmente más cortos que las salidas hash comunes, por lo que tienen un rango mucho más pequeño de valores posibles) es mucho más probable que, en una situación donde hay dos o más errores , un error enmascarará a otro, por lo que terminará con el mismo CRC a pesar de dos errores.

En resumen: a menos que tenga motivos para no utilizar un algoritmo hash decente, evite los CRC simples.


1
CRC detectará todos los cambios accidentales de datos si está utilizando un polinomio adecuado. 1/2 ^ 32 cambios se pierden si se cambian exactamente los bits múltiples correctos.
Gerhard

Y con un polinomio adecuado también detectará todos los errores de ciertas clases comunes, por ejemplo, errores de ráfaga.
erikkallen

Estoy de acuerdo con su respuesta, excepto que la pregunta es sobre sistemas integrados. El rendimiento de un algoritmo criptográfico puede ser problemático en sistemas integrados más pequeños.
Craig McQueen

Estaría absolutamente en desacuerdo con eso. Los polinomios de error CRC se eligen cuidadosamente para que puedan detectar 1,2,3,5 y errores de ráfaga de hasta 11 bits en algunos casos. Un hash criptográfico es puramente estadístico, por lo que debe usar grandes valores de resumen. 8-32 bits no son realistas para un resumen de hash criptográfico, así como innecesariamente costoso en ciclos de CPU y puertas. Definitivamente no es una respuesta a tener en cuenta si trabaja en sistemas integrados. El único momento para NO utilizar un CRC es si tiene que lidiar con un escenario adversario inteligente.
ilgitano

5

Recientemente me encontré con un uso de CRC que era inteligente. El autor de la herramienta de identificación y eliminación de duplicación de archivos jdupe (el mismo autor de la popular herramienta exif jhead) la usa durante la primera pasada a través de los archivos. Se calcula un CRC en los primeros 32K de cada archivo para marcar los archivos que parecen ser iguales, también los archivos deben tener el mismo tamaño. Estos archivos se agregan a una lista de archivos para realizar una comparación binaria completa. Acelera la comprobación de archivos multimedia de gran tamaño.


Un problema con ese enfoque es que cuando se ejecuta en un archivo que contiene un CRC32 incorporado, el CRC resultante puede ser independiente de los datos en el archivo (ya que si los datos cambian, el CRC32 se cambiará para cancelar la diferencia ) Munging los datos de alguna manera simple antes de calcular el CRC32 evitaría ese problema.
supercat

1
@supercat: realmente no creo que esto sea realmente un problema. Si un archivo contiene un encabezado crc32 que es el crc32 del resto del archivo, cuando el archivo se actualice, cada bit en el encabezado crc32 tendrá aproximadamente un 50% de posibilidades de ser diferente. Los cambios en el encabezado deben seguir una distribución bastante aleatoria. No puedo ver cómo esto va a resultar en que el CRC32 (encabezado + datos) siempre sea el mismo, o de alguna manera no dependa de la porción de datos del archivo.
teratorn

@teratorn: He visto una serie de archivos que tienen un CRC32 al final, calculados de tal manera que el CRC32 de todo el archivo, calculado usando alguna constante inicial particular, siempre será algún otro valor constante. Esto es bastante común con cosas como imágenes de código binario. Si el reproductor de DVD Acme 1000 utiliza imágenes de código de tamaño fijo para las actualizaciones de firmware, y espera que cada imagen de código tenga un cierto CRC32, entonces una rutina que computa los CRC32 de varios archivos no podría distinguir diferentes imágenes de código para el Acme 1000.
supercat

El punto de la CRC en ese caso es identificar rápidamente que los archivos son diferentes. Si el CRC vuelve a ser el mismo, ahora tiene que hacer una comparación binaria costosa, para que un CRC incrustado no rompa el algoritmo. Podría suceder que algunos archivos terminen siendo binarios en comparación porque el primer paso de CRC dice que PODRÍAN ser los mismos, pero es poco probable que sean muchos de ellos, y puede evitarlo utilizando un polinomio personalizado.
ilgitano

4

CRC32 es mucho más rápido y a veces tiene soporte de hardware (es decir, en procesadores Nehalem). Realmente, la única vez que lo usaría es que si estás interfaz con el hardware, o si usted es realmente apretado en el rendimiento


4

Empecemos con lo básico.

En Criptografía, un algoritmo de hash convierte muchos bits a menos bits a través de una operación de resumen. Los hashes se utilizan para confirmar la integridad de los mensajes y archivos.

Todos los algoritmos de hash generan colisiones. Una colisión es cuando varias combinaciones de muchos bits producen la misma salida de menos bits. La fuerza criptográfica de un algoritmo de hash se define por la incapacidad de un individuo para determinar cuál será la salida para una entrada dada porque si pudieran, podrían construir un archivo con un hash que coincida con un archivo legítimo y comprometer la integridad asumida. del sistema. La diferencia entre CRC32 y MD5 es que MD5 genera un hash más grande que es más difícil de predecir.

Cuando desee implementar la integridad del mensaje, lo que significa que el mensaje no ha sido alterado en tránsito, la incapacidad de predecir colisiones es una propiedad importante. Un hash de 32 bits puede describir 4 mil millones de mensajes o archivos diferentes usando 4 mil millones de hashes únicos diferentes. Si tiene 4 mil millones y 1 archivos, se garantiza que tendrá 1 colisión. 1 TB Bitspace tiene la posibilidad de miles de millones de colisiones. Si soy un atacante y puedo predecir cuál será el hash de 32 bits, puedo construir un archivo infectado que colisione con el archivo de destino; que tiene el mismo hash

Además, si estoy haciendo una transmisión de 10 mbps, entonces la posibilidad de que un paquete se corrompa de la forma correcta para omitir crc32 y continuar hasta el destino y ejecutar es muy baja. Digamos que a 10mbps obtengo 10 errores \ segundo . Si aumento eso a 1gbps, ahora obtengo 1,000 errores por segundo . Si llego hasta 1 exabit por segundo, entonces tengo una tasa de error de 1,000,000,000 de errores por segundo . Digamos que tenemos una tasa de colisión de 1 \ 1,000,000errores de transmisión, lo que significa que 1 en un millón de errores de transmisión da como resultado que los datos corruptos pasen sin ser detectados. A 10mbps, recibo datos de error que se envían cada 100,000 segundos o aproximadamente una vez al día. A 1 gbps sucedería una vez cada 5 minutos. A 1 exabit por segundo, estamos hablando varias veces por segundo.

Si abre Wireshark, verá que su encabezado Ethernet típico tiene un CRC32, su encabezado IP tiene un CRC32 y su encabezado TCP tiene un CRC32, y eso es además de lo que pueden hacer los protocolos de capa superior; por ejemplo, IPSEC puede usar MD5 o SHA para la verificación de integridad además de lo anterior. Hay varias capas de verificación de errores en las comunicaciones de red típicas, y TODAVÍA funcionan de vez en cuando a velocidades inferiores a 10 mbps.

La verificación de redundancia cíclica (CRC) tiene varias versiones comunes y varias poco comunes, pero generalmente está diseñada para indicar cuándo un mensaje o archivo se ha dañado en tránsito (volteo de varios bits). CRC32 en sí mismo no es un protocolo de verificación de errores muy bueno para los estándares actuales en entornos empresariales grandes y escalares debido a la tasa de colisión; El disco duro de los usuarios promedio puede tener más de 100k archivos, y los archivos compartidos en una empresa pueden tener decenas de millones. La relación entre el espacio hash y la cantidad de archivos es demasiado baja. CRC32 es computacionalmente barato de implementar, mientras que MD5 no lo es.

MD5 fue diseñado para detener el uso intencional de colisiones para hacer que un archivo malicioso se vea benigno. Se considera inseguro porque el espacio hash se ha mapeado lo suficiente como para permitir que ocurran algunos ataques, y algunas colisiones son predecibles. SHA1 y SHA2 son los nuevos niños en el bloque.

Para la verificación de archivos, Md5 está comenzando a ser utilizado por muchos proveedores porque puede crear archivos multigigabyte o multiterrabyte rápidamente y apilarlo sobre el uso general del sistema operativo y el soporte de CRC32. No se sorprenda si en la próxima década los sistemas de archivos comienzan a usar MD5 para la verificación de errores.


1

El código CRC es más simple y rápido.

¿Para qué necesitas algo?

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.