rsa des加密解密,与c++混合使用. c++ 篇

最新推荐文章于 2024-05-12 23:09:42 发布
最新推荐文章于 2024-05-12 23:09:42 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： rsa des
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012850999/article/details/89175709
版权
rsa 同时被 2 个专栏收录
2 篇文章 0 订阅
订阅专栏
des
2 篇文章 0 订阅
订阅专栏

c++ 下des的运用

通过openssl 进行加密解密

myDes.h

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <openssl/ssl.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>
#include <openssl/bio.h>
#include <openssl/des.h>
#include <iostream>
#include <vector>
using namespace std;

typedef enum{
    CBC=1,
}desmode_t;

typedef enum{
   PAD_PKCS5=1,
}mypadmode_t;


class my_Des
{
public:
    my_Des(std::string userkey,desmode_t userdesmode=CBC, std::string IV=NULL,mypadmode_t padmode=PAD_PKCS5);
    std::string decrypt(const std::string &cipherText,mypadmode_t mypadmode);
    std::string decrypt(const std::string &cipherText);
    std::string des_cbc_pkcs5_decrypt(char *cipherText, int datalen, const std::string &key);
    std::string des_cbc_pkcs5_encrypt(char *cipherText, int datalen, const std::string &key);
    std::string des_cbc_pkcs5_encrypt(const std::string &clearText, const std::string &key);
private:
    std::string padFUN(const std::string &cipherText,mypadmode_t mypadmode);
    std::string des_cbc_pkcs5_decrypt(const std::string &cipherText, const std::string &key);

private:
   mypadmode_t mypadmode;
   desmode_t desmode;
   std::string key;
   std::string my_iv;
};

myDes.cpp

#include "myDes.h"

my_Des::my_Des(std::string userkey,desmode_t userdesmode, std::string IV,mypadmode_t padmode)
{
   key=userkey;
   desmode=userdesmode;
   mypadmode=padmode;
   my_iv=IV;
}

