├── 1
    ├── lab1
    │   ├── Caesar.c
    │   ├── Caesar.exe
    │   ├── decrypt.txt
    │   ├── encrypt.txt
    │   └── origin.txt
    ├── lab2
    │   ├── c.txt
    │   ├── change.c
    │   ├── change.exe
    │   ├── decrypt.txt
    │   ├── encrypt.txt
    │   └── origion.txt
    ├── lab3
    │   ├── decrypt.txt
    │   ├── encrypt.txt
    │   ├── fangshe.cpp
    │   ├── fangshe.exe
    │   └── origion.txt
    ├── lab4
    │   ├── DES.cpp
    │   ├── DES.exe
    │   ├── c.txt
    │   ├── d.txt
    │   ├── k.txt
    │   └── p.txt
    ├── lab5
    │   ├── AES.cpp
    │   └── AES.exe
    ├── lab6
    │   ├── RSA.cpp
    │   └── RSA.exe
    ├── lab7
    │   ├── MD5.cpp
    │   ├── MD5.exe
    │   ├── out.txt
    │   └── test.txt
    ├── report
    │   ├── 1.md
    │   ├── 2.md
    │   ├── 3.md
    │   ├── 4.md
    │   ├── 5.md
    │   ├── 6.md
    │   └── 7.md
    └── screenshots
    │   ├── 1.1.png
    │   ├── 1.2.png
    │   ├── 1.3.png
    │   ├── 2.1.png
    │   ├── 2.2.png
    │   ├── 2.3.png
    │   ├── 3.1.png
    │   ├── 3.2.png
    │   ├── 4.1.png
    │   ├── 4.2.png
    │   ├── 5.1.png
    │   ├── 6.1.png
    │   ├── 6.2.png
    │   ├── 7.1.png
    │   └── 7.2.png
├── 2
    ├── 实验1.凯撒密码
    │   ├── ciphertext.txt
    │   ├── decrypted_plaintext.txt
    │   ├── plaintext.txt
    │   ├── test.c
    │   └── test.exe
    ├── 实验2.单表置换
    │   ├── ciphertext.txt
    │   ├── decrypted_plaintext.txt
    │   ├── plaintext.txt
    │   ├── test.c
    │   └── test.exe
    ├── 实验3.仿射密码
    │   ├── ciphertext.txt
    │   ├── devrypted_plaintext.txt
    │   ├── plaintext.txt
    │   ├── test.c
    │   └── test.exe
    ├── 实验4.DES
    │   ├── DES.cpp
    │   ├── DES.exe
    │   ├── ciphertext-tool.txt
    │   ├── ciphertext.txt
    │   ├── decrypted_plaintext.txt
    │   ├── key.txt
    │   └── plaintext.txt
    └── 实验5.AES
    │   ├── AES.cpp
    │   ├── AES.dsp
    │   ├── AES.dsw
    │   ├── AES.exe
    │   ├── AES.h
    │   ├── AES.ncb
    │   ├── AES.opt
    │   ├── AES.plg
    │   ├── Debug
    │       ├── AES.exe
    │       ├── AES.ilk
    │       ├── AES.obj
    │       ├── AES.pch
    │       ├── AES.pdb
    │       ├── AES.sbr
    │       ├── main.obj
    │       ├── main.pch
    │       ├── main.pdb
    │       ├── main.sbr
    │       ├── vc60.idb
    │       └── vc60.pdb
    │   ├── ciphertext-tool.txt
    │   ├── ciphertext.txt
    │   ├── decrypted_plaintext.txt
    │   ├── key.txt
    │   ├── main.cpp
    │   └── main.dsp
├── LICENSE
├── README.md
├── 实验报告-传.docx
└── 实验报告.docx


/1/lab1/Caesar.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<stdlib.h>
  3 | #include<string.h>
  4 | 
  5 | //k为密钥,len为长度,fp为储存的加密文件
  6 | void encrypt(char c[],int len,int k,char e[],FILE *fp){
  7 |     int i = 0;
  8 |     for(i=0;i<len;i++){
  9 |         if(c[i]>='a'&&c[i]<='z'-k){
 10 |             e[i] = c[i] + k;
 11 |         }
 12 |         else if(c[i]>='a'&&c[i]>'z'-k){
 13 |             e[i] = c[i] + k - 26;
 14 |         }
 15 |         else if(c[i]>='A'&&c[i]<='Z'-k){
 16 |             e[i] = c[i] + k;
 17 |         }
 18 |         else if(c[i]>='A'&&c[i]>'Z'-k){
 19 |             e[i] = c[i] + k - 26;
 20 |         }
 21 |         else{
 22 |             e[i] = c[i];
 23 |         }
 24 |     }
 25 |     fputs(e,fp);
 26 |     printf("加密方成功进行加密！\n");
 27 | } 
 28 | 
 29 | void decrypt(char c[],int len,int k,char d[],FILE *fp)
 30 | {
 31 |     int i = 0;
 32 |     for(i=0;i<len;i++){
 33 |         if(c[i]>='a'+k&&c[i]<='z'){
 34 |             d[i] = c[i] - k;
 35 |         }
 36 |         else if(c[i]>='a'&&c[i]<'a'+k){
 37 |             d[i] = c[i] - k + 26;
 38 |         }
 39 |         else if(c[i]>='A'+k&&c[i]<='Z'){
 40 |             d[i] = c[i] - k;
 41 |         }
 42 |         else if(c[i]>='A'&&c[i]<'A'+k){
 43 |             d[i] = c[i] - k + 26;
 44 |         }
 45 |         else{
 46 |             d[i] = c[i];
 47 |         }
 48 |     }
 49 |     fputs(d,fp);
 50 |     printf("解密方成功进行解密！\n");
 51 | } 
 52 | 
 53 | int main(){
 54 |     FILE *fpr,*fpw;
 55 |     int m = 0;
 56 |     do
 57 | 	{
 58 | 		printf("加密请输入1\n解密请输入2\n退出请输入0\n");
 59 | 	    scanf("%d",&m);
 60 | 	    if(m==0)
 61 | 	    	break;
 62 | 	    else if(m!=0&&m!=1&&m!=2)
 63 | 	    	printf("输入有误，请重新输入！\n");
 64 | 	    else{
 65 | 	    	int len = 0,i = 0,k = 0;
 66 | 		    printf("请输入密钥k\n");
 67 | 		    scanf("%d",&k);
 68 | 	    	if(m==1){   
 69 | 		    	char ch,c[10000]={0},e[10000]={0};
 70 | 		        fpr = fopen("origin.txt","r");
 71 | 		        fpw = fopen("encrypt.txt","w");
 72 | 		        if(fpr==NULL){
 73 | 		            printf("open file error\n");
 74 | 		            return 1;
 75 | 			    }
 76 | 		        while(fscanf(fpr,"%c",&ch)!=EOF){
 77 | 		            c[i] = ch;
 78 | 		            i++;
 79 | 		            len++;
 80 | 		        }
 81 | 		        encrypt(c,len,k,e,fpw);
 82 | 		        fclose(fpr);
 83 | 				fclose(fpw);
 84 | 		    }
 85 | 		    else if(m==2)
 86 | 		    {
 87 | 		    	char ch,c[10000]={0},d[10000]={0};
 88 | 		        fpr = fopen("encrypt.txt","r");
 89 | 		        fpw = fopen("decrypt.txt","w");
 90 | 		        if(fpr==NULL){
 91 | 		            printf("open file error\n");
 92 | 		            return 1;
 93 | 			    }
 94 | 		        while(fscanf(fpr,"%c",&ch)!=EOF){
 95 | 		            c[i] = ch;
 96 | 		            i++;
 97 | 		            len++;
 98 | 		        }
 99 | 		        decrypt(c,len,k,d,fpw);
100 | 		        fclose(fpr);
101 | 				fclose(fpw);
102 | 		    }
103 | 		}
104 | 	}while(m!=0);
105 | 	return 0;
106 | }
107 | 


--------------------------------------------------------------------------------
/1/lab1/Caesar.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/lab1/Caesar.exe


--------------------------------------------------------------------------------
/1/lab1/decrypt.txt:
--------------------------------------------------------------------------------
1 | helloworld


--------------------------------------------------------------------------------
/1/lab1/encrypt.txt:
--------------------------------------------------------------------------------
1 | khoorzruog


--------------------------------------------------------------------------------
/1/lab1/origin.txt:
--------------------------------------------------------------------------------
1 | helloworld


--------------------------------------------------------------------------------
/1/lab2/c.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/lab2/c.txt


--------------------------------------------------------------------------------
/1/lab2/change.c:
--------------------------------------------------------------------------------
  1 | //单表置换
  2 | 
  3 | #include<stdio.h>
  4 | #include<stdlib.h>
  5 | #include<string.h>
  6 | #include<ctype.h>
  7 | 
  8 | void encrypt(char *k){
  9 |     FILE *fp1 = fopen("origion.txt","r");
 10 |     FILE *fp2 = fopen("encrypt.txt","w");
 11 |     if(fp1==NULL)
 12 |     {
 13 |         printf("error!\n");
 14 |         exit;
 15 |     }
 16 |     int i=0,len=0;
 17 |     char a[10000],ch;
 18 |     while(fscanf(fp1,"%c",&ch)!=EOF){
 19 |         if(ch>='a'&&ch<='z')
 20 |             a[i] = toupper(ch);
 21 |         else
 22 |             a[i] = ch;
 23 |         i++;
 24 |         len++;
 25 |     }
 26 |     for(i=0;i<len;i++)
 27 |     {
 28 |         if(a[i]>='A'&&a[i]<='Z')
 29 |             a[i] = k[a[i] -'A'];
 30 |     }
 31 |     printf("%s\n",a);
 32 |     fputs(a,fp2);
 33 |     fclose(fp1);
 34 |     fclose(fp2);
 35 | }
 36 | void decrypt(char *k)
 37 | {
 38 |     FILE *fp1 = fopen("encrypt.txt","r");
 39 |     FILE *fp2 = fopen("decrypt.txt","w");
 40 |     if(fp1==NULL)
 41 |     {
 42 |         printf("error!\n");
 43 |         exit;
 44 |     }
 45 |     char b[10000]={0},ch;
 46 |     int i = 0,len = 0, j = 0;
 47 |     while(fscanf(fp1,"%c",&ch)!=EOF)
 48 |     {
 49 |         b[i] = ch;
 50 |         i++;
 51 |         len++;
 52 |     }
 53 |     for(i=0;i<len;i++)
 54 |     {
 55 |         if(b[i]>='A'&&b[i]<='Z')
 56 |         {
 57 |             for(j=0;j<26;j++)
 58 |             {
 59 |                 if(k[j]==b[i])
 60 |                     b[i] = 'a' + j;
 61 |             }
 62 |         }
 63 |     }
 64 |     for(i=0;i<len;i++)
 65 |     {
 66 |         b[i] = b[i] - 32;
 67 |     }
 68 |     printf("%s\n",b);
 69 |     fputs(b,fp2);
 70 |     fclose(fp1);
 71 |     fclose(fp2);
 72 | }
 73 | int main(){
 74 |     FILE *fp1,*fp2;
 75 |     int m;
 76 |     do{
 77 | 	    printf("加密请输入1\n解密请输入2\n退出请输入0\n");
 78 | 	    scanf("%d",&m);
 79 | 	    if(m==0)
 80 | 			break;
 81 | 		else if(m!=0&&m!=1&&m!=2)
 82 | 			printf("输出格式有误，请重新输入！\n");
 83 | 		else
 84 | 		{
 85 | 			char k[26]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'},
 86 | 	    	*c,*s;
 87 | 	    	c = (char*)malloc(sizeof(char));
 88 | 	    	s = (char*)malloc(sizeof(char));
 89 | 			getchar();
 90 | 		    printf("请输入密钥：\n");    
 91 | 		    scanf("%[^\n]",c);
 92 | 		    int len = strlen(c);
 93 | 		    int i,j;
 94 | 		    for(i=0,j=0;i<len;i++,j++){
 95 | 		        if(isupper(c[i]))
 96 | 		            s[j] = c[i];
 97 | 		        else if(islower(c[i]))
 98 | 		            s[j] = toupper(c[i]);
 99 | 		        else
100 | 		            j--;
101 | 		    }
102 | 		    len = strlen(s);
103 | 		    int flag = 0;
104 | 		    int min = 26;
105 | 		    for(i=0;i<len;i++){
106 | 		        int temp = 1;
107 | 		        for(j=0;j<flag;j++){
108 | 		            if(s[i]==k[j]){
109 | 		                temp = 0;
110 | 		                break;
111 | 		            }
112 | 		        }
113 | 		        if(temp){
114 | 		            if(s[i]!=k[flag]){ 
115 | 		                int n = (s[i]-'A'>min)?s[i]-'A':flag+s[i]-'A';
116 | 		                for(n;n>flag;n--){
117 | 		                    k[n] = k[n-1];
118 | 		                }
119 | 		                k[flag] = s[i];       
120 | 		            }
121 | 		            flag++;
122 | 		            if(s[i]-'A'<min)
123 | 		                min = s[i]-'A';
124 | 		        }
125 | 		    }
126 | 		
127 | 		    if(m==1)
128 | 		    {
129 | 		        encrypt(k);
130 | 		        printf("加密方成功进行加密！\n"); 
131 | 		    }
132 | 		    else if(m==2)
133 | 		    {
134 | 		        decrypt(k);
135 | 		        printf("解密方成功进行解密！\n");
136 | 		    }
137 | 		}
138 | 	    
139 | 	}while(m!=0);
140 |    
141 |     return 0;
142 | }
143 | 
144 | 


--------------------------------------------------------------------------------
/1/lab2/change.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/lab2/change.exe


--------------------------------------------------------------------------------
/1/lab2/decrypt.txt:
--------------------------------------------------------------------------------
1 | HELLOWORLD


--------------------------------------------------------------------------------
/1/lab2/encrypt.txt:
--------------------------------------------------------------------------------
1 | COGGNWNRGM


--------------------------------------------------------------------------------
/1/lab2/origion.txt:
--------------------------------------------------------------------------------
1 | HELLOWORLD


--------------------------------------------------------------------------------
/1/lab3/decrypt.txt:
--------------------------------------------------------------------------------
1 | HelloWorld


--------------------------------------------------------------------------------
/1/lab3/encrypt.txt:
--------------------------------------------------------------------------------
1 | RcllaOaplx


--------------------------------------------------------------------------------
/1/lab3/fangshe.cpp:
--------------------------------------------------------------------------------
  1 | //仿射密码
  2 | 
  3 | #include<stdio.h>
  4 | #include<stdlib.h>
  5 | #include<string.h>
  6 | #include<ctype.h>
  7 | 
  8 | //计算a在模m下的乘法逆元。
  9 | //通过遍历1到m-1的整数，找到满足(i * a) % m = 1的数i，并返回i。
 10 | //如果不存在则返回0。 
 11 | int getinverse(int a,int m){
 12 | 	int i; 
 13 |     for(i=1;i<m;i++){
 14 |         if( (i*a) % m == 1)
 15 |             return i;
 16 |     }
 17 | }
 18 | //求a和b的最大公约数。
 19 | //使用辗转相除法（欧几里德算法）计算a和b的最大公约数，直到b为0，返回a的值。
 20 | int gcd(int a,int b){
 21 |     while(b!=0){
 22 |         int temp = a;
 23 |         a = b;
 24 |         b = temp % b;
 25 |     }
 26 |     return a;
 27 | }
 28 | //判断a和b是否互质
 29 | //原理即调用gcd函数计算a和b的最大公约数
 30 | //如果最大公约数为1，则返回1，否则返回0。
 31 | int ifisPrime(int a,int b){
 32 |     if(gcd(a,b)==1)
 33 |         return 1;
 34 |     else 
 35 |         return 0;
 36 | }
 37 | 
 38 | //对明文进行加密
 39 | void encrypt(int a,int b){
 40 |     int m = 26,i=0,len=0;
 41 |     char c[10000] = {0},ch;
 42 |     FILE *fp1,*fp2;
 43 |     fp1 = fopen("origion.txt","r");
 44 |     fp2 = fopen("encrypt.txt","w");
 45 |     if(fp1==NULL){
 46 |         printf("open file error!\n");
 47 |         exit;
 48 |     }
 49 |     while(fscanf(fp1,"%c",&ch)!=EOF){
 50 |         c[i] = ch;
 51 |         i++;
 52 |     }
 53 |     len = strlen(c);
 54 |     for(i=0;i<len;i++){
 55 |     	if(islower(c[i]))
 56 |             c[i] = 'a' + ( (a * (c[i] - 'a') + b) % 26);
 57 |         if(isupper(c[i]))
 58 |             c[i] = 'A' + ( (a * (c[i] - 'A') + b) % 26);
 59 |     }
 60 |     fputs(c,fp2);
 61 |     
 62 |     fclose(fp1);
 63 |     fclose(fp2);
 64 |     printf("加密密文为：%s\n",c);
 65 | 	printf("加密方成功进行加密！\n");
 66 | }
 67 | 
 68 | //对密文进行解密。
 69 | void decrypt(int a,int b){
 70 |     FILE *fp1,*fp2;
 71 |     fp1 = fopen("encrypt.txt","r");
 72 |     fp2 = fopen("decrypt.txt","w");
 73 |     if(fp1==NULL){
 74 |         printf("open file error!\n");
 75 |         exit;
 76 |     }
 77 |     char c[10000] = {0},ch;
 78 |     int i=0,len=0,inva = getinverse(a,26);
 79 |     while(fscanf(fp1,"%c",&ch)!=EOF){
 80 |         c[i] = ch;
 81 |         i++;
 82 |     }
 83 |     len = strlen(c);
 84 |     for(i=0;i<len;i++){
 85 |         if(islower(c[i])){
 86 |             if((c[i] - 'a') < b)
 87 |                 c[i] = ( inva * (c[i] - 'a' - b + 26) % 26) + 'a'; 
 88 |             else
 89 |                 c[i] = ( inva * (c[i] - 'a' - b)  % 26) + 'a'; 
 90 |         }
 91 |         if(isupper(c[i])){
 92 |             if((c[i] - 'A') < b)
 93 |                 c[i] = ( inva * (c[i] - 'A' - b + 26) % 26) + 'A'; 
 94 |             else
 95 |                 c[i] = ( inva * (c[i] - 'A' - b)  % 26) + 'A'; 
 96 |         }
 97 |     }
 98 |     fputs(c,fp2);
 99 |     fclose(fp1);
100 |     fclose(fp2); 
101 |     printf("解密所得明文为：%s\n",c);
102 | 	printf("解密方成功进行解密！\n");
103 | }
104 | int main(){
105 |     int a,b,m;
106 |     do{
107 | 		printf("加密请输入1\n解密请输入2\n退出请输入0\n");
108 |     	scanf("%d",&m);
109 |     	if(m==0)
110 |     		break;
111 |     	else if(m!=0&&m!=1&&m!=2)
112 |     		printf("输入有误，请重新输入！\n");
113 |     	else{
114 | 		    printf("请输入密钥a、b，其中a与26互素\n");
115 | 		    scanf("%d %d",&a,&b);
116 | 		    if(!(ifisPrime(a,26))){
117 | 		        while(!(ifisPrime(a,26))){
118 | 		            printf("经检测，输入a值与26不满足互素条件，请输入与26互素的a!\n");
119 | 		            scanf("%d",&a);
120 | 		        }
121 | 		    }
122 | 		    if(m==1)
123 | 		        encrypt(a,b);
124 | 		    else if(m==2)
125 | 		        decrypt(a,b);
126 | 		}
127 | 	}while(m!=3); 
128 |     return 0;
129 | }
130 | 
131 | 


