精华内容
下载资源
问答
  • 哪一步加c
    千次阅读
    2021-07-22 02:40:22

    计算机中快捷键ctrl加什么是返回上一步

    发布时间:2021-06-10 11:33:52

    来源:亿速云

    阅读:67

    作者:小新

    这篇文章主要为大家展示了“计算机中快捷键ctrl加什么是返回上一步”,内容简而易懂,条理清晰,希望能够帮助大家解决疑惑,下面让小编带领大家一起研究并学习一下“计算机中快捷键ctrl加什么是返回上一步”这篇文章吧。ctrl加z是返回上一步,ctrl加z的反快捷键是“Ctrl+Y”;“CTRL+Y”快捷键的作用就是用来恢复上一步的操作,与“CTRL+Z”快捷键的作用刚好相反。

    本文操作环境:windows7系统,DELL G3电脑

    ctrl加什么是返回上一步?

    ctrl加z是返回上一步。

    Ctrl+Z 的反快捷键是Ctrl+Y。

    CTRL+Y 快捷键的作用就是用来恢复上一步的操作,与CTRL+Z 快捷键的作用刚好相反。

    其他快捷方式:

    ctrl +V 粘贴

    ctrl +C或ctrl +INSERT 复制

    ctrl +X  窗口最大化/剪切(移动)

    ctrl+N 窗口最小化

    ctrl+W 关闭当前窗口

    ctrl +Esc 打开开始菜单

    ctrl +ALT+DELETE 打开安全操作界面

    ctrl +ALT+N  新建一个新的文件

    ctrl+shift+N 新建一个文件夹

    ctrl +O  打开“打开文件”对话框

    ctrl +P  打开“打印”对话框

    ctrl +S  保存当前操作的文件

    以上是“计算机中快捷键ctrl加什么是返回上一步”这篇文章的所有内容,感谢各位的阅读!相信大家都有了一定的了解,希望分享的内容对大家有所帮助,如果还想学习更多知识,欢迎关注亿速云行业资讯频道!

    更多相关内容
  • [纯C语言 + Win32 API]一步一步写个围棋程序之三:个菜单
  • C语言一步一步实现sha256

    千次阅读 2020-10-15 13:53:47
    文章目录sha256 算法一步一步实现简介hash运算流程Step1exampleStep2C语言实现变量名hash的初始值hash加密过程的常量hash运算hash结构体hash_inithash_updatehash_caculatorhash_finalmainresultSrcsha256在线计算...

    sha256 算法一步一步实现

    简介

    sha256能够对任意长度的消息生成64个十六进制字符串。

    hash运算流程

    Step1

    报文长度以bit计算,在报文末尾进行填充,使得报文长度对512取模以后的余数是448。

    补充方法:先补第一个bit为1,然后都补0,直到长度满足对512取模后余数是448。

    即使当前报文长度对512取模以后的余数是448,也要进行填充,第一个bit为1,后面全部补0,直到长度满足再次对512取模后余数是448。

    最后在末尾添加一个该报文长度(未填充的报文长度)64bit的数,以bit为单位计算。这样填充后的报文长度将满足整除512。

    example

    加密字符串“abcd”,报文应是如下,以16进制为单位

    0x61626364 0x80000000 0x00000000 0x00000000
    0x00000000 0x00000000 0x00000000 0x00000000
    0x00000000 0x00000000 0x00000000 0x00000000
    0x00000000 0x00000000 0x00000000 0x00000020
    

    Step2

    将填充的报文长度以 512bit为一组,从第1组到最后一组。每一组都进行如下迭代:每一次迭代都需要一次hash的值。
    在这里插入图片描述
    hash的初始值:
    在这里插入图片描述
    Map函数计算如下:

    在这里插入图片描述

    • 田字格代表这几个数相加,若大于 2 32 2^{32} 232,则对 2 32 2^{32} 232取余。

    • W t W_t Wt : 这一组的报文总共长度512bit,分成16个32bit Word ,从 W [ 0 ] → W [ 15 ] W[0] \to W[15] W[0]W[15],后续的 W [ 16 ] → W [ 63 ] W[16]\to W[63] W[16]W[63],由下式递推给出。

    W t = σ 1 ( W t − 2 ) + W t − 7 + σ 0 ( W t − 15 ) + W t − 16 W_t=\sigma1(W_{t-2})+W_{t-7}+\sigma0(W_{t-15})+W_{t-16} Wt=σ1(Wt2)+Wt7+σ0(Wt15)+Wt16

    • K t K_t Kt 为64个32bit 常量,将与 C h σ 0 σ 1 M a ∑ 0 ∑ 1 Ch \quad \sigma0 \quad \sigma1 \quad Ma \quad \sum0 \quad \sum1 Chσ0σ1Ma01这些运算规则一起在下面用C语言介绍。

    • 利用如图所示的方式,运算64次后及得到下一次的hash值。

    C语言实现

    变量名

    typedef unsigned int u32;
    typedef unsigned char u8;
    typedef unsigned long long u64;
    

    hash的初始值

    #define H0  0x6a09e667
    #define H1  0xbb67ae85
    #define H2  0x3c6ef372
    #define H3  0xa54ff53a
    #define H4  0x510e527f
    #define H5  0x9b05688c
    #define H6  0x1f83d9ab
    #define H7  0x5be0cd19
    

    hash加密过程的常量

    u32 Kt[64] = { 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
    				0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
    				0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
    				0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
    				0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
    				0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
    				0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
    				0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
    				0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
    				0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
    				0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
    				0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
    				0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
    				0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
    				0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
    				0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };
    

    hash运算

    C h ( x , y , z ) = ( x & y ) ⊕ ( x ˉ & z ) Ch(x,y,z)=(x \And y)\oplus(\bar{x} \And z) Ch(x,y,z)=(x&y)(xˉ&z)

    u32 Ch(u32 x, u32 y, u32 z)
    {
    	return (x & y) ^ (~x & z);
    }
    
    • M a ( x , y , z ) = ( x & y ) ⊕ ( x & z ) ⊕ ( y & z ) Ma(x,y,z)=(x \And y)\oplus(x \And z)\oplus(y \And z) Ma(x,y,z)=(x&y)(x&z)(y&z)
    u32 Ma(u32 x, u32 y, u32 z)
    {
    	return (x & y) ^ (x & z)^ (y & z);
    }
    
    • ∑ 0 = C r s 2 ( x ) ⊕ C r s 13 ( x ) ⊕ C r s 22 ( x ) \sum 0 =Crs^2(x)\oplus Crs^{13}(x)\oplus Crs^{22}(x) 0=Crs2(x)Crs13(x)Crs22(x)

    C r s n Crs^{n} Crsn代表循环右移 n n n bit。

    u32 cycle_rshift(u32 x,u32 n)
    {
    	return 	((x & (((u32)1 << n) - 1)) << (32 - n))|(x >> n);
    }
    u32 Sum0(u32 x)
    {
    	return cycle_rshift(x, 2) ^ cycle_rshift(x, 13) ^ cycle_rshift(x, 22);
    }
    
    • ∑ 1 = C r s 6 ( x ) ⊕ C r s 11 ( x ) ⊕ C r s 25 ( x ) \sum 1 =Crs^6(x)\oplus Crs^{11}(x)\oplus Crs^{25}(x) 1=Crs6(x)Crs11(x)Crs25(x)
    u32 Sum1(u32 x)
    {
    	return cycle_rshift(x, 6) ^ cycle_rshift(x, 11) ^ cycle_rshift(x, 25);
    }
    

    σ 0 ( x ) = C r s 7 ( x ) ⊕ C r s 18 ( x ) ⊕ R s 3 ( x ) \sigma0(x) =Crs^7(x)\oplus Crs^{18}(x)\oplus Rs^{3}(x) σ0(x)=Crs7(x)Crs18(x)Rs3(x)

    R s n Rs^{n} Rsn代表逻辑向右移 n n n bit 。

    u32 Sigma0(u32 x)
    {
    	return cycle_rshift(x, 7) ^ cycle_rshift(x, 18) ^ (x>>3);
    }
    
    • σ 1 ( x ) = C r s 17 ( x ) ⊕ C r s 19 ( x ) ⊕ R s 10 ( x ) \sigma1(x) =Crs^{17}(x)\oplus Crs^{19}(x)\oplus Rs^{10}(x) σ1(x)=Crs17(x)Crs19(x)Rs10(x)
    u32 Sigma1(u32 x)
    {
    	return cycle_rshift(x, 17) ^ cycle_rshift(x, 19) ^ (x >> 10);
    }
    

    hash结构体

    struct sha256
    {
    	u32 block[16];	//加密measage 512bit
    	u32 hash[8];	//hash的结果
    	u64 hash_length;//总共hash的byte数
    	u8  offset;		//一个update未对齐Word(4字节)的字节数
    	u8  index;		//当前已经写到block的位置
    };
    

    hash_init

    void sha_init(struct sha256 *s)
    {
    	s->hash[0] = H0;
    	s->hash[1] = H1;
    	s->hash[2] = H2;
    	s->hash[3] = H3;
    	s->hash[4] = H4;
    	s->hash[5] = H5;
    	s->hash[6] = H6;
    	s->hash[7] = H7;
    	s->hash_length = 0;
    	s->index  = 0;
    	s->offset = 0;
    }
    

    下面这些函数请在gitee仓库查看源码。

    hash_update

    void sha_updata(struct sha256* s,unsigned char *str,u64 len);
    

    hash_caculator

    void sha_caculator(struct sha256* s);
    

    hash_final

    void sha_final(struct sha256* s);
    

    main

    int main()
    {
        
    	int i = 0;
    	struct sha256 testsha;
    
    	sha_init(&testsha);
    	sha_updata(&testsha, "abc", 3);
    	sha_updata(&testsha, "defg", 4);
    	sha_updata(&testsha, "hi", 2);
    	sha_updata(&testsha, "jklmno", 5);
    	sha_final(&testsha);
    
    	for (i = 0; i < 8; i++)
    		printf("%08x", testsha.hash[i]);
    
    	system("pause");
    
    }
    

    result

    在这里插入图片描述

    Src

    #include<stdio.h>
    #include<windows.h>
    typedef unsigned int u32;
    typedef unsigned char u8;
    typedef unsigned long long u64;
    #define H0  0x6a09e667
    #define H1  0xbb67ae85
    #define H2  0x3c6ef372
    #define H3  0xa54ff53a
    #define H4  0x510e527f
    #define H5  0x9b05688c
    #define H6  0x1f83d9ab
    #define H7  0x5be0cd19
    u32 Wt[64];
    u32 Kt[64] = { 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
    				0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
    				0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
    				0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
    				0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
    				0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
    				0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
    				0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
    				0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
    				0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
    				0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
    				0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
    				0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
    				0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
    				0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
    				0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };
    u32 Ch(u32 x, u32 y, u32 z)
    {
    	return (x & y) ^ (~x & z);
    }
    u32 cycle_rshift(u32 x,u32 n)
    {
    	return 	((x & (((u32)1 << n) - 1)) << (32 - n))|(x >> n);
    }
    u32 Sum0(u32 x)
    {
    	return cycle_rshift(x, 2) ^ cycle_rshift(x, 13) ^ cycle_rshift(x, 22);
    }
    u32 Sum1(u32 x)
    {
    	return cycle_rshift(x, 6) ^ cycle_rshift(x, 11) ^ cycle_rshift(x, 25);
    }
    u32 Sigma0(u32 x)
    {
    	return cycle_rshift(x, 7) ^ cycle_rshift(x, 18) ^ (x>>3);
    }
    u32 Sigma1(u32 x)
    {
    	return cycle_rshift(x, 17) ^ cycle_rshift(x, 19) ^ (x >> 10);
    }
    u32 Ma(u32 x, u32 y, u32 z)
    {
    	return (x & y) ^ (x & z)^ (y & z);
    }
    struct sha256
    {
    	u32 block[16];	//加密的measage
    	u32 hash[8];	//hash的结果
    	u64 hash_length;//总共hash的byte数
    	u8  offset;		//一个update未对齐Word(4字节)的字节数
    	u8  index;		//当前已经写到block的位置
    };
    void sha_init(struct sha256 *s)
    {
    	s->hash[0] = H0;
    	s->hash[1] = H1;
    	s->hash[2] = H2;
    	s->hash[3] = H3;
    	s->hash[4] = H4;
    	s->hash[5] = H5;
    	s->hash[6] = H6;
    	s->hash[7] = H7;
    	s->hash_length = 0;
    	s->index  = 0;
    	s->offset = 0;
    }
    void sha_caculator(struct sha256* s)//先补齐 Wt,然后循环64次加密
    {
    	u8 i = 0;
    	u32 m0, s0, s1,c1,t1;
    
    	u32 temp[8];
    	for(i=0;i<8;i++)
    		temp[i]=s->hash[i];
    
    	for (i = 0; i < 16; i++)
    		Wt[i] = s->block[i];
    
    	for (i = 16; i < 64; i++)
    		Wt[i] = Sigma1(Wt[i-2])+ Wt[i-7]+Sigma0(Wt[i - 15])+ Wt[i - 16];
    	
    	for (i = 0; i < 64; i++)
    	{
    		s0 = Sum0(temp[0]);
    
    		s1 = Sum1(temp[4]);
    
    		m0 = Ma(temp[0], temp[1], temp[2]);
    
    		c1 = Ch(temp[4], temp[5], temp[6]);
    
    		t1 = s1+c1+temp[7]+Wt[i] + Kt[i];
    
    		temp[7] = temp[6];
    		temp[6] = temp[5];
    		temp[5] = temp[4];
    		temp[4] = temp[3]+ t1;
    		temp[3] = temp[2];
    		temp[2] = temp[1];
    		temp[1] = temp[0];
    		temp[0] = t1+m0+s0;
    	
    	}
    
    	for (i = 0; i < 8; i++)
    		s->hash[i]+=temp[i];
    }
    void sha_updata(struct sha256* s,unsigned char *str,u64 len)
    {
    	u64 i = 0;
    	u64 count;
    	s->hash_length += len;
    	if (s->offset!=0)//说明没有4字节对齐
    	{
    		if (s->offset + len < 4)
    		{
    			for (i = s->offset; i < s->offset+len; i++)
    			{
    				s->block[s->index]  |= (((u32)(*str)) << (8 * (3 - i)));
    				str++;
    			}
    			s->offset += len;
    			return;
    		}
    		else
    		{
    			len = len + s->offset - 4;
    			for (i = s->offset; i < 4; i++)
    			{
    				s->block[s->index]  |= (((u32)(*str)) << (8 * (3 - i)));
    				str++;
    			}
    			s->index++;
    			if (s->index == 16)
    			{
    				sha_caculator(s);//满足512bit 16Word加密一次
    				s->index = 0;
    			}
    		}
    	}
    	count = (len >> 2);//计算这次加密有多少个Word
    	s->offset = len % 4;//对齐Word剩余的byte
    
    
    	for(i=0;i<count;i++)
    	{
    
    		s->block[s->index] = (((u32)(*str))		<< 24) |
    								((*(str	+	1))		<< 16) |
    								((*(str + 2))	<< 8) |
    								(*(str + 3));
    		s->index++;
    
    		str += 4;
    
    		if (s->index == 16)
    		{
    			sha_caculator(s);//满足512bit 16Word加密一次
    			s->index = 0;
    		}
    	}
    
    
    	s->block[s->index] = 0;//对齐Word剩余的byte写在 s->index 位置上,供下一次update使用
    
    	for (i = 0; i < s->offset; i++)
    	{
    		s->block[s->index] |= (((u32)(*str)) << (8 * (3 - i)));
    		str++;
    	}
    	
    }
    void sha_final(struct sha256* s)
    {
    	u8 temp=s->hash_length % 64;//计算需要填充多少byte
    	u8 fill[4] = { 0x80,0x0,0x0,0x0 };
    	u32 i;
    	if (temp == 56)//则需要填充一个512bit
    	{
    		//补齐前一次的512bit
    		if (s->offset != 0)
    		{
    			for (i = 0; i < 4-s->offset; i++)
    			s->block[s->index]  |= (fill[i]<< (8 * (3 - i-s->offset)));
    
    			s->index++;
    		}
    		else
    		{
    			s->block[s->index] = 0x80000000;
    			s->index++;
    		}
    		for (i = s->index; i < 16; i++)
    			s->block[i] = 0;
    
    		sha_caculator(s);
    
    	
    		for(i=0;i<14;i++)
    		s->block[i] = 0;
    
    		s->block[14] = s->hash_length >> 29;
    		s->block[15] = s->hash_length << 3 & 0xffffffff;
    		sha_caculator(s);
    
    	}
    	else
    	{
    		if (s->offset != 0)
    		{
    			for (i = 0; i < 4-s->offset; i++)
    				s->block[s->index]  |= (fill[i] << (8 * ( 3 - i - s->offset)));
    
    			s->index++;
    		}
    		else
    		{
    			s->block[s->index] = 0x80000000;
    			s->index++;
    		}
    		for (i = s->index; i < 14; i++)
    			s->block[i] = 0;
    		s->block[14] = s->hash_length>> 29;
    		s->block[15] = s->hash_length<<3 & 0xffffffff;
    		sha_caculator(s);
    	}
    }
    int main()
    {
    	
    
    	int i = 0;
    	struct sha256 testsha;
    
    	sha_init(&testsha);
    	sha_updata(&testsha, "abc", 3);
    	sha_updata(&testsha, "defg", 4);
    	sha_updata(&testsha, "hi", 2);
    	sha_updata(&testsha, "jklmn", 5);
    	sha_final(&testsha);
    
    	for (i = 0; i < 8; i++)
    		printf("%08x", testsha.hash[i]);
    
    	system("pause");
    
    
    
    
    }
    

    sha256在线计算

    sha256在线计算

    参考博客

    https://blog.csdn.net/u011583927/article/details/80905740

    展开全文
  • C语言简单实现减乘除

    千次阅读 2022-04-06 13:27:53
    //简单实现减乘除 //函数指针数组 #include<stdio.h> void nume(){ printf("***********************\n"); printf("**** 1.Add 2.Sub ****\n"); printf("**** 3.Mul 4.Div ****\n"); printf("*****5....

     

    //简单实现加减乘除
    //函数指针数组
    #include<stdio.h>
    
    void nume(){
    	printf("***********************\n");
    	printf("**** 1.Add   2.Sub ****\n");
    	printf("**** 3.Mul   4.Div ****\n");
    	printf("*****5.Eor  0.exit ****\n");
    	printf("***********************\n");
    	
    }
    int Add(int x, int y){
    	return x + y;
    }
    
    int Sub(int x, int y){
    	return x - y;
    }
    
    int Mul(int x, int y){
    	return x * y;
    }
    
    int Div(int x, int y){
    	return x / y;
    }
    
    int Eor(int x, int y){
    	return x ^ y;
    }
    int main(){
    	
    	int input=0, x=0, y=0;
    	do{
    		nume();
    		printf("请输入你的选项:\n");
    		scanf("%d",&input);	
    		int (*p[6])(int, int) = {0,Add,Sub,Mul,Div,Eor};
    		if(input>=1 && input<=5){
    			printf("请输入两个操作数\n");
    			scanf("%d%d",&x,&y);
    			printf("%d \n", p[input](x,y) ); // 函数指针数组的使用
    		}else if(input == 0){
    			printf("退出\n");
    		}	
    		else{
    			printf("请重新输入\n");
    		}
    	}while(input);
    	return 0;
    }

     

    展开全文
  • 首先将上一步的结果: E(R0)异或K1(48)=01010000 00111011 01010010 11010111 00111100 10011010 分为8个6位的数据块 1:010100 2:000011 3:101101 4:010010 5:110101 6:110011 7:110010 8:011010 对第1块...

    加密

    DES加密算法其实分为两个部分,一部分对密钥进行处理 ,一部分对明文进行处理。
    下面从一个例子说明:
    64位明文:

    M=00110000 00110001 00110010 00110011 00110100 00110101 00110110 00110111
    

    64位密钥:

    K=00110001 00110010 00110011 00110100 00110101 00110110 00110111 00111000
    

    密钥

    K=00110001 00110010 00110011 00110100 00110101 00110110 00110111 00111000

    置换选择

    置换选择1(PC_1)8*7矩阵:

    int pc_1[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
        };
    

    在密钥当中,前八位00110001,第8位的1是奇偶校验位
    这个表有两个作用,一是去掉8个奇偶校验位,二是其他位打乱重排,即得到的56位密钥(64-8)中第1位的数是原来64位的第57位的数,第2位的数是原来的第49位的数。。。
    其实不用特意去掉奇偶校验位,因为按PC_1换位置之后剩下来的8位就是奇偶校验位,直接舍去就可以。

    经过上面的变换我们就可以得到56位的密钥:

    K(56)=0000000 0000000 0011111 1111111 0110011 0011110 001000 00001111
    

    再将前28位存储到C0,后28位存储到D0,即:

    C0(28)=0000000 0000000 0011111 1111111
    D0(28)=0110011 0011110 001000 00001111
    

    循环左移

    为了得到16个子密钥,我们需要有16对C和D。
    C1为C0循环左移得到,D1为D0循环左移得到,C2为C1循环左移得到,D2为D1循环左移得到、、、
    循环左移的位数如图所示:
    在这里插入图片描述
    循环左移1位的意思是把第一位保留下来,其他位左移,再将保留的第一位填到最后空出来的1位。
    可以得到结果:
    第一轮:

    C1=0000000 0000000 0111111 1111110
    D1=1100110 0111100 0100000 0011110
    

    第二轮:

    C2=0000000 0000000 1111111 1111100
    D2=1001100 1111000 1000000 0111101
    


    第16轮:

    C16=0000000 0000000 0011111 1111111
    D16=0110011 0011110 0010000 0001111
    

    左移完成后,将每对拼接起来构成56位的密钥

    K1(56)=0000000 0000000 0111111 1111110 1100110 0111100 0100000 0011110
    

    接下来进行第二次置换
    置换选择2(PC_2)6*8矩阵:

    int pc_2[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
        };
    

    将56位变为48位,和PC_1原理一样,最终得到16个子密钥:

    k1(48)=010100000010110010101100010101110010101011000010
    k2(48)=010100001010110010100100010100001010001101000111
    k3(48)=110100001010110000100110111101101000010010001100
    k4(48)=111000001010011000100110010010000011011111001011
    k5(48)=111000001001011000100110001111101111000000101001
    k6(48)=111000001001001001110010011000100101110101100010
    k7(48)=101001001101001001110010100011001010100100111010
    k8(48)=101001100101001101010010111001010101111001010000
    k9(48)=001001100101001101010011110010111001101001000000
    k10(48)=001011110101000101010001110100001100011100111100
    k11(48)=000011110100000111011001000110010001111010001100
    k12(48)=000111110100000110011001110110000111000010110001
    k13(48)=000111110000100110001001001000110110101000101101
    k14(48)=000110110010100010001101101100100011100110010010
    k15(48)=000110010010110010001100101001010000001100110111
    k16(48)=010100010010110010001100101001110100001111000000
    

    对密钥的处理完毕,下面开始对明文处理。

    明文

    M=00110000 00110001 00110010 00110011 00110100 00110101 00110110 00110111

    IP置换

    IP置换表(IP)8*8:

    //IP置换表
    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
        };
    

    将明文打乱顺序,得到

    M_IP(64)=00000000 11111111 11110000 10101010 00000000 11111111 00000000 11001100
    

    再将其分为两部分L0、R0

    L0(32)=00000000 11111111 11110000 10101010
    R0(32)=00000000 11111111 00000000 11001100
    

    接下来,从L0R0开始推L1R1,一共循环16次,推出L1-L16
    根据下面的运算规则:

    Ln=R(n-1);
    Rn=L(n-1)异或P( S ( ( E ( R(n-1) ) 异或 Kn ) ) );
    

    L很好得到,就是L1=R0;L2=R1;L3=R2…

    L16R16的运算

    拓展置换

    为了得到R1,首先执行最里面的E(R0)

    选择运算/拓展置换(E)8*6:

    //r数组拓展置换表
    int 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
        };
    

    将32位的R0拓展到48位

    R0(32)=00000000 11111111 00000000 11001100
    R0(48)=00000000 00010111 11111110 10000000 00010110 01011000
    

    接下来进行 E(R0)异或K1(48)

    k1(48)=010100000010110010101100010101110010101011000010
    E(R0)异或K1(48)=01010000 00111011 01010010 11010111 00111100 10011010
    

    S盒

    接下来进行 S(E(R0)异或K1(48))
    代替函数S盒(S_box):

    //l数组s盒置换表
    int s_box[8][4][16]={
        14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7,  //s1
        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,  //s2
        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,  //s3
        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,  //s4
        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,  //s5
        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,  //s6
        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,  //s7
        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,  //s8
        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
    };
    

    首先将上一步的结果:

    E(R0)异或K1(48)=01010000 00111011 01010010 11010111 00111100 10011010
    

    分为8个6位的数据块

    1010100      2000011     3101101      4010010
    5110101      6110011     7110010      8011010
    

    对第1块处理,将6位中的第1位和第6位组成一个二进制数00,转为十进制数X=0*2+0=0 。再将中间四位1010组成二进制数,转为十进制Y=1*8+0*4+1*2+0*1=10 。X作为行数,Y作为列数,第几块就去找第几盒,那这个块的结果就是S1的0行10列,即S_box[0][0][10],结果为6,将6转为二进制0110 。
    再对其余7块处理完成后,可以得到4*8=32位的结果:

    S(E(R0)异或K1(48))(32)=01101101 10000010 00001110 11110000
    

    P置换

    再进行P(S(E(R0)异或K1(48)))
    置换运算(P)8*4:

    //P盒置换
    int 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
    };
    

    这个跟置换选择就一样了,可以得到结果:

    P(S(E(R0)异或K1(48))(32))(32)=00010010 01111000 11000111 00011001
    

    最后将这个结果和L0进行异或操作:

    R1 = L0 异或 P(S(E(R0)异或K1(48))(32))(32)
    L0(32)=00000000 11111111 11110000 10101010
    
    R1(32)=00010010 10000111 00110111 10110011
    L1(32)=R0=00000000 11111111 00000000 11001100
    

    按照拓展置换、S置换、P置换的顺序退出来L16和R16:

    N=1
    L1=00000000111111110000000011001100
    R1=00010010100001110011011110110011
    N=2
    L2=00010010100001110011011110110011
    R2=11100001100111001000011010001010
    N=3
    L3=11100001100111001000011010001010
    R3=11010110001011101111011101100101
    N=4
    L4=11010110001011101111011101100101
    R4=00011110111001010111111100100110
    N=5
    L5=00011110111001010111111100100110
    R5=01011000010000001110001001011100
    N=6
    L6=01011000010000001110001001011100
    R6=00011010011000000110100000101100
    N=7
    L7=00011010011000000110100000101100
    R7=11010001011100100100110001010100
    N=8
    L8=11010001011100100100110001010100
    R8=01101001101101100001001111111010
    N=9
    L9=01101001101101100001001111111010
    R9=10101110100001011111100010000110
    N=10
    L10=10101110100001011111100010000110
    R10=00010101101110011000100100011001
    N=11
    L11=00010101101110011000100100011001
    R11=00010011011001010001111111011000
    N=12
    L12=00010011011001010001111111011000
    R12=11110000111011000111011010001110
    N=13
    L13=11110000111011000111011010001110
    R13=00100111110111000010101111001011
    N=14
    L14=00100111110111000010101111001011
    R14=00011000111101010110001110010100
    N=15
    L15=00011000111101010110001110010100
    R15=00110011111101101010110101000101
    N=16
    L16=00110011111101101010110101000101
    R16=11010100000101101000101010100001
    

    我们需要的就是L16和R16,将它们按R16L16的顺序拼接在一起组成64位数据。

    (64)1101010000010110100010101010000100110011111101101010110101000101
    

    IP逆置换

    //IP逆置换表
    int IP_[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
        };
    

    按此表对上步结果进行最后的置换,得到最终的密文:

    C(64)=10001011 10110100 01111010 00001100 11110000 10101001 01100010 01101101
    

    解密

    解密过程其实跟加密过程一样,就是把明文换成密文,密钥不变,再按这个顺序来一遍,但有一点不同的地方
    首先根据密文来获得16个子密钥,不过这16个子密钥跟你明文加密过程中得到的是一样的;
    然后对密文进行操作,IP置换,获得L0R0,在进行16次递推运算时有不同,
    明文加密的运算规则是:

    Ln=R(n-1);
    Rn=L(n-1)异或P( S ( ( E ( R(n-1) ) 异或 Kn ) ) );
    

    密文解密的运算规则是:

    Ln=R(n-1);
    Rn=L(n-1)异或P( S ( ( E ( R(n-1) ) 异或 K(16-n+1) ) ) );
    

    即明文在获取R1时,使用的是子密钥K1
    密文在获取R1时,使用的是子密钥K16,获取R2使用K15
    然后依次进行S盒、P置换、IP逆置换可以得到明文

    N=1
    L1=00110011111101101010110101000101
    R1=00011000111101010110001110010100
    N=2
    L2=00011000111101010110001110010100
    R2=00100111110111000010101111001011
    N=3
    L3=00100111110111000010101111001011
    R3=11110000111011000111011010001110
    N=4
    L4=11110000111011000111011010001110
    R4=00010011011001010001111111011000
    N=5
    L5=00010011011001010001111111011000
    R5=00010101101110011000100100011001
    N=6
    L6=00010101101110011000100100011001
    R6=10101110100001011111100010000110
    N=7
    L7=10101110100001011111100010000110
    R7=01101001101101100001001111111010
    N=8
    L8=01101001101101100001001111111010
    R8=11010001011100100100110001010100
    N=9
    L9=11010001011100100100110001010100
    R9=00011010011000000110100000101100
    N=10
    L10=00011010011000000110100000101100
    R10=01011000010000001110001001011100
    N=11
    L11=01011000010000001110001001011100
    R11=00011110111001010111111100100110
    N=12
    L12=00011110111001010111111100100110
    R12=11010110001011101111011101100101
    N=13
    L13=11010110001011101111011101100101
    R13=11100001100111001000011010001010
    N=14
    L14=11100001100111001000011010001010
    R14=00010010100001110011011110110011
    N=15
    L15=00010010100001110011011110110011
    R15=00000000111111110000000011001100
    N=16
    L16=00000000111111110000000011001100
    R16=00000000111111111111000010101010
    解密后的明文为:
    00110000 00110001 00110010 00110011 00110100 00110101 00110110 00110111
    

    对比明文

    M=00110000 00110001 00110010 00110011 00110100 00110101 00110110 00110111
    

    结果正确


    代码:C语言DES加密解密代码

    展开全文
  • DES算法加密C语言实现

    万次阅读 多人点赞 2018-11-24 19:34:57
    这几天把老师布置作业写了写,主要是DES算法加密,随便写了写,这里是...代码每一步都有解释,可能实现的有些麻烦,但是易懂,代码如下: ///DES算法加密 #include<cstdio> #include<cstring> const ...
  • c语言return机制

    千次阅读 2021-05-25 06:07:54
    0引C/C++中,函数内部的一切变量(函数内部局部变量,形参)都是在其被调用时才被分配内存单元。...(注:其实C语言传参方式只有传值一种形式,作者这里指的传址,形式上是传指针,其实这个指针也被拷贝了一份,只不...
  • 一步带你了解C语言中的++、--的使用方法
  • } //这个函数能够 把 字符串数组中的 pos1到pos2位置的 数字 转化成int 类型 方便减乘除的计算 int f(int pos1,int pos2) { int sum=0; for(int i=pos1 ; i; i++) { if(s[i][i]>='0') sum=sum*10+(s[i]-'0');...
  • c语言中1+三分之一五分之二七分之三以下文字资料是由(历史新知网...c语言中1+三分之一五分之二七分之三#include "stdio.h"int main(){ int i,n; float sum=0; scanf("%d",&n); for(i=1;i<...
  • C语言基础入门开发,在C-Free5中新建C语言工程超详细流程。 还有编译出错的解决方案。
  • C语言中,树数组是开发中常用的操作,而它的出现可以大大降低数字序列的复杂度,下面是爱站技术频道小编和大家分享的谨慎C语言中树数组的每一步操作。C语言树状数组的实例详解最近学了树状数组,给我的感觉就是 这...
  • 在使用scanf()读取输入的字符时,当转换说明为%c时,"%c"、" %c"、"%c " 这三种不同的写法,对数据读取的结果有什么影响吗,答案是肯定的,%c 空格,空格在前还是在后,结果是不同的。 1、先来看看%c前后都不...
  • C/C++】C语言特性总结

    万次阅读 多人点赞 2019-08-10 16:21:28
    已经有大约半年的时间没有碰C语言了,当时学习的时候记录了很多的笔记,但是都是特别混乱,后悔那个时候,不懂得写博客,这里凭借记忆和零零散散的笔记记录,尝试系统性地复习一下C语言。 之前都是在Windows环境下...
  • CTOD(c语言ctod函数)

    千次阅读 2021-05-19 04:42:24
    计算机VC中的ctod函数怎么用?把 字符型 转换为 日期型 普通的日期型数据应该用花括号{}或CTOD()函数表示,如1999年8月20日可以表示为:{^1999/08/20}或CTOD("08/20/99")。而08/20/99表示.ctod是一个自定义的函数 ...
  • 关于数字加密的问题

    2021-05-18 11:18:08
    在每一位5。再每一位取模,最后把第一位和最后一位位置交换。输出来;我用的是数组和for循环,把数反转和+5与取模一步写出来。最后再调换第一位和最后一位的位置。最后输出来。但最后一步写不出来。希望哪个高手帮...
  • MD5加密算法(C语言实现,已编译,亲试可用~)

    千次阅读 多人点赞 2021-03-02 09:26:59
    C语言实现MD5加密算法 本文有部分内容参考引用百度百科-MD5 。 MD5 MD5信息摘要算法(英语:MD5 Message-Digest Algorithm),一种被广泛使用的密码散列函数,可以产生出一个128位(16字节)的散列值(hash value...
  • C语言简单的单步调试

    千次阅读 2021-04-15 18:20:19
    C语言中的单步跟踪调试 单步调试是指程序开发中,为了找到程序的bug,通常采用的一种调试手段,一步一步跟踪程序执行的流程,根据变量的值,找到错误的原因。 下面以一个简单的小程序为例,这里的程序必须是在项目下...
  • mac 后退一步 快捷键

    千次阅读 2020-12-21 02:26:33
    展开全部mac后退一步快捷键:1、在32313133353236313431303231363533e4b893e5b19e31333431353334浏览器中:⌘(command)+⟵/⟶是前进或后退,⌘(command)+↑/↓是滚动到顶或底。2、在Finder中:⌘(command)+↑/↓是上...
  • int com(int a, int b)//高中学的排列组合中的组合C(a b),下面有一张图。 { int mother = 1, son = 1;//mother是图片中分母的值。son是图片中分子的值。 int p = a;//因为a存的值,既要用来决定循环次数,又要...
  • c语言来具体实现单表仿射密码的加密解密过程,首先要求输入要处理的密文或明文,接着要求输入密钥a和b的值,接着输入0来表示对所给明文加密,输入1来表示对所给密文解密。然后程序根据调用函数gcd判断输入的密钥a与...
  • 看到这里我建议大家先停一停,仔细思考思考这一步。 好了,接下来就可以写L’变换了 unsigned long TransL_1 (unsigned long temp) { return temp ^ Change_Place(temp, 13) ^ Change_Place(temp, 23); } 接下来就...
  • C/C++减乘除运算效率分析

    千次阅读 2021-03-21 09:47:05
    乘法是加操作,而除法是每步的结果作加法或减法(加减交替法),有的算法还需要恢复上一次的结果(余数恢复法),而且每一步加减后还要进行移位,所以最慢。 从数学上讲,CPU中的ALU在算术上只干了两件事,加法,移位,...
  • 救命啊,就是每一步都要保留 就是把这一步加在里面,我不知道加哪儿 if(HT[i].parent==0&&HT[i].weight!=0) printf(" %d ",HT[i].weight);
  • your own = fn(your own-1)*2;return your own;elsereturn 1;if(your own == 1)int fn(int your own)printf(“%.20lf\n”....c = (double)b/your own;b = fn(23);your own = fn(30);double c;int b;int your own;v...
  • 在Visual Studio中,如果你创建的是纯C语言的工程,那么给可执行程序添加图标就没有便捷的入口。但也只是入口不好找了,添加步骤还是比较简单的,以下为具体操作方法:1. 右键点击C工程,选择Add->Resource去添加...
  • 我们写的代码是文本文件(.c文件),.c文件通过编译转换为.obj文件,.obj文件通过链接转换为.exe文件(可执行文件)。可执行文件在运行环境中运行。 1.编译 编译可以分为三个部分:预编译,编译, 汇编。 预编译...
  • 解析 RC4 加密算法(C语言、python)

    千次阅读 2022-03-08 16:33:45
    解析 RC4 加密算法(C语言、python): RC4加密算法是一种对称加密算法: 加密(解密)原理: RC4算法中的几个关键变量: RC4代码介绍: rc4初始化介绍: 包含三个参数: RC4加密: 包含三个参数: 代码实现:...
  • C语言中.c文件与.h文件 的使用 转自(https://blog.csdn.net/qq_35327108/article/details/83656409?utm_medium=distribute.pc_relevant_t0.none-task-blog-OPENSEARCH-1.control&depth_1-utm_source=...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 340,710
精华内容 136,284
关键字:

哪一步加c