C/C++: 3DES-ECB模式加密，可以与C#和Java互通

最新推荐文章于 2020-06-16 00:10:56 发布
最新推荐文章于 2020-06-16 00:10:56 发布
阅读量4.5k 收藏 9
点赞数 2
分类专栏： c/c++ 文章标签： 3des 加密 数据 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/slaron/article/details/56013222
版权

在开发过程中经常会射击到对数据的加密处理，常用的加密方式有Aes和Des，Aes/Des加密速度快，适合大量数据，Des容易破解,一般用3重Des即TripleDes。

在项目开发时从网上找了很多例子，大部分只能单平台运行，或者文件不全，本人这样的新手来说对于加密算法还是望而生畏的。后来找了一些资料，然后整合了一下别人的代码（加密核心代码的原作者:黄双全，如有侵权请告知，会及时处理），实现了3DES-ECB的加密方法。

最喜欢的就是：直接上代码

1、头文件des.h

#ifndef _DES_H_
#define _DES_H_
#include <string>
#include <sstream>
using namespace std;

//为了提高程序效率，把这两个位操作功能定义在宏。

//读取缓冲区的指定位.
#define GET_BIT(p_array, bit_index)  \
((p_array[(bit_index) >> 3] >> (7 - ((bit_index) & 0x07))) & 0x01)

//设置缓冲区的指定位.
#define SET_BIT(p_array, bit_index, bit_val) \
if (1 == (bit_val)) \
{\
p_array[(bit_index) >> 3] |= 0x01 << (7 - ((bit_index) & 0x07));\
}\
else\
{\
p_array[(bit_index) >> 3] &= ~(0x01 << (7 - ((bit_index) & 0x07)));\
}

//加解密标识，这两个标识涉及到对表的读取位置,
//必须保证DES_ENCRYPT = 0 DES_DECRYPT = 1
typedef enum {
    DES_ENCRYPT = 0, DES_DECRYPT = 1
} DES_MODE;

//key
typedef enum {
    //1key模式 等同于des
    KEY_16,
    //2key模式 key1 ＝ key3
    KEY_32,
    //3key模式
    KEY_48,
    KEY_ERROR
} KEYMODE;

class Des {
private:
    std::string deskey;
private:
    //字符输出处理
    void print_binary(char * tip, unsigned char * buff, unsigned char bits);
    void print_hex(char * tip, unsigned char * buff, unsigned char bytes);
    ///
    //  函 数 名 : des
    //  函数功能 : DES加解密
    //  处理过程 : 根据标准的DES加密算法用输入的64位密钥对64位密文进行加/解密
    //              并将加/解密结果存储到p_output里
    //  时    间 : 2006年9月2日
    //  返 回 值 :
    //  参数说明 :  const char * p_data     输入, 加密时输入明文, 解密时输入密文, 64位(8字节)
    //              const char * p_key      输入, 密钥, 64位(8字节)
    //              char * p_output         输出, 加密时输出密文, 解密时输入明文, 64位(8字节)
    //              unsigned char mode              0 加密  1 解密
    ///
    void des(const char * p_data, const char * p_key, const char * p_output,
            DES_MODE mode);
    //对两块大小相同的内存区进行异或
    //异或结果保存到第一块内存
    //unsigned char * p_buf_1       内存区1
    //const unsigned char * p_buf_2 内存区2
    //unsigned char bytes           内存区大小(单位：字节)
    void Xor(unsigned char * p_buf_1, const unsigned char * p_buf_2,
            unsigned char bytes);
    //将缓冲区从第bit_start位到第bit_end进行循环左移
    //offset只能是1，2
    void move_left(unsigned char * p_input, unsigned char bit_start,
            unsigned char bit_end, unsigned char offset);
    //将缓冲区从第bit_start位到第bit_end进行循环右移
    //offset只能是1，2
    void move_right(unsigned char * p_input, unsigned char bit_start,
            unsigned char bit_end, unsigned char offset);
    //缓冲区移位
    //offset大于0时左移
    //offset小于0时右移
    void move_bits(unsigned char * p_input, unsigned char bit_start,
            unsigned char bit_end, char offset);
    //通用置换函数, bits <= 64
    //p_input与p_output不能指向同一个地址，否则置换会出错。
    void Permutation(unsigned char * p_input, unsigned char * p_output,
            const unsigned char * Table, unsigned char bits);
    //获取从bit_s为起始的第1, 6 位组成行
    unsigned char S_GetLine(unsigned char * p_data_ext, unsigned char bit_s);
    //获取从bit_s为起始的第2,3,4,5位组成列
    unsigned char S_GetRow(unsigned char * p_data_ext, unsigned char bit_s);

