凯撒解密算法

‘壹’ 凯撒加密解密算法问题 c语言描述

你这语句有问题吧？
#include<stdio.h>
main()
{ char i;
int n;
scanf("%d",&n);
printf("Input your word:");
while(1)
{ i=getchar();
if(i!='\0')
printf("%c",i+n);
else break;
}
} 这个是密钥自己输入的

‘贰’ 网络安全凯撒密码的计算方法。

凯撒密码关键的是密匙，密匙也就是一个数字，比如说密匙是1，那对英文单词book这个单词加密，结果就是相应的每个字母在字母表中的序号减去1，比如b在英文单词里排第二位，那加密后就是a,o加密后就是n,依此类推，book加密后就是annj,解密时每个字母的顺序号加1，所对应的字母就是密文。

‘叁’ 凯撒算法的问题

第一次回答可获2分，答案被采纳可获得悬赏分和额外20分奖励。#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

#define MAX_SIZE 100 /*最大字符数*/

void encrypt()
/*加密算法*/
{
char code[MAX_SIZE] = "\0";
int j= 0, k = 0;

printf("\n请输入明文:\n");
fflush(stdin);

gets(code);
printf("\n请输入密钥:");
scanf("%d", &k);

while(code[j] != '\0')
{
if(code[j] >= 'a' &&code[j] <= 'z')
//小写字母加密
{
code[j] = (code[j]-'a'+k)%26+'a';
}
else if(code[j] >= 'A' &&code[j] <= 'Z')
//大写字母加密
{
code[j] = (code[j]-'A'+k)%26+'A';
}
j++;

}
printf("\n对应的密文:\n%s\n", code);
}

void decrypt()
/*解密算法*/
{
char code[MAX_SIZE] = "\0";
int j= 0, k = 0;

printf("\n请输入密文:\n");
fflush(stdin);

gets(code);
printf("\n请输入密钥:");
scanf("%d", &k);

while(code[j] != '\0')
{
if(code[j] >= 'a' &&code[j] <= 'z')
//小写字母解密
{
code[j] = (code[j]-'a'-k+26)%26+'a' ;
}
else if(code[j] >= 'A' &&code[j] <= 'Z')
//大写字母解密
{
code[j] = (code[j]-'A'-k+26)%26+'A' ;
}
j++;

}
printf("\n对应的明文:\n%s\n", code);
}

void main(void)
{

int flag = 1;

while(flag)
{
printf("\n请选择：\n1.加密；\n2.解密；\n0.退出；\n");
scanf("%d", &flag);

switch(flag)
{
case 1:
encrypt();/*加密函数*/
break;

case 2:
decrypt();/*解密函数*/
break;
default :
break;
}
}
}

运行过程如下：

‘肆’ 用java 编写一个凯撒加密和解密

import java.util.Scanner;

public class Caeser {
private String table; // 定义密钥字母表
private int key; // 定义密钥key
public Caeser(String table, int key) {
// 根据不同的字母表和不同的密钥生成一个新的凯撒算法，达到通用的目的
super();
this.table = table;
this.key = key;
}
public String encrypt(String from) {
//凯撒加密算法，传入明文字符串，返回一个密文字符串
String to = "";
for (int i = 0; i < from.length(); i++) {
to += table.charAt((table.indexOf(from.charAt(i))+key)%table.length());
}
return to;
}

public static void main(String[] args) {
Caeser caeser = new Caeser("abcdefghijklmnopqrstuvwxyz", 3);
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要加密的字符串");
String str =scanner.nextLine(); //输入字符串 security
String result = caeser.encrypt(str); //调用加密方法进行加密
System.out.print(result); // 可得结果 vhfxulwb
}
}

‘伍’ 谁懂计算机的凯撒码 我想知道怎么代换

这里有方法，自己看吧，比较多，呵呵
[凯撒介绍]