//解密 cbc pkcs5padding 自己实现  //zeropadding / pkcs7padding 跟 pkcs5padding是一样的
std::string my_Des::des_cbc_pkcs5_decrypt(const std::string &cipherText, const std::string &key)
{

   // static unsigned char cbc_iv[8] = {'m', 'H', 'A', 'x', 's', 'L', 'Y', 'z'};
    static unsigned char cbc_iv[8];
    memcpy(cbc_iv,my_iv.data(),sizeof (cbc_iv));
    //初始化IV向量
    std::string clearText;
    DES_cblock keyEncrypt, ivec;
    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);   //设置密钥，且不检测密钥奇偶性
    memcpy(ivec, cbc_iv, sizeof(cbc_iv));

    // 循环解密，每8字节一次
    const_DES_cblock inputText;
    DES_cblock outputText;
    std::vector<unsigned char> vecCleartext;
    unsigned char tmp[8];
    for (unsigned int i = 0; i < cipherText.length() / 8; i++)
    {
        memcpy(inputText, cipherText.c_str() + i * 8, 8);
        DES_ncbc_encrypt(inputText, outputText, 8, &keySchedule, &ivec, DES_DECRYPT);  //解密
        memcpy(tmp, outputText, 8);
        for (int j = 0; j < 8; j++)
            vecCleartext.push_back(tmp[j]);
        //重置ivec
        //memcpy(ivec, outputText, 8);  //解密过程不需要用前一块的结果作为下一块的IV
    }

    unsigned int mod=clearText.length() % 8;
    if (mod != 0)
    {
        unsigned int tmp1 = clearText.length() / 8 * 8;
        unsigned int tmp2 = clearText.length() - tmp1;
        memset(inputText,0, static_cast<size_t>(tmp2));
        memcpy(inputText, cipherText.c_str() + tmp1, tmp2);
        DES_ncbc_encrypt(inputText, outputText, static_cast<long>(tmp2), &keySchedule, &ivec, DES_DECRYPT);  //解密
        memcpy(tmp, outputText, tmp2);

        for (unsigned int j = 0; j < mod; j++)
            vecCleartext.push_back(tmp[j]);
    }
    clearText.clear();
    clearText.assign(vecCleartext.begin(),vecCleartext.end());

    // 返回值去除末尾的填充值
    unsigned int retlen=clearText.length();
    unsigned int modlen=static_cast<unsigned int>(clearText[retlen-1]);

   // for(char i=0;i<retlen;i++)
     //   clearText.pop_back();
   // clearText.erase(retlen-modlen,retlen);

    return clearText;
}
//这里有一个char * 和 string 两个版本， string 为网上大神的版本，char * 为自己改进的，因为字符串中遇到'\0'就截止。但是加密字串难免回产生'\0' 所以 以char * 处理更好
std::string my_Des::des_cbc_pkcs5_encrypt(char *cipherText, int datalen, const std::string &key)
{
   // static unsigned char cbc_iv[8] = {'j', 'k', 't', '1', '2', '3', '4', '5'};
    static unsigned char cbc_iv[8];
    memcpy(cbc_iv,my_iv.data(),sizeof (cbc_iv));
    //初始化IV向量
    std::string strCipherText;
    DES_cblock keyEncrypt, ivec;
    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);   //设置密钥，且不检测密钥奇偶性

    memcpy(ivec, cbc_iv, sizeof(cbc_iv));

     // 循环加密，每8字节一次
    const_DES_cblock inputText;
    DES_cblock outputText;
    std::vector<unsigned char> vecCiphertext;
    unsigned char tmp[8];

    for (int i = 0; i < datalen / 8; i++)
    {
        memcpy(inputText,cipherText + i * 8, 8);
        DES_ncbc_encrypt(inputText, outputText, 8, &keySchedule, &ivec, DES_ENCRYPT);  //加密
        memcpy(tmp, outputText, 8);

        for (int j = 0; j < 8; j++)
            vecCiphertext.push_back(tmp[j]);

        //重置ivec
        memcpy(ivec, outputText, 8);
    }

    if (datalen% 8 != 0)
    {
        int tmp1 =datalen / 8 * 8;
        int tmp2 = datalen - tmp1;
        memset(inputText,(8-tmp2), 8);
        memcpy(inputText, cipherText + tmp1, tmp2);
    }
    else
    {
        memset(inputText,8, 8);
    }
    // 加密函数
    DES_ncbc_encrypt(inputText, outputText, 8, &keySchedule, &ivec, DES_ENCRYPT);  //加密
    memcpy(tmp, outputText, 8);

    for (int j = 0; j < 8; j++)
        vecCiphertext.push_back(tmp[j]);

    strCipherText.clear();
    strCipherText.assign(vecCiphertext.begin(), vecCiphertext.end());
    return strCipherText;
}


std::string my_Des::des_cbc_pkcs5_encrypt(const std::string &clearText, const std::string &key)
{
    static unsigned char cbc_iv[8];
    memcpy(cbc_iv,my_iv.data(),sizeof (cbc_iv));
    //初始化IV向量
    std::string strCipherText;
    DES_cblock keyEncrypt, ivec;
    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);   //设置密钥，且不检测密钥奇偶性

    memcpy(ivec, cbc_iv, sizeof(cbc_iv));

     // 循环加密，每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_ncbc_encrypt(inputText, outputText, 8, &keySchedule, &ivec, DES_ENCRYPT);  //加密
        memcpy(tmp, outputText, 8);

        for (int j = 0; j < 8; j++)
            vecCiphertext.push_back(tmp[j]);

        //重置ivec
        memcpy(ivec, outputText, 8);
    }

    if (clearText.length() % 8 != 0)
    {
        int tmp1 = clearText.length() / 8 * 8;
        int tmp2 = clearText.length() - tmp1;
        memset(inputText,(8-tmp2), 8);
        memcpy(inputText, clearText.c_str() + tmp1, tmp2);
    }
    else
    {
        memset(inputText,8, 8);
    }
    // 加密函数
    DES_ncbc_encrypt(inputText, outputText, 8, &keySchedule, &ivec, DES_ENCRYPT);  //加密
    memcpy(tmp, outputText, 8);

    for (int j = 0; j < 8; j++)
        vecCiphertext.push_back(tmp[j]);

    strCipherText.clear();
    strCipherText.assign(vecCiphertext.begin(), vecCiphertext.end());
    return strCipherText;
}

