openssl解密错误代码101560482解决方式

错误代码101560482是 OpenSSL 库的一个常见错误，通常是由于证书或密钥不匹配或格式不正确导致的。

以下是可能的解决方案：

1. 确认证书和密钥是否匹配，可以使用以下命令检查：

   openssl x509 -noout -modulus -in server.crt | openssl md5
   openssl rsa -noout -modulus -in server.key | openssl md5

如果两个命令输出的 MD5 值不同，则证书和密钥不匹配，需要重新生成或重新配置。

2. 确认证书和密钥的格式是否正确，OpenSSL 支持多种格式，例如 PEM、DER、PKCS#12 等。可以使用以下命令检查：

   openssl x509 -in server.crt -text -noout
   openssl rsa -in server.key -text -noout

如果命令输出的内容包含错误或异常，则证书或密钥格式可能不正确，需要重新生成或转换格式。

3. 确认 OpenSSL 版本是否支持所使用的算法，例如如果使用了较新的加密算法（如 AES-GCM），则需要 OpenSSL 1.1.0 或更高版本支持。

4. 确认 OpenSSL 配置是否正确，例如 OpenSSL 配置文件中的路径是否正确，是否存在必要的库和依赖项等。

希望这些解决方案能够帮助你解决问题。

相关问题

c++ openssl rsa 字符串公私钥加解密示例代码

在C++中使用OpenSSL库处理RSA加密解密，你需要包含相关的头文件，并利用`BIO`和`RSA`结构来操作公钥和私钥。下面是一个简单的示例，展示了如何生成密钥对、加密字符串、然后用私钥解密：

#include <openssl/bio.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <string>

// 生成RSA密钥对
std::string generate_key_pair() {
    RSA *rsa = RSA_new();
    BIGNUM *e = BN_new(), *n = BN_new();

    // 生成大素数n和e(通常e=65537)
    BN_rand_range(n, RSA_NBITS);
    BN_set_word(e, RSA_F4);

    // 创建RSA结构并设置参数
    RSA_generate_key_ex(rsa, RSA modulus bits, e, n, NULL, NULL);

    // 将公钥和私钥转换为PEM格式的字符串
    BIO* bio_pub = BIO_new(BIO_s_mem());
    BIO* bio_priv = BIO_new(BIO_s_mem());
    PEM_write_bio_RSA_PUBKEY(bio_pub, rsa);
    PEM_write_bio_RSAPrivateKey(bio_priv, rsa, NULL, NULL);

    std::string pub_str = BIO_get_mem_data(bio_pub), priv_str = BIO_get_mem_data(bio_priv);
    RSA_free(rsa);
    BN_free(e);
    BN_free(n);
    BIO_free_all(bio_pub);
    BIO_free_all(bio_priv);

    return "Public Key:\n" + pub_str + "\nPrivate Key:\n" + priv_str;
}

// 加密函数
std::string encrypt(const std::string& plaintext, const std::string& public_key) {
    RSA *rsaPub = RSA_new();
    rsaPub = PEM_read_RSA_PUBKEY(RSA_new(), (char*)public_key.c_str(), NULL, NULL);
    BIO* bio_in = BIO_new(BIO_f_base64());
    BIO* bio_out = BIO_new(BIO_s_mem());

    BIO_write(bio_in, plaintext.c_str(), plaintext.length());
    BIO_push(bio_out, bio_in);
    RSA_public_encrypt(plaintext.size(), BIO_get_mem_ptr(bio_out), rsaPub, RSA_PKCS1_OAEP_PADDING);

    std::string ciphertext = BIO_get_mem_data(bio_out);
    BIO_free_all(bio_out);
    RSA_free(rsaPub);
    return ciphertext;
}

// 解密函数
std::string decrypt(const std::string& ciphertext, const std::string& private_key) {
    RSA *rsaPri = RSA_new();
    rsaPri = PEM_read_PrivateKey(RSA_new(), (char*)private_key.c_str(), NULL, NULL);
    BIO* bio_in = BIO_new(BIO_f_base64());
    BIO* bio_out = BIO_new(BIO_s_mem());

    BIO_write(bio_in, ciphertext.c_str(), ciphertext.length());
    BIO_push(bio_out, bio_in);
    RSA_private_decrypt(ciphertext.size(), BIO_get_mem_ptr(bio_in), rsaPri, RSA_PKCS1_OAEP_PADDING);

    std::string plaintext = BIO_get_mem_data(bio_out);
    BIO_free_all(bio_out);
    RSA_free(rsaPri);
    return plaintext;
}

int main() {
    auto key_pairs = generate_key_pair();
    std::cout << "Keys generated.\n";
    std::string encrypted_text = encrypt("Hello, World!", key_pairs.substr(key_pairs.find("\n")+1));
    std::cout << "Text encrypted.\n";
    std::string decrypted_text = decrypt(encrypted_text, key_pairs.substr(0, key_pairs.find("\n")));
    std::cout << "Decrypted text: " << decrypted_text << std::endl;

    return 0;
}