--------------------------------------------------------------------------------
/1/lab3/fangshe.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/lab3/fangshe.exe


--------------------------------------------------------------------------------
/1/lab3/origion.txt:
--------------------------------------------------------------------------------
1 | HelloWorld


--------------------------------------------------------------------------------
/1/lab4/DES.cpp:
--------------------------------------------------------------------------------
  1 | #include "stdio.h"
  2 | #include "memory.h"
  3 | #include "time.h"
  4 | #include "stdlib.h"
  5 |   
  6 | #define PLAIN_FILE_OPEN_ERROR -1
  7 | #define KEY_FILE_OPEN_ERROR -2
  8 | #define CIPHER_FILE_OPEN_ERROR -3
  9 | #define OK 1 
 10 | typedef char ElemType; 
 11 |  /*初始置换表IP*/
 12 | int IP_Table[64] = {  57,49,41,33,25,17,9,1,
 13 | 59,51,43,35,27,19,11,3,
 14 | 61,53,45,37,29,21,13,5,
 15 | 63,55,47,39,31,23,15,7,
 16 | 56,48,40,32,24,16,8,0,
 17 | 58,50,42,34,26,18,10,2,
 18 | 60,52,44,36,28,20,12,4,
 19 | 62,54,46,38,30,22,14,6}; 
 20 | /*逆初始置换表IP^-1*/
 21 | int IP_1_Table[64] = {39,7,47,15,55,23,63,31,
 22 |   38,6,46,14,54,22,62,30,
 23 |   37,5,45,13,53,21,61,29,
 24 |   36,4,44,12,52,20,60,28,
 25 |   35,3,43,11,51,19,59,27,
 26 |   34,2,42,10,50,18,58,26,
 27 |   33,1,41,9,49,17,57,25,
 28 |   32,0,40,8,48,16,56,24};
 29 |   
 30 | /*扩充置换表E*/
 31 | int E_Table[48] = {31, 0, 1, 2, 3, 4,
 32 | 3,  4, 5, 6, 7, 8,
 33 | 7,  8,9,10,11,12,
 34 | 11,12,13,14,15,16,
 35 | 15,16,17,18,19,20,
 36 | 19,20,21,22,23,24,
 37 | 23,24,25,26,27,28,
 38 | 27,28,29,30,31, 0};
 39 |   
 40 | /*置换函数P*/
 41 | int P_Table[32] = {15,6,19,20,28,11,27,16,
 42 | 0,14,22,25,4,17,30,9,
 43 | 1,7,23,13,31,26,2,8,
 44 | 18,12,29,5,21,10,3,24};
 45 |   
 46 | /*S盒*/
 47 | int S[8][4][16] =
 48 | /*S1*/
 49 | {{{14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
 50 |   {0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
 51 |  {4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
 52 |  {15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}},
 53 |  /*S2*/
 54 |   {{15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},
 55 |   {3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},
 56 |   {0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},
 57 |   {13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9}},
 58 |   /*S3*/
 59 |   {{10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8},
 60 |   {13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1},
 61 |  {13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7},
 62 |   {1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}},
 63 |   /*S4*/
 64 |   {{7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15},
 65 |   {13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},
 66 |   {10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},
 67 |   {3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14}},
 68 |   /*S5*/
 69 |   {{2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},
 70 |   {14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},
 71 |   {4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},
 72 |   {11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3}},
 73 |   /*S6*/
 74 |   {{12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},
 75 |   {10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},
 76 |   {9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},
 77 |   {4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13}},
 78 |   /*S7*/
 79 |   {{4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},
 80 |   {13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},
 81 |   {1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},
 82 |   {6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12}},
 83 |   /*S8*/
 84 |   {{13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},
 85 |   {1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},
 86 |   {7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},
 87 |   {2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11}}};
 88 | /*置换选择1*/
 89 | int PC_1[56] = {56,48,40,32,24,16,8,
 90 |   0,57,49,41,33,25,17,
 91 |   9,1,58,50,42,34,26,
 92 |   18,10,2,59,51,43,35,
 93 |   62,54,46,38,30,22,14,
 94 |   6,61,53,45,37,29,21,
 95 |   13,5,60,52,44,36,28,
 96 |   20,12,4,27,19,11,3};
 97 |   
 98 | /*置换选择2*/
 99 | int PC_2[48] = {13,16,10,23,0,4,2,27,
100 |   14,5,20,9,22,18,11,3,
101 |   25,7,15,6,26,19,12,1,
102 |   40,51,30,36,46,54,29,39,
103 |   50,44,32,46,43,48,38,55,
104 |   33,52,45,41,49,35,28,31};
105 |   
106 | /*对左移次数的规定*/
107 | int MOVE_TIMES[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};  
108 | int ByteToBit(ElemType ch,ElemType bit[8]);
109 | int BitToByte(ElemType bit[8],ElemType *ch);
110 | int Char8ToBit64(ElemType ch[8],ElemType bit[64]);
111 | int Bit64ToChar8(ElemType bit[64],ElemType ch[8]);
112 | int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]);
113 | int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]);
114 | int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]);
115 | int DES_ROL(ElemType data[56], int time);
116 | int DES_IP_Transform(ElemType data[64]);
117 | int DES_IP_1_Transform(ElemType data[64]);
118 | int DES_E_Transform(ElemType data[48]);
119 | int DES_P_Transform(ElemType data[32]);
120 | int DES_SBOX(ElemType data[48]);
121 | int DES_XOR(ElemType R[48], ElemType L[48],int count);
122 | int DES_Swap(ElemType left[32],ElemType right[32]);
123 | int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]);
124 | int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48], ElemType plainBlock[8]);
125 | int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile);
126 | int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile);  
127 | /*字节转换成二进制*/
128 | int ByteToBit(ElemType ch, ElemType bit[8]){
129 |  int cnt;
130 |  for(cnt = 0;cnt < 8; cnt++){
131 |   *(bit+cnt) = (ch>>cnt)&1;
132 |  }
133 |  return 0;
134 | }
135 |   
136 | /*二进制转换成字节*/
137 | int BitToByte(ElemType bit[8],ElemType *ch){
138 |  int cnt;
139 |  for(cnt = 0;cnt < 8; cnt++){
140 |   *ch |= *(bit + cnt)<<cnt;
141 |  }
142 |  return 0;
143 | }
144 |   
145 | /*将长度为8的字符串转为二进制位串*/
146 | int Char8ToBit64(ElemType ch[8],ElemType bit[64]){
147 |  int cnt;
148 |  for(cnt = 0; cnt < 8; cnt++){  
149 |   ByteToBit(*(ch+cnt),bit+(cnt<<3));
150 |  }
151 |  return 0;
152 | }
153 |   
154 | /*将二进制位串转为长度为8的字符串*/
155 | int Bit64ToChar8(ElemType bit[64],ElemType ch[8]){
156 |  int cnt;
157 |  memset(ch,0,8);
158 |  for(cnt = 0; cnt < 8; cnt++){
159 |   BitToByte(bit+(cnt<<3),ch+cnt);
160 |  }
161 |  return 0;
162 | }
163 |   
164 | /*生成子密钥*/
165 | int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]){
166 |  ElemType temp[56];
167 |  int cnt;
168 |  DES_PC1_Transform(key,temp);/*PC1置换*/
169 |  for(cnt = 0; cnt < 16; cnt++){/*16轮跌代，产生16个子密钥*/
170 |   DES_ROL(temp,MOVE_TIMES[cnt]);/*循环左移*/
171 |   DES_PC2_Transform(temp,subKeys[cnt]);/*PC2置换，产生子密钥*/
172 |  }
173 |  return 0;
174 | }
175 |   
176 | /*密钥置换1*/
177 | int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]){
178 |  int cnt; 
179 |  for(cnt = 0; cnt < 56; cnt++){
180 |   tempbts[cnt] = key[PC_1[cnt]];
181 |  }
182 |  return 0;
183 | }
184 |   
185 | /*密钥置换2*/
186 | int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]){
187 |  int cnt;
188 |  for(cnt = 0; cnt < 48; cnt++){
189 |   tempbts[cnt] = key[PC_2[cnt]];
190 |  }
191 |  return 0;
192 | }
193 |   
194 | /*循环左移*/
195 | int DES_ROL(ElemType data[56], int time){
196 |  ElemType temp[56];
197 |   
198 |  /*保存将要循环移动到右边的位*/
199 |  memcpy(temp,data,time);
200 |  memcpy(temp+time,data+28,time);
201 |  
202 |  /*前28位移动*/
203 |  memcpy(data,data+time,28-time);
204 |  memcpy(data+28-time,temp,time);
205 |   
206 |  /*后28位移动*/
207 |  memcpy(data+28,data+28+time,28-time);
208 |  memcpy(data+56-time,temp+time,time); 
209 |   
210 |  return 0;
211 | }
212 |   
213 | /*IP置换*/
214 | int DES_IP_Transform(ElemType data[64]){
215 |  int cnt;
216 |  ElemType temp[64];
217 |  for(cnt = 0; cnt < 64; cnt++){
218 |   temp[cnt] = data[IP_Table[cnt]];
219 |  }
220 |  memcpy(data,temp,64);
221 |  return 0;
222 | }
223 |   
224 | /*IP逆置换*/
225 | int DES_IP_1_Transform(ElemType data[64]){
226 |  int cnt;
227 |  ElemType temp[64];
228 |  for(cnt = 0; cnt < 64; cnt++){
229 |   temp[cnt] = data[IP_1_Table[cnt]];
230 |  }
231 |  memcpy(data,temp,64);
232 |  return 0;
233 | }
234 |   
235 | /*扩展置换*/
236 | int DES_E_Transform(ElemType data[48]){
237 |  int cnt;
238 |  ElemType temp[48];
239 |  for(cnt = 0; cnt < 48; cnt++){
240 |   temp[cnt] = data[E_Table[cnt]];
241 |  }
242 |  memcpy(data,temp,48);
243 |  return 0;
244 | }
245 |   
246 | /*P置换*/
247 | int DES_P_Transform(ElemType data[32]){
248 |  int cnt;
249 |  ElemType temp[32];
250 |  for(cnt = 0; cnt < 32; cnt++){
251 |   temp[cnt] = data[P_Table[cnt]];
252 |  }
253 |  memcpy(data,temp,32);
254 |  return 0;
255 | }
256 |   
257 | /*异或*/
258 | int DES_XOR(ElemType R[48], ElemType L[48] ,int count){
259 |  int cnt;
260 |  for(cnt = 0; cnt < count; cnt++){
261 |   R[cnt] ^= L[cnt];
262 |  }
263 |  return 0;
264 | }
265 |   
266 | /*S盒置换*/
267 | int DES_SBOX(ElemType data[48]){
268 |  int cnt;
269 |  int line,row,output;
270 |  int cur1,cur2;
271 |  for(cnt = 0; cnt < 8; cnt++){
272 |   cur1 = cnt*6;
273 |   cur2 = cnt<<2;
274 |   
275 |   /*计算在S盒中的行与列*/
276 |   line = (data[cur1]<<1) + data[cur1+5];
277 |   row = (data[cur1+1]<<3) + (data[cur1+2]<<2)
278 | + (data[cur1+3]<<1) + data[cur1+4];
279 |   output = S[cnt][line][row];
280 |   
281 |   /*化为2进制*/
282 |   data[cur2] = (output&0X08)>>3;
283 |   data[cur2+1] = (output&0X04)>>2;
284 |   data[cur2+2] = (output&0X02)>>1;
285 |   data[cur2+3] = output&0x01;
286 |  }
287 |  return 0;
288 | }
289 |   
290 | /*交换*/
291 | int DES_Swap(ElemType left[32], ElemType right[32]){
292 |  ElemType temp[32];
293 |  memcpy(temp,left,32);
294 |  memcpy(left,right,32);  
295 |  memcpy(right,temp,32);
296 |  return 0;
297 | }
298 |   
299 | /*加密单个分组*/
300 | int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]){
301 |  ElemType plainBits[64];
302 |  ElemType copyRight[48];
303 |  int cnt;
304 |   
305 |  Char8ToBit64(plainBlock,plainBits);  
306 |  /*初始置换（IP置换）*/
307 |  DES_IP_Transform(plainBits);
308 |   
309 |  /*16轮迭代*/
310 |  for(cnt = 0; cnt < 16; cnt++){ 
311 |   memcpy(copyRight,plainBits+32,32);
312 |   /*将右半部分进行扩展置换，从32位扩展到48位*/
313 |   DES_E_Transform(copyRight);
314 |   /*将右半部分与子密钥进行异或操作*/
315 |   DES_XOR(copyRight,subKeys[cnt],48); 
316 |   /*异或结果进入S盒，输出32位结果*/
317 |   DES_SBOX(copyRight);
318 |   /*P置换*/
319 |   DES_P_Transform(copyRight);
320 |   /*将明文左半部分与右半部分进行异或*/
321 |   DES_XOR(plainBits,copyRight,32);
322 |   if(cnt != 15){
323 | /*最终完成左右部的交换*/
324 | DES_Swap(plainBits,plainBits+32);
325 |   }
326 |  }
327 |  /*逆初始置换（IP^1置换）*/
328 |  DES_IP_1_Transform(plainBits);
329 |  Bit64ToChar8(plainBits,cipherBlock);
330 |  return 0;
331 | }
332 |   
333 | /*解密单个分组*/
334 | int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48],ElemType plainBlock[8]){
335 |  	 ElemType cipherBits[64];
336 | 	 ElemType copyRight[48];
337 | 	 int cnt;
338 | 	  
339 | 	 Char8ToBit64(cipherBlock,cipherBits); 
340 | 	 /*初始置换（IP置换）*/
341 | 	 DES_IP_Transform(cipherBits);
342 | 	 
343 | 	 /*16轮迭代*/
344 | 	 for(cnt = 15; cnt >= 0; cnt--){
345 | 	 	memcpy(copyRight,cipherBits+32,32);
346 | 		  /*将右半部分进行扩展置换，从32位扩展到48位*/
347 | 		  DES_E_Transform(copyRight);
348 | 		  /*将右半部分与子密钥进行异或操作*/
349 | 		  DES_XOR(copyRight,subKeys[cnt],48);  
350 | 		  /*异或结果进入S盒，输出32位结果*/
351 | 		  DES_SBOX(copyRight);
352 | 		  /*P置换*/
353 | 		  DES_P_Transform(copyRight);  
354 | 		  /*将明文左半部分与右半部分进行异或*/
355 | 		  DES_XOR(cipherBits,copyRight,32);
356 | 		  if(cnt != 0){
357 | 				/*最终完成左右部的交换*/
358 | 				DES_Swap(cipherBits,cipherBits+32);
359 | 	  	}
360 | 	 }
361 | 	 /*逆初始置换（IP^1置换）*/
362 | 	 DES_IP_1_Transform(cipherBits);
363 | 	 Bit64ToChar8(cipherBits,plainBlock);
364 | 	 return 0;
365 | }
366 |   
367 | /*加密文件*/
368 | int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile){
369 | 	FILE *plain,*cipher;
370 | 	int count;
371 | 	ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
372 | 	ElemType bKey[64];
373 | 	ElemType subKeys[16][48];
374 | 	if((plain = fopen(plainFile,"rb")) == NULL){
375 | 		return PLAIN_FILE_OPEN_ERROR;
376 | 	}
377 | 	if((cipher = fopen(cipherFile,"wb")) == NULL){
378 | 		return CIPHER_FILE_OPEN_ERROR;
379 | 	}
380 | 	/*设置密钥*/
381 |  	memcpy(keyBlock,keyStr,8);
382 |  	/*将密钥转换为二进制流*/
383 |  	Char8ToBit64(keyBlock,bKey);
384 |  	/*生成子密钥*/
385 |  	DES_MakeSubKeys(bKey,subKeys);
386 |  
387 |  	while(!feof(plain)){
388 |   		/*每次读8个字节，并返回成功读取的字节数*/
389 |  		if((count = fread(plainBlock,sizeof(char),8,plain)) == 8){
390 | 			DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
391 | 			fwrite(cipherBlock,sizeof(char),8,cipher);  
392 |   		}
393 |  	}
394 |  	if(count){
395 |   		/*填充*/
396 |   		memset(plainBlock + count,'\0',7 - count);
397 |   		/*最后一个字符保存包括最后一个字符在内的所填充的字符数量*/
398 |   		plainBlock[7] = 8 - count;
399 |   		DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
400 |   		fwrite(cipherBlock,sizeof(char),8,cipher);
401 |  	}
402 |  	fclose(plain);
403 |  	fclose(cipher);
404 |  	printf("加密成功！\n");
405 | }
406 |   
407 | /*解密文件*/
408 | int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile){
409 | 	FILE *plain, *cipher;
410 | 	int count,times = 0;
411 | 	long fileLen;
412 | 	ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
413 | 	ElemType bKey[64];
414 | 	ElemType subKeys[16][48];
415 | 	if((cipher = fopen(cipherFile,"rb")) == NULL){
416 |   		return CIPHER_FILE_OPEN_ERROR;
417 | 	}
418 | 	if((plain = fopen(plainFile,"wb")) == NULL){
419 | 		return PLAIN_FILE_OPEN_ERROR;
420 | 	}
421 |   
422 |  	/*设置密钥*/
423 |  	memcpy(keyBlock,keyStr,8);
424 |  	/*将密钥转换为二进制流*/
425 |  	Char8ToBit64(keyBlock,bKey);
426 |  	/*生成子密钥*/
427 |  	DES_MakeSubKeys(bKey,subKeys);
428 |   
429 |  	/*取文件长度 */
430 |  	fseek(cipher,0,SEEK_END);/*将文件指针置尾*/
431 |  	fileLen = ftell(cipher); /*取文件指针当前位置*/
432 |  	rewind(cipher); /*将文件指针重指向文件头*/
433 | 	while(1){
434 |   		/*密文的字节数一定是8的整数倍*/
435 |   		fread(cipherBlock,sizeof(char),8,cipher);
436 |   		DES_DecryptBlock(cipherBlock,subKeys,plainBlock);  
437 |   		times += 8;
438 | 	  	if(times < fileLen){
439 | 			fwrite(plainBlock,sizeof(char),8,plain);
440 | 	  	}
441 | 	  	else{
442 | 			break;
443 | 	  	}
444 |  	}
445 |  	/*判断末尾是否被填充*/
446 |  	if(plainBlock[7] < 8){
447 | 	  	for(count = 8 - plainBlock[7]; count < 7; count++){
448 | 			if(plainBlock[count] != '\0'){
449 | 	 			break;
450 | 			}
451 | 	  	}
452 |  	}
453 |  	if(count == 7){/*有填充*/
454 |   		fwrite(plainBlock,sizeof(char),8 - plainBlock[7],plain);
455 |  	}
456 | 	 else{/*无填充*/
457 | 	  	fwrite(plainBlock,sizeof(char),8,plain);
458 | 	 }
459 |   
460 | 	 fclose(plain);
461 | 	 fclose(cipher);
462 | 	 printf("解密成功！\n");
463 | }  
464 | int main(){ 
465 | 	printf("DES加解密程序:\n");
466 | 	int ss;
467 | 	while(1){
468 | 		printf("请选择工作模式：1.加密；2.解密；0.退出\n");
469 | 	    int ss,n;
470 | 	    scanf("%d",&ss);
471 |         if(ss==1){
472 | 	        char m1[100],m2[100],m3[100];
473 | 			printf("请输入明文文件 秘钥文件 加密后的密文存入文件：\n");
474 | 	        scanf("%s %s %s", &m1,&m2,&m3);
475 |             DES_Encrypt(m1,m2,m3);
476 | 		}
477 |         else if(ss==2){
478 |             char m11[100],m22[100],m33[100];
479 |             printf("请输入密文文件 秘钥文件 解密后的明文存入文件：\n");
480 | 	        scanf("%s %s %s", &m11,&m22,&m33);
481 |             DES_Decrypt(m11,m22,m33);
482 | 		}
483 | 		else if(ss==0)
484 | 			break;
485 | 		else
486 | 			printf("输入有误，请重新输入！\n");
487 | 	}
488 |     return 0;
489 | }
490 | 


--------------------------------------------------------------------------------
/1/lab4/DES.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/lab4/DES.exe


--------------------------------------------------------------------------------
/1/lab4/c.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/lab4/c.txt


--------------------------------------------------------------------------------
/1/lab4/d.txt:
--------------------------------------------------------------------------------
1 | HelloWorldddddd


--------------------------------------------------------------------------------
/1/lab4/k.txt:
--------------------------------------------------------------------------------
1 | 29183121


--------------------------------------------------------------------------------
/1/lab4/p.txt:
--------------------------------------------------------------------------------
1 | HelloWorldddddd


--------------------------------------------------------------------------------
/1/lab5/AES.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <bitset>
  3 | #include <string>
  4 | using namespace std;
  5 | typedef bitset<8> byte;
  6 | typedef bitset<32> word;
  7 | 
  8 | const int Nr = 10;  // AES-128需要 10 轮加密
  9 | const int Nk = 4;   // Nk 表示输入密钥的 word 个数
 10 | 
 11 | byte S_Box[16][16] = {
 12 | 	{ 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76 },
 13 | 	{ 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0 },
 14 | 	{ 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15 },
 15 | 	{ 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75 },
 16 | 	{ 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84 },
 17 | 	{ 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF },
 18 | 	{ 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8 },
 19 | 	{ 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2 },
 20 | 	{ 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73 },
 21 | 	{ 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB },
 22 | 	{ 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79 },
 23 | 	{ 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08 },
 24 | 	{ 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A },
 25 | 	{ 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E },
 26 | 	{ 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF },
 27 | 	{ 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16 }
 28 | };
 29 | 
 30 | byte Inv_S_Box[16][16] = {
 31 | 	{ 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB },
 32 | 	{ 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB },
 33 | 	{ 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E },
 34 | 	{ 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25 },
 35 | 	{ 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92 },
 36 | 	{ 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84 },
 37 | 	{ 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06 },
 38 | 	{ 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B },
 39 | 	{ 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73 },
 40 | 	{ 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E },
 41 | 	{ 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B },
 42 | 	{ 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4 },
 43 | 	{ 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F },
 44 | 	{ 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF },
 45 | 	{ 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61 },
 46 | 	{ 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D }
 47 | };
 48 | 
 49 | // 轮常数，密钥扩展中用到。（AES-128只需要10轮）
 50 | word Rcon[10] = { 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000,
 51 | 0x20000000, 0x40000000, 0x80000000, 0x1b000000, 0x36000000 };
 52 | 
 53 | 
 54 | //字节替换变换 - 前4位为行号，后4位为列号
 55 | void SubBytes(byte mtx[4 * 4])
 56 | {
 57 | 	for (int i = 0; i<16; ++i)
 58 | 	{
 59 | 		int row = mtx[i][7] * 8 + mtx[i][6] * 4 + mtx[i][5] * 2 + mtx[i][4];
 60 | 		int col = mtx[i][3] * 8 + mtx[i][2] * 4 + mtx[i][1] * 2 + mtx[i][0];
 61 | 		mtx[i] = S_Box[row][col];
 62 | 	}
 63 | }
 64 | 
 65 | //行移位变换 - 按字节循环移位
 66 | void ShiftRows(byte mtx[4 * 4])
 67 | {
 68 | 	// 第二行循环左移一位
 69 | 	byte temp = mtx[4];
 70 | 	for (int i = 0; i<3; ++i)
 71 | 		mtx[i + 4] = mtx[i + 5];
 72 | 	mtx[7] = temp;
 73 | 	// 第三行循环左移两位
 74 | 	for (int i = 0; i<2; ++i)
 75 | 	{
 76 | 		temp = mtx[i + 8];
 77 | 		mtx[i + 8] = mtx[i + 10];
 78 | 		mtx[i + 10] = temp;
 79 | 	}
 80 | 	// 第四行循环左移三位
 81 | 	temp = mtx[15];
 82 | 	for (int i = 3; i>0; --i)
 83 | 		mtx[i + 12] = mtx[i + 11];
 84 | 	mtx[12] = temp;
 85 | }
 86 | 
 87 | //有限域上的乘法 GF(2^8)
 88 | byte GFMul(byte a, byte b)
 89 | {
 90 | 	byte p = 0;
 91 | 	byte hi_bit_set;
 92 | 	for (int counter = 0; counter < 8; counter++) {
 93 | 		if ((b & byte(1)) != 0) {
 94 | 			p ^= a;
 95 | 		}
 96 | 		hi_bit_set = (byte)(a & byte(0x80));
 97 | 		a <<= 1;
 98 | 		if (hi_bit_set != 0) {
 99 | 			a ^= 0x1b; /* x^8 + x^4 + x^3 + x + 1 */
100 | 		}
101 | 		b >>= 1;
102 | 	}
103 | 	return p;
104 | }
105 | 
106 | //列混合变换
107 | void MixColumns(byte mtx[4 * 4])
108 | {
109 | 	byte arr[4];
110 | 	for (int i = 0; i<4; ++i)
111 | 	{
112 | 		for (int j = 0; j<4; ++j)
113 | 			arr[j] = mtx[i + j * 4];
114 | 
115 | 		mtx[i] = GFMul(0x02, arr[0]) ^ GFMul(0x03, arr[1]) ^ arr[2] ^ arr[3];
116 | 		mtx[i + 4] = arr[0] ^ GFMul(0x02, arr[1]) ^ GFMul(0x03, arr[2]) ^ arr[3];
117 | 		mtx[i + 8] = arr[0] ^ arr[1] ^ GFMul(0x02, arr[2]) ^ GFMul(0x03, arr[3]);
118 | 		mtx[i + 12] = GFMul(0x03, arr[0]) ^ arr[1] ^ arr[2] ^ GFMul(0x02, arr[3]);
119 | 	}
120 | }
121 | 
122 | //轮密钥加变换 - 将每一列与扩展密钥进行异或
123 | void AddRoundKey(byte mtx[4 * 4], word k[4])
124 | {
125 | 	for (int i = 0; i<4; ++i)
126 | 	{
127 | 		word k1 = k[i] >> 24;
128 | 		word k2 = (k[i] << 8) >> 24;
129 | 		word k3 = (k[i] << 16) >> 24;
130 | 		word k4 = (k[i] << 24) >> 24;
131 | 
132 | 		mtx[i] = mtx[i] ^ byte(k1.to_ulong());
133 | 		mtx[i + 4] = mtx[i + 4] ^ byte(k2.to_ulong());
134 | 		mtx[i + 8] = mtx[i + 8] ^ byte(k3.to_ulong());
135 | 		mtx[i + 12] = mtx[i + 12] ^ byte(k4.to_ulong());
136 | 	}
137 | }
138 | 
139 | //逆字节替换变换
140 | void InvSubBytes(byte mtx[4 * 4])
141 | {
142 | 	for (int i = 0; i<16; ++i)
143 | 	{
144 | 		int row = mtx[i][7] * 8 + mtx[i][6] * 4 + mtx[i][5] * 2 + mtx[i][4];
145 | 		int col = mtx[i][3] * 8 + mtx[i][2] * 4 + mtx[i][1] * 2 + mtx[i][0];
146 | 		mtx[i] = Inv_S_Box[row][col];
147 | 	}
148 | }
149 | 
150 | //逆行移位变换 - 以字节为单位循环右移
151 | void InvShiftRows(byte mtx[4 * 4])
152 | {
153 | 	// 第二行循环右移一位
154 | 	byte temp = mtx[7];
155 | 	for (int i = 3; i>0; --i)
156 | 		mtx[i + 4] = mtx[i + 3];
157 | 	mtx[4] = temp;
158 | 	// 第三行循环右移两位
159 | 	for (int i = 0; i<2; ++i)
160 | 	{
161 | 		temp = mtx[i + 8];
162 | 		mtx[i + 8] = mtx[i + 10];
163 | 		mtx[i + 10] = temp;
164 | 	}
165 | 	// 第四行循环右移三位
166 | 	temp = mtx[12];
167 | 	for (int i = 0; i<3; ++i)
168 | 		mtx[i + 12] = mtx[i + 13];
169 | 	mtx[15] = temp;
170 | }
171 | 
172 | //逆列混合变换 
173 | void InvMixColumns(byte mtx[4 * 4])
174 | {
175 | 	byte arr[4];
176 | 	for (int i = 0; i<4; ++i)
177 | 	{
178 | 		for (int j = 0; j<4; ++j)
179 | 			arr[j] = mtx[i + j * 4];
180 | 
181 | 		mtx[i] = GFMul(0x0e, arr[0]) ^ GFMul(0x0b, arr[1]) ^ GFMul(0x0d, arr[2]) ^ GFMul(0x09, arr[3]);
182 | 		mtx[i + 4] = GFMul(0x09, arr[0]) ^ GFMul(0x0e, arr[1]) ^ GFMul(0x0b, arr[2]) ^ GFMul(0x0d, arr[3]);
183 | 		mtx[i + 8] = GFMul(0x0d, arr[0]) ^ GFMul(0x09, arr[1]) ^ GFMul(0x0e, arr[2]) ^ GFMul(0x0b, arr[3]);
184 | 		mtx[i + 12] = GFMul(0x0b, arr[0]) ^ GFMul(0x0d, arr[1]) ^ GFMul(0x09, arr[2]) ^ GFMul(0x0e, arr[3]);
185 | 	}
186 | }
187 | 
188 | //将4个 byte 转换为一个 word
189 | word Word(byte& k1, byte& k2, byte& k3, byte& k4)
190 | {
191 | 	word result(0x00000000);
192 | 	word temp;
193 | 	temp = k1.to_ulong();  // K1
194 | 	temp <<= 24;
195 | 	result |= temp;
196 | 	temp = k2.to_ulong();  // K2
197 | 	temp <<= 16;
198 | 	result |= temp;
199 | 	temp = k3.to_ulong();  // K3
200 | 	temp <<= 8;
201 | 	result |= temp;
202 | 	temp = k4.to_ulong();  // K4
203 | 	result |= temp;
204 | 	return result;
205 | }
206 | 
207 | //按字节 循环左移一位
208 | word RotWord(word& rw)
209 | {
210 | 	word high = rw << 8;
211 | 	word low = rw >> 24;
212 | 	return high | low;
213 | }
214 | 
215 | //对输入word中的每一个字节进行字节替换变换
216 | word SubWord(word& sw)
217 | {
218 | 	word temp;
219 | 	for (int i = 0; i<32; i += 8)
220 | 	{
221 | 		int row = sw[i + 7] * 8 + sw[i + 6] * 4 + sw[i + 5] * 2 + sw[i + 4];
222 | 		int col = sw[i + 3] * 8 + sw[i + 2] * 4 + sw[i + 1] * 2 + sw[i];
223 | 		byte val = S_Box[row][col];
224 | 		for (int j = 0; j<8; ++j)
225 | 			temp[i + j] = val[j];
226 | 	}
227 | 	return temp;
228 | }
229 | 
230 | //密钥扩展函数 - 对128位密钥进行扩展得到 w[4*(Nr+1)] 
231 | void KeyExpansion(byte key[4 * Nk], word w[4 * (Nr + 1)]){
232 | 	word temp;
233 | 	int i = 0;
234 | 	// w[]的前4个就是输入的key
235 | 	while (i < Nk){
236 | 		w[i] = Word(key[4 * i], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3]);
237 | 		++i;
238 | 	}
239 | 	i = Nk;
240 | 	while (i < 4 * (Nr + 1))	{
241 | 		temp = w[i - 1]; // 记录前一个word
242 | 		if (i % Nk == 0){
243 | 			word temp2 = RotWord(temp);
244 | 			w[i] = w[i - Nk] ^ SubWord(temp2) ^ Rcon[i / Nk - 1];
245 | 		}
246 | 		else
247 | 			w[i] = w[i - Nk] ^ temp;
248 | 		++i;
249 | 	}
250 | }
251 | 
252 | //加密 
253 | void encrypt(byte in[4 * 4], word w[4 * (Nr + 1)]){
254 | 	word key[4];
255 | 	for (int i = 0; i<4; ++i)
256 | 		key[i] = w[i];
257 | 	AddRoundKey(in, key);
258 | 
259 | 	for (int round = 1; round<Nr; ++round)
260 | 	{
261 | 		SubBytes(in);
262 | 		ShiftRows(in);
263 | 		MixColumns(in);
264 | 		for (int i = 0; i<4; ++i)
265 | 			key[i] = w[4 * round + i];
266 | 		AddRoundKey(in, key);
267 | 	}
268 | 
269 | 	SubBytes(in);
270 | 	ShiftRows(in);
271 | 	for (int i = 0; i<4; ++i)
272 | 		key[i] = w[4 * Nr + i];
273 | 	AddRoundKey(in, key);
274 | }
275 | 
276 | //解密 
277 | void decrypt(byte in[4 * 4], word w[4 * (Nr + 1)]){
278 | 	word key[4];
279 | 	for (int i = 0; i<4; ++i)
280 | 		key[i] = w[4 * Nr + i];
281 | 	AddRoundKey(in, key);
282 | 
283 | 	for (int round = Nr - 1; round>0; --round)
284 | 	{
285 | 		InvShiftRows(in);
286 | 		InvSubBytes(in);
287 | 		for (int i = 0; i<4; ++i)
288 | 			key[i] = w[4 * round + i];
289 | 		AddRoundKey(in, key);
290 | 		InvMixColumns(in);
291 | 	}
292 | 
293 | 	InvShiftRows(in);
294 | 	InvSubBytes(in);
295 | 	for (int i = 0; i<4; ++i)
296 | 		key[i] = w[i];
297 | 	AddRoundKey(in, key);
298 | }
299 | 
300 | int main(){
301 | 	char strKey[2];      
302 | 	byte key[16];        
303 | 	char strMessage[2];   
304 | 	byte message[16]; 
305 | 
306 | 	//输入密钥 ,存入Key中 
307 | 	cout << "请以十六进制格式输入128位密钥，每两位用空格隔开" << endl;
308 | 	unsigned long temp;
309 | 	for (int i = 0; i < 16; i++){
310 | 		scanf("%s", strKey);
311 | 		//使用sscanf函数将读取到的字符串类型密钥转换成字节类型的密钥，并逐一存放进key中 
312 | 		sscanf(strKey, "%2x", &temp);
313 | 		key[i] = temp;
314 | 	}
315 | 
316 | 	//输入明文 
317 | 	cout << "请以十六进制格式输入128位明文，每两位用空格隔开：" << endl;
318 | 	for (int i = 0; i < 16; i++)
319 | 	{
320 | 		scanf("%s", strMessage);
321 | 		//使用sscanf函数将读取到的字符串类型明文转换成字节类型的明文，并逐一存放进message中 
322 | 		sscanf(strMessage, "%2x", &temp);
323 | 		message[i] = temp;
324 | 	}
325 | 
326 | 	word w[4 * (Nr + 1)];
327 | 	KeyExpansion(key, w);
328 | 
329 | 	// 加密
330 | 	encrypt(message, w);
331 | 	cout << endl;
332 | 	cout << "加密后的密文：" << endl;
333 | 	for (int i = 0; i<16; ++i)
334 | 		cout << hex << message[i].to_ulong() << " ";
335 | 	cout << endl;
336 | 
337 | 	// 解密
338 | 	cout << "请以十六进制格式输入128位密钥，每两位用空格隔开：" << endl;
339 | 	for (int i = 0; i < 16; i++){
340 | 		scanf("%s", strKey);
341 | 		sscanf(strKey, "%2x", &temp);
342 | 		key[i] = temp;
343 | 	}
344 | 
345 | 	decrypt(message, w);
346 | 	cout << "解密后的明文：" << endl;
347 | 	for (int i = 0; i<16; ++i)
348 | 		cout << hex << message[i].to_ulong() << " ";
349 | 	cout << endl;
350 | 	return 0;
351 | }
352 | 
353 | 
354 | // key:2b 3c 7e 56 35 23 ff 88 15 09 a3 56 e5 67 19 1f
355 | //2b3c7e563523ff881509a356e567191f
356 | // mes:cc a4 56 78 fa 1e c4 57 2d 3e 33 56 46 13 a1 a5
357 | //cca45678fa1ec4572d3e33564613a1a5
358 | // 52 fd da 98 cb f6 13 99 2c c1 7 b3 21 6e d5 34
359 | 
360 | 


--------------------------------------------------------------------------------
/1/lab5/AES.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/lab5/AES.exe


--------------------------------------------------------------------------------
/1/lab6/RSA.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <math.h>
 3 | //判断 p q是否为素数
 4 | int Prime(int m){    
 5 | 	int i, k;
 6 | 	if (m<2) return 0;
 7 | 	k = sqrt(m);
 8 | 	for (i = 2; i <= k; i++)
 9 | 		if (m%i == 0)
10 | 			break;
11 | 	 //素数返回1,否则返回0
12 | 	if (i>k)   
13 | 		return 1;                  
14 | 	else
15 | 		return 0;                    
16 | }
17 | //幂的取余
18 | int encrypt(int a, int b, int c){
19 | 	int r = 1;
20 | 	b = b + 1;
21 | 	while (b != 1){
22 | 		r = r*a;
23 | 		r = r%c;
24 | 		b--;
25 | 	}
26 | 	return r;
27 | }
28 | //判断两数是否互素
29 | int husu(int x, int y){   
30 | 	int t;
31 | 	while (y){
32 | 		t = x;
33 | 		x = y;
34 | 		y = t%y;
35 | 	}
36 | 	//x与y互素时返回0，x与y不互素时返回1  
37 | 	if (x == 1) 
38 | 		return 0;           
39 | 	else  
40 | 		return 1;   
41 | }
42 | 
43 | int main() {
44 | 	//p,q为素数，e为公钥，d为私钥，m为明文，n为模数 ,c为密文 
45 | 	int p, q, e, d, m, n, t, c, r, k;
46 | 	printf("请输入两个素数p,q:");
47 | 	while (1){
48 | 		scanf("%d%d", &p, &q);
49 | 		//判断两个数是否为素数，不是的话重新输入
50 | 		if ((Prime(p) == 1) && (Prime(q) == 1)){  
51 | 			n = p*q;
52 | 			break;
53 | 		}
54 | 		else printf("ERROR!\n请重新输入两个素数p,q\n");
55 | 	}
56 | 	//求欧拉函数t
57 | 	t = (p - 1)*(q - 1);      
58 | 	printf("请输入你想设置的公钥e，注意：1<e<φ(n)，且e与(p - 1)*(q - 1)互质。e:");
59 | 	scanf("%d", &e);
60 | 
61 | 	while (e<1 || e>t || husu(e, t)){
62 | 		printf("ERROR!e不符合要求！请重新输入e:\n");
63 | 		scanf("%d", &e);
64 | 	}
65 | 
66 | 	d = 1;
67 | 	//由公钥e求出私钥d
68 | 	while (((e*d) % t) != 1)   
69 | 		d++;     
70 | 	printf("计算出的私钥d:%d\n",d);
71 | 	printf("请输入想要加密的明文:");
72 | 	scanf("%d", &m);
73 | 	c = encrypt(m, e, n);
74 | 	printf("密文为: %d\n", c);
75 | 	printf("请输入密文:");
76 | 	scanf("%d", &c);
77 | 	m = encrypt(c, d, n);
78 | 	printf("明文为: %d", m);
79 | }
80 | 
81 | 
82 | 
83 | 


