C/C++使用openssl进行摘要和加密解密（md5, sha256, des, rsa）

最新推荐文章于 2024-05-14 17:51:59 发布
最新推荐文章于 2024-05-14 17:51:59 发布
阅读量1.4k 收藏 8
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37990044/article/details/78688797
版权

penssl里面有很多用于摘要哈希、加密解密的算法，方便集成于工程项目，被广泛应用于网络报文中的安全传输和认证。下面以md5，sha256，des，rsa几个典型的api简单使用作为例子。

 

算法介绍

md5：https://en.wikipedia.org/wiki/MD5

sha256：https://en.wikipedia.org/wiki/SHA-2

des: https://en.wikipedia.org/wiki/Data_Encryption_Standard

rsa: https://en.wikipedia.org/wiki/RSA_(cryptosystem)

 

工程配置

以windows下为例

 

  1. 编译openssl库，得到头文件include和链接库lib和dll
  2. 配置包含头文件目录和库目录
  3. 工程中设置链接指定的lib：fenbieshlibssl.lib，libcrypto.lib
  4. 将对应的dll拷贝到exe执行目录：libcrypto-1_1.dll， libssl-1_1.dll
linux下同理

 

 

代码

#include <iostream>    
#include <cassert>  
#include <string>    
#include <vector>    
#include "openssl/md5.h"    
#include "openssl/sha.h"    
#include "openssl/des.h"    
#include "openssl/rsa.h"    
#include "openssl/pem.h" 
#pragma comment(lib,"libeay32.lib")
#pragma comment(lib,"ssleay32.lib")
  
// ---- md5摘要哈希 ---- //    
void md5(const std::string &srcStr, std::string &encodedStr, std::string &encodedHexStr)  
{  
    // 调用md5哈希    
    unsigned char mdStr[33] = {0};  
    MD5((const unsigned char *)srcStr.c_str(), srcStr.length(), mdStr);  
  
    // 哈希后的字符串    
    encodedStr = std::string((const char *)mdStr);  
    // 哈希后的十六进制串 32字节    
    char buf[65] = {0};  
    char tmp[3] = {0};  
    for (int i = 0; i < 32; i++)  
    {  
        sprintf(tmp, "%02x", mdStr[i]);  
        strcat(buf, tmp);  
    }  
    buf[32] = '\0'; // 后面都是0，从32字节截断    
    encodedHexStr = std::string(buf);  
}  
  
// ---- sha256摘要哈希 ---- //    
void sha256(const std::string &srcStr, std::string &encodedStr, std::string &encodedHexStr)  
{  
    // 调用sha256哈希    
    unsigned char mdStr[33] = {0};  
    SHA256((const unsigned char *)srcStr.c_str(), srcStr.length(), mdStr);  
  
    // 哈希后的字符串    
    encodedStr = std::string((const char *)mdStr);  
    // 哈希后的十六进制串 32字节    
    char buf[65] = {0};  
    char tmp[3] = {0};  
    for (int i = 0; i < 32; i++)  
    {  
        sprintf(tmp, "%02x", mdStr[i]);  
        strcat(buf, tmp);  
    }  
    buf[32] = '\0'; // 后面都是0，从32字节截断    
    encodedHexStr = std::string(buf);  
}  
  
// ---- des对称加解密 ---- //    
// 加密 ecb模式    
std::string des_encrypt(const std::string &clearText, const std::string &key)  
{  
    std::string cipherText; // 密文    
  
    DES_cblock keyEncrypt;  
    memset(keyEncrypt, 0, 8);  
  
    // 构造补齐后的密钥    
    if (key.length() <= 8)  
        memcpy(keyEncrypt, key.c_str(), key.length());  
    else  
        memcpy(keyEncrypt, key.c_str(), 8);  
  
    // 密钥置换    
    DES_key_schedule keySchedule;  
    DES_set_key_unchecked(&keyEncrypt, &keySchedule);  
  
    // 循环加密，每8字节一次    
    const_DES_cblock inputText;  
    DES_cblock outputText;  
    std::vector<unsigned char> vecCiphertext;  
    unsigned char tmp[8];  
  
    for (int i = 0; i < clearText.length() / 8; i++)  
    {  
        memcpy(inputText, clearText.c_str() + i * 8, 8);  
        DES_ecb_encrypt(&inputText, &outputText, &keySchedule, DES_ENCRYPT);  
        memcpy(tmp, outputText, 8);  
  
        for (int j = 0; j < 8; j++)  
            vecCiphertext.push_back(tmp[j]);  
    }  
  
    if (clearText.length() % 8 != 0)  
    {  
        int tmp1 = clearText.length() / 8 * 8;  
        int tmp2 = clearText.length() - tmp1;  
        memset(inputText, 0, 8);  
        memcpy(inputText, clearText.c_str() + tmp1, tmp2);  
        // 加密函数    
        DES_ecb_encrypt(&inputText, &outputText, &keySchedule, DES_ENCRYPT);  
        memcpy(tmp, outputText, 8);  
  
        for (int j = 0; j < 8; j++)  
            vecCiphertext.push_back(tmp[j]);  
    }  
  
    cipherText.clear();  
    cipherText.assign(vecCiphertext.begin(), vecCiphertext.end());  
  
    return cipherText;  
}  
  
// 解密 ecb模式    
std::string des_decrypt(const std::string &cipherText, const std::string &key)  
{  
    std::string clearText; // 明文    
  
    DES_cblock keyEncrypt;  
    memset(keyEncrypt, 0, 8);  
  
    if (key.length() <= 8)  
        memcpy(keyEncrypt, key.c_str(), key.length());  
    else  
        memcpy(keyEncrypt, key.c_str(), 8);  
  
    DES_key_schedule keySchedule;  
    DES_set_key_unchecked(&keyEncrypt, &keySchedule);  
  
    const_DES_cblock inputText;  
    DES_cblock outputText;  
    std::vector<unsigned char> vecCleartext;  
    unsigned char tmp[8];  
  
    for (int i = 0; i < cipherText.length() / 8; i++)  
    {  
        memcpy(inputText, cipherText.c_str() + i * 8, 8);  
        DES_ecb_encrypt(&inputText, &outputText, &keySchedule, DES_DECRYPT);  
        memcpy(tmp, outputText, 8);  
  
        for (int j = 0; j < 8; j++)  
            vecCleartext.push_back(tmp[j]);  
    }  
  
    if (cipherText.length() % 8 != 0)  
    {  
        int tmp1 = cipherText.length() / 8 * 8;  
        int tmp2 = cipherText.length() - tmp1;  
        memset(inputText, 0, 8);  
        memcpy(inputText, cipherText.c_str() + tmp1, tmp2);  
        // 解密函数    
        DES_ecb_encrypt(&inputText, &outputText, &keySchedule, DES_DECRYPT);  
        memcpy(tmp, outputText, 8);  
  
        for (int j = 0; j < 8; j++)  
            vecCleartext.push_back(tmp[j]);  
    }  
  
    clearText.clear();  
    clearText.assign(vecCleartext.begin(), vecCleartext.end());  
  
    return clearText;  
}  
  
  
// ---- rsa非对称加解密 ---- //    
#define KEY_LENGTH  2048               // 密钥长度  
#define PUB_KEY_FILE "pubkey.pem"    // 公钥路径  
#define PRI_KEY_FILE "prikey.pem"    // 私钥路径  
  
// 函数方法生成密钥对   
void generateRSAKey(std::string strKey[2])  
{  
    // 公私密钥对    
    size_t pri_len;  
    size_t pub_len;  
    char *pri_key = NULL;  
    char *pub_key = NULL;  
  
    // 生成密钥对    
    RSA *keypair = RSA_generate_key(KEY_LENGTH, RSA_3, NULL, NULL);  
  
    BIO *pri = BIO_new(BIO_s_mem());  
    BIO *pub = BIO_new(BIO_s_mem());  
  
    PEM_write_bio_RSAPrivateKey(pri, keypair, NULL, NULL, 0, NULL, NULL);  
    PEM_write_bio_RSAPublicKey(pub, keypair);  
  
    // 获取长度    
    pri_len = BIO_pending(pri);  
    pub_len = BIO_pending(pub);  
  
    // 密钥对读取到字符串    
    pri_key = (char *)malloc(pri_len + 1);  
    pub_key = (char *)malloc(pub_len + 1);  
  
    BIO_read(pri, pri_key, pri_len);  
    BIO_read(pub, pub_key, pub_len);  
  
    pri_key[pri_len] = '\0';  
    pub_key[pub_len] = '\0';  
  
    // 存储密钥对    
    strKey[0] = pub_key;  
    strKey[1] = pri_key;  
  
    // 存储到磁盘（这种方式存储的是begin rsa public key/ begin rsa private key开头的）  
    FILE *pubFile = fopen(PUB_KEY_FILE, "w");  
    if (pubFile == NULL)  
    {  
        assert(false);  
        return;  
    }  
    fputs(pub_key, pubFile);  
    fclose(pubFile);  
  
    FILE *priFile = fopen(PRI_KEY_FILE, "w");  
    if (priFile == NULL)  
    {  
        assert(false);  
        return;  
    }  
    fputs(pri_key, priFile);  
    fclose(priFile);  
  
    // 内存释放  
    RSA_free(keypair);  
    BIO_free_all(pub);  
    BIO_free_all(pri);  
  
    free(pri_key);  
    free(pub_key);  
}  
  
