OpenSSL 实现RSA AES加解密

最新推荐文章于 2024-07-24 20:25:39 发布
最新推荐文章于 2024-07-24 20:25:39 发布
阅读量1w 收藏 9
点赞数
文章标签： 加密 file 解密 算法 class null

OpenSSL初学总结

2008年12月29日星期一

最近一段时间看些关于OpenSSL加密函数的使用，现将一些使用总结如下：

1、  OpenSSL简介：

openssl是一个功能丰富且自包含的开源安全工具箱。它提供的主要功能有：SSL协议实现(包括SSLv2、SSLv3和TLSv1)、大量软算法(对称/非对称/摘要)、大数运算、非对称算法密钥生成、ASN.1编解码库、证书请求(PKCS10)编解码、数字证书编解码、CRL编解码、OCSP协议、数字证书验证、PKCS7标准实现和PKCS12个人数字证书格式实现等功能。

openssl采用C语言作为开发语言，这使得它具有优秀的跨平台性能。openssl支持Linux、UNIX、windows、Mac等平台。

2、  OpenSSL加密算法——AES加密流程：

（1）       加密

设置加密密钥：AES_set_encrypt_key

加密：AES_encrypt

（2）       减密

设置减密密钥：AES_set_decrypt_key

减密：AES_decrypt

3、  OpenSSL加密算法——RSA加密流程：

（1）       公钥加密，私钥减密

初始化RSA加密：RSA_new

设置密钥：RSA_general_key（自动生成）和BN_bin2bn（加载）

验证密钥：RSA_check_key

指定Padding和要加密的长度（通常选择RSA_PKCS1_PADDING）

加密：RSA_public_encrypt

减密：RSA_private_decrypt

释放RSA：RSA_free

（2）       私钥加密，公钥减密

初始化RSA加密：RSA_new

设置密钥：RSA_general_key（自动生成）和BN_bin2bn（加载）

验证密钥：RSA_check_key

指定Padding和要加密的长度（通常选择RSA_PKCS1_PADDING）

加密：RSA_private_encrypt

减密：RSA_public_decrypt

释放RSA：RSA_free

4、  对上述两种算法接口的简单封装：

类CMyOpenSSL头文件：

//------------------------------------------------------------------------------------------

/*

   类名：CMyOpenSSL

   功能：实现了对OpenSSL中RSA和AES加密的基本操作的简单封装

*/

 

#pragmaonce

 

#include<openssl/rsa.h>

#include<openssl/sha.h>

#include<openssl/aes.h>

#pragmacomment(lib,"libeay32.lib")

#include"define.h"

 

 

#define OPENSSL_RSA_BUFFBLOCK 128           // RSA缓冲区块

#define OPENSSL_AES_BUFFBLOCK 16            // AES缓冲区块

 

 

enum RSA_TYPE                               // 加密类型

{

     PUBENCRYPT,

     PRIENCRYPT

};

 

enum PADDING                                // Padding类型

{

     RSA_NO,

     RSA_PKCS1,

     RSA_SSLV23,

//   RSA_X931,

     RSA_PKCS1_OAEP

};

 

 

constint RSA_bits = 1024;                  // RSA bits

constunsignedlong e = RSA_3;

 

constint AES_bits = 128;                   // AES bits

 

// class CMyOpenSSL //----

 

class CMyOpenSSL

{

public:

     CMyOpenSSL(void);

     ~CMyOpenSSL(void);

 

     ULONGLONG m_sourceFileLen;              // 原文件大小

     int m_len;                              // 加减密缓存大小

     virtualvoid GetSourceFileLen(ULONGLONG len);

 

// RSA Encrypt/Decrypt //----

public:

     void InitRSA();                         // 初始化RSA加密

     void FreeRSA();                         // 释放RSA加密

 

     void GenerateKey();                     // 自动生成密钥

     void GetEncryptKey(RSA_TYPE type);      // 根据加密类型，将外界导入的密钥生成RSA加密密钥

     void GetDecryptKey(RSA_TYPE type);      // 根据加密类型，将外界导入的密钥生成RSA减密密钥

     BOOL CheckKey();                        // 验证RSA密钥信息

 