    /************************************************************************
     *功能：字符串转换为16进制表示，每两位为一组
     ************************************************************************/
    unsigned char* str_to_hex(const std::string& str);
    /************************************************************************
     *功能：获得3DES分组的key
     ************************************************************************/
    unsigned char *getKey1(std::string key);
    unsigned char *getKey2(std::string key);
    unsigned char *getKey3(std::string key);
    /************************************************************************
     *功能：数组清空
     ************************************************************************/
    void clearBuff(char *buff, int length);
    /*编码
     DataByte
     [in]输入的数据长度,以字节为单位
     */
    std::string base64Encode(const unsigned char* Data, int DataByte);
    /*解码
     DataByte
     [in]输入的数据长度,以字节为单位
     OutByte
     [out]输出的数据长度,以字节为单位,请不要通过返回值计算
     输出数据的长度
     */
    std::string base64Decode(const char* Data, int DataByte, int& OutByte);

    //功能：URL字符转换
    unsigned char ToHex(unsigned char x);
    unsigned char FromHex(unsigned char x);
    //功能：URL-ENCODE编码
    std::string UrlEncode(const std::string& str);
    //功能：URL-DECODE解码
    std::string UrlDecode(const std::string& str);

    //替换字符串
    std::string replaceAllSubStr(string &str, string &oldStr, string &newStr);

    //检查key的长度，返回加密模式
    KEYMODE checkKey();
    KEYMODE checkKey(std::string key);

public:
    Des() {
    }
    ;
    Des(std::string key) {
        deskey = key;
    }
    ;

    ~Des() {
        deskey = nullptr;
    }
    ;
    /************************************************************************
     *功能：3DES-ECB加密
     ************************************************************************/
    std::string desEncrypt(std::string str);

    /************************************************************************
     *功能：3DES-ECB解密
     ************************************************************************/
    std::string desDecrypt(std::string str);

};
#endif //#ifndef _DES_H_

2、实现des.cpp

#include "des.h"

// 初始置换
const unsigned char Table_IP[64] = { 58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44,
        36, 28, 20, 12, 4, 62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32,
        24, 16, 8, 57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
        61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7 };

// 末置换
const unsigned char Table_InverseIP[64] = { 40, 8, 48, 16, 56, 24, 64, 32, 39,
        7, 47, 15, 55, 23, 63, 31, 38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13,
        53, 21, 61, 29, 36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19,
        59, 27, 34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25 };

// 扩展置换
const unsigned char Table_E[48] = { 32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, 8, 9,
        10, 11, 12, 13, 12, 13, 14, 15, 16, 17, 16, 17, 18, 19, 20, 21, 20, 21,
        22, 23, 24, 25, 24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1 };

// 密钥初始置换
const unsigned char Table_PC1[56] = { 57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42,
        34, 26, 18, 10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36, 63,
        55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45,
        37, 29, 21, 13, 5, 28, 20, 12, 4 };

// 左右移运算
const signed char Table_Move[2][16] = {
//加密左移
        { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 },

        //解密右移
        { 0, -1, -2, -2, -2, -2, -2, -2, -1, -2, -2, -2, -2, -2, -2, -1 } };

// 密钥压缩置换
const unsigned char Table_PC2[48] = { 14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21,
        10, 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2, 41, 52, 31, 37, 47, 55,
        30, 40, 51, 45, 33, 48, 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32 };

// S盒
const unsigned char Table_SBOX[8][4][16] = {
        // S1
        14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7, 0, 15, 7, 4, 14,
        2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8, 4, 1, 14, 8, 13, 6, 2, 11, 15, 12,
        9, 7, 3, 10, 5, 0, 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,
        // S2
        15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10, 3, 13, 4, 7, 15,
        2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5, 0, 14, 7, 11, 10, 4, 13, 1, 5, 8,
        12, 6, 9, 3, 2, 15, 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14,
        9,
        // S3
        10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8, 13, 7, 0, 9, 3, 4,
        6, 10, 2, 8, 5, 14, 12, 11, 15, 1, 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2,
        12, 5, 10, 14, 7, 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,
        // S4
        7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15, 13, 8, 11, 5, 6,
        15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9, 10, 6, 9, 0, 12, 11, 7, 13, 15, 1,
        3, 14, 5, 2, 8, 4, 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,
        // S5
        2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9, 14, 11, 2, 12, 4,
        7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6, 4, 2, 1, 11, 10, 13, 7, 8, 15, 9,
        12, 5, 6, 3, 0, 14, 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5,
        3,
        // S6
        12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11, 10, 15, 4, 2, 7,
        12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8, 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4,
        10, 1, 13, 11, 6, 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,
        // S7
        4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1, 13, 0, 11, 7, 4,
        9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6, 1, 4, 11, 13, 12, 3, 7, 14, 10, 15,
        6, 8, 0, 5, 9, 2, 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,
        // S8
        13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7, 1, 15, 13, 8, 10,
        3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2, 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10,
        13, 15, 3, 5, 8, 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 };

