QT三方库 Openssl Des 算法实现

已于 2023-09-21 16:44:39 修改
阅读量1.1k 收藏 4
点赞数 3
文章标签： qt c++ openssl
于 2021-09-10 17:24:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45976607/article/details/120225790
版权

QT三方库 Openssl Des 算法实现 ，可直接套用接口

DECcpp文件
在这里插入图片描述

//使用前请在pro文件中包含你的openssl三方库，路径为你openssl在电脑中的位置。
//LIBS += -L"G:/OpenSSL-Win32/lib"
//LIBS += -L"G:/OpenSSL-Win32/lib" -llibeay32
//LIBS += -L"G:/OpenSSL-Win32/lib" -lssleay32
//INCLUDEPATH += $$quote(G:/OpenSSL-Win32/include)


#include "DES.h"
#include "HEX.h"

enum Except{ EXCEP_ZERO,EXCEP_ONE};

QDES::QDES()
{

}

//3Des_cbc加密
QString QDES::m3Des_cbc_encrypt(char *clText,char *key1,char *key2,char *key3)
{
    int i = 0;
        int len = 0;
        int nlen = 0;

        char ch = '\0';
//        char *key1 = "4041424344454647";  /* 原始密钥, 十六进制字符串 */
//        char *key2 = "48494A4B4C4D4E4F";  /* 原始密钥, 十六进制字符串 */
//        char *key3 = "4041424344454647";  /* 原始密钥, 十六进制字符串 */
        //	char *data = "01820003000000000000000000000000";  /* 原始明文, 十六进制字符串 */
        char *data = clText;
        unsigned char src[64] = {0};
        unsigned char out[64] = {0};
        //unsigned char tmp[64] = {0};

        unsigned char *ptr  = NULL;
        unsigned char block[8] = {0};
        DES_key_schedule ks1, ks2, ks3;
        DES_cblock ivec;
        DES_cblock ivsetup = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

        /* 设置密码表 */
        ptr = p->hex2bin(key1, strlen(key1), &nlen);
        memcpy(block, ptr, sizeof(block));
        free(ptr);
        DES_set_key_unchecked((const_DES_cblock *)block, &ks1);

        ptr = p->hex2bin(key2, strlen(key2), &nlen);
        memcpy(block, ptr, sizeof(block));
        free(ptr);
        DES_set_key_unchecked((const_DES_cblock *)block, &ks2);

        ptr = p->hex2bin(key3, strlen(key3), &nlen);
        memcpy(block, ptr, sizeof(block));
        free(ptr);
        DES_set_key_unchecked((const_DES_cblock *)block, &ks3);

        ptr = p->hex2bin(data, strlen(data), &nlen);
        memcpy(src, ptr, nlen);
        free(ptr);

        len = (nlen / 8 + (nlen % 8 ? 1: 0)) * 8;

        ch = 8 - nlen % 8;
        memset(src + nlen, ch, (8 - nlen % 8) % 8);


        memcpy(ivec, ivsetup, sizeof(ivsetup));
        /* 按照8字节数据进行加密，length=8 */
        for (i = 0; i < len; i += 8) {
            DES_ede3_cbc_encrypt(src + i, out + i, 8, &ks1, &ks2, &ks3, &ivec, DES_ENCRYPT);
        }


        const char *result[24];
        //const char *mR = new char;
        printf("加密后数据: ");
        for (i = 0; i < len; i++) {
            //		printf("%02X" , *(out + i));
            result[i] = p->bin2hex((out + i),1);
        }
        QString mValue;
        int valLen = strlen((char *)result);
        for (int j=0;j<len;j++)
        {
            QString temp(result[j]);
            mValue += temp;
        }
        printf(clText);
        return mValue;
}

