Qt openssl rsa 加密解密

最新推荐文章于 2024-05-16 00:23:13 发布
最新推荐文章于 2024-05-16 00:23:13 发布
阅读量4.5k 收藏 26
点赞数 4
分类专栏： qt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010559682/article/details/90479150
版权 
最近在处理加密问题，需要用到数字签名，查询资料得知采用rsa加密基本安全。关于rsa加密算法，网络上关于这类说明比较多。其实关于C++ + openssl + rsa的相关代码比较多，要么要积分，要么写的不是qt方面的。今天抽空整理出qt + openssl + rsa相关加密函数及实现。
首先在实现功能的时候出现的一些问题及解决方法。
1、采用openssl-1_1_0h版本
2、qt pro文件中增加动态库关联，这里是把openssl安装文件中的include和lib文件拷贝至qt项目目录下。
   INCLUDEPATH += ./include
   LIBS += libcrypto.lib \   
           libssl.lib 
3、openssl有两种生成key的方式，一种是通过openssl命令生成；一种是通过调用接口用代码生成。两者生成的私钥格式一致，
   但是公钥格式存在区别，从而导致调用接口不一样。
   代码生成的key标题为 -----BEGIN RSA PUBLIC KEY----- ，调用接口PEM_read_bio_RSAPublicKey；
   命令生成的key标题为 -----BEGIN PUBLIC KEY----- ，调用接口 PEM_read_bio_RSA_PUBKEY
4、若通过命令生成的key，拷贝至项目中使用时，需要注意格式，标题和每一行后的换行（/n）必须都带上。
5、由于传输的key都是QString类型，需要转化为uchar*。
   错误的方式： uchar* pPriKey = (uchar*)strPriKey.toUtf8().data();  
   正确的方式： QByteArray priKeyArry = strPriKey.toUtf8();
               uchar* pPriKey = (uchar*)priKeyArry.data(); 
6、代码中为方便查看生成的key，统一都转化base64格式，但是在解密的时候需要转化为uchar*。

这里仅处理小于128字节的数据加密，后续把分片加密整理出来。

代码实现如下：

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

// define rsa public key
#define BEGIN_RSA_PUBLIC_KEY    "BEGIN RSA PUBLIC KEY"
#define BEGIN_PUBLIC_KEY        "BEGIN PUBLIC KEY"
#define KEY_LENGTH              1024                        // 密钥长度
 
class rsa
{
public:    
/**     
* @brief createRsaKey 生成秘钥对     
* @param strPubKey 公钥     
* @param strPriKey 私钥     
* @return 状态     
*/
static bool createRsaKey (QString& strPubKey, QString& strPriKey);    
/**     
* @brief rsa_pri_encrypt 私钥加密     
* @param strClearData 明文     
* @param strPriKey 私钥     
* @return 加密后数据(base64格式)     
*/    
static QString rsa_pri_encrypt_base64 (const QString& strClearData, const QString& strPriKey);    
/**
* @brief rsa_pub_decrypt 公钥解密    
* @param strDecrypt 待解密数据(base64格式)     
* @param strPubKey 公钥钥     
* @return 明文     
*/    
static QString rsa_pub_decrypt_base64 (const QString& strDecryptData, const QString& strPubKey);    
/**     
* @brief rsa_pub_encrypt 公钥加密     
* @param strClearData 明文     
* @param strPubKey 私钥     
* @return 加密后数据(base64格式)     
*/    
static QString rsa_pub_encrypt_base64 (const QString& strClearData, const QString& strPubKey);    
/**     
* @brief rsa_pri_decrypt 私钥解密     
* @param strDecrypt 待解密数据(base64格式)     
* @param strPriKey 私钥     
* @return 明文     
*/    
static QString rsa_pri_decrypt_base64 (const QString& strDecryptData, const QString& strPriKey);    
/**< 测试 */    
static void test ();
};