     int RSAEncrypt(unsignedchar from[OPENSSL_RSA_BUFFBLOCK],unsignedchar to[OPENSSL_RSA_BUFFBLOCK],

         RSA_TYPE type);                     // RSA加密函数

     void RSADecrypt(unsignedchar from[OPENSSL_RSA_BUFFBLOCK],unsignedchar to[OPENSSL_RSA_BUFFBLOCK],

         RSA_TYPE type);                     // RSA减密函数

 

     void MyEncryptFile(LPCTSTR sourceFileName,LPCTSTR destFileName,RSA_TYPE type);

                                             // RSA文件加密函数

     void MyDecryptFile(LPCTSTR sourceFileName,LPCTSTR destFileName,RSA_TYPE type);

                                             // RSA文件减密函数

 

     int GetBuffLen(PADDING padding);        // 获取加减密缓冲区大小

 

private:

     RSA *m_rsa;                             // RSA密钥

     int m_padding;                          // RSA padding类型

     int m_nRetLen;                          // 加密返回的密文长度

     int m_nRet;                             // 返回值

//------------------------------------------------------------------------------------------

 

// AES Encrypt/Decrypt //----

public:

     void SetEncryptKey(unsignedchar *aes_key); // 设置AES加密密钥

     void SetDecryptKey(unsignedchar *aes_key); // 设置AES减密密钥

 

     void MyAESEncryptFile(LPCTSTR sourceFileName,LPCTSTR destFileName,unsignedchar *aes_key);

                                                 // AES文件加密函数

     void MyAESDecryptFile(LPCTSTR sourceFileName,LPCTSTR destFileName,unsignedchar *aes_key);

                                                 // AES文件减密函数

 

private:

     AES_KEY m_key;                              // AES密钥

     unsignedchar m_from[OPENSSL_AES_BUFFBLOCK],m_to[OPENSSL_AES_BUFFBLOCK]; // 输入、输出缓冲区

};

//--------------------------------------------------------------------------------------

类CMyOpenSSL源文件：

#include"StdAfx.h"

#include"MyOpenSSL.h"

 

CMyOpenSSL::CMyOpenSSL(void)

{

     m_len = 0;

     m_nRetLen = OPENSSL_RSA_BUFFBLOCK;

}

 

CMyOpenSSL::~CMyOpenSSL(void)

{

}

 

// RSA //-----

 

void CMyOpenSSL::InitRSA()

{

     m_rsa = RSA_new();

}

 

void CMyOpenSSL::FreeRSA()

{

     RSA_free(m_rsa);

}

 

void CMyOpenSSL::GenerateKey()

{

     m_rsa = RSA_generate_key(RSA_bits,e,NULL,NULL);

}

 

void CMyOpenSSL::GetEncryptKey(RSA_TYPE type)

{

     m_rsa->n = BN_bin2bn(rsa_N,sizeof(rsa_N),m_rsa->n);

//   if (type == PUBENCRYPT)

//   {

//       m_rsa->e = BN_bin2bn(rsa_E,sizeof(rsa_E),m_rsa->e);

//   }

//   else if (type == PRIENCRYPT)

     {

         m_rsa->e = BN_bin2bn(rsa_E,sizeof(rsa_E),m_rsa->e);

         m_rsa->d = BN_bin2bn(rsa_D,sizeof(rsa_D),m_rsa->d);

     }

     m_rsa->p = BN_bin2bn(rsa_P,sizeof(rsa_P),m_rsa->p);

     m_rsa->q = BN_bin2bn(rsa_Q,sizeof(rsa_Q),m_rsa->q);

     m_rsa->dmp1 = BN_bin2bn(rsa_DP,sizeof(rsa_DP),m_rsa->dmp1);

     m_rsa->dmq1 = BN_bin2bn(rsa_DQ,sizeof(rsa_DQ),m_rsa->dmq1);

     m_rsa->iqmp = BN_bin2bn(rsa_InverseQ,sizeof(rsa_InverseQ),m_rsa->iqmp);

}

 

void CMyOpenSSL::GetDecryptKey(RSA_TYPE type)

