RSA-Algorithmus ist ein asymmetrischer Kryptographiealgorithmus. Asymmetrisch bedeutet eigentlich, dass es auf zwei verschiedenen Tonarten funktioniert, d.h. Öffentlicher Schlüssel Und Privat Schlüssel. Wie der Name schon sagt, wird der öffentliche Schlüssel jedem gegeben und der private Schlüssel privat gehalten.

Ein Beispiel für asymmetrische Kryptographie:

1. Ein Client (z. B. Browser) sendet seinen öffentlichen Schlüssel an den Server und fordert einige Daten an.
2. Der Server verschlüsselt die Daten mit dem öffentlichen Schlüssel des Clients und sendet die verschlüsselten Daten.
3. Der Client empfängt diese Daten und entschlüsselt sie.

Da dies asymmetrisch ist, kann niemand außer dem Browser die Daten entschlüsseln, selbst wenn ein Dritter über den öffentlichen Schlüssel des Browsers verfügt.

Die Idee! Die Idee von RSA basiert auf der Tatsache, dass es schwierig ist, eine große ganze Zahl zu faktorisieren. Der öffentliche Schlüssel besteht aus zwei Zahlen, wobei eine Zahl eine Multiplikation zweier großer Primzahlen ist. Und der private Schlüssel wird ebenfalls aus denselben beiden Primzahlen abgeleitet. Wenn also jemand die große Zahl faktorisieren kann, ist der private Schlüssel gefährdet. Daher hängt die Stärke der Verschlüsselung vollständig von der Schlüsselgröße ab, und wenn wir die Schlüsselgröße verdoppeln oder verdreifachen, steigt die Stärke der Verschlüsselung exponentiell an. RSA-Schlüssel können typischerweise 1024 oder 2048 Bit lang sein, Experten gehen jedoch davon aus, dass 1024-Bit-Schlüssel in naher Zukunft gebrochen werden könnten. Aber bis jetzt scheint es eine unlösbare Aufgabe zu sein.

Lassen Sie uns den Mechanismus hinter dem RSA-Algorithmus kennenlernen:>> Generieren eines öffentlichen Schlüssels:

Select two prime no's. Suppose   P = 53 and Q = 59.    Now First part of the Public key : n = P*Q = 3127.   We also need a small exponent say   e :     But e Must be     An integer.    Not be a factor of Φ(n).     1     Φ(n) [Φ(n) is discussed below],>> Generieren des privaten Schlüssels: Wir müssen Φ(n) berechnen: So dass Φ(n) = (P-1)(Q-1), also Φ(n) = 3016. Berechnen Sie nun den privaten Schlüssel, d: d = (k *Φ(n) + 1) / e für eine ganze Zahl k Für k = 2 ist der Wert von d 2011. Jetzt sind wir mit unserem öffentlichen Schlüssel (n = 3127 und e = 3) und unserem privaten Schlüssel (d = 2011) fertig ) Jetzt werden wir HI verschlüsseln: Buchstaben in Zahlen umwandeln: H = 8 und I = 9 Somit sind die verschlüsselten Daten c = (89 e)mod n. Somit sind unsere verschlüsselten Daten 1394. Jetzt werden wir 1394 entschlüsseln: Entschlüsselte Daten = (c d )mod n Somit sind unsere verschlüsselten Daten 89 8 = H und I = 9, d. h. 'HI'.    Nachfolgend finden Sie die Implementierung des RSA-Algorithmus für Methode 1: Verschlüsseln und Entschlüsseln kleiner Zahlenwerte: C++ // C-Programm für den asymmetrischen kryptografischen RSA-Algorithmus //. Zu Demonstrationszwecken sind // die Werte relativ klein im Vergleich zur praktischen // Anwendung #include using namespace std; // Gibt gcd von a und b zurück int gcd(int a, int h) { int temp;  while (1) { temp = a % h;  if (temp == 0) return h;  a = h;  h = Temperatur;  } } // Code zur Demonstration des RSA-Algorithmus int main() { // Zwei zufällige Primzahlen double p = 3;  doppeltes q = 7;  // Erster Teil des öffentlichen Schlüssels: double n = p * q;  // Anderen Teil des öffentlichen Schlüssels finden.  // e steht für encrypt double e = 2;  doppeltes Phi = (p – 1) * (q – 1);  while (e // e muss teilerfremd zu Phi sein und // kleiner als Phi. if (gcd(e, phi) == 1) break; else e++; } // Privater Schlüssel (d steht für Decrypt) // Wählen Sie d so aus, dass es erfüllt: // d*e = 1 + k * totient k = 2; // Ein konstanter Wert double d = (1 + (k * phi)) / e // Zu verschlüsselnde Nachricht double msg = 12; printf('Message data = %lf', msg); // Verschlüsselung c = (msg ^ e) % n double c = pow(msg, e); ('
Verschlüsselte Daten = %lf', c); // Entschlüsselung m = (c ^ d) % n double m = pow(c, d); 
Original Message Sent = %lf', m); return 0; java.math.*; import java.util.*; /* * Java-Programm für den asymmetrischen RSA-Kryptographiealgorithmus * Zur Demonstration sind die Werte * relativ klein im Vergleich zur praktischen Anwendung */ public class GFG { public static double gcd(double a , double h) { /* * Diese Funktion gibt den ggT oder den größten gemeinsamen * Teiler zurück */ double temp;  while (true) { temp = a % h;  if (temp == 0) return h;  a = h;  h = Temperatur;  } } public static void main(String[] args) { double p = 3;  doppeltes q = 7;  // Speichert den ersten Teil des öffentlichen Schlüssels: double n = p * q;  // Den anderen Teil des öffentlichen Schlüssels finden.  // double e steht für encrypt double e = 2;  doppeltes Phi = (p – 1) * (q – 1);  while (e /* * e muss teilerfremd zu Phi und * kleiner als Phi sein. */ if (gcd(e, phi) == 1) break; else e++; } int k = 2; // Ein konstanter Wert double d = (1 + (k * phi)) / e; // Zu verschlüsselnde Nachricht double msg = 12; System.out.println('Message data = ' + msg); ^ e) % n double c = Math.pow(msg, e); c = c % n; System.out.println('Encrypted data = ' + c); % n double m = Math.pow(c, d); m = m % n; System.out.println('Original Message Sent = ' + m } } // Dieser Code wurde von Pranay Arora beigesteuert. Python3 # Python für den asymmetrischen kryptografischen Algorithmus RSA # Zur Veranschaulichung: Die Werte sind im Vergleich zur praktischen Anwendung relativ klein 0): return h a = h h = temp p = 3 q = 7 n = p*q e = 2 phi = (p-1)*(q-1) while (e # e muss teilerfremd zu phi und # kleiner sein als phi. if(gcd(e, phi) == 1): break else: e = e+1 # Privater Schlüssel (d steht für decrypt) # d so wählen, dass es # d*e = 1 + k * totient erfüllt k = 2 d = (1 + (k*phi))/e # Zu verschlüsselnde Nachricht msg = 12.0 print('Message data = ', msg) # Verschlüsselung c = (msg ^ e) % n c = pow( msg, e) c = math.fmod(c, n) print('Encrypted data = ', c) # Entschlüsselung m = (c ^ d) % n m = pow(c, d) m = math.fmod( m, n) print('Original Message Sent = ', m) # Dieser Code wurde von Pranay Arora beigesteuert.  C# /* * C#-Programm für den asymmetrischen kryptografischen RSA-Algorithmus.  * Zur Veranschaulichung: Die Werte sind * relativ klein im Vergleich zur praktischen Anwendung */ unter Verwendung von System; öffentliche Klasse GFG { public static double gcd(double a, double h) { /* * Diese Funktion gibt den ggT oder den größten gemeinsamen Teiler zurück */ double temp;  while (true) { temp = a % h;  if (temp == 0) return h;  a = h;  h = Temperatur;  } } static void Main() { double p = 3;  doppeltes q = 7;  // Speichert den ersten Teil des öffentlichen Schlüssels: double n = p * q;  // Den anderen Teil des öffentlichen Schlüssels finden.  // double e steht für encrypt double e = 2;  doppeltes Phi = (p – 1) * (q – 1);  while (e /* * e muss teilerfremd zu Phi und * kleiner als Phi sein. */ if (gcd(e, phi) == 1) break; else e++; } int k = 2; // Ein konstanter Wert double d = (1 + (k * phi)) / e; // Zu verschlüsselnde Nachricht double msg = 12; Console.WriteLine('Message data = ' + String.Format('{0:F6} ', msg)); // Verschlüsselung c = (msg ^ e) % n double c = Math.Pow(msg, e); c = c % n; Format('{0:F6}', c)); // Entschlüsselung m = (c ^ d) % n double m = Math.Pow(c, d); 'Original Message Sent = ' + String.Format('{0:F6}', m)); // Dieser Code wird von Pranay Arora //GFG //Javascript-Code für diesen Ansatz bereitgestellt Funktion gcd(a, h) { /* * Diese Funktion gibt den ggT oder größten gemeinsamen Teiler zurück */ let temp; ; h = temp; } let p = 3; let q = 7; // Speichert den ersten Teil des öffentlichen Schlüssels: let n = p * q; // Den anderen Teil des öffentlichen Schlüssels finden. // e steht für encrypt let e = 2; sei phi = (p – 1) * (q – 1); while (e /* * e muss teilerfremd zu Phi und * kleiner als Phi sein. */ if (gcd(e, phi) == 1) break; else e++; } let k = 2; // Ein konstanter Wert let d = (1 + (k * phi)) / e; // Zu verschlüsselnde Nachricht let msg = 12; console.log('Message data = ' + msg); ) % n let c = Math.pow(msg, e); c = c % n; console.log('Encrypted data = ' + c); // Entschlüsselung m = (c ^ d) % n let m = Math.pow(c, d); m = m % n; console.log('Original Message Sent = ' + m); Gesendete Nachricht = 12,000000 Methode 2: Verschlüsseln und Entschlüsseln von Klartextnachrichten, die Alphabete und Zahlen enthalten, mithilfe ihres ASCII-Werts: C++ #include mithilfe des Namespace std; Primzahl; // eine Menge wird die Sammlung von Primzahlen sein, // wo wir zufällige Primzahlen p und q auswählen können int public_key; int private_key; int n; // Wir werden die Funktion nur einmal ausführen, um die Menge // der Primzahlen zu füllen. void primefiller() { // Die zum Füllen der Primzahlenmenge verwendete Methode ist siebenmal // eratosthenes (eine Methode zum Sammeln von Primzahlen) Vektor seive(250, true);  seive[0] = false;  seive[1] = false;  für (int i = 2; i <250; i++) {  for (int j = i * 2; j  <250; j += i) {  seive[j] = false;  }  } // filling the prime numbers  for (int i = 0; i   if (seive[i])  prime.insert(i);  } } // picking a random prime number and erasing that prime // number from list because p!=q int pickrandomprime() {  int k = rand() % prime.size();  auto it = prime.begin();  while (k--)  it++;  int ret = *it;  prime.erase(it);  return ret; } void setkeys() {  int prime1 = pickrandomprime(); // first prime number  int prime2 = pickrandomprime(); // second prime number  // to check the prime numbers selected  // cout <  n = prime1 * prime2;  int fi = (prime1 - 1) * (prime2 - 1);  int e = 2;  while (1) {  if (__gcd(e, fi) == 1)  break;  e++;  } // d = (k*Φ(n) + 1) / e for some integer k  public_key = e;  int d = 2;  while (1) {  if ((d * e) % fi == 1)  break;  d++;  }  private_key = d; } // to encrypt the given number long long int encrypt(double message) {  int e = public_key;  long long int encrpyted_text = 1;  while (e--) {  encrpyted_text *= message;  encrpyted_text %= n;  }  return encrpyted_text; } // to decrypt the given number long long int decrypt(int encrpyted_text) {  int d = private_key;  long long int decrypted = 1;  while (d--) {  decrypted *= encrpyted_text;  decrypted %= n;  }  return decrypted; } // first converting each character to its ASCII value and // then encoding it then decoding the number to get the // ASCII and converting it to character vector Encoder(String-Nachricht) { Vektor bilden;  // Aufruf der Verschlüsselungsfunktion in der Kodierungsfunktion für (auto& letter : message) form.push_back(encrypt((int)letter));  Rücksendeformular; } string decoder(vector codiert) { string s;  // Aufruf der Entschlüsselungsfunktion, Dekodierungsfunktion für (auto& num : encoded) s += decrypt(num);  kehrt zurück; } int main() { primefiller();  setkeys();  string message = 'Testnachricht';  // Kommentar unten für manuelle Eingabe entfernen // cout < <'enter the message
';getline(cin,message);  // calling the encoding function  vector coded = Encoder(Nachricht);  cout < < 'Initial message:
'  < < message;  cout  < < '