--------------------------------------------------------------------------------
/1/lab6/RSA.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/lab6/RSA.exe


--------------------------------------------------------------------------------
/1/lab7/MD5.cpp:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include   <stdlib.h> 
  3 | #include   <time.h>  
  4 | #include   <string.h>  
  5 | 
  6 | #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
  7 | #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
  8 | #define H(x, y, z) ((x) ^ (y) ^ (z))
  9 | #define I(x, y, z) ((y) ^ ((x) | (~z)))
 10 | 
 11 | #define RL(x, y) (((x) << (y)) | ((x) >> (32 - (y)))) //x向左循环移y位
 12 | 
 13 | #define PP(x) (x<<24)|((x<<8)&0xff0000)|((x>>8)&0xff00)|(x>>24) //将x高低位互换,例如PP(aabbccdd)=ddccbbaa
 14 | 
 15 | #define FF(a, b, c, d, x, s, ac) a = b + (RL((a + F(b,c,d) + x + ac),s))
 16 | #define GG(a, b, c, d, x, s, ac) a = b + (RL((a + G(b,c,d) + x + ac),s))
 17 | #define HH(a, b, c, d, x, s, ac) a = b + (RL((a + H(b,c,d) + x + ac),s))
 18 | #define II(a, b, c, d, x, s, ac) a = b + (RL((a + I(b,c,d) + x + ac),s))
 19 | 
 20 | unsigned A,B,C,D,a,b,c,d,i,len,flen[2],x[16]; //i临时变量,len文件长,flen[2]为64位二进制表示的文件初始长度
 21 | char filename[200]; //文件名
 22 | FILE *fp;
 23 | 
 24 | void md5() //MD5核心算法,供64轮
 25 | {
 26 | 
 27 |     a=A,b=B,c=C,d=D;
 28 |     /**//* Round 1 */
 29 |     FF (a, b, c, d, x[ 0], 7, 0xd76aa478); /**//* 1 */
 30 |     FF (d, a, b, c, x[ 1], 12, 0xe8c7b756); /**//* 2 */
 31 |     FF (c, d, a, b, x[ 2], 17, 0x242070db); /**//* 3 */
 32 |     FF (b, c, d, a, x[ 3], 22, 0xc1bdceee); /**//* 4 */
 33 |     FF (a, b, c, d, x[ 4], 7, 0xf57c0faf); /**//* 5 */
 34 |     FF (d, a, b, c, x[ 5], 12, 0x4787c62a); /**//* 6 */
 35 |     FF (c, d, a, b, x[ 6], 17, 0xa8304613); /**//* 7 */
 36 |     FF (b, c, d, a, x[ 7], 22, 0xfd469501); /**//* 8 */
 37 |     FF (a, b, c, d, x[ 8], 7, 0x698098d8); /**//* 9 */
 38 |     FF (d, a, b, c, x[ 9], 12, 0x8b44f7af); /**//* 10 */
 39 |     FF (c, d, a, b, x[10], 17, 0xffff5bb1); /**//* 11 */
 40 |     FF (b, c, d, a, x[11], 22, 0x895cd7be); /**//* 12 */
 41 |     FF (a, b, c, d, x[12], 7, 0x6b901122); /**//* 13 */
 42 |     FF (d, a, b, c, x[13], 12, 0xfd987193); /**//* 14 */
 43 |     FF (c, d, a, b, x[14], 17, 0xa679438e); /**//* 15 */
 44 |     FF (b, c, d, a, x[15], 22, 0x49b40821); /**//* 16 */
 45 | 
 46 |     /**//* Round 2 */
 47 |     GG (a, b, c, d, x[ 1], 5, 0xf61e2562); /**//* 17 */
 48 |     GG (d, a, b, c, x[ 6], 9, 0xc040b340); /**//* 18 */
 49 |     GG (c, d, a, b, x[11], 14, 0x265e5a51); /**//* 19 */
 50 |     GG (b, c, d, a, x[ 0], 20, 0xe9b6c7aa); /**//* 20 */
 51 |     GG (a, b, c, d, x[ 5], 5, 0xd62f105d); /**//* 21 */
 52 |     GG (d, a, b, c, x[10], 9, 0x02441453); /**//* 22 */
 53 |     GG (c, d, a, b, x[15], 14, 0xd8a1e681); /**//* 23 */
 54 |     GG (b, c, d, a, x[ 4], 20, 0xe7d3fbc8); /**//* 24 */
 55 |     GG (a, b, c, d, x[ 9], 5, 0x21e1cde6); /**//* 25 */
 56 |     GG (d, a, b, c, x[14], 9, 0xc33707d6); /**//* 26 */
 57 |     GG (c, d, a, b, x[ 3], 14, 0xf4d50d87); /**//* 27 */
 58 |     GG (b, c, d, a, x[ 8], 20, 0x455a14ed); /**//* 28 */
 59 |     GG (a, b, c, d, x[13], 5, 0xa9e3e905); /**//* 29 */
 60 |     GG (d, a, b, c, x[ 2], 9, 0xfcefa3f8); /**//* 30 */
 61 |     GG (c, d, a, b, x[ 7], 14, 0x676f02d9); /**//* 31 */
 62 |     GG (b, c, d, a, x[12], 20, 0x8d2a4c8a); /**//* 32 */
 63 | 
 64 |     /**//* Round 3 */
 65 |     HH (a, b, c, d, x[ 5], 4, 0xfffa3942); /**//* 33 */
 66 |     HH (d, a, b, c, x[ 8], 11, 0x8771f681); /**//* 34 */
 67 |     HH (c, d, a, b, x[11], 16, 0x6d9d6122); /**//* 35 */
 68 |     HH (b, c, d, a, x[14], 23, 0xfde5380c); /**//* 36 */
 69 |     HH (a, b, c, d, x[ 1], 4, 0xa4beea44); /**//* 37 */
 70 |     HH (d, a, b, c, x[ 4], 11, 0x4bdecfa9); /**//* 38 */
 71 |     HH (c, d, a, b, x[ 7], 16, 0xf6bb4b60); /**//* 39 */
 72 |     HH (b, c, d, a, x[10], 23, 0xbebfbc70); /**//* 40 */
 73 |     HH (a, b, c, d, x[13], 4, 0x289b7ec6); /**//* 41 */
 74 |     HH (d, a, b, c, x[ 0], 11, 0xeaa127fa); /**//* 42 */
 75 |     HH (c, d, a, b, x[ 3], 16, 0xd4ef3085); /**//* 43 */
 76 |     HH (b, c, d, a, x[ 6], 23, 0x04881d05); /**//* 44 */
 77 |     HH (a, b, c, d, x[ 9], 4, 0xd9d4d039); /**//* 45 */
 78 |     HH (d, a, b, c, x[12], 11, 0xe6db99e5); /**//* 46 */
 79 |     HH (c, d, a, b, x[15], 16, 0x1fa27cf8); /**//* 47 */
 80 |     HH (b, c, d, a, x[ 2], 23, 0xc4ac5665); /**//* 48 */
 81 | 
 82 |     /**//* Round 4 */
 83 |     II (a, b, c, d, x[ 0], 6, 0xf4292244); /**//* 49 */
 84 |     II (d, a, b, c, x[ 7], 10, 0x432aff97); /**//* 50 */
 85 |     II (c, d, a, b, x[14], 15, 0xab9423a7); /**//* 51 */
 86 |     II (b, c, d, a, x[ 5], 21, 0xfc93a039); /**//* 52 */
 87 |     II (a, b, c, d, x[12], 6, 0x655b59c3); /**//* 53 */
 88 |     II (d, a, b, c, x[ 3], 10, 0x8f0ccc92); /**//* 54 */
 89 |     II (c, d, a, b, x[10], 15, 0xffeff47d); /**//* 55 */
 90 |     II (b, c, d, a, x[ 1], 21, 0x85845dd1); /**//* 56 */
 91 |     II (a, b, c, d, x[ 8], 6, 0x6fa87e4f); /**//* 57 */
 92 |     II (d, a, b, c, x[15], 10, 0xfe2ce6e0); /**//* 58 */
 93 |     II (c, d, a, b, x[ 6], 15, 0xa3014314); /**//* 59 */
 94 |     II (b, c, d, a, x[13], 21, 0x4e0811a1); /**//* 60 */
 95 |     II (a, b, c, d, x[ 4], 6, 0xf7537e82); /**//* 61 */
 96 |     II (d, a, b, c, x[11], 10, 0xbd3af235); /**//* 62 */
 97 |     II (c, d, a, b, x[ 2], 15, 0x2ad7d2bb); /**//* 63 */
 98 |     II (b, c, d, a, x[ 9], 21, 0xeb86d391); /**//* 64 */
 99 | 
100 |     A += a;
101 |     B += b;
102 |     C += c;
103 |     D += d;
104 | 
105 | }
106 | 
107 | int main(){   
108 | 	printf("MD5加密程序：\n");
109 |     while(1)
110 |     {
111 |         printf("请输入加密文件名称（输入exit则退出程序）\n");
112 |         gets(filename); //用get函数,避免scanf以空格分割数据,
113 |         if (filename[0]==34) filename[strlen(filename)-1]=0,strcpy(filename,filename+1); //支持文件拖曳,但会多出双引号,这里是处理多余的双引号
114 |         if (!strcmp(filename,"exit")) exit(0); //输入exit退出
115 |         if (!(fp=fopen(filename,"rb")))
116 |         {
117 |             printf("Can not open this file!\n"); //以二进制打开文件
118 |             continue;
119 |         }
120 |         fseek(fp, 0, SEEK_END); //文件指针转到文件末尾
121 |         if((len=ftell(fp))==-1)
122 |         {
123 |             printf("Sorry! Can not calculate files which larger than 2 GB!\n"); //ftell函数返回long,最大为2GB,超出返回-1
124 |             fclose(fp);
125 |             continue;
126 |         }
127 |         rewind(fp); //文件指针复位到文件头
128 |         A=0x67452301,B=0xefcdab89,C=0x98badcfe,D=0x10325476; //初始化链接变量
129 |         flen[1]=len/0x20000000; //flen单位是bit
130 |         flen[0]=(len%0x20000000)*8;
131 |         memset(x,0,64); //初始化x数组为0
132 |         fread(&x,4,16,fp); //以4字节为一组,读取16组数据
133 |         for(i=0; i<len/64; i++) //循环运算直至文件结束
134 |         {
135 |             md5();
136 |             memset(x,0,64);
137 |             fread(&x,4,16,fp);
138 |         }
139 |         ((char*)x)[len%64]=128; //文件结束补1,补0操作,128二进制即10000000
140 |         if(len%64>55) md5(),memset(x,0,64);
141 |         memcpy(x+14,flen,8); //文件末尾加入原文件的bit长度
142 |         md5();
143 |         fclose(fp);
144 | 		printf("请输入输出文件名称:\n");
145 | 		gets(filename);
146 | 		fp=fopen(filename,"w+");
147 |         fprintf(fp,"%08x%08x%08x%08x\n",PP(A),PP(B),PP(C),PP(D)); //高低位逆反输出
148 | 		fclose(fp);
149 | 		printf("加密完成，请查看！\n");
150 | 		printf("\n");
151 |     }
152 |     return 0;
153 | }
154 | 
155 | 


--------------------------------------------------------------------------------
/1/lab7/MD5.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/lab7/MD5.exe


--------------------------------------------------------------------------------
/1/lab7/out.txt:
--------------------------------------------------------------------------------
1 | 572ccae4a5a37d76b4fa1f8813c9b1c3
2 | 


--------------------------------------------------------------------------------
/1/lab7/test.txt:
--------------------------------------------------------------------------------
1 | hello XDUUUU


--------------------------------------------------------------------------------
/1/report/1.md:
--------------------------------------------------------------------------------
  1 | ## 实验一
  2 | 
  3 | ### 古典密码算法-Kaiser密码
  4 | 
  5 | ##### 一、实验目的
  6 | 
  7 | 1. 熟悉VC++6.0系统，设计实现一个Caesar加密工具，完成对文件的加解密。
  8 | 2. 对实验结果进行分析和评价。
  9 | 
 10 | ##### 二、实验所用仪器（或实验环境）
 11 | 
 12 | ​	VSCode+MinGW
 13 | 
 14 | ##### 三、实验基本原理及步骤（或方案设计及理论计算）
 15 | 
 16 | **基本原理**: 凯撒密码是一种简单的密码算法，也被称为移位密码。它的原理很简单：将明文中的每个字母按照固定的偏移量（例如向右移动三个位置）进行移位，得到密文。解密过程也很简单：将密文中的每个字母反向移动同样的偏移量，即可还原出明文。
 17 | 
 18 | **代码解析**: main函数如下:
 19 | ```C
 20 | int main(){
 21 |     FILE *fpr,*fpw;
 22 |     int m = 0;
 23 |     do
 24 | 	{
 25 | 		printf("加密请输入1\n解密请输入2\n退出请输入0\n");
 26 | 	    scanf("%d",&m);
 27 | 	    if(m==0)
 28 | 	    	break;
 29 | 	    else if(m!=0&&m!=1&&m!=2)
 30 | 	    	printf("输入有误，请重新输入！\n");
 31 | 	    else{
 32 | 	    	int len = 0,i = 0,k = 0;
 33 | 		    printf("请输入密钥k\n");
 34 | 		    scanf("%d",&k);
 35 | 	    	if(m==1){   
 36 | 		    	char ch,c[10000]={0},e[10000]={0};
 37 | 		        fpr = fopen("origin.txt","r");
 38 | 		        fpw = fopen("encrypt.txt","w");
 39 | 		        if(fpr==NULL){
 40 | 		            printf("open file error\n");
 41 | 		            return 1;
 42 | 			    }
 43 | 		        while(fscanf(fpr,"%c",&ch)!=EOF){
 44 | 		            c[i] = ch;
 45 | 		            i++;
 46 | 		            len++;
 47 | 		        }
 48 | 		        encrypt(c,len,k,e,fpw);
 49 | 		        fclose(fpr);
 50 | 				fclose(fpw);
 51 | 		    }
 52 | 		    else if(m==2)
 53 | 		    {
 54 | 		    	char ch,c[10000]={0},d[10000]={0};
 55 | 		        fpr = fopen("encrypt.txt","r");
 56 | 		        fpw = fopen("decrypt.txt","w");
 57 | 		        if(fpr==NULL){
 58 | 		            printf("open file error\n");
 59 | 		            return 1;
 60 | 			    }
 61 | 		        while(fscanf(fpr,"%c",&ch)!=EOF){
 62 | 		            c[i] = ch;
 63 | 		            i++;
 64 | 		            len++;
 65 | 		        }
 66 | 		        decrypt(c,len,k,d,fpw);
 67 | 		        fclose(fpr);
 68 | 				fclose(fpw);
 69 | 		    }
 70 | 		}
 71 | 	}while(m!=0);
 72 | 	return 0;
 73 | }
 74 | ```
 75 | 
 76 | 在 `main` 函数中首先要求用户输入执行加密或解密操作的选项，然后再根据用户选择的操作类型分别执行对应的操作。在执行操作之前，用户需要输入密钥值 k，该值会作为加密解密算法的参数。在加密操作中，程序会读取指定文件中的明文，并将加密结果写入到另一个指定文件中；在解密操作中，程序会读取指定文件中的密文，并将解密结果写入到另一个指定文件中。
 77 | 
 78 | 加密算法encrypt如下
 79 | 
 80 | ```C
 81 | //k为密钥,len为长度,fp为储存的加密文件
 82 | void encrypt(char c[],int len,int k,char e[],FILE *fp){
 83 |     int i = 0;
 84 |     for(i=0;i<len;i++){
 85 |         if(c[i]>='a'&&c[i]<='z'-k){
 86 |             e[i] = c[i] + k;
 87 |         }
 88 |         else if(c[i]>='a'&&c[i]>'z'-k){
 89 |             e[i] = c[i] + k - 26;
 90 |         }
 91 |         else if(c[i]>='A'&&c[i]<='Z'-k){
 92 |             e[i] = c[i] + k;
 93 |         }
 94 |         else if(c[i]>='A'&&c[i]>'Z'-k){
 95 |             e[i] = c[i] + k - 26;
 96 |         }
 97 |         else{
 98 |             e[i] = c[i];
 99 |         }
100 |     }
101 |     fputs(e,fp);
102 |     printf("加密方成功进行加密！\n");
103 | } 
104 | ```
105 | 
106 | `encrypt` 函数实现了加密过程，接收4个参数：原始消息字符串、字符串长度、密钥值以及用于存储加密结果的字符串数组，最后将结果写入指定文件中。加密算法中使用了一种简单的移位方法，将每个字符的ASCII码增加密钥值 k，如果超出字母 'z' 或 'Z' 的范围则需要回到字母表开头处。否则，不做任何更改。
107 | 
108 | 解密算法decrypt如下所示
109 | 
110 | ```C
111 | void decrypt(char c[],int len,int k,char d[],FILE *fp)
112 | {
113 |     int i = 0;
114 |     for(i=0;i<len;i++){
115 |         if(c[i]>='a'+k&&c[i]<='z'){
116 |             d[i] = c[i] - k;
117 |         }
118 |         else if(c[i]>='a'&&c[i]<'a'+k){
119 |             d[i] = c[i] - k + 26;
120 |         }
121 |         else if(c[i]>='A'+k&&c[i]<='Z'){
122 |             d[i] = c[i] - k;
123 |         }
124 |         else if(c[i]>='A'&&c[i]<'A'+k){
125 |             d[i] = c[i] - k + 26;
126 |         }
127 |         else{
128 |             d[i] = c[i];
129 |         }
130 |     }
131 |     fputs(d,fp);
132 |     printf("解密方成功进行解密！\n");
133 | } 
134 | ```
135 | 
136 | `decrypt` 函数实现了解密过程，接收4个参数：密文字符串、字符串长度、密钥值以及用于存储解密结果的字符串数组，最后将结果写入指定文件中。解密算法中同样采用了移位方法，但是需要将增加的密钥值 k 换成减少的密钥值 k。
137 | 
138 | ##### 四、实验数据记录（或仿真及软件设计）
139 | 
140 | 先对明文文件p.txt进行加密，密钥k为3，加密后的内容存储到c.txt中。再对密文文件c.txt进行解密，密钥值为3，解密后的结果存放到d.txt中
141 | 
142 | ![img](/screenshots/1.1.png)
143 | 
144 | 明文文件、密文文件以及解密文件内容如下所示
145 | 
146 | ![img](/screenshots/1.2.png)
147 | 
148 | 利用给的小工具对加密解密流程进行测试，可以看出加解密流程正确
149 | 
150 | ![img](/screenshots/1.3.png)
151 | 
152 | ##### 五、实验结果分析及回答问题（或测试环境及测试结果）
153 | 
154 | 1. 在手动完成Caesar密码实验中，密钥k=3，试着画出这时的Caesar置换表？
155 | 
156 |    | **明文** | **A** | B     | C     | D     | E     | F     | G     | H     | I     | G     | K     | L     | M     |
157 |    | -------- | ----- | ----- | ----- | ----- | ----- | ----- | ----- | ----- | ----- | ----- | ----- | ----- | ----- |
158 |    | **密文** | D     | E     | F     | G     | H     | I     | J     | K     | L     | M     | N     | O     | P     |
159 |    | **明文** | **N** | **O** | **P** | **Q** | **R** | **S** | **T** | **U** | **V** | **W** | **X** | **Y** | **Z** |
160 |    | **密文** | Q     | R     | S     | T     | U     | V     | W     | X     | Y     | Z     | A     | B     | C     |
161 | 
162 | 2. 古典密码学曾经被广泛应用，它可以分为代替密码和置换密码两种，请查找相关资料，列举出几种属于代替密码和置换密码的古典密码算法？
163 | 
164 |    代替密码：
165 | 
166 |    - 凯撒密码：将明文中的每个字母向右移动一个固定数量的位置，比如向右移动3个位置。
167 |    - 维吉尼亚密码：结合了多个凯撒密码，通过使用不同的移动量来加密每个字母。
168 |    - Hill密码：使用矩阵乘法来加密明文中的每个字母。
169 |    - RC4：一种流密码，使用伪随机数生成器生成密钥流，再将其与明文异或运算得到密文。
170 | 
171 |    置换密码：
172 | 
173 |    - 栅栏密码：将明文按照一定规则分成若干组，然后将每组中的字母重新排列。
174 |    - 简单替换密码：使用一个简单的固定字母表来加密明文，即将明文中的每个字母替换为另一个字母。
175 |    - 频率分析密码：利用字母出现频率的统计规律来猜测密文中的字母，从而解密消息。
176 |    - Playfair密码：将明文中的每个字母映射到一个二维矩阵中的两个字母，然后将这两个字母替换为矩阵中的另外两个字母。
177 | 
178 |    
179 | 


