Hoy voy a explicar el código fuente para implementar el algoritmo de cifrado ROT 13 en Java.

El método de cifrado llamado ROT 13 rota las letras del alfabeto 13 posiciones. Son 13 veces porque 13 es la mitad de la longitud del alfabeto inglés (es decir, 26).

Debido a que rota las letras justamente a la mitad, el método para descifrar es el mismo que se utiliza para cifrar.

Es decir, al cifrar, la letra a se convierte en n. Y al cifrar de nuevo la n, se convierte en a, por lo que podemos concluir en que el mismo método sirve para cifrar y descifrar.

ROT 13 es una variante del cifrado César (el cual ya implementé en Java) pero a diferencia de ROT 13, para descifrar usando el método César se necesita rotar la cadena a la izquierda.

Una vez explicado esto veamos el código y la explicación para implementar ROT 13 en Java.

También veremos algunas variantes de ROT 13 como ROT 1, y a partir de ello podremos ver cómo implementar ROT 2, ROT 3, etcétera (pues son rotaciones al final del día)

Algoritmo ROT 13 en Java

En posts anteriores presenté una función que sirve para rotar las letras de una cadena según el alfabeto, y que funciona tanto para rotar hacia la derecha o hacia la izquierda.

El código que permite hacer la rotación es el siguiente:

public static String rotar(String cadenaOriginal, int rotaciones) {
  // En ASCII, la a es 97, b 98, A 65, B 66, etcétera
  final int LONGITUD_ALFABETO = 26, INICIO_MINUSCULAS = 97, INICIO_MAYUSCULAS = 65;
  String cadenaRotada = ""; // La cadena nueva, la que estará rotada
  for (int x = 0; x < cadenaOriginal.length(); x++) {
    char caracterActual = cadenaOriginal.charAt(x);
    // Si no es una letra del alfabeto entonces ponemos el char tal y como está
    // y pasamos a la siguiente iteración
    if (!Character.isLetter(caracterActual)) {
      cadenaRotada += caracterActual;
      continue;
    }

    int codigoAsciiDeCaracterActual = (int) caracterActual;
    boolean esMayuscula = Character.isUpperCase(caracterActual);

    // La posición (1 a 26) que ocupará la letra después de ser rotada
    // El % LONGITUD_ALFABETO se utiliza por si se pasa de 26. Por ejemplo,
    // la "z", al ser rotada una vez da el valor de 27, pero en realidad debería
    // regresar a la letra "a", y con mod hacemos eso ya que 27 % 26 == 1,
    // 28 % 26 == 2, etcétera ;)
    int nuevaPosicionEnAlfabeto = ((codigoAsciiDeCaracterActual
        - (esMayuscula ? INICIO_MAYUSCULAS : INICIO_MINUSCULAS)) + rotaciones) % LONGITUD_ALFABETO;
    // Arreglar rotaciones negativas
    if (nuevaPosicionEnAlfabeto < 0)
      nuevaPosicionEnAlfabeto += LONGITUD_ALFABETO;
    int nuevaPosicionAscii = (esMayuscula ? INICIO_MAYUSCULAS : INICIO_MINUSCULAS) + nuevaPosicionEnAlfabeto;
    // Convertir el código ASCII numérico a su representación como símbolo o letra y
    // concatenar
    cadenaRotada += Character.toString((char) nuevaPosicionAscii);
  }
  return cadenaRotada;
}

Si nos fijamos bien, la función es simple: recibe la cadena y el número de rotaciones que queremos dar.

Así que la función de ROT 13 sería llamar a la misma pasándole el número 13 así:

public static String rot13(String cadenaOriginal) {
  return rotar(cadenaOriginal, 13);
}

El código completo que cifra y descifra una cadena con el método ROT 13 es el siguiente, el cual es una combinación de las dos funciones dentro del método main.