{

     m_rsa->n = BN_bin2bn(rsa_N,sizeof(rsa_N),m_rsa->n);

//   if (type == PRIENCRYPT)

//   {

//       m_rsa->e = BN_bin2bn(rsa_E,sizeof(rsa_E),m_rsa->e);

//   }

//   else if (type == PUBENCRYPT)

     {

         m_rsa->e = BN_bin2bn(rsa_E,sizeof(rsa_E),m_rsa->e);

         m_rsa->d = BN_bin2bn(rsa_D,sizeof(rsa_D),m_rsa->d);

     }

     m_rsa->p = BN_bin2bn(rsa_P,sizeof(rsa_P),m_rsa->p);

     m_rsa->q = BN_bin2bn(rsa_Q,sizeof(rsa_Q),m_rsa->q);

     m_rsa->dmp1 = BN_bin2bn(rsa_DP,sizeof(rsa_DP),m_rsa->dmp1);

     m_rsa->dmq1 = BN_bin2bn(rsa_DQ,sizeof(rsa_DQ),m_rsa->dmq1);

     m_rsa->iqmp = BN_bin2bn(rsa_InverseQ,sizeof(rsa_InverseQ),m_rsa->iqmp);

}

 

BOOL CMyOpenSSL::CheckKey()

{

     m_nRet = RSA_check_key(m_rsa);

     return m_nRet;

}

 

int CMyOpenSSL::GetBuffLen(PADDING padding)

{

     m_len = RSA_size(m_rsa);

 

     switch (padding)

     {

     case RSA_NO:

         m_padding = RSA_NO_PADDING;

         m_len = m_len;

         break;

 

     case RSA_PKCS1:

         m_padding = RSA_PKCS1_PADDING;

         m_len -= 11;

         break;

 

     case RSA_SSLV23:

         m_padding = RSA_SSLV23_PADDING;

         m_len -= 11;

         break;

 

//   case RSA_X931:

//       m_padding = RSA_X931_PADDING;

//       m_len -= 2;

//       break;

 

     case RSA_PKCS1_OAEP:

         m_padding = RSA_PKCS1_OAEP_PADDING;

         m_len = m_len - 2 * SHA_DIGEST_LENGTH - 2;

         break;

 

     default:

         break;

     }

 

     return m_len;

}

 

int CMyOpenSSL::RSAEncrypt(unsignedchar *from,unsignedchar *to,

                                 RSA_TYPE type)

{

     if (type == PUBENCRYPT)

     {

         m_nRet = RSA_public_encrypt(m_len,from,to,m_rsa,m_padding);

     }

     else

     {

         m_nRet = RSA_private_encrypt(m_len,from,to,m_rsa,m_padding);

     }

     return m_nRet;

}

 

void CMyOpenSSL::RSADecrypt(unsignedchar *from,unsignedchar *to,

                                 RSA_TYPE type)

{

     if (type == PUBENCRYPT)

     {

         m_nRet = RSA_private_decrypt(m_nRetLen,from,to,m_rsa,m_padding);

     }

     else

     {

         m_nRet = RSA_public_decrypt(m_nRetLen,from,to,m_rsa,m_padding);

     }

}

 

void CMyOpenSSL::MyEncryptFile(LPCTSTR sourceFileName, LPCTSTR destFileName, RSA_TYPE type)

{

     // Open source file and dest file

     CFile sourceFile,destFile;

     sourceFile.Open(sourceFileName,CFile::modeRead);

     destFile.Open(destFileName,CFile::modeCreate | CFile::modeWrite);

 

     ULONGLONG sourceLen,destLen,sourceOff,destOff;

     sourceLen = sourceFile.GetLength();

     m_sourceFileLen = sourceLen;

     destLen = 0;

     sourceOff = 0;

     destOff = 0;

 

     // read, encrypt and write

     unsignedchar sourceBuff[OPENSSL_RSA_BUFFBLOCK],destBuff[OPENSSL_RSA_BUFFBLOCK];

     while (sourceLen > destLen)

     {

         sourceFile.Read(sourceBuff,m_len);

         // Encrypt

         m_nRetLen = RSAEncrypt(sourceBuff,destBuff,PRIENCRYPT);

         destFile.Write(destBuff,m_nRetLen);

 

         // Update

         destLen = destFile.GetLength();

         sourceOff += m_len;

         destOff += m_nRetLen;

 

         // Move the point to current pos

         sourceFile.Seek(sourceOff,CFile::begin);

         destFile.Seek(destOff,CFile::begin);

     }

 

     // Close file

     sourceFile.Close();

     destFile.Close();

}

 

