Algoritmus RSA je asymetrický kryptografický algoritmus. Asymetrický vlastne znamená, že funguje na dvoch rôznych klávesoch t.j. Verejný kľúč a Súkromný kľúč. Ako už názov napovedá, verejný kľúč dostane každý a súkromný kľúč zostane súkromný.
java cast char na reťazec
Príklad asymetrickej kryptografie:
- Klient (napríklad prehliadač) odošle svoj verejný kľúč na server a vyžiada si nejaké údaje.
- Server zašifruje údaje pomocou verejného kľúča klienta a odošle zašifrované údaje.
- Klient prijme tieto údaje a dešifruje ich.
Keďže je to asymetrické, nikto iný okrem prehliadača nemôže dešifrovať údaje, aj keď má verejný kľúč prehliadača tretia strana.
Nápad! Myšlienka RSA je založená na skutočnosti, že je ťažké faktorizovať veľké celé číslo. Verejný kľúč pozostáva z dvoch čísel, pričom jedno číslo je násobením dvoch veľkých prvočísel. A súkromný kľúč je tiež odvodený od rovnakých dvoch prvočísel. Takže ak niekto dokáže faktorizovať veľké číslo, súkromný kľúč je kompromitovaný. Sila šifrovania teda úplne závisí od veľkosti kľúča a ak zdvojnásobíme alebo strojnásobíme veľkosť kľúča, sila šifrovania sa exponenciálne zvýši. Kľúče RSA môžu byť zvyčajne dlhé 1024 alebo 2048 bitov, ale odborníci sa domnievajú, že 1024-bitové kľúče by sa v blízkej budúcnosti mohli zlomiť. Ale zatiaľ sa to javí ako nesplniteľná úloha.
Poďme sa naučiť mechanizmus algoritmu RSA:>> Generovanie verejného kľúča:
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],>> Generovanie súkromného kľúča: Musíme vypočítať Φ(n) : Tak, že Φ(n) = (P-1)(Q-1), takže, Φ(n) = 3016 Teraz vypočítajte súkromný kľúč, d : d = (k *Φ(n) + 1) / e pre nejaké celé číslo k Pre k = 2 je hodnota d 2011. Teraz sme pripravení s naším – verejným kľúčom ( n = 3127 a e = 3) a súkromným kľúčom (d = 2011 ) Teraz zašifrujeme HI : Prevedieme písmená na čísla : H = 8 a I = 9 Takto zašifrované údaje c = (89 e )mod n Takto naše šifrované údaje vyjdú na 1394 Teraz dešifrujeme 1394 : Dešifrované údaje = (c d )mod n Naše šifrované údaje teda vychádzajú 89 8 = H a I = 9 t.j. 'HI'. Nižšie je uvedená implementácia algoritmu RSA pre metódu 1: Šifrovanie a dešifrovanie malých číselných hodnôt: C++ // Program C pre asymetrický kryptografický // algoritmus RSA. Pre demonštračné hodnoty sú // relatívne malé v porovnaní s praktickou // aplikáciou #include using namespace std; // Vráti gcd z a a b int gcd(int a, int h) { int temp; pričom (1) { teplota = a % h; if (teplota == 0) vráti h; a = h; h = teplota; } } // Kód na demonštráciu algoritmu RSA int main() { // Dve náhodné prvočísla double p = 3; dvojité q = 7; // Prvá časť verejného kľúča: double n = p * q; // Nájdenie inej časti verejného kľúča. // e znamená zašifrovať double e = 2; dvojité phi = (p - 1) * (q - 1); while (e // e musí byť co-prime k phi a // menšie ako phi. if (gcd(e, phi) == 1) break; else e++; } // Súkromný kľúč (d znamená dešifrovať) // zvolenie d tak, aby vyhovovalo // d*e = 1 + k * totient int k = 2; // Konštantná hodnota double d = (1 + (k * phi)) / e Správa, ktorá sa má zašifrovať double msg = 12 printf('Data spravy = %lf', msg) // Šifrovanie c = (msg ^ e) % n double c = pow(msg, e); ('
Zašifrované údaje = %lf', c // Dešifrovanie m = (c ^ d) % n double m = pow(c, d = fmod(m, n);
Pôvodná správa bola odoslaná = %lf', m návrat 0 } // Tento kód pridal Akash Sharan /*nepíšte sem názov balíka */ import java.io.*; java.math.*; import java.util.*; /* * Java program pre asymetrický kryptografický algoritmus RSA * Pre ukážku, hodnoty sú * relatívne malé v porovnaní s praktickou aplikáciou */ public class GFG { public static double gcd(double a. , double h) { /* * Táto funkcia vráti gcd alebo najväčší spoločný * deliteľ */ double temp; while (pravda) { temp = a % h; if (teplota == 0) vráti h; a = h; h = teplota; } } public static void main(String[] argumenty) { double p = 3; dvojité q = 7; // Uloží prvú časť verejného kľúča: double n = p * q; // Nájdenie druhej časti verejného kľúča. // double e znamená zašifrovať double e = 2; dvojité phi = (p - 1) * (q - 1); pričom (e /* * e musí byť prvočíslo k phi a * menšie ako phi. */ if (gcd(e, phi) == 1) break; inak e++; } int k = 2; // Konštantná hodnota double d = (1 + (k * phi)) / e; // Správa, ktorá sa má zašifrovať double msg = 12; ^ e) % n double c = Math.pow(msg, e); c = c % n; % n double m = Math.pow(c, d); System.out.println('Pôvodná správa odoslaná = ' + m); Python3 # Python pre asymetrický kryptografický algoritmus RSA # Pre demonštráciu sú hodnoty # relatívne malé v porovnaní s matematickým importom z praktickej aplikácie def gcd(a, h): temp = 0 while(1): temp = a % h if (temp ==. 0): návrat h a = h h = teplota p = 3 q = 7 n = p*q e = 2 phi = (p-1)*(q-1), pričom (e # e musí byť prvočíslo k phi a # menšie než phi (gcd(e, phi) == 1): break else: e = e+1 # Súkromný kľúč (d znamená dešifrovať) # výber d tak, aby vyhovoval # d*e = 1 + k * totient. k = 2 d = (1 + (k*phi))/e # Správa na zašifrovanie msg = 12,0 print('Údaje správy = ', msg) # Šifrovanie c = (správa ^ e) % n c = pow( msg, e) c = math.fmod(c, n) print('Zašifrované údaje = ', c) # Dešifrovanie m = (c ^ d) % n m = pow(c, d) m = math.fmod( m, n) print('Pôvodná správa odoslaná = ', m) # Tento kód prispel Pranay Arora. C# /* * C# program pre asymetrický kryptografický algoritmus RSA. * Pre demonštráciu, hodnoty sú * relatívne malé v porovnaní s praktickou aplikáciou */ pomocou System; public class GFG { public static double gcd(double a, double h) { /* * Táto funkcia vráti gcd alebo najväčší spoločný * deliteľ */ double temp; while (pravda) { temp = a % h; if (teplota == 0) vráti h; a = h; h = teplota; } } static void Main() { double p = 3; dvojité q = 7; // Uloží prvú časť verejného kľúča: double n = p * q; // Nájdenie druhej časti verejného kľúča. // double e znamená zašifrovať double e = 2; dvojité phi = (p - 1) * (q - 1); pričom (e /* * e musí byť prvočíslo k phi a * menšie ako phi. */ if (gcd(e, phi) == 1) break; inak e++; } int k = 2; // Konštantná hodnota double d = (1 + (k * phi)) / e; // Správa, ktorá sa má zašifrovať double msg = 12; ', msg)); // Šifrovanie c = (msg ^ e) % n double c = Math.Pow(msg, e). Format('{0:F6}', c)); // Dešifrovanie m = (c ^ d) % n double m = Math.Pow(c, d) = m % n; 'Pôvodná správa bola odoslaná = ' + String.Format('{0:F6}', m)); function gcd(a, h) { /* * Táto funkcia vráti gcd alebo najväčší spoločný * deliteľ */ nech temp while (true) { temp = a % h if (temp == 0) return h; ; h = temp } nech q = 7 // Uloží prvú časť verejného kľúča: nech n = p * q; // Nájdenie druhej časti verejného kľúča. // e znamená šifrovať nech e = 2; nech phi = (p - 1) * (q - 1); pričom (e /* * e musí byť prvočíslo k phi a * menšie ako phi. */ if (gcd(e, phi) == 1) break; inak e++; } nech k = 2; // Konštantná hodnota nech d = (1 + (k * phi)) / e; // Správa, ktorá sa má zašifrovať nech msg = 12; ) % n nech c = Math.pow(msg, e); c = c % n; console.log('Zašifrované dáta = ' + c // Dešifrovanie m = (c ^ d) % n nech m); = Math.pow(c, d); m = m % n console.log('Pôvodná správa odoslaná = ' + m); Message Sent = 12.000000 Metóda 2: Šifrovanie a dešifrovanie obyčajných textových správ obsahujúcich abecedy a čísla pomocou ich ASCII hodnoty: C++ #include using namespace std set; hlavný; // množina bude zbierka prvočísel, // kde môžeme vybrať náhodné prvočísla p a q int verejný_kľúč; int súkromný_kľúč; int n; // funkciu spustíme iba raz, aby sme naplnili množinu // prvočísel void primefiller() { // metóda použitá na vyplnenie množiny prvočísel je seive of // eratosthenes (metóda na zber prvočísel) vektor seive(250, pravda); seive[0] = nepravda; seive[1] = nepravda; pre (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 kodér(reťazcová správa) { vektor forma; // volanie šifrovacej funkcie vo funkcii kódovania pre (auto& písmeno : správa) form.push_back(encrypt((int)list)); návratový formulár; } reťazcový dekodér (vektor zakódované) { reťazec s; // volanie dešifrovacej funkcie dekódovacej funkcie pre (auto& num : zakódované) s += decrypt(num); návrat s; } int main() { primefiller(); setkeys(); string message = 'Testovacia správa'; // zrušte komentár nižšie pre manuálne zadanie // cout<<'enter the message
';getline(cin,message); // calling the encoding function vector kódované = kodér (správa); 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) { zašifrovaný_text *= správa; zašifrovaný_text %= n; e= 1; } return encrypted_text; } public static int decrypt(int encrypted_text) { int d = private_key; int dešifrované = 1; while (d> 0) { decrypted *= encrypted_text; dešifrované %= n; d = 1; } return dešifrovaný; } 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 (písmeno znaku: message.toCharArray()) { encoded.add(encrypt((int)letter)); } návrat zakódovaný; } public static String decoder(List encoded) { StringBuilder s = new StringBuilder(); for (int num : zakódované) { s.append((char)decrypt(num)); } return s.toString(); } } Python3 import náhodný import matematika # Množina bude zbierka prvočísel, # kde môžeme vybrať náhodné prvočísla p a q prime = set() public_key = Žiadne private_key = Žiadne n = Žiadne # Funkciu spustíme iba raz na vyplnenie množiny # prvočísel def primefiller(): # Metóda použitá na vyplnenie množiny prvočísel je Sieve of # Eratosthenes (metóda na zbieranie prvočísel) seive = [Pravda] * 250 seive[0] = False seive[1 ] = Nepravda pre i v rozsahu (2, 250): pre j v rozsahu (i * 2, 250, i): seive[j] = Nepravda # Vyplnenie prvočísel pre i v rozsahu (len(seive)): ak seive[i]: prime.add(i) # Výber náhodného prvočísla a vymazanie tohto # čísla zo zoznamu, pretože p!=q def pickrandomprime(): globálne prvočíslo k = random.randint(0, len(prvočíslo) - 1) it = iter(prime) for _ in range(k): next(it) ret = next(it) prime.remove(ret) return ret def setkeys(): global public_key, private_key, n prime1 = pickrandomprime() # Prvé prvočíslo prime2 = pickrandomprime() # Druhé prvočíslo n = prvočíslo1 * prvočíslo2 fi = (prvočíslo1 - 1) * (prvočíslo2 - 1) e = 2, zatiaľ čo True: if math.gcd(e, fi) == 1: zlom e += 1 # d = (k*Φ(n) + 1) / e pre nejaké celé číslo k verejný_kľúč = e d = 2, kým True: if (d * e) % fi == 1: zlom d += 1 súkromný_kľúč = d # Na zašifrovanie daného čísla def encrypt(správa): global public_key, n e = public_key encrypted_text = 1 while e> 0: encrypted_text *= message encrypted_text %= n e -= 1 return encrypted_text # Na dešifrovanie daného čísla def decrypt( encrypted_text): global private_key, n d = private_key decrypted = 1, zatiaľ čo d> 0: decrypted *= encrypted_text decrypted %= n d -= 1 return decrypted # Najprv skonvertujte každý znak na jeho hodnotu ASCII a # potom ho zakódujte a potom dekódujte číslo, aby ste získali # ASCII a jeho konverzia na znak def encoder(správa): encoded = [] # Volanie šifrovacej funkcie v kódovacej funkcii pre písmeno v správe: encoded.append(encrypt(ord(list))) return encoded def decoder(encoded) : s = '' # Volanie dešifrovacej funkcie dekódovacej funkcie pre num in zakódované: s += chr(decrypt(num)) return s if __name__ == '__main__': primefiller() setkeys() message = 'Test Message' # Odkomentujte nižšie pre manuálne zadanie # message = input('Zadajte správu
') # Volanie kódovacej funkcie coded = kodér(správa) print('Počiatočná správa:') print(správa ) print('
Zakódovaná správa (šifrovaná verejným kľúčom)
') print(''.join(str(p) pre p v kódovanom)) print('
Dekódovaná správa(dešifrovaná verejným kľúčom)
') print(''.join(str(p) pre p v dekodéri(kódované))) C# pomocou System; pomocou System.Collections.Generic; public class GFG { private static HashSet prime = nový HashSet (); súkromný statický int? verejný_kľúč = null; súkromný statický int? private_key = null; súkromný statický int? n = null; private static Random random = new Random(); public static void Main() { PrimeFiller(); SetKeys(); string message = 'Testovacia správa'; // Odkomentujte nižšie pre manuálne zadanie // Console.WriteLine('Zadajte správu:'); // správa = Console.ReadLine(); Zoznam kódované = Kodér(správa); Console.WriteLine('Úvodná správa:'); Console.WriteLine(správa); Console.WriteLine('
Zakódovaná správa (zašifrovaná verejným kľúčom)
'); Console.WriteLine(string.Join('', kódované)); Console.WriteLine('
Dekódovaná správa (dešifrovaná verejným kľúčom)
'); Console.WriteLine(Decoder(coded)); } public static void PrimeFiller() { bool[] sito = new bool[250]; pre (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) { zašifrovaný_text *= správa; encrypted_text %= n.Value; e= 1; } return encrypted_text; } public static int Dešifrovať(int zašifrovaný_text) { int d = súkromný_kľúč.Hodnota; int dešifrované = 1; while (d> 0) { decrypted *= encrypted_text; dešifrované %= n.Hodnota; d = 1; } return dešifrovaný; } public static int GCD(int a, int b) { if (b == 0) { return a; } return GCD(b, a % b); } verejný statický zoznam Kódovač (reťazcová správa) { Zoznam zakódované = nový zoznam (); foreach (písmeno char v správe) { zakódované.Add(Zašifrovať((int)písmeno)); } návrat zakódovaný; } public static string Decoder(Zoznam zakódované) { string s = ''; foreach (int num in zakódované) { s += (char)Decrypt(num); } return s; } } Výstup Počiatočná správa: Testovacia správa Zakódovaná správa (zašifrovaná verejným kľúčom) 863312887135951593413927434912887135951359583051879012887 Dekódovaná správa (dešifrovaná pomocou súkromného kľúča RImpot implementuje jednoduchú verziu RSA pomocou primitívnych koreňov. Krok 1: Generovanie kľúčov Na začiatok musíme vygenerovať dve veľké prvočísla, p a q. Tieto prvočísla by mali mať približne rovnakú dĺžku a ich súčin by mal byť oveľa väčší ako správa, ktorú chceme zašifrovať. Prvočísla môžeme vygenerovať pomocou akéhokoľvek algoritmu testovania primality, ako je Miller-Rabinov test. Keď máme dve prvočísla, môžeme vypočítať ich súčin n = p*q, čo bude modul pre náš systém RSA. Ďalej musíme zvoliť celé číslo e také, že 1 Na výpočet exponentu súkromného kľúča d musíme nájsť celé číslo d také, že d*e = 1 (mod phi(n)). Dá sa to urobiť pomocou rozšíreného euklidovského algoritmu. Náš verejný kľúč je (n, e) a náš súkromný kľúč je (n, d). Krok 2: Šifrovanie Aby sme zašifrovali správu m, musíme ju previesť na celé číslo medzi 0 a n-1. Dá sa to urobiť pomocou schémy reverzibilného kódovania, ako je ASCII alebo UTF-8. Keď máme celočíselné vyjadrenie správy, vypočítame šifrový text c ako c = m^e (mod n). Dá sa to efektívne dosiahnuť pomocou modulárnych umocňovacích algoritmov, ako je binárne umocňovanie. Krok 3: Dešifrovanie Na dešifrovanie šifrového textu c vypočítame otvorený text m ako m = c^d (mod n). Opäť môžeme použiť modulárne umocňovacie algoritmy, aby sme to dosiahli efektívne. Krok 4: Príklad Prejdime si príkladom s použitím malých hodnôt na ilustráciu toho, ako funguje kryptosystém RSA. Predpokladajme, že zvolíme p = 11 a q = 13, čím dostaneme n = 143 a phi(n) = 120. Môžeme zvoliť e = 7, keďže gcd(7, 120) = 1. Pomocou rozšíreného euklidovského algoritmu môžeme vypočítať d = 103, pretože 7*103 = 1 (mod 120). Náš verejný kľúč je (143, 7) a náš súkromný kľúč je (143, 103). Predpokladajme, že chceme zašifrovať správu HELLO. Môžeme to previesť na celé číslo 726564766 pomocou kódovania ASCII. Pomocou verejného kľúča vypočítame šifrový text ako c = 726564766^7 (mod 143) = 32. Na dešifrovanie šifrovaného textu použijeme súkromný kľúč na výpočet m = 32^103 (mod 143) = 726564766, čo je originál správu. Príklad kódu: C++ #include #include using namespace std; // výpočet phi(n) pre dané číslo n int phi(int n) { int vysledok = n; pre (int i = 2; i<= sqrt(n); i++) { if (n % i == 0) { while (n % i == 0) { n /= i; } result -= result / i; } } if (n>1) { vysledok -= vysledok / n; } vrátiť výsledok; } // výpočet gcd(a, b) pomocou euklidovského algoritmu int gcd(int a, int b) { if (b == 0) { return a; } return gcd(b, a % b); } // vypočítajte a^b mod m pomocou modulárneho umocňovania int modpow(int a, int b, int m) { int vysledok = 1; while (b> 0) { if (b & 1) { vysledok = (vysledok * a) % m; } a = (a * a) % m; b>>= 1; } vrátiť výsledok; } // vygeneruj nahodny primitivny koren modulo n int vygenerujPrimitiveRoot(int n) { int phiN = phi(n); int faktory[phiN], numFactors = 0; int temp = phiN; // získajte všetky prvočísla phi(n) pre (int i = 2; i<= sqrt(temp); i++) { if (temp % i == 0) { factors[numFactors++] = i; while (temp % i == 0) { temp /= i; } } } if (temp>1) { faktory[numFactors++] = temp; } // testovanie možných primitívnych koreňov pre (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.>