DES加密算法

已于 2022-11-26 14:09:46 修改
阅读量278 收藏
点赞数
于 2022-11-26 14:07:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57929980/article/details/128051379
版权

c++ 算法 安全

DES加密算法

#ifndef DES_H
#define DES_H
#include<iostream>
using namespace std;

typedef unsigned long long message;
message Plaintext, Ciphertext, Key;
typedef unsigned char u_char;
typedef enum { encipher, decipher }OPTION;
int bit_get(const u_char* bits, int byte) {
    return ((bits[byte / 8] & (0x80 >> (byte % 8))) != 0);
}
void bit_set(u_char* bits, int byte, int num) {
	if (num == 1)
	{
		bits[byte / 8] |= (0x80 >> (byte % 8));
	}
	else {
		bits[byte / 8] &= ~(0x80 >> (byte % 8));
	}
}
void print_bits(u_char* bits, int byte) {
    for (int i = 0; i < byte; i++) {
        cout << bit_get(bits, i);
    }
    cout << endl;
}
static u_char subkeys[16][7];
static const int 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
};
static const int IP_1[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
};
static const int LS[16] =
{
    1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
};
static const int 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
};
static const int 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
};
static const int Ebox[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
};
static const int Sbox[8][4][16] =
{
    {
        {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},
    },
    {
        {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},
    },
    {
        {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},
    },
    {
        {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},
    },
    {
        {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},
    },
    {
        {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},
    },
    {
        {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},
    },
    {
        {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},
    }
};
static const int Pbox[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
};
static struct des_test_case {
    int num, mode; // mode 1 = encrypt, 0 = decrypt
    unsigned char key[8], in[8], out[8];
} cases[] = {
    { 1, 1,     { 0x10, 0x31, 0x6E, 0x02, 0x8C, 0x8F, 0x3B, 0x4A },
                { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                { 0x82, 0xDC, 0xBA, 0xFB, 0xDE, 0xAB, 0x66, 0x02 } },
    { 2, 1,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x95, 0xF8, 0xA5, 0xE5, 0xDD, 0x31, 0xD9, 0x00 },
                { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
    { 3, 1,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0xDD, 0x7F, 0x12, 0x1C, 0xA5, 0x01, 0x56, 0x19 },
                { 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
    { 4, 1,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x2E, 0x86, 0x53, 0x10, 0x4F, 0x38, 0x34, 0xEA },
                { 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
    { 5, 1,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x4B, 0xD3, 0x88, 0xFF, 0x6C, 0xD8, 0x1D, 0x4F },
                { 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
    { 6, 1,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x20, 0xB9, 0xE7, 0x67, 0xB2, 0xFB, 0x14, 0x56 },
                { 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
    { 7, 1,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x55, 0x57, 0x93, 0x80, 0xD7, 0x71, 0x38, 0xEF },
                { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
    { 8, 1,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x6C, 0xC5, 0xDE, 0xFA, 0xAF, 0x04, 0x51, 0x2F },
                { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
    { 9, 1,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x0D, 0x9F, 0x27, 0x9B, 0xA5, 0xD8, 0x72, 0x60 },
                { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
    {10, 1,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0xD9, 0x03, 0x1B, 0x02, 0x71, 0xBD, 0x5A, 0x0A },
                { 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },

    { 1, 0,     { 0x10, 0x31, 0x6E, 0x02, 0x8C, 0x8F, 0x3B, 0x4A },
                { 0x82, 0xDC, 0xBA, 0xFB, 0xDE, 0xAB, 0x66, 0x02 },
                { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
    { 2, 0,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                { 0x95, 0xF8, 0xA5, 0xE5, 0xDD, 0x31, 0xD9, 0x00 } },
    { 3, 0,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                { 0xDD, 0x7F, 0x12, 0x1C, 0xA5, 0x01, 0x56, 0x19 } },
    { 4, 0,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                { 0x2E, 0x86, 0x53, 0x10, 0x4F, 0x38, 0x34, 0xEA } },
    { 5, 0,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                { 0x4B, 0xD3, 0x88, 0xFF, 0x6C, 0xD8, 0x1D, 0x4F } },
    { 6, 0,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                { 0x20, 0xB9, 0xE7, 0x67, 0xB2, 0xFB, 0x14, 0x56 } },
    { 7, 0,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                { 0x55, 0x57, 0x93, 0x80, 0xD7, 0x71, 0x38, 0xEF } },
    { 8, 0,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                { 0x6C, 0xC5, 0xDE, 0xFA, 0xAF, 0x04, 0x51, 0x2F } },
    { 9, 0,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                { 0x0D, 0x9F, 0x27, 0x9B, 0xA5, 0xD8, 0x72, 0x60 } },
    {10, 0,     { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
                { 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                { 0xD9, 0x03, 0x1B, 0x02, 0x71, 0xBD, 0x5A, 0x0A } }
};

void permute(u_char* bits, const int* mapping, int byte)
{
    int n = byte / 8 + (byte % 8 != 0);
    u_char* tmp = new u_char[n];
    memset(tmp, 0, n);
    for (int i = 0; i < byte; i++) {
        bit_set(tmp, i, bit_get(bits, mapping[i] - 1));
    }
    memcpy(bits, tmp, n);
    return;
}
void bit_shift(u_char* bits, int byte, int num) {
    int n = byte / 8 + (byte % 8 != 0);
    int* table = new int[byte];
    for (int i = 0; i < byte; i++) {
        if (i < byte - num) {
            table[i] = i + num;
        }
        else {
            table[i] = i + num - byte;
        }
    }
    u_char* tmp = new u_char[n];
    memset(tmp, 0, n);
    for (int i = 0; i < byte; i++) {
        bit_set(tmp, i, bit_get(bits, table[i]));
    }
    for (int i = 0; i < byte; i++) {
        bit_set(bits, i, bit_get(tmp, i));
    }
    return;
}
void GetSubkeys(const u_char* key) {
    u_char temp[8];
    memset(temp, 0, 8);
    memcpy(temp, key, 8);
    permute(temp, PC1, 64);
    u_char lkey[4], rkey[4];
    memset(lkey, 0, 4);
    memset(rkey, 0, 4);
    for (int i = 0; i < 28; i++) {
        bit_set(lkey, i, bit_get(temp, i));
        bit_set(rkey, i, bit_get(temp, i + 28));
    }
    for (int i = 0; i < 16; i++) {
        bit_shift(lkey, 28, LS[i]);
        bit_shift(rkey, 28, LS[i]);
        for (int j = 0; j < 28; j++) {
            bit_set(subkeys[i], j, bit_get(lkey, j));
            bit_set(subkeys[i], j + 28, bit_get(rkey, j));
        }            
        permute(subkeys[i], PC2, 48);
    }
}
void DES_main(const u_char* source, u_char* target, const u_char* key, OPTION option) {
    GetSubkeys(key);
    u_char L[17][4] = { 0 }, R[17][4] = { 0 };
    u_char temp[8];
    memset(temp, 0, 8);
    memcpy(temp, source, 8);
    permute(temp, IP, 64);
    memcpy(L[0], temp, 4);
    memcpy(R[0], temp + 4, 4);
    for (int i = 1; i <= 16; i++) {
        memcpy(L[i], R[i-1], 4);
        u_char MR[6];
        memset(MR, 0, 6);
        memcpy(MR, R[i - 1], 4);
        permute(MR, Ebox, 48);
        u_char tmp1[6];
        memset(tmp1, 0, 6);
        int k;
        if (option == encipher) {
            k = i - 1;
        }
        else {
            k = 16 - i;
        }
        for (int j = 0; j < 48; j++) {
            int bit = 1;
            if (bit_get(MR, j) == bit_get(subkeys[k], j)) {
                bit = 0;
            }
            bit_set(tmp1, j, bit);
        }
        u_char func[4];
        for (int j = 0; j < 48; j += 6) {
            int x = bit_get(tmp1, j);
            x = x * 2 + bit_get(tmp1, j + 5);
            int y = bit_get(tmp1, j + 1);
            y = y * 2 + bit_get(tmp1, j + 2);
            y = y * 2 + bit_get(tmp1, j + 3);
            y = y * 2 + bit_get(tmp1, j + 4);
            int num = Sbox[j / 6][x][y];
            bit_set(func, (j / 6) * 4, ((num & 0x08) != 0));
            bit_set(func, (j / 6) * 4 + 1, ((num & 0x04) != 0));
            bit_set(func, (j / 6) * 4 + 2, ((num & 0x02) != 0));
            bit_set(func, (j / 6) * 4 + 3, ((num & 0x01) != 0));
        }
        permute(func, Pbox, 32);
        for (int j = 0; j < 32; j++) {
            int bit = 1;
            if (bit_get(func, j) == bit_get(L[i-1], j)) {
                bit = 0;
            }
            bit_set(R[i], j, bit);
        }
    }
    memcpy(target, R[16], 4);
    memcpy(target + 4, L[16], 4);
    permute(target, IP_1, 64);
}
void DES_Encryption(const u_char* plaintext, u_char* ciphertext, const u_char* key) {
    DES_main(plaintext, ciphertext, key, encipher);
    return;
}
void DES_Decryption(u_char* plaintext, const u_char* ciphertext, const u_char* key) {
    DES_main(ciphertext, plaintext, key, decipher);
    return;
}

#endif
NKU-Jan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++简单数据加密算法实现加密和解密的代码
pink_in的博客
07-24 7185
工作闲暇时间，把写内容过程中较好的内容珍藏起来，下面的资料是关于C++简单数据加密算法实现加密和解密的内容，应该是对小伙伴有用。 This is a program for Encryption and Decryption This program uses the Simple Data Encryption Standard (SDES) Algorithm. This Algo...
DES加密解密
weixin_33858336的博客
11-28 176
#include "memory.h" #include "stdio.h" #include "conio.h" enum {ENCRYPT,DECRYPT};// ENCRYPT:加密,DECRYPT:解密 void Des_Run(char Out[8], char In[8], bool Type=ENCRYPT); void Des_SetKey(const ...
DES 加密解密
CJ_WORLD的博客
08-02 507
DES加密解密
c语言文件加密解密算法步骤基础,C语言文件加密解密算法步骤基础.docx
weixin_35632257的博客
05-18 420
C语言文件加密解密算法步骤基础.docx【任务描述】对于硬盘上面某一文件进行加密与解密。要求1、程序运行时，要有提示，选择输入字母来确定对文件进行何种操作，比如输入字母“E”代表进行加密运算，输入字母“D”代表进行解密运算，字母“Q”代表退出。2、文件加密，生成新的文件。移位加密、伪随机数加密、命令加密等。3、对加密后文件的还原。4、加密解密后文件的保存。【主要算法设计】计算文件的长度，在源文件A...
DES加密算法（c语言实现）
06-11
DES加密算法的工作原理主要包括以下几个步骤： 1. **初始置换**：原始64位的数据块首先经过一个固定的初始置换，使得数据分布更均匀，增强安全性。 2. **16轮迭代**：每轮迭代都包括四个子步骤： - **子密钥产生*...
DES加密算法C++实现
06-05
在C++中实现DES加密算法，通常涉及到以下几个关键知识点： 1. **DES算法原理**：DES算法基于Feistel结构，通过16轮迭代变换将64位明文数据转化为64位密文。每一轮迭代包含一个子密钥生成过程和一个替换-置换过程。...
DES加密算法实验
09-27
### DES加密算法实验知识点 #### 一、实验背景与目的 **DES（Data Encryption Standard）加密算法**是一种经典的对称加密技术，在信息安全领域占据着重要地位。本实验旨在通过实践操作，加深对DES算法工作原理的...
java实现的DES加密算法详解
08-30
java实现的DES加密算法详解 java实现的DES加密算法是对称加密算法的一种，主要用于数据加密和解密。下面是java实现的DES加密算法的知识点： 一、DES加密算法介绍 * DES加密算法需要密钥必须是8个字节，即64bit...
des加密算法
10-16
DES（Data Encryption ...总结来说，DES加密算法是历史上重要且有影响力的加密技术，虽然现在已被更先进的算法所取代，但它在密码学的发展历程中起到了关键作用，并且对于理解和学习现代加密技术的基础至关重要。
DES加密解密源代码
04-09
这是我学习DES时编写的DES加密解密程序。源代码中有详细注释。运行程序时，16轮加密解密的每一步都会输出中间结果，便于学习和研究DES。
python实现的DES加密算法和3DES加密算法实例
12-23
本文实例讲述了python实现的DES加密算法和3DES加密算法。分享给大家供大家参考。具体实现方法如下： ############################################################################# # Documentation # #########...
des加密算法_DES加密算法_encryption_
10-01
DES加密算法的核心是Feistel网络结构，它通过一系列的迭代过程来变换输入的64位明文块。每一轮迭代包括以下四个步骤： 1. **扩展置换（Permutation Function P）**：首先，64位的数据经过一个固定的置换表，将其...
【转】C++实现AES、DES加密算法（含MFC界面）
01-11
在 AES 出现之前，最常用的对称密钥算法是 DES 加密算法，它在 1977 年被公布成为美国政府的商用加密标准。DES 的主要问题是密钥长度较短，渐渐不适合于分布式开放网络对数据加密安全性的要求。因此，1998年美国...
c语言文件加密6,C语言 文件加密解密
weixin_42320493的博客
05-24 127
根据你的需要，修改了之前的代码。#include #include #include #include const unsigned int MAX_KEY_LENGTH = 1000;int encode(char const *datafile, char const *keyfill);int decode(char const *datafile, char const *keyfile)...
【c语言】文本加密
小飞的博客
03-17 1771
问题描述 　　先编写函数EncryptChar,按照下述规则将给定的字符c转化（加密）为新的字符：“A"转化"B”，“B"转化为"C”，… …“Z"转化为"a”，“a"转化为"b”,… …, “z"转化为"A”，其它字符不加密。编写程序，加密给定字符串。 　　 样例输出 与上面的样例输入对应的输出。 例： 数据规模和约定 　　输入数据中每一个数的范围。 　　例：50个字符以内无空格字符串。 #in...
简单的文件加密系统C语言代码
rongmoul的专栏
03-22 1709
用C语言实现一个简易的文件加密/解密系统。该系统采用对称加密体制，由用户指定自己的密钥key，加密函数可描述为M = P + key，对应的解密函数可描述为M = P - key。   代码如下： #include #include void encryption(char buffer[], int file_size, int key); void decryption(cha
PBOC MAC 计算算法 实现
abc
05-04 2263
win7 64位 PC vs2013 建立 一个 控制台 空工程： 添加下面两个文件： des.cpp // DES算法利用一个56+8奇偶校验位(第8,16,24,32,40,48,56,64位)=64位的密钥对以64位为单位的块数据进行加解密 #include "memory.h" #include "stdio.h" #include "conio.h" enum { E...
深入理解DES加密算法及其工作过程
DES(Data Encryption Standard)加密算法是一种由IBM公司研发的分组密码算法，它在数据加密领域有着广泛的应用，尽管在其之后出现了更多新型加密算法，但DES的地位仍然显著。DES主要针对8位明文分组和10位密钥进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值