Función hash criptográfica en Java

Cryptographic Hash es una función Hash que toma una entrada de tamaño aleatorio y produce una salida de tamaño fijo. Es fácil de calcular, pero difícil recuperar los datos originales. Es fuerte y difícil duplicar el mismo hash con entradas únicas y es una función unidireccional, por lo que no es posible revertir. Hashing también se conoce con diferentes nombres como Digest, Message Digest , Checksum , etc.

Propiedades de la función hash de criptografía

La función hash criptográfica ideal tiene las siguientes propiedades principales:

1. Determinista: Esto significa que el mismo mensaje siempre da como resultado el mismo hash.
2. Rápido: es rápido calcular el valor hash para cualquier mensaje dado.
3. Efecto de avalancha: esto significa que cada cambio menor en el mensaje da como resultado un cambio importante en el valor hash.
4. Función unidireccional: no puede invertir la función hash criptográfica para acceder a los datos.
5. Resistencia a colisiones: es inviable encontrar dos mensajes diferentes que produzcan el mismo valor hash.

hachís agrietado

A menudo escuchamos el término Cracking a Hash, hay un par de formas de hacerlo: 

• Encuentre un algoritmo para generar una colisión entre dos hashes. Cuanto más avanzado es el algoritmo, más difícil es descifrar el hash.
• Otra forma es encontrar un algoritmo para identificar una entrada única y diferente que produzca un hash dado. Es similar a una colisión, pero en lugar de colisionar, nos enfocamos en encontrar la entrada usando un algoritmo.
• Algunos hashes comunes que todavía usamos hoy en día y que se consideran «crackeados» desde un punto de vista criptográfico son MD5 (algoritmo de resumen de mensaje) y SHA-1 (algoritmo de hash seguro 1). Tenga en cuenta que estos son hashes técnicamente rotos y nunca se usan para fines de seguridad.

Cómo crear un hash criptográfico

• Cree un valor de sal aleatorio utilizando la clase SecureRandom, la clase SecureRandom genera valores aleatorios fuertes. El método engineNextBytes(byte[] bytes) se utiliza para generar un número de bytes aleatorios especificado por el usuario.
• Convierta dos conjuntos de bytes en uno usando la clase ByteArrayOutputStream y creándolo en ByteArray.
• Cree una instancia de un messageDigest pasando SHA2_ALGORITHM que devuelve un hash del valor de entrada dado.
• UUID se usa para generar un número aleatorio que se convierte en string y se pasa como entrada.
• El objeto devuelto se puede convertir a un formato binario hexadecimal utilizando DatatypeConverter.

// Java program to demonstrate
// how to create a Hash
 
package java_cryptography;
 
import java.io.ByteArrayOutputStream;
import java.security.MessageDigest;
import java.util.UUID;
import javax.xml.bind.DatatypeConverter;
import sun.security.provider.SecureRandom;
 
public class Hashing {
 
    // Initializing the final string variable
    private static final String SHA2_ALGORITHM
        = "SHA-256";
 
    // Creating a random salt value to prevent
    // attacks from the Rainbow table.
    public static byte[] Creating_Random_Salt()
    {
        byte[] salt = new byte[16];
        SecureRandom secure_random
            = new SecureRandom();
        secure_random.engineNextBytes(salt);
        return salt;
    }
 
    // Creating hash value using input value
    // and salt using the SHA2 Algorithm.
    public static byte[] Creating_SHA2_Hash(
        String input, byte[] salt) throws Exception
    {
        ByteArrayOutputStream byte_Stream
            = new ByteArrayOutputStream();
 
        byte_Stream.write(salt);
        byte_Stream.write(input.getBytes());
        byte[] valueToHash
            = byte_Stream.toByteArray();
        MessageDigest messageDigest
            = MessageDigest
                  .getInstance(SHA2_ALGORITHM);
        return messageDigest
            .digest(valueToHash);
    }
 
    public static void main(String args[])
        throws Exception
    {
 
        // Calling the function Creating_Random_Salt()
        // to generate a random salt value
        byte[] salt = Creating_Random_Salt();
        System.out.println(
            "SALT_VALUE: "
            + DatatypeConverter.printHexBinary(salt));
        String valueToHash
            = UUID.randomUUID().toString();
 
        // Generating first hash with the salt
        byte[] hash1
            = Creating_SHA2_Hash(valueToHash, salt);
 
        // Generating second hash with exact salt
        // to check if we get the same hash.
        byte[] hash2
            = Creating_SHA2_Hash(valueToHash, salt);
 
        // Print first and the second hash value
        System.out.println(
            "HASH1_VALUE: "
            + DatatypeConverter
                  .printHexBinary(hash1));
        System.out.println(
            "HASH2_VALUE: "
            + DatatypeConverter
                  .printHexBinary(hash2));
    }
}

Nota: Salt es un valor aleatorio que se agrega a los datos de entrada (contraseñas) para defenderse de los ataques hash calculados previamente, como las tablas Rainbow.

Producción:

SALT_VALUE: A96BB94B1FDACDD9B5FDDFFF2E173366 HASH1_VALUE: 53C77F310EEBCBDA585E9458BCA02715555624D9838190AC7DB5F7FA424C8429 HASH2_VALUE: 53C77F310EEBCBDA585E9458BCA02715555624D9838190AC7DB5F7FA424C8429

Cómo crear contraseñas de hashing criptográfico

Como hemos visto cómo generar un Hash ahora, usemos Bcrypt para codificar una contraseña. No utilice algoritmos Hashing rotos para Hashing Passwords. Bcrypt es una función Hashing de contraseñas basada en Blowfish Cipher .

Acercarse:

• Pase la contraseña a la función hashpw que está en la clase Bcrypt, que también puede generar la sal por sí misma y devuelve una string.
• Verifique si el hash de la contraseña y la contraseña realmente coinciden usando la función checkpw(). Devuelve un valor booleano.

Código:

// Java program to demonstrate
// how to hash a password
 
package java_cryptography;
 
import java.util.Scanner;
import org.springframework
    .security
    .crypto
    .bcrypt
    .BCrypt;
 
public class Hashing {
 
    // Creating a private instance
    // of Scanner class
    private static Scanner sc;
 
    // BCrypt is a password Hashing
    // Function based on Blowfish
    // Algorithm.
    public static String Password_Hash(
        String password)
    {
        return BCrypt.hashpw(
            password, BCrypt.gensalt());
    }
 
    // Verifying password with the
    // hashed password.
    public static boolean Verify_Password(
        String password,
        String hashed_password)
    {
        return BCrypt.checkpw(
            password, hashed_password);
    }
 
    public static void main(
        String args[]) throws Exception
    {
 
        // Scanner class instance connected
        // to the Input Stream(System.in)
        sc = new Scanner(System.in);
 
        System.out.println(
            "Enter the password: ");
 
        // Scanner class instance
        // reading the user input
        String p = sc.nextLine();
 
        // Generate hashed password
        String passwordHash
            = Password_Hash(p);
 
        // Print Hashed Password
        System.out.println(
            "Hashed-password: "
            + passwordHash);
 
        // Printing the result of verification
        // of hashed password
        // with original password
        System.out.println(
            "Verification: "
            + Verify_Password(
                  p, passwordHash));
    }
}

Producción:

Entrada: Ingrese la contraseña: GEEKS FOR GEEKS Salida: Hashed-password: $2a$10$u6MFjykfR76nHGfhYYzjjOOe1I3EY.YxpQY4vKRHpKRCqz7w69RTa Verificación: verdadero

Usos de hash

• Firmas digitales.
• Huellas dactilares digitales.
• Registro de datos confidenciales.
• Guardar contraseñas.