其他现代密码学算法详解及实现见专栏合集~
（i）算法结构
概述：将明文分为64位的分组，首先对64位码做初始IP置换，再进行16论迭代变换，其中包括ESP三种运算，最后进行逆初始置换。
1.初始置换IP
将64个明文位的位置进行置换，得到一个乱序的64位明文组，然后分成左右两端，每段位32位，左边用L0表示，右边用R0表示，并将R0送入迭代变换。
2. 迭代变换F
I．选择扩展运算E
（为了和48位的密钥运算而扩展）
四字节一组，组前位=上组最后一位，组后位=下组的第一位。
II．密钥加密运算
将子密钥产生器产生的48位子密钥k与选择扩展运算E输出的48位数据按位做异或运算。
III．选择压缩运算S（S盒）
（实现非线性混淆，增加明文空间复杂度，因为密文需要是64位，所以必须压缩回32位）
将加密过后的48位数据自左向右分成8组，每组6位。然后并行送入8个S盒，每个S盒为一个非线性代换网络。6进4出，头尾两位的二进制->行数，中间四位的二进制->列数，找到其在S盒中对应的数字，即结果。
IV．置换运算P（P盒）
（为了扩散，使明文和密钥的影响迅速扩散到密文中，增加密文密钥空间复杂度）
置换运算P对S输出的32位进行坐标变换，置换P输出的32位数据与左边的L0做异或，得到的R1作为下一轮的右边数据使用。即：
Rp⊕L0=L1
3.逆初始置换IP
16轮迭代后，将左32位和右32位交换次序，得到R16L16，拼在一起得到64位的数据，经过逆初始置换表置换，按行读数，得到密文。
（ii）混淆的效果
通过S盒实现非线性变换混淆，研究中并没有找到S盒的弱点。
注：子密钥产生器：
首先有一个64位的种子密钥，放入PC-1置换后，去除8位校验位得到56位的数据。分成左右两个部分，左边的位C0，右边的为D0。
C0,D0经过移位次序表移位后，得到C1,D1，放入PC-2置换后，得到一48bit的k1。PC-2本身会去除C中第9，18，22，25位，和D中第7，9，15，26位，剩下48位。
k1作为第一轮的子密钥输出，C1,D1再根据移位次序表移位得到C2,D2，并得到k2，以此类推。
（i）混淆
迭代8次之后输出和输入就可以认为是不相关的了。S盒实现了非线性变换混淆。
（ii）雪崩效应
DES具有很强的雪崩效应，仅有一位不同的明文，使用相同的密钥，仅仅经过三轮迭代，所的两段准密文就有过半数位不同。
64位分组-分组加密
56位：256
3DES算法：
使用三（或两）个不同的密钥对数据块进行三次（或两次）加密，加密一次要比进行普通加密的三次要快。
三重DES的强度大约和112-bit的密钥强度相当。
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
/*------------------------
定义枚举型全局变量
------------------------*/
typedef enum
{
false = 0,
true = 1
} bool;
// 十六轮子密钥
static bool SubKey[16][48] = {0};
/*---------------------*/
/*-------------------------------------------------------------
各种置换表
-------------------------------------------------------------*/
// IP置换表
const char IP_Table[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
};
// IP-1置换表
const char IPR_Table[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
};
// E扩展表
static char E_Table[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
};
// PC1置换表
static char PC1_Table[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
};
// pc2表
static char PC2_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,34,33,48,
44,49,39,56,34,53,46,42,50,36,29,32
};
// 移位表
static char Move_Table[16] = {
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
};
// S盒
static char S_Box[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, 0, 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, 0, 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置换表
static char P_Table[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
};
/*-------------------------------------------------------------------*/
/*-----------------------------自定义函数-----------------------------*/
void SetKey(char My_key[8]); //生成16轮的子密钥；
void ByteToBit(bool* Data_out, char* Data_in, int Num); //字节转换成位；
void Change_bit(bool* Data_out, int Num);//二进制的位置进行转换；
void BitToByte(char My_message[8], bool* Message_in, int Num); //位转换成字节；
void TableReplace(bool* Data_out, bool* Data_in, const char* Table, int Num); //各种表的置换算法；
void Bitcopy(bool* Data_out, bool* Data_in, int Num); //二进制数组的拷贝
void Loop_bit(bool* Data_out, int movstep, int len); //左移位；
void Run_Des(char My_message[8], char HexMssage[16]);//des的轮加密算法
void Xor(bool* Message_out, bool* Message_in, int Num); //执行异或
void S_change(bool* Data_out, bool* Data_in); // S盒变换；
void HexToBit(bool* Data_out, char* Data_in, int Num); // 十六进制转二进制
void BitToHex(char* Data_out, bool* Data_in, int Num); //二进制转换成十六进制；
void Run_desDes(char My_message[8], char HexMessage[16]);// DES轮解密算法；
/*--------------------------*/
/*--------------------------主函数----------------------------------*/
int main()
{
int i = 0, j;
char My_key[8] = {0}; //记录加密密钥；
char You_key[8] = {0}; //解密密钥
char My_message[8] = {0}; //明文
char Message_hex[16] = {0};//16进制的密文
printf("请输入你要加密的内容(8 Byte):\n");
gets(My_message);
printf("请输入你的加密密钥:\n");
gets(My_key);
i = strlen(My_key);
while(i != 8)
{
printf("请输入加密密钥(8 Byte)\n");
gets(My_key);
i = 0;
i = strlen(My_key);
}
SetKey(My_key); //生成16轮的加密子密钥；
Run_Des(My_message, Message_hex); //des的轮加密过程
printf("经过加密的密文为:\n");
for(i = 0; i < 16; i++)
{
printf("%c ", Message_hex[i]);
}
printf("\n");
printf("请输入你的解密密钥(8 Byte):\n");
gets(You_key);
i = strlen(You_key);
while(i != 8)
{
printf("请输入解密密钥(8 Byte)\n");
gets(You_key);
i = 0;
i = strlen(You_key);
}
SetKey(You_key); //生成16轮的解密子密钥；
Run_desDes(My_message, Message_hex);//解密;
printf("解密结果为:\n");
for(i = 0; i < 8; i++)
{
printf("%c ", My_message[i]);
}
printf("\n");
return 0;
}
/*--------------------具体函数定义----------------------*/
void Bitcopy(bool* Data_out, bool* Data_in, int Num) //二进制数组拷贝
{
int i = 0;
for(i = 0; i < Num; i++)
{
Data_out[i] = Data_in[i];
}
}
void Change_bit(bool* Data_out, int Num) //二进制的位置进行转换；
{
int i, j;
static bool Temp[8] = {0};
for(i = 0; i < Num / 8; i++)
{
Bitcopy(Temp, Data_out, Num / 8);
for(j = 0; j < Num / 8; j++)
{
Data_out[j] = Temp[Num / 8 - 1 - j];
}
Data_out += Num / 8;
}
}
void ByteToBit(bool* Data_out, char* Data_in, int Num) //字节转位
{
int i, j;
for(i = 0; i < Num; i++)
{
Data_out[i] = (Data_in[i / 8] >> (i % 8)) & 0x01;
}
//Change_bit(Data_out,Num);
}
void BitToHex(char* Data_out, bool* Data_in, int Num) //二进制转十六进制
{
int i;
for(i = 0; i < Num / 4; i++)
{
Data_out[i] = 0;
}
for(i = 0; i < Num / 4; i++)
{
Data_out[i] = Data_in[4 * i] + Data_in[4 * i + 1] * 2 + Data_in[4 * i + 2] * 4 + Data_in[4 * i + 3] * 8;
if(Data_out[i] % 16 > 9)
{
Data_out[i] = Data_out[i] % 16 + '7';
}
else
Data_out[i] = Data_out[i] % 16 + '0';
}
}
void HexToBit(bool* Data_out, char* Data_in, int Num) //十六进制转二进制
{
int i;
for(i = 0; i < Num; i++)
{
if(Data_in[i / 4] <= '9')
{
Data_out[i] = ((Data_in[i / 4] - '0') >> (i % 4)) & 0x01;
}
else
{
Data_out[i] = ((Data_in[i / 4] - '7') >> (i % 4)) & 0x01;
}
}
}
void BitToByte(char My_message[8], bool* Message_in, int Num) //位转换成字节
{
int i = 0;
for(i = 0; i < (Num / 8); i++)
{
My_message[i] = 0;
}
for(i = 0; i < Num; i++)
{
My_message[i / 8] |= Message_in[i] << (i % 8);
}
}
void TableReplace(bool* Data_out, bool* Data_in, const char* Table, int Num) // 置换算法
{
int i = 0;
static bool Temp[256] = {0};
for(i = 0; i < Num; i++)
{
Temp[i] = Data_in[Table[i] - 1];
}
Bitcopy(Data_out, Temp, Num);
}
void Loop_bit(bool* Data_out, int movstep, int len)
{
static bool Temp[256] = {0};
Bitcopy(Temp, Data_out, movstep);
Bitcopy(Data_out, Data_out + movstep, len - movstep);
Bitcopy(Data_out + len - movstep, Temp, movstep);
/*Temp=Data_out;
Temp[movstep]='\0';
Data_out=Data_out+movstep;
Data_out+(len-movstep)=Temp;*/
}
void Xor(bool* Message_out, bool* Message_in, int Num)//执行异或
{
int i;
for(i = 0; i < Num; i++)
{
Message_out[i] = Message_out[i] ^ Message_in[i];
}
}
void SetKey(char My_key[8])
{
int i, j;
static bool Key_bit[64] = {0}; //Key的二进制缓存；
static bool* Key_bit_L, * Key_bit_R;
Key_bit_L = &Key_bit[0]; //key的左边28位；
Key_bit_R = &Key_bit[28]; //key的右边28位；
ByteToBit(Key_bit, My_key, 64);
/* Change_bit(Key_bit,64) ;//二进制的位置进行转换；
for(i=0;i<64;i++)
{
printf("%d ",Key_bit[i]);
}
printf("\n");
printf("\n");*/
TableReplace(Key_bit, Key_bit, PC1_Table, 56);//pc-1 置换
for(i = 0; i < 16; i++)
{
Loop_bit(Key_bit_L, Move_Table[i], 28);
Loop_bit(Key_bit_R, Move_Table[i], 28);
TableReplace(SubKey[i], Key_bit, PC2_Table, 48);//pc-2置换
}
}
void S_change(bool* Data_out, bool* Data_in) //S盒变换
{
int i;
int r = 0, c = 0;//S盒的行和列；
for(i = 0; i < 8; i++, Data_in = Data_in + 6, Data_out = Data_out + 4)
{
r = Data_in[0] * 2 + Data_in[5] * 1;
c = Data_in[1] * 8 + Data_in[2] * 4 + Data_in[3] * 2 + Data_in[4] * 1;
ByteToBit(Data_out, &S_Box[i][r][c], 4);
}
}
void F_change(bool Data_out[32], bool Data_in[48]) // f函数；
{
int i;
static bool Message_E[48] = {0}; //存放E置换的结果；
TableReplace(Message_E, Data_out, E_Table, 48);//E表置换
Xor(Message_E, Data_in, 48);
S_change(Data_out, Message_E); // S盒变换
TableReplace(Data_out, Data_out, P_Table, 32); //P置换
}
void Run_Des(char My_message[8], char HexMssage[16])//des轮加密算法；
{
int i;
static bool Message_bit[64] = {0};
static bool* Message_bit_L = &Message_bit[0], * Message_bit_R = &Message_bit[32];
static bool Temp[32] = {0};
ByteToBit(Message_bit, My_message, 64);
/*Change_bit(Message_bit,64) ;//二进制的位置进行转换；
for(i=0;i<64;i++)
{
printf("%d ",Message_bit[i]);
}
printf("\n");
printf("\n");*/
TableReplace(Message_bit, Message_bit, IP_Table, 64);
for(i = 0; i < 16; i++)
{
Bitcopy(Temp, Message_bit_R, 32);
F_change(Message_bit_R, SubKey[i]);
Xor(Message_bit_R, Message_bit_L, 32);
Bitcopy(Message_bit_L, Temp, 32);
}
TableReplace(Message_bit, Message_bit, IPR_Table, 64);
BitToHex(HexMssage, Message_bit, 64);//二进制转换成十六进制；
}
void Run_desDes(char My_message[8], char HexMessage[16])// DES轮解密算法；
{
int i = 0;
static bool Message_bit[64] = {0};
static bool* Message_bit_L = &Message_bit[0], * Message_bit_R = &Message_bit[32];
static bool Temp[32] = {0};
HexToBit(Message_bit, HexMessage, 64);
TableReplace(Message_bit, Message_bit, IP_Table, 64);
for(i = 15; i >= 0; i--)
{
Bitcopy(Temp, Message_bit_L, 32);
F_change(Message_bit_L, SubKey[i]);
Xor(Message_bit_L, Message_bit_R, 32);
Bitcopy(Message_bit_R, Temp, 32);
}
TableReplace(Message_bit, Message_bit, IPR_Table, 64);
BitToByte(My_message, Message_bit, 64);
}
我正在寻找执行以下操作的正确语法(在Perl、Shell或Ruby中):#variabletoaccessthedatalinesappendedasafileEND_OF_SCRIPT_MARKERrawdatastartshereanditcontinues. 最佳答案 Perl用__DATA__做这个:#!/usr/bin/perlusestrict;usewarnings;while(){print;}__DATA__Texttoprintgoeshere 关于ruby-如何将脚
我有一个用户工厂。我希望默认情况下确认用户。但是鉴于unconfirmed特征，我不希望它们被确认。虽然我有一个基于实现细节而不是抽象的工作实现，但我想知道如何正确地做到这一点。factory:userdoafter(:create)do|user,evaluator|#unwantedimplementationdetailshereunlessFactoryGirl.factories[:user].defined_traits.map(&:name).include?(:unconfirmed)user.confirm!endendtrait:unconfirmeddoenden
几个月前，我读了一篇关于rubygem的博客文章，它可以通过阅读代码本身来确定编程语言。对于我的生活，我不记得博客或gem的名称。谷歌搜索“ruby编程语言猜测”及其变体也无济于事。有人碰巧知道相关gem的名称吗？ 最佳答案 是这个吗:http://github.com/chrislo/sourceclassifier/tree/master 关于ruby-寻找通过阅读代码确定编程语言的rubygem？，我们在StackOverflow上找到一个类似的问题：
目录一.加解密算法数字签名对称加密DES(DataEncryptionStandard)3DES(TripleDES)AES(AdvancedEncryptionStandard)RSA加密法DSA(DigitalSignatureAlgorithm)ECC(EllipticCurvesCryptography)非对称加密签名与加密过程非对称加密的应用对称加密与非对称加密的结合二.数字证书图解一.加解密算法加密简单而言就是通过一种算法将明文信息转换成密文信息，信息的的接收方能够通过密钥对密文信息进行解密获得明文信息的过程。根据加解密的密钥是否相同，算法可以分为对称加密、非对称加密、对称加密和非
华为OD机试题本篇题目：明明的随机数题目输入描述输出描述：示例1输入输出说明代码编写思路最近更新的博客华为od2023|什么是华为od，od薪资待遇，od机试题清单华为OD机试真题大全，用Python解华为机试题|机试宝典【华为OD机试】全流程解析+经验分享,题型分享,防作弊指南华为o
?博客主页：https://xiaoy.blog.csdn.net?本文由呆呆敲代码的小Y原创，首发于CSDN??学习专栏推荐：Unity系统学习专栏?游戏制作专栏推荐：游戏制作?Unity实战100例专栏推荐：Unity实战100例教程?欢迎点赞?收藏⭐留言?如有错误敬请指正！?未来很长，值得我们全力奔赴更美好的生活✨------------------❤️分割线❤️-------------------------
嗨~大家好，这里是可莉！今天给大家带来的是7个C语言的经典基础代码~那一起往下看下去把【程序一】打印100到200之间的素数#includeintmain(){ inti; for(i=100;i 【程序二】输出乘法口诀表#includeintmain(){inti;for(i=1;i 【程序三】判断1000年---2000年之间的闰年#includeintmain(){intyear;for(year=1000;year 【程序四】给定两个整形变量的值，将两个值的内容进行交换。这里提供两种方法来进行交换，第一种为创建临时变量来进行交换，第二种是不创建临时变量而直接进行交换。1.创建临时变量来
C#实现简易绘图工具一.引言实验目的:通过制作窗体应用程序(C#画图软件),熟悉基本的窗体设计过程以及控件设计,事件处理等,熟悉使用C#的winform窗体进行绘图的基本步骤,对于面向对象编程有更加深刻的体会.Tutorial任务设计一个具有基本功能的画图软件**·包括简单的新建文件,保存,重新绘图等功能**·实现一些基本图形的绘制,包括铅笔和基本形状等,学习橡皮工具的创建**·设计一个合理舒适的UI界面**注明:你可能需要先了解一些关于winform窗体应用程序绘图的基本知识,以及关于GDI+类和结构的知识二.实验环境Windows系统下的visualstudio2017C#窗体应用程序三.
MIMO技术的优缺点优点通过下面三个增益来总体概括：阵列增益。阵列增益是指由于接收机通过对接收信号的相干合并而活得的平均SNR的提高。在发射机不知道信道信息的情况下，MIMO系统可以获得的阵列增益与接收天线数成正比复用增益。在采用空间复用方案的MIMO系统中，可以获得复用增益，即信道容量成倍增加。信道容量的增加与min(Nt,Nr)成正比分集增益。在采用空间分集方案的MIMO系统中，可以获得分集增益，即可靠性性能的改善。分集增益用独立衰落支路数来描述，即分集指数。在使用了空时编码的MIMO系统中，由于接收天线或发射天线之间的间距较远，可认为它们各自的大尺度衰落是相互独立的，因此分布式MIMO
遍历文件夹我们通常是使用递归进行操作，这种方式比较简单，也比较容易理解。本文为大家介绍另一种不使用递归的方式，由于没有使用递归，只用到了循环和集合，所以效率更高一些！一、使用递归遍历文件夹整体思路1、使用File封装初始目录，2、打印这个目录3、获取这个目录下所有的子文件和子目录的数组。4、遍历这个数组，取出每个File对象4-1、如果File是否是一个文件，打印4-2、否则就是一个目录，递归调用代码实现publicclassSearchFile{publicstaticvoidmain(String[]args){//初始目录Filedir=newFile("d:/Dev");Datebeg