Implementación del algoritmo Vernam Cipher o One Time Pad

El algoritmo One Time Pad es la mejora del Vernam Cipher , propuesto por un oficial de Army Signal Corp, Joseph Mauborgne. Es el único algoritmo disponible que es irrompible (completamente seguro). Es un método de encriptación de texto sin formato alfabético. Es una de las técnicas de sustitución que convierte texto sin formato en texto cifrado. En este mecanismo asignamos un número a cada carácter del Texto Plano.

Los dos requisitos para el One-Time pad son

  • La clave debe generarse aleatoriamente siempre que el tamaño del mensaje .
  • La clave se utilizará para cifrar y descifrar un solo mensaje , y luego se desechará .

Por lo tanto, para cifrar cada mensaje nuevo se requiere una clave nueva de la misma longitud que el mensaje nuevo en el bloc de notas de un solo uso.

El texto cifrado generado por One-Time pad es aleatorio, por lo que no tiene ninguna relación estadística con el texto sin formato.

La asignación es la siguiente: 

A B C D mi F GRAMO H yo j
0 1 2 3 4 5 6 7 8 9
k L METRO norte O PAGS q R S T
10 11 12 13 14 15 dieciséis 17 18 19
tu V W X Y Z
20 21 22 23 24 25

La relación entre la clave y el texto sin formato: en este algoritmo, la longitud de la clave debe ser igual a la del texto sin formato.

Ejemplos:

Entrada: Mensaje = HOLA, Clave = DINERO Salida: Cifrado – TSYPM, Mensaje – HOLA Explicación:     Parte 1: Texto sin formato a texto cifrado Texto sin formato — HOLA → 7 4 11 11 14 Clave — DINERO → 12 14 13 4 24 Texto sin formato + tecla → 19 18 24 15 38 → 19 18 24 15 12 (= 38 – 26)         Texto cifrado → TSYPM     Parte 2: Texto cifrado a mensaje Texto cifrado — TSYPM → 19 18 24 15 12 Clave — DINERO→ 12 14 13 4 24 Texto cifrado – tecla → 7 4 11 11 -12 → 7 4 11 11 14         Mensaje → HOLA Entrada: Mensaje = GUARDAR, Clave = VIDA Salida: Cifrado – DIAI Mensaje – GUARDAR

Seguridad de One-Time Pad

  • Si de alguna manera el criptoanalista encuentra estas dos claves con las que se producen dos textos sin formato, pero si la clave se produjo al azar, entonces el criptoanalista no puede encontrar qué clave es más probable que la otra. De hecho, para cualquier texto sin formato del tamaño del texto cifrado, existe una clave que produce ese texto sin formato.
  • Entonces, si un criptoanalista intenta el ataque de fuerza bruta (intente usar todas las claves posibles), terminará con muchos textos sin formato legítimos, sin forma de saber qué texto sin formato es legítimo. Por lo tanto, el código es irrompible.
  • La seguridad del bloc de notas de un solo uso depende completamente de la aleatoriedad de la clave. Si los caracteres de la clave son verdaderamente aleatorios, los caracteres del texto cifrado serán verdaderamente aleatorios. Por lo tanto, no hay patrones o regularidades que un criptoanalista pueda usar para atacar el texto cifrado.

Ventajas

  • One-Time Pad es el único algoritmo que es realmente indescifrable y se puede usar para canales de bajo ancho de banda que requieren una seguridad muy alta (por ejemplo, para usos militares).

Desventajas

  • Existe el problema práctico de hacer grandes cantidades de claves aleatorias. Cualquier sistema muy utilizado puede requerir millones de caracteres aleatorios de forma regular.
  • Para que se envíe cada mensaje, tanto el remitente como el receptor necesitan una clave de igual longitud. Por lo tanto, existe un problema gigantesco de distribución de claves.

A continuación se muestra la implementación del cifrado de Vernam:

Java

// Java program Implementing One Time Pad Algorithm
 
// Importing required classes
import java.io.*;
 
// Main class
public class GFG {
 
    // Method 1
    // Returning encrypted text
    public static String stringEncryption(String text,
                                          String key)
    {
 
        // Initializing cipherText
        String cipherText = "";
 
        // Initialize cipher array of key length
        // which stores the sum of corresponding no.'s
        // of plainText and key.
        int cipher[] = new int[key.length()];
 
        for (int i = 0; i < key.length(); i++) {
            cipher[i] = text.charAt(i) - 'A'
                        + key.charAt(i)
                        - 'A';
        }
 
        // If the sum is greater than 25
        // subtract 26 from it
        // and store that resulting value
        for (int i = 0; i < key.length(); i++) {
            if (cipher[i] > 25) {
                cipher[i] = cipher[i] - 26;
            }
        }
 
        // Converting the no.'s into integers
 
        // Convert these integers to corresponding
        // characters and add them up to cipherText
        for (int i = 0; i < key.length(); i++) {
            int x = cipher[i] + 'A';
            cipherText += (char)x;
        }
 
        // Returning the cipherText
        return cipherText;
    }
 
    // Method 2
    // Returning plain text
    public static String stringDecryption(String s,
                                          String key)
    {
        // Initializing plain text
        String plainText = "";
 
        // Initializing integer array of key length
        // which stores difference
        // of corresponding no.'s of
        // each character of cipherText and key
        int plain[] = new int[key.length()];
 
        // Running for loop for each character
        // subtracting and storing in the array
        for (int i = 0; i < key.length(); i++) {
            plain[i]
                = s.charAt(i) - 'A'
                  - (key.charAt(i) - 'A');
        }
 
        // If the difference is less than 0
        // add 26 and store it in the array.
        for (int i = 0; i < key.length(); i++) {
            if (plain[i] < 0) {
                plain[i] = plain[i] + 26;
            }
        }
 
        // Converting int to corresponding char
        // add them up to plainText
        for (int i = 0; i < key.length(); i++) {
            int x = plain[i] + 'A';
            plainText += (char)x;
        }
 
        // Returning plainText
        return plainText;
    }
 
    // Method 3
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring plain text
        String plainText = "Hello";
 
        // Declaring key
        String key = "MONEY";
 
        // Converting plain text to toUpperCase
        // function call to stringEncryption
        // with plainText and key as parameters
        String encryptedText = stringEncryption(
            plainText.toUpperCase(), key.toUpperCase());
 
        // Printing cipher Text
        System.out.println("Cipher Text - "
                           + encryptedText);
 
        // Calling above method to stringDecryption
        // with encryptedText and key as parameters
        System.out.println(
            "Message - "
            + stringDecryption(encryptedText,
                               key.toUpperCase()));
    }
}
Producción:

Cipher Text - TSYPM
Message - HELLO

Publicación traducida automáticamente

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

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *