openssl的计算MD5、AES、RSA

于 2024-09-05 09:44:31 发布
阅读量261 收藏
点赞数 2
文章标签： 网络 linux 算法 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37607695/article/details/141922649
版权

1.MD5
主要由以下几个函数计算：MD5、MD5_Init、MD5_Update、MD5_Final

#include <openssl/md5.h>
#include <openssl/err.h>
//1.计算字符串
    unsigned char MD5result[128]={0};
    unsigned char  inStr[4]={'1','2','3','4'} ;
    size_t inStrSize=sizeof(inStr);
    MD5(inStr,inStrSize,MD5result); //获取字符串的MD5值
//2.计算文件
    unsigned char MD5result[128]={0};
    MD5_CTX md5_ctx;
    MD5_Init(&md5_ctx);
    char readData[2048]={0};
    while(!rfile.eof())
    {
        rfile.read(ReadBuff,sizeof(readBuff));   //以二进制方式读需要计算MD5的文件
        int rlength = rfile.gcount();
        if(rlength>0)
        {
            MD5_Update(&md5_ctx,readBuff,rlength); //将当前文件块加入，并更新MD5
        }
    }
    MD5_Final(MD5result,&md5_ctx);  //获取MD5值

2.AES

AES加密最常用ECB、CBC分组模式，以ECB模式128位加密zeropadding为例：

//userkey:用户指定的密码，可以通过MD5、sha等算法生成，也可以用户自定义（注意：密码长度只能是16、24、32字节，如果密码字符串长度不够，可以在字符串末尾追加一些特定的字符，或者重复密码字符串，直到满足最少的长度。）

#include <openssl/aes.h>
#include <openssl/evp.h>

//1.加密
int aes128_ecb_encrypt_zeropadding_evp(const unsigned char *userkey,int userkey_len, const unsigned char* plaintext,int plaintext_len, unsigned char *out_ciphetext)
{
  if (    userkey_len<=0||
            (!(userkey_len == 16 ||userkey_len== 24 ||userkey_len == 32))
        )
    {
     
        return -1;
    }

    const unsigned char *data = plaintext;
    unsigned char *encrypt =out_ciphetext;
    const unsigned char *input_gen_key =userkey;

    unsigned char iv[EVP_MAX_IV_LENGTH] = {0}; ecb模式不需要iv偏移量
    memset((void *)iv, 'i', EVP_MAX_IV_LENGTH);
    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
    int ret = 0;
    int tlen = 0;
    int mlen = 0;
    int flen = 0;

    /*初始化ctx*/
    EVP_CIPHER_CTX_init(ctx);

    /*指定加密算法及key和iv(此处IV没有用)*/
    ret = EVP_EncryptInit_ex(ctx, EVP_aes_128_ecb(), NULL, input_gen_key, iv);
    if (ret != 1)
    {
        printf("EVP_EncryptInit_ex failed\n");
        EVP_CIPHER_CTX_free(ctx);
        return -1;
    }

    /*禁用padding功能*/
    //EVP_CIPHER_CTX_set_padding(ctx, 0);
    /*进行加密操作*/
    ret = EVP_EncryptUpdate(ctx, encrypt, &mlen, data, plaintext_len);
    if (ret != 1)
    {
        printf("EVP_EncryptUpdate failed\n");
        EVP_CIPHER_CTX_free(ctx);
        return -1;
    }
    /*结束加密操作*/
    ret = EVP_EncryptFinal_ex(ctx, encrypt + mlen, &flen);
    if (ret != 1)
    {
        printf("EVP_EncryptFinal_ex failed\n");
        return -1;
    }

    EVP_CIPHER_CTX_free(ctx);
    return mlen + flen;
}
//2.AES解密
int AES128_ecb_decrypt_zeropadding_evp(const unsigned char *userkey,int userkey_len, const unsigned char*in_ciphetext,int in_ciphetext_len, unsigned char*out_plaintext)
{
    if (    userkey_len<=0||
            (!(userkey_len == 16 ||userkey_len== 24 ||userkey_len == 32))
        )
    {
     
        return -1;
    }

    const unsigned char *data =in_ciphetext;
    unsigned char *decrypt =out_plaintext;
    const unsigned char *input_gen_key =userkey;
    if (NULL == decrypt || NULL == data || NULL == input_gen_key)
    {
        return -1;
    }

    unsigned char iv[EVP_MAX_IV_LENGTH] = {0}; ecb模式不需要iv偏移量
    memset((void *)iv, 'i', EVP_MAX_IV_LENGTH);
    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
    int ret = 0;
    int tlen = 0;
    int mlen = 0;
    int flen = 0;
    EVP_CIPHER_CTX_init(ctx);
    ret = EVP_DecryptInit_ex(ctx, EVP_aes_128_ecb(), NULL, input_gen_key, iv);
    if (ret != 1)
    {
        printf("EVP_DecryptInit_ex failed\n");
        EVP_CIPHER_CTX_free(ctx);
        return -1;
    }
    /*禁用padding功能*/
    //EVP_CIPHER_CTX_set_padding(ctx, 0);
    ret = EVP_DecryptUpdate(ctx, decrypt, &mlen, data, in_ciphetext_len);
    if (ret != 1)
    {
        printf("EVP_DecryptUpdate failed\n");
        EVP_CIPHER_CTX_free(ctx);
        return -1;
    }
    ret = EVP_DecryptFinal_ex(ctx, decrypt + mlen, &flen);
    if (ret != 1)
    {
        printf("EVP_DecryptFinal_ex failed\n");
    }
    EVP_CIPHER_CTX_free(ctx);
    return mlen + flen;
}