凯撒密码（kaiser）是罗马扩张时期朱利斯"凯撒（Julius Caesar）创造的，用于加密通过信使传递的作战命令。它将字母表中的字母移动一定位置而实现加密。

[加密原理]

凯撒密码的加密算法极其简单。其加密过程如下：
在这里，我们做此约定：明文记为m，密文记为c，加密变换记为E(k1,m)（其中k1为密钥），解密变换记为D(k2,m)（k2为解密密钥）（在这里k1=k2,不妨记为k）。凯撒密码的加密过程可记为如下一个变换：
c≡m+k mod n （其中n为基本字符个数）
同样，解密过程可表示为：
m≡c+k mod n （其中n为基本字符个数）
对于计算机而言，n可取256或128，m、k、c均为一个8bit的二进制数。显然，这种加密算法极不安全，即使采用穷举法，最多也只要255次即可破译。当然，究其本身而言，仍然是一个单表置换，因此，频率分析法对其仍是有效的。

[加密算法]

我们预定义基本字符个数为 #define MAX 128
凯撒加密函数可以表示为

[Copy to clipboard]
CODE:
char cipher(char plain_char, int key)
{
return (plain_char + key) % MAX;
};

凯撒解密函数：

[Copy to clipboard]
CODE:
char decipher(char cipher_char, int key)
{
return (cipher_char - key + MAX) % MAX;
};

加密后，原所有的ASCII码偏移key位，解密则移回key位。
如果要对一个文本文件进行加密，则只要依次逐个字符逐个字符地读取文本文件，进行加密后，逐个字符逐个字符写入密文文本文件中，即可：

[Copy to clipboard]
CODE:
FILE *fp_plaintext;
FILE *fp_ciphertext;
char plain_char;
... ...
while((plain_char=fgetc(fp_plaintext))!=EOF)
{
fputc(cipher(plain_char,key),fp_ciphertext);
}

对文件的解密也同样方法。

[破解原理]

一篇包含字符的英文文章，其各ASCII码字符出现，都有一定的频率，下面是对Google上随意搜索到的英文文章进行分析的结果，见表：

QUOTE:
=================================================
FileName : 01.txt

[1] 32: times:204
[2] 101:e times:134
[3] 116:t times:91
[4] 105:i times:87
[5] 111:o times:77
[6] 108:l times:75
[7] 97:a times:75
[8] 110:n times:69
[9] 10:
times:67
[10] 115:s times:63

=================================================
FileName : php.si.source.txt

[1] 32: times:576
[2] 101:e times:162
[3] 115:s times:153
[4] 110:n times:141
[5] 114:r times:138
[6] 105:i times:135
[7] 10:
times:134
[8] 116:t times:129
[9] 42:* times:116
[10] 111:o times:103

=================================================
FileName : work.txt

[1] 32: times:51322
[2] 101:e times:30657
[3] 116:t times:23685
[4] 97:a times:19038
[5] 111:o times:17886
[6] 105:i times:16156
[7] 110:n times:15633
[8] 114:r times:15317
[9] 115:s times:15226
[10] 104:h times:12191

=================================================
FileName : 02.txt

[1] 32: times:299
[2] 101:e times:217
[3] 110:n times:136
[4] 105:i times:133
[5] 111:o times:124
[6] 116:t times:116
[7] 97:a times:110
[8] 115:s times:98
[9] 114:r times:92
[10] 108:l times:82

=================================================
FileName : 03.txt

[1] 45:- times:404
[2] 32: times:394
[3] 101:e times:237
[4] 116:t times:196
[5] 114:r times:173
[6] 97:a times:163
[7] 105:i times:161
[8] 110:n times:153
[9] 111:o times:142
[10] 115:s times:129

=================================================
FileName : 04.txt

[1] 32: times:326
[2] 101:e times:179
[3] 116:t times:106
[4] 105:i times:101
[5] 111:o times:96
[6] 110:n times:94
[7] 97:a times:92
[8] 115:s times:78
[9] 100:d times:61
[10] 114:r times:60