// P盒置换
const unsigned char Table_P[32] = { 16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23,
        26, 5, 18, 31, 10, 2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4,
        25 };

//检查key的长度，返回加密模式
KEYMODE Des::checkKey() {
    if (deskey.length() != 0) {
        if (deskey.length() != 32 && deskey.length() != 48) {
            printf("key输入不正确，请输入32位key或者48位key");
            return KEY_ERROR;
        }

        if (deskey.length() % 2 != 0) {
            printf("请检查输入的位数是否是偶数位");
            return KEY_ERROR;
        }

        if (deskey.length() == 32) {
            return KEY_32;
        }

        if (deskey.length() == 48) {
            return KEY_48;
        }
    } else {
        return KEY_ERROR;
    }
    return KEY_ERROR;
}

KEYMODE Des::checkKey(std::string key) {
    deskey = key;

    if (deskey.length() != 32 && deskey.length() != 48) {
        printf("key输入不正确，请输入32位key或者48位key");
        return KEY_ERROR;
    }

    if (deskey.length() % 2 != 0) {
        printf("请检查输入的位数是否是偶数位");
        return KEY_ERROR;
    }

    if (deskey.length() == 32) {
        return KEY_32;
    }

    if (deskey.length() == 48) {
        return KEY_48;
    }
    return KEY_ERROR;
}

void Des::print_binary(char * tip, unsigned char * buff, unsigned char bits) {
    unsigned char bit_index = 0;

    printf("\r\n****** start %s ******\r\n", tip);

    for (bit_index = 0; bit_index < bits; bit_index++) {
        printf("%d", (buff[bit_index >> 3] >> (7 - (bit_index % 8))) & 0x01);

        if ((bit_index + 1) % 4 == 0) {
            printf(" ");
        }

        if ((bit_index + 1) % 64 == 0) {
            printf("\r\n");
        }
    }

    printf("\r\n****** end %s ******\r\n", tip);
}

void Des::print_hex(char * tip, unsigned char * buff, unsigned char bytes) {
    unsigned char byte_index = 0;

    printf("\r\n %s", tip);

    for (byte_index = 0; byte_index < bytes; byte_index++) {
        //LOGI("0x%0.2X ", buff[byte_index]);
    }
}

//对两块大小相同的内存区进行异或
//异或结果保存到第一块内存
//unsigned char * p_buf_1       内存区1
//const unsigned char * p_buf_2 内存区2
//unsigned char bytes           内存区大小(单位：字节)
void Des::Xor(unsigned char * p_buf_1, const unsigned char * p_buf_2,
        unsigned char bytes) {
    while (bytes > 0) {
        bytes--;

        p_buf_1[bytes] ^= p_buf_2[bytes];
    }
}

//将缓冲区从第bit_start位到第bit_end进行循环左移
//offset只能是1，2
//本段代码还可以优化。
void Des::move_left(unsigned char * p_input, unsigned char bit_start,
        unsigned char bit_end, unsigned char offset) {
    unsigned char b_val = 0;
    unsigned char b_tmp1 = 0;
    unsigned char b_tmp2 = 0;

    //读取bit_start位
    b_tmp1 = GET_BIT(p_input, bit_start);
    b_tmp2 = GET_BIT(p_input, bit_start + 1);

    //循环左移offset位
    for (; bit_start <= (bit_end - offset); bit_start++) {
        b_val = GET_BIT(p_input, bit_start + offset);
        SET_BIT(p_input, bit_start, b_val);
    }

    //将bit_start开始的offset位移到bit_end后头来
    if (1 == offset) {
        SET_BIT(p_input, bit_end, b_tmp1);
    } else {
        SET_BIT(p_input, bit_end, b_tmp2);
        SET_BIT(p_input, bit_end - 1, b_tmp1);
    }
}

//将缓冲区从第bit_start位到第bit_end进行循环右移
//offset只能是1，2
//本段代码在性能上还可以优化。
void Des::move_right(unsigned char * p_input, unsigned char bit_start,
        unsigned char bit_end, unsigned char offset) {
    unsigned char b_val = 0;
    unsigned char b_tmp1 = 0;
    unsigned char b_tmp2 = 0;

    //读取bit_end位
    b_tmp1 = GET_BIT(p_input, bit_end);
    b_tmp2 = GET_BIT(p_input, bit_end - 1);

    //循环左移offset位
    for (; bit_end >= (bit_start + offset); bit_end--) {
        b_val = GET_BIT(p_input, bit_end - offset);
        SET_BIT(p_input, bit_end, b_val);
    }

    //将bit_end倒数的offset位移到bit_start来
    if (1 == offset) {
        SET_BIT(p_input, bit_start, b_tmp1);
    } else {
        SET_BIT(p_input, bit_start, b_tmp2);
        SET_BIT(p_input, bit_start + 1, b_tmp1);
    }
}