3.RSA

以RSA512 padding为例，包括秘钥生成（PKCS#1/PKCS#8）、秘钥加载、加密解密
在这里插入图片描述

#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>
/*********************
 * 
 * rsa的PKCS#1密钥头为‘-----BEGIN RSA PUBLIC KEY-----’,
 * rsa的PKCS#8密钥头为‘-----BEGIN PUBLIC KEY-----’
 * 对PKCS#1格式的密钥加载使用PEM_read_RSAPublicKey()函数
 * 对PKCS#8格式公钥的加载使用PEM_read_RSA_PUBKEY()函数
 * 
 * *********************/
int gen_pem_rsa512_pkcs1_pub_prvkey(const char *dir_path)
{
    if (NULL == dir_path)
    {
        return -1;
    }
    int ret = -1;
    RSA *rsa_key = RSA_new();
    BIGNUM *bignum_t = BN_new();
    int bits = 512;
    FILE *prv_key_file = NULL;
    FILE *pub_key_file = NULL;
    char prv_key_path[512] = {0};
    char pub_key_path[512] = {0};
    snprintf(prv_key_path, sizeof(prv_key_path) - 1, "%s/myprv_pkcs1.pem", dir_path);
    snprintf(pub_key_path, sizeof(pub_key_path) - 1, "%s/mypub_pkcs1.pem", dir_path);
    prv_key_file = fopen(prv_key_path, "wb");
    pub_key_file = fopen(pub_key_path, "wb");

    if (NULL == rsa_key || NULL == bignum_t || NULL == prv_key_file || NULL == pub_key_file)
    {
        goto clear_gen_pem_rsa512_pkcs1_pub_prvkey;
    }
    BN_set_word(bignum_t, 65537);
    if (1 != RSA_generate_key_ex(rsa_key, bits, bignum_t, NULL))
    {
        goto clear_gen_pem_rsa512_pkcs1_pub_prvkey;
    }
    if (1 != PEM_write_RSAPrivateKey(prv_key_file, rsa_key, NULL, NULL, 0, NULL, NULL))
    {
        goto clear_gen_pem_rsa512_pkcs1_pub_prvkey;
    }
    if (1 != PEM_write_RSAPublicKey(pub_key_file, rsa_key))
    {
        goto clear_gen_pem_rsa512_pkcs1_pub_prvkey;
    }
    ret = 0;
    goto clear_gen_pem_rsa512_pkcs1_pub_prvkey;
clear_gen_pem_rsa512_pkcs1_pub_prvkey:
    if (rsa_key)
        RSA_free(rsa_key);
    if (bignum_t)
        BN_free(bignum_t);
    if (prv_key_file)
        fclose(prv_key_file);
    if (pub_key_file)
        fclose(pub_key_file);
    return ret;
}