//3Des_cbc加密
QString QDES::m3Des_cbc_nokey_encrypt(char *clText, char *LKey, char *RKey)
{
    int i = 0;
        int len = 0;
        int nlen = 0;


        char ch = '\0';
        char *key1 = LKey;  /* 原始密钥, 十六进制字符串 */
        char *key2 = RKey;  /* 原始密钥, 十六进制字符串 */
        char *key3 = LKey;  /* 原始密钥, 十六进制字符串 */
        //	char *data = "01820003000000000000000000000000";  /* 原始明文, 十六进制字符串 */
        char *data = clText;
        unsigned char src[64] = {0};
        unsigned char out[64] = {0};
        //unsigned char tmp[64] = {0};

        unsigned char *ptr  = NULL;
        unsigned char block[8] = {0};
        DES_key_schedule ks1, ks2, ks3;
        DES_cblock ivec;
        DES_cblock ivsetup = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

        /* 设置密码表 */
        ptr = p->hex2bin(key1, strlen(key1), &nlen);
        memcpy(block, ptr, sizeof(block));
        free(ptr);
        DES_set_key_unchecked((const_DES_cblock *)block, &ks1);

        ptr = p->hex2bin(key2, strlen(key2), &nlen);
        memcpy(block, ptr, sizeof(block));
        free(ptr);
        DES_set_key_unchecked((const_DES_cblock *)block, &ks2);

        ptr = p->hex2bin(key3, strlen(key3), &nlen);
        memcpy(block, ptr, sizeof(block));
        free(ptr);
        DES_set_key_unchecked((const_DES_cblock *)block, &ks3);

        ptr = p->hex2bin(data, strlen(data), &nlen);
        memcpy(src, ptr, nlen);
        free(ptr);

        len = (nlen / 8 + (nlen % 8 ? 1: 0)) * 8;

        ch = 8 - nlen % 8;
        memset(src + nlen, ch, (8 - nlen % 8) % 8);


        memcpy(ivec, ivsetup, sizeof(ivsetup));
        /* 按照8字节数据进行加密，length=8 */
        for (i = 0; i < len; i += 8) {
            DES_ede3_cbc_encrypt(src + i, out + i, 8, &ks1, &ks2, &ks3, &ivec, DES_ENCRYPT);
        }


        const char *result[24];
        //const char *mR = new char[];
        printf("加密后数据: ");
        for (i = 0; i < len; i++) {
            //		printf("%02X" , *(out + i));
            result[i] = p->bin2hex((out + i),1);
        }
        QString mValue;
        //int valLen = strlen((char *)result);
        for (int j=0;j<len;j++)
        {
            QString temp(result[j]);
            mValue += temp;
        }
        printf(clText);
        return mValue;
}