void CMyOpenSSL::MyDecryptFile(LPCTSTR sourceFileName, LPCTSTR destFileName, RSA_TYPE type)

{

     // Open and read file

     CFile sourceFile,destFile;

     sourceFile.Open(sourceFileName,CFile::modeRead);

     destFile.Open(destFileName,CFile::modeCreate | CFile::modeWrite);

     ULONGLONG destLen,sourceOff,destOff;

     destLen = 0;

     sourceOff = 0;

     destOff = 0;

 

     unsignedchar sourceBuff[OPENSSL_RSA_BUFFBLOCK],destBuff[OPENSSL_RSA_BUFFBLOCK];

     while (m_sourceFileLen > destLen)

     {

         sourceFile.Read(sourceBuff,m_nRetLen);

         // Decrypt

         RSADecrypt(sourceBuff,destBuff,PRIENCRYPT);

 

         if (m_sourceFileLen - destLen < OPENSSL_RSA_BUFFBLOCK)

              m_len = (int)(m_sourceFileLen - destLen);

 

         destFile.Write(destBuff,m_len);

 

         // Update

         destLen = destFile.GetLength();

         sourceOff += m_nRetLen;

         destOff += m_len;

 

         // Move the point to current pos

         sourceFile.Seek(sourceOff,CFile::begin);

         destFile.Seek(destOff,CFile::begin);

     }

 

     // Close file

     sourceFile.Close();

     destFile.Close();

}

 

//---------------------------------------------------------------------------------------------

 

// AES //----

 

void CMyOpenSSL::SetEncryptKey(unsignedchar *aes_key)

{

     AES_set_encrypt_key(aes_key,AES_bits,&m_key);

}

 

void CMyOpenSSL::SetDecryptKey(unsignedchar *aes_key)

{

     AES_set_decrypt_key(aes_key,AES_bits,&m_key);

}

 

void CMyOpenSSL::MyAESEncryptFile(LPCTSTR sourceFileName, LPCTSTR destFileName,unsignedchar *aes_key)

{

     // Set Encrypt Key

     SetEncryptKey(aes_key);

 

     // Open source file and dest file

     CFile sourceFile,destFile;

     sourceFile.Open(sourceFileName,CFile::modeRead);

     destFile.Open(destFileName,CFile::modeCreate | CFile::modeWrite);

 

     ULONGLONG sourceLen,destLen,sourceOff,destOff;

     sourceLen = sourceFile.GetLength();

     m_sourceFileLen = sourceLen;

     destLen = 0;

     sourceOff = 0;

     destOff = 0;

     m_len = OPENSSL_AES_BUFFBLOCK;

 

     // read, encrypt and write

     while (sourceLen > destLen)

     {

         sourceFile.Read(m_from,m_len);

         // Encrypt

         AES_encrypt(m_from,m_to,&m_key);

         destFile.Write(m_to,m_len);

 

         // Update

         destLen = destFile.GetLength();

         sourceOff += m_len;

         destOff += m_len;

 

         // Move the point to current pos

         sourceFile.Seek(sourceOff,CFile::begin);

         destFile.Seek(destOff,CFile::begin);

     }

 

     // Close file

     sourceFile.Close();

     destFile.Close();

}

 

void CMyOpenSSL::MyAESDecryptFile(LPCTSTR sourceFileName, LPCTSTR destFileName,unsignedchar *aes_key)

{

     // Set Decrypt Key

     SetDecryptKey(aes_key);

 

     // Open and read file

     CFile sourceFile,destFile;

     sourceFile.Open(sourceFileName,CFile::modeRead);

     destFile.Open(destFileName,CFile::modeCreate | CFile::modeWrite);

     ULONGLONG destLen,sourceOff,destOff;

     destLen = 0;

     sourceOff = 0;

     destOff = 0;

     m_len = OPENSSL_AES_BUFFBLOCK;

 

     while (m_sourceFileLen > destLen)

     {

         sourceFile.Read(m_from,m_len);

         // Decrypt

         AES_decrypt(m_from,m_to,&m_key);

 

         if (m_sourceFileLen - destLen < OPENSSL_AES_BUFFBLOCK)

              m_len = (int)(m_sourceFileLen - destLen);

 

         destFile.Write(m_to,m_len);

 

         // Update

         destLen = destFile.GetLength();

         sourceOff += m_len;

         destOff += m_len;

 

         // Move the point to current pos

         sourceFile.Seek(sourceOff,CFile::begin);

         destFile.Seek(destOff,CFile::begin);

     }

 

     // Close file

     sourceFile.Close();

     destFile.Close();

}

 