int gen_pem_rsa512_pkcs8_pub_prvKey(const char *dir_path)
{
    if (NULL == dir_path)
    {
        return -1;
    }
    int ret = -1;
    RSA *rsa_key = RSA_new();
    BIGNUM *bignum_t = BN_new();
    EVP_PKEY *evpkey = EVP_PKEY_new();
    int bits = 512;
    FILE *prv_key_file = NULL;
    FILE *pub_key_file = NULL;
    char prv_key_path[512] = {0};
    char pub_key_path[512] = {0};
    snprintf(prv_key_path, sizeof(prv_key_path) - 1, "%s/myprv_pkcs8.pem", dir_path);
    snprintf(pub_key_path, sizeof(pub_key_path) - 1, "%s/mypub_pkcs8.pem", dir_path);
    prv_key_file = fopen(prv_key_path, "wb");
    pub_key_file = fopen(pub_key_path, "wb");

    if (NULL == rsa_key || NULL == bignum_t || NULL == prv_key_file || NULL == pub_key_file || NULL == evpkey)
    {
        goto clear_gen_pem_rsa512_pkcs8_pub_prvKey;
    }
    BN_set_word(bignum_t, 65537);
    if (1 != RSA_generate_key_ex(rsa_key, bits, bignum_t, NULL))
    {
        goto clear_gen_pem_rsa512_pkcs8_pub_prvKey;
    }
    if (1 != EVP_PKEY_set1_RSA(evpkey, rsa_key))
    {
        goto clear_gen_pem_rsa512_pkcs8_pub_prvKey;
    }
    if (1 != PEM_write_PrivateKey(prv_key_file, evpkey, NULL, NULL, 0, NULL, NULL))
    {
        goto clear_gen_pem_rsa512_pkcs8_pub_prvKey;
    }
    if (1 != PEM_write_PUBKEY(pub_key_file, evpkey))
    {
        goto clear_gen_pem_rsa512_pkcs8_pub_prvKey;
    }
    ret = 0;
    goto clear_gen_pem_rsa512_pkcs8_pub_prvKey;

clear_gen_pem_rsa512_pkcs8_pub_prvKey:
    if (rsa_key)
        RSA_free(rsa_key);
    if (bignum_t)
        BN_free(bignum_t);
    if (evpkey)
        EVP_PKEY_free(evpkey);
    if (prv_key_file)
        fclose(prv_key_file);
    if (pub_key_file)
        fclose(pub_key_file);
    return ret;
}
int read_pubkey_pem_rsa512_pkcs1(const char *key_path, RSA **out_rsa)
{
    if (NULL == key_path)
    {
        return -1;
    }
    FILE *pf_key = NULL;
    pf_key = fopen(key_path, "rb");
    if (NULL == pf_key)
    {
        return -1;
    }
    *out_rsa = RSA_new();
    if (NULL == out_rsa)
    {
        fclose(pf_key);
        return -1;
    }
    *out_rsa = PEM_read_RSAPublicKey(pf_key, out_rsa, NULL, NULL);
    fclose(pf_key);
    return 0;
}

int read_pubkey_pem_rsa512_pkcs8(const char *key_path, RSA **out_rsa)
{
    if (NULL == key_path)
    {
        return -1;
    }
    FILE *pf_key = NULL;
    pf_key = fopen(key_path, "rb");
    if (NULL == pf_key)
    {
        return -1;
    }

    EVP_PKEY* rsa_evp=NULL;
    rsa_evp= PEM_read_PUBKEY(pf_key, &rsa_evp, NULL, NULL);
    *out_rsa = EVP_PKEY_get1_RSA(rsa_evp);
    //RSA_print_fp(stdout, *out_rsa, 0);
    EVP_PKEY_free(rsa_evp);
    fclose(pf_key);
    return 0;
}
int read_prvkey_pem_rsa512_pkcs1(const char *key_path, RSA **out_rsa)
{
    if (NULL == key_path)
    {
        return -1;
    }
    FILE *pf_key = NULL;
    pf_key = fopen(key_path, "rb");
    if (NULL == pf_key)
    {
        return -1;
    }
    *out_rsa = RSA_new();
    if (NULL == out_rsa)
    {
        fclose(pf_key);
        return -1;
    }
    *out_rsa = PEM_read_RSAPrivateKey(pf_key, out_rsa, NULL, NULL);
    //RSA_print_fp(stdout, *out_rsa, 0);
    fclose(pf_key);
    return 0;
}
int read_prvkey_pem_rsa512_pkcs8(const char *key_path, RSA **out_rsa)
{
    if (NULL == key_path)
    {
        return -1;
    }
    FILE *pf_key = NULL;
    pf_key = fopen(key_path, "rb");
    if (NULL == pf_key)
    {
        return -1;
    }

    EVP_PKEY *rsa_evp=NULL;
    rsa_evp= PEM_read_PrivateKey(pf_key, &rsa_evp, NULL, NULL);
    *out_rsa = EVP_PKEY_get1_RSA(rsa_evp);
    //RSA_print_fp(stdout, *out_rsa, 0);
    EVP_PKEY_free(rsa_evp);
    fclose(pf_key);
    return 0;
}

