El valor alfanumérico, es decir, la secuencia de letras y números que define de forma única el contenido de un archivo se denomina suma de comprobación (a menudo denominada hash). Las sumas de verificación generalmente se usan para verificar la integridad de los archivos descargados de una fuente externa. Puede usar una utilidad de suma de verificación para asegurarse de que su copia sea equivalente si conoce la suma de verificación de la versión original. Por ejemplo, antes de hacer una copia de seguridad de sus archivos, puede generar una suma de verificación de esos archivos y puede verificar lo mismo una vez que tenga que descargarlos en algún otro dispositivo. La suma de comprobación sería diferente si el archivo se ha dañado o alterado en el proceso.
MD5 y SHA son los dos algoritmos de suma de comprobación más utilizados. Debe asegurarse de utilizar el mismo algoritmo que se ha utilizado para generar la suma de comprobación al comprobar las sumas de comprobación. Por ejemplo, el valor de suma de verificación MD5 de un archivo es totalmente diferente de su valor de suma de verificación SHA-256.
Para producir una suma de comprobación, ejecuta un programa que somete ese archivo a un algoritmo. Los algoritmos típicos utilizados para esto incluyen MD5, SHA-1, SHA-256 y SHA-512.
Estos algoritmos utilizan una función hash criptográfica que toma una entrada y genera una string alfanumérica de longitud fija, independientemente del tamaño del archivo.
NOTA:
- Incluso pequeños cambios en el archivo producirán una suma de verificación diferente.
- Sin embargo, estas funciones hash criptográficas no son perfectas. Los investigadores de seguridad han descubierto «colisiones» con las funciones MD5 y SHA-1. Encontraron dos archivos diferentes, que producen el mismo hash MD5 o SHA-1, pero son diferentes. Es muy poco probable que esto suceda por mero accidente, pero un atacante puede utilizar esta estrategia para enmascarar un archivo malicioso como un archivo válido.
Generando Checksum en Java
Java proporciona una funcionalidad incorporada para generar estas funciones hash a través de MessageDigest Class presente en el paquete de seguridad de Java. Los resúmenes de mensajes son funciones hash unidireccionales cifradas que toman datos de tamaño arbitrario y producen un valor hash de longitud fija.
- Primero comenzamos con la creación de instancias del objeto MessageDigest pasando cualquier string de algoritmo hash válida.
- Luego actualizamos este objeto hasta que leemos el archivo completo. Aunque podemos usar el resumen (entrada de byte []) que crea una actualización final en el objeto MessageDigest leyendo todo el archivo a la vez en caso de que el archivo sea demasiado grande, es posible que no tengamos suficiente memoria para leer el archivo completo como un array de bytes y esto podría resultar en Java.lang.OutOfMemoryError: Java Heap Space .
- Por lo tanto, es mejor leer los datos por partes y actualizar MessageDigest.
Una vez que se completa la actualización, se llama a uno de los métodos de resumen para completar el cálculo del hash. Cada vez que se llama a un método de resumen, el objeto MessageDigest se restablece a su estado inicializado. El método de resumen devuelve una array de bytes que tiene bytes en formato decimal, por lo que lo convertimos a formato hexadecimal. Y la string final es la suma de comprobación.
Ejemplo:
Java
// Java program to Generate MD5 Checksum for Files
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class GFG {
// this method gives a NoSuchAlgorithmException in case
// we pass a string which dosen't have any hashing
// algorithm in its correspondence
public static void main(String[] args)
throws IOException, NoSuchAlgorithmException
{
// create a file object referencing any file from
// the system of which checksum is to be generated
File file = new File("C:\\Users\\Raghav\\Desktop\\GFG.txt");
// instantiate a MessageDigest Object by passing
// string "MD5" this means that this object will use
// MD5 hashing algorithm to generate the checksum
MessageDigest mdigest = MessageDigest.getInstance("MD5");
// Get the checksum
String checksum = checksum(mdigest, file);
// print out the checksum
System.out.println(checksum);
}
// this method return the complete hash of the file
// passed
private static String checksum(MessageDigest digest,
File file)
throws IOException
{
// Get file input stream for reading the file
// content
FileInputStream fis = new FileInputStream(file);
// Create byte array to read data in chunks
byte[] byteArray = new byte[1024];
int bytesCount = 0;
// read the data from file and update that data in
// the message digest
while ((bytesCount = fis.read(byteArray)) != -1)
{
digest.update(byteArray, 0, bytesCount);
};
// close the input stream
fis.close();
// store the bytes returned by the digest() method
byte[] bytes = digest.digest();
// this array of bytes has bytes in decimal format
// so we need to convert it into hexadecimal format
// for this we create an object of StringBuilder
// since it allows us to update the string i.e. its
// mutable
StringBuilder sb = new StringBuilder();
// loop through the bytes array
for (int i = 0; i < bytes.length; i++) {
// the following line converts the decimal into
// hexadecimal format and appends that to the
// StringBuilder object
sb.append(Integer
.toString((bytes[i] & 0xff) + 0x100, 16)
.substring(1));
}
// finally we return the complete hash
return sb.toString();
}
}
Producción:
8eeecb74627e963d65d10cbf92a2b7c9