//3Des_ecb加密
QString QDES::m3Des_ecb_encrypt(QString clText, QString key)
{

    QString mValue;
        QT_TRY
        {
            int i = 0;
            int len = 0;
            int nlen = 0;

            char ch = '\0';
            // 	char *key1 = "0000000000000000";  /* 原始密钥, 十六进制字符串 */
            // 	char *key2 = "0000000000000000";  /* 原始密钥, 十六进制字符串 */
            // 	char *key3 = "0000000000000000";  /* 原始密钥, 十六进制字符串 */
            // 	char *data = "12345678123456781234567812345678";  /* 原始明文, 十六进制字符串 */
            QString lKey,rKey;
            lKey = key.left(16);
            rKey = key.right(16);
            char *key1 = lKey.toLatin1().data();   /* 原始密钥, 十六进制字符串 */
            char *key2 = rKey.toLatin1().data();   /* 原始密钥, 十六进制字符串 */
            char *key3 = lKey.toLatin1().data();   /* 原始密钥, 十六进制字符串 */
            char *data = clText.toLatin1().data(); /* 原始明文, 十六进制字符串 */
            unsigned char src[64] = {0};
            unsigned char out[64] = {0};
            unsigned char tmp[64] = {0};

            unsigned char *ptr  = NULL;
            unsigned char block[8] = {0};

            DES_key_schedule ks1, ks2, ks3;

            /* 设置密码表 */
            ptr = p->hex2bin(key1, strlen(key1), &nlen);
            memcpy(block, ptr, sizeof(block));
            free(ptr);

            DES_set_key_unchecked((const_DES_cblock *)block, &ks1);

            ptr = p->hex2bin(key2, strlen(key2), &nlen);
            memcpy(block, ptr, sizeof(block));
            free(ptr);
            DES_set_key_unchecked((const_DES_cblock *)block, &ks2);

            ptr = p->hex2bin(key3, strlen(key3), &nlen);
            memcpy(block, ptr, sizeof(block));
            free(ptr);
            DES_set_key_unchecked((const_DES_cblock *)block, &ks3);

            ptr = p->hex2bin(data, strlen(data), &nlen);
            memcpy(src, ptr, nlen);
            free(ptr);

            len = (nlen / 8 + (nlen % 8 ? 1: 0)) * 8;

            ch = 8 - nlen % 8;
            memset(src + nlen, ch, (8 - nlen % 8) % 8);

            printf("加密前数据: ");
            for (i = 0; i < len; i++) {
                printf("%02X", *(src + i));
            }
            printf("\n");

            for (i = 0; i < len; i += 8) {
                DES_ecb3_encrypt((const_DES_cblock *)(src + i), (const_DES_cblock *)(out + i), &ks1, &ks2, &ks3, DES_ENCRYPT);
            }

            const char *result[79] ;

            /*把解密后的数据转成16进制数*/
            for (i = 0; i < len; i++) {
                result[i] = p->bin2hex((out + i),1);
            }

            /*再把解密的数据装成CString*/
            for (int j=0;j<len;j++)
            {
                QString temp(result[j]);
                mValue += temp;
            }

            return mValue;
        }
        QT_CATCH(Except ex)
        {
            if(ex == EXCEP_ZERO) QT_RETHROW;
            return mValue;
        }

}

//3Des_ecb解密
QString QDES::m3Des_ecb_decrypt(QString clText, QString key)
{
    QString mValue;
        QT_TRY
        {
            int i = 0;
            int len = 0;
            int nlen = 0;
            char ch = '\0';
            // 	char *key1 = "0000000000000000";  /* 原始密钥, 十六进制字符串 */
            // 	char *key2 = "0000000000000000";  /* 原始密钥, 十六进制字符串 */
            // 	char *key3 = "0000000000000000";  /* 原始密钥, 十六进制字符串 */
            // 	char *data = "12345678123456781234567812345678";  /* 原始明文, 十六进制字符串 */
            QString lKey,rKey;
            lKey = key.left(16);
            rKey = key.right(16);
            char *key1 = lKey.toLatin1().data();   /* 原始密钥, 十六进制字符串 */
            char *key2 = rKey.toLatin1().data();   /* 原始密钥, 十六进制字符串 */
            char *key3 = lKey.toLatin1().data();   /* 原始密钥, 十六进制字符串 */
            char *data = clText.toLatin1().data(); /* 原始明文, 十六进制字符串 */
            unsigned char src[64] = {0};
            unsigned char out[64] = {0};
            unsigned char tmp[64] = {0};

            unsigned char *ptr  = NULL;
            unsigned char block[8] = {0};
            DES_key_schedule ks1, ks2, ks3;

            /* 设置密码表 */
            ptr = p->hex2bin(key1, strlen(key1), &nlen);
            memcpy(block, ptr, sizeof(block));
            free(ptr);
            DES_set_key_unchecked((const_DES_cblock *)block, &ks1);

            ptr = p->hex2bin(key2, strlen(key2), &nlen);
            memcpy(block, ptr, sizeof(block));
            free(ptr);
            DES_set_key_unchecked((const_DES_cblock *)block, &ks2);

            ptr = p->hex2bin(key3, strlen(key3), &nlen);
            memcpy(block, ptr, sizeof(block));
            free(ptr);
            DES_set_key_unchecked((const_DES_cblock *)block, &ks3);

            ptr = p->hex2bin(data, strlen(data), &nlen);
            memcpy(src, ptr, nlen);
            free(ptr);

            len = (nlen / 8 + (nlen % 8 ? 1: 0)) * 8;

            ch = 8 - nlen % 8;
            memset(src + nlen, ch, (8 - nlen % 8) % 8);

            printf("加密前数据: ");
            for (i = 0; i < len; i++) {
                printf("%02X", *(src + i));
            }
            printf("\n");

            for (i = 0; i < len; i += 8) {
                DES_ecb3_encrypt((const_DES_cblock *)(src + i), (const_DES_cblock *)(out + i), &ks1, &ks2, &ks3, DES_DECRYPT);
            }
            QString mValue;
            const char *result[128] ;

            /*把解密后的数据转成16进制数*/
            for (i = 0; i < len; i++) {
                result[i] = p->bin2hex((out + i),1);
            }

            /*再把解密的数据装成CString*/
            for (int j=0;j<len;j++)
            {
                QString temp(result[j]);
                mValue += temp;
            }

            return mValue;
        }
        QT_CATCH(Except ex)
        {
            if(ex == EXCEP_ZERO) QT_RETHROW;
            return mValue;
    }
}