void CMyOpenSSL::GetSourceFileLen(ULONGLONG len)

{

     m_sourceFileLen = len;

}

 

类CMyCryptClass头文件：

//--------------------------------------------------------------------------------------------------------

 

/*

   类名：CMyCryptClass

   功能：实现了RSA非对称加密对称密钥，AES对称加密文件数据

*/

 

#pragmaonce

 

#include"MyOpenSSL.h"

 

#define MYCRYPT_PLAINTEXT_BLOCK OPENSSL_AES_BUFFBLOCK     // 明文缓冲区块

#define MYCRYPT_CIPHERTEXT_BLOCK OPENSSL_RSA_BUFFBLOCK    // 密文缓冲区块

 

class CMyCryptClass

{

public:

     CMyCryptClass(void);

     ~CMyCryptClass(void);

 

// Operations

public:

     BOOL InitCrypt();                           // 初始化加密

     void DestroyCrypt();                        // 销毁加密

 

     BOOL MyKeyEncrypt(unsignedchar *KeyFrom,unsignedchar *KeyTo,RSA_TYPE type);

                                                 // 加密密钥函数

     BOOL MyKeyDecrypt(unsignedchar *KeyFrom,unsignedchar *KeyTo,RSA_TYPE type);

                                                 // 减密密钥函数

 

     BOOL MyFileEncrypt(LPCTSTR sourceFileName,LPCTSTR destFileName,unsignedchar *key);

                                                 // 文件加密函数

     BOOL MyFileDecrypt(LPCTSTR sourceFileName,LPCTSTR destFileName,unsignedchar *key);

                                                 // 文件减密函数

     void GetSourceFileLen(ULONGLONG len);

 

private:

     CMyOpenSSL *m_OpenSSL;

     ULONGLONG m_sourceFileLen;

};

 

//---------------------------------------------------------------------------------------

 

类CMyCryptClass源文件：

#include"StdAfx.h"

#include"MyCryptClass.h"

 

CMyCryptClass::CMyCryptClass(void)

{

     m_OpenSSL = new CMyOpenSSL();

}

 

CMyCryptClass::~CMyCryptClass(void)

{

     delete m_OpenSSL;

}

 

BOOL CMyCryptClass::InitCrypt()

{

     m_OpenSSL->InitRSA();

     return TRUE;

}

 

void CMyCryptClass::DestroyCrypt()

{

     m_OpenSSL->FreeRSA();

}

 

BOOL CMyCryptClass::MyKeyEncrypt(unsignedchar *KeyFrom,unsignedchar *KeyTo,

                                    RSA_TYPE type)

{

     m_OpenSSL->GetEncryptKey(type);

 

     if (!m_OpenSSL->CheckKey()) return FALSE;

 

     m_OpenSSL->GetBuffLen(RSA_PKCS1);

 

     m_OpenSSL->RSAEncrypt(KeyFrom,KeyTo,type);

 

     return TRUE;

}

 

BOOL CMyCryptClass::MyKeyDecrypt(unsignedchar *KeyFrom,unsignedchar *KeyTo,

                                    RSA_TYPE type)

{

     m_OpenSSL->GetDecryptKey(type);

 

     if (!m_OpenSSL->CheckKey()) return FALSE;

    

     m_OpenSSL->GetBuffLen(RSA_PKCS1);

 

     m_OpenSSL->RSADecrypt(KeyFrom,KeyTo,type);

 

     return TRUE;

}

 

BOOL CMyCryptClass::MyFileEncrypt(LPCTSTR sourceFileName,LPCTSTR destFileName,unsignedchar *key)

