说明

1、先给家人们说一下，我这程序明文加密之后再解密不等于原明文，发出来是因为以后有时间会改一改，好找

2、在加解密过程中，所使用的置换表，S盒，P盒也是我在网上找的，除了IP表和IP逆表我验证过没问题，其他的表我就不能保证了

3、我这写下来很流畅，除非是我对加解密的某一步理解出了问题，不然的话就有可能是我在网上找的这些表不合规范

4、对源码有兴趣的话，可以瞅瞅
链接：https://pan.baidu.com/s/1Eoeam_fZp3DcVAs4ZI56Ew
提取码：nlvl

任务拆解

子密钥生成

加/解密

效果

代码

main.cpp 文件

#include "Basic_Func_Lib.h"void Generating_Subkeys();//子密钥:Subkeys生成
void Encryption();//加密
void Decode();//解密int main() {//密钥生成Generating_Subkeys();//加密Encryption();//解密Decode();return 0;
}//子密钥:Subkeys生成
void Generating_Subkeys() {Ke_transform();for (int i = 0; i < 16; i++) {Cyclic_Shift_Left(Cyclic_Shift_Table[i]);Compression_replacement(Subkeys[i]);}
}//加密
void Encryption() {printf("明文为:\n");print_1(M, 64);//S盒初始化S_Box_Initial();//分割Split(M);//IP置换Equivalent_replacement(M);//加密for (int i = 0; i < 16; i++) {//函数f计算结果保存在Func_Ret中Func(i);//赋值Copy(Right, Left, 32);Copy(Func_Ret, Right, 32);}//合并Combination(C);//IP逆置换Inv_Equivalent_replacement(C);printf("加密结果为:\n");print_1(C, 64);
}//解密
void Decode() {printf("密文为:\n");print_1(C, 64);//S盒初始化S_Box_Initial();//分割Split(C);//IP置换Equivalent_replacement(C);//解密for (int i = 15; i >= 0; i--) {//函数f计算结果保存在Func_Ret中Func(i);//赋值Copy(Left, Right, 32);Copy(Func_Ret, Left, 32);}//合并Combination(M);//IP逆置换Inv_Equivalent_replacement(M);printf("解密结果为:\n");print_1(M, 64);
}

Basic_Func_Lib.h头文件

#include <stdio.h>
#include <stdlib.h>
#define Row 16void Copy(int* src, int* dst, int n);//###############################数组打印
//一维数组打印函数
void print_1(int* array, int n) {for (int i = 0; i < n; i++) {printf("%d  ", array[i]);}printf("\n");
}//二维数组打印函数
void print_2(int array[][Row], int n, int m) {for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {printf("%d  ", array[i][j]);}printf("\n");}
}//###############################轮密钥生成基本函数
//初始密钥
int Ke_Initial[64] = { 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 };
//左
int Ke_Left_Index[28] = { 47, 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 };
int Ke_Left[28];
//右
int Ke_Right_Index[28] = { 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 };
int Ke_Right[28];//移位步长表
int Cyclic_Shift_Table[16] = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };//压缩置换表
int Compression_replacement_table[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 };//子密钥存储
int Subkeys[16][48];//除去密钥中的奇偶校验位,将密钥分为两28位密钥
void Ke_transform() {for (int i = 0; i < 28; i++) {Ke_Left[i] = Ke_Initial[Ke_Left_Index[i] - 1];Ke_Right[i] = Ke_Initial[Ke_Right_Index[i] - 1];}
}//密钥左循环移位
void Cyclic_Shift_Left(int n) {int temp_L[2];int temp_R[2];for (int i = 0; i < n; i++) {temp_L[i] = Ke_Left[i];temp_R[i] = Ke_Right[i];}for (int i = n; i < 28; i++) {Ke_Left[i - n] = Ke_Left[i];Ke_Right[i - n] = Ke_Right[i];}for (int i = 0; i < n; i++) {Ke_Left[28 - n + i] = temp_L[i];Ke_Right[28 - n + i] = temp_L[i];}
}//置换选择
void Compression_replacement(int Subkey[48]) {int temp[56];for (int i = 0; i < 28; i++) {temp[i] = Ke_Left[i];temp[i + 28] = Ke_Right[i];}for (int i = 0; i < 48; i++) {Subkey[i] = temp[Compression_replacement_table[i] - 1];}
}//###############################加/解密基本函数
//明文
int M[64] = { 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 };//明密文置换中转站
int Temp[64];//初始置换表
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 };
int Left[32];//左
int Right[32];//右//扩展置换表
int Permutation_extension_table[48] = { 32, 8, 16, 24, 1, 9, 17, 25, 2, 10, 18, 26, 3, 11, 19, 27, 4, 12, 20, 28, 5, 13, 21, 29, 4, 12, 20, 28, 5, 13, 21, 29, 6, 14, 22, 30, 7, 15, 23, 31, 8, 16, 24, 32, 9, 17, 25, 1 };
int Permutation_extension_M[48];//扩展置换明文//S盒
int S_Box[4][16];
int S_Box_L0[16] = { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 };
int S_Box_L1[16] = { 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8 };
int S_Box_L2[16] = { 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0 };
int S_Box_L3[16] = { 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 };int Func_Ret[32];//函数f处理结果暂存//P盒
int P_Box[32] = { 16,1,2,19,7,15,8,13,20,23,24,30,21,26,14,6,29,5,32,22,12,18,27,11,28,31,3,4,17,10,9,25 };//密文
int C[64];//Ip逆置换表
int Ip_Inv[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 };void S_Box_Initial() {Copy(S_Box_L0, S_Box[0], 16);Copy(S_Box_L1, S_Box[1], 16);Copy(S_Box_L2, S_Box[2], 16);Copy(S_Box_L3, S_Box[3], 16);
}//IP置换函数
void Equivalent_replacement(int* M_C) {for (int i = 0; i < 64; i++) {Temp[i] = M_C[Ip[i] - 1];}Copy(Temp, M_C, 64);for (int i = 0; i < 32; i++) {Left[i] = M_C[Ip[i] - 1];Right[i] = M_C[Ip[i + 32] - 1];}
}//分割函数 将输入的数组分配给Left，Right
void Split(int* M_C) {for (int i = 0; i < 32; i++) {Left[i] = M_C[i];Right[i] = M_C[i + 32];}
}//置换扩展函数
void Extended_replacement() {for (int i = 0; i < 48; i++) {Permutation_extension_M[i] = Right[Permutation_extension_table[i] - 1];}
}//异或
void Xor(int n) {for (int i = 0; i < 48; i++) {Permutation_extension_M[i] ^= Subkeys[n][i];}
}//一个16进制数转4位二进制数，存入Func_Ret
void x_2_b(int x, int n) {int r;for (int i = 3; i >= 0; i--) {r = x % 2;x = (x - r) / 2;Func_Ret[i + n] = r;}
}//S盒压缩 一共需要七个S盒，为了简单都用S_Box
void S_box() {int L, R;for (int i = 0; i < 48; i += 6) {L = 2 * Permutation_extension_M[i] + Permutation_extension_M[i + 5];R = 8 * Permutation_extension_M[i + 1] + 4 * Permutation_extension_M[i + 2] + 2 * Permutation_extension_M[i + 3] + Permutation_extension_M[i + 4];x_2_b(S_Box[L][R], i);}
}//P盒置换
void P_box() {Func_Ret;P_Box;for (int i = 0; i < 32; i++) {Func_Ret[i] = Func_Ret[P_Box[i] - 1];}
}//函数f整合
void Func(int n) {Extended_replacement();Xor(n);S_box();P_box();
}//src赋值给dst
void Copy(int* src, int* dst, int n) {for (int i = 0; i < n; i++) {dst[i] = src[i];}
}//合并L、R
void Combination(int* M_C) {for (int i = 0; i < 32; i++) {M_C[i] = Left[i];M_C[i + 32] = Right[i];}
}//逆置换函数
void Inv_Equivalent_replacement(int* M_C) {for (int i = 0; i < 64; i++) {Temp[i] = M_C[Ip_Inv[i] - 1];}Copy(Temp, M_C, 64);
}//交换M_L与M_R
void Exchange() {int temp;for (int i = 0; i < 32; i++) {temp = Left[i] ^ Right[i];Left[i] ^= temp;Right[i] ^= temp;}
}