//QDes_cbc加密
QString QDES::mDes_cbc_encrypt(char *clText, char *key)
{
    QString mValue;
        QT_TRY
        {
            DES_key_schedule ks;
            DES_cblock ivec = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

            int i = 0;
            int len = 0;
            int nlen = 0;

            // 	char *data = "848200001082CD0CACFA92293B800000";  /* 原始明文, 十六进制字符串 */
            // 	char *okey = "D527FB5519C316C9";  /* 原始密钥, 十六进制字符串 */

            char *data = clText;  /* 原始明文, 十六进制字符串 */
            char *okey = key;  /* 原始密钥, 十六进制字符串 */  //赋值

            unsigned char ch = '\0';
            unsigned char *ptr = NULL;

            unsigned char src[16] = {0}; /* 补齐后的明文, data补齐后的1/2长度 */
            unsigned char dst[16] = {0}; /* 解密后的明文, data补齐后的1/2长度 */

            unsigned char block[8] = {0};

            /* 设置密码表 */
            ptr = p->hex2bin(okey, strlen(okey), &nlen);
            memcpy(block, ptr, 8);
            free(ptr);
            DES_set_key_unchecked((const_DES_cblock*)block, &ks);

            /* 分析补齐明文所需空间及补齐填充数据 */
            len = strlen((char *)data);
            ptr = p->hex2bin(data, len, &nlen);
            len = (nlen / 8 + (nlen % 8 ? 1: 0)) * 8;
            memcpy(src, ptr, len);
            free(ptr);

            ch = 8 - nlen % 8;
            memset(src + nlen, ch, 8 - nlen % 8);

            printf("加密之前: ");
            for (i = 0; i < len; i++) {
                printf("%.2X", *(src + i));
            }
            printf("\n");

            /* 加密块链式加密 */
            DES_ncbc_encrypt(src, dst, sizeof(src), &ks, &ivec, DES_ENCRYPT);

            //	unsigned char *result[16] ;
            const char *result[36] ;
            printf("加密之后: ");
            int j=0;
            /*把解密后的结果转成16进制数*/
            for (i = 0; i < len; i++) {
                result[i] = p->bin2hex((dst + i),1);

            }
            /*再把解密的数据转成CString*/

            //	int valLen = strlen((char *)result);
            for (int j=0;j<len;j++)
            {
                QString temp(result[j]);
                mValue += temp;
            }

            free(src);
            free(dst);

            return mValue;
        }
        QT_CATCH(Except ex)
        {
        if(ex == EXCEP_ZERO) QT_RETHROW;
        return mValue;
        }
}

//QDes_cbc解密
QString QDES::mDes_cbc_decrypt(char *clText, char *key)
{
    QString mValue;
        QT_TRY
        {
            DES_key_schedule ks;
            DES_cblock ivec = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

            int i = 0;
            int len = 0;
            int nlen = 0;

            // 	char *data = "848200001082CD0CACFA92293B800000";  /* 原始明文, 十六进制字符串 */
            // 	char *okey = "D527FB5519C316C9";  /* 原始密钥, 十六进制字符串 */

            char *data = clText;  /* 原始明文, 十六进制字符串 */
            char *okey = key;  /* 原始密钥, 十六进制字符串 */  //赋值

            unsigned char ch = '\0';
            unsigned char *ptr = NULL;

            unsigned char src[16] = {0}; /* 补齐后的明文, data补齐后的1/2长度 */
            unsigned char dst[16] = {0}; /* 解密后的明文, data补齐后的1/2长度 */

            unsigned char block[8] = {0};

            /* 设置密码表 */
            ptr = p->hex2bin(okey, strlen(okey), &nlen);
            memcpy(block, ptr, 8);
            free(ptr);
            DES_set_key_unchecked((const_DES_cblock*)block, &ks);

            /* 分析补齐明文所需空间及补齐填充数据 */
            len = strlen((char *)data);
            ptr = p->hex2bin(data, len, &nlen);
            len = (nlen / 8 + (nlen % 8 ? 1: 0)) * 8;
            memcpy(src, ptr, len);
            free(ptr);

            ch = 8 - nlen % 8;
            memset(src + nlen, ch, 8 - nlen % 8);

            printf("加密之前: ");
            for (i = 0; i < len; i++) {
                printf("%.2X", *(src + i));
            }
            printf("\n");

            /* 加密块链式加密 */
            DES_ncbc_encrypt(src, dst, sizeof(src), &ks, &ivec, DES_DECRYPT);

            //	unsigned char *result[16] ;
            const char *result[128] ;
            printf("加密之后: ");

            /*把解密后的结果转成16进制数*/
            for (i = 0; i < len; i++) {
                result[i] = p->bin2hex((dst + i),1);

            }
            /*再把解密的数据装成CString*/

            //	int valLen = strlen((char *)result);
            for (int j=0;j<len;j++)
            {
                QString temp(result[j]);
                mValue += temp;
            }

            //	free(src);
            free(dst);

            return mValue;
        }
        QT_CATCH(Except ex)
        {
        if(ex == EXCEP_ZERO) QT_RETHROW;
        return mValue;
        }

}

DES.h文件

#ifndef QDES_H
#define QDES_H

#include <QMainWindow>
#include <QObject>
#include <QWidget>
#include <openssl/ssl.h>
#include <openssl/sha.h>
#include <openssl/aes.h>
#include <openssl/des.h>
#include <openssl/hmac.h>
#include "HEX.h"

class QDES
{
public:
    QDES(void);
    ~QDES(void);

    QString m3Des_cbc_encrypt(char *clText,char *key1,char *key2,char *key3);
    QString m3Des_cbc_nokey_encrypt(char *clText,char *LKey,char *RKey);
    QString m3Des_ecb_encrypt(QString clText,QString key);
    QString m3Des_ecb_decrypt(QString clText,QString key);
    QString mDes_cbc_encrypt(char *clText,char *key);
    QString mDes_cbc_decrypt(char *clText,char *key);

    QHEX *p = new QHEX;
};

#endif // QDES_H

HEX.C文件

#include "HEX.h"

QHEX::QHEX()
{

}

/************************************************************************
 * 二进制字节数组转换十六进制字符串函数
 * 输入：
 *       data 二进制字节数组
 *       size 二进制字节数组长度
 * 输出：
 *       十六进制字符串，需要free函数释放空间，失败返回NULL
 *
 * author: tonglulin@gmail.com by www.qmailer.net
 ************************************************************************/
char *QHEX::bin2hex(unsigned char *data, int size)
{
    int  i = 0;
        int  v = 0;
        char *p = NULL;
        char *buf = NULL;
        char base_char = 'A';

        buf = p = (char *)malloc(size * 2 + 1);
        for (i = 0; i < size; i++) {
            v = data[i] >> 4;
            *p++ = v < 10 ? v + '0' : v - 10 + base_char;

            v = data[i] & 0x0f;
            *p++ = v < 10 ? v + '0' : v - 10 + base_char;
        }

        *p = '\0';
        return buf;
}


/************************************************************************
 * 十六进制字符串转换二进制字节数组
 * 输入：
 *       data 十六进制字符串
 *       size 十六进制字符串长度，2的倍数
 *       outlen 转换后的二进制字符数组长度
 * 输出：
 *       二进制字符数组，需要free函数释放空间，失败返回NULL
 *
 * author: tonglulin@gmail.com by www.qmailer.net
 ************************************************************************/
unsigned char *QHEX::hex2bin(const char *data, int size, int *outlen)
{
    int i = 0;
      int len = 0;
      char char1 = '\0';
      char char2 = '\0';
      unsigned char value = 0;
      unsigned char *out = NULL;

      if (size % 2 != 0) {
          return NULL;
      }

      len = size / 2;
      out = (unsigned char *)malloc(len * sizeof(char) + 1);
      if (out == NULL) {
          return NULL;
      }

      while (i < len) {
          char1 = *data;
          if (char1 >= '0' && char1 <= '9') {
              value = (char1 - '0') << 4;
          }
          else if (char1 >= 'a' && char1 <= 'f') {
              value = (char1 - 'a' + 10) << 4;
          }
          else if (char1 >= 'A' && char1 <= 'F') {
              value = (char1 - 'A' + 10) << 4;
          }
          else {
              free(out);
              return NULL;
          }
          data++;

          char2 = *data;
          if (char2 >= '0' && char2 <= '9') {
              value |= char2 - '0';
          }
          else if (char2 >= 'a' && char2 <= 'f') {
              value |= char2 - 'a' + 10;
          }
          else if (char2 >= 'A' && char2 <= 'F') {
              value |= char2 - 'A' + 10;
          }
          else {
              free(out);
              return NULL;
          }

          data++;
          *(out + i++) = value;
      }
      *(out + i) = '\0';

      if (outlen != NULL) {
          *outlen = i;
      }

      return out;
}

#ifndef QHEX_H
#define QHEX_H

#include <QMainWindow>
#include <QObject>
#include <QWidget>

class QHEX
{
public:
    QHEX(void);
    ~QHEX(void);


    char *bin2hex(unsigned char *data, int size);

    unsigned char *hex2bin(const char *data, int size, int *outlen);
};

#endif // QHEX_H

在博主资源里有win 32 位的openssl三方库的下载，自取不客气，麻烦给个小小的赞~