//缓冲区移位
//offset大于0时左移
//offset小于0时右移
void Des::move_bits(unsigned char * p_input, unsigned char bit_start,
        unsigned char bit_end, char offset) {
    if (0 < offset) //左移
            {
        move_left(p_input, bit_start, bit_end, offset);
    } else if (0 > offset) //右移
            {
        move_right(p_input, bit_start, bit_end, -offset);
    }
}

//通用置换函数, bits <= 64
//p_input与p_output不能指向同一个地址，否则置换会出错。
void Des::Permutation(unsigned char * p_input, unsigned char * p_output,
        const unsigned char * Table, unsigned char bits) {
    unsigned char b_val = false;
    unsigned char bit_index = 0;

    for (bit_index = 0; bit_index < bits; bit_index++) {
        b_val = GET_BIT(p_input, Table[bit_index] - 1);

        SET_BIT(p_output, bit_index, b_val);
    }
}

//获取从bit_s为起始的第1, 6 位组成行
unsigned char Des::S_GetLine(unsigned char * p_data_ext, unsigned char bit_s) {
    return (GET_BIT(p_data_ext, bit_s + 0) << 1)
            + GET_BIT(p_data_ext, bit_s + 5);
}

//获取从bit_s为起始的第2,3,4,5位组成列
unsigned char Des::S_GetRow(unsigned char * p_data_ext, unsigned char bit_s) {
    unsigned char row;

    //2,3,4,5位组成列
    row = GET_BIT(p_data_ext, bit_s + 1);
    row <<= 1;
    row += GET_BIT(p_data_ext, bit_s + 2);
    row <<= 1;
    row += GET_BIT(p_data_ext, bit_s + 3);
    row <<= 1;
    row += GET_BIT(p_data_ext, bit_s + 4);

    return row;
}

///
//  函 数 名 : des
//  函数功能 : DES加解密
//  处理过程 : 根据标准的DES加密算法用输入的64位密钥对64位密文进行加/解密
//              并将加/解密结果存储到p_output里
//  时    间 : 2006年9月2日
//  返 回 值 :
//  参数说明 :  const char * p_data     输入, 加密时输入明文, 解密时输入密文, 64位(8字节)
//              const char * p_key      输入, 密钥, 64位(8字节)
//              char * p_output         输出, 加密时输出密文, 解密时输入明文, 64位(8字节)
//              unsigned char mode              DES_ENCRYPT 加密  DES_DECRYPT 解密
///
void Des::des(const char * p_data, const char * p_key, const char * p_output,
        DES_MODE mode) {
    unsigned char loop = 0; //16轮运算的循环计数器
    unsigned char key_tmp[8]; //密钥运算时存储中间结果
    unsigned char sub_key[6]; //用于存储子密钥

    unsigned char * p_left;
    const char* p_right;

    unsigned char p_right_ext[8]; //R[i]经过扩展置换生成的48位数据(6字节), 及最终结果的存储
    unsigned char p_right_s[4]; //经过S_BOX置换后的32位数据(4字节)

    unsigned char s_loop = 0; //S_BOX置换的循环计数器

    //密钥第一次缩小换位, 得到一组56位的密钥数据
    Permutation((unsigned char*) p_key, key_tmp, Table_PC1, 56);

    //明文初始化置换
    Permutation((unsigned char*) p_data, (unsigned char*) p_output, Table_IP,
            64);

    p_left = (unsigned char*) p_output; //L0
    p_right = &p_output[4]; //R0

    for (loop = 0; loop < 16; loop++) {
        //把缩进小后的把这56位分为左28位和右28位,
        //对左28位和右28位分别循环左/右移, 得到一组新数据
        //加解密操作时只在移位时有差异
        move_bits(key_tmp, 0, 27, Table_Move[mode][loop]);
        move_bits(key_tmp, 28, 55, Table_Move[mode][loop]);

        //密钥第二次缩小换位，得到一组子48位的子密钥
        Permutation(key_tmp, sub_key, Table_PC2, 48);

        //R0扩展置换
        Permutation((unsigned char*) p_right, p_right_ext, Table_E, 48);

        //将R0扩展置换后得到的48位数据(6字节)与子密钥进行异或
        Xor(p_right_ext, sub_key, 6);

        //S_BOX置换
        for (s_loop = 0; s_loop < 4; s_loop++) {
            unsigned char s_line = 0;
            unsigned char s_row = 0;
            unsigned char s_bit = s_loop * 12;

            s_line = S_GetLine(p_right_ext, s_bit);
            s_row = S_GetRow(p_right_ext, s_bit);

            p_right_s[s_loop] = Table_SBOX[s_loop * 2][s_line][s_row];

            s_bit += 6;

            s_line = S_GetLine(p_right_ext, s_bit);
            s_row = S_GetRow(p_right_ext, s_bit);

            p_right_s[s_loop] <<= 4;
            p_right_s[s_loop] += Table_SBOX[(s_loop * 2) + 1][s_line][s_row];
        }

        //P置换
        Permutation(p_right_s, p_right_ext, Table_P, 32);

        Xor(p_right_ext, p_left, 4);

        memcpy(p_left, (unsigned char*) p_right, 4);
        memcpy((unsigned char*) p_right, p_right_ext, 4);
    }

    memcpy(&p_right_ext[4], p_left, 4);
    memcpy(p_right_ext, p_right, 4);

    //最后再进行一次逆置换, 得到最终加密结果
    Permutation(p_right_ext, (unsigned char*) p_output, Table_InverseIP, 64);
}