// 命令行方法生成公私钥对（begin public key/ begin private key）  
// 找到openssl命令行工具，运行以下  
// openssl genrsa -out prikey.pem 1024   
// openssl rsa - in privkey.pem - pubout - out pubkey.pem  
  
// 公钥加密    
std::string rsa_pub_encrypt(const std::string &clearText, const std::string &pubKey)  
{  
    std::string strRet;  
    RSA *rsa = NULL;  
    BIO *keybio = BIO_new_mem_buf((unsigned char *)pubKey.c_str(), -1);  
    // 此处有三种方法  
    // 1, 读取内存里生成的密钥对，再从内存生成rsa  
    // 2, 读取磁盘里生成的密钥对文本文件，在从内存生成rsa  
    // 3，直接从读取文件指针生成rsa  
    RSA* pRSAPublicKey = RSA_new();  
    rsa = PEM_read_bio_RSAPublicKey(keybio, &rsa, NULL, NULL);  
  
    int len = RSA_size(rsa);  
    char *encryptedText = (char *)malloc(len + 1);  
    memset(encryptedText, 0, len + 1);  
  
    // 加密函数  
    int ret = RSA_public_encrypt(clearText.length(), (const unsigned char*)clearText.c_str(), (unsigned char*)encryptedText, rsa, RSA_PKCS1_PADDING);  
    if (ret >= 0)  
        strRet = std::string(encryptedText, ret);  
  
    // 释放内存  
    free(encryptedText);  
    BIO_free_all(keybio);  
    RSA_free(rsa);  
  
    return strRet;  
}  
  
// 私钥解密    
std::string rsa_pri_decrypt(const std::string &cipherText, const std::string &priKey)  
{  
    std::string strRet;  
    RSA *rsa = RSA_new();  
    BIO *keybio;  
    keybio = BIO_new_mem_buf((unsigned char *)priKey.c_str(), -1);  
  
    // 此处有三种方法  
    // 1, 读取内存里生成的密钥对，再从内存生成rsa  
    // 2, 读取磁盘里生成的密钥对文本文件，在从内存生成rsa  
    // 3，直接从读取文件指针生成rsa  
    rsa = PEM_read_bio_RSAPrivateKey(keybio, &rsa, NULL, NULL);  
  
    int len = RSA_size(rsa);  
    char *decryptedText = (char *)malloc(len + 1);  
    memset(decryptedText, 0, len + 1);  
  
    // 解密函数  
    int ret = RSA_private_decrypt(cipherText.length(), (const unsigned char*)cipherText.c_str(), (unsigned char*)decryptedText, rsa, RSA_PKCS1_PADDING);  
    if (ret >= 0)  
        strRet = std::string(decryptedText, ret);  
  
    // 释放内存  
    free(decryptedText);  
    BIO_free_all(keybio);  
    RSA_free(rsa);  
  
    return strRet;  
}  
  
int main(int argc, char **argv)  
{  
    // 原始明文    
    std::string srcText = "this is an example";  
  
    std::string encryptText;  
    std::string encryptHexText;  
    std::string decryptText;  
  
    std::cout << "=== 原始明文 ===" << std::endl;  
    std::cout << srcText << std::endl;  
  
    // md5    
    std::cout << "=== md5哈希 ===" << std::endl;  
    md5(srcText, encryptText, encryptHexText);  
    std::cout << "摘要字符： " << encryptText << std::endl;  
    std::cout << "摘要串： " << encryptHexText << std::endl;  
  
    // sha256    
    std::cout << "=== sha256哈希 ===" << std::endl;  
    sha256(srcText, encryptText, encryptHexText);  
    std::cout << "摘要字符： " << encryptText << std::endl;  
    std::cout << "摘要串： " << encryptHexText << std::endl;  
  
    // des    
    std::cout << "=== des加解密 ===" << std::endl;  
    std::string desKey = "12345";  
    encryptText = des_encrypt(srcText, desKey);  
    std::cout << "加密字符： " << std::endl;  
    std::cout << encryptText << std::endl;  
    decryptText = des_decrypt(encryptText, desKey);  
    std::cout << "解密字符： " << std::endl;  
    std::cout << decryptText << std::endl;  
  
    // rsa    
    std::cout << "=== rsa加解密 ===" << std::endl;  
    std::string key[2];  
    generateRSAKey(key);  
    std::cout << "公钥: " << std::endl;  
    std::cout << key[0] << std::endl;  
    std::cout << "私钥： " << std::endl;  
    std::cout << key[1] << std::endl;  
    encryptText = rsa_pub_encrypt(srcText, key[0]);  
    std::cout << "加密字符： " << std::endl;  
    std::cout << encryptText << std::endl;  
    decryptText = rsa_pri_decrypt(encryptText, key[1]);  
    std::cout << "解密字符： " << std::endl;  
    std::cout << decryptText << std::endl;  
  
    system("pause");  
    return 0;  
}
运行结果 

