c++实现RSA加解密代码并加注释

RSA (Rivest-Shamir-Adleman) 是一种非对称加密算法，用于在信息安全领域保证数据的安全传输。以下是使用C++实现RSA的基本步骤，包括生成密钥对、加密和解密的简单示例。请注意，这只是一个基础版本，实际应用中需要考虑更多的安全性和效率优化。

#include <iostream>
#include <vector>
#include <string>

using namespace std;

// 密钥长度和素数大小（这里为了简化示例）
const int RSA_KEY_SIZE = 512;
const int PRIME_SIZE = RSA_KEY_SIZE / 8; // 十进制位

// 计算大素数
int generatePrime() {
    vector<bool> isComposite(PRIME_SIZE, false);
    for (int i = 0; i * i <= PRIME_SIZE; ++i) {
        if (isComposite[i]) continue;
        for (int j = i * i; j < PRIME_SIZE; j += i)
            isComposite[j] = true;
    }
    int prime = 0;
    for (int i = 2; i < PRIME_SIZE && !isComposite[i]; ++i)
        prime = i;
    return prime;
}

// 获取欧拉函数
int euler_phi(int n) {
    int result = n;
    for (int i = 2; i * i <= n; ++i) {
        if (n % i == 0) {
            while (n % i == 0) {
                n /= i;
            }
            result -= result / i;
        }
    }
    if (n > 1) result -= result / n;
    return result;
}

// 模逆运算
int mod_inv(int a, int m) {
    int extended_gcd = extendedEuclid(a, m, NULL, NULL);
    return extended_gcd == 1 ? static_cast<int>(m - 1) % m : -1;
}

// 费马小定理
bool fermat_test(int p, int q) {
    int a = p - 1;
    return powmod(a, q, p) == 1;
}

void generateRSAKeys() {
    int p = generatePrime();
    int q = generatePrime();

    // 验证两个素数是否互质
    if (!fermat_test(p, q)) {
        cerr << "Error: Primes are not co-prime!" << endl;
        return;
    }

    int n = p * q;
    int phi_n = euler_phi(n);

    // 秘钥部分
    int e = 65537; // 公开选择的一个常用素数
    int d = mod_inv(e, phi_n); // 私钥，满足 ed ≡ 1 (mod φ(n))

    cout << "Public Key: (e = " << e << ", n = " << n << ")" << endl;
    cout << "Private Key: (d = " << d << ")" << endl;
}

// RSA 加密
string encrypt(const string& message, int e, int n) {
    vector<int> message_ints;
    for (char c : message) {
        message_ints.push_back(c);
    }

    vector<int> encrypted(message_ints.size(), 0);
    for (size_t i = 0; i < message_ints.size(); ++i) {
        encrypted[i] = powmod(message_ints[i], e, n);
    }

    string encrypted_str;
    for (int num : encrypted)
        encrypted_str += (char)(num % 256);
    return encrypted_str;
}

// RSA 解密
string decrypt(const string& encrypted, int d, int n) {
    vector<int> encrypted_ints(encrypted.begin(), encrypted.end());
    vector<int> decrypted(encrypted_ints.size(), 0);

    for (size_t i = 0; i < encrypted_ints.size(); ++i) {
        decrypted[i] = powmod(encrypted_ints[i], d, n);
    }

    string decrypted_str;
    for (int num : decrypted)
        decrypted_str += (char)(num % 256);
    return decrypted_str;
}

int main() {
    generateRSAKeys();
    string plaintext = "Hello, RSA!";
    string ciphertext = encrypt(plaintext, getPublicKey().first, getPublicKey().second);
    string decryptedtext = decrypt(ciphertext, getPrivateKey(), getPublicKey().second);
    cout << "Original Text: " << plaintext << endl;
    cout << "Encrypted Text: " << ciphertext << endl;
    cout << "Decrypted Text: " << decryptedtext << endl;

    return 0;
}

// 简化的辅助函数
tuple<int, int> getPublicKey() { return make_tuple(65537, RSA_KEY_SIZE * 8); } // 示例用法，实际应从私钥获取

在这个示例中，我们没有包含完整的错误处理以及一些关键辅助函数如`extendedEuclid`和`powmod`。在实际应用中，你需要确保所有的数学操作都正确，并添加适当的错误检查。