Algoritmo RSA en Criptografía

El algoritmo RSA es un algoritmo de criptografía asimétrica. Asimétrico en realidad significa que funciona en dos claves diferentes, es decir , clave pública y clave privada. Como el nombre describe, la clave pública se otorga a todos y la clave privada se mantiene privada.

Un ejemplo de criptografía asimétrica:

1. Un cliente (por ejemplo, un navegador) envía su clave pública al servidor y solicita algunos datos.
2. El servidor cifra los datos utilizando la clave pública del cliente y envía los datos cifrados.
3. El cliente recibe estos datos y los descifra.

Dado que esto es asimétrico, nadie más, excepto el navegador, puede descifrar los datos, incluso si un tercero tiene la clave pública del navegador.

¡La idea! La idea de RSA se basa en el hecho de que es difícil factorizar un número entero grande. La clave pública consta de dos números donde un número es la multiplicación de dos números primos grandes. Y la clave privada también se deriva de los mismos dos números primos. Entonces, si alguien puede factorizar el gran número, la clave privada está comprometida. Por lo tanto, la fuerza del cifrado depende totalmente del tamaño de la clave y si duplicamos o triplicamos el tamaño de la clave, la fuerza del cifrado aumenta exponencialmente. Las claves RSA suelen tener una longitud de 1024 o 2048 bits, pero los expertos creen que las claves de 1024 bits podrían romperse en un futuro próximo. Pero hasta ahora parece ser una tarea inviable.

Aprendamos el mecanismo detrás del algoritmo RSA:

>> Generación de clave pública:

>> Generación de clave privada:

Ahora estamos listos con nuestra clave pública (n = 3127 y e = 3) y clave privada (d = 2011)

Ahora cifraremos “HI” :

Ahora vamos a descifrar
1394
:

8 = H e I = 9, es decir, «HI».

A continuación se muestra la implementación en C del algoritmo RSA para valores pequeños:

// C program for RSA asymmetric cryptographic
// algorithm. For demonstration values are
// relatively small compared to practical
// application
#include<stdio.h>
#include<math.h>
  
// Returns gcd of a and b
int gcd(int a, int h)
{
    int temp;
    while (1)
    {
        temp = a%h;
        if (temp == 0)
          return h;
        a = h;
        h = temp;
    }
}
  
// Code to demonstrate RSA algorithm
int main()
{
    // Two random prime numbers
    double p = 3;
    double q = 7;
  
    // First part of public key:
    double n = p*q;
  
    // Finding other part of public key.
    // e stands for encrypt
    double e = 2;
    double phi = (p-1)*(q-1);
    while (e < phi)
    {
        // e must be co-prime to phi and
        // smaller than phi.
        if (gcd(e, phi)==1)
            break;
        else
            e++;
    }
  
    // Private key (d stands for decrypt)
    // choosing d such that it satisfies
    // d*e = 1 + k * totient
    int k = 2;  // A constant value
    double d = (1 + (k*phi))/e;
  
    // Message to be encrypted
    double msg = 20;
  
    printf("Message data = %lf", msg);
  
    // Encryption c = (msg ^ e) % n
    double c = pow(msg, e);
    c = fmod(c, n);
    printf("\nEncrypted data = %lf", c);
  
    // Decryption m = (c ^ d) % n
    double m = pow(c, d);
    m = fmod(m, n);
    printf("\nOriginal Message Sent = %lf", m);
  
    return 0;
}
// This code is contributed by Akash Sharan.

# Python for RSA asymmetric cryptographic algorithm. 
# For demonstration, values are 
# relatively small compared to practical application
import math
  
  
def gcd(a, h):
    temp = 0
    while(1):
        temp = a % h
        if (temp == 0):
            return h
        a = h
        h = temp
  
  
p = 3
q = 7
n = p*q
e = 2
phi = (p-1)*(q-1)
  
while (e < phi):
  
    # e must be co-prime to phi and
    # smaller than phi.
    if(gcd(e, phi) == 1):
        break
    else:
        e = e+1
  
# Private key (d stands for decrypt)
# choosing d such that it satisfies
# d*e = 1 + k * totient
  
k = 2
d = (1 + (k*phi))/e
  
# Message to be encrypted
msg = 12.0
  
print("Message data = ", msg)
  
# Encryption c = (msg ^ e) % n
c = pow(msg, e)
c = math.fmod(c, n)
print("Encrypted data = ", c)
  
# Decryption m = (c ^ d) % n
m = pow(c, d)
m = math.fmod(m, n)
print("Original Message Sent = ", m)
  
  
# This code is contributed by Pranay Arora.

Producción :

Message data = 12.000000
Encrypted data = 3.000000
Original Message Sent = 12.000000

Este artículo es aportado por Mohit Gupta_OMG 🙂 . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.