RSA 알고리즘 비대칭 암호화 알고리즘입니다. 비대칭은 실제로 두 개의 서로 다른 키에서 작동한다는 것을 의미합니다. 공개 키 그리고 개인 키. 이름에서 알 수 있듯이 공개 키는 모든 사람에게 제공되고 개인 키는 비공개로 유지됩니다.
100개 중 25개
비대칭 암호화의 예:
- 클라이언트(예: 브라우저)는 공개 키를 서버에 보내고 일부 데이터를 요청합니다.
- 서버는 클라이언트의 공개 키를 사용하여 데이터를 암호화하고 암호화된 데이터를 보냅니다.
- 클라이언트는 이 데이터를 수신하고 이를 해독합니다.
이는 비대칭이기 때문에 제3자가 브라우저의 공개 키를 가지고 있더라도 브라우저 외에는 누구도 데이터를 해독할 수 없습니다.
아이디어! RSA의 아이디어는 큰 정수를 인수분해하는 것이 어렵다는 사실에 기초합니다. 공개 키는 두 개의 숫자로 구성되며, 여기서 하나의 숫자는 두 개의 큰 소수의 곱입니다. 그리고 개인 키도 동일한 두 소수에서 파생됩니다. 따라서 누군가 큰 숫자를 인수분해할 수 있으면 개인 키가 손상됩니다. 따라서 암호화 강도는 전적으로 키 크기에 따라 결정되며 키 크기를 두 배 또는 세 배로 늘리면 암호화 강도는 기하급수적으로 증가합니다. RSA 키의 길이는 일반적으로 1024비트 또는 2048비트일 수 있지만 전문가들은 1024비트 키가 가까운 미래에 손상될 수 있다고 믿습니다. 하지만 지금까지는 실현 불가능한 작업인 것 같습니다.
RSA 알고리즘의 메커니즘을 알아보겠습니다.>> 공개 키 생성:
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],>> 개인 키 생성: Φ(n)을 계산해야 합니다. Φ(n) = (P-1)(Q-1)이므로 Φ(n) = 3016 이제 개인 키를 계산합니다. d : d = (k *Φ(n) + 1) / e(일부 정수 k) k = 2인 경우 d의 값은 2011입니다. 이제 공개 키(n = 3127 및 e = 3) 및 개인 키(d = 2011)를 사용할 준비가 되었습니다. ) 이제 HI를 암호화하겠습니다. 문자를 숫자로 변환합니다. H = 8 및 I = 9 따라서 암호화된 데이터 c = (89 e )mod n 따라서 암호화된 데이터는 1394가 됩니다. 이제 1394를 해독하겠습니다. 해독된 데이터 = (c d )mod n 따라서 암호화된 데이터는 89 8 = H 및 I = 9, 즉 'HI'가 됩니다. 다음은 방법 1에 대한 RSA 알고리즘의 구현입니다. 작은 숫자 값의 암호화 및 복호화: C++ // RSA 비대칭 암호화를 위한 C 프로그램 // 알고리즘. 데모용 값은 // 실제 애플리케이션에 비해 상대적으로 작습니다. // #include using 네임스페이스 std; // a와 b의 gcd를 반환합니다. int gcd(int a, int h) { int temp; 동안 (1) { 임시 = a % h; if (temp == 0) 반환 h; a = h; h = 온도; } } // RSA 알고리즘을 보여주는 코드 int main() { // 두 개의 임의의 소수 double p = 3; 이중 q = 7; // 공개 키의 첫 번째 부분: double n = p * q; // 공개키의 다른 부분을 찾는다. // e는 encrypt double을 나타냅니다. e = 2; 이중 파이 = (p - 1) * (q - 1); while (e // e는 phi와 동일소수이고 // phi보다 작아야 합니다. if (gcd(e, phi) == 1) break; else e++; } // 개인 키 (d는 해독을 나타냄) // // d*e = 1 + k * totient int k = 2; // 상수 값 double d = (1 + (k * phi)) / e // 암호화할 메시지 double msg; = 12; printf('메시지 데이터 = %lf', msg); // 암호화 c = (msg ^ e) % n double c = pow(msg, e); ('
암호화된 데이터 = %lf', c); // 복호화 m = (c ^ d) % n double m = pow(c, d) m = fmod(m, n);
Original Message Sent = %lf', m); return 0; } // 이 코드는 Akash Sharan이 제공한 것입니다. Java /*package //여기에 패키지 이름을 쓰지 마십시오. */ import java.io.*; java.math.*; import java.util.*; /* * RSA 비대칭 암호화 알고리즘을 위한 Java 프로그램 * 데모를 위해 값은 * 실제 애플리케이션에 비해 상대적으로 작습니다. */ public static double gcd(double a , double h) { /* * 이 함수는 gcd 또는 최대 공약수를 반환합니다. */ double temp; while (true) { temp = a % h; if (temp == 0) 반환 h; a = h; h = 온도; } } public static void main(String[] args) { double p = 3; 이중 q = 7; // 공개 키의 첫 번째 부분을 저장합니다: double n = p * q; // 공개키의 다른 부분을 찾는다. // double e는 암호화를 나타냅니다. double e = 2; 이중 파이 = (p - 1) * (q - 1); while (e /* * e는 phi와 서로소여야 하고 * phi보다 작아야 합니다. */ if (gcd(e, phi) == 1) break; else e++; } int k = 2; // 상수 값 double d = (1 + (k * phi)) / e; // 암호화할 메시지 double msg = 12 System.out.println('Message data = ' + msg); ^ e) % n double c = Math.pow(msg, e); c = c % n; System.out.println('암호화된 데이터 = ' + c); % n double m = Math.pow(c, d); m = m % n; System.out.println('Original Message Sent = ' + m) } } // 이 코드는 Pranay Arora가 제공한 것입니다. Python3 # RSA 비대칭 암호화 알고리즘을 위한 Python # 데모를 위해 값은 # 실제 응용 프로그램에 비해 상대적으로 작습니다. import math def gcd(a, h): temp = 0 while(1): temp = a % h if (temp == 0): 반환 h a = h h = temp p = 3 q = 7 n = p*q e = 2 phi = (p-1)*(q-1) while (e # e는 phi와 서로소여야 하고 # 더 작아야 합니다 if(gcd(e, phi) == 1): break else: e = e+1 # 개인 키(d는 decrypt를 나타냄) # d를 만족하도록 선택 # d*e = 1 + k * totient k = 2 d = (1 + (k*phi))/e # 암호화할 메시지 msg = 12.0 print('Message data = ', msg) # 암호화 c = (msg ^ e) % n c = pow( msg, e) c = math.fmod(c, n) print('암호화된 데이터 = ', c) # 복호화 m = (c ^ d) % n m = pow(c, d) m = math.fmod( m, n) print('Original Message Sent = ', m) # 이 코드는 Pranay Arora가 제공한 것입니다. C# /* * RSA 비대칭 암호화 알고리즘을 위한 C# 프로그램입니다. * 데모를 위해 값은 * 실제 적용에 비해 상대적으로 작습니다 */ 시스템 사용; public class GFG { public static double gcd(double a, double h) { /* * 이 함수는 gcd 또는 최대 공약수 */ double temp를 반환합니다. while (true) { temp = a % h; if (temp == 0) 반환 h; a = h; h = 온도; } } static void Main() { double p = 3; 이중 q = 7; // 공개 키의 첫 번째 부분을 저장합니다: double n = p * q; // 공개키의 다른 부분을 찾는다. // double e는 암호화를 나타냅니다. double e = 2; 이중 파이 = (p - 1) * (q - 1); while (e /* * e는 phi와 서로소여야 하고 * phi보다 작아야 합니다. */ if (gcd(e, phi) == 1) break; else e++; } int k = 2; // 상수 값 double d = (1 + (k * phi)) / e; // 암호화할 메시지 double msg = 12 Console.WriteLine('메시지 데이터 = ' + String.Format('{0:F6} ', msg)); // 암호화 c = (msg ^ e) % n double c = Math.Pow(msg, e); c = c % n; Console.WriteLine('암호화된 데이터 = ' + String. Format('{0:F6}', c)); // 복호화 m = (c ^ d) % n double m = Math.Pow(c, d) m = m % n; 'Original Message Sent = ' + String.Format('{0:F6}', m)) } } // 이 코드는 Pranay Arora가 제공한 것입니다. //GFG //이 접근 방식에 대한 Javascript 코드입니다. function gcd(a, h) { /* * 이 함수는 gcd 또는 최대 공약수를 반환합니다. */ let temp; while (true) { temp = a % h; if (temp == 0) return a = h; ; h = temp; } } let p = 3; let q = 7; // 공개 키의 첫 번째 부분을 저장합니다: let n = p * q; // 공개키의 다른 부분을 찾는다. // e는 암호화를 나타냅니다. let e = 2; phi = (p - 1) * (q - 1)이라고 하자; while (e /* * e는 phi와 서로소여야 하고 * phi보다 작아야 합니다. */ if (gcd(e, phi) == 1) break; else e++; } let k = 2; // 상수 값 let d = (1 + (k * phi)) / e; // 암호화할 메시지 let msg = 12; console.log('메시지 데이터 = ' + msg); ) % n let c = Math.pow(msg, e); c = c % n; console.log('암호화된 데이터 = ' + c) // 복호화 m = (c ^ d) % n let m = Math.pow(c, d); m = m % n; console.log('Original Message Sent = ' + m); //순다람이 작성한 코드입니다. 출력 메시지 데이터 = 12.000000 암호화된 데이터 = 3.000000 보낸 메시지 = 12.000000 방법 2: ASCII 값을 사용하여 알파벳과 숫자가 포함된 일반 텍스트 메시지 암호화 및 해독: C++ #include using 네임스페이스 std; 초기; // 집합은 소수의 집합이 될 것입니다. // 여기서 임의의 소수 p와 q를 선택할 수 있습니다. int public_key; int 개인_키; int n; // 소수 집합을 채우기 위해 함수를 한 번만 실행합니다. // void primefiller() { // 소수 집합을 채우는 데 사용되는 메서드는 // 에라토스테네스(소수를 수집하는 메서드) 벡터와 같습니다. seive(250, 참); seive[0] = 거짓; seive[1] = 거짓; for (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 인코더(문자열 메시지) { 벡터 형태; // (auto& letter : message)에 대한 인코딩 함수에서 암호화 함수 호출 form.push_back(encrypt((int)letter)); 반품 양식; } 문자열 디코더(벡터 인코딩됨) { 문자열 s; // 해독 함수 호출 decodering function for (auto& num : encoded) s += decrypt(num); 반환 s; } int main() { primefiller(); 세트키(); 문자열 메시지 = '테스트 메시지'; // 수동 입력을 위해 아래 주석 해제 // cout<<'enter the message
';getline(cin,message); // calling the encoding function vector 코딩됨 = 인코더(메시지); 시합<< '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) { 암호화된_텍스트 *= 메시지; 암호화된_텍스트 %= n; 전자 -= 1; } 암호화된 텍스트를 반환합니다. } 공개 정적 int decrypt(int 암호화_텍스트) { int d = private_key; int 해독됨 = 1; while (d> 0) { 해독됨 *= 암호화된_텍스트; 해독됨 %= n; d -= 1; } 해독된 반환; } public static int gcd(int a, int b) { if (b == 0) { return a; } return gcd(b, a % b); } 공개 정적 목록 인코더(문자열 메시지) { 목록 인코딩 = new ArrayList(); for (char 문자 : message.toCharArray()) { encoded.add(encrypt((int)letter)); } 인코딩된 반환; } 공개 정적 문자열 디코더(목록 인코딩) { StringBuilder s = new StringBuilder(); for (int num : 인코딩됨) { s.append((char)decrypt(num)); } s.toString()을 반환합니다. } } Python3 import random import math # 세트는 소수의 모음입니다. # 여기서 임의의 소수 p와 q를 선택할 수 있습니다. prime = set() public_key = None private_key = None n = None # 함수를 한 번만 실행합니다. # 소수 집합을 채우려면 def primefiller(): # 소수 집합을 채우는 데 사용되는 방법은 Sieve of # 에라토스테네스(소수를 수집하는 방법) seive = [True] * 250 seive[0] = False seive[1 ] = False for i in range(2, 250): for j in range(i * 2, 250, i): seive[j] = False # i in range(len(seive))에 대한 소수 채우기: if seive[i]: prime.add(i) # 임의의 소수를 선택하고 그 소수를 # 목록에서 지웁니다. 왜냐면 p!=q def pickrandomprime(): global prime k = random.randint(0, len(prime) - 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() # 첫 번째 소수 prime2 = pickrandomprime() # 두 번째 소수 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 for some 정수 k public_key = e d = 2 while True: if (d * e) % fi == 1: break d += 1 private_key = d # 주어진 숫자를 암호화하려면 def encrypt(message): global public_key, n e = public_key 암호화된_text = 1 while e> 0: 암호화된_text *= message 암호화된_text %= n e -= 1 return 암호화된_text # 주어진 숫자를 해독하려면 def decrypt( crypto_text): global private_key, n d = private_key decrypted = 1 while d> 0: decrypted *= 암호화된_text decrypted %= n d -= 1 return decrypted # 먼저 각 문자를 ASCII 값으로 변환한 다음 # 인코딩한 다음 숫자를 디코딩하여 가져옵니다. # ASCII를 문자로 변환 def 인코더(message): encode = [] # 메시지의 문자에 대한 인코딩 함수에서 암호화 함수 호출: encoded.append(encrypt(ord(letter))) return encode def decoder(encoded) : s = '' # 해독 함수 호출 decodering function for num in Encoded: s += chr(decrypt(num)) return s if __name__ == '__main__': primefiller() setkeys() message = '테스트 메시지' # 수동 입력을 위해 아래 주석 해제 # message = input('메시지 입력
') # 인코딩 함수 호출 coded = 인코더(message) print('초기 메시지:') print(message ) print('
인코딩된 메시지(공개 키로 암호화됨)
') print(''.join(str(p) for p in coded)) print('
디코딩된 메시지 message(공개 키로 해독됨)
') print(''.join(str(p) for p in decoder(coded))) C# using System; System.Collections.Generic을 사용합니다. 공개 클래스 GFG { 개인 정적 HashSet 프라임 = 새로운 HashSet (); 개인 정적 정수? 공개_키 = null; 개인 정적 정수? 개인키 = null; 개인 정적 정수? n = 널; 개인 정적 무작위 무작위 = 새로운 무작위(); 공개 정적 무효 Main() { PrimeFiller(); 키 설정(); 문자열 메시지 = '테스트 메시지'; // 수동 입력을 위해 아래 주석 해제 // Console.WriteLine('Enter the message:'); // 메시지 = Console.ReadLine(); 목록 coded = 인코더(메시지); Console.WriteLine('초기 메시지:'); Console.WriteLine(메시지); Console.WriteLine('
인코딩된 메시지(공개 키로 암호화됨)
'); Console.WriteLine(string.Join('', 코딩됨)); Console.WriteLine('
디코드된 메시지(공개 키로 해독됨)
'); Console.WriteLine(디코더(코딩)); } 공개 정적 void PrimeFiller() { bool[] sieve = new bool[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.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) { 암호화된_텍스트 *= 메시지; 암호화된_텍스트 %= n.값; 전자 -= 1; } 암호화된 텍스트를 반환합니다. } 공개 정적 int Decrypt(int 암호화_텍스트) { int d = private_key.Value; int 해독됨 = 1; while (d> 0) { 해독됨 *= 암호화된_텍스트; 해독됨 %= n.값; d -= 1; } 해독된 반환; } 공개 정적 int GCD(int a, int b) { if (b == 0) { return a; } return GCD(b, a % b); } 공개 정적 목록 인코더(문자열 메시지) { 목록 인코딩됨 = 새 목록 (); foreach(메시지의 문자) { encoded.Add(Encrypt((int)letter)); } 인코딩된 반환; } 공개 정적 문자열 디코더(목록 인코딩됨) { 문자열 s = ''; foreach (인코딩된 int num) { s += (char)Decrypt(num); } s를 반환합니다; } } 출력 초기 메시지: 테스트 메시지 인코딩된 메시지(공개 키로 암호화됨) 863312887135951593413927434912887135951359583051879012887 디코딩된 메시지(개인 키로 해독됨) C++에서 기본 루트를 사용하는 RSA 암호화 시스템의 테스트 메시지 구현 기본 루트를 사용하여 RSA의 간단한 버전을 구현합니다. 1단계: 키 생성 시작하려면 두 개의 큰 소수 p와 q를 생성해야 합니다. 이러한 소수는 길이가 거의 같아야 하며 그 결과는 암호화하려는 메시지보다 훨씬 커야 합니다. Miller-Rabin 테스트와 같은 소수 테스트 알고리즘을 사용하여 소수를 생성할 수 있습니다. 두 개의 소수가 있으면 그 곱 n = p*q를 계산할 수 있으며, 이는 RSA 시스템의 모듈러스가 됩니다. 다음으로, 1이 되는 정수 e를 선택해야 합니다. 개인 키 지수 d를 계산하려면 d*e = 1(mod phi(n))이 되는 정수 d를 찾아야 합니다. 이는 확장된 유클리드 알고리즘을 사용하여 수행할 수 있습니다. 공개 키는 (n, e)이고 개인 키는 (n, d)입니다. 2단계: 암호화 메시지 m을 암호화하려면 이를 0과 n-1 사이의 정수로 변환해야 합니다. 이는 ASCII 또는 UTF-8과 같은 가역적 인코딩 체계를 사용하여 수행할 수 있습니다. 메시지의 정수 표현이 있으면 암호문 c를 c = m^e(mod n)로 계산합니다. 이는 이진 지수화와 같은 모듈식 지수화 알고리즘을 사용하여 효율적으로 수행할 수 있습니다. 3단계: 암호 해독 암호문 c를 해독하기 위해 일반 텍스트 m을 m = c^d(mod n)로 계산합니다. 다시 말하지만, 모듈식 지수화 알고리즘을 사용하여 이 작업을 효율적으로 수행할 수 있습니다. 4단계: 예 RSA 암호화 시스템의 작동 방식을 설명하기 위해 작은 값을 사용하는 예를 살펴보겠습니다. p = 11 및 q = 13을 선택하여 n = 143 및 phi(n) = 120이라고 가정합니다. gcd(7, 120) = 1이므로 e = 7을 선택할 수 있습니다. 확장된 유클리드 알고리즘을 사용하여 다음을 계산할 수 있습니다. 7*103 = 1(mod 120)이므로 d = 103입니다. 공개 키는 (143, 7)이고 개인 키는 (143, 103)입니다. HELLO 메시지를 암호화한다고 가정해 보겠습니다. ASCII 인코딩을 사용하여 이를 정수 726564766으로 변환할 수 있습니다. 공개 키를 사용하여 암호문을 c = 726564766^7(mod 143) = 32로 계산합니다. 암호문을 해독하기 위해 개인 키를 사용하여 원본인 m = 32^103(mod 143) = 726564766을 계산합니다. 메시지. 예제 코드: C++ #include #include using 네임스페이스 std; // 주어진 숫자 n에 대해 phi(n)을 계산합니다. int phi(int n) { int result = n; for (int i = 2; i<= sqrt(n); i++) { if (n % i == 0) { while (n % i == 0) { n /= i; } result -= result / i; } } if (n>1) { 결과 -= 결과 / n; } 결과를 반환합니다. } // 유클리드 알고리즘을 사용하여 gcd(a, b)를 계산합니다. int gcd(int a, int b) { if (b == 0) { return a; } return gcd(b, a % b); } // 모듈러 지수법을 사용하여 a^b mod m을 계산합니다. int modpow(int a, int b, int m) { int result = 1; while (b> 0) { if (b & 1) { 결과 = (결과 * a) % m; } a = (a * a) %m; b>>= 1; } 결과를 반환합니다. } // n 모듈로 임의의 원시 루트를 생성합니다. int generatePrimitiveRoot(int n) { int phiN = phi(n); 정수 인자[phiN], numFactors = 0; int 온도 = phiN; // phi(n)의 모든 소인수를 얻습니다. for (int i = 2; i<= sqrt(temp); i++) { if (temp % i == 0) { factors[numFactors++] = i; while (temp % i == 0) { temp /= i; } } } if (temp>1) { 요인[numFactors++] = 온도; } // (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.>