/*
 Implementación del algoritmo ROT 13 en Java

 @author parzibyte
 Visita: parzibyte.me/blog
*/class Main {
 public static void main(String[] args) {
  System.out.println("Rotando abcdefghijklmnopqrstuvwxyz ==>" + rot13("abcdefghijklmnopqrstuvwxyz"));
  System.out.println("Rotando ABCDEFGHIJKLMNOPQRSTUVWXYZ ==>" + rot13("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));
  String mensajeOriginal = "Hola, mundo! hacen algo hoy?";
  String mensajeCifrado = rot13(mensajeOriginal);
  String mensajeDescifrado = rot13(mensajeCifrado);
  System.out.println("Original: " + mensajeOriginal);
  System.out.println("Cifrado: " + mensajeCifrado);
  System.out.println("Descifrado: " + mensajeDescifrado);
 }

 public static String rot13(String cadenaOriginal) {
  return rotar(cadenaOriginal, 13);
 }

 public static String rotar(String cadenaOriginal, int rotaciones) {
  // En ASCII, la a es 97, b 98, A 65, B 66, etcétera
  final int LONGITUD_ALFABETO = 26, INICIO_MINUSCULAS = 97, INICIO_MAYUSCULAS = 65;
  String cadenaRotada = ""; // La cadena nueva, la que estará rotada
  for (int x = 0; x < cadenaOriginal.length(); x++) {
   char caracterActual = cadenaOriginal.charAt(x);
   // Si no es una letra del alfabeto entonces ponemos el char tal y como está
   // y pasamos a la siguiente iteración
   if (!Character.isLetter(caracterActual)) {
    cadenaRotada += caracterActual;
    continue;
   }

   int codigoAsciiDeCaracterActual = (int) caracterActual;
   boolean esMayuscula = Character.isUpperCase(caracterActual);

   // La posición (1 a 26) que ocupará la letra después de ser rotada
   // El % LONGITUD_ALFABETO se utiliza por si se pasa de 26. Por ejemplo,
   // la "z", al ser rotada una vez da el valor de 27, pero en realidad debería
   // regresar a la letra "a", y con mod hacemos eso ya que 27 % 26 == 1,
   // 28 % 26 == 2, etcétera ;)
   int nuevaPosicionEnAlfabeto = ((codigoAsciiDeCaracterActual
     - (esMayuscula ? INICIO_MAYUSCULAS : INICIO_MINUSCULAS)) + rotaciones) % LONGITUD_ALFABETO;
   // Arreglar rotaciones negativas
   if (nuevaPosicionEnAlfabeto < 0)
    nuevaPosicionEnAlfabeto += LONGITUD_ALFABETO;
   int nuevaPosicionAscii = (esMayuscula ? INICIO_MAYUSCULAS : INICIO_MINUSCULAS) + nuevaPosicionEnAlfabeto;
   // Convertir el código ASCII numérico a su representación como símbolo o letra y
   // concatenar
   cadenaRotada += Character.toString((char) nuevaPosicionAscii);
  }
  return cadenaRotada;
 }
}

La salida es:

Rotando abcdefghijklmnopqrstuvwxyz ==>nopqrstuvwxyzabcdefghijklm
Rotando ABCDEFGHIJKLMNOPQRSTUVWXYZ ==>NOPQRSTUVWXYZABCDEFGHIJKLM
Original: Hola, mundo! hacen algo hoy?
Cifrado: Ubyn, zhaqb! unpra nytb ubl?
Descifrado: Hola, mundo! hacen algo hoy?

ROT 1, ROT 2, etcétera

Gracias a la función que he escrito las letras se pueden rotar distintas posiciones. Para cifrar con ROT 1 sería rotar las letras 1 vez a la derecha, pero para descifrar no se puede usar el mismo algoritmo, sería otro.

Como ejemplo dejo a continuación la implementación de ROT 1:

/*
 Implementación del algoritmo ROT 1 (variante de ROT 13) 
 en Java

 @author parzibyte
 Visita: parzibyte.me/blog
*/class Main {
 public static void main(String[] args) {
  System.out.println("Rotando abcdefghijklmnopqrstuvwxyz ==>" + cifrarRot1("abcdefghijklmnopqrstuvwxyz"));
  System.out.println("Rotando ABCDEFGHIJKLMNOPQRSTUVWXYZ ==>" + cifrarRot1("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));
  String mensajeOriginal = "Hola, mundo! hacen algo hoy?";
  String mensajeCifrado = cifrarRot1(mensajeOriginal);
  String mensajeDescifrado = descifrarRot1(mensajeCifrado);
  System.out.println("Original: " + mensajeOriginal);
  System.out.println("Cifrado: " + mensajeCifrado);
  System.out.println("Descifrado: " + mensajeDescifrado);
 }

 public static String cifrarRot1(String cadenaOriginal) {
  return rotar(cadenaOriginal, 1);
 }
 public static String descifrarRot1(String cadenaOriginal) {
  return rotar(cadenaOriginal, -1);
 }

 public static String rotar(String cadenaOriginal, int rotaciones) {
  // En ASCII, la a es 97, b 98, A 65, B 66, etcétera
  final int LONGITUD_ALFABETO = 26, INICIO_MINUSCULAS = 97, INICIO_MAYUSCULAS = 65;
  String cadenaRotada = ""; // La cadena nueva, la que estará rotada
  for (int x = 0; x < cadenaOriginal.length(); x++) {
   char caracterActual = cadenaOriginal.charAt(x);
   // Si no es una letra del alfabeto entonces ponemos el char tal y como está
   // y pasamos a la siguiente iteración
   if (!Character.isLetter(caracterActual)) {
    cadenaRotada += caracterActual;
    continue;
   }

   int codigoAsciiDeCaracterActual = (int) caracterActual;
   boolean esMayuscula = Character.isUpperCase(caracterActual);

   // La posición (1 a 26) que ocupará la letra después de ser rotada
   // El % LONGITUD_ALFABETO se utiliza por si se pasa de 26. Por ejemplo,
   // la "z", al ser rotada una vez da el valor de 27, pero en realidad debería
   // regresar a la letra "a", y con mod hacemos eso ya que 27 % 26 == 1,
   // 28 % 26 == 2, etcétera ;)
   int nuevaPosicionEnAlfabeto = ((codigoAsciiDeCaracterActual
     - (esMayuscula ? INICIO_MAYUSCULAS : INICIO_MINUSCULAS)) + rotaciones) % LONGITUD_ALFABETO;
   // Arreglar rotaciones negativas
   if (nuevaPosicionEnAlfabeto < 0)
    nuevaPosicionEnAlfabeto += LONGITUD_ALFABETO;
   int nuevaPosicionAscii = (esMayuscula ? INICIO_MAYUSCULAS : INICIO_MINUSCULAS) + nuevaPosicionEnAlfabeto;
   // Convertir el código ASCII numérico a su representación como símbolo o letra y
   // concatenar
   cadenaRotada += Character.toString((char) nuevaPosicionAscii);
  }
  return cadenaRotada;
 }
}

A partir de la misma puedes hacer otros tipos de rotaciones. De hecho ROT 3 es lo mismo que el cifrado César.