Implementación Java de Firmas Digitales en Criptografía

Las firmas digitales son un hash cifrado asimétricamente de un mensaje digital (datos). Es un valor que puede proporcionar una garantía de autenticidad, no repudio e integridad. En otros términos, significa que puede verificar que el remitente, la fecha y la hora y el contenido del mensaje no hayan sido revelados ni comprometidos.

Nota: puede consultar este enlace para comprender mejor los términos criptográficos.

Cálculo de Firma Digital

Las firmas digitales a menudo se calculan mediante criptografía de curva elíptica, especialmente en dispositivos IoT, pero usaremos RSA con fines de demostración. Primero, tomaremos el mensaje de entrada y crearemos un hash con SHA-256 debido a su velocidad y seguridad, y luego cifraremos ese hash con la clave privada del par de claves asimétricas. Por otro lado, el receptor lo descifrará usando la clave pública y comparará el hash para asegurarse de que sean iguales.

Flujo de firma digital

Deje que «A» y «B» sean los actores ficticios en el sistema criptográfico para una mejor comprensión.
“A” es el remitente y calcula el hash del mensaje y adjunta la firma que quiere enviar usando su clave privada.
El otro lado «B» procesa el mensaje y luego descifra la firma con la clave pública de A y compara los dos hashes.
Si «B» encuentra que los hashes coinciden, entonces el mensaje no ha sido alterado ni comprometido.

Implementación de firmas digitales

Implementemos la firma digital usando los algoritmos SHA y RSA y también verifiquemos si el hash coincide con una clave pública.

Acercarse:

Cree un método denominado Create_Digital_Signature() para implementar la firma digital pasando dos parámetros, el mensaje de entrada y la clave privada. En este método, obtendremos una instancia del objeto de firma que pasa el algoritmo de firma y le asignaremos una clave privada y finalmente pasaremos la entrada, esto devolverá una array de bytes.
```
public static byte[] Create_Digital_Signature(byte[] input, PrivateKey privateKey);
signature.initSign(privateKey);
signature.update(input);
```

El siguiente paso es generar un par de claves asimétricas utilizando el algoritmo RSA y las funciones de clase SecureRandom.

SecureRandom secureRandom =new SecureRandom();
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);

Finalmente verificando la firma usando clave pública. El método Verify_Digital_Signature() se usa para verificar si la firma coincide pasándole la entrada, la firma y la clave pública.
```
Signature signature = Signature.getInstance(SIGNING_ALGORITHM);
        signature.initVerify(publickey);
        signature.update(input);
```

Ejemplo:

Entrada: msg = «GEEKSFORGEEEKS ES UN PORTAL DE CIENCIAS DE LA COMPUTACIÓN»
Salida:
Valor de la firma:
80429D3FA203437B4098CAF774D96C827B6CC2489F437A82926DA2EFCE64EF68FB33235B9F6BA8E3B033235B9F6BA8
Verificación: verdadero

A continuación se muestra la implementación:

// Java implementation for Generating
// and verifying the digital signature
  
package java_cryptography;
  
// Imports
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;
import java.util.Scanner;
  
import javax.xml.bind.DatatypeConverter;
  
public class Digital_Signature_GeeksforGeeks {
  
    // Signing Algorithm
    private static final String
        SIGNING_ALGORITHM
        = "SHA256withRSA";
    private static final String RSA = "RSA";
    private static Scanner sc;
  
    // Function to implement Digital signature
    // using SHA256 and RSA algorithm
    // by passing private key.
    public static byte[] Create_Digital_Signature(
        byte[] input,
        PrivateKey Key)
        throws Exception
    {
        Signature signature
            = Signature.getInstance(
                SIGNING_ALGORITHM);
        signature.initSign(Key);
        signature.update(input);
        return signature.sign();
    }
  
    // Generating the asymmetric key pair
    // using SecureRandom class
    // functions and RSA algorithm.
    public static KeyPair Generate_RSA_KeyPair()
        throws Exception
    {
        SecureRandom secureRandom
            = new SecureRandom();
        KeyPairGenerator keyPairGenerator
            = KeyPairGenerator
                  .getInstance(RSA);
        keyPairGenerator
            .initialize(
                2048, secureRandom);
        return keyPairGenerator
            .generateKeyPair();
    }
  
    // Function for Verification of the
    // digital signature by using the public key
    public static boolean
    Verify_Digital_Signature(
        byte[] input,
        byte[] signatureToVerify,
        PublicKey key)
        throws Exception
    {
        Signature signature
            = Signature.getInstance(
                SIGNING_ALGORITHM);
        signature.initVerify(key);
        signature.update(input);
        return signature
            .verify(signatureToVerify);
    }
  
    // Driver Code
    public static void main(String args[])
        throws Exception
    {
  
        String input
            = "GEEKSFORGEEKS IS A"
              + " COMPUTER SCIENCE PORTAL";
        KeyPair keyPair
            = Generate_RSA_KeyPair();
  
        // Function Call
        byte[] signature
            = Create_Digital_Signature(
                input.getBytes(),
                keyPair.getPrivate());
  
        System.out.println(
            "Signature Value:\n "
            + DatatypeConverter
                  .printHexBinary(signature));
  
        System.out.println(
            "Verification: "
            + Verify_Digital_Signature(
                  input.getBytes(),
                  signature, keyPair.getPublic()));
    }
}

Producción:

Publicación traducida automáticamente

Artículo escrito por nimma_shravan_kumar_reddy y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Implementación de firmas digitales

Deja una respuesta Cancelar la respuesta