¿Cuáles son los métodos comunes de verificación de datos?

La ecuación (3-5) es la clave para programar el cálculo CRC. Muestra que el código CRC después de calcular el estándar es igual al último código CRC multiplicado por 2 y dividido por el polinomio. sumado al valor estándar dividido por El resto obtenido por un polinomio. El siguiente programa en lenguaje C para encontrar el código CRC no es difícil de entender. *ptr apunta al primer byte del búfer de envío, len es el número total de bytes que se enviarán y 0x1021 está relacionado con el polinomio.

[Código]

unsigned int cal _ CRC(unsigned char * ptr, unsigned char len) {

Carácter sin firmar I;

Entero sin signo CRC = 0;

mientras (len -!=0) {

for(I = 0x 80; i!=0; i/=2) {

if ((crc amp0x8000)!= 0){ CRC * = 2;crc^=0x1021;}/*Multiplica el CRC restante por 2 y encuentra el CRC */

else CRC * = 2;

if ((*ptr amp i)!= 0)crc^=0x1021 /*Agregar CRC estándar */

}

ptr;

}

Retorno (CRC);

}

[Código]

Aunque el código El método CRC bit a bit es simple y ocupa menos memoria, su mayor desventaja es que el CRC bit a bit consume mucho tiempo de procesamiento del procesador, lo cual es intolerable, especialmente en situaciones de comunicación de alta velocidad. Aquí hay otra forma de calcular rápidamente el CRC mediante una tabla de búsqueda de bytes.

4 Calcula CRC en bytes.

No es difícil entender que para secuencias binarias, los números se pueden expresar en bytes como (4-1), uno de los cuales tiene 8 bits (***8).

(4-1)

Encuentre el código CRC de este número de serie binario, primero multiplíquelo (es decir, desplace a la izquierda 16 bits) y luego divídalo por el polinomio G( X), obtienes El resto no es solo el código CRC requerido. Como se muestra en la fórmula (4-2):

(4-2)

se puede establecer de la siguiente manera: (4-3)

¿dónde está el número binario con 16 El número entero del resto. Sustituya la fórmula (4-3) en la fórmula (4-2) para obtener:

(4-4)

Porque:

(4-5)

Entre ellos, hay ocho altos y ocho bajos. Sustituyendo la fórmula (4-5) en la fórmula (4-4), puedes obtener:

(4-6)

Restablecer: (4-7)

donde es un número entero con un resto binario de 16. Sustituyendo la fórmula (4-7) en la fórmula (4-6), y así sucesivamente, finalmente obtenemos:

