Criptografía de cifrado asimétrico en Java

La criptografía es el estudio de diferentes técnicas para proteger los datos de una entidad no autorizada. En informática, tratamos de desarrollar estrategias y prácticas para proteger datos confidenciales. La mayor parte de la criptografía implica funciones matemáticas muy avanzadas que se utilizan para proteger los datos. El único propósito de los algoritmos desarrollados para criptografía es ocultar datos del atacante o intermediario.
En el artículo anterior, hemos estudiado los diferentes métodos, clases y enfoques para realizar el cifrado y descifrado simétrico. En este artículo, entenderemos el cifrado asimétrico. 
Cifrado asimétrico, también llamado clave privada/pública El cifrado es una relación matemática entre dos claves, una para el cifrado y otra para el descifrado. Por ejemplo, si hay dos claves «K1» y «K2», entonces si la clave «K1» se usa para el cifrado y «K2» se usa para el descifrado. Si se usa «K1» para el descifrado, entonces se usa «K2» para el cifrado.

Antes de implementar el cifrado asimétrico utilizando el algoritmo RSA , primero veremos cómo generar un par de claves (pública, privada). Se pueden seguir los siguientes pasos para generar una clave asimétrica:
 

• Primero debemos generar una clave pública y privada utilizando la clase SecureRandom . La clase SecureRandom se utiliza para generar números aleatorios. 
   

SecureRandom aleatorio = new SecureRandom();

• La clase KeyGenerator proporcionará el método getInstance() que se puede usar para pasar una variable de string que denota el algoritmo de generación de claves. Devuelve KeyGenerator Object. Estamos utilizando el algoritmo RSA para generar las claves. 
   

KeyPairGenerator KPGenerator = KeyPairGenerator.getInstance(Key_Generation_Algorithm_string_variable); 
 

• Inicializar el objeto keyGenerator con un tamaño de clave de 2048 bits y pasar el número aleatorio. 
   

keyPairGenerator.initialize(2048, seguroRandom); 

• Ahora, se genera la clave secreta y si realmente deseamos ver la clave generada que es un objeto, podemos convertirla a formato hexadecimal utilizando DatatypeConverter.

A continuación se muestra la implementación del enfoque anterior:
 

// Java program to create a
// asymmetric key
 
package java_cryptography;
import java.security.KeyPair;
import java.security
    .KeyPairGenerator;
import java.security
    .SecureRandom;
import javax.xml.bind
    .DatatypeConverter;
 
// Class to create an asymmetric key
public class Asymmetric {
 
    private static final String RSA
        = "RSA";
 
    // Generating public and private keys
    // using RSA algorithm.
    public static KeyPair generateRSAKkeyPair()
        throws Exception
    {
        SecureRandom secureRandom
            = new SecureRandom();
 
        KeyPairGenerator keyPairGenerator
            = KeyPairGenerator.getInstance(RSA);
 
        keyPairGenerator.initialize(
            2048, secureRandom);
 
        return keyPairGenerator
            .generateKeyPair();
    }
 
    // Driver code
    public static void main(String args[])
        throws Exception
    {
        KeyPair keypair
            = generateRSAKkeyPair();
 
        System.out.println(
            "Public Key is: "
            + DatatypeConverter.printHexBinary(
                  keypair.getPublic().getEncoded()));
 
        System.out.println(
            "Private Key is: "
            + DatatypeConverter.printHexBinary(
                  keypair.getPrivate().getEncoded()));
    }
}

Producción:
 

Cifrado y descifrado usando la clave asimétrica: en los pasos anteriores, hemos creado las claves públicas y privadas para el cifrado y el descifrado. Ahora, implementemos el cifrado asimétrico utilizando el algoritmo RSA. Se pueden seguir los siguientes pasos para implementar el cifrado y descifrado. 
 

• La clase de cifrado se utiliza para dos modos diferentes, el cifrado y el descifrado. Como el cifrado asimétrico usa claves diferentes, usamos la clave privada para el cifrado y la clave pública para el descifrado. 
   

cipher.init(Cipher.ENCRYPT_MODE, clave privada); 
cipher.init(Cipher.DECRYPT_MODE, publicKey); 
 

• El método doFinal() se invoca en el cifrado que cifra/descifra los datos en una operación de una sola parte, o finaliza una operación de varias partes y devuelve una array de bytes.
• Finalmente obtenemos el texto cifrado después del cifrado con ENCRYPT_MODE.

A continuación se muestra la implementación del enfoque anterior:
 

// Java program to perform the
// encryption and decryption
// using asymmetric key
 
package java_cryptography;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.util.Scanner;
 
import javax.crypto.Cipher;
import javax.xml.bind
    .DatatypeConverter;
 
public class Asymmetric {
 
    private static final String RSA
        = "RSA";
    private static Scanner sc;
 
    // Generating public & private keys
    // using RSA algorithm.
    public static KeyPair generateRSAKkeyPair()
        throws Exception
    {
        SecureRandom secureRandom
            = new SecureRandom();
        KeyPairGenerator keyPairGenerator
            = KeyPairGenerator.getInstance(RSA);
 
        keyPairGenerator.initialize(
            2048, secureRandom);
        return keyPairGenerator
            .generateKeyPair();
    }
 
    // Encryption function which converts
    // the plainText into a cipherText
    // using private Key.
    public static byte[] do_RSAEncryption(
        String plainText,
        PrivateKey privateKey)
        throws Exception
    {
        Cipher cipher
            = Cipher.getInstance(RSA);
 
        cipher.init(
            Cipher.ENCRYPT_MODE, privateKey);
 
        return cipher.doFinal(
            plainText.getBytes());
    }
 
    // Decryption function which converts
    // the ciphertext back to the
    // original plaintext.
    public static String do_RSADecryption(
        byte[] cipherText,
        PublicKey publicKey)
        throws Exception
    {
        Cipher cipher
            = Cipher.getInstance(RSA);
 
        cipher.init(Cipher.DECRYPT_MODE,
                    publicKey);
        byte[] result
            = cipher.doFinal(cipherText);
 
        return new String(result);
    }
 
    // Driver code
    public static void main(String args[])
        throws Exception
    {
        KeyPair keypair
            = generateRSAKkeyPair();
 
        String plainText = "This is the PlainText "
                           + "I want to Encrypt using RSA.";
 
        byte[] cipherText
            = do_RSAEncryption(
                plainText,
                keypair.getPrivate());
 
        System.out.println(
            "The Public Key is: "
            + DatatypeConverter.printHexBinary(
                  keypair.getPublic().getEncoded()));
 
        System.out.println(
            "The Private Key is: "
            + DatatypeConverter.printHexBinary(
                  keypair.getPrivate().getEncoded()));
 
        System.out.print("The Encrypted Text is: ");
 
        System.out.println(
            DatatypeConverter.printHexBinary(
                cipherText));
 
        String decryptedText
            = do_RSADecryption(
                cipherText,
                keypair.getPublic());
 
        System.out.println(
            "The decrypted text is: "
            + decryptedText);
    }
}

Producción: