[信息论]统计分析攻击凯撒密码实现

最新推荐文章于 2023-05-17 17:06:33 发布
最新推荐文章于 2023-05-17 17:06:33 发布
阅读量3.9k 收藏 6
点赞数
分类专栏： 信息论 密码学 文章标签： 密码 加密 解密 凯撒 密码攻击
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010536377/article/details/45398809
版权

该实验证明了传统密码体制通过统计分析等办法很容易破译。

Caesar密码作为一种最为古老的对称加密体制，在古罗马的时候都已经很流行，它的基本思想是：通过把字母移动一定的位数来实现加密和解密。明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。例如，当偏移量是3的时候，所有的字母A将被替换成D，B变成E，以此类推X将变成 A，Y变成B，Z变成C。由此可见，位数就是Caesar密码加密和解密的密钥。

本次程序在网上选取了3篇类型不一样的文章（来自经济、教育，人物）制作成一个txt文档，名称为 明文.txt。然后我用Caesar密码对其进行加密，形成文档  密文.txt。

并且读取密文.txt,依次查找单字母出现的频率、双字母出现的次数以及三字母出现的次数，并且由于数据量较大，将三者依次输出到三个txt文档中，并且在网上查找到了字母频率分布表，如下：


加密前的明文如下：


加密后的密文如下：


 


单字母统计结果如下（从大到小排序输出）：



双字母统计结果如下：

三字母统计结果如下（仅仅统计了出现次数，结果很长见附件）：

 

分析：首先感觉单字母统计情况与实际频率分布对比，发现密文中H和h出现的概率大约为12%，与第二9%相差比较大，初步判断H对应的明文为E；注意到W在密文中出现概率为9%左右，且频率分布表中T的概率也为9%左右，初步判断W对应的明文为T；概率分布表中出现概率最小的是C，且频率分布表中Z的概率最小，初步判断C对应的明文为Z；依次类推……我们可以根据单字母的频率分布初步破解该加密方法；

同样，由于我们拥有双字母和三字母出现次数的情况，这2种情况为破解的推理过程提供了校验和推理的依据，不难发现加密的规律，从而应用统计分析的方式破解加密方式。


Node.java

/**
 * 用于保存概率（次数）和字符或者字母的信息 以结构体的形式，利于排序
 */

public class Node {
	private double p;// 记录概率
	private char alpha;// 记录对应的字母
	private String str;// 记录对应的字符串

	public Node(double p, char alpha) {
		this.p = p;
		this.alpha = alpha;
	}

	public Node(double p, String str) {
		this.p = p;
		this.str = str;
	}

	public void setp(double p) {
		this.p = p;
	}

	public void setalpha(char a) {
		this.alpha = a;
	}

	public void setstring(String s) {
		this.str = s;
	}

	public double getp() {
		return p;
	}

	public char getalpha() {
		return alpha;
	}

	public String getstr() {
		return str;
	}

	public char getalphabig() {
		return (char) (alpha + 32);
	}
}


Caesar.java

import java.io.*;
import java.util.ArrayList;

/**
 * 运行说明：注意将明文.txt的位置与代码中保持一致，才可以正常运行，修改代码57行位置为明文的路径即可
 * 
 * 
 * 本程序参考了数据结构3.1.4中的代码，对txt文件进行读取， 并且译码存入到另外一个txt文件中，并且统计每个字母在明文和明文中
 * 出现的概率，查阅字母频率分布表后，对明文进行攻击
 */

public class Caesar {
	public static final int ALPHASIZE = 26;// 英文字母表
	public static final char[] alpha = { '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' };
	public static final char[] alpha1 = { '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' };
	protected char[] encrypt = new char[ALPHASIZE];
	protected char[] encrypt1 = new char[ALPHASIZE];
	protected char[] decrypt = new char[ALPHASIZE];
	protected char[] decrypt1 = new char[ALPHASIZE];

	public Caesar() {
		for (int i = 0; i < ALPHASIZE; i++) {
			encrypt[i] = alpha[(i + 3) % ALPHASIZE];
			encrypt1[i] = alpha1[(i + 3) % ALPHASIZE];
		}
		for (int i = 0; i < ALPHASIZE; i++) {
			decrypt[encrypt[i] - 'A'] = alpha[i];
			decrypt1[encrypt1[i] - 'a'] = alpha1[i];
		}
	}

