标签：10 DES 09 nlen char 2021 data ptr block

QT三方库 Openssl Des 算法实现

DECcpp文件

#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

标签：10,DES,09,nlen,char,2021,data,ptr,block
来源： https://blog.csdn.net/weixin_45976607/article/details/120225790

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。