--------------------------------------------------------------------------------
/1/report/2.md:
--------------------------------------------------------------------------------
  1 | ## 实验二
  2 | 
  3 | ### 古典密码算法-单表置换密码
  4 | 
  5 | ##### 一、实验目的
  6 | 
  7 | 1. 设计一个单表置换加密工具，利用单表置换加密算法对文件进行加密。
  8 | 2.  对实验结果进行分析和评价。
  9 | 
 10 | ##### 二、实验所用仪器（或实验环境）
 11 | 
 12 | ​	VSCode+MinGW
 13 | 
 14 | ##### 三、实验基本原理及步骤（或方案设计及理论计算）
 15 | 
 16 | 单表置换加密（单字母替换密码）在加密时将明文中的每个字符按照预先定义好的顺序替换成另一个字符，生成密文。解密时则根据相同的替换顺序进行反向替换，恢复原文。
 17 | 
 18 | 主函数 main() 的代码如下
 19 | 
 20 | ```c
 21 | int main(){
 22 |     FILE *fp1,*fp2;
 23 |     int m;
 24 |     do{
 25 | 	    printf("加密请输入1\n解密请输入2\n退出请输入0\n");
 26 | 	    scanf("%d",&m);
 27 | 	    if(m==0)
 28 | 			break;
 29 | 		else if(m!=0&&m!=1&&m!=2)
 30 | 			printf("输出格式有误，请重新输入！\n");
 31 | 		else
 32 | 		{
 33 | 			char k[26]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'},
 34 | 	    	*c,*s;
 35 | 	    	c = (char*)malloc(sizeof(char));
 36 | 	    	s = (char*)malloc(sizeof(char));
 37 | 			getchar();
 38 | 		    printf("请输入密钥：\n");    
 39 | 		    scanf("%[^\n]",c);
 40 | 		    int len = strlen(c);
 41 | 		    int i,j;
 42 | 		    for(i=0,j=0;i<len;i++,j++){
 43 | 		        if(isupper(c[i]))
 44 | 		            s[j] = c[i];
 45 | 		        else if(islower(c[i]))
 46 | 		            s[j] = toupper(c[i]);
 47 | 		        else
 48 | 		            j--;
 49 | 		    }
 50 | 		    len = strlen(s);
 51 | 		    int flag = 0;
 52 | 		    int min = 26;
 53 | 		    for(i=0;i<len;i++){
 54 | 		        int temp = 1;
 55 | 		        for(j=0;j<flag;j++){
 56 | 		            if(s[i]==k[j]){
 57 | 		                temp = 0;
 58 | 		                break;
 59 | 		            }
 60 | 		        }
 61 | 		        if(temp){
 62 | 		            if(s[i]!=k[flag]){ 
 63 | 		                int n = (s[i]-'A'>min)?s[i]-'A':flag+s[i]-'A';
 64 | 		                for(n;n>flag;n--){
 65 | 		                    k[n] = k[n-1];
 66 | 		                }
 67 | 		                k[flag] = s[i];       
 68 | 		            }
 69 | 		            flag++;
 70 | 		            if(s[i]-'A'<min)
 71 | 		                min = s[i]-'A';
 72 | 		        }
 73 | 		    }
 74 | 		
 75 | 		    if(m==1)
 76 | 		    {
 77 | 		        encrypt(k);
 78 | 		        printf("加密方成功进行加密！\n"); 
 79 | 		    }
 80 | 		    else if(m==2)
 81 | 		    {
 82 | 		        decrypt(k);
 83 | 		        printf("解密方成功进行解密！\n");
 84 | 		    }
 85 | 		}
 86 | 	    
 87 | 	}while(m!=0);
 88 |    
 89 |     return 0;
 90 | }
 91 | ```
 92 | 
 93 | 主函数 main() 中，首先定义了两个文件指针 fp1 和 fp2，然后通过 do-while 循环不断接受用户输入，直到用户输入 0 退出程序。在循环内部，先让用户选择加密还是解密，如果输入有误则重新输入。如果用户选择加密或解密，程序会要求用户输入一个密钥。这里通过 scanf() 函数读取密钥字符串，然后使用 isupper() 和 toupper() 函数将其转换为大写字母，并将所有非字母字符删除。接下来程序会遍历密钥字符串，对于每个字母，如果它还没有出现在密钥表中，就将它插入到密钥表中。密钥表中的字母按照它们在密钥字符串中出现的顺序排序，如果有相同字母，则以第一次出现的位置为准。最后，程序会遍历密钥表，将其中未出现在密钥字符串中的字母按顺序填充到密钥表中，并生成加密表（数组k）。最后根据用户的选择调用 encrypt() 或 decrypt() 函数进行加密或解密，并输出相应的提示信息。
 94 | 
 95 | 加密解密代码如下
 96 | 
 97 | ```c
 98 | void encrypt(char *k){
 99 |     FILE *fp1 = fopen("origion.txt","r");
100 |     FILE *fp2 = fopen("encrypt.txt","w");
101 |     if(fp1==NULL)
102 |     {
103 |         printf("error!\n");
104 |         exit;
105 |     }
106 |     int i=0,len=0;
107 |     char a[10000],ch;
108 |     while(fscanf(fp1,"%c",&ch)!=EOF){
109 |         if(ch>='a'&&ch<='z')
110 |             a[i] = toupper(ch);
111 |         else
112 |             a[i] = ch;
113 |         i++;
114 |         len++;
115 |     }
116 |     for(i=0;i<len;i++)
117 |     {
118 |         if(a[i]>='A'&&a[i]<='Z')
119 |             a[i] = k[a[i] -'A'];
120 |     }
121 |     printf("%s\n",a);
122 |     fputs(a,fp2);
123 |     fclose(fp1);
124 |     fclose(fp2);
125 | }
126 | void decrypt(char *k)
127 | {
128 |     FILE *fp1 = fopen("encrypt.txt","r");
129 |     FILE *fp2 = fopen("decrypt.txt","w");
130 |     if(fp1==NULL)
131 |     {
132 |         printf("error!\n");
133 |         exit;
134 |     }
135 |     char b[10000]={0},ch;
136 |     int i = 0,len = 0, j = 0;
137 |     while(fscanf(fp1,"%c",&ch)!=EOF)
138 |     {
139 |         b[i] = ch;
140 |         i++;
141 |         len++;
142 |     }
143 |     for(i=0;i<len;i++)
144 |     {
145 |         if(b[i]>='A'&&b[i]<='Z')
146 |         {
147 |             for(j=0;j<26;j++)
148 |             {
149 |                 if(k[j]==b[i])
150 |                     b[i] = 'a' + j;
151 |             }
152 |         }
153 |     }
154 |     for(i=0;i<len;i++)
155 |     {
156 |         b[i] = b[i] - 32;
157 |     }
158 |     printf("%s\n",b);
159 |     fputs(b,fp2);
160 |     fclose(fp1);
161 |     fclose(fp2);
162 | }
163 | ```
164 | 
165 | 函数 `encrypt` 中，首先打开名为 "origin.txt" 的文件并将其读入到字符数组 `a` 中，然后遍历该数组中的每个字符，如果是小写字母则将其转换为大写字母；接着，将置换表 `k` 中对应位置的字符替换原来在 `a` 中相同位置的字符；最后将修改后的字符串写入名为 "encrypt.txt" 的文件中。
166 | 
167 | 函数 `decrypt` 中，首先打开名为 "encrypt.txt" 的文件并将其读入到字符数组 `b` 中，然后遍历该数组中的每个字符，将 `k` 中对应位置的字符替换原来在 `b` 中相同位置的字符；最后将修改后的字符串写入名为 "decrypt.txt" 的文件中，解密时并没有进行大小写转换。
168 | 
169 | ##### 四、实验数据记录（或仿真及软件设计）
170 | 
171 | 先对明文文件origin.txt进行加密，密钥为JKLMKO，加密后的内容存储到encrypt.txt中。再对密文文件encrypt.txt进行解密，密钥为JKLMKO，解密后的结果存放到decrypt.txt中
172 | 
173 | ![img](/screenshots/2.1.png)
174 | 
175 | 明文文件、密文文件以及解密文件内容如下所示
176 | 
177 | ![img](/screenshots/2.2.png)
178 | 
179 | 利用给的小工具对加密解密流程进行测试，可以看出加解密流程正确
180 | 
181 | ![img](/screenshots/2.3.png)
182 | 
183 | ##### 五、实验结果分析及回答问题（或测试环境及测试结果）
184 | 
185 | 问：在单表置换密码分析过程中，我们看到破解方法是基于英文字母出现的频率，你能想出一个改进方法使单表置换加密方法能抵抗这种方法的密码分析吗？
186 | 
187 | 答：一种改进单表置换加密方法的方式是使用多个置换表，而不是只使用一个。具体来说，可以为每个字母指定多个置换表中的一个，然后随机选择一个置换表进行加密。这样可以使得破解者无法推断出某个字母在哪个置换表中出现的频率，并且提高了密码的安全性。另外一种改进的方式是引入一些随机性和混淆技术，以增加密码的复杂度和难度。例如，可以使用随机生成的替代字符或随机的字符串来替换明文中的某些字符，以及在加密过程中引入一些随机的步骤，如随机交换字符位置或随机选择加密算法等等。这些技术可以使得密码更难被破解，同时保持单表置换加密方法的简单性和可行性。
188 | 


--------------------------------------------------------------------------------
/1/report/3.md:
--------------------------------------------------------------------------------
  1 | ## 实验三
  2 | 
  3 | ###  古典密码算法-仿射密码
  4 | 
  5 | ##### 一、实验目的
  6 | 
  7 | 1. 编写调试仿射密码算法，实现对文件的加解密
  8 | 2. 对实验结果进行分析和评价。
  9 | 
 10 | ##### 二、实验所用仪器（或实验环境）
 11 | 
 12 | ​	VSCode+MinGW
 13 | 
 14 | ##### 三、实验基本原理及步骤（或方案设计及理论计算）
 15 | 
 16 | **基本原理：**仿射密码是一种替换密码。它是一个字母对一个字母的。它的加密过程可以表示为下面的函数：e(x)=(ax+b) mod m其中，a和m互质，m是字母的数目。它的解密过程可以表示为下面的函数：d(x)=a^(x-b)\ mod m其中a^是a对m的乘法逆元。
 17 | 
 18 | **代码解析：**
 19 | 
 20 | 主函数main的代码如下
 21 | 
 22 | ```c
 23 | int main(){
 24 |     int a,b,m;
 25 |     do{
 26 | 		printf(" 加密请输入1\n 解密请输入2\n 退出请输入0\n");
 27 |     	scanf("%d",&m);
 28 |     	if(m==0)
 29 |     		break;
 30 |     	else if(m!=0&&m!=1&&m!=2)
 31 |     		printf("输入有误，请重新输入！\n");
 32 |     	else{
 33 | 		    printf("请输入密钥a、b，其中a与26互素\n");
 34 | 		    scanf("%d %d",&a,&b);
 35 | 		    if(!(ifisPrime(a,26))){
 36 | 		        while(!(ifisPrime(a,26))){
 37 | 		            printf("经检测，输入a值与26不满足互素条件，请输入与26互素的a!\n");
 38 | 		            scanf("%d",&a);
 39 | 		        }
 40 | 		    }
 41 | 		    if(m==1)
 42 | 		        encrypt(a,b);
 43 | 		    else if(m==2)
 44 | 		        decrypt(a,b);
 45 | 		}
 46 | 	}while(m!=3); 
 47 |     return 0;
 48 | }
 49 | 
 50 | ```
 51 | 
 52 | 主函数会根据用户输入的选项进行加密、解密或退出。选择加密时或者解密时提醒用户输入密钥a和b，并检查a和26是否互素。如果用户输入的是加密选项，则调用encrypt函数进行加密；如果用户输入的是解密选项，则调用decrypt函数进行解密。如果用户输入的是退出选项，则程序结束。
 53 | 
 54 | 判断a和b是否互质的函数 ifisPrime以及求a和b的最大公约数函数gcd
 55 | 
 56 | ```c
 57 | //求a和b的最大公约数。
 58 | //使用辗转相除法（欧几里德算法）计算a和b的最大公约数，直到b为0，返回a的值。
 59 | int gcd(int a,int b){
 60 |     while(b!=0){
 61 |         int temp = a;
 62 |         a = b;
 63 |         b = temp % b;
 64 |     }
 65 |     return a;
 66 | }
 67 | //判断a和b是否互质
 68 | //原理即调用gcd函数计算a和b的最大公约数
 69 | //如果最大公约数为1，则返回1，否则返回0。
 70 | int ifisPrime(int a,int b){
 71 |     if(gcd(a,b)==1)
 72 |         return 1;
 73 |     else 
 74 |         return 0;
 75 | }
 76 | ```
 77 | 
 78 | ifisPrime原理即调用gcd函数计算a和b的最大公约数，如果最大公约数为1，则返回1，否则返回0。gcd 即使用辗转相除法（欧几里德算法）计算a和b的最大公约数，直到b为0，返回a的值。
 79 | 
 80 | getinverse函数：计算a在模m下的乘法逆元，主要原理是通过遍历1到m-1的整数，找到满足(i * a) % m = 1的数i，并返回i。如果不存在则返回0。
 81 | 
 82 | ```c
 83 | int getinverse(int a,int m){
 84 | 	int i; 
 85 |     for(i=1;i<m;i++){
 86 |         if( (i*a) % m == 1)
 87 |             return i;
 88 |     }
 89 | }
 90 | ```
 91 | 
 92 | 下面是加密解密函数
 93 | 
 94 | ```c
 95 | void encrypt(int a,int b){
 96 |     int m = 26,i=0,len=0;
 97 |     char c[10000] = {0},ch;
 98 |     FILE *fp1,*fp2;
 99 |     fp1 = fopen("origion.txt","r");
100 |     fp2 = fopen("encrypt.txt","w");
101 |     if(fp1==NULL){
102 |         printf("open file error!\n");
103 |         exit;
104 |     }
105 |     while(fscanf(fp1,"%c",&ch)!=EOF){
106 |         c[i] = ch;
107 |         i++;
108 |     }
109 |     len = strlen(c);
110 |     for(i=0;i<len;i++){
111 |     	if(islower(c[i]))
112 |             c[i] = 'a' + ( (a * (c[i] - 'a') + b) % 26);
113 |         if(isupper(c[i]))
114 |             c[i] = 'A' + ( (a * (c[i] - 'A') + b) % 26);
115 |     }
116 |     fputs(c,fp2);
117 |     
118 |     fclose(fp1);
119 |     fclose(fp2);
120 |     printf("加密密文为：%s\n",c);
121 | 	printf("加密方成功进行加密！\n");
122 | }
123 | 
124 | void decrypt(int a,int b){
125 |     FILE *fp1,*fp2;
126 |     fp1 = fopen("encrypt.txt","r");
127 |     fp2 = fopen("decrypt.txt","w");
128 |     if(fp1==NULL){
129 |         printf("open file error!\n");
130 |         exit;
131 |     }
132 |     char c[10000] = {0},ch;
133 |     int i=0,len=0,inva = getinverse(a,26);
134 |     while(fscanf(fp1,"%c",&ch)!=EOF){
135 |         c[i] = ch;
136 |         i++;
137 |     }
138 |     len = strlen(c);
139 |     for(i=0;i<len;i++){
140 |         if(islower(c[i])){
141 |             if((c[i] - 'a') < b)
142 |                 c[i] = ( inva * (c[i] - 'a' - b + 26) % 26) + 'a'; 
143 |             else
144 |                 c[i] = ( inva * (c[i] - 'a' - b)  % 26) + 'a'; 
145 |         }
146 |         if(isupper(c[i])){
147 |             if((c[i] - 'A') < b)
148 |                 c[i] = ( inva * (c[i] - 'A' - b + 26) % 26) + 'A'; 
149 |             else
150 |                 c[i] = ( inva * (c[i] - 'A' - b)  % 26) + 'A'; 
151 |         }
152 |     }
153 |     fputs(c,fp2);
154 |     fclose(fp1);
155 |     fclose(fp2); 
156 |     printf("解密所得明文为：%s\n",c);
157 | 	printf("解密方成功进行解密！\n");
158 | }
159 | ```
160 | 
161 | 加密函数主要利用e(x)=(ax+b) mod m公式进行加密，它的解密函数思想即d(x)=a^(x-b)\ mod m，利用getinverse函数计算a在模m下的乘法逆元，即可以求得明文。
162 | 
163 | ##### 四、实验数据记录（或仿真及软件设计）
164 | 
165 | 先对明文文件origin.txt（内容为HelloWorld）进行加密，密钥为a=7,b=8，加密后的内容存储到encrypt.txt中。再对密文文件encrypt.txt进行解密，密钥为a=5,b=8，解密后的结果存放到decrypt.txt中
166 | 
167 | ![img](/screenshots/3.1.png)
168 | 
169 | 利用给的小工具对加密解密流程进行测试，可以看出加解密流程正确
170 | 
171 | ![img](/screenshots/3.2.png)
172 | ##### 五、实验结果分析及回答问题（或测试环境及测试结果）
173 | 
174 | 1. 思考仿射变换为何要求k1与26互素？
175 | 
176 |    当k1与26不互素时，会导致下面两种情况的发生：
177 | 
178 |    1. 存在某个数字a，使得(a * k1) mod 26 = 0，这意味着在进行仿射变换时，存在一些明文字符被映射到了另一些字符的同一个位置上，从而降低了加密强度。
179 |    2. 密文字符中可能出现一些无法解密的字符，因为它们没有对应的明文字符。具体来说，如果gcd(k1, 26) ≠ 1，则不存在一个数x，使得(x * k1) mod 26 = 1，也就是说，在进行解密操作时，有些密文字符无法还原成相应的明文字符。
180 | 
181 |    因此，在仿射密码中，要求选择的k1必须与26互素，以保证加密过程的安全性，并且能够保证解密操作的可行性。
182 | 
183 | 2. 思考仿射变换与凯撒密码的关系？
184 | 
185 |    凯撒密码是一种简单的替换密码，它将每个字母向右或向左移动一个固定的数量（位移），从而生成密文。这个位移量可以看作是一个参数，类似于仿射变换中的矩阵。但是，凯撒密码只对字母进行了简单的移位操作，而没有对其进行缩放、旋转或错切等变换。与凯撒密码不同，仿射变换是一种更复杂的线性变换，其中包括平移、旋转、缩放和错切等操作。由于仿射变换的灵活性，它被广泛用于图像处理和计算机视觉领域中的几何变换。
186 | 