	public String encrypt(String secret) {
		char[] mess = secret.toCharArray();
		for (int i = 0; i < mess.length; i++) {
			if (Character.isUpperCase(mess[i]))
				mess[i] = encrypt[mess[i] - 'A'];
			else if (Character.isLowerCase(mess[i]))
				mess[i] = encrypt1[mess[i] - 'a'];
		}
		return new String(mess);
	}

	public String decrypt(String secret) {
		char[] mess = secret.toCharArray();
		for (int i = 0; i < mess.length; i++)
			if (Character.isUpperCase(mess[i]))
				mess[i] = decrypt[mess[i] - 'A'];
			else if (Character.isLowerCase(mess[i]))
				mess[i] = decrypt1[mess[i] - 'a'];
		return new String(mess);
	}

	public static void main(String args[]) throws Exception {
		Caesar cipher = new Caesar();
		System.out.println("Encryption order=" + new String(cipher.encrypt));
		System.out.println("Decryption order=" + new String(cipher.decrypt));
		// String secret="The Eagle IS IN Play;MEET AT JOE'S.";
		FileReader in = new FileReader(new File(
				"C:\\Users\\Administrator\\Desktop\\明文.txt"));
		BufferedReader sec = new BufferedReader(in);// 字节流
		FileOutputStream out = new FileOutputStream(
				"C:\\Users\\Administrator\\Desktop\\密文.txt");
		// FileOutputStream out1=new
		// FileOutputStream("C:\\Users\\Administrator\\Desktop\\2.txt");
		String secret = sec.readLine();
		int jishu_mingwen[] = new int[52];// 记录出现次数
		int jishu_miwen[] = new int[52];// 记录出现次数
		while (secret != null) {
			char[] sss = secret.toCharArray();// 字符串变成字符数组
			/** 统计明文信息 */
			for (int i = 0; i < sss.length; i++) {
				if (Character.isUpperCase(sss[i]))
					jishu_mingwen[sss[i] - 'A']++;
				else if (Character.isLowerCase(sss[i]))
					jishu_mingwen[26 + sss[i] - 'a']++;
			}
			secret = cipher.encrypt(secret);// 译码
			byte[] buff = secret.getBytes();
			if (secret.equals(""))
				buff = "\r\n\r\n".getBytes();

			out.write(buff);// 输出到文件
			sss = secret.toCharArray();// 字符串变成字符数组
			/** 统计密文信息 */
			for (int i = 0; i < sss.length; i++) {
				if (Character.isUpperCase(sss[i]))
					jishu_miwen[sss[i] - 'A']++;
				else if (Character.isLowerCase(sss[i]))
					jishu_miwen[26 + sss[i] - 'a']++;
			}
			secret = sec.readLine();// 读取下一行
		}
		in.close();// 关闭文件
		/** 计算明文熵 */
		int sum = 0;
		for (int i = 0; i < 52; i++)
			sum += jishu_mingwen[i];
		double Entropy = 0;
		for (int i = 0; i < 52; i++) {
			double p = (double) jishu_mingwen[i] / sum;
			if (p != 0)
				Entropy += -p * Math.log(p) / Math.log(2);
		}
		System.out.println("统计得知明文熵为：" + Entropy);

		/** 计算密文熵 */
		sum = 0;
		for (int i = 0; i < 52; i++)
			sum += jishu_miwen[i];
		Entropy = 0;
		double[] pp = new double[26];// 计算出现频率
		Node[] node = new Node[26];
		for (int i = 0; i < 52; i++) {
			double p = (double) jishu_miwen[i] / sum;
			if (p != 0)
				Entropy += -p * Math.log(p) / Math.log(2);
			if (i < 26)
				pp[i] = p;
			else {
				pp[i - 26] = pp[i - 26] + p;
				node[i - 26] = new Node(pp[i - 26], alpha[i - 26]);
			}
		}
		System.out.println("统计得知密文熵为：" + Entropy);
		FileOutputStream out1 = new FileOutputStream(
				"C:\\Users\\Administrator\\Desktop\\单个字母出现频率分布计算结果.txt");
		for (int i = 0; i < 25; i++)
			// 排序
			for (int j = i + 1; j < 26; j++) {
				if (node[i].getp() < node[j].getp()) {
					Node temp;
					temp = node[i];
					node[i] = node[j];
					node[j] = temp;
				}
			}
		for (int i = 0; i < 26; i++) {
			byte[] buff = (node[i].getalpha() + "和" + node[i].getalphabig()
					+ "出现的频率" + node[i].getp() + "\r\n").getBytes();
			out1.write(buff);
		}
		out.close();
		out1.close();
		// 计算双字母出现频率
		in = new FileReader(new File(
				"C:\\Users\\Administrator\\Desktop\\密文.txt"));
		sec = new BufferedReader(in);// 字节流
		secret = sec.readLine();
		ArrayList<Node> tongji = new ArrayList<Node>();
		while (secret != null) {
			secret.toLowerCase();
			for (int i = 0; i < secret.length() - 1; i++) {
				boolean flag = false;// 队列中的没有匹配
				for (int j = 0; j < tongji.size(); j++) {
					if (secret.substring(i, i + 2).equals(
							tongji.get(j).getstr())) {
						flag = true;
						tongji.get(j).setp(tongji.get(j).getp() + 1);// 此时用途为记录出现次数
						break;
					}
				}
				boolean flag2 = true;
				if (secret.substring(i, i + 1).equals(" ")
						|| secret.substring(i + 1, i + 2).equals(" "))
					flag2 = false;
				if (!flag && flag2)
					tongji.add(new Node(1, secret.substring(i, i + 2)));// 初始次数为1
			}
			secret = sec.readLine();// 读取下一行
		}
		in.close();
		// 排序
		for (int i = 0; i < tongji.size() - 1; i++)
			for (int j = i + 1; j < tongji.size(); j++)
				if (tongji.get(i).getp() < tongji.get(j).getp()) {
					Node temp = tongji.get(i);
					tongji.set(i, tongji.get(j));
					tongji.set(j, temp);
				}
		out1 = new FileOutputStream(
				"C:\\Users\\Administrator\\Desktop\\双字母出现频率分布计算结果.txt");
		byte[] buff = ("双字母出现次数从多到少排序如下：" + "\r\n").getBytes();
		out1.write(buff);
		for (int i = 0; i < tongji.size(); i++) {
			buff = ("双字母" + tongji.get(i).getstr() + "出现次数为："
					+ tongji.get(i).getp() + "次\r\n").getBytes();
			out1.write(buff);
		}

		// 计算三字母出现频率
		in = new FileReader(new File(
				"C:\\Users\\Administrator\\Desktop\\密文.txt"));
		sec = new BufferedReader(in);// 字节流
		secret = sec.readLine();
		tongji.clear();// 情况统计，即双字母的数据
		while (secret != null) {
			secret.toLowerCase();
			for (int i = 0; i < secret.length() - 2; i++) {
				boolean flag = false;// 队列中的没有匹配
				for (int j = 0; j < tongji.size(); j++) {
					if (secret.substring(i, i + 3).equals(
							tongji.get(j).getstr())) {
						flag = true;
						tongji.get(j).setp(tongji.get(j).getp() + 1);// 此时用途为记录出现次数
						break;
					}
				}
				boolean flag2 = true;
				if (secret.substring(i, i + 1).equals(" ")
						|| secret.substring(i + 1, i + 2).equals(" ")
						|| secret.substring(i + 2, i + 3).equals(" "))
					flag2 = false;
				if (!flag && flag2)
					tongji.add(new Node(1, secret.substring(i, i + 3)));// 初始次数为1
			}
			secret = sec.readLine();// 读取下一行
		}
		in.close();
		// 排序
		for (int i = 0; i < tongji.size() - 1; i++)
			for (int j = i + 1; j < tongji.size(); j++)
				if (tongji.get(i).getp() < tongji.get(j).getp()) {
					Node temp = tongji.get(i);
					tongji.set(i, tongji.get(j));
					tongji.set(j, temp);
				}
		out1 = new FileOutputStream(
				"C:\\Users\\Administrator\\Desktop\\三字母出现频率分布计算结果.txt");
		buff = ("三字母出现次数从多到少排序如下：" + "\r\n").getBytes();
		out1.write(buff);
		for (int i = 0; i < tongji.size(); i++) {
			buff = ("三字母" + tongji.get(i).getstr() + "出现次数为："
					+ tongji.get(i).getp() + "次\r\n").getBytes();
			out1.write(buff);
		}
	}
}