/************************************************************************
 *功能：字符串转换为16进制表示，每两位为一组
 ************************************************************************/
unsigned char* Des::str_to_hex(const std::string& str) {
    unsigned char *buff = NULL;
    int size = sizeof(unsigned char *) * str.length() / 2;
    buff = (unsigned char*) malloc(size);
    memset((void*) buff, 0, size);

    std::stringstream ss;
    ss << std::hex;
    for (int i = 0; i != str.size() / 2; ++i) {
        int val = 0;
        ss << str.substr(i * 2, 2);
        ss >> val;
        buff[i] = val;
        ss.clear();
    }
    return buff;
}

/************************************************************************
 *功能：获得3DES分组的key
 ************************************************************************/
unsigned char *Des::getKey1(std::string key) {
    unsigned char *key1;
    key1 = str_to_hex(key.substr(0, 16));
    return key1;
}

unsigned char *Des::getKey2(std::string key) {
    unsigned char *key2;
    key2 = str_to_hex(key.substr(16, 32));
    return key2;
}

unsigned char *Des::getKey3(std::string key) {
    unsigned char *key3;
    key3 = str_to_hex(key.substr(32, 48));
    return key3;
}

/************************************************************************
 *功能：数组清空
 ************************************************************************/
void Des::clearBuff(char *buff, int length) {
    for (int i = 0; i < length; i++) {
        buff[i] = '\0';
    }
}

std::string Des::base64Encode(const unsigned char* Data, int DataByte) {
    //编码表
    const char EncodeTable[] =
            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    //返回值
    std::string strEncode;
    unsigned char Tmp[4] = { 0 };
    int LineLength = 0;
    for (int i = 0; i < (int) (DataByte / 3); i++) {
        Tmp[1] = *Data++;
        Tmp[2] = *Data++;
        Tmp[3] = *Data++;
        strEncode += EncodeTable[Tmp[1] >> 2];
        strEncode += EncodeTable[((Tmp[1] << 4) | (Tmp[2] >> 4)) & 0x3F];
        strEncode += EncodeTable[((Tmp[2] << 2) | (Tmp[3] >> 6)) & 0x3F];
        strEncode += EncodeTable[Tmp[3] & 0x3F];
        if (LineLength += 4, LineLength == 76) {
            strEncode += "\r\n";
            LineLength = 0;
        }
    }
    //对剩余数据进行编码
    int Mod = DataByte % 3;
    if (Mod == 1) {
        Tmp[1] = *Data++;
        strEncode += EncodeTable[(Tmp[1] & 0xFC) >> 2];
        strEncode += EncodeTable[((Tmp[1] & 0x03) << 4)];
        strEncode += "==";
    } else if (Mod == 2) {
        Tmp[1] = *Data++;
        Tmp[2] = *Data++;
        strEncode += EncodeTable[(Tmp[1] & 0xFC) >> 2];
        strEncode +=
                EncodeTable[((Tmp[1] & 0x03) << 4) | ((Tmp[2] & 0xF0) >> 4)];
        strEncode += EncodeTable[((Tmp[2] & 0x0F) << 2)];
        strEncode += "=";
    }

    return strEncode;
}

std::string Des::base64Decode(const char* Data, int DataByte, int& OutByte) {
    //解码表
    const char DecodeTable[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0,
            62, // '+'
            0, 0, 0,
            63, // '/'
            52, 53, 54, 55, 56, 57, 58, 59, 60,
            61, // '0'-'9'
            0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
            14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
            25, // 'A'-'Z'
            0, 0, 0, 0, 0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
            38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // 'a'-'z'
            };
    //返回值
    std::string strDecode;
    int nValue;
    int i = 0;
    while (i < DataByte) {
        if (*Data != '\r' && *Data != '\n') {
            nValue = DecodeTable[*Data++] << 18;
            nValue += DecodeTable[*Data++] << 12;
            strDecode += (nValue & 0x00FF0000) >> 16;
            OutByte++;
            if (*Data != '=') {
                nValue += DecodeTable[*Data++] << 6;
                strDecode += (nValue & 0x0000FF00) >> 8;
                OutByte++;
                if (*Data != '=') {
                    nValue += DecodeTable[*Data++];
                    strDecode += nValue & 0x000000FF;
                    OutByte++;
                }
            }
            i += 4;
        } else // 回车换行,跳过
        {
            Data++;
            i++;
        }
    }
    return strDecode;
}