=================================================
FileName : 05.txt

[1] 32: times:441
[2] 101:e times:191
[3] 111:o times:151
[4] 116:t times:120
[5] 97:a times:112
[6] 110:n times:108
[7] 105:i times:91
[8] 114:r times:84
[9] 117:u times:79
[10] 115:s times:79

有此分析可知，一篇英文文章中，出现较高频率的两个字符是 ' ' (空格) 和 'e'，而且它们的ASCII码分别是32和101，差值是69。
既然凯撒密码利用的是单表替换的一种简单加密算法，所以，我们的主角， ' ' 和 'e' ，在解密后，依然会保持相同的ASCII码差值，69。

|c1 - c2| = |'e' - ' '| = |101 - 32| = 69
|m1 - m2| = | ((c1 + k) mod 256)-((c2 + k) mod 256)| = |c1 - c2| = |'e' - ' '| = 69

现在可以得到破解凯撒密码的原理了，我们统计一片经过凯撒加密的密文字符信息，在出现频率较高的字符里面寻找差值是69的2个字符，这两个必定是 ' ' 和 'e' 字符的加密字符，计算偏移量（既密钥key），通过解密运算，还原出明文。

[破解算法]

任何一片英文加密后的密文，我们统计出所有字符的个数：

[Copy to clipboard]
CODE:
#define MAX 128

... ...

FILE *fp_ciphertext;
char cipher_char;
int i; //密文文件长度，包含多少字符
unsigned int size_file=0; //申明num数组，存储各个ASCII字符在密文中出现的个数
num[MAX];

... ...

for(i = 0;i < MAX; i++) //初始化num数组中的值
num[i] = 0;

... ...

while((cipher_char=fgetc(fp_ciphertext))!=EOF)
{
num[cipher_char]++;
size_file++;
}

统计出现最多次数的字符，定义#define GETTOP 10，统计最多的前10位字符：

[Copy to clipboard]
CODE:
//统计前10位
#define GETTOP 10

... ...

int temp,i,j;
int maxascii[GETNUM]; //申明maxascii数组，存储统计出的概率前10位的字符ascii码
int maxtimes[GETNUM]; //申明maxtimes数组，存储统计出的概率前10位的字符的出现次数

... ...

for(i=0;i<GETTOP;i++)
{
temp=0; //临时变量temp里面来存储出现最多次数的字符的ascii码
for(j=1;j<MAX;j++) //依次比较所有的字符次数，获得最多字符的ascii码
{
if(num[j]>=num[temp])
temp=j;
}
maxascii[i]=temp; //把出现最多次数字符的ascii存储到相应的maxascii数组中
maxtimes[i]=num[temp]; //把最多次数字符的出现次数存储到相应的maxtimes数组中
num[temp]=0; //把最多次数字符的次数赋值成0，
//进行循环运算，同样的算法，第二次循环得到的值，肯定是出现第二多的字符
//避免了对256或128个字符进行排序的复杂运算
//当年我用汇编编写成绩排序的程序时，也用这套排序算法:-)

}

找出出现最多字符中，ASCII码差别是69的两个字符，计算出密钥key的长度：

[Copy to clipboard]
CODE:
for(i=0;i<GETTOP;i++)
{
for(j=0;j<GETTOP;j++)
{
if((max[i]-max[j])==69)
{
key=(max[j] - 32 + MAX ) % MAX;
printf("Key : %d\n",key);
break;
}
}
}

既然得到了密钥长度，算完成了对凯撒密码的破解了，那就进行解密吧，大功告成！

‘陆’ jmu-python-凯撒密码加密算法，谢谢

def encryption():
str_raw = input("请输入明文:")
k = int(input("请输入位移值:"))
str_change = str_raw.lower()
str_list = list(str_change)
str_list_encry = str_list
i = 0
while i < len(str_list):
if ord(str_list[i]) < 123-k:
str_list_encry[i] = chr(ord(str_list[i]) + k)
else:

print ("解密结果为:"+"".join(str_list_decry))
while True:
print (u"1. 加密")
print(u"2. 解密")
choice = input("请选择:")
if choice == "1": encryption()
elif choice == "2": decryption()
else: print (u"您的输入有误!")

‘柒’ 汇编语言写个凯撒密码加密和解密的！

着名的凯撒加密算法就是一种简单的替代加密法，它是将明文中每一个字符用右移3位并以26个字符为模的替代(A由D替代，B由E替代，··…—，W由Z替代，X由A替代，Y由B替代，Z由C替代)。

所以你的汇编很简单呀，按1的时候，你用一个寄存器指向明文，然后对寄存器指向的数据做加3，然后mod26的处理，解密是按2的时候，你用一个寄存器指向密文，然后然后对寄存器指向的数据做减3，然后mod26的处理。

‘捌’ C语言的凯撒密码问题我想求教这个算法是怎么推出来的呢 加密算法：(a［i］-a+k)%26-a

它的原理是字母与字母之间的替换。例如26个字母都向后移动K位。若K等于2，则A用C代替，B用D代替，以此类推
k是移动的位数，例如移动两位，当前字母是c，那么c-a=2,再加2,4%26=4(保证变换后的在26个字母的范围内)，然后a+4即为e

‘玖’ 将凯撒密码X的加密、解密过程用C语言编程实现

1、在密码学中，恺撒密码（或称恺撒加密、恺撒变换、变换加密）是一种最简单且最广为人知的加密技术。它是一种替换加密的技术，明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。例如，当偏移量是3的时候，所有的字母A将被替换成D，B变成E，以此类推。这个加密方法是以恺撒的名字命名的，当年恺撒曾用此方法与其将军们进行联系。恺撒密码通常被作为其他更复杂的加密方法中的一个步骤，例如维吉尼尔密码。恺撒密码还在现代的ROT13系统中被应用。但是和所有的利用字母表进行替换的加密技术一样，恺撒密码非常容易被破解，而且在实际应用中也无法保证通信安全。例子恺撒密码的替换方法是通过排列明文和密文字母表，密文字母表示通过将明文字母表向左或向右移动一个固定数目的位置。

2、kaiser加密算法具体程序：

