古典密码之hill密码的加密与解密程序实现

最新推荐文章于 2023-04-14 15:32:25 发布
置顶 最新推荐文章于 2023-04-14 15:32:25 发布
阅读量2.1w 收藏 50
点赞数 9
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/no_sying_nothing/article/details/51534580
版权

*欢迎阅读小明哥的博客*

这里主要介绍的是：古典密码之 hill密码加密解密过程的编程实现。

首先，请看对我对hill密码做的简单介绍。

hill密码是古典密码中多表代换密码部分的重要一环，以下的介绍节选自百度，想要深入了解的请查阅书籍补充相关知识。

原理：希尔密码(Hill Password)是运用基本矩阵论原理的替换密码，由Lester S. Hill在1929年发明。每个字母当作26进制数字:A=0, B=1, C=2... 一串字母当成n维向量，跟一个n×n的矩阵相乘，再将得出的结果模26。注意用作加密的矩阵(即密匙)在\mathbb_^n必须是可逆的，否则就不可能译码。只有矩阵的行列式和26互质，才是可逆的。

需要的知识储备：

1)线性代数基础知识.

2) 初等数论基础知识.

约定：

       1)希尔密码常使用Z26字母表，在此贴中，我们也以Z26最为字母表进行讲解.在附带源码中有两种字母表选择.

2) 大家都知道最小的质数是2,1 既不是质数也不是合数. 在此我们定义1对任何质数的模逆为其本身.

因为对于任意质数n，有: 1*1 % n = 1 的. 也应该是很好理解的.

过程：

1）加密：密文=明文*密钥矩阵  （注：明文要被分割成与密钥维数相同的一维行列式）
2）解密：明文=密文*密钥矩阵的逆 （注：要求与加密过程相同）

加密解密过程如下图：

wKiom1boxprjDe_VAAAZKXwEiBU284.png

例：

wKioL1box_iQAR_KAABY49UTUXI528.png

wKiom1box_uhu0vvAABDW--g6Ds013.png

加密过程：

wKiom1boyGCShMdqAABOMysHfaA697.png

解密：

wKiom1boyJ6BiUN0AABUhBw0uyc397.png

wKioL1bo0P2A6pBAAAA1WEF6DDQ054.png

对上述过程进行编程，主要的函数声明如下：

/*
*
*  头文件名称：hillcrypto.h
*  实现文件名称：hillcrypto.cpp
*  项目名称：多表代换密码之hill密码
*  作者：邹明
*  完成时间：2016.3.14
*
*/

#ifndef  __HILLCRTPTO_H__
#define __HILLCRTPTO_H__

#include<iostream>
using namespace std;

#include<assert.h>
#include <iomanip>

#define ROW 4  //密钥行数为4
#define COV 4   //密钥列数为4

void InputKeys(float keys[ROW][COV]);   //输入密钥
void InputWords(char *words);        //输入明文
void InputObwords(char *words);      //输入密文
void PopKeys(float keys[ROW][COV]);     //输出密钥
void Encryption(float keys[ROW][COV], char *words, char *crypto);   //明文加密
void Decode(float keys[ROW][COV], char *words, char *crypto);     //密文解密
bool Gauss(float A[ROW][COV], float B[ROW][COV], int n);          //高斯消去法求逆矩阵
void 	ObMatrix(float a[ROW][COV], float b[ROW][COV], int n);      //求密钥逆矩阵
void menu();   //菜单

#endif


函数实现过程中的主函数实现以及菜单函数实现如下：

/*   实现文件名称：hillcrypto.cpp    */
#include"hillcrypto.h"

int main()
{
	menu();   //菜单+选择
	system("pause");
	return 0;
}