/************************************************************************
 *功能：URL字符转换
 ************************************************************************/
unsigned char Des::ToHex(unsigned char x) {
    return x > 9 ? x + 55 : x + 48;
}

unsigned char Des::FromHex(unsigned char x) {
    unsigned char y = NULL;
    if (x >= 'A' && x <= 'Z')
        y = x - 'A' + 10;
    else if (x >= 'a' && x <= 'z')
        y = x - 'a' + 10;
    else if (x >= '0' && x <= '9')
        y = x - '0';
    return y;
}

/************************************************************************
 *功能：URL-ENCODE编码
 ************************************************************************/
std::string Des::UrlEncode(const std::string& str) {
    std::string strTemp = "";
    size_t length = str.length();
    for (size_t i = 0; i < length; i++) {
        if (isalnum((unsigned char) str[i]) || (str[i] == '-')
                || (str[i] == '_') || (str[i] == '.') || (str[i] == '~'))
            strTemp += str[i];
        else if (str[i] == ' ')
            strTemp += "+";
        else {
            strTemp += '%';
            strTemp += ToHex((unsigned char) str[i] >> 4);
            strTemp += ToHex((unsigned char) str[i] % 16);
        }
    }
    return strTemp;
}

/************************************************************************
 *功能：URL-DECODE解码
 ************************************************************************/
std::string Des::UrlDecode(const std::string& str) {
    std::string strTemp = "";
    size_t length = str.length();
    for (size_t i = 0; i < length; i++) {
        if (str[i] == '+')
            strTemp += ' ';
        else if (str[i] == '%') {
            //assert(i + 2 < length);
            unsigned char high = FromHex((unsigned char) str[++i]);
            unsigned char low = FromHex((unsigned char) str[++i]);
            strTemp += high * 16 + low;
        } else
            strTemp += str[i];
    }
    return strTemp;
}

//替换字符串
std::string Des::replaceAllSubStr(string &str, string &oldStr, string &newStr) {
    while (true) {
        string::size_type pos(0);
        if ((pos = str.find(oldStr)) != string::npos) {
            str.replace(pos, oldStr.length(), newStr);
        } else {
            break;
        }
    }
    return str;
}

/************************************************************************
 *功能：3DES-ECB加密
 ************************************************************************/
std::string Des::desEncrypt(std::string str) {
    auto mode = checkKey(deskey);
    if (mode == KEY_ERROR) {
        return nullptr;
    }

    int block = 0;
    int len = str.length();
    std::string encode = "";
    std::string result = "";

    char *key1 = NULL;
    char *key2 = NULL;
    char *key3 = NULL;
    if (mode == KEY_16) {
        key1 = (char*) getKey1(deskey);
        key2 = (char*) getKey1(deskey);
        key3 = (char*) getKey1(deskey);
    }
    if (mode == KEY_32) {
        key1 = (char*) getKey1(deskey);
        key2 = (char*) getKey2(deskey);
        key3 = (char*) getKey1(deskey);
    }
    if (mode == KEY_48) {
        key1 = (char*) getKey1(deskey);
        key2 = (char*) getKey2(deskey);
        key3 = (char*) getKey3(deskey);
    }

    if (len % 8 == 0) {
        block = len / 8;
    } else {
        block = len / 8 + 1;
    }

    //LOGI("block = %d", block);
    unsigned char *result1 = NULL;
    int size = sizeof(unsigned char *) * 8 * block + 1;
    result1 = (unsigned char*) malloc(size);
    memset(result1, 0, size);

    //3DES 加密
    char en_out_put[9] = { 0 };
    char en_data[9] = { 0 };

    for (int i = 0; i < block; i++) {
        clearBuff(en_data, 9);
        if (i == block - 1) {
            if (len % 8 == 0) {
                memcpy(en_data, str.c_str() + (i * 8), 8);
            } else {
                memcpy(en_data, str.c_str() + (i * 8), len % 8);
            }
        } else {
            memcpy(en_data, str.c_str() + (i * 8), 8);
        }
        //LOGI("en_data = %s", en_data);
        des(en_data, key1, en_out_put, DES_ENCRYPT);
        des(en_out_put, key2, en_data, DES_DECRYPT);
        des(en_data, key3, en_out_put, DES_ENCRYPT);

        //result.append(en_out_put);
        for (int n = 0; n < 8; n++) {
            result1[(i * 8) + n] = en_out_put[n];
        }
    }
    encode = base64Encode((unsigned char*) result1, block * 8);
    //encode = base64Encode((unsigned char*) result.c_str(), block * 8);

    free(key1);
    free(key2);
    free(key3);

    free(result1);

    return encode;
}