The encoded message(encrypted by public '  'key)
';  for (auto& p : coded)  cout  < < p;  cout  < < '

The decoded message(decrypted by private '  'key)
';  cout  < < decoder(coded)  < < endl;  return 0; }  Java       import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Random; public class GFG {  private static HashSet prime = new HashSet();  private static Integer public_key = null;  private static Integer private_key = null;  private static Integer n = null;  private static Random random = new Random();  public static void main(String[] args)  {  primeFiller();  setKeys();  String message = 'Test Message';  // Uncomment below for manual input  // System.out.println('Enter the message:');  // message = new Scanner(System.in).nextLine();  List coded = encoder(message);  System.out.println('Initial message:');  System.out.println(message);  System.out.println(  '

The encoded message (encrypted by public key)
');  System.out.println(  String.join('', coded.stream()  .map(Object::toString)  .toArray(String[] ::new)));  System.out.println(  '

The decoded message (decrypted by public key)
');  System.out.println(decoder(coded));  }  public static void primeFiller()  {  boolean[] sieve = new boolean[250];  for (int i = 0; i  <250; i++) {  sieve[i] = true;  }  sieve[0] = false;  sieve[1] = false;  for (int i = 2; i  <250; i++) {  for (int j = i * 2; j  <250; j += i) {  sieve[j] = false;  }  }  for (int i = 0; i   if (sieve[i]) {  prime.add(i);  }  }  }  public static int pickRandomPrime()  {  int k = random.nextInt(prime.size());  List primeList = new ArrayList(prime);  int ret = primeList.get(k);  prime.remove(ret);  return ret;  }  public static void setKeys()  {  int prime1 = pickRandomPrime();  int prime2 = pickRandomPrime();  n = prime1 * prime2;  int fi = (prime1 - 1) * (prime2 - 1);  int e = 2;  while (true) {  if (gcd(e, fi) == 1) {  break;  }  e += 1;  }  public_key = e;  int d = 2;  while (true) {  if ((d * e) % fi == 1) {  break;  }  d += 1;  }  private_key = d;  }  public static int encrypt(int message)  {  int e = public_key;  int encrypted_text = 1;  while (e>0) { verschlüsselter_text *= Nachricht;  verschlüsselter_text %= n;  e -= 1;  } return verschlüsselter_text;  } public static int decrypt(int verschlüsselter_text) { int d = private_key;  int entschlüsselt = 1;  while (d> 0) { entschlüsselt *= verschlüsselter_text;  entschlüsselt %= n;  d -= 1;  } entschlüsselt zurückgeben;  } public static int gcd(int a, int b) { if (b == 0) { return a;  } return gcd(b, a % b);  } public static List Encoder(String message) { List encoded = new ArrayList();  for (char-Buchstabe: message.toCharArray()) { encoded.add(encrypt((int)letter));  } return encoded;  } public static String decoder(List encoded) { StringBuilder s = new StringBuilder();  for (int num : encoded) { s.append((char)decrypt(num));  } return s.toString();  } } Python3 import random import math # Eine Menge wird die Sammlung von Primzahlen sein, # wo wir zufällige Primzahlen p und q auswählen können prime = set() public_key = None private_key = None n = None # Wir werden die Funktion nur einmal ausführen um den Satz von # Primzahlen zu füllen def primefiller(): # Die zum Füllen des Primzahlensatzes verwendete Methode ist Sieve of # Eratosthenes (eine Methode zum Sammeln von Primzahlen) seive = [True] * 250 seive[0] = False seive[1 ] = False für i in range(2, 250): for j in range(i * 2, 250, i): seive[j] = False # Füllen der Primzahlen für i in range(len(seive)): if seive[i]: prime.add(i) # Eine zufällige Primzahl auswählen und diese Primzahl # aus der Liste löschen, weil p!=q def pickrandomprime(): global prime k = random.randint(0, len(prime) - 1) it = iter(prime) für _ in range(k): next(it) ret = next(it) prime.remove(ret) return ret def setkeys(): global public_key, private_key, n prime1 = pickrandomprime() # Erste Primzahl prime2 = pickrandomprime() # Zweite Primzahl n = prime1 * prime2 fi = (prime1 - 1) * (prime2 - 1) e = 2 while True: if math.gcd(e, fi) == 1: break e += 1 # d = (k*Φ(n) + 1) / e für eine ganze Zahl k public_key = e d = 2 while True: if (d * e) % fi == 1: break d += 1 private_key = d # Zum Verschlüsseln der angegebenen Nummer def encrypt(message): global public_key, n e = public_key verschlüsselter_text = 1 während e> 0: verschlüsselter_text *= Nachricht verschlüsselter_text %= n e -= 1 return verschlüsselter_text # Zum Entschlüsseln der angegebenen Nummer def decrypt( verschlüsselter_text): globaler privater_schlüssel, n d = privater_schlüssel entschlüsselt = 1 während d> 0: entschlüsselt *= verschlüsselter_text entschlüsselt %= n d -= 1 entschlüsselt zurückgeben # Zuerst jedes Zeichen in seinen ASCII-Wert konvertieren und # dann codieren und dann die zu erhaltende Zahl decodieren das # ASCII und Konvertieren in Zeichen def Encoder(Nachricht): encoded = [] # Aufrufen der Verschlüsselungsfunktion in der Codierungsfunktion für den Buchstaben in der Nachricht: encoded.append(encrypt(ord(letter))) return encoded def decoder(encoded) : s = '' # Aufruf der Entschlüsselungsfunktion, Dekodierungsfunktion für num in encoded: s += chr(decrypt(num)) return s if __name__ == '__main__': primefiller() setkeys() message =  'Testnachricht' # Kommentar unten für manuelle Eingabe entfernen # message = input('Geben Sie die Nachricht ein
') # Aufruf der Kodierungsfunktion coded = Encoder(Nachricht) print('Initial message:') print(message ) print('