不吃蛋黄啊
关注
DES加解密算法Qt实现
tandesir的专栏
10-07 1万+
【声明】 (1) 本文源码 大部分源码来自：DES算法代码。在此基础上，利用Qt编程进行了改写，实现了DES加解密算法，并添加了文件加解密功能。在此对署名为bengold1979的网友表示感谢！本文是对DES算法代码一文代码的具体描述。该源码仅供学习交流，请勿用于商业目的。 (2) 图片及描述 图片及部分解析来自 http://zh.wikipedia.org/wiki/%E8%B3%8
openssl qt 生成秘钥_QT中运用Openssl DES加密算法
weixin_32487755的博客
01-28 859
QT并没有自带的加解密工具，网上有用Qt开源加解密插件，有自己实现加解密算法功能的。因博主之前的文章已经用C++编写过一个DES加密算法，这里就不再用QT重复一遍了。本文介绍了在QT中运用OPENSSL开源加解密库的DES算法，和着重提醒几个容易出错的地方，其他算法的运用与此类似。一、配置环境运用VS2014平台配置Openssl环境已经在之前讲过，如有不懂，可以二、选择加解密模式电子密码本模式E...
qt实现DES加解密
qq_44744263的博客
08-09 275
在Qt中实现DES加密通常需要使用OpenSSL库。确保你的系统上已经安装了OpenSSL库。如果没有安装，可以通过包管理器进行安装。在这个示例中，我们首先设置DES密钥，然后使用DES_ecb_encrypt函数进行加密和解密。
Qt写的DES加密算法展示程序
12-27
一个用Qt编写简单DES加密算法展示程序，可以实现简单的8位16轮加密变换
QT做的DES加解密实例
02-09
之前在CSDN下载了个DES例子，在调试的过程中发现有个BUG，就重新找资源更改了下，上传出来供参考，所参考的资源参考文件中readme
DES算法C++、QT实现（有图形界面）
dzn的博客
06-01 6382
总共 7 个文件。其中一个编译配置文件 (DES.pro) ;两个类: DES_UI 、 DesCrypt ;两个类共四个 文件,分别为 DES_UI.h 、 DesCrypt.h 、 DES_UI.cpp 、 DesCrypt.cpp ;一个 GUI 文件: DES_UI.ui ;还有一个主函数 main.cpp 。
C语言使用openSSL库DES模块实现加密功能详解
08-30
C语言使用openSSL库DES模块实现加密功能详解 在本文中，我们将详细介绍C语言使用openSSL库DES模块实现加密功能的相关知识点。首先，我们需要了解DES加密的基本概念。DES（Data Encryption Standard）是一种对称加密...
基于C++和OpenSSL库的PBKDF算法实现源码.zip
最新发布
09-19
基于C++和OpenSSL库的PBKDF算法实现源码.zip基于C++和OpenSSL库的PBKDF算法实现源码.zip基于C++和OpenSSL库的PBKDF算法实现源码.zip基于C++和OpenSSL库的PBKDF算法实现源码.zip基于C++和OpenSSL库的PBKDF算法实现...
QTwindows下OpenSSL的使用
01-09
OpenSSL是一个强大的安全套接层（SSL）和传输层安全（TLS）协议实现，同时也包含了许多常用的加密算法、证书处理等功能。本教程将详细介绍如何在Qt Windows平台下配置和使用OpenSSL。 首先，你需要下载适用于...
Qt实现DES ECB加密解密
qq_18822805的博客
05-19 2091
使用MinGW编译OpenSSL，通过Qt实现DES ECB模式加密解密。
C++调用openssl实现DES加密解密cbc模式 zeropadding填充方式 pkcs5padding填充方式 pkcs7padding填充方式...
weixin_30388677的博客
12-26 1657
============================================== 　　　　des cbc 加密　zeropadding填充方式 ============================================== //加密 cbc zeropadding 自己实现 std::string des_cbc_zero_encrypt(const s...
Qt_5.7.0_DES.rar
11-07
基于Qt.5.7实现的对字符串进行DES算法的16位16进制输入数据进行加密和解密的小程序。
qt下加密算法EVP函数系列之DES加解密程序
08-18
利用Openssl库结合QT平台，使用EVP系列函数用DES加解密方法对明文进行加密，刻字机调节密钥，明文，还可以修改成3DES加解密方式
Des_Qt项目
08-25
通过自己对DES加密解密算法的学习和理解，用Qt实现的对16位16进制输入数据进行加密和解密的小程序。流程和注释非常详细，跟着流程，肯定是能看懂的。
Qt DES_ECB加密解密类
03-25
Qt DES_ECB加密解密类，JAVA PHP通用，qt5可用！
DES加解密算法
10-03
基于Qt编写的DES加密算法，博客中有详细解释。通过改写他人的代码，加入了加密文件等功能。
Qt之OpenSSL
weixin_33946020的博客
06-08 1217
简述 OpenSSL是一个强大的安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及SSL协议，并提供丰富的应用程序供测试或其它目的使用。 简述 下载安装 使用 更多参考 下载安装 进入Win32 OpenSSL下载页面，选择适合自己的版本进行下载。 下载完成之后进行安装，我选择的目录为D...
DES算法（C++实现）
PTkin的博客
04-14 2536
DES算法的本质就是置换，通过多轮次多变化的置换将64bit的数据加密成密文，从而达到除了暴力破解（遍历密钥）之外没有其他（足够高效的）解法的目的。DES算法的相关原理网上都有比较详尽的描述，理解起来并不困难，只是实现起来稍有点麻烦，一不小心就有可能出错。在我实现的过程中主要参考了网上的一篇 博客，实现之后的结果可以正常加密出结果，解密之后也可以得出原文，同时具有雪崩效应。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值