注意：这个示例仅供参考，实际应用中你需要处理错误检查和异常处理。此外，为了安全存储和传输私钥，建议将其保存在安全的地方，而不是明文显示。

c++ openssl ecc算法大文件加密解密示例代码

下面是一个使用C++和OpenSSL库进行ECC算法大文件加密解密的示例代码：

#include <openssl/ec.h>
#include <openssl/ecdh.h>
#include <openssl/evp.h>
#include <openssl/pem.h>
#include <openssl/err.h>
#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main()
{
    // 1. 生成ECC密钥对
    EC_KEY *key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
    if (key == NULL)
    {
        cout << "Error: Failed to create ECC key." << endl;
        return 1;
    }
    if (!EC_KEY_generate_key(key))
    {
        cout << "Error: Failed to generate ECC key." << endl;
        EC_KEY_free(key);
        return 1;
    }

    // 2. 保存私钥
    string privkey_filename = "ecc_private.pem";
    FILE *privkey_file = fopen(privkey_filename.c_str(), "w");
    if (privkey_file == NULL)
    {
        cout << "Error: Failed to create private key file." << endl;
        EC_KEY_free(key);
        return 1;
    }
    if (!PEM_write_ECPrivateKey(privkey_file, key, NULL, NULL, 0, NULL, NULL))
    {
        cout << "Error: Failed to write private key." << endl;
        fclose(privkey_file);
        EC_KEY_free(key);
        return 1;
    }
    fclose(privkey_file);

    // 3. 保存公钥
    string pubkey_filename = "ecc_public.pem";
    FILE *pubkey_file = fopen(pubkey_filename.c_str(), "w");
    if (pubkey_file == NULL)
    {
        cout << "Error: Failed to create public key file." << endl;
        EC_KEY_free(key);
        return 1;
    }
    if (!PEM_write_EC_PUBKEY(pubkey_file, key))
    {
        cout << "Error: Failed to write public key." << endl;
        fclose(pubkey_file);
        EC_KEY_free(key);
        return 1;
    }
    fclose(pubkey_file);

    // 4. 加密文件
    string plaintext_filename = "largefile.txt";
    string ciphertext_filename = "largefile.enc";
    ifstream plaintext_file(plaintext_filename, ios::in | ios::binary);
    if (!plaintext_file.is_open())
    {
        cout << "Error: Failed to open plaintext file." << endl;
        EC_KEY_free(key);
        return 1;
    }
    ofstream ciphertext_file(ciphertext_filename, ios::out | ios::binary);
    if (!ciphertext_file.is_open())
    {
        cout << "Error: Failed to create ciphertext file." << endl;
        plaintext_file.close();
        EC_KEY_free(key);
        return 1;
    }

    EVP_PKEY *evp_pubkey = EVP_PKEY_new();
    if (evp_pubkey == NULL)
    {
        cout << "Error: Failed to create EVP public key." << endl;
        plaintext_file.close();
        ciphertext_file.close();
        EC_KEY_free(key);
        return 1;
    }
    if (!EVP_PKEY_set1_EC_KEY(evp_pubkey, key))
    {
        cout << "Error: Failed to set EVP public key." << endl;
        plaintext_file.close();
        ciphertext_file.close();
        EVP_PKEY_free(evp_pubkey);
        EC_KEY_free(key);
        return 1;
    }

    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
    if (ctx == NULL)
    {
        cout << "Error: Failed to create cipher context." << endl;
        plaintext_file.close();
        ciphertext_file.close();
        EVP_PKEY_free(evp_pubkey);
        EC_KEY_free(key);
        return 1;
    }
    if (!EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, NULL, NULL))
    {
        cout << "Error: Failed to initialize encryption context." << endl;
        plaintext_file.close();
        ciphertext_file.close();
        EVP_PKEY_free(evp_pubkey);
        EC_KEY_free(key);
        EVP_CIPHER_CTX_free(ctx);
        return 1;
    }

    unsigned char plaintext_buffer[4096];
    unsigned char ciphertext_buffer[4096 + EVP_CIPHER_block_size(EVP_aes_256_cbc())];
    int num_bytes_read = 0;
    int ciphertext_len = 0;
    while ((num_bytes_read = plaintext_file.read((char *)plaintext_buffer, sizeof(plaintext_buffer)).gcount()) > 0)
    {
        if (!EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, NULL))
        {
            cout << "Error: Failed to reset encryption context." << endl;
            plaintext_file.close();
            ciphertext_file.close();
            EVP_PKEY_free(evp_pubkey);
            EC_KEY_free(key);
            EVP_CIPHER_CTX_free(ctx);
            return 1;
        }
        if (!EVP_EncryptInit_ex(ctx, NULL, NULL, EVP_PKEY_get0(evp_pubkey), NULL))
        {
            cout << "Error: Failed to set public key for encryption context." << endl;
            plaintext_file.close();
            ciphertext_file.close();
            EVP_PKEY_free(evp_pubkey);
            EC_KEY_free(key);
            EVP_CIPHER_CTX_free(ctx);
            return 1;
        }
        if (!EVP_EncryptUpdate(ctx, ciphertext_buffer, &ciphertext_len, plaintext_buffer, num_bytes_read))
        {
            cout << "Error: Failed to encrypt plaintext." << endl;
            plaintext_file.close();
            ciphertext_file.close();
            EVP_PKEY_free(evp_pubkey);
            EC_KEY_free(key);
            EVP_CIPHER_CTX_free(ctx);
            return 1;
        }
        ciphertext_file.write((char *)ciphertext_buffer, ciphertext_len);
    }
    if (!EVP_EncryptFinal_ex(ctx, ciphertext_buffer, &ciphertext_len))
    {
        cout << "Error: Failed to finalize encryption." << endl;
        plaintext_file.close();
        ciphertext_file.close();
        EVP_PKEY_free(evp_pubkey);
        EC_KEY_free(key);
        EVP_CIPHER_CTX_free(ctx);
        return 1;
    }
    ciphertext_file.write((char *)ciphertext_buffer, ciphertext_len);

    plaintext_file.close();
    ciphertext_file.close();
    EVP_PKEY_free(evp_pubkey);
    EC_KEY_free(key);
    EVP_CIPHER_CTX_free(ctx);

    // 5. 解密文件
    ifstream ciphertext_file2(ciphertext_filename, ios::in | ios::binary);
    if (!ciphertext_file2.is_open())
    {
        cout << "Error: Failed to open ciphertext file." << endl;
        return 1;
    }
    ofstream plaintext_file2("largefile.dec", ios::out | ios::binary);
    if (!plaintext_file2.is_open())
    {
        cout << "Error: Failed to create plaintext file." << endl;
        ciphertext_file2.close();
        return 1;
    }

    EVP_PKEY *evp_privkey = EVP_PKEY_new();
    if (evp_privkey == NULL)
    {
        cout << "Error: Failed to create EVP private key." << endl;
        ciphertext_file2.close();
        plaintext_file2.close();
        return 1;
    }
    if (!EVP_PKEY_set1_EC_KEY(evp_privkey, key))
    {
        cout << "Error: Failed to set EVP private key." << endl;
        ciphertext_file2.close();
        plaintext_file2.close();
        EVP_PKEY_free(evp_privkey);
        return 1;
    }

    ctx = EVP_CIPHER_CTX_new();
    if (ctx == NULL)
    {
        cout << "Error: Failed to create cipher context." << endl;
        ciphertext_file2.close();
        plaintext_file2.close();
        EVP_PKEY_free(evp_privkey);
        return 1;
    }
    if (!EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, NULL, NULL))
    {
        cout << "Error: Failed to initialize decryption context." << endl;
        ciphertext_file2.close();
        plaintext_file2.close();
        EVP_PKEY_free(evp_privkey);
        EVP_CIPHER_CTX_free(ctx);
        return 1;
    }

    ciphertext_len = 0;
    int plaintext_len = 0;
    while ((ciphertext_file2.read((char *)ciphertext_buffer, sizeof(ciphertext_buffer)).gcount()) > 0)
    {
        if (!EVP_DecryptInit_ex(ctx, NULL, NULL, EVP_PKEY_get0(evp_privkey), NULL))
        {
            cout << "Error: Failed to set private key for decryption context." << endl;
            ciphertext_file2.close();
            plaintext_file2.close();
            EVP_PKEY_free(evp_privkey);
            EVP_CIPHER_CTX_free(ctx);
            return 1;
        }
        if (!EVP_DecryptUpdate(ctx, plaintext_buffer, &plaintext_len, ciphertext_buffer, ciphertext_file2.gcount()))
        {
            cout << "Error: Failed to decrypt ciphertext." << endl;
            ciphertext_file2.close();
            plaintext_file2.close();
            EVP_PKEY_free(evp_privkey);
            EVP_CIPHER_CTX_free(ctx);
            return 1;
        }
        plaintext_file2.write((char *)plaintext_buffer, plaintext_len);
    }
    if (!EVP_DecryptFinal_ex(ctx, plaintext_buffer, &plaintext_len))
    {
        cout << "Error: Failed to finalize decryption." << endl;
        ciphertext_file2.close();
        plaintext_file2.close();
        EVP_PKEY_free(evp_privkey);
        EVP_CIPHER_CTX_free(ctx);
        return 1;
    }
    plaintext_file2.write((char *)plaintext_buffer, plaintext_len);

    ciphertext_file2.close();
    plaintext_file2.close();
    EVP_PKEY_free(evp_privkey);
    EVP_CIPHER_CTX_free(ctx);

    cout << "ECC encryption and decryption completed successfully." << endl;

    return 0;
}

注意：为了简化代码，这里没有进行错误处理和参数检查，实际应用中需要根据需要进行适当的错误处理和参数检查。