std::string my_Des::des_cbc_pkcs5_decrypt(char *cipherText, int datalen, const std::string &key)
{

   // static unsigned char cbc_iv[8] = {'m', 'H', 'A', 'x', 's', 'L', 'Y', 'z'};
    static unsigned char cbc_iv[8];
    memcpy(cbc_iv,my_iv.data(),sizeof (cbc_iv));
    //初始化IV向量
    std::string clearText;
    DES_cblock keyEncrypt, ivec;
    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);   //设置密钥，且不检测密钥奇偶性

    memcpy(ivec, cbc_iv, sizeof(cbc_iv));

    // 循环解密，每8字节一次
    const_DES_cblock inputText;
    DES_cblock outputText;
    std::vector<unsigned char> vecCleartext;
    unsigned char tmp[8];
    for (unsigned int i = 0; i < (datalen)/ 8; i++)
    {
        memcpy(inputText, cipherText + i * 8, 8);
        DES_ncbc_encrypt(inputText, outputText, 8, &keySchedule, &ivec, DES_DECRYPT);  //解密
        memcpy(tmp, outputText, 8);
        for (int j = 0; j < 8; j++)
            vecCleartext.push_back(tmp[j]);
        //重置ivec
        //memcpy(ivec, outputText, 8);  //解密过程不需要用前一块的结果作为下一块的IV
    }

    unsigned int mod=(datalen) % 8;
    if (mod != 0)
    {
        unsigned int tmp1 = clearText.length() / 8 * 8;
        unsigned int tmp2 = clearText.length() - tmp1;
        memset(inputText,0, static_cast<size_t>(tmp2));
        memcpy(inputText, cipherText + tmp1, tmp2);
        DES_ncbc_encrypt(inputText, outputText, static_cast<long>(tmp2), &keySchedule, &ivec, DES_DECRYPT);  //解密
        memcpy(tmp, outputText, tmp2);

        for (unsigned int j = 0; j < mod; j++)
            vecCleartext.push_back(tmp[j]);
    }
    clearText.clear();
    clearText.assign(vecCleartext.begin(),vecCleartext.end());

    // 返回值去除末尾的填充值
    unsigned int retlen=clearText.length();
    unsigned int modlen=static_cast<unsigned int>(clearText[retlen-1]);
   if(modlen<=8&&modlen>0)
   clearText.erase(retlen-modlen,retlen);

    return clearText;
}



std::string my_Des::decrypt(const std::string &cipherText,mypadmode_t mypadmode)
{
    switch (desmode) {
    case CBC:
        return padFUN(cipherText,mypadmode);

    }
    return  "";
}
std::string my_Des::decrypt(const std::string &cipherText)
{
    switch (desmode) {
    case CBC:
        return padFUN(cipherText,mypadmode);

    }
    return  "";
}

std::string my_Des::padFUN(const std::string &cipherText,mypadmode_t mypadmode)
{
    switch (mypadmode) {
    case PAD_PKCS5:
        return des_cbc_pkcs5_decrypt(cipherText,key);
    }
    return  "";
}

 rsa

#ifndef RSA_CLC_H
#define RSA_CLC_H

#include<stdio.h>
#include <fstream>
#include <iostream>
#include <string>
#include <QString>

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

//服务端公钥用于本地加密
const static char* server_pulicKey ="-----BEGIN RSA PUBLIC KEY-----\n"
"MIGJAoGBAKmV1KA9fjRrySfFbgozIDD0n19rL1pEUmM7wdho5qjl2w+wMlpxlqeO\n"
"YdbdMwtufbOekFQ4IcffORQfIynBpPeR12F5gQkC0sG1O8HkKdiDS88gcpVVKX1D\n"
"O77gW9p45Na5ZvajSYMo+4SIQeGWn5y8rCUfNfi3Vh/HeterMiHNAgMBAAE=\n"
"-----END RSA PUBLIC KEY-----";

