Cifrado XOR cambiando el texto sin formato

Aquí hay un algoritmo de cifrado, basado en strings hexadecimales que se implementa haciendo XORing el texto sin formato dado, N número de veces donde N es su longitud. Pero, el problema es que cada siguiente operación XOR se realiza después de cambiar la entrada de texto sin formato consecutiva a la derecha . A continuación se muestra una operación de muestra: Supongamos que la contraseña es ‘abcd’, luego el texto hexadecimal se calcula como a1d0a1d haciendo XORing de la contraseña consigo misma N veces, es decir, 4 veces en este caso. Del mismo modo, si la contraseña es ‘636f646572’ , entonces 653cae8da8edb426052es el texto hexadecimal. Entonces, la declaración del problema es crear un algoritmo de descifrado (en cualquier lenguaje de programación) y deducir el texto sin formato de la string hexadecimal dada. Ejemplos:

Input : a1d0a1d
Output : abcd
abcd once coded will return a1d0a1d

Input : 653cae8da8edb426052
Output : 636f646572

Enfoque: El ingrediente clave en el cifrado y descifrado está en las propiedades de XOR . XOR es una operación bit a bit donde el resultado es 0 si las dos entradas posibles son iguales pero 1 cuando las entradas son diferentes . La tabla XOR se proporciona a continuación como referencia:

Una propiedad importante y útil de XOR que es muy popular en criptografía es que en el caso de múltiples XORing de números (por ejemplo , M números), si solo conocemos los números M – 1 (uno es desconocido) junto con el resultado XOR , entonces puede calcular fácilmente el número que falta haciendo XORing los números conocidos y el resultado XOR. Esta propiedad se analiza con los siguientes números hexadecimales: Usaremos la propiedad enumerada más arriba en el curso de este problema. Ahora, si miramos el diagrama de cifrado de ‘abcd’ en la base, es solo el XOR repetido de los dígitos. El dígito más a la derecha es d y el dígito más a la derecha del ‘abcd’ es dademás, el último dígito tanto del texto sin formato como de la string hexadecimal es el mismo . El siguiente dígito es 1 , que se calcula haciendo XORing el segundo dígito de la derecha de abcd y el dígito anterior, es decir , 1 = d ^ c usando la propiedad que sabemos que el dígito de texto sin formato se puede deducir como d ^ 1 = c . De manera similar, el siguiente dígito es a, que se encuentra mediante d ^ c ^ b = a . Solo tenemos que hacer esto hasta la mitad de la string hexagonal, ya que el resto es simétrico, por lo que no son necesarios . A continuación se muestra la implementación del enfoque anterior: 

// Implementation of the code in C++
#include <bits/stdc++.h>
using namespace std;
 
int main()
{
 
  // Hex String variable
  string hex_s = "653cae8da8edb426052";
 
  // Plain text variable
  string plain = "";
 
  // variable to store the XOR
  // of previous digits
  int x = 0;
 
  int l = hex_s.length();
 
  // Loop for loop from the end to
  // the mid section of the string
  for (int i = l - 1; i > (l / 2) - 1; i--) {
    string digit = "";
    digit += hex_s[i];
 
    // calculation of the plaintext digit
    unsigned int y = x ^ stoul(digit, nullptr, 16);
 
    // calculation of XOR chain
    x = x ^ y;
    stringstream sstream;
    sstream << hex << y;
    string z = sstream.str();
    plain = z[z.length() - 1] + plain;
  }
 
  cout << plain;
}
 
// This code is contributed by phasing17

// Implementation of the code in Java
 
 
class GFG {
    public static void main(String[] args) {
        // Hex String variable
        String hex_s = "653cae8da8edb426052";
         
        // Plain text variable
        String plain = "";
         
        // variable to store the XOR
        // of previous digits
        int x = 0;
         
        int l = hex_s.length();
         
        // Loop for loop from the end to
        // the mid section of the string
        for (int i = l - 1; i > (l / 2) - 1; i--)
        {
            // calculation of the plaintext digit
            int y = x ^ Integer.parseInt(Character.toString(hex_s.charAt(i)), 16);
             
            // calculation of XOR chain
            x = x ^ y;
            String z = Integer.toString(y, 16);
            plain = z.charAt(z.length() - 1) + plain;
        } 
         
        System.out.println(plain);
  
    }
}
 
//This code is contributed by phasing17

# Implementation in Python 3
 
# Hex String variable
hex_s = '653cae8da8edb426052'
 
# Plain text variable
plain = ''
 
# variable to store the XOR
# of previous digits
x = 0
 
l = len(hex_s)
 
# Loop for loop from the end to
# the mid section of the string
for i in range(l - 1, int(l / 2) - 1, -1):
     
    # calculation of the plaintext digit
    y = x^int(hex_s[i], 16)
     
    # calculation of XOR chain
    x = x^y
    plain = hex(y)[-1] + plain
     
print(plain)

// Implementation of the code in C#
using System;
 
class GFG {
 
  public static void Main(string[] args)
  {
 
    // Hex String variable
    string hex_s = "653cae8da8edb426052";
 
    // Plain text variable
    string plain = "";
 
    // variable to store the XOR
    // of previous digits
    int x = 0;
 
    int l = hex_s.Length;
 
    // Loop for loop from the end to
    // the mid section of the string
    for (int i = l - 1; i > (l / 2) - 1; i--) {
      string digit = "";
      digit += hex_s[i];
 
      // calculation of the plaintext digit
      int y = x ^ Convert.ToInt32(digit, 16);
 
      // calculation of XOR chain
      x = x ^ y;
      string z = Convert.ToString(y, 16);
      plain = z[z.Length - 1] + plain;
    }
 
    Console.WriteLine(plain);
  }
}
 
// This code is contributed by phasing17

// Implementation of the code in JS
 
// Hex String variable
var hex_s = '653cae8da8edb426052';
 
// Plain text variable
var plain = '';
 
// variable to store the XOR
// of previous digits
var x = 0;
 
var l = hex_s.length;
 
// Loop for loop from the end to
// the mid section of the string
for (var i = l - 1; i > (l / 2) - 1; i--)
{
    // calculation of the plaintext digit
    var y = x ^ parseInt(hex_s[i], 16);
     
    // calculation of XOR chain
    x = x^y;l
    plain = y.toString(16).slice(-1) + plain;
} 
 
console.log(plain);
 
// this code is contributed by phasing17

636f646572

Complejidad de tiempo: O (l), donde l es el tamaño de la string hexadecimal

Espacio Auxiliar : O(1)