Die verschlüsselte Nachricht (mit öffentlichem Schlüssel verschlüsselt)
') print(''.join(str(p) für p in codiert)) print('

Die entschlüsselte message(decrypted by public key)
') print(''.join(str(p) for p in decoder(coded))) C# using System; mit System.Collections.Generic; öffentliche Klasse GFG { privates statisches HashSet prime = neues HashSet ();  privates statisches int? public_key = null;  privates statisches int? private_key = null;  privates statisches int? n = null;  privater statischer Zufall random = new Random();  public static void Main() { PrimeFiller();  SetKeys();  string message = 'Testnachricht';  // Kommentar unten für manuelle Eingabe entfernen // Console.WriteLine('Geben Sie die Nachricht ein:');  // message = Console.ReadLine();  Aufführen coded = Encoder(Nachricht);  Console.WriteLine('Initial message:');  Console.WriteLine(message);  Console.WriteLine('

Die verschlüsselte Nachricht (verschlüsselt mit öffentlichem Schlüssel)
');  Console.WriteLine(string.Join('', coded));  Console.WriteLine('

Die entschlüsselte Nachricht (entschlüsselt mit dem öffentlichen Schlüssel)
');  Console.WriteLine(Decoder(codiert));  } public static void PrimeFiller() { bool[] sieve = new bool[250];  für (int i = 0; i <250; i++)  {  sieve[i] = true;  }  sieve[0] = false;  sieve[1] = false;  for (int i = 2; i  <250; i++)  {  for (int j = i * 2; j  <250; j += i)  {  sieve[j] = false;  }  }  for (int i = 0; i   {  if (sieve[i])  {  prime.Add(i);  }  }  }  public static int PickRandomPrime()  {  int k = random.Next(0, prime.Count - 1);  var enumerator = prime.GetEnumerator();  for (int i = 0; i  <= k; i++)  {  enumerator.MoveNext();  }  int ret = enumerator.Current;  prime.Remove(ret);  return ret;  }  public static void SetKeys()  {  int prime1 = PickRandomPrime();  int prime2 = PickRandomPrime();  n = prime1 * prime2;  int fi = (prime1 - 1) * (prime2 - 1);  int e = 2;  while (true)  {  if (GCD(e, fi) == 1)  {  break;  }  e += 1;  }  public_key = e;  int d = 2;  while (true)  {  if ((d * e) % fi == 1)  {  break;  }  d += 1;  }  private_key = d;  }  public static int Encrypt(int message)  {  int e = public_key.Value;  int encrypted_text = 1;  while (e>0) { verschlüsselter_text *= Nachricht;  verschlüsselter_text %= n.Value;  e -= 1;  } return verschlüsselter_text;  } public static int Decrypt(int verschlüsselter_text) { int d = private_key.Value;  int entschlüsselt = 1;  while (d> 0) { entschlüsselt *= verschlüsselter_text;  entschlüsselt %= n.Value;  d -= 1;  } entschlüsselt zurückgeben;  } public static int GCD(int a, int b) { if (b == 0) { return a;  } return GCD(b, a % b);  } öffentliche statische Liste Encoder(String-Nachricht) { List codiert = neue Liste ();  foreach (char-Buchstabe in der Nachricht) { encoded.Add(Encrypt((int)letter));  } return encoded;  } öffentlicher statischer String Decoder(List codiert) { string s = '';  foreach (int num in encoded) { s += (char)Decrypt(num);  }  kehrt zurück;  } } Ausgangsnachricht: Testnachricht Die verschlüsselte Nachricht (mit öffentlichem Schlüssel verschlüsselt) 863312887135951593413927434912887135951359583051879012887 Die entschlüsselte Nachricht (mit privatem Schlüssel entschlüsselt) Testnachricht Implementierung des RSA-Kryptosystems mit Primitive Roots in C++ Wir werden eine einfache Version von RSA mit Primitive implementieren Wurzeln.   Schritt 1: Schlüssel generieren Zunächst müssen wir zwei große Primzahlen p und q generieren. Diese Primzahlen sollten ungefähr gleich lang sein und ihr Produkt sollte viel größer sein als die Nachricht, die wir verschlüsseln möchten. Wir können die Primzahlen mit jedem Algorithmus zur Primzahlprüfung generieren, beispielsweise mit dem Miller-Rabin-Test. Sobald wir die beiden Primzahlen haben, können wir ihr Produkt n = p*q berechnen, das den Modul für unser RSA-System darstellt. Als nächstes müssen wir eine ganze Zahl e mit 1 wählen. Um den Exponenten d des privaten Schlüssels zu berechnen, müssen wir eine ganze Zahl d mit d*e = 1 (mod phi(n)) finden. Dies kann mit dem erweiterten Euklidischen Algorithmus erfolgen. Unser öffentlicher Schlüssel ist (n, e) und unser privater Schlüssel ist (n, d).   Schritt 2: Verschlüsselung Um eine Nachricht m zu verschlüsseln, müssen wir sie in eine ganze Zahl zwischen 0 und n-1 umwandeln. Dies kann mithilfe eines reversiblen Codierungsschemas wie ASCII oder UTF-8 erfolgen. Sobald wir die ganzzahlige Darstellung der Nachricht haben, berechnen wir den Chiffretext c als c = m^e (mod n). Dies kann mithilfe modularer Potenzierungsalgorithmen, beispielsweise der binären Potenzierung, effizient erfolgen.   Schritt 3: Entschlüsselung Um den Chiffretext c zu entschlüsseln, berechnen wir den Klartext m als m = c^d (mod n). Auch hier können wir modulare Potenzierungsalgorithmen verwenden, um dies effizient zu tun.   Schritt 4: Beispiel Lassen Sie uns ein Beispiel mit kleinen Werten durchgehen, um zu veranschaulichen, wie das RSA-Kryptosystem funktioniert. Angenommen, wir wählen p = 11 und q = 13, was n = 143 und phi(n) = 120 ergibt. Wir können e = 7 wählen, da ggT(7, 120) = 1. Mit dem erweiterten euklidischen Algorithmus können wir berechnen d = 103, da 7*103 = 1 (mod 120). Unser öffentlicher Schlüssel ist (143, 7) und unser privater Schlüssel ist (143, 103). Angenommen, wir möchten die Nachricht HALLO verschlüsseln. Wir können dies mithilfe der ASCII-Kodierung in die Ganzzahl 726564766 umwandeln. Mit dem öffentlichen Schlüssel berechnen wir den Chiffretext als c = 726564766^7 (mod 143) = 32. Um den Chiffretext zu entschlüsseln, verwenden wir den privaten Schlüssel, um m = 32^103 (mod 143) = 726564766 zu berechnen, was das Original ist Nachricht. Beispielcode: C++ #include #include using namespace std; // berechne phi(n) für eine gegebene Zahl n int phi(int n) { int result = n;  für (int i = 2; i <= sqrt(n); i++) {  if (n % i == 0) {  while (n % i == 0) {  n /= i;  }  result -= result / i;  }  }  if (n>1) { Ergebnis -= Ergebnis / n;  } Ergebnis zurückgeben; } // gcd(a, b) mit dem euklidischen Algorithmus berechnen int gcd(int a, int b) { if (b == 0) { return a;  } return gcd(b, a % b); } // a^b mod m mit modularer Potenzierung berechnen int modpow(int a, int b, int m) { int result = 1;  while (b> 0) { if (b & 1) { result = (result * a) % m;  } a = (a * a) % m;  b>>= 1;  } Ergebnis zurückgeben; } // Erzeuge eine zufällige primitive Wurzel modulo n int genericPrimitiveRoot(int n) { int phiN = phi(n);  int Faktoren[phiN], numFactors = 0;  int temp = phiN;  // alle Primfaktoren von phi(n) für (int i = 2; i erhalten <= sqrt(temp); i++) {  if (temp % i == 0) {  factors[numFactors++] = i;  while (temp % i == 0) {  temp /= i;  }  }  }  if (temp>1) { Faktoren[numFactors++] = temp;  } // teste mögliche primitive Wurzeln für (int i = 2; i <= n; i++) {  bool isRoot = true;  for (int j = 0; j   if (modpow(i, phiN / factors[j], n) == 1) {  isRoot = false;  break;  }  }  if (isRoot) {  return i;  }  }  return -1; } int main() {  int p = 61;  int q = 53;  int n = p * q;  int phiN = (p - 1) * (q - 1);  int e = generatePrimitiveRoot(phiN);  int d = 0;  while ((d * e) % phiN != 1) {  d++;  }  cout  < < 'Public key: {'  < < e  < < ', '  < < n  < < '}'  < < endl;  cout  < < 'Private key: {'  < < d  < < ', '  < < n  < < '}'  < < endl;  int m = 123456;  int c = modpow(m, e, n);  int decrypted = modpow(c, d, n);  cout  < < 'Original message: '  < < m  < < endl;  cout  < < 'Encrypted message: '  < < c  < < endl;  cout  < < 'Decrypted message: '  < < decrypted  < < endl;  return 0; }  Output:  Public key: {3, 3233} Private key: {2011, 3233} Original message: 123456 Encrypted message: 855 Decrypted message: 123456   Advantages:    Security:   RSA algorithm is considered to be very secure and is widely used for secure data transmission.   Public-key cryptography:   RSA algorithm is a public-key cryptography algorithm, which means that it uses two different keys for encryption and decryption. The public key is used to encrypt the data, while the private key is used to decrypt the data.   Key exchange:   RSA algorithm can be used for secure key exchange, which means that two parties can exchange a secret key without actually sending the key over the network.   Digital signatures:   RSA algorithm can be used for digital signatures, which means that a sender can sign a message using their private key, and the receiver can verify the signature using the sender’s public key.   Speed:   The RSA technique is suited for usage in real-time applications since it is quite quick and effective.   Widely used:   Online banking, e-commerce, and secure communications are just a few fields and applications where the RSA algorithm is extensively developed.  Disadvantages:    Slow processing speed:   RSA algorithm is slower than other encryption algorithms, especially when dealing with large amounts of data.   Large key size:   RSA algorithm requires large key sizes to be secure, which means that it requires more computational resources and storage space.   Vulnerability to side-channel attacks:   RSA algorithm is vulnerable to side-channel attacks, which means an attacker can use information leaked through side channels such as power consumption, electromagnetic radiation, and timing analysis to extract the private key.   Limited use in some applications:   RSA algorithm is not suitable for some applications, such as those that require constant encryption and decryption of large amounts of data, due to its slow processing speed.   Complexity:   The RSA algorithm is a sophisticated mathematical technique that some individuals may find challenging to comprehend and use.   Key Management:   The secure administration of the private key is necessary for the RSA algorithm, although in some cases this can be difficult.   Vulnerability to Quantum Computing:   Quantum computers have the ability to attack the RSA algorithm, potentially decrypting the data.