(4-

Obviamente, los números binarios de 16 bits no son solo lo que necesitamos código CRC

La fórmula (4-7) es la clave para escribir un programa para calcular CRC por byte, lo que indica que el código CRC después de calcular este byte es igual a los 8 inferiores del resto. Código CRC del último byte El código CRC obtenido desplazando el bit a la izquierda en 8 bits, más el CRC del último byte desplazado a la derecha en 8 bits (es decir, tomando los 8 bits superiores) y la suma de este byte. Calculamos todos los CRC del número de secuencia binaria de 8 bits y los colocamos en una tabla, que se puede mejorar enormemente utilizando el método de búsqueda en tabla. Por lo tanto, el siguiente programa en lenguaje C para buscar el código CRC byte a byte es. no es difícil de entender. *ptr apunta al primer byte del búfer de envío y se utilizará len Número total de bytes enviados, la tabla de resto CRC se calcula mediante el polinomio 0x11021.

[Código]

unsigned int cal _ CRC(unsigned char * ptr, unsigned char len) {

Crc entero sin signo

Carácter sin firmar da;

Unsigned int crc_ta[256]={ /* Tabla de resto CRC*/

0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,

0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,

0x 1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, f7, 0x62d6,

0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,

0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x5485,

0xa56a , 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,

0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, ,

0 xb75b, 0xa77a , 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,

0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802,

0x. c9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,

0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 050, 0x3a33, 0x2a12,

0xdbfd, 0xcbdc, 0xfbbf, eb9e, 0x9b7 9,0x8b58 , 0xbb3b, 0xab1a,

0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60,

0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, bd0b, 0x8d68, 0x9d49 ,

0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,

0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, x8f78,

0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,

0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, , 0x6067,

0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,

0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214,

0x6277, 0x7256,

0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,

0x34e2, 0x24c3, 0x14a0, 0x0481, 466, 0x6447, 0x5424,0x4405,

0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,

0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 615, 0x5634,

0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,

0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, , 0x28a3,

0xcb7d , 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,

0x4a75, 0x5a54, 0x6a37, 0x7a16, 0f1, 0x1ad0, 0x2ab3,

0x. fd2e, 0xed0f, 0xdd6c , 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,

0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,

0xef1f, 0xcf5d, 0xdf7 c, 0xaf9b , 0xbfba, 0x8fd9, 0x9ff8,

0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0

};

CRC = 0;

And (len -!=0) {

da =(uchar)(CRC/256 /* Los 8 bits superiores de CRC se almacenan temporalmente como binario de 8 bits); números*/

crc lt lt=8; /*Desplazamiento a la izquierda en 8 bits, lo que equivale a multiplicar los 8 bits inferiores de CRC*/

crc^=crc_ta[da ^*ptr];/* Agregue los 8 bits superiores al byte actual, luego busque la tabla para encontrar el CRC y agregue el CRC anterior */

ptr;

}

Retorno (CRC);

}

Obviamente, al calcular CRC por bytes, la velocidad de cálculo mejora enormemente debido al uso de la búsqueda en tabla. método. Sin embargo, para los microprocesadores de 8 bits ampliamente utilizados, el espacio de código es limitado y los requisitos para 256 tablas restantes de CRC (* * 512 bytes de memoria) ya son excesivos, pero la velocidad de cálculo de CRC no puede ser demasiado lenta. El cálculo de bytes se presenta a continuación.

5 Calcular el CRC en nibbles.

De manera similar, para secuencias binarias, los números se pueden representar en bytes como (5-1), donde es medio byte (***4 bits).

(5-1)

Encuentre el código CRC de este número de secuencia binaria, primero multiplíquelo (es decir, deslícelo hacia la izquierda 16 bits) y luego divídalo por el polinomio G(X), se obtiene El resto no es solo el código CRC requerido. Como se muestra en la fórmula (4-2):

(5-2)

se puede establecer de la siguiente manera: (5-3)

¿dónde está el número binario con 16 El número entero del resto.

Sustituya la fórmula (5-3) en la fórmula (5-2) para obtener:

(5-4)

Porque:

(5-5)

Entre ellos se encuentran los 4 bits altos y los 12 bits bajos. Sustituyendo la fórmula (5-5) en la fórmula (5-4), puedes obtener:

(5-6)

Restablecer: (5-7)

donde es un número entero con un resto binario de 16. Sustituyendo la fórmula (5-7) en la fórmula (5-6), y así sucesivamente, finalmente obtenemos:

(5-

Obviamente, los números binarios de 16 bits no son solo lo que necesitamos código CRC

La fórmula (5-7) es la clave para escribir un programa para calcular CRC por byte, lo que significa que el código CRC después de calcular este byte es igual a los 12 inferiores de los. Código CRC del byte anterior. El bit se desplazó 4 bits hacia la izquierda, más el CRC restante del byte anterior se desplazó 4 bits hacia la derecha (es decir, tomando los 4 bits superiores) y la suma de este byte. Si calculamos todos los CRC de una secuencia binaria de 4 dígitos. número, colóquelos en una tabla y utilícelos. Por lo tanto, el siguiente programa en lenguaje C que usa nibbles para encontrar códigos CRC no es difícil de entender. *ptr apunta al primer byte del búfer de envío, len es el número total de bytes. se enviará y el resto del CRC se calculará mediante el polinomio 0x11021

unsigned cal _ CRC(unsigned char * ptr, unsigned char len) {

Crc entero sin signo

Entero sin signo CRC _ ta [16] = {/* Tabla de resto CRC*/

0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,

0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,

}

CRC = 0;

And ( len -! =0) {

da =((uchar)(CRC/256))/16 /* Los cuatro bits superiores de CRC se almacenan temporalmente */

crc lt lt =4; /* Desplaza el CRC a la derecha 4 bits, lo que equivale a tomar los 12 bits inferiores del CRC)*/

crc^=crc_ta[da^( *ptr/16)]; /* Cambia los bits altos del CRC. Los 4 bits se agregan a la primera mitad del byte y luego se busca en la tabla para calcular el CRC.

Luego agregue el resto del último CRC*/

da =((uchar)(CRC/256))/16 /* Los 4 bits superiores de CRC se almacenan temporalmente; */

crc lt lt=4; /* CRC desplazado a la derecha 4 bits, equivalente a los 12 bits inferiores de CRC)*/

crc^=crc_ta[da^( *ptramp; 0x0f) ]; /* Agregue los 4 bits superiores del CRC a la segunda mitad del byte y luego busque la tabla para calcular el CRC.

Luego agregue el resto del último CRC*/

ptr;

}

Devolución (CRC);

}

[Código]

5 Conclusión

Los tres procesos de búsqueda de CRC presentados anteriormente son lentos, pero ocupan el espacio de memoria más pequeño. El método de tabla de búsqueda para encontrar CRC es más rápido, pero ocupa más memoria. El método de tabla de búsqueda de medio byte para encontrar CRC es un equilibrio entre los dos primeros, es decir, no ocupa demasiada memoria ni es demasiado lento. por lo que es más adecuado para aplicaciones de 8 microcontroladores con poca memoria. El programa C proporcionado anteriormente se puede modificar de acuerdo con las características de cada compilador de microprocesador, como colocar la tabla de restos CRC en el área de memoria del programa. [/code]

Hjzgq respondió el: 15 de mayo de 2003 14:12:51.

Notas sobre cómo aprender el algoritmo CRC32 y cómo implementarlo con java De: csdn boot cool 2002 65438 octubre 65438 23 de septiembre: 11 Cosas a tener en cuenta al aprender el algoritmo CRC32 y cómo implementarlo con java.

Notas de estudio sobre el algoritmo CRC32 y su implementación en Java

1: Descripción

No hay mucha introducción detallada al algoritmo de verificación CRC32 en el foro. Hace unos días vi un artículo de Ross N. Williams y finalmente descubrí los entresijos del algoritmo CRC32. Originalmente quería traducir el texto original, pero el tiempo era escaso, así que tuve que escribir algunas de mis propias experiencias de aprendizaje. Esto le permite comprender la esencia de CRC32 más rápidamente. Como el nivel es limitado, corrígeme. El texto original se puede obtener del siguiente sitio web:]

En tercer lugar, cómo utilizar el software para implementar el algoritmo CRC.

Ahora nuestro principal problema es cómo implementar la verificación y codificación CRC. En la actualidad, es imposible implementarlo con hardware, por lo que se considera principalmente el método de implementación de software.

La siguiente es la traducción del texto original del autor:

Asumimos que hay un registro de 4 bits. Mediante cambios repetidos y división CRC, el valor en el registro es, en última instancia, el. resto que necesitamos.

3 2 1 0 bits

- - - -

Pop lt-| |

- - - -

1 0 1 1 1 = poli

(Nota: el mensaje extendido es un mensaje seguido de w cero bits.)

Según este modelo, obtenemos el algoritmo más simple:

Establece el valor en el registro en 0.

Agrega r ceros después de los datos originales.

Mientras (todavía hay datos sin procesar)

Inicio

Desplaza el valor en el registro un bit hacia la izquierda, lee nuevos datos y Colóquelo en el bit 0 del registro.

Si (si el bit desplazado por la operación de desplazamiento a la izquierda en el paso anterior es 1)

Registro = Registrar XOR Poly.

Fin

El valor en el registro actual es el resto del crc que necesitamos.

Mis notas de estudio:

Pero ¿por qué hacemos esto? Ilustremos con el siguiente ejemplo:

1100001010

_______________

10011 11010110110000

10011,,.,,... .

- ,,.,, ....

-》 10011,.,, ....

10011,.,, .. . .

- ,.,, ....

-》 00001., ....

00000.,, ....

- .,, ....

00010,, ....

00000,, ....

-, , ....

00101, ....

00000, ....

Sabemos que el bit más alto de G(x) debe be es 1, y si el cociente es 1 o 0 está determinado por el bit más alto del dividendo. No nos importa cuál sea el cociente, nos importa el resto. Por ejemplo, G(x) en el ejemplo anterior tiene 5 números. Podemos ver que el resto obtenido de cada paso de división en realidad se obtiene aplicando XOR en los últimos cuatro bits de G(x) después del bit más alto del dividendo. ¿De qué sirve el dividendo más alto? Sabemos por qué por los dos restos diferentes de los marcadores.

Cuando el bit más alto del dividendo es 1, el cociente 1 realiza una operación XOR en los cuatro bits después del bit más alto de los últimos cuatro bits de G(x) para obtener el resto, si el bit más significativo es 0; el cociente 0 es ) En los últimos cuatro bits, los cuatro bits después del bit más significativo del dividendo se XOR para obtener el resto, pero encontramos que este resto es en realidad el valor de los cuatro bits después del bit más significativo del dividendo. dividendo original. En otras palabras, si el bit más alto es 0, no es necesario realizar una operación XOR. En este punto, finalmente sabemos por qué construimos el modelo de esta manera antes y el principio del algoritmo también es claro.

La siguiente es la traducción del texto original del autor:

Sin embargo, el algoritmo implementado de esta manera es muy ineficiente. Para aumentar la velocidad, lo hicimos capaz de procesar datos de más de 4 bits a la vez. En otras palabras, queremos implementar una verificación CRC de 32 bits. Supongamos como antes que tenemos un registro de 4 "bits". Pero cada bit es un byte de 8 bits.

3 2 1 0 bytes

- - - -

Pop lt-| - - - -

1 lt; - 32 bits - gt; (lo que implica el orden más alto "1")

De acuerdo con el mismo principio, podemos obtener el siguiente algoritmo:

Mientras (todavía hay datos sin procesar)

Inicio

Comprueba el byte del encabezado del registro y obtén su valor.

Encontrar la suma de polinomios con diferentes desplazamientos

El registro se desplaza un byte hacia la izquierda y el byte recién leído se almacena en la posición más a la derecha.

La suma del valor del registro XOR y el polinomio.

Fin

Mis notas de estudio:

Pero ¿por qué hacemos esto? De manera similar, todavía usamos un ejemplo simple para ilustrar este problema:

Supongamos que existen tales valores:

El valor actual del registro: 01001101.

Se deben desplazar 4 bits: 1011.

El polinomio generador es: 101011100.

Registro superior

- -

1011 01001101

1010 11100 (CRC XOR)

-< / p>

0001 10101101

Si los primeros 4 bits no son 0, significa que no hay división. Continuar dividiendo:

0001 10101101

1 01011100 (CRC XOR)

-

0000 11110001

^^^^

Todos los ceros en los primeros 4 dígitos significan excepto.

¿Qué pasará si haces lo que dice el algoritmo?

1010 11100

1 01011100

-

1011 10111100

1011 10111100

1011 01001101

-

0000 11110001

Ahora vemos el hecho de que los resultados son consistentes con los resultados anteriores. Esto también explica por qué el algoritmo suma los valores polinomiales en función de diferentes valores de compensación y luego usa registros para realizar XOR. Además, podemos ver que cada primer byte corresponde a un valor. Por ejemplo, en el ejemplo anterior: 1011, corresponde a 01001101. Luego, según nuestro modelo, para el byte de encabezado CRC de 32 bits. Debe haber 2 8 en los primeros 8 dígitos, lo que significa que les corresponden 256 valores. Entonces podemos construir una tabla con anticipación y luego, al codificar, solo necesitamos sacar el primer byte de los datos de entrada y encontrar el valor correspondiente de la tabla. Esto puede mejorar enormemente la velocidad de codificación.

- - -

- lt;

| |

Operación XOR

| |

| 0 - - - -

v - -

| - - - -

| - - - -

| - - - -

| p>

| - - - -

- gt; - - - -

- - - -

- - - -

- - - -

- - - -

255 - - - -

La siguiente es la traducción del texto original del autor:

El algoritmo anterior se puede optimizar aún más de la siguiente manera:

1: desplaza el registro a la izquierda un byte y lee un nuevo byte de los datos originales.

2: Utilice el byte que acaba de sacar del registro como índice para localizar el valor de 32 bits en la tabla.

3: XOR el valor en el registro.

4: Si aún quedan datos sin procesar, regrese al primer paso para continuar con la ejecución.

Se puede escribir de la siguiente forma en lenguaje c:

r = 0

mientras (len -)

r; = (( r lt; lt| p * )^ t[(r gt; gt24) amp; 0x ff];

Pero este algoritmo se basa en los datos originales que se han ampliado con 0, por lo que al final tenemos que agregar esto. Un bucle que agrega w ceros a los datos originales.

Mis notas de estudio:

Tenga en cuenta que W ceros no se agregan antes del preprocesamiento, sino como resultado. descrito en el algoritmo anterior Agregado después del bucle

for(I = 0; i ltw/4; i )

r =(r lt; lt^·t[(r). gt; gt24) amp ;0x ff];

Entonces es W/4 porque si hay W ceros, como estamos en bytes (8 bits), son W/4 ceros. no es un bucle. w/8 veces

La siguiente es la traducción del texto original del autor:

1: Para los w/4 cero bytes al final, su función. en realidad es para garantizar que todos los datos originales hayan sido enviados al registro y procesados ​​por el algoritmo

2. Si el valor inicial en el registro es 0, los primeros cuatro ciclos solo se utilizan para enviar el. Los primeros cuatro bytes de los datos originales en el registro (esto debe combinarse con la generación de la tabla. Incluso si el valor inicial del registro no es 0, los primeros cuatro ciclos solo realizan una operación XOR en los primeros cuatro). bytes de los datos originales y algunas constantes en el registro, y luego enviarlos al registro.

3A xor B) xor C = A xor (B xor C)

En términos generales, el algoritmo original se puede cambiar a:

- lt; (no mejorado)

|

v 3 2 1 0 bytes

| - - - -

XOR- lt; | |

| - - - -

|

|

Operación XOR

| |

| 0 - - - -

v - -

| - - - -

| p> p>

| - - - -

| - - - -

| - - - -

- - - - -

|p>

- - - -

- - - -

- - - -

- - - -

255 - - - -

Algoritmo:

1: desplaza el registro a la izquierda un byte y lee un nuevo byte de los datos originales.

2. Utilice el byte que acaba de sacar del registro y el nuevo byte leído por XOR para generar el índice de posicionamiento y obtener el valor correspondiente de la tabla.

3: XOR el valor en el registro.

4: Si aún quedan datos sin procesar, regrese al primer paso para continuar con la ejecución.

Mis notas de estudio:

Todavía no sé mucho sobre este algoritmo. Puede estar relacionado con la naturaleza de XOR. ¿Por favor indique el motivo?

Gracias.

En este punto, básicamente hemos entendido los principios e ideas del algoritmo de CRC32. En el próximo capítulo, quiero centrarme en la implementación en lenguaje Java basada en ideas algorítmicas.

Hjzgq respondió el: 15 de mayo de 2003 14:14:51.

Los algoritmos matemáticos siempre han sido el núcleo del cifrado de contraseñas, pero en general, la gente parece prestarle menos atención al cifrado de ruta suave, porque el cifrado de software en sí es a menudo una técnica de programación. Sin embargo, en los últimos años, con la popularidad de los programas de cifrado de números de serie, los algoritmos matemáticos parecen desempeñar un papel cada vez más importante en el cifrado de software.

Echemos un vistazo a cómo funciona el popular cifrado de números de serie en Internet. Los usuarios descargan un software shareware - *** de Internet, que generalmente tiene un límite de tiempo para su uso. * * *Después del período de prueba del software, debe registrarse con la compañía de software antes de poder continuar usándolo. Durante el proceso de registro, los usuarios suelen comunicar a la empresa de software su información privada (normalmente principalmente su nombre) junto con su número de tarjeta de crédito, y la empresa de software calculará un número de serie basándose en la información del usuario. Después de que el usuario obtenga el número de serie, seguirá los pasos necesarios para el registro e ingresará la información de registro y el código de registro en el software. Después de que el software verifique la legitimidad de la información de registro, cancelará sus diversas restricciones. Este tipo de cifrado es relativamente sencillo de implementar, no requiere ningún costo adicional y es muy conveniente para los usuarios comprarlo. El 80% del software que hay en Internet está protegido de esta forma.

Podemos notar que el proceso mediante el cual el software verifica la legitimidad del número de serie es en realidad el proceso de verificar si la relación de conversión entre el nombre de usuario y el número de serie es correcta. Hay dos tipos básicos de validación. Una es generar un código de registro basado en el nombre ingresado por el usuario y luego compararlo con el código de registro ingresado por el usuario. La fórmula es la siguiente:

Número de serie = F (nombre de usuario)