Cifrado ROT13

El cifrado ROT13 (que se lee como «rotar 13 lugares») es un caso especial del cifrado Caesar en el que el cambio es siempre 13. 
Por lo tanto, cada letra se cambia 13 lugares para cifrar o descifrar el mensaje. 

Debes pensar que es solo otro cifrado césar, entonces, ¿ qué es diferente esta vez? Bueno, la diferencia está en su implementación. El enfoque es usar dos diccionarios de python separados. 

1. El primero en buscar las distintas letras según su lugar en los alfabetos ingleses para obtener el número desplazado
2. El segundo para obtener las letras que corresponden a esos números desplazados.

Implementación:

// CPP program to implement
// ROT13 Caesar Cipher
 
#include<bits/stdc++.h>
using namespace std;
 
// Map to lookup the index of alphabets
map <char,int> dict1;
 
// Map to lookup alphabets corresponding
// to the index after shift
map <int,char> dict2;
 
// Function to create map to lookup
void create_dict()
{
    for(int i = 1; i < 27; i++)
        dict1[char(64 + i)] = i;
    
    dict2[0] = 'Z';
     
    for(int i = 1; i < 26; i++)
        dict2[i] = char(64 + i);
         
    return;
}
 
// Function to encrypt the string
// according to the shift provided
string encrypt(string message, int shift)
{
    string cipher = "";
    for(int i = 0; i < message.size(); i++)
    {
        // Checking for namespace
        if(message[i] != ' ')
        {
            // looks up the map and
            // adds the shift to the index
            int num = (dict1[message[i]] + shift) % 26;
             
            // looks up the second map for the
            // shifted alphabets and adds them
            cipher += dict2[num];
        }
        else
        {
            // adds space
            cipher += " ";
        }
    }
    return cipher;
}
 
// Function to decrypt the string
// according to the shift provided
string decrypt(string message, int shift)
{
    string decipher = "";
    for(int i = 0; i < message.size(); i++)
    {
        // checks for space
        if(message[i] != ' ')
        {
            // looks up the map and
            // subtracts the shift to the index
            int num = (dict1[message[i]] - shift + 26) % 26;
            // looks up the second map for the
            // shifted alphabets and adds them
            decipher += dict2[num];
        }
        else
        {
            // adds space
            decipher += " ";
        }
    }
    return decipher;
}
 
// Driver code
int main()
{
    create_dict();
     
    string message = "GEEKS FOR GEEKS";
    int shift = 13;
     
    cout << encrypt(message, shift) << "\n";
     
    message = "TRRXF SBE TRRXF";
    shift = 13;
     
    cout << decrypt(message, shift) << "\n";
     
    return 0;
}
// This code is contributed by Sachin Bisht

# Python program to implement
# ROT13 Caesar cipher
 
'''This script uses dictionaries instead of 'chr()' & 'ord()' function'''
 
# Dictionary to lookup the index of alphabets
dict1 = {'A' : 1, 'B' : 2, 'C' : 3, 'D' : 4, 'E' : 5,
        'F' : 6, 'G' : 7, 'H' : 8, 'I' : 9, 'J' : 10,
        'K' : 11, 'L' : 12, 'M' : 13, 'N' : 14, 'O' : 15,
        'P' : 16, 'Q' : 17, 'R' : 18, 'S' : 19, 'T' : 20,
        'U' : 21, 'V' : 22, 'W' : 23, 'X' : 24, 'Y' : 25, 'Z' : 26}
 
# Dictionary to lookup alphabets
# corresponding to the index after shift
dict2 = {0 : 'Z', 1 : 'A', 2 : 'B', 3 : 'C', 4 : 'D', 5 : 'E',
        6 : 'F', 7 : 'G', 8 : 'H', 9 : 'I', 10 : 'J',
        11 : 'K', 12 : 'L', 13 : 'M', 14 : 'N', 15 : 'O',
        16 : 'P', 17 : 'Q', 18 : 'R', 19 : 'S', 20 : 'T',
        21 : 'U', 22 : 'V', 23 : 'W', 24 : 'X', 25 : 'Y'}
 
# Function to encrypt the string
# according to the shift provided
def encrypt(message, shift):
    cipher = ''
    for letter in message:
        # checking for space
        if(letter != ' '):
            # looks up the dictionary and
            # adds the shift to the index
            num = ( dict1[letter] + shift ) % 26
            # looks up the second dictionary for
            # the shifted alphabets and adds them
            cipher += dict2[num]
        else:
            # adds space
            cipher += ' '
 
    return cipher
 
# Function to decrypt the string
# according to the shift provided
def decrypt(message, shift):
    decipher = ''
    for letter in message:
        # checks for space
        if(letter != ' '):
            # looks up the dictionary and
            # subtracts the shift to the index
            num = ( dict1[letter] - shift + 26) % 26
            # looks up the second dictionary for the
            # shifted alphabets and adds them
            decipher += dict2[num]
        else:
            # adds space
            decipher += ' '
 
    return decipher
 
# driver function to run the program
def main():
    # use 'upper()' function to convert any lowercase characters to uppercase
    message = "GEEKS FOR GEEKS"
    shift = 13
    result = encrypt(message.upper(), shift)
    print (result)
 
    message = "TRRXF SBE TRRXF"
    shift = 13
    result = decrypt(message.upper(), shift)
    print (result)
 
# Executes the main function
if __name__ == '__main__':
    main()

TRRXF SBE TRRXF
GEEKS FOR GEEKS

Análisis: El cifrado ROT13 no es muy seguro, ya que es solo un caso especial del cifrado César. El cifrado César se puede descifrar mediante análisis de frecuencia o simplemente probando las 25 claves, mientras que el cifrado ROT13 se puede descifrar simplemente cambiando las letras 13 lugares. Por lo tanto, no tiene ningún uso práctico.

Aplicación: ROT13 estaba en uso en el grupo de noticias net.jokes a principios de la década de 1980. 

Este artículo es una contribución de Palash Nigam . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.