#include<stdio.h>
#include<conio.h>
charencrypt(charch,intn)/*加密函数，把字符向右循环移位n*/
{
while(ch>='A'&&ch<='Z')
{
return('A'+(ch-'A'+n)%26);
}
while(ch>='a'&&ch<='z')
{
return('a'+(ch-'a'+n)%26);
}
returnch;
}
voidmenu()/*菜单，1.加密，2.解密，3.暴力破解，密码只能是数字*/
{
clrscr();
printf("
=========================================================");
printf("
1.Encryptthefile");
printf("
2.Decryptthefile");
printf("
3.Forcedecryptfile");
printf("
4.Quit
");
printf("=========================================================
");
printf("Pleaseselectaitem:");
return;
}
main()
{
inti,n;
charch0,ch1;
FILE*in,*out;
charinfile[20],outfile[20];
textbackground(BLACK);
textcolor(LIGHTGREEN);
clrscr();
sleep(3);/*等待3秒*/
menu();
ch0=getch();
while(ch0!='4')
{
if(ch0=='1')
{
clrscr();
printf("
Pleaseinputtheinfile:");
scanf("%s",infile);/*输入需要加密的文件名*/
if((in=fopen(infile,"r"))==NULL)
{
printf("Cannotopentheinfile!
");
printf("Pressanykeytoexit!
");
getch();
exit(0);
}
printf("Pleaseinputthekey:");
scanf("%d",&n);/*输入加密密码*/
printf("Pleaseinputtheoutfile:");
scanf("%s",outfile);/*输入加密后文件的文件名*/
if((out=fopen(outfile,"w"))==NULL)
{
printf("Cannotopentheoutfile!
");
printf("Pressanykeytoexit!
");
fclose(in);
getch();
exit(0);
}
while(!feof(in))/*加密*/
{
fputc(encrypt(fgetc(in),n),out);
}
printf("
Encryptisover!
");
fclose(in);
fclose(out);
sleep(1);
}
if(ch0=='2')
{
clrscr();
printf("
Pleaseinputtheinfile:");
scanf("%s",infile);/*输入需要解密的文件名*/
if((in=fopen(infile,"r"))==NULL)
{
printf("Cannotopentheinfile!
");
printf("Pressanykeytoexit!
");
getch();
exit(0);
}
printf("Pleaseinputthekey:");
scanf("%d",&n);/*输入解密密码（可以为加密时候的密码）*/
n=26-n;
printf("Pleaseinputtheoutfile:");
scanf("%s",outfile);/*输入解密后文件的文件名*/
if((out=fopen(outfile,"w"))==NULL)
{
printf("Cannotopentheoutfile!
");
printf("Pressanykeytoexit!
");
fclose(in);
getch();
exit(0);
}
while(!feof(in))
{
fputc(encrypt(fgetc(in),n),out);
}
printf("
Decryptisover!
");
fclose(in);
fclose(out);
sleep(1);
}
if(ch0=='3')
{
clrscr();
printf("
Pleaseinputtheinfile:");
scanf("%s",infile);/*输入需要解密的文件名*/
if((in=fopen(infile,"r"))==NULL)
{
printf("Cannotopentheinfile!
");
printf("Pressanykeytoexit!
");
getch();
exit(0);
}
printf("Pleaseinputtheoutfile:");
scanf("%s",outfile);/*输入解密后文件的文件名*/
if((out=fopen(outfile,"w"))==NULL)
{
printf("Cannotopentheoutfile!
");
printf("Pressanykeytoexit!
");
fclose(in);
getch();
exit(0);
}
for(i=1;i<=25;i++)/*暴力破解过程，在察看信息正确后，可以按'Q'或者'q'退出*/
{
rewind(in);
rewind(out);
clrscr();
printf("==========================================================
");
printf("Theoutfileis:
");
printf("==========================================================
");
while(!feof(in))
{
ch1=encrypt(fgetc(in),26-i);
putch(ch1);
fputc(ch1,out);
}
printf("
========================================================
");
printf("Thecurrentkeyis:%d
",i);/*显示当前破解所用密码*/
printf("Press'Q'toquitandotherkeytocontinue......
");
printf("==========================================================
");
ch1=getch();
if(ch1=='q'||ch1=='Q')/*按'Q'或者'q'时退出*/
{
clrscr();
printf("
GoodBye!
");
fclose(in);
fclose(out);
sleep(3);
exit(0);
}
}
printf("
Forcedecryptisover!
");
fclose(in);
fclose(out);
sleep(1);
}
menu();
ch0=getch();
}
clrscr();
printf("
GoodBye!
");
sleep(3);
}

‘拾’ c语言凯撒密码暴力破解

加上这个函数吧

voidforce_decode(void)
{
	charbuf[100];
	charbuf1[100];
	intn,i;
	
	gets(buf);
	for(n=1;n<26;n++)
	{
		printf("usekey%d
",n);
		for(i=0;buf[i];i++)
		{
			if(buf[i]>='A'&&buf[i]<='Z')
			{
				buf1[i]=(buf[i]-'A'-n+26)%26+'A';
			}
			elseif(buf[i]>='a'&&buf[i]<='z')
			{
				buf1[i]=(buf[i]-'a'-n+26)%26+'a';
			}
		}
		buf1[i]=0;
		printf("%s
",buf1);
	}
}

其实 如果改成在main中输入，然后把decode改成处理字符串，并获取结果。在main出输出。

那么要求的暴力破解就可以直接用decode的代码了。