{

     m_OpenSSL->MyAESEncryptFile(sourceFileName,destFileName,key);

 

     return TRUE;

}

 

BOOL CMyCryptClass::MyFileDecrypt(LPCTSTR sourceFileName,LPCTSTR destFileName,unsignedchar *key)

{

     m_OpenSSL->MyAESDecryptFile(sourceFileName,destFileName,key);

 

     return TRUE;

}

 

void CMyCryptClass::GetSourceFileLen(ULONGLONG len)

{

     m_sourceFileLen = len;

}

5、  使用上面的封装类实现RSA加密对称密钥，AES对称加密文件的小示例：

CMyCryptClass myCrypt;

ULONGLONG fileLen;

 

char sourceCABFileName[] = "C://Documents and Settings//Administrator//桌面//old//GlobalUpdateFile(src).cab";

char EncryptedCABFileName[] = "C://Documents and Settings//Administrator//桌面//old//GlobalUpdateFile.cab";

 

void CTestCabDlg::OnBnClickedButton5()

{

     // 制作CAB文件，加密并加密密钥写入CAB文件

     unsignedchar KeyBeforeEncrypt[MYCRYPT_PLAINTEXT_BLOCK];

     unsignedchar KeyAfterEncrypt[MYCRYPT_CIPHERTEXT_BLOCK];

     for (int i = 0; i < MYCRYPT_PLAINTEXT_BLOCK; i++)

         KeyBeforeEncrypt[i] = aes_Key[i];

 

     // Make CAB file //----

     CCabinet a;

     a.CreateCabinet(sourceCABFileName);

     a.AddFile2Cab("C://Documents and Settings//Administrator//桌面//old//爱要怎么说出口(赵传).mp3");

     a.AddFile2Cab("C://Documents and Settings//Administrator//桌面//old//TSReader.ocx");

     // add new file for CAB file

     // ...

     a.FlushCab();

 

     // Get source file len

     CFile cab;

     cab.Open(EncryptedCABFileName,CFile::modeRead);

     fileLen = cab.GetLength();

     cab.Close();

 

     // Encrypt the CAB file //----

     if (!myCrypt.InitCrypt()) return;

     if (!myCrypt.MyKeyEncrypt(KeyBeforeEncrypt,KeyAfterEncrypt,PRIENCRYPT)) return;

     if (!myCrypt.MyFileEncrypt((LPCTSTR)sourceCABFileName,(LPCTSTR)EncryptedCABFileName,KeyBeforeEncrypt)) return;

     myCrypt.DestroyCrypt();

 

     // 将KeyAfterEncrypt发送给远程接收端

     CFile file;

     file.Open(EncryptedCABFileName,CFile::modeWrite);

     file.SeekToEnd();

     file.Write(KeyAfterEncrypt,MYCRYPT_CIPHERTEXT_BLOCK);

     file.Close();

}

 

// Get the file name

     CString FileBeforeDecrypt("C://Documents and Settings//Administrator//桌面//old//GlobalUpdateFile.cab"),

         FileAfterDecrypt("C://Documents and Settings//Administrator//桌面//new//GlobalUpdateFile(des).cab");

 

void CTestCabDlg::OnBnClickedButton6()