--------------------------------------------------------------------------------
/1/report/4.md:
--------------------------------------------------------------------------------
  1 | ## 实验四
  2 | 
  3 | ### 对称密码算法-DES密码
  4 | 
  5 | ##### 一、实验目的
  6 | 
  7 | 1. 学习理解DES算法的工作原理
  8 | 
  9 | 2. 设计DES加密程序，利用DES加密算法完成对文件加解密。
 10 | 
 11 | 3. 连接远程实验系统，下载相关工具进行验证，记录实验过程和结果。
 12 | 
 13 | 4. 对实验结果进行分析和评价。
 14 | 
 15 | ##### 二、实验所用仪器（或实验环境）
 16 | 
 17 | ​	VSCode+MinGW
 18 | 
 19 | ##### 三、实验基本原理及步骤（或方案设计及理论计算）
 20 | 
 21 | **基本原理**: DES（Data Encryption Standard）是一种对称加密算法，其基本原理是通过利用相同的密钥对数据进行加密和解密，以确保数据的机密性。
 22 | 
 23 | DES算法的加密步骤如下：
 24 | 
 25 | 1. 密钥生成：首先需要生成一个长度为64位的密钥，这个密钥将被用于加密和解密过程中。
 26 | 
 27 | 2. 初始置换：将明文数据按照特定的规则进行重新排列，生成新的数据序列。这个步骤旨在增加加密强度和随机性。
 28 | 
 29 | 3. 分组：将初始置换后的数据分成8个64位的块。
 30 | 
 31 | 4. 加密轮次：DES算法共有16个加密轮次，每轮都需要进行以下四个步骤：
 32 | 
 33 |    a) 扩展置换：将64位的数据块扩展成48位。
 34 | 
 35 |    b) 轮密钥生成：根据当前轮数生成一个48位的轮密钥，用于加密过程中的异或操作。
 36 | 
 37 |    c) S盒替换：将48位的数据块按照6位一组分成8组，每组使用不同的S盒进行替换，得到新的32位数据块。
 38 | 
 39 |    d) P盒置换：对32位数据块进行重新排列，得到新的32位数据块。
 40 | 
 41 | 5. 交换左右半部分：将最后一轮加密后得到的左半部分和右半部分交换。
 42 | 
 43 | 6. 逆初始置换：将加密后的数据按照特定的规则进行重新排列，生成新的数据序列，作为密文输出
 44 | 
 45 | 解密步骤与加密步骤相同，只是轮密钥的使用顺序与加密时相反。
 46 | 
 47 | **代码解析**: 主函数如下：
 48 | 
 49 | ```c
 50 | int main(){ 
 51 | 	printf("DES加解密程序:\n");
 52 | 	int ss;
 53 | 	while(1){
 54 | 		printf("请选择工作模式：1.加密；2.解密；0.退出\n");
 55 | 	    int ss,n;
 56 | 	    scanf("%d",&ss);
 57 |         if(ss==1){
 58 | 	        char m1[100],m2[100],m3[100];
 59 | 			printf("请输入明文文件 秘钥文件 加密后的密文存入文件：\n");
 60 | 	        scanf("%s %s %s", &m1,&m2,&m3);
 61 |             DES_Encrypt(m1,m2,m3);
 62 | 		}
 63 |         else if(ss==2){
 64 |             char m11[100],m22[100],m33[100];
 65 |             printf("请输入密文文件 秘钥文件 解密后的明文存入文件：\n");
 66 | 	        scanf("%s %s %s", &m11,&m22,&m33);
 67 |             DES_Decrypt(m11,m22,m33);
 68 | 		}
 69 | 		else if(ss==0)
 70 | 			break;
 71 | 		else
 72 | 			printf("输入有误，请重新输入！\n");
 73 | 	}
 74 |     return 0;
 75 | }
 76 | ```
 77 | 
 78 | 主函数提供了DES算法加密和解密两种模式，输入1为加密模式，要求用户分别输入明文文件名、秘钥文件名和加密后的密文存储文件名，并调用DES_Encrypt函数进行加密操作。输入2为解密模式，则要求用户分别输入密文文件名、秘钥文件名和解密后的明文存储文件名，并调用DES_Decrypt函数进行解密操作。输入0则退出循环。
 79 | 
 80 | 加密函数如下
 81 | 
 82 | ```c
 83 | /*加密文件*/
 84 | int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile){
 85 | 	FILE *plain,*cipher;
 86 | 	int count;
 87 | 	ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
 88 | 	ElemType bKey[64];
 89 | 	ElemType subKeys[16][48];
 90 | 	if((plain = fopen(plainFile,"rb")) == NULL){
 91 | 		return PLAIN_FILE_OPEN_ERROR;
 92 | 	}
 93 | 	if((cipher = fopen(cipherFile,"wb")) == NULL){
 94 | 		return CIPHER_FILE_OPEN_ERROR;
 95 | 	}
 96 | 	/*设置密钥*/
 97 |  	memcpy(keyBlock,keyStr,8);
 98 |  	/*将密钥转换为二进制流*/
 99 |  	Char8ToBit64(keyBlock,bKey);
100 |  	/*生成子密钥*/
101 |  	DES_MakeSubKeys(bKey,subKeys);
102 |  
103 |  	while(!feof(plain)){
104 |   		/*每次读8个字节，并返回成功读取的字节数*/
105 |  		if((count = fread(plainBlock,sizeof(char),8,plain)) == 8){
106 | 			DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
107 | 			fwrite(cipherBlock,sizeof(char),8,cipher);  
108 |   		}
109 |  	}
110 |  	if(count){
111 |   		/*填充*/
112 |   		memset(plainBlock + count,'\0',7 - count);
113 |   		/*最后一个字符保存包括最后一个字符在内的所填充的字符数量*/
114 |   		plainBlock[7] = 8 - count;
115 |   		DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
116 |   		fwrite(cipherBlock,sizeof(char),8,cipher);
117 |  	}
118 |  	fclose(plain);
119 |  	fclose(cipher);
120 |  	printf("加密成功！\n");
121 | }
122 | ```
123 | 
124 | 这段代码是一个使用DES算法对文件进行加密的函数。主要实现思路如下：打开明文文件和密文文件，如果打开失败则返回相应的错误代码。把密钥转换为二进制流，并生成16个子密钥。每次读取8个字节的明文，如果成功读取，则对其进行加密并写入密文文件中。如果最后一次读取的字节数不够8个字节，则需要进行填充（补全），并在最后一个字节中记录填充的字符数量。关闭文件并输出“加密成功！”提示信息。其中，使用的函数包括：Char8ToBit64：把长度为8的字符串转换为长度为64的二进制流。DES_MakeSubKeys：根据密钥生成16个子密钥。DES_EncryptBlock：对长度为8的明文块进行加密，得到长度为8的密文块。
125 | 
126 | 解密函数如下
127 | 
128 | ```c
129 | int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile){
130 | 	FILE *plain, *cipher;
131 | 	int count,times = 0;
132 | 	long fileLen;
133 | 	ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
134 | 	ElemType bKey[64];
135 | 	ElemType subKeys[16][48];
136 | 	if((cipher = fopen(cipherFile,"rb")) == NULL){
137 |   		return CIPHER_FILE_OPEN_ERROR;
138 | 	}
139 | 	if((plain = fopen(plainFile,"wb")) == NULL){
140 | 		return PLAIN_FILE_OPEN_ERROR;
141 | 	}
142 |    	/*设置密钥*/
143 |  	memcpy(keyBlock,keyStr,8);
144 |  	/*将密钥转换为二进制流*/
145 |  	Char8ToBit64(keyBlock,bKey);
146 |  	/*生成子密钥*/
147 |  	DES_MakeSubKeys(bKey,subKeys);  
148 |  	/*取文件长度 */
149 |  	fseek(cipher,0,SEEK_END);/*将文件指针置尾*/
150 |  	fileLen = ftell(cipher); /*取文件指针当前位置*/
151 |  	rewind(cipher); /*将文件指针重指向文件头*/
152 | 	while(1){
153 |   		/*密文的字节数一定是8的整数倍*/
154 |   		fread(cipherBlock,sizeof(char),8,cipher);
155 |   		DES_DecryptBlock(cipherBlock,subKeys,plainBlock);  
156 |   		times += 8;
157 | 	  	if(times < fileLen){
158 | 			fwrite(plainBlock,sizeof(char),8,plain);
159 | 	  	}
160 | 	  	else{
161 | 			break;
162 | 	  	}
163 |  	}
164 |  	/*判断末尾是否被填充*/
165 |  	if(plainBlock[7] < 8){
166 | 	  	for(count = 8 - plainBlock[7]; count < 7; count++){
167 | 			if(plainBlock[count] != '\0'){
168 | 	 			break;
169 | 			}
170 | 	  	}
171 |  	}
172 |  	if(count == 7){/*有填充*/
173 |   		fwrite(plainBlock,sizeof(char),8 - plainBlock[7],plain);
174 |  	}
175 | 	 else{/*无填充*/
176 | 	  	fwrite(plainBlock,sizeof(char),8,plain);
177 | 	 }  
178 | 	 fclose(plain);
179 | 	 fclose(cipher);
180 | 	 printf("解密成功！\n");
181 | } 
182 | ```
183 | 
184 | DES算法解密的步骤如下：打开密文文件和明文文件，如果打开失败则返回相应的错误代码。把密钥转换为二进制流，并生成16个子密钥。每次读取8个字节的密文，如果成功读取，则对其进行解密并写入明文文件中。判断最后一个字节中记录的填充字符数，如果有填充则去掉填充，否则直接写入剩余的字节。关闭文件并输出“解密成功！”提示信息。其中，使用的函数包括：`Char8ToBit64`：把长度为8的字符串转换为长度为64的二进制流。`DES_MakeSubKeys`：根据密钥生成16个子密钥。`DES_DecryptBlock`：对长度为8的密文块进行解密，得到长度为8的明文块。
185 | 
186 | ##### 四、实验数据记录（或仿真及软件设计） 
187 | 
188 | 
189 | 
190 | ![img](/screenshots/4.1.png)
191 | 
192 | 
193 | 
194 | ![img](/screenshots/4.2.png)
195 | 
196 | ##### 五、实验结果分析及回答问题（或测试环境及测试结果）
197 | 
198 | 1、根据实验原理的讲解，回答下列问题：
199 | 
200 | ​	(1) DES每一个明文分组的长度是多少位？这个明文分组加密后的密文是多少位？
201 | 
202 | ​	DES加密算法的明文分组长度为64位，即8个字节。经过加密后，每一个明文分组将会生成64位（8个字节）的密文。
203 | 
204 | ​	(2) 在DES算法的各种置换中，哪个置换为DES提供了最好的安全性？
205 | 
206 | ​	S盒置换为DES提供了最好的安全性。S盒置换将每个6比特的输入映射到一个4比特的输出，这意味着它通过一个非线性的转换对每个6比特的输入进行加密。由于每个S盒都有自己独特的变换规则，并且DES使用8个不同的S盒，因此它们共同提供了DES的强安全性。
207 | 
208 | 2、DES的S盒在设计时就能够防止某些类型的攻击，当1991年Biham和Shamir发现的差分攻击的方法时，美国国家安全局就已承认某些未公布的S盒设计原则正是为了使得差分密码分析变得不可行。也就是说，差分密码分析在DES最初被研发时就已为IBM的研发者所知，但是这种方法却被保密了将近20年，直到Biham和Shamir又独立地发现了这种攻击。目前，DES加密方法已经被认为是不安全的了，请同学查阅相关资料，列出两种DES的分析方法。
209 | 
210 | -  差分密码分析 差分密码分析是一种广泛应用于对分组密码进行攻击的技术。它利用了加密算法中相邻明文之间的差异，并基于这些差异对密钥进行推断。在DES中，差分密码分析是一种强大的攻击方法，因为DES的S盒具有良好的差分性质。差分密码分析可以通过构造满足一定条件的明文对来推断子密钥，然后通过将这些子密钥组合来获得完整的密钥。
211 | 
212 | - 线性密码分析 线性密码分析是另一种常用的对分组密码进行攻击的技术。它利用了加密算法中明文、密文和密钥之间的线性关系，以及某些位上的偏差来推断出密钥。在DES中，线性密码分析可以被用来找到DES的轮函数的一些比较弱的特征，然后利用这些特征来推断出子密钥。但是，与差分密码分析相比，线性密码分析需要更多的数据量和计算资源。
213 | 


--------------------------------------------------------------------------------
/1/report/5.md:
--------------------------------------------------------------------------------
  1 | ## 实验五
  2 | 
  3 | ### 对称密码算法-AES密码
  4 | 
  5 | ##### 一、实验目的
  6 | 
  7 | 1. 学习理解AES算法的工作原理
  8 | 
  9 | 2. 设计AES加密程序，利用AES加密算法完成对文件加解密。
 10 | 
 11 | 3. 连接远程实验系统，下载相关工具进行验证，记录实验过程和结果。
 12 | 
 13 | 4. 对实验结果进行分析和评价。
 14 | 
 15 | ##### 二、实验所用仪器（或实验环境）
 16 | 
 17 | ​	VSCode+MinGW
 18 | 
 19 | ##### 三、实验基本原理及步骤（或方案设计及理论计算）
 20 | 
 21 | AES（Advanced Encryption Standard）是一种对称加密算法，它将明文分成固定长度的块，然后通过多轮运算对每个块进行加密。下面是AES加密的流程：
 22 | 
 23 | 1. 密钥扩展。AES加密使用一个密钥，密钥长度可以为128位、192位或256位。在加密之前，需要对密钥进行扩展，生成一系列子密钥。密钥扩展算法会根据密钥长度和AES的加密轮数，计算出需要的子密钥。
 24 | 
 25 | 2. 初始轮密钥加。将明文块与第一个子密钥进行异或操作。
 26 | 
 27 | 3. 多轮加密。AES加密使用多轮加密，每轮都包含四个步骤：字节代换、行移位、列混淆和轮密钥加。这四个步骤在所有轮中重复执行，直到达到指定轮数。
 28 | 
 29 |    - 字节代换：将每个字节替换为一个固定的值，这个值由S盒提供。S盒是一个256×8的查找表，它使用输入字节的不同组合来提供输出值。这个步骤实现了非线性变换。
 30 | 
 31 |    - 行移位：对每行进行循环移位操作。第一行不变，第二行向左移动一个字节，第三行向左移动两个字节，第四行向左移动三个字节。这个步骤实现了一些位移的效果，增加了变换的复杂性。
 32 |    - 列混淆：对每列进行矩阵乘法操作。列混淆使用一个固定的矩阵进行乘法，这个矩阵是通过数学分析得出的。这个步骤实现了另一种非线性变换。
 33 |    - 轮密钥加：将每个字节与轮密钥进行异或操作。
 34 | 
 35 | 4. 最终轮。最后一轮没有列混淆步骤，只有字节代换、行移位和轮密钥加步骤。
 36 | 
 37 | 5. 密文输出。经过多轮加密之后，得到密文块。如果还有其他的明文块需要加密，重复上述过程即可。
 38 | 
 39 | 主函数如下
 40 | 
 41 | ```c
 42 | int main(){
 43 | 	char strKey[2];      
 44 | 	byte key[16];        
 45 | 	char strMessage[2];   
 46 | 	byte message[16]; 
 47 | 
 48 | 	//输入密钥 ,存入Key中 
 49 | 	cout << "请以十六进制格式输入128位密钥，每两位用空格隔开" << endl;
 50 | 	unsigned long temp;
 51 | 	for (int i = 0; i < 16; i++){
 52 | 		scanf("%s", strKey);
 53 | 		//使用sscanf函数将读取到的字符串类型密钥转换成字节类型的密钥，并逐一存放进key中 
 54 | 		sscanf(strKey, "%2x", &temp);
 55 | 		key[i] = temp;
 56 | 	}
 57 | 
 58 | 	//输入明文 
 59 | 	cout << endl;
 60 | 	cout << "请以十六进制格式输入128位明文，每两位用空格隔开：" << endl;
 61 | 	for (int i = 0; i < 16; i++)
 62 | 	{
 63 | 		scanf("%s", strMessage);
 64 | 		//使用sscanf函数将读取到的字符串类型明文转换成字节类型的明文，并逐一存放进message中 
 65 | 		sscanf(strMessage, "%2x", &temp);
 66 | 		message[i] = temp;
 67 | 	}
 68 | 
 69 | 	word w[4 * (Nr + 1)];
 70 | 	KeyExpansion(key, w);
 71 | 
 72 | 	// 加密
 73 | 	encrypt(message, w);
 74 | 	cout << endl;
 75 | 	cout << "加密后的密文：" << endl;
 76 | 	for (int i = 0; i<16; ++i)
 77 | 		cout << hex << message[i].to_ulong() << " ";
 78 | 	cout << endl;
 79 | 
 80 | 	// 解密
 81 | 	cout << endl;
 82 | 	cout << "请以十六进制格式输入128位密钥，每两位用空格隔开：" << endl;
 83 | 	for (int i = 0; i < 16; i++){
 84 | 		scanf("%s", strKey);
 85 | 		sscanf(strKey, "%2x", &temp);
 86 | 		key[i] = temp;
 87 | 	}
 88 | 
 89 | 	decrypt(message, w);
 90 | 	cout << endl;
 91 | 	cout << "解密后的明文：" << endl;
 92 | 	for (int i = 0; i<16; ++i)
 93 | 		cout << hex << message[i].to_ulong() << " ";
 94 | 	cout << endl;
 95 | 	return 0;
 96 | }
 97 | ```
 98 | 
 99 | 函数主要是对AES加密算法进行了测试。其流程如下：用户输入一个128位的十六进制格式的密钥以及明文，然后使用sscanf函数将其转换为字节类型的密钥以及明文，并逐一存放进key与message中。然后声明一个w数组，用于存储扩展密钥后的结果。调用KeyExpansion函数，将key作为参数传入该函数，进行密钥扩展操作，并将扩展后的结果按顺序存储进w数组中。调用encrypt函数进行AES加密操作，输出加密后的16进制密文结果。之后进行解密，输入相同的密钥，即可以对message进行AES解密操作，解密后的结果会转换成16进制输出。