void menu()
{
	float keys[ROW][COV] = { 8, 6, 9, 5, 6, 9, 5, 10, 5, 8, 4, 9, 10, 6, 11, 4 };  //加密矩阵（默认密钥）
	float obkeys[ROW][COV] = { 0 };  //解密矩阵 （密钥逆矩阵）
	char words[100] = { 0 };
	char crypto[100] = { 0 };
	char obwords[100] = { 0 };
	bool flag = true;   //菜单选择
	bool chose = false;    //密钥选择
	char cn = 0;
	while (flag)
	{
		int n = 0;
		cout << endl;
		cout << "\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
		cout << "\t\t\t1.输入密钥" << endl;
		cout << "\t\t\t2.明文加密" << endl;
		cout << "\t\t\t3.密文解密" << endl;
		cout << "\t\t\t4.退出" << endl << endl;
		cout << "\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
		cout << "请选择->：";
		cin >> n;
		switch (n)
		{
		case 1:
			system("cls");
			cout << "默认密钥为："; 
			PopKeys(keys);
			cout << "请问您要重新输入密钥？ y/n" << endl << "请选择->:";
			cin >> cn;
			if ((cn == 'y') || (cn == 'Y'))
			{
				InputKeys(keys);   //输入密钥
			}
			else if ((cn == 'n') || (cn == 'N'))
			{
				cout << "感谢您选择使用默认密钥！" << endl;
			}
			else
				cout << "输入有误，请重新选择！" << endl;
			system("pause");
			break;
		case 2:
			system("cls");
			InputWords(words);  //输入明文
			Encryption(keys, words, crypto);  //加密
			cout << "密文是->：" << crypto << endl;
			system("pause");
			break;
		case 3:
			system("cls");
			InputObwords(crypto);  //输入密文
			ObMatrix(keys, obkeys, COV);  //计算解密矩阵
			Decode(obkeys, obwords, crypto);  //解密
			cout << "明文是->：" << obwords << endl;
			system("pause");
			break;
		case 4:
			system("cls");
			cout << endl << endl << endl;
			cout << setw(15) << "谢谢使用！" << endl;
			flag = false;
			system("pause");
			break;
		default:
			cout << "选择有误，请重新选择！" << endl;
			system("pause");
			break;
		}
	}
}

输入明文函数和输入密文函数：

void InputWords(char *words)  //输入明文
{
	assert(words);
	cout << "请输入明文：";
	char *start = words;
	int flag = 1;
	getchar();
	while (flag)
	{
		*words = getchar();
		words++;
		if (*(words - 1) == '\n')
		{
			*words = '\0';
			flag = 0;
		}
	}
	words = start;
	while (*start)
	{
		if (('A' <= *start) && (*start <= 'Z'))
		{
			*words = *start;
			words++;
		}
		else if (('a' <= *start) && (*start <= 'z'))
		{
			*words = *start - 32;
			words++;
		}
		start++;
	}
	*words = '\0';
	cout << "输入成功 ！" << endl;
}

void InputObwords(char *words)  //输入密文
{
	assert(words);
	cout << "请输入密文：";
	char *start = words;
	int flag = 1;
	getchar();
	while (flag)
	{
		*words = getchar();
		words++;
		if (*(words - 1) == '\n')
		{
			*words = '\0';
			flag = 0;
		}
	}
	words = start;
	while (*start)
	{
		if (('A' <= *start) && (*start <= 'Z'))
		{
			*words = *start;
			words++;
		}
		else if (('a' <= *start) && (*start <= 'z'))
		{
			*words = *start - 32;
			words++;
		}
		start++;
	}
	*words = '\0';
	cout << "输入成功 ！" << endl;
}

输入密钥与输出密钥函数：

void InputKeys(float keys[ROW][COV])  //输入密钥
{
	cout << "请输入密钥：" << endl;
	for (size_t i = 0; i < ROW; i++)
	{
		cout << "请输入第" << i << "行密钥("<<ROW<<"个数):";
		for (size_t j = 0; j < COV; j++)
		{
			cin >> keys[i][j];
		}
	}
	cout << "输入成功 !" << endl;
}

void PopKeys(float keys[ROW][COV])  //输出密钥
{
	cout << "密钥为：" << endl;
	for (size_t i = 0; i < ROW; i++)
	{
		for (size_t j = 0; j < COV; j++)
		{
			cout << keys[i][j] << "   ";
		}
		cout << endl;
	}
}

加密函数：

void Encryption(float keys[ROW][COV], char *words, char *crypto)  //加密函数
{
	assert(words);
	int len = strlen(words);
	char *start = words;

	while (len > 0)
	{
		int matrix[ROW] = { 0 };
		for (int i = 0; i < ROW; i++)
		{
			if (*start)
				matrix[i] = *start - 'A';
			else
				matrix[i] = 0;
			start++;
		}
		len -= ROW;
		int cry[ROW] = { 0 };
		for (int i = 0; i < ROW; i++)
		{
			int temp = 0;
			for (int j = 0; j < COV; j++)
			{
				temp = matrix[j] * keys[j][i] + temp;
			}
			cry[i] = temp % 26;
			*crypto = 'A' + cry[i];  //计算密文
			crypto++;
		}
	}
}

解密函数，以及求逆矩阵函数：