int pub_encrypt_rsa512_pkcs1_padding(unsigned char *in_data, size_t input_len, unsigned char *out_data, size_t *out_len, RSA *rsa_key)
{
    size_t total_len=0;
    size_t loop=input_len/64;
    for(int i=0;i<loop;i++)
    {
        size_t len=0;
        len=RSA_public_encrypt(64,(in_data+i*64), out_data+total_len, rsa_key, RSA_PKCS1_PADDING);
        total_len+=len;
    }
    size_t final_len=0;
    final_len=RSA_public_encrypt(input_len%64,in_data+loop*64, out_data+total_len, rsa_key, RSA_PKCS1_PADDING);
    total_len=total_len+final_len;
    *out_len=total_len;

    return 0;
}

int pub_decrypt_rsa512_pkcs1_padding(unsigned char *in_data, size_t input_len, unsigned char *out_data, size_t *out_len, RSA *rsa_key)
{
    //RSA_print_fp(stdout, rsa_key, 0);
    size_t total_len=0;
    size_t loop=input_len/64;
    for(int i=0;i<loop;i++)
    {
        size_t len=0;
        len=RSA_public_decrypt(64,(in_data+i*64), out_data+total_len, rsa_key, RSA_PKCS1_PADDING);
        total_len+=len;
    }
    *out_len=total_len;
    return 0;
}