100 | 
101 | 下面是AES中的密钥扩展函数，用于从一个128位的密钥中生成一系列轮密钥（round key）。在AES中，加密和解密过程都需要使用这些轮密钥。
102 | 
103 | ```c
104 | //密钥扩展函数 - 对128位密钥进行扩展得到 w[4*(Nr+1)] 
105 | void KeyExpansion(byte key[4 * Nk], word w[4 * (Nr + 1)]){
106 | 	word temp;
107 | 	int i = 0;
108 | 	// w[]的前4个就是输入的key
109 | 	while (i < Nk){
110 | 		w[i] = Word(key[4 * i], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3]);
111 | 		++i;
112 | 	}
113 | 	i = Nk;
114 | 	while (i < 4 * (Nr + 1))	{
115 | 		temp = w[i - 1]; // 记录前一个word
116 | 		if (i % Nk == 0){
117 | 			word temp2 = RotWord(temp);
118 | 			w[i] = w[i - Nk] ^ SubWord(temp2) ^ Rcon[i / Nk - 1];
119 | 		}
120 | 		else
121 | 			w[i] = w[i - Nk] ^ temp;
122 | 		++i;
123 | 	}
124 | }
125 | 
126 | ```
127 | 
128 | 该函数接收一个长度为4Nk的字节数组key，其中Nk表示输入的密钥长度；并生成一个长度为4*(Nr+1)的轮密钥数组w，其中Nr表示AES的轮数（对于128位密钥而言，Nr=10）。该函数首先将输入的密钥分成Nk个32位的字，并将它们存入w数组的前Nk个位置。然后，它进入一个循环，生成剩余的轮密钥。在每一轮中，它会先记录前一个word，然后根据当前轮数和Nk是否整除当前轮数，分别进行RotWord、SubWord和Rcon等操作，最终得到新的轮密钥。其中，RotWord操作将一个word的四个字节循环左移一位，SubWord操作将一个word的四个字节通过S-box进行替换，Rcon操作则是一个常量数组，用于生成某些特定的轮密钥。最后，通过异或操作将各个word组合起来，生成新的轮密钥。
129 | 
130 | 下面是加密函数
131 | 
132 | ```c
133 | void encrypt(byte in[4 * 4], word w[4 * (Nr + 1)]){
134 | 	word key[4];
135 | 	for (int i = 0; i<4; ++i)
136 | 		key[i] = w[i];
137 | 	AddRoundKey(in, key);
138 | 
139 | 	for (int round = 1; round<Nr; ++round)
140 | 	{
141 | 		SubBytes(in);
142 | 		ShiftRows(in);
143 | 		MixColumns(in);
144 | 		for (int i = 0; i<4; ++i)
145 | 			key[i] = w[4 * round + i];
146 | 		AddRoundKey(in, key);
147 | 	}
148 | 
149 | 	SubBytes(in);
150 | 	ShiftRows(in);
151 | 	for (int i = 0; i<4; ++i)
152 | 		key[i] = w[4 * Nr + i];
153 | 	AddRoundKey(in, key);
154 | }
155 | ```
156 | 
157 | 具体而言，加密函数首先通过AddRoundKey操作将输入in与密钥的前4个字单元进行异或运算。然后，在接下来的Nr-1轮中，它会对输入执行一系列操作——SubBytes（使用S盒将输入的每个字节替换为另一个字节）、ShiftRows（将每行字节向左移动特定数量的位置）和MixColumns（将每列字节乘以特定矩阵并进行模多项式加法运算）——并使用当前轮数的密钥key进行AddRoundKey（简单的异或操作，它将输入与当前轮次的密钥进行异或运算）操作。最后，在第Nr轮中，它只执行SubBytes、ShiftRows和AddRoundKey操作，没有MixColumns操作。
158 | 
159 | 下面是解密函数
160 | 
161 | ```c
162 | void decrypt(byte in[4 * 4], word w[4 * (Nr + 1)]){
163 | 	word key[4];
164 | 	for (int i = 0; i<4; ++i)
165 | 		key[i] = w[4 * Nr + i];
166 | 	AddRoundKey(in, key);
167 | 
168 | 	for (int round = Nr - 1; round>0; --round)
169 | 	{
170 | 		InvShiftRows(in);
171 | 		InvSubBytes(in);
172 | 		for (int i = 0; i<4; ++i)
173 | 			key[i] = w[4 * round + i];
174 | 		AddRoundKey(in, key);
175 | 		InvMixColumns(in);
176 | 	}
177 | 
178 | 	InvShiftRows(in);
179 | 	InvSubBytes(in);
180 | 	for (int i = 0; i<4; ++i)
181 | 		key[i] = w[i];
182 | 	AddRoundKey(in, key);
183 | }
184 | ```
185 | 
186 | 解密函数首先从w中提取最后一轮密钥，并使用AddRoundKey操作将其与输入进行异或运算。随后，在接下来的Nr-1轮中，该函数执行一系列操作：首先对输入执行InvShiftRows操作，然后执行InvSubBytes操作，并使用当前轮数的密钥与输入进行AddRoundKey操作。接着，它执行InvMixColumns操作，以撤销AES加密算法中的MixColumns操作。在第Nr轮中，函数仅执行InvShiftRows、InvSubBytes和AddRoundKey操作，没有InvMixColumns操作。最后，函数使用密钥扩展数组中的第一个字作为最终轮次的密钥，并使用AddRoundKey操作对输入进行最后一次解密。
187 | 
188 | ##### 四、实验数据记录（或仿真及软件设计）
189 | 
190 | 输入密钥：99 87 7e 56 35 23 ff 88 15 09 a3 56 e5 67 19 1f以及明文：aa 7d 6a 78 fa 1e c4 57 2d 3e 33 56 46 13 a1 a5，进行相应的加密，可以得出加密的结果是3e 88 9 18 7a bf 53 bb f3 30 31 27 60 16 f5 d0，输入对应密钥再对加密后的结果进行解密操作得到原始明文aa 7d 6a 78 fa 1e c4 57 2d 3e 33 56 46 13 a1 a5。
191 | 
192 | ![img](/screenshots/5.1.png)
193 | 
194 | ##### 五、实验结果分析及回答问题（或测试环境及测试结果）
195 | 
196 | 1. 在AES加密的10轮循环中，前9轮与第10轮有什么不同？
197 | 
198 | 前9轮和第10轮使用的密钥是不同的。其次，在前9轮中，AES算法使用的转换操作是SubBytes、ShiftRows、MixColumns和AddRoundKey。这些操作将输入块分割成16个字节，然后通过置换、替换和线性变换来混淆它们。在第10轮中，AES算法只使用SubBytes、ShiftRows和AddRoundKey三种转换，而没有MixColumns操作。MixColumns操作将每个字节与特定矩阵相乘并进行模多项式加法运算，增强了算法的扰动和非线性性质。但是，在最终一轮中，该操作被省略，因为它会使得解密过程更加困难。
199 | 
200 | 2. “AES算法和DES算法一样，都是对比特进行操作从而完成加密的”，你认为这句话对吗？
201 | 
202 | 尽管AES算法和DES算法都是对比特进行操作，但它们的加密方式是不同的。在DES算法中，明文被分成64位块，并使用56位密钥进行加密。算法将每个块分为左右两个32位半块，并对右半块应用一系列置换、替换、移位和异或运算。算法重复16轮以上的步骤来加密每个块，每轮都涉及到了密钥的子集。而在AES算法中，明文被分成128位块，并使用128位密钥进行加密。算法将每个块视为一个4x4矩阵，并执行SubBytes、ShiftRows、MixColumns和AddRoundKey等转换操作，使得每个元素都有机会与其他元素之间相互影响。AES算法重复10轮以上的步骤来加密每个块，每轮都需要使用轮密钥的不同子集。因此，AES和DES算法都是基于对比特进行操作的块密码算法，但它们具体的加密方式和操作过程是不同的。
203 | 


--------------------------------------------------------------------------------
/1/report/6.md:
--------------------------------------------------------------------------------
  1 | ## 实验六
  2 | 
  3 | ### 非对称密码算法-RSA密码
  4 | 
  5 | ##### 一、实验目的
  6 | 
  7 | 1. 掌握RSA生成公钥私钥的过程；
  8 | 
  9 | 2. 熟练掌握利用RSA密钥对指定内容的加解密进程。
 10 | 3. 设计RSA加密工具，利用RSA加密算法对文件进行加密。
 11 | 
 12 | ##### 二、实验所用仪器（或实验环境）
 13 | 
 14 | ​	VSCode+MinGW
 15 | 
 16 | ##### 三、实验基本原理及步骤（或方案设计及理论计算）
 17 | 
 18 | RSA（Rivest–Shamir–Adleman）是一种非对称加密算法，其加解密过程如下：
 19 | 
 20 | 1. 密钥生成：随机生成两个大素数p和q，并计算模数n=p\*q、φ(n)=(p-1)\*(q-1)，选择一个整数e（1<e<φ(n)）作为公钥，使得e和φ(n)互质，然后计算d，使得d*e = 1 (mod φ(n))，即d是e在模φ(n)意义下的乘法逆元。公钥为{e, n}，私钥为{d, n}。
 21 | 2. 加密：将明文转换成整数M（通常使用编码方案进行转换），然后用公钥{e, n}来计算密文C = M^e (mod n)。
 22 | 3. 解密：接收到密文C后，使用私钥{d, n}来计算出明文M = C^d (mod n)。
 23 | 
 24 | 主函数如下
 25 | 
 26 | ```c++
 27 | int main() {
 28 | 	//p,q为素数，e为公钥，d为私钥，m为明文，n为模数 ,c为密文 
 29 | 	int p, q, e, d, m, n, t, c, r, k;
 30 | 	printf("请输入两个素数p,q:");
 31 | 	while (1){
 32 | 		scanf("%d%d", &p, &q);
 33 | 		//判断两个数是否为素数，不是的话重新输入
 34 | 		if ((Prime(p) == 1) && (Prime(q) == 1)){  
 35 | 			n = p*q;
 36 | 			break;
 37 | 		}
 38 | 		else printf("ERROR!\n请重新输入两个素数p,q\n");
 39 | 	}
 40 | 	//求欧拉函数t
 41 | 	t = (p - 1)*(q - 1);      
 42 | 	printf("请输入你想设置的公钥e，注意：1<e<φ(n)，且e与(p - 1)*(q - 1)互质。e:");
 43 | 	scanf("%d", &e);
 44 | 
 45 | 	while (e<1 || e>t || husu(e, t)){
 46 | 		printf("ERROR!e不符合要求！请重新输入e:\n");
 47 | 		scanf("%d", &e);
 48 | 	}
 49 | 
 50 | 	d = 1;
 51 | 	//由公钥e求出私钥d
 52 | 	while (((e*d) % t) != 1)   
 53 | 		d++;     
 54 | 	printf("计算出的私钥d:%d\n",d);
 55 | 	printf("请输入想要加密的明文:");
 56 | 	scanf("%d", &m);
 57 | 	c = encrypt(m, e, n);
 58 | 	printf("密文为: %d\n", c);
 59 | 	printf("请输入密文:");
 60 | 	scanf("%d", &c);
 61 | 	m = encrypt(c, d, n);
 62 | 	printf("明文为: %d", m);
 63 | }
 64 | ```
 65 | 
 66 | 主函数实现了一个基本的RSA加密算法。通过获取输入的两个素数p和q，计算得到模数n。然后输入公钥e，公钥e应该满足1<e<φ(n)，且e与(p - 1)*(q - 1)互质，所以会对输入的e进行一个是否是素数的判断。再根据欧拉函数求出私钥d。然后将明文m加密为密文c，并输出密文；同时也能将密文解密为明文。在加密和解密过程中，使用了encrypt()函数来实现加解密操作。encrypt()函数实际上是是一个幂取余的过程。
 67 | 
 68 | 下面是判断整数是否为素数的函数Prime(int m)，其输入参数为一个整数m。这个函数用于判断输入的p,q是否是素数。
 69 | 
 70 | ```c++
 71 | int Prime(int m){    
 72 | 	int i, k;
 73 | 	if (m<2) return 0;
 74 | 	k = sqrt(m);
 75 | 	for (i = 2; i <= k; i++)
 76 | 		if (m%i == 0)
 77 | 			break;
 78 | 	 //素数返回1,否则返回0
 79 | 	if (i>k)   
 80 | 		return 1;                  
 81 | 	else
 82 | 		return 0;                    
 83 | }
 84 | ```
 85 | 
 86 | 这段代码的实现逻辑如下：
 87 | 
 88 | - 首先，如果输入的m小于2，直接返回0，因为小于2的数都不是素数。
 89 | - 接着，定义变量k等于m的平方根（sqrt(m)）向下取整的值，这是因为一个数如果有因子n，那么必定存在另一个因子m/n。而且n和m/n中必有一个小于或等于sqrt(m)，另一个大于或等于sqrt(m)。因此只需要从2遍历到k就可以找到m的所有因子，从而判断m是否为素数。
 90 | - 然后使用for循环，从2开始遍历到k，依次判断m能否被i整除。如果存在可以整除的i，则跳出循环。
 91 | - 最后，在循环结束后，检查i是否大于k。若大于k，说明m没有除了1和自身之外的其它因子，即m是素数，返回1；否则，说明m有其他因子，返回0。
 92 | 
 93 | 下面是判断两数是否互素的函数，主要用于判断公钥e是否与(p - 1)*(q - 1)互质
 94 | 
 95 | ```c++
 96 | int husu(int x, int y){   
 97 | 	int t;
 98 | 	while (y){
 99 | 		t = x;
100 | 		x = y;
101 | 		y = t%y;
102 | 	}
103 | 	//x与y互素时返回0，x与y不互素时返回1  
104 | 	if (x == 1) 
105 | 		return 0;           
106 | 	else  
107 | 		return 1;   
108 | }
109 | ```
110 | 
111 | 这个函数的具体实现流程如下：
112 | 
113 | - 首先，使用while循环进行辗转相除法（又称欧几里得算法），求出x和y的最大公约数，保存在变量t中，直到y等于0，此时x就是x和y的最大公约数。
114 | - 然后，如果x等于1，说明x和y互质，因为只有当两个数的最大公约数为1时，它们才是互质的，返回0。
115 | - 最后，如果x不等于1，说明x和y不互质，返回1。
116 | 
117 | 下面是加密解密用到的函数，这段代码实现了一个简单的模幂运算，其中a为明文，b为指数，c为模数。
118 | 
119 | ```c++
120 | int encrypt(int a, int b, int c){
121 | 	int r = 1;
122 | 	b = b + 1;
123 | 	while (b != 1){
124 | 		r = r*a;
125 | 		r = r%c;
126 | 		b--;
127 | 	}
128 | 	return r;
129 | }
130 | ```
131 | 
132 | ##### 四、实验数据记录（或仿真及软件设计）
133 | 
134 | 输入两个素数p=47，q=59，则n=p\*q，再输入设置的公钥e=63，满足了1<e<φ(n)，且e与(p - 1)*(q - 1)互质。计算出的私钥d为847，进行加密后密文c=m^e (mod n)为1692，密文解密后的结果m = c^d (mod n)为188.
135 | 
136 | ![img](/screenshots/6.1.png)
137 | 
138 | 利用给出的小工具去判断加密解密流程是否正确，注意这里公钥63的格式应该输入成十六进制的3f，右侧的进制选择10，明文选项选择大数。通过使用工具验证，可知RSA加解密流程正确。
139 | 
140 | ![img](/screenshots/6.2.png)
141 | 
142 | ##### 五、实验结果分析及回答问题（或测试环境及测试结果）
143 | 
144 | 1、简述RSA的公钥生成算法
145 | 
146 | RSA公钥生成算法的步骤如下：
147 | 
148 | 1. 随机选择两个不相等的质数p和q
149 | 2. 计算n = p * q
150 | 3. 计算欧拉函数φ(n) = (p-1) * (q-1)
151 | 4. 随机选择一个整数e，满足1 < e < φ(n)，且e与φ(n)互质（即它们没有除了1以外的公共因子）
152 | 5. 计算e关于模φ(n)的乘法逆元d，即d ≡ e⁻¹ (mod φ(n))
153 | 6. 公钥为(n, e)，私钥为(n, d)
154 | 
155 | 其中，公钥由(n, e)组成，私钥由(n, d)组成。在实际使用中，p和q应该足够大并且随机选择，以确保 RSA 的安全性
156 | 
157 | 2、“无法证明RSA算法是安全的”，你认为这句话对吗？
158 | 
159 | 在密码学中，任何算法都无法被证明是绝对安全的，因为即使看似很安全的算法仍然可能被攻击者破解或者利用漏洞攻击。RSA算法也不例外。RSA算法的安全性与所选用的素数的长度有直接关系。一般来说，选用更长的素数会使攻击者通过暴力破解的难度增大，从而提高了RSA算法的安全性。总之，虽然没有一种加密算法可以被完全证明是绝对安全的，但是，如果正确使用并采取适当的安全措施，RSA算法可以提供足够的保护来满足大部分实际安全需求。
160 | 
161 | 
162 | 
163 | 
164 | 
165 | 


--------------------------------------------------------------------------------
/1/report/7.md:
--------------------------------------------------------------------------------
 1 | ## 实验七
 2 | 
 3 | ### Hash算法-MD5密码
 4 | 
 5 | ##### 一、实验目的
 6 | 
 7 | 1. 学习MD5算法生成文件摘要的过程；
 8 | 2. 设计实现MD5文件校验工具，完成MD5算法对文件加密。
 9 | 3. 了解MD5算法特点和应用场景
10 | 
11 | ##### 二、实验所用仪器（或实验环境）
12 | 
13 | ​	VSCode+MinGW
14 | 
15 | ##### 三、实验基本原理及步骤（或方案设计及理论计算）
16 | 
17 | **MD5算法生成文件摘要的过程**: MD5（Message-Digest Algorithm 5）是一种常用的哈希算法，可以将任意长度的消息摘要成一个固定长度的数字指纹。生成文件摘要的过程如下：
18 | 
19 | 1. 初始化：MD5算法会先初始化一些常量和变量，包括4个32位寄存器A、B、C、D，以及一个64字节的缓冲区。
20 | 2. 填充消息：将要计算摘要的消息进行填充，使其长度满足512位（64字节）的倍数，填充规则为在消息末尾添加一个1，然后补0直到消息长度满足条件。
21 | 3. 处理消息块：将填充后的消息按照512位（64字节）分组，每次处理一组，共进行n个循环，其中n等于消息长度除以512的整数部分。
22 | 4. 更新寄存器：对每个消息块进行操作，从而更新寄存器A、B、C、D的值。
23 | 5. 生成摘要：当所有消息块都被处理后，将A、B、C、D四个寄存器中的内容按照大端序（高位字节在前，低位字节在后）连接起来，即可得到128位的摘要。
24 | 6. 输出摘要：最后返回128位的MD5摘要作为输出结果。
25 | 
26 | 
27 | 
28 | 主函数如下
29 | 
30 | ```cpp
31 | int main(){   
32 | 	printf("MD5加密程序：\n");
33 |     while(1)
34 |     {
35 |         printf("请输入加密文件名称（输入exit则退出程序）\n");
36 |         gets(filename); //用get函数,避免scanf以空格分割数据,
37 |         if (filename[0]==34) filename[strlen(filename)-1]=0,strcpy(filename,filename+1); //支持文件拖曳,但会多出双引号,这里是处理多余的双引号
38 |         if (!strcmp(filename,"exit")) exit(0); //输入exit退出
39 |         if (!(fp=fopen(filename,"rb")))
40 |         {
41 |             printf("Can not open this file!\n"); //以二进制打开文件
42 |             continue;
43 |         }
44 |         fseek(fp, 0, SEEK_END); //文件指针转到文件末尾
45 |         if((len=ftell(fp))==-1)
46 |         {
47 |             printf("Sorry! Can not calculate files which larger than 2 GB!\n"); //ftell函数返回long,最大为2GB,超出返回-1
48 |             fclose(fp);
49 |             continue;
50 |         }
51 |         rewind(fp); //文件指针复位到文件头
52 |         A=0x67452301,B=0xefcdab89,C=0x98badcfe,D=0x10325476; //初始化链接变量
53 |         flen[1]=len/0x20000000; //flen单位是bit
54 |         flen[0]=(len%0x20000000)*8;
55 |         memset(x,0,64); //初始化x数组为0
56 |         fread(&x,4,16,fp); //以4字节为一组,读取16组数据
57 |         for(i=0; i<len/64; i++) //循环运算直至文件结束
58 |         {
59 |             md5();
60 |             memset(x,0,64);
61 |             fread(&x,4,16,fp);
62 |         }
63 |         ((char*)x)[len%64]=128; //文件结束补1,补0操作,128二进制即10000000
64 |         if(len%64>55) md5(),memset(x,0,64);
65 |         memcpy(x+14,flen,8); //文件末尾加入原文件的bit长度
66 |         md5();
67 |         fclose(fp);
68 | 		printf("请输入输出文件名称:\n");
69 | 		gets(filename);
70 | 		fp=fopen(filename,"w+");
71 |         fprintf(fp,"%08x%08x%08x%08x\n",PP(A),PP(B),PP(C),PP(D)); //高低位逆反输出
72 | 		fclose(fp);
73 | 		printf("加密完成，请查看！\n");
74 | 		printf("\n");
75 |     }
76 |     return 0;
77 | }
78 | ```
79 | 
80 | 这段代码是一个MD5加密程序的主函数，使用printf()输出一条提示信息，让用户输入要加密的文件名称。使用gets()函数获取用户输入的文件名称，并存储到filename变量中。使用fopen()函数以二进制模式打开用户输入的文件。然后使用fseek()函数将文件指针移动到文件末尾，使用ftell()函数获取文件长度，单位为字节。、如果文件长度超过了2GB，则无法计算文件摘要，程序会输出错误信息并继续等待用户输入。下面需要初始化链接变量：使用四个32位寄存器A、B、C、D分别初始化为0x67452301、0xefcdab89、0x98badcfe、0x10325476，作为链接变量。再分块处理文件数据：将文件按照64字节（512位）分组，每次处理一组，共进行len/64次循环。在循环中，调用md5()函数来更新链接变量的值。文件结束补位：在文件末尾添加一个1和若干个0，使得文件长度为512的倍数。如果文件末尾不足64字节，则补位操作需要跨越两个分组进行。最后将四个32位链接变量的值高低位逆序输出，并将输出结果写入到用户指定的输出文件中。
81 | 
82 | ##### 四、实验数据记录（或仿真及软件设计）
83 | 
84 | 下面是MD5加密程序
85 | 
86 | ![img](/screenshots/7.1.png)
87 | 
88 | 文件如图所示
89 | 
90 | ![img](/screenshots/7.2.png)
91 | 
92 | ##### 五、实验结果分析及回答问题（或测试环境及测试结果）
93 | 
94 | 1.MD5生成摘要的长度是多少位？
95 | 
96 | MD5生成的摘要长度是128位。
97 | 