mapw1993
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
凯撒密码的自动化破解方法(适用于英文文本)
Bu9pwn
06-26 1万+
凯撒密码的自动化破解方法(适用于英文文本)凯撒密码凯撒加密是有记载的最古老的加密方法。原始的凯撒密码没有密钥，加密方式很原始，就是通过将字母表循环右移三位进行加密：a被D替代，b被E替代，…，x被A替代，y被B替代，z被C替代。 我们现在引入密钥。将字母表看作数字{0,1,2,…,25}（而不是英文字符），密钥k是一个0到25直接的数。加密算法使用密钥k将英文字母组成的明文的每个字母向后移动k个位
凯撒密码加密解密的Java实现设计报告
06-13
在密码学中，恺撒密码（英语：Caesar cipher），或称恺撒加密、恺撒变换、变换加密，是一种最简单且最广为人知的加密技术。它是一种替换加密的技术，明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。例如，当偏移量是3的时候，所有的字母A将被替换成D，B变成E，以此类推。这个加密方法是以罗马共和时期恺撒的名字命名的，当年恺撒曾用此方法与其将军们进行联系。本课程设计是用java语言实现的凯撒密码加密与解密程序。 可直接提交！高分模板！
凯撒加密与频率分析解密
04-08
资源包含凯撒加密与频率分析解密的源代码+操作说明文档。用C#语言编写，仅供学习参考。
凯撒密码加密算法python_信息安全与密码学的关系
weixin_39630813的博客
10-22 1448
一篇文章让你初步了解信息安全领域。 1、简述安全攻击，安全机制，安全服务 安全攻击：任何危及信息系统安全的行为。安全机制：用来检测、阻止攻击或者从攻击状态恢复到正常状态的过程。安全服务(安全属性)：使用一种或多种安全机制来增强安全、对抗安全攻击的过程。 2、安全服务(安全属性)的几个属性及定义 身份认证(鉴别)：确保每个实体都是他们所声称的实体访问控制：防止对资源的未授权使用数据机密性：保护数据免...
密码学基本原理和发展——古典密码学
最新发布
N2O_666的博客
05-17 2381
介绍了以凯撒密码和维吉尼亚密码为代表的古典密码学原理、实现、破解。
网络安全----密码学
juggte的博客
11-16 5416
密码学 数据有哪些安全需求？ 需确保数据的保密性、完整性、不可否认性和可认证性。 基础是现代密码学。 通过加密将可读的信息变换成不可理解的乱码，从而起到保护信息的作用。 密码学的发展史 自人类社会出现战争便产生了密码 ，Phaistos圆盘，一种直径约为 160mm的Cretan-Mnoan粘土圆盘， 始于公元前17世纪。表面有明显字间 空格的字母，至今还没有破解。 1834年，伦敦大学的实验物理学教授惠斯顿发明了电机，这 是通信向机械化、电气化跃进的开始，也为密码通信采用在线 加密技术提
多表古典密码统计分析
考拉研究僧的博客
03-31 5134
多表古典密码统计分析我们以Vigenere密码为例来说明多表古典密码的分析方法。确定密钥字长度的方法有Kasiski测试法（Kasiski Test）和重合指数法（index of coincidence).1.Kasiski测试法:寻找密文中相同的片段(一般长度大于三)对，计算每对相同密文片段对之间的距离，不妨记为d1,d2,…,di，若令密钥字的长度为m，则m=gcd(d1,d2,…,di)2.
应用密码学实验 古典密码
m0_56948411的博客
11-28 2433
穷举破译是一种唯密文攻击，任意给定一段密文，利用穷举法找出所用的密钥，最多尝试26次。凯撒密码是没有密匙的，即使没有密匙也能将它破解出来，因为凯撒移位密码只有25种密匙，最多就是将这25种可能性挨个检测一下可以了，这就是我们所说的暴力破解法。通过实验熟悉掌握凯撒密码原理和多表代替密码的实现方法，编译实现加密算法，提高程序设计能力，掌握穷举破译的方法。凯撒密码是比较简单的，只是进行单表代换，实现起来也比较容易，破解起来也不难，是很不安全的密码。从键盘中读取明文，取出所有字母，放入数组中；
联邦学习的推断攻击
学渣的博客
04-18 5742
什么是联邦学习 联邦学习是在多参与方或多计算结点之间开展高效率的机器学习框架，其设计目标是在保障大数据交换时的信息安全、保护终端数据和个人数据隐私。 我们用一张图来描述联邦学习的流程： ...
基于统计的攻击防范
cxw06023273的博客
01-10 362
本文档的Copyleft归yfydz所有，使用GPL发布，可以自由拷贝，转载，转载时请保持文档的完整性，严禁用于任何商业用途。 msn: [email protected] 来源：http://yfydz.cublog.cn [code="java"]1. 前言 需要进行统计才能判断的网络攻击分为flood和scan，通常需要统计在一定时间内连接数量，通过阈值来判断是否...
python3.6+维吉尼亚密码解密解密词频统计唯密文攻击+tkinter工具
10-18
一个课程作业，关于维吉尼亚密码的加密解密词频统计唯密文攻击的图形化界面。不够健壮....但是主要的功能都能用
Matlab 矩阵论矩阵分析 计算代码实现
01-02
代码涵盖矩阵论 矩阵分析中 满秩分解 奇异值分解 三角分解，史密斯标准型变换 约旦标准型变换 标准正交基 矩阵空间交和并求基 施密特正交化 过渡矩阵和基础矩阵计算（逆 特征值等）。 使用方式 打开代码 选取对应...
分析企业财务信息化管理目标管理论文.doc
12-13
分析企业财务信息化管理目标管理论文.doc
统计决策论及贝叶斯分析
03-12
统计决策论及贝叶斯分析 统计决策论及贝叶斯分析 统计决策论及贝叶斯分析 统计决策论及贝叶斯分析
java凯撒密码课程设计论文
04-28
java凯撒密码课程设计论文，完美实现加密解密。
[密码学]格密码学（3）-Babai算法以及GGH公钥密码体制介绍
让勤奋成为习惯
12-25 9780
Babai算法和GGH加密体制
[密码学]格密码学（2）-背包公钥密码体制
让勤奋成为习惯
12-24 9112
背包公钥密码体制
[密码学]McEliece公钥密码体制
让勤奋成为习惯
12-14 8805
McEliece公钥密码体制的简单介绍
[密码学]格密码学（1）-同余公钥密码体制
让勤奋成为习惯
12-23 7342
同余密钥公钥体制
用c++实现信息论哈夫曼编码
05-13
哈夫曼编码是一种基于字符出现频率构建最优前缀编码的方法。下面是用C++实现哈夫曼编码的基本步骤： 1. 定义一个结构体来表示哈夫曼树的节点，包含字符、出现频率以及左右子节点等信息。 ```c++ struct HuffmanNode { char character; // 字符 int frequency; // 频率 HuffmanNode* left; // 左子节点 HuffmanNode* right; // 右子节点 HuffmanNode(char c, int f) { character = c; frequency = f; left = right = nullptr; } }; ``` 2. 定义一个比较函数用于优先队列的排序，按照频率从小到大排序。 ```c++ struct Compare { bool operator()(HuffmanNode* a, HuffmanNode* b) { return a->frequency > b->frequency; } }; ``` 3. 构建哈夫曼树，将所有字符的出现频率存入优先队列中，每次取出最小的两个节点合并为一个新节点，直到队列中只剩下一个节点为止。 ```c++ HuffmanNode* buildHuffmanTree(map<char, int> frequencyTable) { priority_queue<HuffmanNode*, vector<HuffmanNode*>, Compare> q; for (auto pair : frequencyTable) { char c = pair.first; int f = pair.second; q.push(new HuffmanNode(c, f)); } while (q.size() > 1) { HuffmanNode* left = q.top(); q.pop(); HuffmanNode* right = q.top(); q.pop(); HuffmanNode* parent = new HuffmanNode('\0', left->frequency + right->frequency); parent->left = left; parent->right = right; q.push(parent); } return q.top(); } ``` 4. 生成哈夫曼编码，从根节点开始，当遇到左子节点时，在当前编码后加上0，遇到右子节点时加上1，直到叶子节点结束。 ```c++ void generateHuffmanCode(HuffmanNode* root, string code, map<char, string>& huffmanCodeTable) { if (root->left == nullptr && root->right == nullptr) { huffmanCodeTable[root->character] = code; return; } generateHuffmanCode(root->left, code + "0", huffmanCodeTable); generateHuffmanCode(root->right, code + "1", huffmanCodeTable); } ``` 5. 读入文件，根据字符出现频率构建哈夫曼树并生成哈夫曼编码，将编码写入输出文件。 ```c++ void huffmanEncode(string inputFile, string outputFile) { ifstream fin(inputFile); ofstream fout(outputFile); map<char, int> frequencyTable; char c; while (fin.get(c)) { if (frequencyTable.find(c) != frequencyTable.end()) { frequencyTable[c]++; } else { frequencyTable[c] = 1; } } HuffmanNode* root = buildHuffmanTree(frequencyTable); map<char, string> huffmanCodeTable; generateHuffmanCode(root, "", huffmanCodeTable); fin.clear(); fin.seekg(0, ios::beg); string code; while (fin.get(c)) { code += huffmanCodeTable[c]; } fout << code; fin.close(); fout.close(); } ``` 这样，我们就完成了用C++实现信息论哈夫曼编码的过程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值