¿Cuáles son los métodos de verificación de datos más utilizados?
Comprobación de paridad". La unidad más pequeña en la memoria es un bit, también llamado "bit". Los bits tienen sólo dos estados, etiquetados 1 y 0. Cada 8 bits consecutivos se denomina palabra. Cada byte de memoria sin verificación de paridad tiene solo 8 bits. Si uno de sus bits almacena un valor incorrecto, hará que los datos correspondientes almacenados cambien, lo que provocará errores de aplicación. La verificación de paridad agrega un bit a cada byte (8 bits) como error. bit de detección. Una vez que los datos se almacenan en un byte, los datos almacenados en sus 8 bits son fijos porque los bits son solo un bit. Puede haber dos estados de 1 o 0. Suponga que los datos almacenados están marcados con bits como 1. 1, 1, 0, 0, 1, 0, 1. Luego suma cada bit (1+1+1+1+1=5), y el resultado es un número impar. Luego, el dígito de control. se define como 1, de lo contrario es 0. Cuando la CPU lee los datos almacenados, agregará los datos almacenados en los primeros 8 bits nuevamente para determinar si el resultado es consistente con el dígito de control. Errores de memoria detectados, la paridad solo puede detectar. errores pero no puede corregirlos. Al mismo tiempo, aunque la probabilidad de que ocurran errores de doble bit al mismo tiempo es bastante baja, la paridad no puede detectar errores de doble bit.
El nombre completo de MD5 es Mensaje. -Algoritmo de resumen 5. Fue inventado por el Laboratorio de Ciencias de la Computación del MIT y RSA Data Security Inc a principios de la década de 1990. La aplicación práctica de MD5 se desarrolla a partir de cadenas MD2/MD3/MD4 que pueden prevenir ". Por ejemplo, Tiantian Security Network proporciona el software de verificación de valor MD5 descargable WinMD5.zip. Su valor MD5 es 1e07ab3591d25583eff5129293dc98d2, pero después de descargar el software, descubre que el MD5 está calculado. Su valor es 81395f50b94bb4891a4ce4ffb6ccf64b, lo que significa que el ZIP ha sido modificado por otros. Puede decidir usted mismo si debe utilizar este software.
MD5 se utiliza ampliamente en la tecnología de cifrado y descifrado. En el sistema operativo, la contraseña del usuario se guarda en el formulario. del valor MD5 (u otros algoritmos similares). Cuando el usuario inicia sesión, el sistema calcula la contraseña ingresada por el usuario en un valor MD5 y luego la compara con el valor MD5 guardado en el sistema. Comparar para verificar la legitimidad del. usuario
La versión china del software de verificación de valor MD5 WinMD5.zip es extremadamente simple de usar. Después de ejecutar el software, arrastre el archivo que necesita calcular el valor MD5 con el mouse al cuadro de procesamiento. el valor MD5 y el nombre del archivo probado se mostrarán directamente a continuación. El valor MD5 de varias pruebas de archivos se puede conservar. Seleccione el valor MD5 que debe copiarse y use CTRL+C para copiarlo a otros lugares. /p>
Materiales de referencia: /question/3933661.html
Principio del algoritmo CRC e implementación del lenguaje C: de (Me encantan los microcontroladores)
Resumen Este artículo se deriva teóricamente del Se presenta el principio de implementación del algoritmo CRC y se brindan tres programas en lenguaje C adaptados a diferentes entornos de hardware de computadora o microcontrolador. Los lectores pueden utilizar diferentes lenguajes para escribir programas de cálculo CRC únicos y más prácticos basados en los principios de este algoritmo.
Palabras clave Algoritmo CRC Lenguaje C
1 Introducción
La tecnología de verificación CRC de código de redundancia cíclica se utiliza ampliamente en los campos de medición, control y comunicaciones. El cálculo CRC se puede implementar mediante hardware dedicado, pero para los sistemas de microcontroladores de bajo costo, la cuestión clave al implementar la verificación CRC sin soporte de hardware es cómo completar el cálculo CRC a través del software, que es el problema del algoritmo CRC.
Aquí se proporcionarán tres algoritmos, que son ligeramente diferentes. Uno es adecuado para sistemas de microcontroladores con un espacio de programa muy exigente pero requisitos de velocidad de cálculo CRC bajos, y el otro es adecuado para sistemas de microcontrolador con un gran espacio de programa y. baja velocidad de cálculo CRC Computadoras o sistemas de microcontroladores que requieren alta velocidad de cálculo CRC. El último es adecuado para sistemas de microcontroladores que tienen un espacio de programa pequeño y una velocidad de cálculo CRC que no puede ser demasiado lenta.
2 Introducción a CRC
La idea básica de la verificación CRC es utilizar la teoría de codificación lineal para generar una verificación en el extremo emisor de acuerdo con ciertas reglas según el k-bit. Secuencia de código binario que se transmitirá. El código de supervisión (es decir, el código CRC) r bits se utiliza y se adjunta a la parte posterior de la información para formar una nueva secuencia de código binario de ***(k+r) bits, que es Finalmente enviado. En el extremo receptor, se verifica de acuerdo con las reglas seguidas entre el código de información y el código CRC para determinar si hay un error en la transmisión.
La regla para generar un código CRC de 16 bits es primero desplazar el número de secuencia binaria a enviar 16 bits hacia la izquierda (es decir, multiplicarlo) y luego dividirlo por un polinomio. El resto final es el código CRC, como. Como se muestra en la ecuación (2-1), B(X) representa un número de secuencia binaria de n bits, G(X) es un polinomio, Q(X) es un número entero y R(X) es el resto (es decir, código CRC).
(2-1)
Encuentre el algoritmo de suma y resta de módulo 2 utilizado en el código CRC. Es una suma y resta bit a bit sin acarreo y préstamo. operación de resta De hecho, es una operación XOR lógica. Las operaciones de suma y resta son equivalentes a las operaciones de multiplicación y división de expresiones algebraicas ordinarias y cumplen con las mismas reglas. El polinomio que genera el código CRC es el siguiente, donde CRC-16 y CRC-CCITT producen un código CRC de 16 bits, mientras que CRC-32 produce un código CRC de 32 bits. Este artículo no analiza el algoritmo CRC de 32 bits. Los amigos interesados pueden derivar el método de cálculo por sí mismos basándose en las ideas de este artículo.
CRC-16: (Adoptado en el sistema de sincronización binaria de EE. UU.)
CRC-CCITT: (Recomendado por el CCITT europeo)
CRC-32:
El receptor divide el número de secuencia binario recibido (incluido el código de información y el código CRC) por el polinomio. Si el resto es 0, significa que no ocurrió ningún error durante la transmisión. Incorrecto. El principio no se discutirá aquí. Cuando se utiliza software para calcular el código CRC, el receptor puede calcular el código CRC a partir del código de información recibido y verificar si el resultado de la comparación es el mismo que el código CRC recibido.
3 Calcular CRC bit a bit
Para un número de secuencia binaria, se puede expresar como la fórmula (3-1):
(3-1)
Al encontrar 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). es el código CRC requerido. Como se muestra en la fórmula (3-2):
(3-2)
Se puede establecer como: (3-3)
¿dónde está un entero, que es un resto binario de 16 bits. Sustituyendo la ecuación (3-3) en la ecuación (3-2) obtenemos:
(3-4)
Supongamos nuevamente: (3-5)
donde es un número entero y es el resto binario de 16 bits. Sustituyendo la ecuación (3-5) en la ecuación (3-4), y así sucesivamente, finalmente obtenemos:
(3-6)<. /p>
Según la definición de CRC, es obvio que el número binario de dieciséis bits es el código CRC que necesitamos.
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 bit es igual al código CRC anterior multiplicado por 2 y dividido por el polinomio. se suma al valor del bit. El resto se obtiene al dividir un polinomio. A partir de esto, no es difícil entender el siguiente programa en lenguaje C para encontrar el código CRC. *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) {
unsigned char i;
unsigned int crc=0;
mientras(len--!=0) {
for(i=0x80; i!=0; i/=2) {
if((crc&0x8000)!=0) {crc*=2; crc^=0x1021;} /* Multiplica el CRC restante por 2 y encuentra el CRC */
else crc*=2
if((*ptr&i)!=0) crc^=0x1021 /* Más el CRC local */
}
ptr++;< / p>
}
return(crc);
}
[código]
Calcular CRC bit a bit aunque el código Es simple y ocupa relativamente poca memoria, pero su mayor desventaja es que el cálculo bit a bit consumirá mucho tiempo de procesamiento del procesador, especialmente en situaciones de comunicación de alta velocidad, esta deficiencia es intolerable. Por lo tanto, introduzcamos un método para calcular rápidamente el CRC mediante la búsqueda en la tabla de bytes.
4 Calcular CRC por bytes
No es difícil entender que un número de secuencia binaria se puede expresar por bytes como la fórmula (4-1), donde es un byte (** *8bits).
(4-1)
Al encontrar 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 divida por el polinomio G(X), el resultado El resto es el código CRC requerido. Como se muestra en la fórmula (4-2):
(4-2)
Se puede establecer como: (4-3)
¿dónde está un entero, que es un resto binario de 16 bits. Sustituyendo la fórmula (4-3) en la fórmula (4-2) obtenemos:
(4-4)
Porque:
(4-5)
Entre ellos, sí están los ocho bits superiores y sí, los ocho bits inferiores. Sustituyendo la ecuación (4-5) en la ecuación (4-4), obtenemos:
(4-6)
Asuma nuevamente: (4-7)
Donde es un número entero y es el resto binario de 16 bits. Sustituyendo la ecuación (4-7) en la ecuación (4-6), y así sucesivamente, finalmente obtenemos:
(4-
Obviamente, el número binario de dieciséis dígitos es lo que requerimos código CRC.
La fórmula (4-7) es la clave para escribir un programa de cálculo CRC byte por byte. Muestra que el código CRC después de calcular este byte es igual a los 8 bits inferiores. del código CRC restante del byte anterior después de desplazar 8 bits a la izquierda, más el código CRC obtenido desplazando el CRC del byte anterior a la derecha 8 bits (tomando también los 8 bits superiores) y la suma de este. byte, si tomamos el CRC del número de secuencia binaria de 8 bits Calcula todo y colócalo en una tabla. El uso del método de búsqueda de tabla puede mejorar enormemente la velocidad de cálculo. A partir de esto, no es difícil entender el siguiente programa en lenguaje C. para encontrar el código CRC por byte, *ptr apunta al primer byte del búfer de envío, len es el número total de bytes que se enviarán y la tabla de restos de CRC se calcula en función del polinomio 0x11021.
[código]
unsigned int cal_crc(unsigned char *ptr, unsigned char len) {
unsigned int crc;
unsigned char da;
unsigned int crc_ta[256]={ /* Tabla de resto CRC*/
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
p>0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
0x 1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 2f 7, 0x62d6,
0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4 , 0x5485,
0xa56a , 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4 ,
0xb75b, 0xa77a, 0x9719 , 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
0xc9cc, 9ed, 0xe98e, 0xf9af, 0x8948 , 0x9969, 0xa90a, 0xb92b,
0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 050, 0x3a33, 0x2a12,
0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, b79, 0x8b58, 0xbb3b , 0xab1a,
0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, d68, 0x9d49,
0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0 f78,
0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x6067,
0x83b9 , 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf3
5e,
0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc d, 0xd73c,
0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, a, 0xa9ab,
0x5844 , 0x4865 , 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb,
0x 4a75, 0x5a54, 0x6a37, 0x7a16, 0f1, 0x1ad0, 0x2ab3, 0x3a92,
0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
0x7c26, 07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
0x6e17, 0x7e36, 0x4e55, 5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
};
crc=0;
mientras(len--!=0) {
da=( uchar) ( crc/256); /* Almacena temporalmente los 8 bits superiores de CRC en forma de un número binario de 8 bits*/
crc<<=8; , que es equivalente a los 8 bits inferiores de CRC Multiply */
crc^=crc_ta[da^*ptr] /* Agregue los 8 bits superiores al byte actual y luego busque la tabla para; encuentre el CRC, más el CRC anterior */
ptr++;
}
return(crc);
}
Obviamente, encuentre el CRC por bytes. En este momento, debido al uso del método de tabla de búsqueda, la velocidad de cálculo ha mejorado enormemente. Sin embargo, para los microprocesadores de 8 bits ampliamente utilizados, el espacio de código es limitado y el requisito de 256 tablas restantes CRC (máximo 512 bytes de memoria) ya es demasiado limitado. Sin embargo, la velocidad de cálculo de CRC no puede ser demasiado lenta, por lo que. Ya no presentamos el siguiente algoritmo para calcular CRC por nibble.
5 Calcular CRC en medio byte
De manera similar, un número de secuencia binaria se puede expresar en bytes como la fórmula (5-1), donde es medio byte (* **4 dígitos ).
(5-1)
Al encontrar 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 divida por el polinomio G(X), el resultado El resto es el código CRC requerido.
Como se muestra en la fórmula (4-2):
(5-2)
Se puede establecer como: (5-3)
¿dónde está un entero, que es un resto binario de 16 bits. Sustituyendo la fórmula (5-3) en la fórmula (5-2) obtenemos:
(5-4)
Porque:
(5-5)
Entre ellos, los 4 bits superiores de y los 12 bits inferiores de . Sustituyendo la ecuación (5-5) en la ecuación (5-4), obtenemos:
(5-6)
Asuma nuevamente: (5-7)
Donde es un número entero y es el resto binario de 16 bits. Sustituyendo la ecuación (5-7) en la ecuación (5-6), y así sucesivamente, finalmente obtenemos:
(5-
Obviamente, el número binario de dieciséis dígitos es lo que requerimos código CRC.
La fórmula (5-7) es la clave para escribir un programa de cálculo CRC byte por byte. Muestra que el código CRC después de calcular este byte es igual a los 12 bits inferiores. del código CRC del byte anterior Después de 4 bits, agregue el código CRC obtenido desplazando el CRC restante del byte anterior hacia la derecha 4 bits (tomando también los 4 bits superiores) y la suma de este byte. CRC del número de secuencia binaria de 4 dígitos Calcúlelos todos y colóquelos en una tabla. Utilice el método de búsqueda de tabla para contar cada byte dos veces (el mordisco se cuenta una vez), lo que puede lograr un equilibrio entre velocidad y espacio de memoria. No es difícil entender que el siguiente cálculo se basa en el código CRC del programa en lenguaje C. *ptr apunta al primer byte del búfer de envío, len es el número total de bytes que se enviarán y se calcula la tabla de restos de CRC. basado en el polinomio 0x11021
unsigned cal_crc( unsigned char *ptr, unsigned char len) {
unsigned int crc;
unsigned char da;
p>unsigned int crc_ta[16]={ /* Tabla de resto CRC*/
0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf 1ef ,
}
crc=0;
while(len--!= 0) {
da=((uchar) (crc/256))/16; /* Almacena temporalmente los cuatro bits superiores del CRC*/
crc<<=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)] /*; Agregue los 4 bits superiores del CRC al primer cuarteto de este byte y luego busque la tabla para calcular el CRC.
Luego agregue el resto del último CRC*/
da=((uchar)(crc/256))/16; /* Almacena temporalmente los 4 bits superiores del CRC*/
crc<<=4; equivalente a los 12 bits inferiores de CRC) */
crc^=crc_ta[da^(*ptr&0x0f)] /* Agregue los 4 bits superiores de CRC a la segunda mitad de este byte y observe levante la tabla para calcular el CRC.
Luego agregue el resto del CRC anterior*/
ptr++;
}
regresar (crc);
}
[código]
5 Conclusión
De los tres programas para encontrar CRC presentados anteriormente, el bit El método -wise es más lento, pero ocupa el menor espacio de memoria; el método de búsqueda de tabla basado en bytes para encontrar CRC es más rápido, pero ocupa una mayor cantidad de memoria; el método de media palabra es más rápido. Encontrar el CRC es un equilibrio entre los dos primeros, es decir, no ocupará demasiada memoria y, al mismo tiempo, la velocidad no será demasiado lenta. Es más adecuado para la aplicación de microcontroladores de 8 bits. con poca memoria. El programa C proporcionado anteriormente se puede cambiar de acuerdo con las características de cada compilador de microprocesador, como colocar la tabla de restos CRC en el área de almacenamiento del programa.
[/code]
hjzgq respondió en: 2003-05-15 14:12:51
Notas de estudio del algoritmo CRC32 y cómo implementarlo con java de: csdn bootcool 19 de octubre de 2002 23:11 Notas de estudio del algoritmo CRC32 y cómo implementarlo con java
Notas de estudio del algoritmo CRC32 y cómo implementarlo con java
1: Descripción
Acerca de CRC32 en el foro No hay muchos detalles sobre el algoritmo de verificación. Accidentalmente vi el artículo de Ross N. Williams hace unos días y finalmente descubrí los entresijos del algoritmo CRC32. Originalmente quería traducir el texto original, pero debido a limitaciones de tiempo, tuve que escribir algunas de mis experiencias de aprendizaje. De esta forma, todos podrán comprender más rápidamente la idea principal de CRC32. Debido al nivel limitado, también solicito sus correcciones. Se puede acceder al texto original:]
Tres: Cómo implementar el algoritmo CRC con software
Ahora nuestro principal problema es cómo implementar la verificación, codificación y decodificación de CRC. Actualmente es imposible implementarlo con hardware. Consideramos principalmente el método de implementación del software.
La siguiente es una traducción del texto original del autor:
Asumimos que hay un registro de 4 bits. Mediante cambios repetidos y división CRC, el valor final en el registro es. El resto lo necesitamos.
3 2 1 0 Bits
+---+---+---+---+
Pop <-- | | <----- Mensaje aumentado (datos originales con 0 expansión)
+---+---+---+---+
1 0 1 1 1 = The Poly
(Nota: el mensaje aumentado es el mensaje seguido de W cero bits).
Basado en este modelo, obtenemos el algoritmo más simple:
Establezca el valor en el registro en 0.
Agregue r ceros después de los datos originales.
Mientras (todavía hay datos sin procesar)
Comenzar
Desplaza el valor en el registro un bit hacia la izquierda, lee un nuevo dato y colócalo en la posición de 0 bits del registro.
Si (si el bit desplazado en la operación de desplazamiento a la izquierda anterior es 1)
registro = registrar XOR Poly.
Fin
El valor actual en el registro es el resto de crc que requerimos.
Mis notas de estudio:
¿Por qué hago esto? Ilustremos con el siguiente ejemplo:
1100001010
_______________
10011 11010110110000
10011,,.,,....
-----,,.,,....
－》 10011,.,,....
10011,., , ....
-----,.,,....
－》 00001.,,....
00000 . ,,....
-----.,,....
00010,,....
00000,, . ...
-----,,....
00101,....
00000,....
Sabemos que el dígito más alto de G(x) debe ser 1, y si el cociente es 1 o 0 está determinado por el dígito más alto del dividendo. Y no nos importa cuál sea el cociente, nos importa el resto. Por ejemplo, G(x) en el ejemplo anterior tiene 5 bits. Podemos ver que el resto obtenido de la operación de división en cada paso es en realidad el XOR de los últimos cuatro dígitos de G(x) después del dígito más alto del dividendo.
Entonces, ¿de qué sirve la parte más alta del dividendo? Conocemos el motivo por los dos restos diferentes marcados. Cuando el bit más alto del dividendo es 1, el cociente 1 realiza una operación XOR de los cuatro bits después del bit más alto con los últimos cuatro bits de G(x) para obtener el resto. Si el bit más alto es 0, el cociente 0 luego pone el; cuatro bits después del bit más alto del dividendo en G Los últimos cuatro dígitos de (x) se XOR para obtener el resto, y encontramos que este resto es en realidad el valor de los cuatro dígitos después del dígito más alto del dividendo original. Es decir, si el bit más alto es 0, no es necesario realizar la operación XOR. En este punto, finalmente sabemos por qué construimos el modelo de esta manera antes y el principio del algoritmo es claro.
La siguiente es una traducción del texto original del autor:
Sin embargo, el algoritmo implementado de esta manera es muy ineficiente. Para acelerarlo, le permitimos procesar datos de más de 4 bits a la vez. Esa es la verificación CRC de 32 bits que queremos implementar. Seguimos asumiendo que existe el mismo registro de 4 "bits" que antes. Pero cada bit es un byte de 8 bits.
3 2 1 0 Bytes
+----+----+----+----+
Pop <- - | | | | <---- Mensaje aumentado
+----+----+----+----+
1 <------32 bits------> (implica un bit más alto "1")
Basado en el mismo principio, podemos obtener el siguiente algoritmo:
Mientras (todavía hay datos sin procesar)
Comenzar
Verificar el byte del encabezado del registro y obtener su valor
Encontrar diferentes compensaciones La suma de polinomios
Desplaza el registro un byte hacia la izquierda y almacena el byte recién leído en la posición más a la derecha
Realiza la operación XOR en el valor del registro y la suma de polinomios
Fin
Mis notas de estudio:
Pero ¿por qué hacemos esto? De manera similar, usaremos un ejemplo simple para ilustrar el problema:
Supongamos que hay algunos valores como este:
El valor en el registro actual: 01001101
4 bits deben ser El valor movido hacia fuera: 1011
El polinomio generador es: 101011100
Registro superior
---- ----- ---
1011 01001101
1010 11100 + (CRC XOR)
-------------
0001 10101101
Si los primeros 4 bits no son 0, significa que la división no está completa y la división debe continuar:
0001 10101101
1 01011100 + (CRC XOR)
- ------------
0000 11110001
^^^^
Los primeros 4 bits son todos 0, lo que indica que no es necesario continuar excepto.
¿Cuál será el resultado de seguir el algoritmo?
1010 11100
1 0101110
-------------
1011 10111100 p>
1011 10111100
1011 01001101+
-------------
0000 11110001
Ahora vemos el hecho de que el resultado de hacer esto es consistente con el resultado anterior. Esto también explica por qué en el algoritmo es necesario primero sumar los valores polinomiales según diferentes valores de compensación y luego realizar una operación XOR con el registro. Además, también podemos ver que cada byte de encabezado corresponde a un valor. Por ejemplo, en el ejemplo anterior: 1011 corresponde a 01001101.
Entonces, para el byte de encabezado CRC de 32 bits, según nuestro modelo. Debe haber 2 ^ 8 primeros 8 bits, es decir, le corresponden 256 valores. Entonces podemos crear una tabla por adelantado y luego, al codificar, simplemente sacar el primer byte de los datos de entrada y buscar el valor correspondiente en la tabla. Esto puede mejorar enormemente la velocidad de codificación.
+----+----+----+----+
+----< | --- Mensaje aumentado
| +----+----+----+----+
| |
| XOR
| |
| ----+----+----+----+
v +----+----+----+----+
| +----+----+-- --+----+
| +----+----+----+----+
| +----+----+----+
| +----+----+----+----+
| +----+----+----+----+
+-----> +----+----+- ---+----+
+----+----+----+----+
+----+ ----+----+----+
+----+----+----+----+
+----+----+----+----+
255+----+----+----+----+
La siguiente es una traducción del texto original del autor:
El algoritmo anterior se puede optimizar aún más como:
1: el registro se desplaza un byte hacia la izquierda de los datos originales Lea un nuevo byte.
2: utilice el byte que acaba de sacar del registro como subíndice para ubicar un valor de 32 bits en la tabla
3: Ponga este valor XOR en el registro.
4: Si aún quedan datos sin procesar, volver al primer paso y continuar con la ejecución.
Se puede escribir así en C:
r=0;
mientras (len--)
r = ( (r < < | p*++) ^ t[(r >> 24) & 0xFF];
Pero este algoritmo se basa en los datos originales que se han extendido con 0, por lo que necesita se agregará al final. Dicho bucle agrega W 0 a los datos originales.
Mis notas de estudio:
Tenga en cuenta que los W 0 no se agregan primero durante el preprocesamiento, pero se describen en. el algoritmo anterior Agregue dicho procesamiento después del bucle
for (i=0; i r = (r << ^ t[(r >). > 24) & 0xFF]; Entonces es W/4 porque si hay W 0, debido a que usamos bytes (8 bits) como unidad, es W/4 0 bytes. que no lo es. Bucle w/8 veces La siguiente es la traducción del texto original del autor: 1: Para los w/4 0 bytes al final, de hecho. su función es simplemente 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, entonces los primeros 4 ciclos solo procesarán el los primeros 4 bytes de los datos originales. Envíelos al registro (esto depende de la generación de la tabla). Incluso si el valor inicial del registro no es 0, los primeros cuatro bytes de los datos originales simplemente se realizan mediante XOR. de registro, y luego Enviarlo a registrarse. 3A xor B) xor C = A xor (B xor C) En resumen, el algoritmo original se puede cambiar a: +-- - -- | v 3 2 1 0 Bytes | +----+----+- - --+----+ XOR----<| | | ----+ | ^ | | | +----+----+----+----+ v +----+----+----+---- + | +----+----+----+----+ | --+----+ | +----+----+----+----+ | +----+----+----+ | +----+----+----+----+ +----->+----+----+----+----+ +----+----+- - --+----+ +----+----+----+----+ +----+ - ---+----+----+ +----+----+----+----+ 255 +----+----+----+----+ Algoritmo: 1: Desplazar el registro a la izquierda en un byte de los datos originales Leer un nuevo byte en. 2: Utilice el XOR del byte que acaba de sacar del registro y el nuevo byte leído para generar un subíndice de posicionamiento y obtener el valor correspondiente de la tabla. 3: XOR el valor en el registro 4: Si todavía hay datos sin procesar, regrese al primer paso y continúe la ejecución. Mis notas de estudio: Todavía no sé mucho sobre este algoritmo. Tal vez tenga algo que ver con las propiedades de XOR. Por favor, indique por qué. 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 implementarlo en lenguaje Java basado en ideas algorítmicas. hjzgq respondió en: 2003-05-15 14:14:51 El algoritmo matemático siempre ha sido el núcleo del cifrado de contraseñas, pero en general, el cifrado de ruta suave no lo es. Parece que a la gente no le importa mucho, porque la mayoría de las veces el cifrado de software en sí es una técnica de programación. Sin embargo, con la popularidad de los programas de cifrado de números de serie en los últimos años, la proporción de algoritmos matemáticos en el cifrado de software parece estar aumentando. Echemos un vistazo primero a cómo funciona el cifrado de números de serie tan popular en Internet. Cuando un usuario descarga una pieza de Shareware de Internet, un software gratuito, generalmente hay un límite de tiempo para su uso. Una vez transcurrido el período de prueba del software gratuito, debe ir a la empresa del software para registrarse. para ser utilizado. El proceso de registro generalmente implica que el usuario proporcione a la compañía de software su información personal (generalmente principalmente su nombre) y su número de tarjeta de crédito. La compañía de software calculará un código de serie basado en la información del usuario. Siga los requisitos de registro: Ingrese la información de registro y el código de registro en el software. Después de que el software verifique la legalidad de la información de registro, el software cancelará sus diversas restricciones. Este tipo de cifrado es relativamente sencillo de implementar, no requiere costos adicionales y es muy conveniente para los usuarios comprar el 80% del software en Internet está protegido de esta manera. Podemos notar que el proceso de legalidad del software que verifica el 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. Existen dos métodos de verificación más básicos. Uno 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)