--------------------------------------------------------------------------------
/1/screenshots/1.1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/1.1.png


--------------------------------------------------------------------------------
/1/screenshots/1.2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/1.2.png


--------------------------------------------------------------------------------
/1/screenshots/1.3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/1.3.png


--------------------------------------------------------------------------------
/1/screenshots/2.1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/2.1.png


--------------------------------------------------------------------------------
/1/screenshots/2.2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/2.2.png


--------------------------------------------------------------------------------
/1/screenshots/2.3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/2.3.png


--------------------------------------------------------------------------------
/1/screenshots/3.1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/3.1.png


--------------------------------------------------------------------------------
/1/screenshots/3.2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/3.2.png


--------------------------------------------------------------------------------
/1/screenshots/4.1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/4.1.png


--------------------------------------------------------------------------------
/1/screenshots/4.2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/4.2.png


--------------------------------------------------------------------------------
/1/screenshots/5.1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/5.1.png


--------------------------------------------------------------------------------
/1/screenshots/6.1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/6.1.png


--------------------------------------------------------------------------------
/1/screenshots/6.2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/6.2.png


--------------------------------------------------------------------------------
/1/screenshots/7.1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/7.1.png


--------------------------------------------------------------------------------
/1/screenshots/7.2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/1/screenshots/7.2.png


--------------------------------------------------------------------------------
/2/实验1.凯撒密码/ciphertext.txt:
--------------------------------------------------------------------------------
1 | Ckhqjolq,Ol 17030130089


--------------------------------------------------------------------------------
/2/实验1.凯撒密码/decrypted_plaintext.txt:
--------------------------------------------------------------------------------
1 | Zhenglin,Li 17030130089


--------------------------------------------------------------------------------
/2/实验1.凯撒密码/plaintext.txt:
--------------------------------------------------------------------------------
1 | Zhenglin,Li 17030130089


--------------------------------------------------------------------------------
/2/实验1.凯撒密码/test.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验1.凯撒密码/test.c


--------------------------------------------------------------------------------
/2/实验1.凯撒密码/test.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验1.凯撒密码/test.exe


--------------------------------------------------------------------------------
/2/实验2.单表置换/ciphertext.txt:
--------------------------------------------------------------------------------
1 | ZCEBYRUB,RU 17030130089


--------------------------------------------------------------------------------
/2/实验2.单表置换/decrypted_plaintext.txt:
--------------------------------------------------------------------------------
1 | zhenglin,li 17030130089


--------------------------------------------------------------------------------
/2/实验2.单表置换/plaintext.txt:
--------------------------------------------------------------------------------
1 | Zhenglin,Li 17030130089


--------------------------------------------------------------------------------
/2/实验2.单表置换/test.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验2.单表置换/test.c


--------------------------------------------------------------------------------
/2/实验2.单表置换/test.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验2.单表置换/test.exe


--------------------------------------------------------------------------------
/2/实验3.仿射密码/ciphertext.txt:
--------------------------------------------------------------------------------
1 | XVMNSHYN,HY 17030130089


--------------------------------------------------------------------------------
/2/实验3.仿射密码/devrypted_plaintext.txt:
--------------------------------------------------------------------------------
1 | awrgdupg,up 17030130089


--------------------------------------------------------------------------------
/2/实验3.仿射密码/plaintext.txt:
--------------------------------------------------------------------------------
1 | Zhenglin,Li 17030130089


--------------------------------------------------------------------------------
/2/实验3.仿射密码/test.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验3.仿射密码/test.c


--------------------------------------------------------------------------------
/2/实验3.仿射密码/test.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验3.仿射密码/test.exe


--------------------------------------------------------------------------------
/2/实验4.DES/DES.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验4.DES/DES.cpp


--------------------------------------------------------------------------------
/2/实验4.DES/DES.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验4.DES/DES.exe


--------------------------------------------------------------------------------
/2/实验4.DES/ciphertext-tool.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验4.DES/ciphertext-tool.txt


--------------------------------------------------------------------------------
/2/实验4.DES/ciphertext.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验4.DES/ciphertext.txt


--------------------------------------------------------------------------------
/2/实验4.DES/decrypted_plaintext.txt:
--------------------------------------------------------------------------------
1 | Hello World!


--------------------------------------------------------------------------------
/2/实验4.DES/key.txt:
--------------------------------------------------------------------------------
1 | 12345678


--------------------------------------------------------------------------------
/2/实验4.DES/plaintext.txt:
--------------------------------------------------------------------------------
1 | Hello World!


--------------------------------------------------------------------------------
/2/实验5.AES/AES.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/AES.cpp


--------------------------------------------------------------------------------
/2/实验5.AES/AES.dsp:
--------------------------------------------------------------------------------
  1 | # Microsoft Developer Studio Project File - Name="AES" - Package Owner=<4>
  2 | # Microsoft Developer Studio Generated Build File, Format Version 6.00
  3 | # ** DO NOT EDIT **
  4 | 
  5 | # TARGTYPE "Win32 (x86) Console Application" 0x0103
  6 | 
  7 | CFG=AES - Win32 Debug
  8 | !MESSAGE This is not a valid makefile. To build this project using NMAKE,
  9 | !MESSAGE use the Export Makefile command and run
 10 | !MESSAGE 
 11 | !MESSAGE NMAKE /f "AES.mak".
 12 | !MESSAGE 
 13 | !MESSAGE You can specify a configuration when running NMAKE
 14 | !MESSAGE by defining the macro CFG on the command line. For example:
 15 | !MESSAGE 
 16 | !MESSAGE NMAKE /f "AES.mak" CFG="AES - Win32 Debug"
 17 | !MESSAGE 
 18 | !MESSAGE Possible choices for configuration are:
 19 | !MESSAGE 
 20 | !MESSAGE "AES - Win32 Release" (based on "Win32 (x86) Console Application")
 21 | !MESSAGE "AES - Win32 Debug" (based on "Win32 (x86) Console Application")
 22 | !MESSAGE 
 23 | 
 24 | # Begin Project
 25 | # PROP AllowPerConfigDependencies 0
 26 | # PROP Scc_ProjName ""
 27 | # PROP Scc_LocalPath ""
 28 | CPP=cl.exe
 29 | RSC=rc.exe
 30 | 
 31 | !IF  "$(CFG)" == "AES - Win32 Release"
 32 | 
 33 | # PROP BASE Use_MFC 0
 34 | # PROP BASE Use_Debug_Libraries 0
 35 | # PROP BASE Output_Dir "Release"
 36 | # PROP BASE Intermediate_Dir "Release"
 37 | # PROP BASE Target_Dir ""
 38 | # PROP Use_MFC 0
 39 | # PROP Use_Debug_Libraries 0
 40 | # PROP Output_Dir "Release"
 41 | # PROP Intermediate_Dir "Release"
 42 | # PROP Target_Dir ""
 43 | # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
 44 | # ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
 45 | # ADD BASE RSC /l 0x804 /d "NDEBUG"
 46 | # ADD RSC /l 0x804 /d "NDEBUG"
 47 | BSC32=bscmake.exe
 48 | # ADD BASE BSC32 /nologo
 49 | # ADD BSC32 /nologo
 50 | LINK32=link.exe
 51 | # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
 52 | # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
 53 | 
 54 | !ELSEIF  "$(CFG)" == "AES - Win32 Debug"
 55 | 
 56 | # PROP BASE Use_MFC 0
 57 | # PROP BASE Use_Debug_Libraries 1
 58 | # PROP BASE Output_Dir "Debug"
 59 | # PROP BASE Intermediate_Dir "Debug"
 60 | # PROP BASE Target_Dir ""
 61 | # PROP Use_MFC 2
 62 | # PROP Use_Debug_Libraries 1
 63 | # PROP Output_Dir "Debug"
 64 | # PROP Intermediate_Dir "Debug"
 65 | # PROP Target_Dir ""
 66 | # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ  /c
 67 | # ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "_AFXDLL" /FR /YX /FD /GZ  /c
 68 | # ADD BASE RSC /l 0x804 /d "_DEBUG"
 69 | # ADD RSC /l 0x804 /d "_DEBUG" /d "_AFXDLL"
 70 | BSC32=bscmake.exe
 71 | # ADD BASE BSC32 /nologo
 72 | # ADD BSC32 /nologo
 73 | LINK32=link.exe
 74 | # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
 75 | # ADD LINK32 /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
 76 | 
 77 | !ENDIF 
 78 | 
 79 | # Begin Target
 80 | 
 81 | # Name "AES - Win32 Release"
 82 | # Name "AES - Win32 Debug"
 83 | # Begin Group "Source Files"
 84 | 
 85 | # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
 86 | # Begin Source File
 87 | 
 88 | SOURCE=.\AES.cpp
 89 | # End Source File
 90 | # Begin Source File
 91 | 
 92 | SOURCE=.\main.cpp
 93 | # End Source File
 94 | # End Group
 95 | # Begin Group "Header Files"
 96 | 
 97 | # PROP Default_Filter "h;hpp;hxx;hm;inl"
 98 | # Begin Source File
 99 | 
100 | SOURCE=.\AES.h
101 | # End Source File
102 | # End Group
103 | # Begin Group "Resource Files"
104 | 
105 | # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
106 | # End Group
107 | # End Target
108 | # End Project
109 | 


--------------------------------------------------------------------------------
/2/实验5.AES/AES.dsw:
--------------------------------------------------------------------------------
 1 | Microsoft Developer Studio Workspace File, Format Version 6.00
 2 | # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
 3 | 
 4 | ###############################################################################
 5 | 
 6 | Project: "AES"=.\AES.dsp - Package Owner=<4>
 7 | 
 8 | Package=<5>
 9 | {{{
10 | }}}
11 | 
12 | Package=<4>
13 | {{{
14 | }}}
15 | 
16 | ###############################################################################
17 | 
18 | Global:
19 | 
20 | Package=<5>
21 | {{{
22 | }}}
23 | 
24 | Package=<3>
25 | {{{
26 | }}}
27 | 
28 | ###############################################################################
29 | 
30 | 


--------------------------------------------------------------------------------
/2/实验5.AES/AES.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/AES.exe


--------------------------------------------------------------------------------
/2/实验5.AES/AES.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | void aes_decrypt(unsigned char* key , unsigned int* mw);
4 | void aes_encrypt(unsigned char* key , unsigned int* mw);


--------------------------------------------------------------------------------
/2/实验5.AES/AES.ncb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/AES.ncb


--------------------------------------------------------------------------------
/2/实验5.AES/AES.opt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/AES.opt


--------------------------------------------------------------------------------
/2/实验5.AES/AES.plg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/AES.plg


--------------------------------------------------------------------------------
/2/实验5.AES/Debug/AES.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/Debug/AES.exe


--------------------------------------------------------------------------------
/2/实验5.AES/Debug/AES.ilk:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/Debug/AES.ilk


--------------------------------------------------------------------------------
/2/实验5.AES/Debug/AES.obj:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/Debug/AES.obj


--------------------------------------------------------------------------------
/2/实验5.AES/Debug/AES.pch:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/Debug/AES.pch


--------------------------------------------------------------------------------
/2/实验5.AES/Debug/AES.pdb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/Debug/AES.pdb


--------------------------------------------------------------------------------
/2/实验5.AES/Debug/AES.sbr:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/Debug/AES.sbr


--------------------------------------------------------------------------------
/2/实验5.AES/Debug/main.obj:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/Debug/main.obj


--------------------------------------------------------------------------------
/2/实验5.AES/Debug/main.pch:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/Debug/main.pch


--------------------------------------------------------------------------------
/2/实验5.AES/Debug/main.pdb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/Debug/main.pdb


--------------------------------------------------------------------------------
/2/实验5.AES/Debug/main.sbr:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/Debug/main.sbr


--------------------------------------------------------------------------------
/2/实验5.AES/Debug/vc60.idb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/Debug/vc60.idb


--------------------------------------------------------------------------------
/2/实验5.AES/Debug/vc60.pdb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/Debug/vc60.pdb


--------------------------------------------------------------------------------
/2/实验5.AES/ciphertext-tool.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/ciphertext-tool.txt


--------------------------------------------------------------------------------
/2/实验5.AES/ciphertext.txt:
--------------------------------------------------------------------------------
1 | 4119961686 2318672801 3326210823 2906120858 111 87 111 114 108 100 33 


--------------------------------------------------------------------------------
/2/实验5.AES/decrypted_plaintext.txt:
--------------------------------------------------------------------------------
1 | HelloWorld!


--------------------------------------------------------------------------------
/2/实验5.AES/key.txt:
--------------------------------------------------------------------------------
1 | 12345678ABCDEFGH


--------------------------------------------------------------------------------
/2/实验5.AES/main.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/2/实验5.AES/main.cpp


--------------------------------------------------------------------------------
/2/实验5.AES/main.dsp:
--------------------------------------------------------------------------------
 1 | # Microsoft Developer Studio Project File - Name="main" - Package Owner=<4>
 2 | # Microsoft Developer Studio Generated Build File, Format Version 6.00
 3 | # ** DO NOT EDIT **
 4 | 
 5 | # TARGTYPE "Win32 (x86) Console Application" 0x0103
 6 | 
 7 | CFG=main - Win32 Debug
 8 | !MESSAGE This is not a valid makefile. To build this project using NMAKE,
 9 | !MESSAGE use the Export Makefile command and run
10 | !MESSAGE 
11 | !MESSAGE NMAKE /f "main.mak".
12 | !MESSAGE 
13 | !MESSAGE You can specify a configuration when running NMAKE
14 | !MESSAGE by defining the macro CFG on the command line. For example:
15 | !MESSAGE 
16 | !MESSAGE NMAKE /f "main.mak" CFG="main - Win32 Debug"
17 | !MESSAGE 
18 | !MESSAGE Possible choices for configuration are:
19 | !MESSAGE 
20 | !MESSAGE "main - Win32 Release" (based on "Win32 (x86) Console Application")
21 | !MESSAGE "main - Win32 Debug" (based on "Win32 (x86) Console Application")
22 | !MESSAGE 
23 | 
24 | # Begin Project
25 | # PROP AllowPerConfigDependencies 0
26 | # PROP Scc_ProjName ""
27 | # PROP Scc_LocalPath ""
28 | CPP=cl.exe
29 | RSC=rc.exe
30 | 
31 | !IF  "$(CFG)" == "main - Win32 Release"
32 | 
33 | # PROP BASE Use_MFC 0
34 | # PROP BASE Use_Debug_Libraries 0
35 | # PROP BASE Output_Dir "Release"
36 | # PROP BASE Intermediate_Dir "Release"
37 | # PROP BASE Target_Dir ""
38 | # PROP Use_MFC 0
39 | # PROP Use_Debug_Libraries 0
40 | # PROP Output_Dir "Release"
41 | # PROP Intermediate_Dir "Release"
42 | # PROP Target_Dir ""
43 | # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
44 | # ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
45 | # ADD BASE RSC /l 0x804 /d "NDEBUG"
46 | # ADD RSC /l 0x804 /d "NDEBUG"
47 | BSC32=bscmake.exe
48 | # ADD BASE BSC32 /nologo
49 | # ADD BSC32 /nologo
50 | LINK32=link.exe
51 | # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
52 | # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
53 | 
54 | !ELSEIF  "$(CFG)" == "main - Win32 Debug"
55 | 
56 | # PROP BASE Use_MFC 0
57 | # PROP BASE Use_Debug_Libraries 1
58 | # PROP BASE Output_Dir "Debug"
59 | # PROP BASE Intermediate_Dir "Debug"
60 | # PROP BASE Target_Dir ""
61 | # PROP Use_MFC 0
62 | # PROP Use_Debug_Libraries 1
63 | # PROP Output_Dir "Debug"
64 | # PROP Intermediate_Dir "Debug"
65 | # PROP Target_Dir ""
66 | # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
67 | # ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
68 | # ADD BASE RSC /l 0x804 /d "_DEBUG"
69 | # ADD RSC /l 0x804 /d "_DEBUG"
70 | BSC32=bscmake.exe
71 | # ADD BASE BSC32 /nologo
72 | # ADD BSC32 /nologo
73 | LINK32=link.exe
74 | # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
75 | # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
76 | 
77 | !ENDIF 
78 | 
79 | # Begin Target
80 | 
81 | # Name "main - Win32 Release"
82 | # Name "main - Win32 Debug"
83 | # Begin Source File
84 | 
85 | SOURCE=.\main.cpp
86 | # End Source File
87 | # End Target
88 | # End Project
89 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 Marvel-Gu
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ### 西电计科应用密码学与网络安全实验
2 | 
3 | 可以去<a href="https://www.levitategu.cn" style="color: #177cb0; text-decoration: underline;text-decoration-style: dotted;">我的博客</a>找对应的<a href="https://www.levitategu.cn/2024/06/26/2024-6-26-%E5%BA%94%E7%94%A8%E5%AF%86%E7%A0%81%E5%AD%A6/" style="color: #177cb0; text-decoration: underline;text-decoration-style: dotted;">博文</a>, 仓库中有两份代码和实验报告, 最好结合着看
4 | 
5 | 最后欢迎follow和star😘
6 | 


--------------------------------------------------------------------------------
/实验报告-传.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/实验报告-传.docx


--------------------------------------------------------------------------------
/实验报告.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Marvel-Gu/XDU_CS_Applied_cryptography/f778316f296344398bfc6ce24a7c12219a607264/实验报告.docx


--------------------------------------------------------------------------------