/************************************************************************
 *功能：3DES-ECB解密
 ************************************************************************/
std::string Des::desDecrypt(std::string str) {
    auto mode = checkKey(deskey);
    if (mode == KEY_ERROR) {
        return nullptr;
    }

    char *key1 = NULL;
    char *key2 = NULL;
    char *key3 = NULL;
    if (mode == KEY_16) {
        key1 = (char*) getKey1(deskey);
        key2 = (char*) getKey1(deskey);
        key3 = (char*) getKey1(deskey);
    }
    if (mode == KEY_32) {
        key1 = (char*) getKey1(deskey);
        key2 = (char*) getKey2(deskey);
        key3 = (char*) getKey1(deskey);
    }
    if (mode == KEY_48) {
        key1 = (char*) getKey1(deskey);
        key2 = (char*) getKey2(deskey);
        key3 = (char*) getKey3(deskey);
    }

    int OutByte = 0;
    std::string decode = "";
    std::string result = "";

    decode = base64Decode(str.c_str(), str.length(), OutByte);

    //如果加密字符串经过解密后长度不为8的倍数，则返回NULL
    if(OutByte % 8 != 0) {
        //LOGI("OutByte = %d", OutByte);
        return "isWrongInput";
    }

    int block = 0;
    block = OutByte / 8;

    //3DES 加密
    char en_out_put[9] = { 0 };
    char en_data[9] = { 0 };

    for (int i = 0; i < block; i++) {
        memcpy(en_out_put, decode.c_str() + (i * 8), 8);
        des(en_out_put, key3, en_data, DES_DECRYPT);
        des(en_data, key2, en_out_put, DES_ENCRYPT);
        des(en_out_put, key1, en_data, DES_DECRYPT);
        result += en_data;
    }

    free(key1);
    free(key2);
    free(key3);

    return result;
}

3、使用方法

//十六进制的key，每16位为一组，共三组密钥组合为48位长度，如果之传入16位，将是des加密，32位2des，48位为3des加密，加密后的字符串已经经过base64编码
const char *TRIPLE_DES_KEY="000000000000000000000000000000000000000000000000";
auto my3Des=new des(TRIPLE_DES_KEY);
//加密
my3Des->desEncrypt("明文");
//解密
my3Des->desDecrypt("密文");

4、下载地址

3des加解密下载