DES密码实现( C语言 )相关推荐

DES密码算法实现(C语言)
算法介绍 DES算法为密码体制中的对称密码体制,又被称为美国数据加密标准,是1972年美国IBM公司研制的对称密码体制加密算法. 明文按64位进行分组,密钥长64位,密钥事实上是56位参与DES运算( ...
密码学:c/c 语言实现 pdf,典型密码算法C语言实现pdf
典型密码算法C语言实现内容简介 <典型密码算法C语言实现>详细讲述了一些典型密码算法的算法原理及C语言实现.书中密码算法包括:序列密码.分组密码.公钥密码和Hash算法,其中序列密码有祖 ...
凯撒密码c语言小写字母,凯撒密码c(c语言编程凯撒密码)
凯撒密码c(c语言编程凯撒密码) 2020-05-15 13:09:51 共10个回答 #include#includeintmain(){charsave[10][30];inta,b,i,j;sc ...
usercontroller.java_userlogin 用户登录程序的编写，输入名和密码，JAVA语言，可运行 Develop 254万源代码下载- www.pudn.com...
文件名称: userlogin下载收藏√ [ 5 4 3 2 1 ] 开发工具: Java 文件大小: 11 KB 上传时间: 2016-03-30 下载次数: 0 提供者: 详细说 ...
仿射密码（C语言实现）
仿射密码(C语言实现) 简介仿射密码是一种表单代换密码,字母表的每个字母相应的值使用一个简单的数学函数对应一个数值,再把对应数值转换成字母. 加解密公式加密函数: Y =(AX+B)%26 解密函 ...
密码学实验报告c语言程序,密码学_实验一_古典密码算法_C语言.doc
您所在位置:网站首页 > 海量文档 &nbsp>&nbsp高等教育&nbsp>&nbsp实验设计密码学_实验一_古典密码算法_C语言.doc8页本 ...
PTA(Basic Level) 1076：Wifi密码（C语言实现）
PTA(Basic Level) 1076:Wifi密码(C语言实现) #include <stdio.h> #include <ctype.h> #include <s ...
古典密码算法实验c语言,2021信息安全实验一古典密码算法C语言.docx
2021信息安全实验一古典密码算法C语言.docx 信息安全信息安全实验一实验一古典密码算法古典密码算法 C C 语言语言信息安全实验报告课程名称 _ 专业计算机科学与技术 _2010_级 ...
Vigenere密码（维吉尼亚密码）c语言实现
Vigenere密码(维吉尼亚密码)c语言实现简介 Vigenere密码是基于关键词的加密系统. 算法解释 Vigenere密码技术使用一个词组作为密钥,词组中的每一个字母都作为移位替换密码的密钥并 ...

DES密码实现( C语言 )

文章目录

说明