int prv_encrypt_rsa512_pkcs1_padding(unsigned char *in_data, size_t input_len, unsigned char *out_data, size_t *out_len, RSA *rsa_key)
{
    size_t total_len=0;
    size_t loop=input_len/64;
    for(int i=0;i<loop;i++)
    {
        size_t len=0;
        len=RSA_private_encrypt(64,(in_data+i*64), out_data+total_len, rsa_key, RSA_PKCS1_PADDING);
        total_len+=len;
    }
    size_t final_len=0;
    final_len=RSA_private_encrypt(input_len%64,in_data+loop*64, out_data+total_len, rsa_key, RSA_PKCS1_PADDING);
    total_len=total_len+final_len;
    *out_len=total_len;
    return 0;
}
int prv_decrypt_rsa512_pkcs1_padding(unsigned char *in_data, size_t input_len, unsigned char *out_data, size_t *out_len, RSA *rsa_key)
{

    //RSA_print_fp(stdout, rsa_key, 0);
    size_t total_len=0;
    size_t loop=input_len/64;
    for(int i=0;i<loop;i++)
    {
        size_t len=0;
        len=RSA_private_decrypt(64,(in_data+i*64), out_data+total_len, rsa_key, RSA_PKCS1_PADDING);
        total_len+=len;
    }
    *out_len=total_len;
    return 0;
}
openssl 计算文件MD5
sevendemage的博客
03-09 421
【代码】openssl 计算文件MD5。
基于openssl的MD5实现
08-30
基于openssl和ndk，实现c++版MD5及位运算生成一个32位的字符串；该模块是一个集成了openssl静态库的资源，下载后可直接运行。
Openssl-MD5
Sunspider107的专栏
03-26 4894
MD5是最常用的一个信息摘要算法，虽然现在慢慢被SHA1算法替代，但还是应用广泛。 MD5的计算结果是16个字节。 int MD5_Init(MD5_CTX *c); 初始化MD5 Context参数； c: MD5 context; 返回值： 1： 成功， 0： 失败； int MD5_Update(MD5_CTX *c, const void *data, si
初识openssl库之计算文件的md5值
weixin_44735156的博客
06-18 720
openssl是密码学一个很重要的库，调用openssl库进行编程可以大大简化代码的复杂度，今天要介绍的是使用openssl库计算文件的md5值，代码如下： #include <openssl/md5.h> #pragma comment(lib, "libeay32.lib") #pragma comment(lib, "ssleay32.lib") void main() { int i,blocklength; long int filelength; unsigned char
openssl的Ｍd5计算笔记
固本培元的专栏
03-24 1171
#include #include #include #include #include #include using std::cout ; using std::endl ; std::string downgadget::Downloader_c::FileDigest(const std::string &file) { FILE *fd=fopen(file.c_str(
openssl计算md5
auccy的博客
12-25 549
openssl计算md5
使用OpenSSL实现RSA、AES、MD5算法-VS2017-C++.rar
08-02
在这个项目中，使用OpenSSL库，开发者已经实现了RSA、AES和MD5这三种重要的加密算法，并且在Microsoft Visual Studio 2017环境下用C++语言编写。 1. **RSA算法**：RSA是一种非对称加密算法，由Ron Rivest、Adi ...
报文响应+获取会话公钥（SessionKey）+RAS加密+AES加密+MD5加密
最新发布
04-23
1、接入申请：在接入单位应先向税务局申请，经过审批备案后，将生成的唯一的接入方编号(appCode)和通过使用OpenSSL生成的一对私钥和公钥。...再对（requestData密文+会话公钥明文）进行MD5加密作为sign值。
openssl 图形 md5 des aes
09-12
在您提供的资料中，提到了"openssl 图形 md5 des aes"，这些关键词代表了OpenSSL在加密领域的几个关键概念。 首先，MD5（Message-Digest Algorithm 5）是一种广泛使用的哈希函数，它能将任意长度的数据转化为固定...
深入理解OpenSSL中的AES与RSA加密技术
5. 哈希算法支持：除了AES和RSA，OpenSSL还支持MD5、SHA等哈希算法，用于数据完整性验证。 6. API接口：OpenSSL库提供了大量的API接口，支持C和C++等编程语言，使得开发者可以方便地在程序中调用加密功能。 综上所...
Qt利用OpenSSl实现RSA数字签名
07-05
2. 计算待签名数据的哈希值，这里可以使用SHA256等：`EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();`，`EVP_DigestInit_ex(md_ctx, EVP_sha256(), NULL);`，`EVP_DigestUpdate(md_ctx, data, data_len);`，`unsigned char...
【OpenSSL】MD5:计算字符串和文件的哈希值
梦想博客
09-03 4242
说明 测试平台系统：Ubuntu18.04 X86_64 测试语言：C++11 测试编译器：GCCversion 7.5.0 测试内容：字符串和文件的MD5哈希值计算方法 一、MD5简介 关于16位和32位MD5值： MD5得到的是一个16字节的哈希值(或称散列值)，每个字节格式化位16进制(0x**)，取数值部分的两个字符，连起来得到一个32个字符的字符串。这就是所说的32位MD5值。16位MD5值就是取的32位MD5值的中间段，即第9至24位(如果从0开始作为第一位，则是第8至23位...
openssl md5算法 —— Linux下（字符串加密、文件加密）
杰儿__er 的博客
07-25 8858
理解openssl md5: OpenSSL 是一个安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及SSL协议，并提供丰富的应用程序供测试或其它目的使用。 OpenSSL被曝出现严重安全漏洞后，发现多数通过SSL协议加密的网站使用名为OpenSSL的开源软件包。OpenSSL漏洞不仅影响以https开头的网站，黑客还可利用此漏洞直接对个人电脑发起“心脏出血”（Heartb...
linux openssl md5,使用OpenSSL的MD5计算功能
weixin_36484898的博客
05-26 201
使用OpenSSL的MD5计算功能：#include#include#include#includeusing namespace std;int main(){FILE *fd=fopen("test","r");MD5_CTX c;unsigned char md5[17]={0};if(fd == NULL){cout << "open failed" << endl...
OpenSSL 之 MD5
weixin_34087503的博客
08-15 430
学习一下，OpenSSL，使用OpenSSL有两种方式：命令执行和库调用。对于我来说，学习是为了写代码。直奔库调用了。先从最简单的MD5入手吧！ OpenSSL官网上找到MD5简介只有函数的声明，没有相对明确的解释：#include<openssl/md5.h> unsignedchar*MD5(constunsignedchar*d,uns...
如何利用openssl来计算一个文件的MD5值？
热门推荐
认知 行动 坚持
01-09 1万+
openssl环境的配置， 我就不再说了， 可以参考之前的的博文。 前面， 我们计算过字符串的md5值， 在本文中， 我们来讨论一个文件的md5值， 废话少说， 直接给大家代码， 上点干货： #include #include // 如果你直接拷贝我的程序运行， 那注定找不到md5.h #pragma comment(lib, "libeay32.lib") #pragma comment(
openssl md5
weixin_34162401的博客
03-14 612
关于 16位和32位 md5得到的是一个16字节的散列值 每个字节用16进制(0x**)格式成两个字符,连起来得到一个32个字符的串这就是所说的32位。16位就是取的32位的中间段md5(aabbccdd) 32位 = bf3b2290e229da2ba272a81c602ea88dmd5(aabbccdd) 16位 = e229da2ba272a81c使用...
openssl中的MD5加密
大道之行，始于足下
07-06 2500
openssl中的MD5加密
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值