void Decode(float obkeys[ROW][COV], char *words, char *crypto)//解密函数
{
	assert(crypto);
	int len = strlen(crypto);
	char *start = crypto;
	while (len > 0)
	{
		int matrix[ROW] = { 0 };
		for (int i = 0; i < ROW; i++)
		{
			if (*start)
				matrix[i] = *start - 'A';
			else
				matrix[i] = 0;
			start++;
		}
		len -= ROW;
		int cry[ROW] = { 0 };
		for (int i = 0; i < ROW; i++)
		{
			int temp = 0;
			for (int j = 0; j < COV; j++)
			{
				temp = matrix[j] * obkeys[j][i] + temp;
			}
			cry[i] = temp % 26;
			*words = 'A' + cry[i];  //计算明文
			words++;
		}
	}
}

void 	ObMatrix( float a[ROW][COV], float b[ROW][COV], int n)  //求逆矩阵函数
{
		int i, j;         //定义矩阵的行列式
	if (Gauss(a, b, n))
	{
		cout << "该方阵的逆矩阵为: \n";
		for (i = 0; i < n; i++)
		{
			cout << setw(4);
			for (j = 0; j < n; j++)
			{
				int temp =b[i][j]/ 1;
				float num = b[i][j] - temp;
				if (fabs(num) < 0.50)
					b[i][j] = (int)temp;
				else
					b[i][j] = temp + (int)(num * 2);
				cout << b[i][j] << setw(10);
			}
			cout << endl;
		}
	}
	cout << "逆矩阵（mod26）:" << endl;
	for (int i = 0; i < ROW; i++)
	{
		cout << setw(4);
		for (int j = 0; j < COV; j++)
		{
			if (b[i][j] >= 0)
			{
				b[i][j] = (int)b[i][j] % 26;
			}
			else
			{
				b[i][j] = 26 + (int)b[i][j] % 26;
			}
			cout << b[i][j] << setw(6);
		}
		cout << endl;
	}

}


bool Gauss(float A[ROW][COV], float B[ROW][COV], int n) //高斯消去法
{
	int i, j, k;
	float max, temp;
	float t[ROW][COV];                //临时矩阵
	//将A矩阵存放在临时矩阵t[n][n]中
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			t[i][j] = A[i][j];
		}
	}
	//初始化B矩阵为单位阵
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			B[i][j] = (i == j) ? (int)1 : 0;
		}
	}
	for (i = 0; i < n; i++)
	{
		//寻找主元
		max = t[i][i];
		k = i;
		for (j = i + 1; j < n; j++)
		{
			if (fabs(t[j][i]) > fabs(max))
			{
				max = t[j][i];
				k = j;
			}
		}
		//如果主元所在行不是第i行，进行行交换
		if (k != i)
		{
			for (j = 0; j < n; j++)
			{
				temp = t[i][j];
				t[i][j] = t[k][j];
				t[k][j] = temp;
				//B伴随交换
				temp = B[i][j];
				B[i][j] = B[k][j];
				B[k][j] = temp;
			}
		}
		//判断主元是否为0, 若是, 则矩阵A不是满秩矩阵,不存在逆矩阵
		if (t[i][i] == 0)
		{
			cout << "There is no inverse matrix!";
			return false;
		}
		//消去A的第i列除去i行以外的各行元素
		temp = t[i][i];
		for (j = 0; j < n; j++)
		{
			t[i][j] = t[i][j] / temp;        //主对角线上的元素变为1
			B[i][j] = B[i][j] / temp;        //伴随计算
		}
		for (j = 0; j < n; j++)        //第0行->第n行
		{
			if (j != i)                //不是第i行
			{
				temp = t[j][i];
				for (k = 0; k < n; k++)        //第j行元素 - i行元素*j列i行元素
				{
					t[j][k] = t[j][k] - t[i][k] * temp;
					B[j][k] = B[j][k] - B[i][k] * temp;
				}
			}
		}
	}
	return true;
}

程序运行结果：

wKioL1bozYHDHhlNAAAgPVqMJxk248.png

选择：1

wKiom1bozY7Bl8wjAAAftuVnUPQ208.png

选择：y

wKiom1bozgDA25DfAAAiYiG2Ohk216.png

选择：n

wKiom1bozlSRqoLeAAAhtOqSI9U425.png

选择 2.明文加密：

wKiom1bozs_gpwobAAAej9bk6zA287.png

选择 3.密文解密：

wKioL1boz8vSv20WAAAmikEJ8Qw938.png

选择 4.退出：

wKiom1boz3ezokj0AAAdJ8dnSG0186.png


限于目前的水平，仅写出上述函数，欢迎大家阅读，加密解密函数，我只写了hill密码的一部分，上述代码还有很多需要完善的地方，欢迎各位大神指点，恳请各位批评指正，谢谢