//客户端私钥用于服务端消息解码
const static char* clientPrivateKey ='-----BEGIN RSA PRIVATE KEY-----\n"
        "MIICYQIBAAKBgQCSgVkZKHBVA/Fwdio4N2H1tjXTuwUW1ep9Vdzb3alBGJY575i2\n"
        "N4mVxjvgCTyZjnj0s9QCA+I7mvFpKShTglHHdfEOvO+7T/p246Iq9VGfwstYfdTE\n"
        "CNMiMzX1HdEfcZccEe65IJc8OfeoDHVPHvaGkxfU00kJA/rcdswJOn9hvQIDAQAB\n"
        "AoGAMRs4ES2z0Vs7/1UsO6GcrS6BBlJGl2vmaFJycCPxSoeCOzMrPdCJxnEmuqZ9\n"
        "8H6H3oW0R2Sj3RTHXFdWFi+Xg9PYOEiNg2/HrcvPBG0+/abreDpvIV3Xj6eqEK8i\n"
        "WCS0aQqfehW+QIfITdU4jRI1XjDdbHDAHY+7/ZsKdtyq0cECRQC4aWst/K7N0GMZ\n"
        "DTCx1KJNGTzII8fzPiCvkEaT/22UY/GH9muDVyXDgThwez3c+Wtax+TmuScOe06R\n"
        "0J86bj8X/kIATQI9AMtg1TGuLSlr58PuSfZLe7psBsv1UBfaXde43mtte1jaVpyF\n"
        "6i9Tprw4S+Y7hUqfUxbE6QL6anEpIyQfMQJFALRrPtcRHhxyQmHiC8AP3nI7vMG6\n"
        "cAdEw0nAh6yH/DdvyIBS0EEBZArwQ72YdZ/ZzfRVGVe50cJTVT1HtGDAN65LrVsJ\n"
        "AjxmhoQzLUkbDoih3yht/xN6oSaz/xDHVY/lRg7qPSDnY/oxodiyzwrI6+BnSi4h\n"
        "tjveyJlmpPKv5TsP5KECRQCnQ4/U07F91Vr8X33x1LlT4h66SRZm+PRodaNw0gIS\n"
        "Nps6pDX5CrA0FnLypO878JDTL0q/0mUx5otsfJo3IGF0jCaywQ==\n"
        "-----END RSA PRIVATE KEY-----\n";


using namespace std;
class Rsa_CLC
{
public:
    Rsa_CLC();
    QString rcvFromServer(string data);
    std::string sendToServer(QString data);
private:
    std::string Server_publicKey_jiami(string data);
    std::string Client_privateKey_jiemi(string data);
};

#endif // RSA_CLC_H

Rsa_CLC.cpp

#include "Rsa_CLC.h"

Rsa_CLC::Rsa_CLC()
{

}
std::string Rsa_CLC::Client_privateKey_jiemi(string data)
{
    OpenSSL_add_all_algorithms();
    BIO* bp = BIO_new( BIO_s_mem() );
    BIO_puts(bp, clientPrivateKey);

    RSA* rsaK;
    rsaK = PEM_read_bio_RSAPrivateKey( bp, NULL, NULL, NULL );
    if (NULL == rsaK) {
        perror("read key file fail!");
    }else{
        //printf("read success!\n");
    }

    int nLen = RSA_size(rsaK);
    char *pEncode = new char[nLen + 1];
    int ret = RSA_private_decrypt(data.length(),(const unsigned char*)data.c_str(),(unsigned char *)pEncode,rsaK,RSA_PKCS1_PADDING);
    std::string strRet;
    if (ret >= 0) {
        strRet = std::string(pEncode, ret);
    }

    delete[] pEncode;
    CRYPTO_cleanup_all_ex_data();
    BIO_free_all( bp );
    RSA_free(rsaK);
    return strRet;
}


std::string Rsa_CLC::Server_publicKey_jiami(string data)
{
    OpenSSL_add_all_algorithms();
    BIO* bp = BIO_new( BIO_s_mem() );
    BIO_puts(bp,server_pulicKey);
    RSA* rsaK = PEM_read_bio_RSAPublicKey( bp,NULL,NULL,NULL);
    if (NULL == rsaK) {
        return "";
    }
    int nLen = RSA_size(rsaK);
    char *pEncode = new char[nLen + 1];
    int ret = RSA_public_encrypt(data.length(),(const unsigned char*)data.c_str(),
        (unsigned char *)pEncode,rsaK,RSA_PKCS1_PADDING);
    std::string strRet;
    if (ret >= 0) {
        strRet = std::string(pEncode, ret);
    }
    delete[] pEncode;
    CRYPTO_cleanup_all_ex_data();
    BIO_free_all( bp );
    RSA_free(rsaK);
    return strRet;
}