胖胖的战士
关注
专栏目录
3DES加密和解密【c++】
qq_53682472的博客
08-29 337
再对文本进行解密，得到解密后.doc。对文本进行加密，生成的加密的文本。如需完整的代码请自行下载。随机给一段已有的文本。
java c语言 实现des算法_DES加密算法—实现(C语言)
weixin_42505246的博客
02-24 361
DES(Data Encrypt Standard数据库加密标准)是迄今为止使用最广泛的加密体制。初学信息安全的新生，一般都会被老师要求实现DES算法，如果老师不要求，那么有缘来我这里共同学习的朋友，我建议你用C去实现一下，C语言在信息安全领域很重要，更何况隶属于工科的信息安全，你只懂理论是远远不够的。想用其他语言实现的朋友，如果你用了汇编，那么请您老人家走开不要来看小弟的笑话。如果你用C++或者...
des 及3des ecb pkcs5padding 加密 c++
11-03
des 及3des ecb pkcs5padding 加密 c++ 输出结果非base64及hex 加密结果验证 http://tool.chacuo.net/crypt3des
3DES算法（数据补位）
wp763691的专栏
09-14 1008
这一篇文章要解决数据加密——数据补位的问题、DES算法的两种模式ECB和CBC问题以及更加安全的算法——3DES算法。 一、数据补位 DES数据加解密就是将数据按照8个字节一段进行DES加密或解密得到一段8个字节的密文或者明文，最后一段不足8个字节，按照需求补足8个字节（通常补00或者FF，根据实际要求不同）进行计算，之后按照顺序将计算所得的数据连在一起即可。 这里有个问题就是为什么要进...
AES/ECB---C++算法实现
ailugong8410的博客
05-15 300
　　密码学课后作业实现AES/ECB算法的实现，所以这几天都有在查一些AES资料，在此整理下并附上C++代码(: 　　这里引用一下维基上关于AES的基本介绍： AES加密过程是在一个4×4的字节矩阵上运作，这个矩阵又称为“体（state）”，其初值就是一个明文区块（矩阵中一个元素大小就是明文区块中的一个Byte）。（Rijndael加密法因支持更大的区块，其矩阵行数可视情况增加）加...
C++C#互通DES加密算法
10-12
采用DES的ECB电子密码本方式进行加密，暂时不支持中文，可自行扩展
3DES-ECB模式加密，可以与C#和Java互通
02-20
在描述中提到的“可以与C#和Java互通”，意味着实现的3DES-ECB加密代码在C/C++环境下编译运行后，其加密结果应该与C#和Java平台上的3DES-ECB加密算法得到的结果一致。这通常需要确保所有平台都遵循相同的密钥、初始...
c++,c#互通DES加密算法（支持中文）
08-17
5. **解密过程**：与加密类似，但使用解密函数，如C++的`des_ecb_decrypt()`和C#的`CreateDecryptor()`。 6. **编码恢复**：解密后，数据仍然是经过填充的二进制，需要去除填充并恢复原来的编码。 在实际项目中，...
c++和c#同时实现DES加密解密算法
09-17
在本文中，我们将深入探讨DES加密解密算法，并展示如何在C++和C#这两种编程语言中实现这一算法。 首先，理解DES的工作原理至关重要。DES算法主要由以下四个步骤组成：初始置换（IP）、密钥扩展、16轮Feistel网络和...
可以相互解密的C#版及C++版DES算法代码(包括ECB、CBC模式，Zeros、PKCS7填充，以及Base64编解码)
~~
09-10 6401
稍后补代码。
AES的五种加密模式（CBC、ECB、CTR、OCF、CFB）
weixin_30823683的博客
06-30 3638
AES五种加密模式（CBC、ECB、CTR、OCF、CFB） 分组密码有五种工作体制：1.电码本模式（ElectronicCodebookBook(ECB)）；2.密码分组链接模式（CipherBlockChaining(CBC)）；3.计算器模式（Counter(CTR)）；4.密码反馈模式（CipherFeedBack(CFB)）；5.输出反馈模式（Outpu...
c++ c#同时实现DES加密解密
09-17
c++和c#同时实现DES加密解密
3des_ECB算法
06-28
可直接运行使用的3des算法，vc6环境下C语言写得，常用于厂商之间的数据传递，挺好用的。
3DEC加密解密c++封装(实现ECB和BCB模式)
09-10
这段时间搜了网上很多c/c++ 3des的加解密源代码，有些实现错误(其他语言lib不能相互加解密)，有些实现封装得层次太低，感觉不好用。我在使用得比较多的开源程序d3des.c基础上封装了一个类，可以直接加密文件或者流数据，实现的加解密模式是ECB和BCB。资源中包含类的实现和vc的测试工程，这个类已经在windows,linux,vxworks下使用。
使用3DES-ECB 加解密算法对JSON数据进行加密
07-17
考虑到数据安全考虑，为防止数据泄漏，第三方系统请求发送请求时，采用 3DES-ECB 加解密算法对数据进行加密。
Java 3des加密算法ECB模式
11-10
Java 3des加密算法ECB模式，亲测完美通过。目前网上的大部分算法都通不过或者加进Base64之类的，还要不下载其它jar包。而代码使用时直接下载运行，无须配置和下载额外的jar包 ，只需换上自己的密钥和待加密的数据即可。
java与C++的DES加密与解密
iamhuzl的专栏
04-28 481
DES(Data Encryption Standard)算法，于1977年得到美国政府的正式许可，是一种用56位密钥来加密64位数据的方法。一般密码长度为8个字节，其中56位加密密钥，每个第8位都用作奇偶校验。 [b][color=orange]DES的几种工作方式[/color][/b] [color=orange][u] 第一种电子密本方式（ECB）[/u][/col...
微信小程序3DES加解密，ECB模式。
ethan
09-05 3013
因公司做的产品为金融项目，所以对数据安全性有很高要求，因为项目中的数据都会通过3DES 对称加密，和RSA非对称加密进行数据传输。 在这里先简单介绍一下什么是对称加密和非对称加密 对称加密：对称加密采用了对称密码编码技术，它的特点是文件加密和解密使用相同的密钥加密。 非对称加密：对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。（...
DES加密ECB模式的Java和C++实现
ccf19881030的专栏
06-16 2050
远程采集终端说明 一、方案详细说明 更新内容： 报文添加加密功能 使用终端： RTU 加密方式： DES加密 DES加密模式： ECB模式 填充方式： zeropadding 二、简单测试案例 密文(hex)： 8bb47a0cf0a9626d2b166ab8314d8fb5 密码： 12345678 对应明文： 0123456789 三、后台解析程序 约定密码： 12345678 解密程序： 前期已提供测试，备份在文件夹中。 1、对应的Java实现(ECB模式,zeropadding填充方式)代码
评论 20
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值