四种加密解密算法的源代码：移位密码、仿射密码
加密解密程序设计
加密解密程序设计加密解密程序设计通常用于保护敏感信息的传输和存储，确保只有授权的用户才能访问和理解这些信息。
本文将讨论一个基本的加密解密程序设计，其中包含了常用的加密算法和解密算法，以及一些常见的加密解密技巧和策略。
一、加密算法设计1. 替换加密算法（Substitution Cipher）：将原始消息中的字符替换为其他字符，通常使用一个固定的字母表和一个加密密钥。
例如，可以通过移位加密算法将字母A替换为字母D，将字母B替换为字母E，以此类推。
解密时，将密文中的字符替换回原始字符即可。
2. 移位加密算法（Caesar Cipher）：也称为凯撒密码，是一种简单的替换密码。
将原始消息中的每个字母按照固定的位移量向后移动，例如，位移量为3时，字母A将被替换为字母D，字母B将被替换为字母E，以此类推。
解密时，将密文中的字母按照相同的位移量向前移动即可恢复原始消息。
3. 对称加密算法（Symmetric Cryptography）：使用同一个密钥进行加密和解密，常用的对称加密算法包括DES、AES和RC4等。
加密时，将原始消息和密钥作为输入，通过特定的算法生成密文。
解密时，将密文和相同的密钥作为输入，通过逆算法恢复原始消息。
4. 非对称加密算法（Asymmetric Cryptography）：使用两个不同的密钥进行加密和解密，分别为公钥和私钥。
常用的非对称加密算法包括RSA、DSA和ECC等。
加密时，将原始消息和公钥作为输入，通过特定的算法生成密文。
解密时，将密文和私钥作为输入，通过逆算法恢复原始消息。
5. 哈希函数（Hash Function）：将任意长度的输入数据映射到固定长度的输出数据。
常用的哈希函数有MD5和SHA1等。
哈希函数通常用于生成消息的摘要，以验证消息的完整性和防止数据篡改。
二、加密解密程序设计示例以下是一个基本的加密解密程序设计示例，使用移位加密算法和对称加密算法进行加密和解密。
1.移位加密算法：```pythondef shift_cipher_encrypt(message, shift):encrypted_message = ""for character in message:if character.isalpha(:encrypted_character = chr((ord(character) - ord('A') + shift) % 26 + ord('A'))else:encrypted_character = characterencrypted_message += encrypted_characterreturn encrypted_messagedef shift_cipher_decrypt(encrypted_message, shift):decrypted_message = ""for character in encrypted_message:if character.isalpha(:decrypted_character = chr((ord(character) - ord('A') - shift) % 26 + ord('A'))else:decrypted_character = characterdecrypted_message += decrypted_characterreturn decrypted_message```2. 对称加密算法（使用Python的PyCrypto库进行AES加密）：```pythonfrom Crypto.Cipher import AESdef symmetric_encrypt(message, key):cipher = AES.new(key, AES.MODE_ECB)encrypted_message = cipher.encrypt(message)return encrypted_messagedef symmetric_decrypt(encrypted_message, key):cipher = AES.new(key, AES.MODE_ECB)decrypted_message = cipher.decrypt(encrypted_message)return decrypted_message```三、加密解密技巧和策略1.密钥管理：确保只有授权的用户才能获得密钥。
网络安全常见的四种加密解密算法
System.out.println("输入明文，要求用小写字母，不要打空格");
String s = input.nextLine();//输入明文，要求用小写字母，不要打空格
System.out.println("输入秘钥，要求用小写字母，不要打空格");
}
System.out.println("密文为："+MStr+"密匙为：" + k);
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
/**
*解密公式
*/
void D(int k) {
try {
char b[];
b = MStr.toString().toCharArray();
for (int i = 0; i < ch2.length; i++) {
in2[i] = ch2[i] - 97;//利用ascii变成0-25数字
}
int j = 0;
for (int i = 0; i < length; i++) {
if (j == length2)
j = 0;
in1[i] = (in1[i] + in2[j]) % 26;//加密算法，mod26
}
if(b[i] >= 'A' && b[i] <= 'Z'){
ch = (char) ((b[i] - 'A' + 26 - k) % 26 + 'A');
仿射密码的c代码
仿射密码的c代码仿射密码是一种古典密码学的加密方式，它将明文中的每一个字母通过一组线性变换转换为一个密文字母。
其加密公式为：C = (a * P + b) % 26，其中C为密文，P为明文，a和b为加密时选取的两个整数，%表示取模运算，26表示字母表中的字母个数。
下面是仿射密码的C代码实现：```c#include<stdio.h>#include<stdlib.h>#include<string.h>// 仿射密码加密函数void affineEncrypt(char* plainText, int a, int b) {int len = strlen(plainText);char cipherText[len+1];for(int i=0; i<len; i++) {char c = plainText[i];if(c >= 'a' && c <= 'z') {cipherText[i] = ((a * (c - 'a') + b) % 26) + 'a';} else if(c >= 'A' && c <= 'Z') {cipherText[i] = ((a * (c - 'A') + b) % 26) + 'A';} else {cipherText[i] = c;}}cipherText[len] = '0';printf('Cipher Text: %s', cipherText);}// 仿射密码解密函数void affineDecrypt(char* cipherText, int a, int b) { int len = strlen(cipherText);char plainText[len+1];int aInv = 0;for(int i=0; i<26; i++) {if((a*i)%26 == 1) {aInv = i;break;}}for(int i=0; i<len; i++) {char c = cipherText[i];if(c >= 'a' && c <= 'z') {plainText[i] = (aInv * (c - 'a' - b + 26)) % 26 + 'a'; } else if(c >= 'A' && c <= 'Z') {plainText[i] = (aInv * (c - 'A' - b + 26)) % 26 + 'A'; } else {plainText[i] = c;}}plainText[len] = '0';printf('Plain Text: %s', plainText);}int main() {char plainText[] = 'Hello World';int a = 5;int b = 8;printf('Plain Text: %s', plainText);affineEncrypt(plainText, a, b);affineDecrypt('Mjqqt Btwqi', a, b);return 0;}```在上面的代码中，我们定义了两个函数affineEncrypt和affineDecrypt分别用于加密和解密。
加密解密方式代码
加密解密⽅式代码public class EncodePassword {// (1)加密算法有：AES，DES，DESede(DES3)和RSA 四种// (2) 模式有CBC(有向量模式)和ECB(⽆向量模式)，向量模式可以简单理解为偏移量，使⽤CBC模式需要定义⼀个IvParameterSpec对象// (3) 填充模式:// * NoPadding: 加密内容不⾜8位⽤0补⾜8位, Cipher类不提供补位功能，// 需⾃⼰实现代码给加密内容添加0, 如{65,65,65,0,0,0,0,0}// * PKCS5Padding: 加密内容不⾜8位⽤余位数补⾜8位,// 如{65,65,65,5,5,5,5,5}或{97,97,97,97,97,97,2,2}; 刚好8位补8位8// private static final String ENCODE_TYPE = "AES/CBC/PKCS5Padding"; "算法/模式/填充模式"//指定算法private static final String ENCODE_TYPE = "AES";//salt 盐值，⽤于⽣成密钥private static final String publicKey = "s7WKkt@zqJO+wVdW";public static void main(String[] args) throws Exception {getSecretKey();System.out.println("============AES对称加密⽅式================");String aesEncode = testAESEncode("wo6ai8zhong6guo"); // 加密后的密码String aesDecode = testAESDecode(publicKey, aesEncode);System.out.println("解密后的密码："+aesDecode);// System.out.println("============Base64提供的加密⽅式（可逆）================");// testBase64Encode();// System.out.println("============spring-security-core提供的加密⽅式================");// testBCryptEncode();}// ⽣成密钥private static void getSecretKey() throws NoSuchAlgorithmException {// 通过 KeyGenerator创建秘密密匙 128、192和256位KeyGenerator keyGenerator = KeyGenerator.getInstance(ENCODE_TYPE);keyGenerator.init(128);SecretKey keySpec = keyGenerator.generateKey();byte[] encoded = keySpec.getEncoded(); //密钥String str = Base64.getEncoder().encodeToString(encoded);System.out.println("KeyGenerator："+str);SecretKey secretKey = new SecretKeySpec(publicKey.getBytes(), ENCODE_TYPE);byte[] encoded1 = secretKey.getEncoded();System.out.println(encoded1.toString());String str1 = Base64.getEncoder().encodeToString(encoded1);System.out.println("SecretKeySpec："+str1);}/* AES加密数据块和密钥长度可以是128⽐特、192⽐特、256⽐特中的任意⼀个。
密码学 移位密码、仿射密码
习题：设仿射加密函数为 c 9 p 2(mod 26).
对明文fine进行加密； 对密文EYYD进行解密。
例：设加密函数为 c 9 p 2(mod 26).
1）对明文fine进行加密； 2）对密文EYYD进行解密。
解：1）fine对应数字是5,8,13,4，代入加密函数得，
例1：利用P10的英文字母频率表破译 由仿射密码加密的文件名为affine.text的密文.
已知明文攻击
选择明文攻击 选择密文攻击
例2：P35上机练习ex3
End
例2：密文是用仿射密码加密的： edsgickxhuklzveqzvkxwkzukcvuh；
明文前两字母为if。对其解密。
解：设仿射加密函数为
numbers
CAP
例：设加密函数为 c 9p 2(mod26).
1）对明文fine进行加密； 2）对密文EYYD进行解密。
仿射密码的破译
问题：设仿射密码加密函数为 c p (mod 26).
该密码的密钥是什么？密钥空间有多大？
如何攻击该密码？
唯密文攻击
蛮力攻击法（密文长度约20个字母即可） 频率分析法（密码长度需要长些）
c p (mod 26).
由题意知，
4 8 3 5
(mod 26).
解得，
ห้องสมุดไป่ตู้9 10
(mod 26).
利用CAP，得明文为 If you can read this thank a teacher。 CAP
移位密码：设密钥为k，0≤ k≤25,加密函数
c p （k mod 26),
解密函数
经典密码学实验报告
一、实验目的1. 了解经典密码学的基本原理和算法；2. 掌握古典密码的加密和解密方法；3. 通过编程实现古典密码的加密和解密过程；4. 体验古典密码的破解过程，加深对密码学原理的理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发工具：PyCharm三、实验内容本次实验主要涉及以下几种古典密码：1. 仿射密码2. 单表代替密码3. 维吉尼亚密码4. 移位密码1. 仿射密码（1）原理简介：仿射密码是一种单字母替换密码，加密公式为：Ci = (a pi + b) mod 26，其中，Ci 为密文，pi 为明文，a 和 b 为密钥。
（2）加密和解密代码实现：```pythondef encrypt(plain_text, a, b):cipher_text = ''for char in plain_text:if char.isalpha():cipher_text += chr(((ord(char.upper()) - ord('A') + a b) % 26) + ord('A'))else:cipher_text += charreturn cipher_textdef decrypt(cipher_text, a, b):plain_text = ''for char in cipher_text:if char.isalpha():plain_text += chr(((ord(char.upper()) - ord('A') - a b) % 26) + ord('A'))else:plain_text += charreturn plain_text```2. 单表代替密码（1）原理简介：单表代替密码是一种将明文中的每个字符映射到密文的密码，加密和解密过程是相反的。
C语言密码学与加密算法
C语言密码学与加密算法密码学是研究加密和解密技术的学科，它在现代信息安全中扮演着非常重要的角色。
C语言作为一种高效且广泛应用的编程语言，可以用来实现各种密码学算法。
本文将介绍C语言中的一些常用密码学算法及其实现。
一、凯撒密码（Caesar Cipher）凯撒密码是一种简单的替换密码，它通过将字母按照固定的位移量进行替换来进行加密和解密操作。
C语言中可以使用字符数组和循环来实现凯撒密码的加密和解密功能。
以下是一个示例代码：```c#include <stdio.h>#define SHIFT 3void encrypt(char* message) {int i = 0;while (message[i] != '\0') {if (message[i] >= 'a' && message[i] <= 'z') {message[i] = (message[i] - 'a' + SHIFT) % 26 + 'a';}else if (message[i] >= 'A' && message[i] <= 'Z') {message[i] = (message[i] - 'A' + SHIFT) % 26 + 'A';}i++;}}void decrypt(char* message) {int i = 0;while (message[i] != '\0') {if (message[i] >= 'a' && message[i] <= 'z') {message[i] = (message[i] - 'a' - SHIFT + 26) % 26 + 'a'; }else if (message[i] >= 'A' && message[i] <= 'Z') {message[i] = (message[i] - 'A' - SHIFT + 26) % 26 + 'A'; }i++;}}int main() {char message[] = "Hello, World!";encrypt(message);printf("Encrypted message: %s\n", message);decrypt(message);printf("Decrypted message: %s\n", message);return 0;}```二、AES算法（Advanced Encryption Standard）AES算法是目前应用最广泛的对称加密算法之一。
摩斯密码类似的密码
摩斯密码类似的密码
与摩斯密码类似的密码有：四方密码、希尔密码、波雷费密码、仿射密码、三分密码、二分密码等。
1、四方密码：是一种对称式加密法，由法国人Felix Delastelle 发明。
这种方法将字母两个一组，然后采用多字母替换密码。
四方密码用4个5×5的矩阵来加密。
每个矩阵都有25个字母（通常会取消Q或将I,J视作同一样，或改进为6×6的矩阵，加入10个数字）。
首先选择两个英文字作密匙，例如example和keyword。
对于每一个密匙，将重复出现的字母去除，即example要转成exampl，然后将每个字母顺序放入矩阵，再将余下的字母顺序放入矩阵，便得出加密矩阵。
2、希尔密码：是运用基本矩阵论原理的替换密码，由希尔在1929年发明。
每个字母当作26进制数字：A=0, B=1, C=2，一串字母当成n维向量，跟一个n×n的矩阵相乘，再将得出的结果模26。
3、波雷费密码是一种对称式密码，是首种双字母取代的加密法。
4、仿射密码是一种替换密码。
它是一个字母对一个字母的。
5、三分密码由Felix Delastelle发明（他也发明了四方密码和二分密码）。
6、二分密码是二维的，用5×5（或6×6）的矩阵加密，但三分密码则用3×3×3的。
它是第一个应用的三字母替换密码。
仿射密码
仿射密码o 加法密码和乘法密码结合就构成仿射密码，仿射密码的加密和解密算法是：C= Ek(m)=(k1m+k2) mod n M= Dk(c)=k1(c- k2) mod n o 仿射密码具有可逆性的条件是gcd(k, n)=1。
当k1=0时，仿射密码变为加法密码，当k2=0时，仿射密码变为乘法密码。
o 仿射密码中的密钥空间的大小为nφ(n)，当n为26字母，φ(n)=12，因此仿射密码的密钥空间为12×26 = 312。
仿射密码举例o 设密钥K= (7, 3), 用仿射密码加密明文hot。
o 三个字母对应的数值是7、14和19。
分别加密如下：(7×7 + 3) mod 26 = 52 mod 26 =0 (7×14 + 3) mod 26 = 101 mod 26 =23 (7×19 + 3) mod 26 =136 mod 26 =6 o 三个密文数值为0、23和6，对应的密文是AXG。
移位密码、仿射密码、维吉尼亚密码以及置换密码的源代码：VC6.0调试通过#include <stdio.h>#include <conio.h>#include <string.h>#include <cctype>#include <malloc.h>#include <iostream>using namespace std;void Shift() /*移位密码*/{char c[100];int length, i=0, key=0;system("cls");printf("********Shift Cipher(移位密码)********\nPlease input primal sentence(请输入最初的明文--一组英文字母): ");gets(c);length=strlen(c);printf("Input the key(0~26): ");scanf("%d", &key);getchar();if(key<0){printf("The value of key is error!\nPress any key to return...");getch();return;}for(i=0; i<length; i++){if(c[i]>96&&c[i]<123)c[i] = (c[i]+key-97)%26+65;else if(c[i]>64&&c[i]<91)c[i] = (c[i]+key-65)%26+65;}printf("Result is: %s\n", c);for(i=0; i<length; i++){if(c[i]>64&&c[i]<91)c[i] = (c[i]-key-65+26)%26+97;}printf("\nAfter translated the sentence,we can see the primal sentence as follow:\n%s\n", c);printf("Press any key to return(按任何键返回)...");getch();}int gcd(int a, int b) /*辗转相除法求a,b的最大公因数*/ {int k = 0;do{k = a%b;a = b;b = k;}while(k!=0);return a;}int Ni(int a, int b) /*求a相对于b的逆*/{int i = 0;while(a*(++i)%b!=1);return i;}void Affine() /*仿射密码*/{char c[100];int length, i=0, ka=0, kb=0, tmp;system("cls");printf("********Affine Cipher(仿射密码)********\nPlease input primal sentence(请输入最初的明文): ");gets(c);length = strlen(c);printf("Input the key(2 numbers): ");scanf("%d%d", &ka, &kb);getchar();if(gcd(ka,26)!=1){printf("The value of the key is error!\nPress any key to return...");return;}for(i=0; i<length; i++){if(c[i]>96&&c[i]<123)c[i] = (ka*(c[i]-97)+kb)%26+65;else if(c[i]>64&&c[i]<91)c[i] = (ka*(c[i]-65)+kb)%26+65;}printf("Result is: %s\n", c);for(i=0; i<length; i++){if(c[i]>64&&c[i]<91){tmp = Ni(ka,26)*((c[i]-65)-kb);if(tmp<0)c[i] = tmp%26+26+97;elsec[i] = tmp%26+97;}}printf("\nAfter translated the sentence,we can see the primal sentence as follow:\n%s\n", c);printf("Press any key to return(按任何键返回)...");getch();}void Vigenere() /*维吉利亚密码*/{char c[100], key[100];int lenc, lenk, i=0, j=0, tmp;system("cls");printf("********Vigenere Cipher(维吉利亚密码)********\nPlease input primal sentence(请输入最初的明文): ");gets(c);lenc = strlen(c);strcpy(c, strupr(c));printf("Input the key: ");gets(key);lenk = strlen(key);strcpy(key, strupr(key));for(; i<lenc; i++){j = j%lenk;if(c[i]>64&&c[i]<91){c[i] = (c[i]-65+key[j]-65)%26+65;j++;}}printf("Result is: %s\n", c);for(i=0, j=0; i<lenc; i++){j = j%lenk;if(c[i]>64&&c[i]<91){tmp = c[i]-65-(key[j]-65);if(tmp>=0)c[i] = tmp%26+97;elsec[i] = (tmp+26)%26+97;j++;}}printf("\nAfter translated the sentence,we can see the primal sentence as follow:\n%s\n", c);printf("Press any key to return(按任何键返回)...");getch();}void Permutation() /*置换密码*/{char c[100], *q;int *key, len, m, i, j=0;system("cls");printf("********Permutation Cipher(置换密码)********\nPlease input primal sentence(请输入最初的明文): ");gets(c);strcpy(c, strupr(c));len = strlen(c);for(i=0; i<len; i++){if(c[i]<65||c[i]>90){for(j=i; j<len-1; j++)c[j] = c[j+1];len--;}}c[len] = '\0';printf("Input the length of the key: ");scanf("%d", &m);key = (int*)malloc(m*sizeof(int));q = (char *)malloc(len*sizeof(int));printf("Input the key: ");for(i=0; i<m; i++){scanf("%d", key+i);key[i]--;}getchar();for(i=0; i<len; i++){j = (i/m)*m;q[i] = c[*(key+i%m)+j];}q[i] = '\0';printf("Result is: %s\n", q);for(i=0, j=0; i<len; i++){j = (i/m)*m;c[*(key+i%m)+j] = q[i]+32;}c[len] = '\0';printf("After translated the sentence,we can see the primal sentence as follow:\n%s\n", c);printf("Press any key to return(按任何键返回)...");free(key);free(q);getch();}int main(){char i = '0';system("cls");while(i!='5'){system("cls");printf("********Press 1~5 to choose(请按1～5选择):********\n");printf("1. Shift Cipher(移位密码)\n2. Affine Cipher(仿射密码)\n3. Vigenere Cipher(维吉利亚密码)\n4. Permutation Cipher(置换密码)\n5. Exit(退出)\n");i = getch();if(i=='1')Shift();else if(i=='2')Affine();else if(i=='3')Vigenere();else if(i=='4')Permutation();else if(i=='5')break;}system("pause");return 0;}。
古典密码算法
古典密码算法古典密码算法是指在计算机加密领域之前使用的一些传统密码算法，它们通常基于简单的数学原理和替换规则。
以下是几种常见的古典密码算法：凯撒密码（Caesar Cipher）：凯撒密码是一种替换密码，通过将字母按照一个固定的偏移量进行替换来加密消息。
例如，偏移量为3时，字母A被替换为D，字母B被替换为E，以此类推。
解密过程则是将替换后的字母反向偏移。
凯撒密码很容易破解，因为只有26种可能的偏移量。
维吉尼亚密码（Vigenère Cipher）：维吉尼亚密码是一种多表密码，它使用一个关键字来决定每个字母的偏移量。
关键字被重复使用，逐个与明文中的字母对应，生成密文。
解密过程则是通过将密文与关键字对应的字母相减得到明文。
维吉尼亚密码比凯撒密码更复杂，但仍然容易受到频率分析等攻击。
替代密码（Substitution Cipher）：替代密码使用替换规则来加密和解密消息。
最简单的替代密码是单字母替换，即将明文中的每个字母替换为一个固定的密文字母。
这种方法容易受到频率分析攻击。
更复杂的替代密码如多表密码和多字母替换密码引入了更复杂的替换规则，增加了密码破解的难度。
仿射密码（Affine Cipher）：仿射密码是一种线性替换密码，它使用一个加密函数将明文字母映射到密文字母。
加密函数是一个仿射变换，包括一个乘法和一个加法操作。
解密过程则是应用逆仿射变换。
仿射密码比凯撒密码和替代密码更难破解，但对于较大的密钥空间来说仍然存在弱点。
这些古典密码算法在现代密码学中已经被更安全和复杂的算法所取代，因为它们容易受到密码分析的攻击。
现代密码算法，如对称加密算法（如AES）和公钥加密算法（如RSA），提供了更高的安全性和复杂性，以抵御现代密码破解技术的威胁。
C语言中的加密与解密算法
C语言中的加密与解密算法在计算机科学和信息安全领域，加密和解密算法起着至关重要的作用。
加密是将原始数据转化为不可读的形式，以保护其机密性和安全性。
而解密则是将加密后的数据恢复为原始数据的过程。
在C语言中，我们可以使用不同的加密和解密算法来保护数据的安全。
本文将介绍几种常见的C语言中的加密与解密算法。
一、凯撒密码（Caesar Cipher）凯撒密码是一种最古老且最简单的加密算法之一。
它通过将每个字符按照固定的偏移量向右或向左进行替换来实现加密和解密过程。
例如，偏移量为3的凯撒密码将'A'替换为'D'，'B'替换为'E'，以此类推。
以下是一个示例的C语言代码，实现了凯撒密码的加密和解密：```c#include <stdio.h>void caesar_encrypt(char* message, int shift) {int i = 0;while(message[i] != '\0') {if (message[i] >= 'A' && message[i] <= 'Z') {message[i] = (message[i] - 'A' + shift) % 26 + 'A';}if (message[i] >= 'a' && message[i] <= 'z') {message[i] = (message[i] - 'a' + shift) % 26 + 'a';}i++;}}void caesar_decrypt(char* message, int shift) {int i = 0;while(message[i] != '\0') {if (message[i] >= 'A' && message[i] <= 'Z') {message[i] = (message[i] - 'A' - shift + 26) % 26 + 'A'; }if (message[i] >= 'a' && message[i] <= 'z') {message[i] = (message[i] - 'a' - shift + 26) % 26 + 'a'; }i++;}}int main() {char message[] = "Hello, World!";int shift = 3;caesar_encrypt(message, shift);printf("加密后的消息：%s\n", message);caesar_decrypt(message, shift);printf("解密后的消息：%s\n", message);return 0;}```该示例代码演示了如何使用凯撒密码对消息进行加密和解密。
移位密码的加解密方法
移位密码的加解密方法移位密码是一种简单的密码算法，通过将字母按照一定的规则进行移位来达到加密和解密的目的。
在移位密码中，字母按照字母表的顺序进行移动，并且移动的位数可以是固定的，也可以是变化的。
本文将介绍几种常见的移位密码加解密方法。
一、凯撒密码凯撒密码是最基本的移位密码之一，又称为字母表移位密码。
它的加密规则是将明文中的字母按照字母表的顺序向后移动固定的位数。
例如，将每个字母向后移动三位，A变为D，B变为E，以此类推。
解密时将密文中的字母按照相同的规则向前移动即可还原为明文。
例如，将明文“HELLO”使用凯撒密码加密，移动位数为3，得到密文“KHOOR”。
解密时将密文“KHOOR”向前移动3位，得到明文“HELLO”。
二、栅栏密码栅栏密码是一种通过对明文中的字母进行分组再重新排列来达到加密的目的的移位密码。
首先，将明文按照一定数量的列进行排列，然后将每一列的字母连接起来，形成密文。
解密时按照相同的数量的列重新排列密文，然后将各列的字母顺序连接起来，即可还原为明文。
例如，将明文“HELLO WORLD”使用栅栏密码加密，分为3列，排列如下：H O L O LE L W RL D连接各列的字母得到密文“HOLELWRLLDO”。
解密时重新排列密文的列数为3，然后按照各列的顺序连接字母，得到明文“HELLO WORLD”。
三、仿射密码仿射密码是一种结合了凯撒密码和线性变换的移位密码。
它的加密规则是将明文中的字母进行线性变换后再进行移位。
线性变换是通过字母与一个数的乘法和加法来实现的。
解密时需要进行逆向的线性变换和移位操作。
例如，将明文“HELLO”使用仿射密码加密，选择乘法的数为5，加法的数为8，得到密文“ZMBBT”。
解密时，使用乘法的逆元数2和加法的逆元数18，对密文进行逆向的线性变换和移位操作，即可还原为明文“HELLO”。
四、维吉尼亚密码维吉尼亚密码是一种基于多个字母表的移位密码。
它的加密规则是将明文中的字母按照一组不同的移位规则进行加密。
密码学基础
密码学常识目录密码常识字母表顺序-数字进制转换密码Mod算法倒序间隔字母频率凯撒密码(Caesar Shifts, Simple Shift)凯撒移位(中文版)栅栏密码(The Rail-Fence Cipher)维吉尼亚密码(Vigenère Cipher)Polybius密码(Polybius Cipher)ADFGX/ADFGVX密码(ADFGX/ADFGVX Cipher) ADFGXADFGVX乘法密码(Multiplication Cipher)仿射密码(Affine Shift)希尔密码(Hill Cipher)加密解密Playfair密码(Playfair Cipher)莫尔斯电码置换密码(Transposition Cipher)替代密码(Monoalphabetic Substitution)字母表数字字母表代码反字母表随机乱序字母棋盘密码键盘密码键盘移位软键盘密码数字小键盘密码手机键盘密码数字记忆编码百度/Google/网页字符百度字符(GB2312)Google字符(URI)网页编码(Unicode)Alt+数字小键盘MD5【密码常识】字母表顺序-数字加密的时候，经常要把A至Z这26个字母转换成数字，最常见的一种方法就是取字母表中的数字序号。
A代表1，B代表2，C代表3……字母：A B C D E F G H I J K L M N O P Q R ST U V W X Y Z数字：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26进制转换密码例如二进制：1110 10101 1101 10 101 10010 1111 1110 101转为十进制：14 21 13 2 5 18 15 14 5对应字母表：numberMod算法我们可以对字母序号进行数学运算，然后把所得的结果作为密文。
西方古典密码方式
西方古典密码方式是一种古老的加密技术，起源于古希腊和罗马时期。
这种密码方式主要通过替换、移位和排列等方法对原始信息进行变换，以达到保密的目的。
以下是一些常见的西方古典密码方式：1.凯撒密码（Caesar Cipher）：这是最早的一种古典密码方式，由古罗马将领凯撒发明。
凯撒密码的原理是将明文中的每个字母按照一个固定的偏移量进行移位。
例如，如果偏移量为3，那么字母A将被替换为D，B将被替换为E，以此类推。
凯撒密码的优点是实现简单，但缺点是容易被破解，因为偏移量通常是26的倍数。
2.维吉尼亚密码（Vigenere Cipher）：这是一种基于凯撒密码的变种，由法国密码学家布莱斯·德·维吉尼亚发明。
维吉尼亚密码的原理是将明文和密钥都分成一系列字母，然后按照密钥字母的顺序将明文字母进行替换。
维吉尼亚密码的优点是安全性较高，但缺点是需要密钥长度与明文长度相同。
3.栅栏密码（Rail Fence Cipher）：这是一种通过置换和重组的方法对明文进行加密的古典密码方式。
栅栏密码的原理是将明文按照一定的宽度分为若干行，然后将这些行按照特定的顺序进行排列，最后将排列后的字符连接起来形成密文。
栅栏密码的优点是实现简单，但缺点是解密过程较为复杂。
4.希尔密码（Hill Cipher）：这是一种基于线性代数的古典密码方式，由美国数学家Lester S. Hill发明。
希尔密码的原理是将明文和密钥都表示为矩阵，然后通过矩阵乘法对明文进行加密。
希尔密码的优点是安全性较高，但缺点是计算复杂度较高。
5.仿射密码（Affine Cipher）：这是一种基于线性代数的古典密码方式，由法国密码学家阿德里安·卡西斯基发明。
仿射密码的原理是将明文和密钥都表示为向量，然后通过向量加法和标量乘法对明文进行加密。
仿射密码的优点是安全性较高，但缺点是密钥空间较小。
总之，西方古典密码方式在古代起到了重要的保密作用，为后世的密码学发展奠定了基础。
仿射密码加解密python代码
仿射密码加解密python代码仿射密码是一种古老而经典的加密算法，它通过对明文中的每个字符进行线性变换来实现加密和解密。
在这篇文章中，我将介绍如何使用Python编写仿射密码的加密和解密代码。
首先，我们需要了解仿射密码的原理。
仿射密码的加密公式为：C = (a * P + b) % 26，其中C是密文，P是明文，a和b是密钥。
在这个公式中，a是一个与26互质的整数，b是一个介于0和25之间的整数。
接下来，我们可以开始编写加密函数。
首先，我们需要定义一个函数，该函数将接受明文和密钥作为参数，并返回加密后的密文。
代码如下：```pythondef encrypt(plain_text, key):encrypted_text = ""a, b = keyfor char in plain_text:if char.isalpha():if char.isupper():encrypted_char = chr((a * (ord(char) - ord('A')) + b) % 26 + ord('A'))else:encrypted_char = chr((a * (ord(char) - ord('a')) + b) % 26 +ord('a'))else:encrypted_char = charencrypted_text += encrypted_charreturn encrypted_text```在这个函数中，我们首先将密钥拆分为a和b。
然后，我们遍历明文中的每个字符。
如果字符是字母，则根据其大小写进行不同的处理。
对于大写字母，我们将其转换为0到25之间的数字，然后应用仿射密码的加密公式。
最后，我们将加密后的字符添加到加密文本中。
接下来，我们可以编写解密函数。
解密函数与加密函数的逻辑类似，只是我们需要使用仿射密码的解密公式：P = (a_inv * (C - b)) % 26，其中P是明文，C是密文，a_inv是a的逆元。
Python加密与解密算法
Python加密与解密算法Python是一种高级编程语言，拥有广泛的应用领域，包括数据分析、Web开发和网络安全等。
在网络安全领域中，加密与解密算法起到至关重要的作用。
本文将介绍Python中常用的加密与解密算法以及它们的应用。
一、对称加密算法对称加密算法使用相同的密钥来进行加密与解密操作，常见的对称加密算法有DES、3DES（Triple DES）、AES等。
在Python中，可以使用cryptography库来实现对称加密算法。
1. DES算法DES（Data Encryption Standard）是一种对称加密算法，它使用56位的密钥对数据进行加密和解密。
Python的cryptography库提供了DES算法的实现方法。
```pythonfrom cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modesfrom cryptography.hazmat.backends import default_backendfrom cryptography.hazmat.primitives import paddingdef des_encrypt(key, data):backend = default_backend()cipher = Cipher(algorithms.TripleDES(key), modes.ECB(), backend=backend)encryptor = cipher.encryptor()padder = padding.PKCS7(64).padder()padded_data = padder.update(data) + padder.finalize()ciphertext = encryptor.update(padded_data) + encryptor.finalize()return ciphertextdef des_decrypt(key, ciphertext):backend = default_backend()cipher = Cipher(algorithms.TripleDES(key), modes.ECB(), backend=backend)decryptor = cipher.decryptor()plaintext_padded = decryptor.update(ciphertext) + decryptor.finalize()unpadder = padding.PKCS7(64).unpadder()plaintext = unpadder.update(plaintext_padded) + unpadder.finalize()return plaintextkey = b'0123456789abcdef'data = b'Hello, World!'ciphertext = des_encrypt(key, data)plaintext = des_decrypt(key, ciphertext)print("Cipher text: ", ciphertext)print("Plain text: ", plaintext)```2. AES算法AES（Advanced Encryption Standard）是一种对称加密算法，它使用128、192或256位的密钥对数据进行加密和解密。
Python移位密码、仿射变换解密实例代码
Python移位密码、仿射变换解密实例代码⽬录前⾔⼀、移位密码⼆、仿射变换三、全部代码总结前⾔这个代码是很久之前的，已经忘记具体的思路了，你可以结合此⽂章来了解两个加密⽅式的内容。
前两个步骤是对应加密⽅式的函数，第三个步骤是整合。
⼀、移位密码def yiwei(string,number):'''将字符串的每个字母，向右移动指定的位数，并返回移动后的字符串如：A 向右移动3位，返回值为Dstring为字符串，number为整型A的ASCII码为65'''new_string = ""string = string.upper() #转换为⼤写for i in string: #移位操作#转换为ascii码后，经过移位变为新的ascii，再转换回字母new_string += chr((ord(i)-65+number)%26+65)return new_string##print(yiwei('AAA',3)) #测试函数正确性def yiwei_decode(c):'''移位密码解密，并打印解密的结果'''for i in range(1,27): #穷尽密钥搜索，遍历范围[1,26]print(yiwei(c,i))print("解密结束")##yiwei_decode("A") #测试函数正确性⼆、仿射变换def fangshe_key(m,c):'''通过已知的两对明⽂密⽂，求解得到两个密钥m为明⽂,c为密⽂[A-Z]转换为数字为[0-25]'''#⼤写m = m.upper()c = c.upper()#切⽚m1 = m[:1:] #明⽂的第⼀个字母m2 = m[-1::] #明⽂的最后⼀个字母c1 = c[:1:] #密⽂的第⼀个字母c2 = c[-1::] #密⽂的最后⼀个字母## print(m1,m2)## print(c1,c2)#转换为整数m1 = ord(m1)-65m2 = ord(m2)-65c1 = ord(c1)-65c2 = ord(c2)-65## print(m1,m2)## print(c1,c2)#穷举法for i in range(0,26):for j in range(0,26):if (m1*i+j)%26==c1 and (m2*i+j)%26==c2: #同时满⾜加密算法时return i,jreturn False##print(fangshe_key("IF","ED")) #测试函数正确性def fangshe_reverse(x,y):'''计算乘法逆元,求解x^-1(%y)的乘法逆元,并返回对应值'''i = 0while True:if x*i%26==1: #符合乘法逆元条件时return ii += 1##print(fangshe_reverse(9,26)) #测试函数正确性def fangshe_decode(c,a,b):'''仿射变换解密，并打印解密的结果c为密⽂，a和b为密钥0<=a,b<=25，且满⾜gcd(a,26)=1，a^-1表⽰a的逆元加密公式：c = a*m + b%26解密公式：m = (a^-1)*(c-b)%26'''new_string = ''c = c.upper() #⼤写转换for i in c: #逐个字母解密new_i = ord(i)-65 #转换成数字new_i = (fangshe_reverse(a,26)*(new_i - b))%26 #解密 new_string += chr(new_i + 65) #转换回⼤写字母print(new_string)print("解密结束")##fangshe_decode("ED",9,10) #测试函数正确性三、全部代码移位密码仿射变换# coding=utf-8# 作者：⼩狐狸FM# 题⽬：古典密码def menu():'''菜单界⾯'''print("-----------------------")print("| 0. 退出 |")print("| 1. 移位密码解密 |")print("| 2. 仿射变换解密 |")print("-----------------------")##menu() #测试函数def yiwei(string,number):'''将字符串的每个字母，向右移动指定的位数，并返回移动后的字符串如：A 向右移动3位，返回值为Dstring为字符串，number为整型A的ASCII码为65'''new_string = ""string = string.upper() #转换为⼤写for i in string: #移位操作#转换为ascii码后，经过移位变为新的ascii，再转换回字母new_string += chr((ord(i)-65+number)%26+65)return new_string##print(yiwei('AAA',3)) #测试函数正确性def yiwei_decode(c):'''移位密码解密，并打印解密的结果'''for i in range(1,27): #穷尽密钥搜索，遍历范围[1,26]print(yiwei(c,i))print("解密结束")##yiwei_decode("A") #测试函数正确性def fangshe_key(m,c):'''通过已知的两对明⽂密⽂，求解得到两个密钥m为明⽂,c为密⽂[A-Z]转换为数字为[0-25]'''#⼤写m = m.upper()c = c.upper()#切⽚m1 = m[:1:] #明⽂的第⼀个字母m2 = m[-1::] #明⽂的最后⼀个字母c1 = c[:1:] #密⽂的第⼀个字母c2 = c[-1::] #密⽂的最后⼀个字母## print(m1,m2)## print(c1,c2)#转换为整数m1 = ord(m1)-65m2 = ord(m2)-65c1 = ord(c1)-65c2 = ord(c2)-65## print(m1,m2)## print(c1,c2)#穷举法for i in range(0,26):for j in range(0,26):if (m1*i+j)%26==c1 and (m2*i+j)%26==c2: #同时满⾜加密算法时return i,jreturn False##print(fangshe_key("IF","ED")) #测试函数正确性def fangshe_reverse(x,y):'''计算乘法逆元,求解x^-1(%y)的乘法逆元,并返回对应值'''i = 0while True:if x*i%26==1: #符合乘法逆元条件时return ii += 1##print(fangshe_reverse(9,26)) #测试函数正确性def fangshe_decode(c,a,b):'''仿射变换解密，并打印解密的结果c为密⽂，a和b为密钥0<=a,b<=25，且满⾜gcd(a,26)=1，a^-1表⽰a的逆元加密公式：c = a*m + b%26解密公式：m = (a^-1)*(c-b)%26'''new_string = ''c = c.upper() #⼤写转换for i in c: #逐个字母解密new_i = ord(i)-65 #转换成数字new_i = (fangshe_reverse(a,26)*(new_i - b))%26 #解密new_string += chr(new_i + 65) #转换回⼤写字母print(new_string)print("解密结束")##fangshe_decode("ED",9,10) #测试函数正确性if __name__=='__main__':while True:menu()choose = int(input("请选择: "))if choose==1:string = input("请输⼊密⽂: ")yiwei_decode(string)elif choose==2:string = input("请输⼊密⽂: ")m = input("已知明⽂：")c = input("对应密⽂:")a,b = fangshe_key(m,c)fangshe_decode(string,a,b)else:break总结到此这篇关于Python移位密码、仿射变换解密的⽂章就介绍到这了,更多相关Python移位密码仿射变换内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。
四种加密解密算法的源代码：移位密码、仿射密码
四种加密解密算法的源代码：移位密码、仿射密码、维吉尼亚密码以及置换密码#include <stdio.h>#include <conio.h>#include <string.h>#include <malloc.h>void Shift() /*移位密码*/{char c[100];int length, i=0, key=0;clrscr();printf("********Shift Cipher********\nPlease input primal sentence: ");gets(c);length = strlen(c);printf("Input the key(0~26): ");scanf("%d", &key);getchar();if(key<0){printf("The value of key is error!\nPress any key to return...");getch();return;}for(i=0; i<length; i++){if(c[i]>96&&c[i]<123)c[i] = (c[i]+key-97)%26+65;else if(c[i]>64&&c[i]<91)c[i] = (c[i]+key-65)%26+65;}printf("Result is: %s\n", c);for(i=0; i<length; i++){if(c[i]>64&&c[i]<91)c[i] = (c[i]-key-65+26)%26+97;}printf("\nAfter translated the sentence,we can see the primal sentence as follow:\n%s\n", c);printf("Press any key to return...");getch();}int gcd(int a, int b) /*辗转相除法求a,b的最大公因数*/{int k = 0;do{k = a%b;a = b;b = k;}while(k!=0);return a;}int Ni(int a, int b) /*求a相对于b的逆*/{int i = 0;while(a*(++i)%b!=1);return i;}void Affine() /*仿射密码*/{char c[100];int length, i=0, ka=0, kb=0, tmp;clrscr();printf("********Affine Cipher********\nPlease input primal sentence: "); gets(c);length = strlen(c);printf("Input the key(2 numbers): ");scanf("%d%d", &ka, &kb);getchar();if(gcd(ka,26)!=1){printf("The value of the key is error!\nPress any key to return..."); return;}for(i=0; i<length; i++){if(c[i]>96&&c[i]<123)c[i] = (ka*(c[i]-97)+kb)%26+65;else if(c[i]>64&&c[i]<91)c[i] = (ka*(c[i]-65)+kb)%26+65;printf("Result is: %s\n", c);for(i=0; i<length; i++){if(c[i]>64&&c[i]<91){tmp = Ni(ka,26)*((c[i]-65)-kb);if(tmp<0)c[i] = tmp%26+26+97;elsec[i] = tmp%26+97;}}printf("\nAfter translated the sentence,we can see the primal sentence as follow:\n%s\n", c);printf("Press any key to return...");getch();}void Vigenere() /*维吉利亚密码*/{char c[100], key[100];int lenc, lenk, i=0, j=0, tmp;clrscr();printf("********Vigenere Cipher********\nPlease input primal sentence: "); gets(c);lenc = strlen(c);strcpy(c, strupr(c));printf("Input the key: ");gets(key);lenk = strlen(key);strcpy(key, strupr(key));for(; i<lenc; i++){j = j%lenk;if(c[i]>64&&c[i]<91){c[i] = (c[i]-65+key[j]-65)%26+65;j++;}}printf("Result is: %s\n", c);for(i=0, j=0; i<lenc; i++)j = j%lenk;if(c[i]>64&&c[i]<91){tmp = c[i]-65-(key[j]-65);if(tmp>=0)c[i] = tmp%26+97;elsec[i] = (tmp+26)%26+97;j++;}}printf("\nAfter translated the sentence,we can see the primal sentence as follow:\n%s\n", c);printf("Press any key to return...");getch();}void Permutation() /*置换密码*/{char c[100], *q;int *key, len, m, i, j=0;clrscr();printf("********Permutation Cipher********\nPlease input primal sentence: "); gets(c);strcpy(c, strupr(c));len = strlen(c);for(i=0; i<len; i++){if(c[i]<65||c[i]>90){for(j=i; j<len-1; j++)c[j] = c[j+1];len--;}}c[len] = '\0';printf("Input the length of the key: ");scanf("%d", &m);key = (int)malloc(m*sizeof(int));q = (int)malloc(len*sizeof(int));printf("Input the key: ");for(i=0; i<m; i++)scanf("%d", key+i);key[i]--;}getchar();for(i=0; i<len; i++){j = (i/m)*m;q[i] = c[*(key+i%m)+j];}q[i] = '\0';printf("Result is: %s\n", q);for(i=0, j=0; i<len; i++){j = (i/m)*m;c[*(key+i%m)+j] = q[i]+32;}c[len] = '\0';printf("After translated the sentence,we can see the primal sentence as follow:\n%s\n", c);printf("Press any key to return...");free(key);free(q);getch();}void main(){char i = '0';clrscr();while(i!='5'){clrscr();printf("********Press 1~5 to choose:********\n");printf("1. Shift Cipher\n2. Affine Cipher\n3. Vigenere Cipher\n4. Permutation Cipher\n5. Exit\n");i = getch();if(i=='1')Shift();else if(i=='2') Affine();else if(i=='3') Vigenere(); else if(i=='4') Permutation(); else if(i=='5') break;}}。
仿射密码加解密算法
仿射密码加解密算法
仿射密码是一种简单的替代加密算法，它对每个字符进行线性变换，通常采用如下的加密和解密公式：
1. 加密公式： ()()mod E x ax b m =+
2. 解密公式：1()()mod D y a y b m −=−
其中：
• E(x) 是明文字符 x 的加密结果，
• D(y) 是密文字符 y 的解密结果，
• a 和 b 是加密的密钥，通常要求 a 与 m 互质（即最大公约数为1），
• m 是字符集的大小。
具体步骤如下：
加密算法步骤：
1. 选择密钥 a 和 b ： 选择两个整数，通常要求 a 与字符集大小 m 互质。
2. 转换字符： 对明文中的每个字符 x ，使用加密公式()()mod E x ax b m =+进行加密。
解密算法步骤：
1. 计算逆元1a −： 计算 a 在模 m 意义下的逆元，即1a −满足11mod a a m −⋅=。
2. 转换字符： 对密文中的每个字符 y ，使用解密公式1()()mod D y a y b m −=−进行解密。
请注意，由于仿射密码是一种基于线性代数的替代密码，对于较大的字符集和密钥空间，它相对较强。
然而，对于大规模的计算机安全来说，通常建议使用更为复杂的加密算法，如对称密钥算法或公钥密码学。
仿射密码频率对照
1 / 2仿射密码频率对照仿射密码（Affine Cipher ）是一种替换密码，其中每个字母在加密时被映射为其在字母表中的另一个位置。
仿射密码由两个密钥参数组成：乘法密钥（a ）和加法密钥（b ）。
加密和解密的公式分别为：加密：E(x)=(ax+b)modm解密：1()()mod D x a x b m −=−其中：x 是明文中的字母位置（0 到 m-1其中 m 是字母表的大小）。
a 是乘法密钥，必须与字母表大小互质。
b 是加法密钥，是任意整数。
1a −是a 的模逆元素，满足 11mod aa m −=以下是英文字母表的仿射密码频率对照表，其中字母表大小 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+| 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 |+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26|+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ 在仿射密码中，加法密钥 b 可以取任意整数值，而乘法密钥 a 必须选择与字母表大小互质的值。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
四种加密解密算法的源代码：移位密码、仿射密码、维吉尼亚密码以及置换密码#include <stdio.h>#include <conio.h>#include <string.h>#include <malloc.h>void Shift() /*移位密码*/{char c[100];int length, i=0, key=0;clrscr();printf("********Shift Cipher********\nPlease input primal sentence: ");gets(c);length = strlen(c);printf("Input the key(0~26): ");scanf("%d", &key);getchar();if(key<0){printf("The value of key is error!\nPress any key to return...");getch();return;}for(i=0; i<length; i++){if(c[i]>96&&c[i]<123)c[i] = (c[i]+key-97)%26+65;else if(c[i]>64&&c[i]<91)c[i] = (c[i]+key-65)%26+65;}printf("Result is: %s\n", c);for(i=0; i<length; i++){if(c[i]>64&&c[i]<91)c[i] = (c[i]-key-65+26)%26+97;}printf("\nAfter translated the sentence,we can see the primal sentence as follow:\n%s\n", c);printf("Press any key to return...");getch();}int gcd(int a, int b) /*辗转相除法求a,b的最大公因数*/{int k = 0;do{k = a%b;a = b;b = k;}while(k!=0);return a;}int Ni(int a, int b) /*求a相对于b的逆*/{int i = 0;while(a*(++i)%b!=1);return i;}void Affine() /*仿射密码*/{char c[100];int length, i=0, ka=0, kb=0, tmp;clrscr();printf("********Affine Cipher********\nPlease input primal sentence: "); gets(c);length = strlen(c);printf("Input the key(2 numbers): ");scanf("%d%d", &ka, &kb);getchar();if(gcd(ka,26)!=1){printf("The value of the key is error!\nPress any key to return..."); return;}for(i=0; i<length; i++){if(c[i]>96&&c[i]<123)c[i] = (ka*(c[i]-97)+kb)%26+65;else if(c[i]>64&&c[i]<91)c[i] = (ka*(c[i]-65)+kb)%26+65;printf("Result is: %s\n", c);for(i=0; i<length; i++){if(c[i]>64&&c[i]<91){tmp = Ni(ka,26)*((c[i]-65)-kb);if(tmp<0)c[i] = tmp%26+26+97;elsec[i] = tmp%26+97;}}printf("\nAfter translated the sentence,we can see the primal sentence as follow:\n%s\n", c);printf("Press any key to return...");getch();}void Vigenere() /*维吉利亚密码*/{char c[100], key[100];int lenc, lenk, i=0, j=0, tmp;clrscr();printf("********Vigenere Cipher********\nPlease input primal sentence: "); gets(c);lenc = strlen(c);strcpy(c, strupr(c));printf("Input the key: ");gets(key);lenk = strlen(key);strcpy(key, strupr(key));for(; i<lenc; i++){j = j%lenk;if(c[i]>64&&c[i]<91){c[i] = (c[i]-65+key[j]-65)%26+65;j++;}}printf("Result is: %s\n", c);for(i=0, j=0; i<lenc; i++)j = j%lenk;if(c[i]>64&&c[i]<91){tmp = c[i]-65-(key[j]-65);if(tmp>=0)c[i] = tmp%26+97;elsec[i] = (tmp+26)%26+97;j++;}}printf("\nAfter translated the sentence,we can see the primal sentence as follow:\n%s\n", c);printf("Press any key to return...");getch();}void Permutation() /*置换密码*/{char c[100], *q;int *key, len, m, i, j=0;clrscr();printf("********Permutation Cipher********\nPlease input primal sentence: "); gets(c);strcpy(c, strupr(c));len = strlen(c);for(i=0; i<len; i++){if(c[i]<65||c[i]>90){for(j=i; j<len-1; j++)c[j] = c[j+1];len--;}}c[len] = '\0';printf("Input the length of the key: ");scanf("%d", &m);key = (int)malloc(m*sizeof(int));q = (int)malloc(len*sizeof(int));printf("Input the key: ");for(i=0; i<m; i++)scanf("%d", key+i);key[i]--;}getchar();for(i=0; i<len; i++){j = (i/m)*m;q[i] = c[*(key+i%m)+j];}q[i] = '\0';printf("Result is: %s\n", q);for(i=0, j=0; i<len; i++){j = (i/m)*m;c[*(key+i%m)+j] = q[i]+32;}c[len] = '\0';printf("After translated the sentence,we can see the primal sentence as follow:\n%s\n", c);printf("Press any key to return...");free(key);free(q);getch();}void main(){char i = '0';clrscr();while(i!='5'){clrscr();printf("********Press 1~5 to choose:********\n");printf("1. Shift Cipher\n2. Affine Cipher\n3. Vigenere Cipher\n4. Permutation Cipher\n5. Exit\n");i = getch();if(i=='1')Shift();else if(i=='2') Affine();else if(i=='3') Vigenere(); else if(i=='4') Permutation(); else if(i=='5') break;}}。