QString Rsa_CLC::rcvFromServer(string data)
{
   std::string rcvstr=Client_privateKey_jiemi(data);

   QString ret=QString::fromStdString(rcvstr);
  return ret;
}
std::string Rsa_CLC::sendToServer(QString data)
{
    std::string str=data.toStdString();
    std::string sendstr=Server_publicKey_jiami(str);

    return  sendstr;
}

 

Jehovah_W
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于C++的DES与RSA演示程序（附带源码）
03-15
基于C++的DES与RSA演示程序（附带源码） 1. 程序由Visual Studio 2008编写，针对RSA那个程序，需先安装Visual Studio 2008运行库“vcredist_x86_vs2008_sp1.exe”（已经附带），否 则程序将无法正常运行。 2. 程序运行时，将在目录下生成1~2个临时文件用于数据交换，请勿对这些文件进行任何操作，否则程序可能无法运行。 3. RSA.exe为RSA的主程序。 4. 要重新编译程序需要Visual Studio 2008或更高版本，否则只认浏览、借鉴源代码，无法直接重新编译。
基于DES和RSA混合加密的通信系统（C++）
05-19
可能的流程是，首先使用RSA进行公钥和私钥的生成，然后通过RSA公钥交换DES的会话密钥，之后用DES加密实际的通信数据，最后接收方使用私钥解密会话密钥，再用该密钥解密DES加密的数据。 此外，C++作为编程语言，提供...
des rsa加密解密,与c++混合使用. 第一步分python
u012850999的博客
04-10 597
一次偶然的机会需要开发服务器和QT版本的客户端，在其中需要用到常见的加密解密算法，其中纠结了许久，最后项目做完后做出一些总结。 python 下使用Des库非常的简单 1.Des加密解密 from pyDes import * import binascii ret="hello world !" #需要加密的字符串 secret_key = "12345678" #密钥 iv...
2024年C C++最全DES加密解密算法（简单、易懂、超级详细）_des算法，2024年最新C C++程序员必经的实践之路
最新发布
2401_84976318的博客
05-12 920
cout
DES加密算法、RSA加密算法
wrypot的博客
05-11 848
7、k1：将56位密钥进行初始置换，然后前28位为C,后28位为D0，都进行循环左移以为，得到C1 D1，通过置换将56位置换后为48位形成k1。6、E运算，将32位扩增到48位，比如 0101 0011 扩增后为 1 0101 01 0011 0。5、F运算：先将R0进行E运算扩增到48位，再跟k1进行异或运算，然后S盒，P盒。同理，上面的加密过程执行16轮，就是DES加密全过程，上面只是一轮加密的过程。1、将明文和密钥转化为ASCII码，明文64位bit，密钥56位。
DES和RSA数据加密
zjbkzj的博客
01-20 2136
数据加密处理好懒呀，简单记录下吧项目开饭中(做个干饭人)对于信息加密的方式有很多种使用crypto-js 做DES加解密jsencrypt 做RSA加密解密字符串 好懒呀，简单记录下吧 在如今互联网时代 各种数据信息铺天盖地，我们该如何保证自己的信息安全呢？ 首先用户自己不外露自己的重要信息 用户使用的各种软件也要对用户重要信息进行加密保护处理 项目开饭中(做个干饭人)对于信息加密的方式有很多种 简单记录下我使用的两种情况 在处理用户注册信息时，需要做加密处理 使用DES和RSA做数据加密；
C++ Aes与Rsa加密算法使用
xunmeng2002的专栏
08-06 994
AesTest.h #ifndef AES_TEST_H #define AES_TEST_H #include <openssl/aes.h> bool AesEncrypt(unsigned char* in, unsigned char* out, size_t len, const unsigned char* key, size_t keyLen = 32); bool AesDecrypt(unsigned char* in, unsigned char* out, si
一种DES和RSA混合加密的通信系统
农夫果园好好喝的博客
02-25 7535
0 引言 随着通信技术的不断发展和人们需求的增加，使得通信安全问题越来越受到广泛的关注，而创造敏感信息的安全传输环境一直是学术界重要的研究内容。例如，行鸿彦[[i]]等人设计了一种特殊的保密通信系统，在使用脉冲同步技术的基础上，结合压缩检测技术，增强了通信系统的安全性；骆钊[[ii]]等人提供了一套基于IEC62351通信协议的身份认证机制，并提供了通过SM双密码系统安全传输目标通信消息的方案，有效解决了变电站通信报文的数据安全性和实时性要求；冷飞[[iii]]等人指出这种RSA融合高...
Stringencode.rar_加密解密_C++_Builder_
08-11
在给定的“Stringencode.rar”压缩包中，我们关注的是C++ Builder平台下的字符串加密解密技术。C++ Builder是一款强大的开发环境，支持C++编程语言，尤其适合创建桌面应用程序。 首先，让我们探讨一下字符串加密的...
纯C++简易加密库，含Aes、Des、Rsa、MD5加密解密
02-27
对于需要快速实现数据加密解密功能的开发者来说，这是一个非常实用的资源。 总的来说，这个C++加密库涵盖了对称加密（AES、DES）和非对称加密（RSA），以及哈希算法（MD5），覆盖了信息安全中的基础需求。开发者...
locFile.zip_加密解密_C++_
08-12
标题“locFile.zip_加密解密_C++_”表明我们将关注一个使用C++编程语言处理的加密解密任务，具体到操作的对象是LOC文件，这种文件通常用于存储软件的本地化信息，如多语言支持的数据。在C++中，我们可以利用不同的库...
OpenSSL RSA AES加密解密C++源码
08-30
OpenSSL RSA AES加密解密C++源码
简单的加密解密算法，混合多种加密操作
02-03
自己编写的一种简单加密解密算法，通过把多种算法进行组合。特点是同个字符串不同时间加密结果不同，混合了多种加密方式，很难用统计的方式对密文进行破解。 加密过程： 1）扩展字符串 2)字符串移位 3)单字符替换 4)加入密钥进行异或，密钥字符串自定义 5)整个字符串循环移位
EEncryptionAlx.rar_加密解密_C++_
08-11
总的来说，"EEncryptionAlx.rar"提供的加密解密C++实例集是一个极好的学习资源，涵盖了多种加密方法，有助于提升对信息安全的理解和实战能力。通过学习和实践这些代码，你可以更深入地掌握如何在C++环境中应用加密...
RSA与AES混合加密算法的实现
http://kingim.cn/
05-07 8781
RSA与AES加密算法所产生的密钥数不一样，它们是如何进行加密的呢？ 接收方生成RSA密钥对，将其中的RSA公钥传递给发送方(接收方与发送方建立连接是需要认证的，SSL/TLS协议可以确保RSA公钥的安全完整)，然后用RSA公钥对AES密钥进行加密，加密后的结果传递给接收方，接收方用RSA私钥解密后，得到AES密钥，最后使用AES密钥解密，从而达到安全互通数据的目的。(如下图所示) 工
RSA加密解密-java
JcMR_Li的博客
02-22 864
RSA加密解密 maven依赖： &amp;lt;!-- RSA --&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.apache.axis&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;axis&amp;lt;/artifactId&amp;gt
des cbc c语言,C语言openssl库DES-CBC解密
weixin_34191434的博客
05-24 572
#include #include #include #include #include int des_encrypt(const char *clearText, unsigned char **cipherText, const char *key){DES_cblock keyEncrypt;DES_key_schedule keySchedule;const_DES_cblock inp...
RSA密码的C++实现
-CQ-的专栏
10-25 3506
//RSA密码 /*理解算法最重要，最好自己动手实现试试看，可以使用MFC写一个简单的交互界面*/ #include #include #include #include using namespace std; //RSA算法所需参数 typedef struct RSA_PARAM_Tag { unsigned __int64 p, q; //两个素数，不参与加密
DES加解密类
g84369的博客
03-31 438
算是第一个开发任务了，C++写一个DES 加解密类用来解密序列号，加解密适用ecb/cbc模式，最好调用OpenSSL库。DES是一种对称分组加密算法，只是用它加解密的话，我认为不需要理解得特别深刻，只要知道以下几点就好了：（1）分组：每八字节为一组，利用密钥进行加密，最后将密文拼接；（2）对称：加解密使用同一种算法，在openssl中使用的是同一个函数，只是参数不同；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值