本文出自 “分享中进步” 博客，请务必保留此出处http://xmwen1.blog.51cto.com/10730069/1751672

no_sying_nothing
关注
  • 9
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
hill密码（希尔密码）
野原新之助
12-21 2万+
简述 希尔密码是利用矩阵进行加密的一种加密算法，其本质是一种多表代换密码。 百科： 希尔密码是运用基本矩阵论原理的替换密码，由Lester S. Hill在1929年发明。 每个字母当作26进制数字：A=0, B=1, C=2… 一串字母当成n维向量，跟一个n×n的矩阵相乘，再将得出的结果模26。 注意用作加密的矩阵（即密匙）在 必须是可逆的，否则就不可能解码。只有矩阵的行列式和26互质，才是可...
Hill密码算法
破晓而生，踏浪前行。
04-01 2738
Hill密码简介，分析和简单实现。
hill密码的加密、解密以及破译.zip
06-07
使用c++实现hill密码的加密解密以及破译，代码可即时运行。 代码详述：代码有两个文件，第一个文件用于加密解密，第二个文件用于破译，均可由用户即时输入，交互性好。
CTF密码学-Python古典密码加密解密脚本
04-30
该压缩包包含了Python脚本编写的摩斯密码加密解密、培根密码加密解密、ASCII编码解码、凯撒密码加密解密，可用于教学和实操
浅析加密算法四【Hill密码】
小谢的博客
05-28 8667
文章目录一、简介二、原理2.1 Hill加密原理2.2 矩阵求逆原理三、 举例四、代码4.1 加密代码4.2 解密代码 一、简介 Hill密码又称希尔密码是运用基本矩阵论原理的替换密码，属于多表代换密码的一种，由LesterS.HillLester S. HillLesterS.Hill在1929年发明。 随着科技的日新月异和人们对信用卡、计算机的依赖性的加强，密码学显得愈来愈重要。密码学是一门关于加密和解密、密文和明文的学科。若将原本的符号代换成另一种符号，即可称之为广义的密码。狭义的密码主要是为了保密，
密码的加密解密方法
qq_53162045的博客
12-23 6375
文章目录前言一、凯撒密码的加密解密加密算法解密算法二、单字母表加密法生成字母表单以及加密解密算法 前言 密码学基本原理： 1、发送信息的以防被称为“信源”，接收信息的一方被称为“信宿”。 2、信源发送的原内容被称为“明文”，被加密之后的内容被称为“密文”。 3、从明文转换为密文的过程被称为“加密过程”，从密文转换为明文的过程被称为“解密过程”。 4、加密过程要是用两个重要的要素： （1）加密算法：（公开的） （2）密钥：（保密的） 5、现代密码学将加密算法分为两类： （1）对称加密算法：加密使用的秘钥.
凯撒（caser）密码实现加密与解密
不积跬步无以至千里，不积小流无以成江海。
11-25 3045
Code: package ttwork.secret;       import java.io.*;       public class CaesarSecretCode {        private int key;                public CaesarSecretCod
[古典密码]:Hill cipher（希尔密码）
09-10 1万+
来源于我的博客 希尔加密法 根据字典序将字母转化为数字(0-25) 设定密钥矩阵(n*n)，将明文转化为r*n的矩阵 将明文矩阵与密钥矩阵相乘即可得到密文矩阵(结果模26)，再将其转化为字母即可. 以3*3密钥矩阵为例:（确保密钥矩阵能求逆） int key[3][3] = { 6,13,20, 24,16,17, 1,10,15 }; 假设明文CAT，C=2，A=0
希尔密码（hill）的解密与加密
热门推荐
林林子的博客
03-27 1万+
hill的理论 hill密码涉及到了一部分线性代数方面的求解，在做题时要注意求解逆序数。 加密：Bi = A * ai(mod 26) 解密：ai = A^-1 * Bi 这里的 A 为加密密钥，ai 是根据分组大小定的一个列矩阵，Bi 是求出的加密密文，A^-1是解密密钥。 举例 .hill密码分组大小m=2，加密密钥(3, 5;20，19)。（分号表示换行） （1）请加密“good” （2）请...
【python实现Hill加密】最详细的Hill加密讲解，文中附代码
大道至简
01-01 1万+
前言 最近在准备网络安全期末考试，复习到Hill加密时，想起来之前做的编程作业，没有学会Hill加密求解密秘钥，今天琢磨出来了，然后准备把整个Hill加密过程清晰地整理一下，供大家参考学习。
C语言实现hill（希尔）密码
墨城烟柳ベ旧人殇的博客
04-14 2339
C语言实现hill密码。
【Hill Cipher】希尔密码描述 by Xiaosi_lemon
Xiaosi_lemon的博客
03-03 2808
【Hill Cipher】希尔密码简述基础知识回顾加密功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 简述 加密方式为： 密钥矩阵 * 明文向量然后取模26 解密方式为： 密钥矩阵的逆矩阵 * 密文向量然后取模26 用公式描述即为
Hill密码的加密与解密
cobek的博客
05-21 1万+
Hill密码原理 首先随机生成或选取一个密钥矩阵（该矩阵必须是可逆的），过程如下图所示 在加密过程中，先将明文分为三个字母一组，不足的用“X”代替，然后将其转化成数字，如0==‘A’，再与矩阵相乘，得到的数字转成字母，如‘’B‘’==1，进行输出。 在解密过程中，先求出密钥的逆矩阵，本文直接给出逆矩阵，需要注意的是逆矩阵的元素不可以为负数，若存在负数，则将所有元素+26的若干倍，再mod26，得到全为正整数的逆矩阵。将得到的密文字母转成数字（三个一组），与逆矩阵相乘，将所得的数字转成字母，最后
希尔（加密--＞解密）
DHKSHFJ的博客
04-10 3001
希尔斯加密原理 在学习过程中，无意中接触到希尔斯加密C++语言程序的编写，在这个过程中，遇到了很多无知的错误，比如说：希尔斯加密的原理混淆了，不会求伴随矩阵，不会求矩阵的逆，不会计算两矩阵相乘，使用string定义的变量不能与char定义的变量进行数据的交换，等等一些问题。不过在最后，还是使用C++编写出来了，不过在这里，我不得不抱怨一下哈，之前写C习惯使用的输入输出scanf()和printf()在Visual Studio 中编译不通过，无奈之下使用了C++编译的习惯，使用了std::cout与std
希尔密码C语言源代码,希尔密码加密解密(示例代码)
weixin_35554273的博客
05-22 1542
这个我是从百科中看到的，但是有些地方看不懂，在查阅资料后，进行了修改，希望对大家有帮助加密例如：密钥(密码学中好象没有密匙一词)矩阵1 30 2这个是加密的密钥明文：HI THERE去空格，2个字母一组，根据字母表顺序(如a就是1)换成矩阵数值如下，末尾的E为填充字元：HI TH ER EE8 20 5 59 8 18 5HI 经过矩阵运算转换为 IS，具体算法参考下面的说明(...
hill2
llllliuchang的博客
04-27 518
四、实验原理： 破译关键是求得加密矩阵的逆——解密矩阵。 分析出两个线性无关的明文向量与相应的密文向量，即可利用可逆矩阵求解矩阵方程计算出解密矩阵。即： 五、实验目的： 1、熟悉密码算法的基本破译方法； 2、理解密码算法破译中基于数学的分析方法的基本思路。 六、实验内容： 实现2阶Hill密码在已知明文攻击场景中，基于向量线性无关的破译。 七、实验器材（设备、元器件）： 学生每人一台PC，安装W...
维吉尼亚密码和仿射希尔密码的解密程序(python)
qq_36473502的博客
10-21 3853
密码学原理与实践(第三版) 冯登国 1.21(b) 及1.24 维吉尼亚密码.py # -*- coding: utf-8 -*- ''' 代码中各个函数的说明如下 gcd(a, b) #获取两个数的最大公因数 multi_gcd(num) #获取数组中所有数的最大公因数 find_substr(strs...
Hill密码（希尔密码）
qq_44095715的博客
12-18 5463
Hill密码（希尔密码） 希尔密码可以防止频率分析攻击（因为运用的是矩阵，可能密文中同一个字母翻译成明文是不一样的） 希尔密码隐藏了单字母的频率 字母和数字的对应可以修改成其他方案 抵抗频率攻击 易受已知明文的攻击 希尔密码的加密过程： 1.准备一个n*n的可逆矩阵 E(即密钥) 2.将a-z 对应0-25编码 3.将要加密的一串字母当作n维度向量，比如矩阵E的大小是3*3，那么abcde就可以分为 abc de 转为数字就是012 340(不足n位补0) 4.密文（数字列向量）=（E*明
用python实现Hill密码加密和解密
最新发布
06-08
Hill密码是一种基于线性代数的加密算法，可以用矩阵运算实现加密和解密。下面是用Python实现Hill密码加密和解密的示例代码： ```python import numpy as np # 加密函数 def hill_encrypt(plain_text, key): # 将...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值