#endif // RSA_H
#include "rsa.h"
/** 
* @brief createRsaKey 生成秘钥对 
* @param strPubKey 公钥 
* @param strPriKey 私钥 
* @return 成功状态 
*/
bool rsa::createRsaKey (QString& strPubKey, QString& strPriKey)
{    
     RSA *pRsa = RSA_generate_key(KEY_LENGTH, RSA_3, NULL, NULL);    
     if ( !pRsa ){       
         return false; 
     }
     BIO *pPriBio = BIO_new(BIO_s_mem());    
     PEM_write_bio_RSAPrivateKey(pPriBio, pRsa, NULL, NULL, 0, NULL, NULL);    
     BIO *pPubBio = BIO_new(BIO_s_mem());   
     PEM_write_bio_RSAPublicKey(pPubBio, pRsa);    
     // 获取长度   
     size_t nPriKeyLen = BIO_pending(pPriBio);   
     size_t nPubKeyLen = BIO_pending(pPubBio);    
     // 密钥对读取到字符串    
     char* pPriKey = new char[nPriKeyLen];    
     char* pPubKey = new char[nPubKeyLen];    
     BIO_read(pPriBio, pPriKey, nPriKeyLen);     
     BIO_read(pPubBio, pPubKey, nPubKeyLen);    
     // 存储密钥对    
     strPubKey = QByteArray(pPubKey, nPubKeyLen);    
     strPriKey = QByteArray(pPriKey, nPriKeyLen);    
     // 内存释放     
     RSA_free(pRsa);    
     BIO_free_all(pPriBio);    
     BIO_free_all(pPubBio);    
     delete pPriKey;    
     delete pPubKey;    
     return true;
}

/**
 * @brief rsa_pri_encrypt 私钥加密
 * @param strClearData 明文
 * @param strPriKey 私钥
 * @return 加密后数据(base64格式)
 */
QString rsa::rsa_pri_encrypt_base64 (const QString& strClearData, const QString& strPriKey)
{    
    QByteArray priKeyArry = strPriKey.toUtf8();    
    uchar* pPriKey = (uchar*)priKeyArry.data();    
    BIO* pKeyBio = BIO_new_mem_buf(pPriKey, strPriKey.length());    
    if (pKeyBio == NULL){        
        return "";    
    }    
    RSA* pRsa = RSA_new();    
    pRsa = PEM_read_bio_RSAPrivateKey(pKeyBio, &pRsa, NULL, NULL);    
    if ( pRsa == NULL ){        
         BIO_free_all(pKeyBio);        
         return "";    
    }    
    int nLen = RSA_size(pRsa);    
    char* pEncryptBuf = new char[nLen];    
    memset(pEncryptBuf, 0, nLen);    
    QByteArray clearDataArry = strClearData.toUtf8();    
    int nClearDataLen = clearDataArry.length();     
    uchar* pClearData = (uchar*)clearDataArry.data();    
    int nSize = RSA_private_encrypt(nClearDataLen,                     
                                    pClearData,                                    
                                    (uchar*)pEncryptBuf,                                    
                                    pRsa,                                    
                                    RSA_PKCS1_PADDING);    
    QString strEncryptData = "";    
    if ( nSize >= 0 ){        
         QByteArray arry(pEncryptBuf, nSize);        
         strEncryptData = arry.toBase64();    
    }    
    // 释放内存    
    delete pEncryptBuf;    
    BIO_free_all(pKeyBio);    
    RSA_free(pRsa);   
    return strEncryptData;
}

/**
 * @brief rsa_pub_decrypt 公钥解密
 * @param strDecrypt 待解密数据(base64格式)
 * @param strPubKey 公钥
 * @return 明文
 */
QString rsa::rsa_pub_decrypt_base64(const QString& strDecryptData, const QString& strPubKey)
{    
    QByteArray pubKeyArry = strPubKey.toUtf8();
    uchar* pPubKey = (uchar*)pubKeyArry.data();
    BIO* pKeyBio = BIO_new_mem_buf(pPubKey, strPubKey.length());
    if (pKeyBio == NULL){
        return "";
    }

    RSA* pRsa = RSA_new();
    if ( strPubKey.contains(BEGIN_RSA_PUBLIC_KEY) ){
        pRsa = PEM_read_bio_RSAPublicKey(pKeyBio, &pRsa, NULL, NULL);
    }else{
        pRsa = PEM_read_bio_RSA_PUBKEY(pKeyBio, &pRsa, NULL, NULL);
    }

    if ( pRsa == NULL ){
        BIO_free_all(pKeyBio);
        return "";
    }
    int nLen = RSA_size(pRsa);
    char* pClearBuf = new char[nLen];
    memset(pClearBuf, 0, nLen);
    //解密
    QByteArray decryptDataArry = strDecryptData.toUtf8();
    decryptDataArry = QByteArray::fromBase64(decryptDataArry);
    int nDecryptDataLen = decryptDataArry.length();
    uchar* pDecryptData = (uchar*)decryptDataArry.data();
    int nSize = RSA_public_decrypt(nDecryptDataLen,
                                   pDecryptData,
                                   (uchar*)pClearBuf,
                                   pRsa,
                                   RSA_PKCS1_PADDING);
    QString strClearData = "";
    if ( nSize >= 0 ){
        strClearData = QByteArray(pClearBuf, nSize);
    }

    // 释放内存
    delete pClearBuf;
    BIO_free_all(pKeyBio);
    RSA_free(pRsa);
    return strClearData;
}

/**
 * @brief rsa_pub_encrypt 公钥加密
 * @param strClearData 明文
 * @param strPubKey 私钥
 * @return 加密后数据(base64格式)
 */
QString rsa::rsa_pub_encrypt_base64 (const QString& strClearData, const QString& strPubKey)
{
    QByteArray pubKeyArry = strPubKey.toUtf8();
    uchar* pPubKey = (uchar*)pubKeyArry.data();
    BIO* pKeyBio = BIO_new_mem_buf(pPubKey, pubKeyArry.length());
    if (pKeyBio == NULL){
        return "";
    }
    RSA* pRsa = RSA_new();
    if ( strPubKey.contains(BEGIN_RSA_PUBLIC_KEY) ){
        pRsa = PEM_read_bio_RSAPublicKey(pKeyBio, &pRsa, NULL, NULL);
    }else{
        pRsa = PEM_read_bio_RSA_PUBKEY(pKeyBio, &pRsa, NULL, NULL);
    }
    if ( pRsa == NULL ){
        BIO_free_all(pKeyBio);
        return "";
    }

    int nLen = RSA_size(pRsa);
    char* pEncryptBuf = new char[nLen];
    memset(pEncryptBuf, 0, nLen);

    QByteArray clearDataArry = strClearData.toUtf8();
    int nClearDataLen = clearDataArry.length();
    uchar* pClearData = (uchar*)clearDataArry.data();
    int nSize = RSA_public_encrypt(nClearDataLen,
                                   pClearData,
                                   (uchar*)pEncryptBuf,
                                   pRsa,
                                   RSA_PKCS1_PADDING);
    QString strEncryptData = "";
    if ( nSize >= 0 ){
        QByteArray arry(pEncryptBuf, nSize);
        strEncryptData = arry.toBase64();
    }
    // 释放内存
    delete pEncryptBuf;
    BIO_free_all(pKeyBio);
    RSA_free(pRsa);
    return strEncryptData;
}

/** 
 * @brief rsa_pri_decrypt 私钥解密
 * @param strDecrypt 待解密数据(base64格式) 
 * @param strPriKey 私钥
 * @return 明文
 */
QString rsa::rsa_pri_decrypt_base64(const QString& strDecryptData, const QString& strPriKey)
{
    QByteArray priKeyArry = strPriKey.toUtf8();
    uchar* pPriKey = (uchar*)priKeyArry.data();
    BIO* pKeyBio = BIO_new_mem_buf(pPriKey, priKeyArry.length());
    if (pKeyBio == NULL){
        return "";
    } 
    RSA* pRsa = RSA_new();
    pRsa = PEM_read_bio_RSAPrivateKey(pKeyBio, &pRsa, NULL, NULL);
    if ( pRsa == NULL ){
        BIO_free_all(pKeyBio);
        return "";
    }
    int nLen = RSA_size(pRsa);
    char* pClearBuf = new char[nLen];
    memset(pClearBuf, 0, nLen);

    //解密
    QByteArray decryptDataArry = strDecryptData.toUtf8();
    decryptDataArry = QByteArray::fromBase64(decryptDataArry);
    int nDecryptDataLen = decryptDataArry.length(); 
    uchar* pDecryptData = (uchar*)decryptDataArry.data(); 
    int nSize = RSA_private_decrypt(nDecryptDataLen,
                                    pDecryptData,
                                    (uchar*)pClearBuf,
                                    pRsa,
                                    RSA_PKCS1_PADDING);
    QString strClearData = "";
    if ( nSize >= 0 ){
        strClearData = QByteArray(pClearBuf, nSize);
    }
    // 释放内存
    delete pClearBuf;
    BIO_free_all(pKeyBio);
    RSA_free(pRsa);
    return strClearData;
}

void rsa::test()
{
    /**< rsa private/public key 若从文件中拷贝出来，需要注意保存元先文件格式，即换行符需要带上，包括最后一行的换行符 */
    QString strPriKey = "";   
    QString strPubKey = "";
    /** 
     *  用代码生成的key与openssl命令生成的key区别：
     *  1、代码生成key，标题为 -----BEGIN RSA PUBLIC KEY-----,openssl命令生成key, 标题为 -----BEGIN PUBLIC KEY-----
     *  2、获取RSA函数不同，代码生成key，用PEM_read_bio_RSAPublicKey，openssl命令生成key，用PEM_read_bio_RSA_PUBKEY
    */
    createRsaKey(strPubKey, strPriKey);
    qDebug() << strPubKey << endl;
    qDebug() << strPriKey << endl;
    qDebug() << "private key encrypt, public key decrypt";
    QString strClear = "hello";
    QString strEncryptData = rsa_pri_encrypt_base64 (strClear, strPriKey);
    qDebug() << strEncryptData;
    QString strClearData = rsa_pub_decrypt_base64 (strEncryptData, strPubKey);
    qDebug() << strClearData;
    qDebug() << "public key encrypt, private key decrypt"; 
    strEncryptData = rsa_pub_encrypt_base64 (strClear, strPubKey);
    qDebug() << strEncryptData; 
    strClearData = rsa_pri_decrypt_base64 (strEncryptData, strPriKey);
    qDebug() << strClearData;
}
 
 
u010559682
关注
  • 4
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Qt使用第三方库openssl进行RSA加密解密操作详解
小米的修行之路
06-08 1317
qt使用openssl进行rsa加密解密
Qt实现RSA加解密
07-24
在本文中，我们将深入探讨如何使用Qt框架来实现RSA加解密，并结合开源库openssl进行数字签名。Qt是一个跨平台的应用程序开发框架，广泛应用于GUI应用程序的开发，同时支持非图形化应用程序。RSA是一种公开密钥加密...
QT C/C++ 使用 CryptoPP加密解密
m0_73482095的博客
05-06 1903
CryptoPP 是一个开源的密码学加密库，提供了大量的密码学算法和功能，包括对称加密、非对称加密、哈希函数、消息认证码 (MAC)、数字签名等。这里重点介绍一下对称加密算法（AES）的使用和注意事项。
QT中用openssl做rsa加密解密
yajunsun的专栏
12-27 1万+
首先，你得安装openssl，去官网下载最新版本就行， 安装完成后用命令行打开到openssl安装目录，先生成私钥，私钥保存到此目录的private.pem中，密钥长度2048位，然后再从私钥中提取公钥，公钥保存到此目录的public.pem中，当然，文件名称自己定。 按照上述命令生成好私钥公钥文件后，直接编辑打开把密钥复制出来用，或者在程序中直接用公钥私钥文件加载RSA对象。
QT中使用openssl实现RSA加密
li_yi_feng_的博客
03-10 1826
RSA加密，QT，openssl
QT使用openssl实现RSA加解密
weixin_42098322的博客
05-26 3134
使用openssl生成公私钥，随后用QT对相应的信息进行RSA加解密
QT使用Openssl实现RSA加解密
未来的博客
12-03 6030
前言： RSA是目前最有影响力和最常用的加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密标准。这是一种非对称密码算法，所谓非对称，就是指该算法需要一对公密钥，使用其中一个加密，则需要用另一个才能解密。密钥越长，它就越难破解。根据已经披露的文献，目前被破解的最长RSA密钥是768个二进制位。也就是说，长度超过768位的密钥，还无法破解（至少没人公开宣布...
QT使用Openssl实现RSA加解密_qt rsa(1)
2401_85014224的博客
05-16 900
RSA是目前最有影响力和最常用的加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密标准。这是一种非对称密码算法，所谓非对称，就是指该算法需要一对公密钥，使用其中一个加密，则需要用另一个才能解密。密钥越长，它就越难破解。根据已经披露的文献，目前被破解的最长RSA密钥是768个二进制位。也就是说，长度超过768位的密钥，还无法破解（至少没人公开宣布）。因此可以认为，1024位的RSA密钥基本安全，2048位的密钥极其安全。下面这篇文章采用的是512位的RSA秘钥。
RSA 加密解密简单案列 Openssl 1.1.1 C语言实现
误入人间小生灵
11-01 1619
RSA 加密解密简单案列 Openssl 1.1.1 C语言实现一、直接复制公钥私钥到代码里代码gcc编译运行结果二、读取pem文件后加密解密代码编译 一、直接复制公钥私钥到代码里 代码 main.c #include "crypto.h" int main(int argc, char* argv[]) { char* cleartext = "123abc"; if (sizeof(cleartext) > 256) { printf("cleartext too len
使用OpenSSL进行RSA加密和解密（非对称）
热门推荐
yizhiniu_xuyw的专栏
03-04 1万+
1. RSA加密和解密基础概念 RSA是一种非对称加密。 RSA秘钥：私钥和公钥，一对私钥和公钥就像夫妻一样是唯一的，用私钥加密后必须用对应的公钥才能解密，用公钥加密后必须用对应的私钥才能解密。 加密和解密方式：公钥加密-私钥解密，私钥加密-公钥解密 2. 使用OpenSSL库进行RSA加密和解密的基础过程 加密基础过程 1) 调用OpenSSL库生成秘钥（非必要步骤，如果已经有秘钥对了，就不需要进行这步了） 2) 调用OpenSSL库对明文进...
C++使用Openssl进行RSA加密解密及签名验签功能（SHA256）
09-19
本文将深入探讨如何使用OpenSSL库在C++中实现RSA加密、解密以及签名和验签功能，特别关注SHA256WithRSA这一安全强度更高的签名方法。 首先，RSA的核心原理是基于大整数因子分解的困难性。它包含一对密钥，即公钥和...
Qt利用OpenSSl实现RSA数字签名
07-05
接着，导入必要的头文件，例如`<openssl/rsa.h>`、`<openssl/pem.h>`等，然后在Qt项目中编写代码来生成RSA密钥对。这通常包括以下步骤： 1. 初始化OpenSSL库：`OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS |...
QT RSA 公钥加密 公钥解密 私钥加密 私钥解密 分段加密 分段解密
05-25
推荐在线完成RSA加密解密的网站：https://the-x.cn/cryptography/Rsa.aspx 可以用VS打开.sln文件也可以用QT编辑器打开.pro文件 文件中虽然有RSATool.cpp的文件，但是程序中使用动态库的形式引入的 如果你想分步调试...
openssl rsa 算法示例源码
09-21
本示例是基于openssl库实现RSA算法，并且将其接口封装为Qt版本，便于在Qt应用程序中进行加解密操作。理解RSA算法及其在openssl中的应用，以及如何将这些功能集成到Qt界面中，对于提升开发者在实际项目中的能力...
chromedriver-mac-arm64_126.0.6474.0.zip
07-31
chromedriver-mac-arm64_126.0.6474.0.zip
chromedriver-mac-arm64_128.0.6548.0.zip
07-31
chromedriver-mac-arm64_128.0.6548.0.zip
MySQL查询加速器：利用Query Cache提升效率
07-31
MySQL是一个流行的开源关系型数据库管理系统（RDBMS），广泛用于Web应用程序的后端数据存储。它基于结构化查询语言（SQL）来管理数据，并且是LAMP（Linux, Apache, MySQL, PHP/Python/Perl）技术栈的一部分，这个技术栈常用于构建动态网站和Web应用程序。 MySQL的特点包括： - **开放源代码**：MySQL的源代码是公开的，任何人都可以自由使用和修改。 - **跨平台**：MySQL可以在多种操作系统上运行，包括Linux、Windows、macOS等。 - **高性能**：MySQL以其快速的查询处理和良好的性能而闻名。 - **可靠性**：MySQL提供了多种机制来确保数据的完整性和可靠性，包括事务支持、备份和恢复功能。 - **易于使用**：MySQL提供了简单直观的界面和丰富的文档，便于用户学习和使用。 - **可扩展性**：MySQL支持从小型应用到大型企业级应用的扩展。 - **社区支持**：由于其广泛的使用，MySQL拥有一个活跃的开发者社区，提供大量的资源和支持。 MySQL被广泛应用于各种场景，包括在线事务处理（OL
Objective-C语言的基础教程.md
最新发布
07-31
Objective-C是一种面向对象的编程语言，是C语言的扩展。它主要用于苹果的iOS和macOS应用程序开发。
openssl c++ des rsa 加密解密
01-13
OpenSSL是一个广泛使用的开放源代码工具包，提供加密和解密功能。它支持DES和RSA等加密算法，可以用来加密和解密数据。DES是一种对称加密算法，使用相同的密钥进行加密和解密。RSA是一种非对称加密算法，使用公钥进行加密，私钥进行解密。 使用OpenSSL进行DES加密和解密，首先需要生成一个DES密钥，然后使用该密钥进行加密和解密操作。可以使用以下命令生成DES密钥： ``` openssl rand -out des.key 8 ``` 生成的密钥保存在des.key文件中。然后使用该密钥进行加密和解密： ``` openssl enc -des -in plaintext.txt -out encrypted.des -kfile des.key openssl enc -d -des -in encrypted.des -out decrypted.txt -kfile des.key ``` 上述命令分别用指定的DES密钥对明文文件plaintext.txt进行加密，然后将加密结果保存到encrypted.des文件中。解密操作则相反，使用相同的DES密钥对加密后的文件进行解密，得到明文文件decrypted.txt。 而要使用RSA算法进行加密和解密，首先需要生成RSA密钥对（公钥和私钥），然后使用公钥进行加密，私钥进行解密。可以使用以下命令生成RSA密钥对： ``` openssl genrsa -out private.pem 1024 openssl rsa -in private.pem -pubout -out public.pem ``` 生成的私钥保存在private.pem文件中，公钥保存在public.pem文件中。然后使用公钥进行加密，私钥进行解密： ``` openssl rsautl -encrypt -in plaintext.txt -out encrypted.rsa -inkey public.pem openssl rsautl -decrypt -in encrypted.rsa -out decrypted.txt -inkey private.pem ``` 上述命令分别使用指定的公钥对明文文件plaintext.txt进行加密，然后将加密结果保存到encrypted.rsa文件中。解密操作则相反，使用相同的私钥对加密后的文件进行解密，得到明文文件decrypted.txt。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值