=== 原始明文 ===  
this is an example  
  
=== md5哈希 ===  
摘要字符： 乵驥!範  
摘要串： 9202816dabaaf34bb106a10421b9a0d0  
=== sha256哈希 ===  
摘要字符： 訪X5衽鄁媫j/醢?17?P?4膡zD  
摘要串： d44c035835f1c5e0668b7d186a2ff5b0  
=== des加解密 ===  
加密字符：  
?/灲取鮋t8:夽U錺?说  
解密字符：  
this is an example  
  
=== rsa加解密 ===  
公钥:  
-----BEGIN RSA PUBLIC KEY-----  
MIIBCAKCAQEA59WESdYbPsD6cYATooC4ebClTpvbTsu3X29Ha0g31kW3AmLR2zLj  
hMvdWjUhhVuM7xBoh3Ufoyj4jTGHVhunFfbzxNrt1Nb64N95bZH8e9u6LjJYqh4e  
sNoFknG+McjoSLNqGW9Yd8ejKH1Ju6C9SBUcC43XbB3XdC2matgV1zTsKhqjuywm  
gVN9DZdo2TlZkqsvOHC23rbQ+lP09rpQJ/RI4NQSnCUBqQxErCN85trcWRj1zyJA  
WaBZSvKh7J5RJcrC2ByMDmL7jrDDZl7YEolyW93SSc4xTE9Dr20OXznXNDsfQc9r  
RQHBri8Aqsu4WW3tHSBRmjW5kxFMxS4qxwIBAw==  
-----END RSA PUBLIC KEY-----  
  
私钥：  
-----BEGIN RSA PRIVATE KEY-----  
MIIEowIBAAKCAQEA59WESdYbPsD6cYATooC4ebClTpvbTsu3X29Ha0g31kW3AmLR  
2zLjhMvdWjUhhVuM7xBoh3Ufoyj4jTGHVhunFfbzxNrt1Nb64N95bZH8e9u6LjJY  
qh4esNoFknG+McjoSLNqGW9Yd8ejKH1Ju6C9SBUcC43XbB3XdC2matgV1zTsKhqj  
uywmgVN9DZdo2TlZkqsvOHC23rbQ+lP09rpQJ/RI4NQSnCUBqQxErCN85trcWRj1  
zyJAWaBZSvKh7J5RJcrC2ByMDmL7jrDDZl7YEolyW93SSc4xTE9Dr20OXznXNDsf  
Qc9rRQHBri8Aqsu4WW3tHSBRmjW5kxFMxS4qxwIBAwKCAQEAmo5YMTlnfytRoQAN  
FwB6+8sY3xKSNIfPlPTaR4V6jtkkrEHhPMyXrd0+PCNrrj0In2BFr6NqbMX7CMuv  
jr0aDqSigzyejeSnQJT7nmFS/T0myXblxr6/IJFZDEvUITCa2yJGu5+QT9psxajb  
0mso2ri9XQk6SBPk+B5u8eVj5Myt4tqpWL0DEEDzwfhihs+uEGM7g6bPvQBI4JXu  
8uxfSRUkpyZ5s1koEhqj+RCguksPzSWO/Ut2Sd60iOUMRhya2aEbAyRTtfhsXja3  
4NMWjXorJ0SRkryM1iLJvVWkhkcr2vShH9rm9qz16BkrkI9/9Yx++GNNr6VU/p/+  
Waa8CwKBgQD4m0ryXi6rCqazdCICGoZJGzaljApOZ1rWOiotM9TekaYE7tZ2NDAT  
eytiCzxvs4/+1Jt5XzdGJ035VJKSai/n2ZzAq1YYtVHy5CG2olmeFtwaIWU18m2s  
RjHQf/FiscVB4XdKrHjh3gLgSB8MWMDg/krisxT86HNyp1UE2jZv+QKBgQDuuoez  
V+H23ktb9oDS9HuLXt+wZuww29uNb0jhVoLiqK6M90Pl2u8yErjsq04cG9pF0MUl  
8/nIw4RRKQh9GUOBBbxZqA/1yBxmHTz48siYJ3YXf5HB+0WxxOlEk3s05AnTilTi  
5Y4u9Ptwieoy+TOXatBL9XZgKkpHbcxKZH2gvwKBgQClvNyhlB8cscR3osFWvFmG  
EiRuXVw0ROc5fBweIo3ptm6t9I75eCAM/MeWsihKd7VUjbz7lM+EGjP7jbcMRsqa  
kRMrHOQQeOFMmBZ5wZEUDz1mwO4j9vPILsvgVUuXIS4r66TccvtBPqyVhWoIOytA  
qYdBzLiomvehxONYkXmf+wKBgQCfJwUiOpaklDI9TwCMov0HlJUgRJ115+ezn4Xr  
jwHscHRd+i1D50ohYdCdx4loEpGD4INuoqaF162LcLBTZi0Arn2RGrVOhWhEE337  
TIW6xPlk/7aBUi52g0Ytt6d4mAaNBuNB7l7J+KegW/F3UM0PnIrdTk7qxtwvnogx  
mFPAfwKBgAEuRGqF2Q9bNu/r0OufeFxsYm0zFvWBIxbq3DxPYRtzfhiQMeTOzl1g  
5rowAtb/w1SusGAZ4/lEUZoBgzV+8fr+rpx3eavVCmcXBVjDi9B5nNLIXWkcoEQG  
G/4ZwXUr5kyTBktL6mIBVNJ8dJUQo8xyxK0GjfWhlsk5t/Zu8tmK  
-----END RSA PRIVATE KEY-----  
  