{

     // 从CAB文件中读取密钥密文，解密密钥并解密文件

     CFile sourceFile,destFile;

 

     ULONGLONG sourceFileLen;

     sourceFile.Open(FileBeforeDecrypt,CFile::modeRead);

     sourceFileLen = sourceFile.GetLength();

     sourceFile.Seek(sourceFileLen - MYCRYPT_CIPHERTEXT_BLOCK, CFile::begin);

     unsignedchar KeyBeforeDecrypt[MYCRYPT_CIPHERTEXT_BLOCK],KeyAfterDecrypt[MYCRYPT_PLAINTEXT_BLOCK];

     sourceFile.Read(KeyBeforeDecrypt,MYCRYPT_CIPHERTEXT_BLOCK);

     sourceFile.SeekToBegin();

     sourceFile.Close();

 

     // Init the crypt

     if (!myCrypt.InitCrypt()) return;

 

     // Use RSA to decrypt the key

     if (!myCrypt.MyKeyDecrypt(KeyBeforeDecrypt,KeyAfterDecrypt,PRIENCRYPT))

     {

         MessageBox("解密密钥错误");

         return;

     }

 

     // Get source file len from ini file

     ULONGLONG len = fileLen;

     myCrypt.GetSourceFileLen(len);

 

     // Use AES to decrypt the file

     if (!myCrypt.MyFileDecrypt(FileBeforeDecrypt.GetBuffer(),FileAfterDecrypt.GetBuffer(),

         KeyAfterDecrypt))

     {

         MessageBox("解密失败");

         return;

     }

     FileBeforeDecrypt.ReleaseBuffer();

     FileAfterDecrypt.ReleaseBuffer();

 

     // Free the crypt

     myCrypt.DestroyCrypt();

}
zaitianaoxiang
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Openssl-RSA加解密实现demo
Ethereal的博客
11-13 2254
Openssl RSA加解密实现 VM ware 15.5pro Linux虚拟机：Kali （debian 10.x 64）
OpenSSL RSA AES加密解密C++源码
08-30
总结来说，OpenSSL库提供了RSA和AES加密解密的API，使得在C++中实现数据加密变得相对简单。开发者可以通过调用相应的函数，结合公钥私钥和密钥，实现安全的数据保护。在实际应用中，这些加密技术常用于保护用户隐私...
用OpenSSL实现RSA/AES加解密
希哈科技
05-26 1715
基本思想是这样的：1.用随机生成的32字节密码对文件经行AES加密；2.将随机密码用RSA的公钥加密;3.将加密后的随机密码和密文通过网络等渠道传送给接受者；4.接受者用RSA私钥解密随机密码；5.用解密后的随机密码解密密文；这么做的理由：1.RSA是非对称加密算法，安全性最好，即使公钥泄露也无法对密文进行解密。缺点是加密速度慢，只能加密小数据。因此用RSA加密仅32字节的随机密码；2.AES是对...
使用C语言openssl库实现 RSA加密 和 消息验证
mjmmm的博客
05-29 1289
RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，是最早的一种用于公开密钥加密和数字签名的算法。它使用一对公钥（public key）和私钥（private key）。公钥用于加密，私钥用于解密。由于使用不同的密钥进行加密和解密，因此被称为非对称加密算法。RSA消息验证指的是使用RSA算法对消息进行签名和验证，以确保消息的完整性和真实性
openssl rsa加密解析 aes加解密
qq_35975827的博客
03-09 439
RSA加密长度限制问题 RSA加解密中必须考虑到的密钥长度、明文长度和密文长度问题。明文长度需要小于密钥长度，而密文长度则等于密钥长度。因此当加密内容长度大于密钥长度时，有效的RSA加解密就需要对内容进行分段。 这是因为，RSA算法本身要求加密内容也就是明文长度m必须0<m<密钥长度n。如果小于这个长度就需要进行padding，因为如果没有padding，就无法确定解密后内容的真实长度，字符串之类的内容问题还不大，以0作为结束符，但对二进制数据就很难，因为不确定后面的0是内容还是内容结束符。而只
GO实现RSA 、AES加解密
起个破名真费劲..的博客
05-06 1323
使用门面和策略模式，对外开放加解密接口，由于密码比较场景使用率较高，再对外开放一个比较的接口，接口最少有两个参数，明文密码，密文密码，详见代码
go实现rsa和aes加解密
止语的博客
03-06 952
密码学中两大经典算法，一个是对称加解密，具有代表性的是AES加解密，另一个是非对称加解密，代表性的是RSA加解密。那什么事对称和非对称呢？对称加密算法又称为传统密码算法，加密密钥和解密密钥是相同的。对称加密算法要求通信双方在开始通信前，要首先商定一个用于加密和解密的密钥。算法的安全性就依赖于这个密钥，如果这个密钥被泄露了，就意味着通信不再安全非对称加密算法是现代密码学取得的最大成就之一，也是密码学近20年来能够快速发展和推广应用的主要原因之一。
openssl实现RSA+AES加密
Luobooooo的博客
07-13 740
RSA+AES加密是传输数据过程中常用的一种加密方式，通讯双方都要实现加密解密过程，作为java，有接口，直接调用就好了，然而作为C语言这一端，加解密起来就比较蛋疼了，最近折腾了一下，这里留个脚印 AES加密算法 AES是一种对称加密算法,有几种加密方式（ecb，cbc，cfb等等），这里不细说，可以看这里https://blog.csdn.net/qq_28205153/articl...
20.3 OpenSSL 对称AES加解密算法
CSDN
10-30 7570
AES算法是一种对称加密算法，全称为高级加密标准（Advanced Encryption Standard）。它是一种分组密码，以`128`比特为一个分组进行加密，其密钥长度可以是`128`比特、`192`比特或`256`比特，因此可以提供不同等级的安全性。该算法采用了替代、置换和混淆等技术，以及多轮加密和密钥扩展等机制，使得其加密效果优秀，安全性高，被广泛应用于各种领域中，如数据加密、文件加密、网络安全等。
C++使用openssl做AES/RSA加解密
qq1187239259的博客
08-26 1641
#include <iostream> #include <stdio.h> #include <string.h> #include <openssl/aes.h> #include <openssl/rsa.h> #include <openssl/pem.h> #include <stdlib.h> #include "crypto.h" using namespace std; // 公钥加密 // .
linux+openssl命令之RSA加解密操作
N阶二进制的博客
11-05 3470
RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出。RSA是目前最广泛使用的公钥加密算法之一。它基于两个大素数的乘积的难解性问题，其中一个素数用作加密密钥，另一个素数用作解密密钥。
pb + openssl 实现 RSA、SM2、AES
06-11
pb11.5 + pbni + openssl实现RSA\SM2\AES加密解密，平时用不到这些，做民营医疗机构监管平台对接，AK/SK接口认证，需要用到RSA\AES才做，分享出来，希望能对有需要的人有点帮助。
C语言使用openSSL库AES模块实现加密功能详解
08-30
C语言使用openSSL库AES模块实现加密功能详解 加密分类 在密码学中，加密可以分为三种分类：对称加密、非对称加密和离散。 1. 对称加密：对称加密使用相同的密钥进行加密和解密。常见的对称加密算法有DES和AES。 2...
PHP RSA AES加密解密及封装的类方便调用
03-26
在压缩包中的`RSA`文件可能是这个类库的源代码，包含了实现RSA和AES加密解密功能的PHP类。这些类可能提供了如`encrypt()`和`decrypt()`等方法，方便开发者在项目中调用，无需关心底层加密算法的细节。 总的来说，`...
RSA+AES加解密算法程序示例
11-11
在你提供的压缩包中，"RSA加解密算法.rar"可能包含使用RSA算法的Delphi代码示例，而"AES加解密算法+演示原码.rar"则可能包含了AES算法的实现以及如何将两者结合使用的演示代码。通过研究这些示例，你可以更好地理解...
学习记录day18——数据结构 算法
最新发布
weixin_64918301的博客
07-24 718
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 296
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
Codeforces Round 961 (Div. 2)
2301_80105412的博客
07-24 999
Codeforces Round 961 (Div. 2) ABC
openssl enc函数加解密
09-02
OpenSSL是一个开源的加密库，它提供了各种加密算法和功能。其中，`enc`命令是OpenSSL库中用于加解密的命令行工具。 `openssl enc`命令可以使用不同的加密算法对文件进行加密和解密。它支持对称加密算法和非对称加密算法。 下面是一些常见的用法示例： 1. 使用对称加密算法AES-256-CBC对文件进行加密并输出到另一个文件： ``` openssl enc -aes-256-cbc -salt -in inputfile -out encryptedfile ``` 在加密过程中，你需要输入一个密码作为密钥。加密后的文件会保存为`encryptedfile`。 2. 使用对称加密算法AES-256-CBC对文件进行解密并输出到另一个文件： ``` openssl enc -d -aes-256-cbc -in encryptedfile -out decryptedfile ``` 在解密过程中，你需要输入之前用于加密的密码。解密后的文件会保存为`decryptedfile`。 除了AES算法，`enc`命令还支持其他的对称加密算法（如DES、Triple DES和RC4等），以及非对称加密算法（如RSA和ECC等）。你可以使用`openssl enc --help`命令来查看更多选项和示例。 需要注意的是，使用OpenSSL进行加解密操作需要小心保护密钥和加密结果，确保安全性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值