加密字符：  
佷篒?z_&欗霐嗪K赸;J╄[i9?S絑?て晄p?[hD∞51鱠,k|1裡郿     犓鈪鑒?饞w2?`vlu  
L<萿囂?圖L潥?O0佲y▃飕E堿^桮??,e鉀煯ACsJ挈R聡-鳊帔!eQC乥+1\(齀  
я盈Xj饮[o6覾羂≯傁澓  
解密字符：  
this is an example

注：

（1）在读取公钥文件时，PEM_read_RSA_PUBKEY()函数和PEM_read_RSAPublicKEY()的疑惑。有时候为什么读取私钥文件用的PEM_read_RSAPrivateKey()，针对上述openssl命令生成的公钥文件，在读取其内容时用对称的PEM_read_RSAPublicKEY()接口却会报错，必须要用PEM_read_RSA_PUBKEY()才可以。

          RSA PUBLIC KEY和PUBLIC KEY的两种公钥文件其存储方式是不一样的，PEM_read_RSAPublicKEY()只能读取RSA PUBLIC KEY开头形式的公钥文件（用函数生成的）；而PEM_read_RSA_PUBKEY()只能读取PUBLIC KEY开头格式的公钥文件（用命令行生成），所以公钥私钥读取函数一定要跟生成的密钥对的格式对应起来。

（2）公钥加密和私钥解密， 私钥加密公钥解密 这两种都可以使用

（3）一般加密之后的字符串因为编码跟中文对应不上所以是乱码，在很多场合选择用十六进制串输出

 

（4）实际的工程应用中读取密钥对需要加安全验证

（5）用纯代码不依赖openssl库也是可以自己实现这些加解密算法的，搞清楚原理就行


以上代码为函数格式的公钥和私钥

不同之处在于：

生成密钥对的调用函数不同

	PEM_write_bio_RSAPublicKey(pub, keypair);//函数专用
   	PEM_write_bio_RSA_PUBKEY(pub, keypair);  //命令行专用

公钥加密的调用函数不同

	rsa = PEM_read_bio_RSAPublicKey(keybio, &rsa, NULL, NULL);  //函数专用
	rsa = PEM_read_bio_RSA_PUBKEY(keybio, &rsa, NULL, NULL); //命令行专用



以下代码为命令行格式的公钥和私钥

 rsa_test_04.cpp : 定义控制台应用程序的入口点。

//
#include "stdafx.h"
//
//
//int _tmain(int argc, _TCHAR* argv[])
//{
// return 0;
//}
#include "stdafx.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <openssl/rsa.h>
#include <openssl/evp.h>
#include <openssl/objects.h>
#include <openssl/x509.h>
#include <openssl/err.h>
#include <openssl/pem.h>
#include <openssl/ssl.h>
#include <openssl/engine.h>
#include <openssl/rand.h>
#include <openssl/bio.h>
//#include <unistd.h>
#include <iostream>
#include <io.h>
//#pragma comment(lib,"ws2_32.lib")
const char *g_pPubFile = "public.pem";
const char *g_pPriFile = "private.pem";
//maxCodeByte = g_nBits/8-11
const int g_nBits = 1024;
using namespace std;
#pragma comment(lib,"libeay32.lib")
#pragma comment(lib,"ssleay32.lib")
int MakeKey()
{
 /*if (access(g_pPubFile,0) != 0 || access(g_pPriFile,0) != 0)
 {
  return 0;
 }*/
 //生成key,这里设置了1024，意味着最多可以编解码1024/8-11=117个字节，
 //RSA_F4为公钥指数，一般情况下使用RSA_F4即可，
 //其它两个参数可以设置为NULL
 RSA *pRsa = RSA_generate_key(g_nBits,RSA_F4,NULL,NULL);
 if (pRsa == NULL)
 {
  cout << "rsa_generate_key error" << endl;
  return -1;
 }
 BIO *pBio = BIO_new_file(g_pPubFile,"wb");
 if (pBio == NULL)
 {
  cout << "BIO_new_file " << g_pPubFile << " error" << endl;
  return -2;
 }
 if(PEM_write_bio_RSAPublicKey(pBio,pRsa) == 0)
 {
  cout << "write public key error" << endl;
  return -3;
 }
 BIO_free_all(pBio);

 pBio = BIO_new_file(g_pPriFile,"w");
 if (pBio == NULL)
 {
  cout << "BIO_new_file " << g_pPriFile << " error" << endl;
  return -4;
 }
 if(PEM_write_bio_RSAPrivateKey(pBio,pRsa,NULL,NULL,0,NULL,NULL) == 0)
 {
  cout << "write private key error" << endl;
  return -5;
 }
 BIO_free_all(pBio);
 RSA_free(pRsa);
 return 0;
}

int MakeKey_test_01()
{
 /*if (access(g_pPubFile,0) != 0 || access(g_pPriFile,0) != 0)
 {
  return 0;
 }*/
 //生成key,这里设置了1024，意味着最多可以编解码1024/8-11=117个字节，
 //RSA_F4为公钥指数，一般情况下使用RSA_F4即可，
 //其它两个参数可以设置为NULL
 RSA *pRsa = RSA_generate_key(g_nBits,RSA_F4,NULL,NULL);
 if (pRsa == NULL)
 {
  cout << "rsa_generate_key error" << endl;
  return -1;
 }
 BIO *pBio = BIO_new_file(g_pPubFile,"wb");
 if (pBio == NULL)
 {
  cout << "BIO_new_file " << g_pPubFile << " error" << endl;
  return -2;
 }
 PEM_write_bio_RSA_PUBKEY
 //if(PEM_write_bio_RSAPublicKey(pBio,pRsa) == 0)
 if(PEM_write_bio_RSA_PUBKEY(pBio,pRsa) == 0)
 {
  cout << "write public key error" << endl;
  return -3;
 }
 BIO_free_all(pBio);

 pBio = BIO_new_file(g_pPriFile,"w");
 if (pBio == NULL)
 {
  cout << "BIO_new_file " << g_pPriFile << " error" << endl;
  return -4;
 }
 //PEM_write_bio_PKCS8PrivateKey
 if(PEM_write_bio_RSAPrivateKey(pBio,pRsa,NULL,NULL,0,NULL,NULL) == 0)
 //if(PEM_write_bio_PKCS8PrivateKey(pBio,pRsa,NULL,NULL,0,NULL,NULL) == 0)
 {
  cout << "write private key error" << endl;
  return -5;
 }
 BIO_free_all(pBio);
 RSA_free(pRsa);
 return 0;
}
//测试使用PEM_write_bio_RSA_PUBKEY 生成的公钥加密，测试私钥解密
int Enc_test_01(char *in, int inLen, char *out, int &outLen)
{
 BIO *pBio = BIO_new_file(g_pPubFile,"r");
 //RSA *pRsa = PEM_read_bio_RSAPublicKey(pBio,NULL,NULL,NULL);
 RSA *pRsa = PEM_read_bio_RSA_PUBKEY(pBio,NULL,NULL,NULL);
 BIO_free_all(pBio);
 outLen = RSA_public_encrypt(
  (RSA_size(pRsa)-11)>inLen?inLen:RSA_size(pRsa)-11,
  reinterpret_cast<unsigned char*>(in),
  reinterpret_cast<unsigned char*>(out),
  pRsa,
  RSA_PKCS1_PADDING);
 std::cout << out << std::endl;
 //RSA_free(pRsa);
 if(outLen >= 0)
  return 0;
 return -1;
}
int Enc(char *in, int inLen, char *out, int &outLen)
{
 BIO *pBio = BIO_new_file(g_pPubFile,"r");
 RSA *pRsa = PEM_read_bio_RSAPublicKey(pBio,NULL,NULL,NULL);
 BIO_free_all(pBio);
 outLen = RSA_public_encrypt(
  (RSA_size(pRsa)-11)>inLen?inLen:RSA_size(pRsa)-11,
  reinterpret_cast<unsigned char*>(in),
  reinterpret_cast<unsigned char*>(out),
  pRsa,
  RSA_PKCS1_PADDING);
 std::cout << out << std::endl;
 //RSA_free(pRsa);
 if(outLen >= 0)
  return 0;
 return -1;
}

int Dec(char *in, int inLen, char *out, int &outLen)
{
 BIO *pBio = BIO_new_file(g_pPriFile,"r");
 RSA *pRsa = PEM_read_bio_RSAPrivateKey(pBio,NULL,NULL,NULL);
 BIO_free_all(pBio);
 outLen = RSA_private_decrypt(
  inLen,
  reinterpret_cast<unsigned char*>(in),
  reinterpret_cast<unsigned char*>(out),
  pRsa,
  RSA_PKCS1_PADDING);
 //RSA_free(pRsa);
 if(outLen >= 0)
  return 0;
 return -1;
}
//RSA_PUBKEY

//test base64

int main()
{
 //MakeKey();
 //char pOld[100]="for test";
 //char szEnc[1024] = {0};
 //int nEncLen = 0;
 //char szDec[1024] = {0};
 //int nDecLen = 0;
 //Enc(pOld,strlen(pOld),szEnc,nEncLen);
 //Dec(szEnc,nEncLen,szDec,nDecLen);
 //cout << "decode: " << szDec << endl;
//MakeKey_test_01();
//--Enc_test_01--
 //char pOld[100]="for test";
 //char szEnc[1024] = {0};
 //int nEncLen = 0;
 //char szDec[1024] = {0};
 //int nDecLen = 0;
 //Enc_test_01(pOld,strlen(pOld),szEnc,nEncLen);
 //Dec(szEnc,nEncLen,szDec,nDecLen);
 //cout << "decode: " << szDec << endl;

 cin.get();
}



以上文章借鉴与两位前辈的经验加工而成

传送门：https://www.cnblogs.com/findumars/p/7252839.html

http://blog.csdn.net/cyuyan112233/article/details/45693519

城北徐公a
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
OpenSSL之API编程 - C/C++实现AES、DES、3DES、SM4对称加密算法
new9232的博客
05-23 247
本文章介绍了OpenSSL计算对称加解密算法(AES、DES、3DES、SM4等)的相关接口，并使用C语言实现了AES和SM4加解密。
C++使用Openssl进行RSA加密解密及签名验签功能（SHA256）
09-19
使用Openssl实现RSA的加密和解密过程；使用Openssl实现签名和验签过程；SHA256WithRSA签名验签过程；封装很好，一看就懂，直接使用!
ECC加密——C++/OPENssl实现
niujinya的博客
10-14 2705
ECC加密——C++/OPENssl实现
c/c++基于openssl库的DES加密ECB模式pkcs5padding填充
Mr_oOo_的博客
01-30 1万+
前言 最近项目中需要使用DES加密算法,因为算法模式以及填充方式的不同导致无法正确加密解密,最终通过基于openssl库来完成加密解密.网上对于DES加解密的原理较多,这里就不做介绍,直接上干货, 这里只主要介绍ecb模式,pkcs5填充的加密算法的实例,如果需要更换算法,可在下面代码的注释中找到对应的设置参数. 准备 在线加解密: http://tool.chacuo.net/cryptdes...
C C++使用openssl进行摘要和加密解密（md5, sha256, des, rsa）_c+
最新发布
2401_84976377的博客
05-14 539
/ 命令行方法生成公私钥对（begin public key/ begin private key）#define PUB_KEY_FILE “pubkey.pem” // 公钥路径。#define PRI_KEY_FILE “prikey.pem” // 私钥路径。// 2, 读取磁盘里生成的密钥对文本文件，在从内存生成rsa。// 1, 读取内存里生成的密钥对，再从内存生成rsa。// ---- rsa非对称加解密 ---- //=== des加解密 ====== rsa加解密 ===
openssl+ECC开发实例（含源码）
N阶二进制的博客
12-05 2230
椭圆曲线加密（ECC，Elliptic Curve Cryptography）是一种非对称加密算法，它使用椭圆曲线上的点来进行加密、解密、数字签名和密钥交换。与传统的RSA算法相比，ECC提供了相当的安全性，但使用更短的密钥长度，从而提供更高的性能和较小的计算资源要求。
c++通过openssl实现rsa加密解密【windows版】
06-18
c++通过使用openssl实现rsa加密解密算法，网上有很多文章和例子，但是大部分都是linux版的，并且内容不全、代码老旧等各种问题，导致最后无法调试，这里提供的源码是用code::blocks编写的c++源码，可以直接运行...
ios常见加密解密方法（RSA、DES 、AES、MD5）
08-31
本文将详细介绍几种常见的加密解密方法，包括RSA、DES、AES以及MD5，并针对iOS环境中的具体使用情况进行分析。 首先，RSA是一种非对称加密算法，其特点是拥有两个密钥——公钥和私钥。公钥用于加密，私钥用于解密。...
使用OpenSSL实现RSA、AES、MD5算法-VS2017-C++.rar
08-02
用OpenSSL库实现的RSA、AES和MD5算法，用C++在Visual Studio 2017上写的，RSA和AES的秘钥长度可调、生成秘钥、加密解密都可以实现。
SHA256算法C++代码openssl库实现
08-22
对sha256在openssl库中调用和组装生成可以执行的基于openssl库的sha256模块，可供之后的生日攻击和长度扩展攻击等使用该模块。 可以运行test.cpp对该模块的散列加密功能进行简单测试。 运行指导 将源码clone到...
使用 OpenSSL 命令行进行 ECC 签名及验签
01-07
首先查看一下 OpenSSL 内建了哪些椭圆曲线，使用命令为： openssl ecparam -list_curves         选择一条椭圆曲线创建 ECC 公私钥对，这里使用 secp256k1，执行命令： openssl ecparam -name secp256k1 -genkey -out ec.key         可以用文本编辑器打开 ec.key 文件，其内容类似于： —–BEGIN EC PARAMETERS—– BgUrgQQACg== —–END EC PARAMETERS—– —–BEGIN EC PRIVATE KEY—– MHQCAQEEINMie6Xet
c++实现ECC加解密
12-30
实现了ECC算法的加密解密，主要是对字符串的加解密。 (Realize the ECC algorithm encrypt, decrypt, is mainly to the string encryption.)
C++实现对数据的SHA-256加密算法
10-31
C++实现对数据的SHA-256加密算法
des加密算法的c++ 实现
专注java二开部署
11-30 1750
总的来说，实现一个安全的加密系统需要综合考虑多个因素，并采取适当的措施来确保其安全性、性能和合规性。此外，还需要不断关注最新的安全研究和最佳实践，并及时更新和改进现有的系统。需要注意的是，DES 加密算法已经被认为是不安全的，不建议在现代应用程序中使用。总的来说，实现一个安全的加密系统需要考虑许多因素，并且需要遵循最佳实践来确保其安全性和性能。实现一个安全的加密系统需要综合考虑多个因素，并采取适当的措施来确保其安全性、性能和合规性。除了上述基本的DES加密过程，还有一些其他的步骤和注意事项可以考虑。
C++的AES及ECC加解密
weixin_41989340的博客
10-10 1902
使用C++语言，使用AES库及ECC库，实现对明文的加解密处理
简单阐述对称加密算法和非对称加密算法（附C++示例代码，以openssl实现AES、DES、RSA、ECC、DSA算法加密）
Bobowen的博客
12-22 4014
对称加密和非对称加密是两种常见的加密方法。常见的对称加密算法：AES、DES等，常见的非对称加密算法有RSA、DSA、ECC等。本篇简单介绍这些算法并做对比。
C++-openssl-aes-加密解密
aggie4628的专栏
10-25 1560
调用openssl aes的库加密解密的基本解法。离工程实践差的远了，做个基本的demo用以参考。
OpenSSL中对称加密算法DES常用函数使用举例
热门推荐
网络资源是无限的
01-11 1万+
OpenSSL中对称加密算法DES常用函数使用举例！
openssl c++ des rsa 加密解密
01-13
使用OpenSSL进行DES加密和解密，首先需要生成一个DES密钥，然后使用该密钥进行加密和解密操作。可以使用以下命令生成DES密钥： ``` openssl rand -out des.key 8 ``` 生成的密钥保存在des.key文件中。然后使用该...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值