矩阵编制Hill密码
hill密码体制
Hill密码是一种简单的加密手段。
优点是：可以实现同一个字母在不同的上下文中，对应密文中不同的字母。
缺点是：加密前明文是几个字母，加密后还是几个字母。
容易被穷举。
以下，我们都用英文字母举例，比较简单明了下面简要介绍一下加密过程首先，要将26个字母，编号，例如a:1b:2c:3d:4e:5f:6g:7h:8i:9j:10k:11l:12m:13n:14o:15p:16q:17r:18s:19t:20u:21v:22w:23x:24y:25z:0其次，确定密钥，在这里其实就是加密矩阵，Hill2密码对应的是一个二阶矩阵，Hill n密码对应的就是一个N接矩阵了，我们这里取二阶，比较简单。
如：取个加密矩阵A=(1 2;0 3) 说明：大家凑合着看啊，其实是 1 2是一行，0 3是一行。
画个矩阵太麻烦了以下说明，矩阵里加了分号就表示换行哈有了字母编号表和密钥就万事具备了。
我们来将下面一段字母加密woshigetiancai首先，将字母两两分组wo ,sh, ig, et, ia, nc, ai。
这里刚好是偶数个字母，如果是奇数个，就重复一次，最后一个字母，凑成偶数。
其次，查询字母标号表，将分好组的字母，写成向量形式，其实就是写成一个1*2的矩阵（我就讨厌，那些书，明明就是个1*2矩阵，偏偏要要定义成向量，增加无谓的概念）：如w 对应23，o对应15，写成向量（23;15）（这个是竖着写的，实在不好意思，矩阵实在不太好画，手头没matlab）以此类推，得到7组向量，分别是wo对应的(23;15) sh对应的(19;8) ig对应的(9;7) et对应的（5;20) ia对应的(9;1）nc 对应的(14;3) ai对应的(1;9)将这些向量分别左乘密钥注意:这里矩阵这个东西比较麻烦，不符合乘法交换律，两个矩阵左乘和右乘的结果是不一样的左乘就是将密钥放到左边，右边是向量A*P(向量）又得到7组向量，分别是（38；45），（27；24），（16；24），（25；60），（10；3），（17；9），（10；27）这时候，我们就遇到了一个问题，我们定义的字母标号表是0~25的，这里又是45 ，又是60的，怎么办？？没关系，遇到比25大的，我们就减26 知道，让数字落在0~25之间就可以了例如原向量(38;45）我们就变成了(12；19），这样就落在我们的字母标号表里了，很简单吧以此类推，最后得到的7组向量就变成了(12;19),(1;24),(14;24),(25;8),(10;3),(17;9),(10,1)最后再将数字通过字母标号表对照过来就可以了这里是lsaxnxyhjcqija 这样就和原字符有很大的区别了吧。
Hill密码
Hill密码本⽂为转载他⼈⽂章这⾥主要介绍的是：古典密码之 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）解密：明⽂=密⽂*密钥矩阵的逆（注：要求与加密过程相同）加密解密过程如下图：例：加密过程：解密：对上述过程进⾏编程，主要的函数声明如下：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25/*** 头⽂件名称：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 //密钥列数为4void 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); //明⽂加密2526 27 28 29 30 31 32 33void 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函数实现过程中的主函数实现以及菜单函数实现如下：12345 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56/* 实现⽂件名称：hillcrypto.cpp */#include"hillcrypto.h"int main(){menu(); //菜单+选择system("pause");return0;}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){case1: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;}elsecout << "输⼊有误，请重新选择！"<< endl;system("pause");break;case2:system("cls");InputWords(words); //输⼊明⽂Encryption(keys, words, crypto); //加密cout << "密⽂是->："<< crypto << endl;56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 cout << "密⽂是->："<< crypto << endl;system("pause");break;case3:system("cls");InputObwords(crypto); //输⼊密⽂ObMatrix(keys, obkeys, COV); //计算解密矩阵 Decode(obkeys, obwords, crypto); //解密cout << "明⽂是->："<< obwords << endl;system("pause");break;case4:system("cls");cout << endl << endl << endl;cout << setw(15) << "谢谢使⽤！"<< endl;flag = false;system("pause");break;default:cout << "选择有误，请重新选择！"<< endl;system("pause");break;}}}输⼊明⽂函数和输⼊密⽂函数：123456 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40void 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;40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 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;}输⼊密钥与输出密钥函数：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26void 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;}}加密函数：123 4 5void Encryption(float keys[ROW][COV], char*words, char*crypto) //加密函数{assert(words);int len = strlen(words);5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 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';elsematrix[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++;}}}解密函数，以及求逆矩阵函数：1234567891011 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39void 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';elsematrix[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++;}}}39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107void 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;elseb[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;}}107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 }//如果主元所在⾏不是第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; //主对⾓线上的元素变为1B[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;}程序运⾏结果：选择：1选择：y选择：n选择 2.明⽂加密：选择 3.密⽂解密：选择 4.退出：。
hill密码算法
hill密码算法
Hill密码算法是一种基于线性代数的密码算法，旨在实现块密码的加密和解密操作。
它由美国数学家莱斯利·斯普兰特·希尔（Leslie S. Hill）于1929年提出。
Hill密码算法的主要思想是利用矩阵运算和模运算来实现加密和解密过程。
算法的关键在于定义一个矩阵作为密钥，然后将明文分成固定长度的块，每个块用矩阵乘法进行加密或解密。
具体步骤如下：
1. 选择一个密钥矩阵K。
矩阵K的行列数应该是一个合法的平方数，一般为2x2或3x3。
2. 将明文分成长度为密钥矩阵行（列）数的块。
每个块可以表示为一个列向量。
3. 对于加密操作，将每个明文块表示为一个列向量X。
计算密文块C = K * X % 26，其中% 26表示模运算。
得到的密文块也表示为一个列向量。
4. 对于解密操作，将每个密文块表示为一个列向量C。
计算明文块X = K^-1 * C % 26，其中K^-1表示矩阵K的逆矩阵。
得到的明文块也表示为一个列向量。
5. 将每个块转换为对应的字母或字符，即完成加密或解密操作。
需要注意的是，密钥矩阵K的选择很重要，它应该是一个可逆矩阵，即存在逆矩阵K^-1，使得K * K^-1 = I，其中I为单位矩阵。
否则，加密和解密操作将无法正确进行。
Hill密码算法的优点是可以同时处理多个字符，提高了加密的效率和安全性。
然而，它的缺点是对于大型密钥矩阵的逆矩阵计算较为困难，且算法的安全性依赖于密钥的保密性。
hill密码-矩阵应用
13
信源 → 加密 → 信道 → 解密 → 信宿
1
1929年，希尔（Hill）通过矩阵理论对传输信息 年 希尔（ 矩阵理论对传输信息 ）通过矩阵理论 进行加密处理，提出了在密码史上有重要地位的希尔 进行加密处理，提出了在密码史上有重要地位的希尔 加密算法。下面我们介绍一下这种算法的基本思想。 加密算法。下面我们介绍一下这种算法的基本思想。 【准备】若要发出信息 action，现需要利用矩阵 准备】 ， 乘法给出加密方法和加密后得到的密文， 乘法给出加密方法和加密后得到的密文，并给出相应 的解密方法。 的解密方法。
2
【假设】（1）假定 个英文字母与数字之间有以 假设】 ）假定26个英文字母与数字之间有以 下的一一对应关系： 下的一一对应关系：
A վ 1
B վ 2
C վ 3
⋯ ⋯ ⋯
X վ 24
Y վ 25
Z վ 26
个字母分为一组， （2）假设将单词中从左到右，每3个字母分为一组， ）假设将单词中从左到右， 个字母分为一组 并将对应的3个整数排成 维的行向量，加密后仍为3 个整数排成3维的行向量 并将对应的 个整数排成 维的行向量，加密后仍为 维的行向量，其分量仍为整数。 维的行向量，其分量仍为整数。
是事先约定的， 称为解密的钥匙 解密的钥匙， 可逆矩阵 A 是事先约定的，这个可逆矩阵 A 称为解密的钥匙， 或称为“密匙” ）．即用 或称为“密匙” ）．即用
1 −1 0 A −1 = 2 − 2 − 1 −1 1 1
从密码中恢复明码： 从密码中恢复明码：
1 −1 67 1 67 0 81 9 A−1 44 = 2 −2 −1 44 = 3 , A−1 52 = 15 43 −1 1 1 43 20 43 14
hill密码加密例题
hill密码加密例题Hill密码是一种基于线性代数的密码算法，它使用矩阵运算来进行加密和解密。
下面我将给出一个Hill密码加密的例题，并从多个角度进行全面解答。
假设我们要加密的明文是："HELLO"，并且我们选择使用2x2的密钥矩阵进行加密。
密钥矩阵可以表示为：K = [[2, 3],。
[1, 4]]现在，我们将按照Hill密码的加密步骤来进行加密：步骤1: 明文转化为数字。
首先，我们需要将明文转化为对应的数字。
通常可以使用字母表来进行映射，比如A对应0，B对应1，以此类推。
在这个例题中，我们使用A=0，B=1，C=2，...，Z=25的映射方式。
所以，"HELLO"可以转化为[7, 4, 11, 11, 14]。
步骤2: 分组。
然后，我们将数字分组，每个组的长度与密钥矩阵的行数相同。
在这个例题中，由于密钥矩阵是2x2的，所以我们将数字分组为[[7, 4], [11, 11], [14]]。
步骤3: 矩阵乘法。
接下来，我们将每个分组与密钥矩阵进行矩阵乘法运算。
对于每个分组，我们将其转化为一个行向量，并与密钥矩阵进行乘法运算。
在这个例题中，第一个分组[7, 4]与密钥矩阵K进行乘法运算，得到的结果为[2, 29]。
步骤4: 取模运算。
然后，我们对矩阵乘法的结果进行取模运算，通常取模26。
这是因为我们使用了26个字母的字母表。
在这个例题中，对于矩阵乘法的结果[2, 29]，我们进行取模26运算，得到[2, 3]。
步骤5: 数字转化为密文。
最后，我们将取模运算的结果转化为对应的字母。
在这个例题中，[2, 3]对应的字母是"C"和"D"。
所以，加密后的密文为"CD"。
综上所述，使用2x2的密钥矩阵K对明文"HELLO"进行Hill密码加密后得到的密文为"CD"。
从多个角度来看，Hill密码的加密过程涉及到了线性代数的矩阵运算，包括矩阵乘法和取模运算。
Hill密码的加密与解密_矩阵
加密过程 将明文变换成另一种不能被非授权者所
加密变换 将明文变为密文的变换
解密变换 将密文变为明文的变换
密 钥
加密变换所使用的参数
简单的加密解密过程模型
发送者 明文 加密器 密文
普 通 信 道
接收者
明文
解密器
窃听、干扰
HILL2密码
明文分组(两个一组)，按组转换成密文
同一字母在不同组中所对应密码不同
21 18 (mod 26) 15 19 18 (mod 26) 3 21 3 19 25 16 7 3
1
20 3 21 18 1 17 A (mod26) 1 15 3 19 0 9
Mathematica： Eulerphi[m]
k
故所求 x为
( m)
1 (mod m)
x a ( m )1 (mod m)
aij Z m , 矩阵模 m 可逆 设 A aij nn 为 n 阶方阵， 若存在 B bij nn , bij Z m , 使得 AB E (mod m) ，称 B 为 A 的模 m逆矩 阵，记作 B A1 (mod m)
15 18 1 19 1 23 19 8 20 21 13 18 8 12 1 19 15 20
HILL2密码的破译
关键是求得加密矩阵的逆—解密矩阵 只要分析出两个明文向量（线性无关）与 相应的密文向量
若有 b1
a1 b3 a3 A A b2 a2 b4 a4
R 18 2 A 2 S 19
hill密码算法原理
hill密码算法原理
Hill密码算法是一种基于线性代数的分组对称密码算法，它的
核心原理是将明文分成几个字母一组，然后利用矩阵乘法来实现加密和解密过程。
具体原理如下：
1. 密钥生成：选择一个正整数n，然后随机生成一个n×n的矩
阵K作为密钥矩阵。
2. 加密过程：
a. 将明文分组，每组n个字母。
如果最后一组不足n个字母，可以通过添加空格等方式补齐。
b. 将每个明文分组转换为一个列向量X，即向量X的每个元
素对应一个字母的数值，可以使用ASCII码表进行转换。
c. 对于每个明文向量X，进行矩阵乘法运算：C = K * X，其
中C为密文向量。
d. 将得到的密文向量C转换回字母形式。
3. 解密过程：
a. 将密文分组，每组n个字母。
b. 对于每个密文向量Y，进行矩阵乘法运算：X = K^-1 * Y，其中X为解密后的明文向量。
c. 将得到的明文向量X转换回字母形式。
需要注意的是，密钥矩阵K必须是可逆的，否则解密过程无
法正确进行。
同时，由于矩阵乘法运算的特性，对于某些明文分组，可能存在明文和密文相同的情况，这被称为"Hill同态"。
为了避免这种情况，通常会对字母表进行扩展或使用其他技巧进行加密。
实验报告书-Hill密码体系
实验内容：Hill n 密码体系 一 实验目的实现Hill n 密码体系的关键环节（加密、解密、破译） 二 预备知识熟悉mod 、det 、find 等Matlab 命令 三 实验内容与要求（1）假设加密矩阵为A =⎪⎪⎭⎫⎝⎛3201，用M A T L A B 编制程序，加密下面一段明文：SHUXUEJIANMOJINGSAI（2）假设加密矩阵为A =1103⎛⎫⎪⎝⎭，用M A T L A B编制程序，解密下面一段密文：AXSTZOSAOPBSTKSAN OPSAHAUUNSUUAKGAUZC K KOP D O（3）甲方截获了一段密文:BKOPGATRHMMBFC SDJC CAUU经分析这段密文是用Hill 2密码编译的,且这段密文的字母SDJC依次代表字母IJIA ，请破（4）编写通用的Hill密码软件(Matlab或C++) Shiyan.m代码function mima=shiyan(x,A)n=length(x);x2=double(x)-96;x3=reshape(x2,2,n/2);x4=A*x3;x5=mod(reshape(x4,1,n),26)+96;x5(find(x5==96))=122;mima=char(x5);sy2.m代码：function mingwen=sy2(x,A)n=length(x);x2=double(x)-96;x3=reshape(x2,2,n/2);a=floor(det(A));aa=qiumoni(a);A_inv=mod(aa*det(A)*inv(A),26);x4=A_inv*x3;x5=mod(reshape(x4,1,n),26)+96;x5(find(x5==96))=122;mingwen=char(x5);qiumoni代码：function aa=qiumoni(a)a=a;aa=0;for i=1:25if mod(a*i,26)==1aa=i;breakendendif aa==0disp('没有该模的逆')endsy3.m代码：function A=sy3(a1,a2)C=reshape(double(a1)-96,2,2);P=reshape(double(a2)-96,2,2);c=mod(det(C),26);cc=qiumoni(c);%qiumoni请参见（2）C_inv=mod(cc*det(C)*inv(C),26);A=mod(P*C_inv,26)%使用说明：%先建立Shiyan.m、sy2.m、qiumoni.m、sy3.m三个M文件%1、进行加密操作：% 将加密的内容写在“x=’’”中的单引号中，将加密矩阵写在“A=’’”的单引号中，接着%输入“mima=shiyan(x,A)”即可得到密文。
线性代数实验题09_Hill加密算法
实验题：应用矩阵编制Hill 密码（线性变换与矩阵求逆应用）密码学中将信息代码称为密码，尚未转换成密码的文字信息称为明文，由密码表示的信息称为密文。
从明文到密文的过程称为加密，反之为解密。
1929年，希尔（Hill ）通过线性变换对待传输信息进行加密处理，提出了在密码史上有重要地位的希尔加密算法。
如果我们假定每个字母都对应一个非负整数，空格和26个英文字母依次对应整数0~26。
表1：空格及字母的整数代码表希尔加密算法的思想是：每次将s 个明文字母通过线性变换转换为s 个密文字母，密钥为变换矩阵本身。
解密只需要作一次逆变换。
设s 个明文字母为⎪⎪⎪⎪⎪⎭⎫ ⎝⎛=s m m m M 21， s 个密文字母为⎪⎪⎪⎪⎪⎭⎫ ⎝⎛=s c c c C 21，线性变换矩阵⎪⎪⎪⎪⎪⎭⎫⎝⎛=ss s s s s k k k k k k k k k K 212222111211则加密过程可描述为⎪⎪⎩⎪⎪⎨⎧+++=+++=+++=)(mod )(mod )(mod 22112222121212121111n m k m k m k c n m k m k m k c n m k m k m k c sss s s l s s ss或者写成)(mod n KM C ≡，这里显然取27=n 。
如果变换矩阵K 在27mod 的意义下可逆，则解密过程只需要两边同时乘以1-K ，即)(mod 1n C K M -≡。
注意：矩阵K 在实数域上可逆与矩阵K 在27mod 的意义下可逆的概念有所不同，矩阵K 在实数域上可逆的充要条件是K 的行列式0det ≠K ；而矩阵K 在27mod 的意义下可逆的充要条件是K 的行列式除了满足0det ≠K ，且行列式值与27没有公因数，即K det 中不含因子3。
在27mod 的意义下，1271+⋅=⋅-k a a 。
根据所提供的MATLAB 程序hill_com.m ，作如下工作：（1）请完成程序的每一个注解（程序中%后的内容），以解释某行程序或某循环体的功能；（2）构造一个3阶变换矩阵K ，使它在27mod 的意义下可逆；（3）自行输入的一段文字信息，用（2）构造的矩阵进行加密、解密处理，分别输出加密后的密文和解密后的明文。
矩阵的应用举例Hill密码的编制
1 明文向量：
U V W X 字母 O P Q R S T A 密 表值 文：49,22,7,3,23,1,30,5 1 2 3 4 5 利用 6 7 i 8 i 9 10 表值 15 16 17 18 19 20 21 22 1 23 2 24 A O P Q R S T U V W X 解 字母 密：求加密矩阵的逆矩阵，得解密矩阵 0 1 5 1 21 20 , 21 18 19 22 表值 15 16 2217 , 3 , 20 5 23 24 明文向量： 1
密码学（cryptography）源于希腊文字（秘密＋书写）， 是研究如何隐密地传递信息的一门古老而神秘的学科。
自然密码的鼻祖是凯撒密码。 恺撒密码：是古罗马恺撒大帝用来保护重要 军情的加密系统。它是一种代换密码，通过 将字母按顺序推后3位起到加密作用。 明文:Evacuate(撤退) 密文：Hydfxdwh
全国高校数学微课程教学设计竞赛
明
3. 应用矩阵编制Hill密码 文：Evacuate(撤退) 分 组：Ev ac ua te
5 1 21 20 将明文字母依次按两两一组查出 , , , 2 3 4 22 3 1 5 其表值，得到一组二维向量. 1 2 A B C D E F G H I J K L M N 字母 左乘一加密矩阵 A 0 1 加 密： 75 23 2 493 4 6 7 , 8 30 9 . 10 11 12 13 14 表值 1 , , 2D E 3F G 4 密文向量： C H I J K L M N 字母 A 1 B 22 3 1 5
2x2 hill密码的实验原理
2x2 hill密码的实验原理
2x2 Hill 密码是一种基于矩阵运算的加密算法，它利用线性代数的原理对明文进行加密，从而保护通信数据的安全性。
具体实验原理如下：
1. 生成密钥矩阵：在2x2 Hill 密码中，密钥矩阵是一个2x2 的矩阵，其中每个元素都是不大于26 的正整数。
密钥矩阵可以由发送方随机生成或者事先共享给接收方。
2. 明文加密：明文可以是一个长度为2 的字母组合，例如AB、CD 等。
发送方在加密明文时，将明文转换为一个向量（2x1 的矩阵），然后将密钥矩阵与明文向量相乘，得到密文向量。
3. 密文传输：发送方将密文向量传输给接收方，接收方将其保存下来。
4. 密文解密：接收方在解密密文时，将密文向量与密钥矩阵的逆矩阵相乘，得到明文向量。
然后，将明文向量转换为明文，即完成解密过程。
总的来说，2x2 Hill 密码的加密和解密过程都是基于矩阵运算的。
发送方将明文向量与密钥矩阵相乘得到密文向量，接收方将密文向量与
密钥矩阵的逆矩阵相乘得到明文向量，从而完成解密过程。
实验中需要注意的是，密钥矩阵的生成和保存必须安全可靠，否则会影响到整个加密算法的安全性。
Hill密码
Hill 密码1. 原理介绍希尔密码（Hill Cipher）是运⽤基本矩阵论原理的代替密码技术，由 Lester S. Hill 在 1929 年发明，26 个英⽂字母可表⽰成 0 ~ 25 的数字，将明⽂转化成 n 维向量，与⼀个 n × n 矩阵相乘后，得到的结果模 26，即可得到密⽂对应的值假设对明⽂ act 加密：a 为 0，b 为 1，t 为 19，对其进⾏向量化得到 M =[0,2,19]T 。
选取 3 × 3 阶矩阵密钥：6241131610201715加密过程如下：6241131610201715×0219=67222319=15147mod 26得到的密⽂为 pob解密时，必须先算出密钥的逆矩阵，再根据加密的过程做逆运算2. 矩阵求逆对于矩阵求逆，常见的有 伴随矩阵 和 ⾏变换 两种⽅法，不过需要注意的是，此处的逆矩阵为模 26 的逆矩阵，也就是所⾥⾯所有的运算（加减乘除）都是在模 26 下的运算2.1 利⽤伴随矩阵⼀个 n ×n 矩阵 A ，A 的逆矩阵 A −1 为 1d ⋅(C A )T 。
其中 d 是矩阵 A 的⾏列式，C A 是 A 的伴随矩阵，(C A )T 是 C A 的转置矩阵在求伴随矩阵的转置 (C A )T 的过程中，只使⽤了乘法与加减法运算， 并未使⽤特殊的除法运算，故算法过程与对⼀般矩阵求 (C A )T ⽆异，区别只在于每次运算时都需要模 26在求矩阵⾏列式 d 的时候，若是采⽤余⼦式法，则也与⼀般矩阵⽆异。
最后使⽤ 扩展欧⼏⾥得 算法判断逆元的存在性：若不存在逆元，则矩阵在模 26 条件下不可逆；若存在逆元，则结合上述求解出的 (C A )T 可计算出 A −12.2 利⽤⾼斯⾏变换(1) 先不考虑模 26 的条件根据求伴随矩阵的过程，有 A −1=1d ⋅(C A )T ，那么 (C A )T =dA −1。
HILL密码——密码学
Hill 密码Hill 体制是1929年由Lester S.Hill 发明的，它实际上就是利用了我们熟知的线性变换方法，是在26Z 上进行的。
Hill 体制的基本思想是将n 个明文字母通过线性变换转化为n 个密文字母，解密时只需做一次逆变换即可，密钥就是变换矩阵。
设明文n n Z m m m m 2621),,(∈⋯+=,密文n n Z c c c c 2621),,.,(∈⋯=，密钥为26Z 上的n n ⨯阶可逆方阵n n ij k K ⨯=)(，则26mod 26mod 1-==cK m mK c 解密：明文加密：密文具体过程：1、 假设要加密的明文是由26个字母组成，其他字符省略。
2、 将每个字符与0-25的一个数字一一对应起来。
（例如：a/A —0，b/B —1，……z/Z —25）。
3、 选择一个加密矩阵n n A ⨯，其中矩阵A 必须是可逆矩阵，例如⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=15227132102123916296101571823055117A 4、 将明文字母分别依照次序每n 个一组（如果最后一组不足n 个的话，就将其补成n个），依照字符与数字的对应关系得到明文矩阵ming n n len ⨯/。
5、 通过加密矩阵A ，利用矩阵乘法得到密文矩阵mi n n len ⨯/= ming n n len ⨯/⨯n n A ⨯mod 26；6、 将密文矩阵的数字与字符对应起来，得到密文。
7、 解密时利用加密矩阵的逆矩阵1-A 和密文，可得到明文。
实例 随机产生一个5阶加密方阵⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=15227132102123916296101571823055117A得到方阵A 的逆矩阵⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎣⎡=-9131341212252318151920391211824723102141871A加密过程：输入明文：Hill cipher is one of my favorite cipher分组：Hillc ipher isone ofmyf avori tecip her(aa)加密得到密文：SKSXAQERQQYDVDGBKNVSMWZATGIAPDOJBIO解密过程：输入密文：SKSXAQERQQYDVDGBKNVSMWZATGIAPDOJBIO解密得到密文：HILLCIPHERISONEOFMYFA VORITECIPHERAA代码部分：#include <iostream>#include <string>#include <math.h>#include <stdlib.h>using namespace std;int A[1000][1000];//转化矩阵int a[1000][1000];//[A E]int B[1000][1000];//A^(-1)int ming[1000][1000];//明文矩阵int mi[1000][1000];//密文矩阵int n;//矩阵的阶数void input()//输入数据{int i, j;//cout << "请输入矩阵的元素" << endl;for( i = 1; i <= n; i++ )for( j = 1; j <= n; j++ )//cin >> A[i][j];A[i][j] = rand() % 26;memcpy( a, A, sizeof( A ) );//将矩阵A 复制给afor( i = 1; i <= n; i++ )//将矩阵变成[a E]的形式，E 为单位矩阵{for( j = n + 1; j <= 2*n; j++ ){if( i + n == j )a[i][j] = 1;elsea[i][j] = 0;}}}void output(){int i,j;cout << "矩阵阶数:" << n <<endl;cout << "矩阵A的元素:" << endl;for( i = 1; i <= n; i++ ){for( j = 1; j <= n; j++ )cout << A[i][j] << " ";cout << endl;}cout << "A矩阵的逆矩阵B为" << endl;for( i = 1; i <= n; i++ )//输出A矩阵的逆矩阵B{for( j = 1; j <= n; j++ ){B[i][j] = a[i][j+n];cout << B[i][j] << " ";}cout << endl;}}int Extend_Gcd( int a, int b, int &x, int &y )//扩展欧几里得算法{if( b == 0 ){x = 1;y = 0;return a;}int r = Extend_Gcd( b, a % b, x, y ); //a'=b;b'=a%b; a'x + b'y <=> bx + (a-a/b*b)y <=> ay + b(x-a/b*y)int t = x;x = y;y = t - a / b * y;return r;}int ni( int a)//求逆a*x=1(mod n){int x, y;int d = Extend_Gcd( a, 26, x, y );if( d == 1 )return ( x % 26 + 26 ) % 26;elsereturn -1;}int gaosi()//高斯-约当消元求A矩阵的逆矩阵B{int i, j, k;for( k = 1; k <= n; k++ )//高斯-约当消元{int Ni = ni( a[k][k] );if( Ni == -1 ) return 0;//cout << Ni << endl;for( i = k + 1; i <= 2 * n; i++ )a[k][i] = ( a[k][i] * Ni % 26 + 26 ) % 26;for( i = 1; i <= n; i++ ){if( i == k ) continue;for( j = k + 1; j <= 2 * n; j++ )a[i][j] = ( ( a[i][j] - a[i][k] * a[k][j] % 26 ) % 26 + 26 ) % 26;}}return 1;}void jiami() //加密过程{int i, j, k;char mingstr[100];char mingc;cout << "请输入明文" << endl;cin >> mingstr;//getchar();//gets( mingstr );int len = strlen( mingstr );if( len % n ){for( i = len; i < len/n*n+n; i++)mingstr[i] = 'a';mingstr[i] = '\0';}puts( mingstr );int Len = strlen( mingstr );cout << "字符串长度:" << Len << endl;for( i = 1; i <= Len/n; i++ )//将明文分成len/n段{for( j = 1; j <= n; j++ )//求每一段的明文转换为矩阵{if( mingstr[(i-1)*n+j-1] >= 'a' && mingstr[(i-1)*n+j-1] <= 'z' )ming[i][j] = mingstr[(i-1)*n+j-1] - 'a';elseming[i][j] = mingstr[(i-1)*n+j-1] - 'A';//cout << ming[i][j] << " ";}//cout << endl;}for( k = 1; k <= Len/n; k++ )//求len/n段的密文矩阵{for( i = 1; i <= n; i++ )//利用矩阵的乘法{mi[k][i] = 0;for( j = 1; j <= n; j++ )mi[k][i] = ( mi[k][i] + ming[k][j] * A[j][i] % 26 + 26 ) % 26;//cout << mi[k][i] << endl;}}cout << "密文为" << endl;for( i = 1; i <= Len/n; i++ )//输出密文{for( j = 1; j <= n; j++ ){mingc = mi[i][j] + 'A';cout << mingc;}}cout << endl;}void jiemi()//解密过程{int i, j, k;char mistr[100];char mingc;cout << "请输入密文" << endl;cin >> mistr;//getchar();//gets( mistr );//puts( mistr );int len = strlen( mistr );for( i = 1; i <= len/n; i++ )//将密文分成len/n段{for( j = 1; j <= n; j++ )//求每一段的密文转换为矩阵{if( mistr[(i-1)*n+j-1] >= 'a' && mistr[(i-1)*n+j-1] <= 'z' )mi[i][j] = mistr[(i-1)*n+j-1] - 'a';elsemi[i][j] = mistr[(i-1)*n+j-1] - 'A';}}for( k = 1; k <= len/n; k++ )//求len/n段的明文矩阵{for( i = 1; i <= n; i++ )//利用矩阵的乘法{ming[k][i] = 0;for( j = 1; j <= n; j++ )ming[k][i] = ( ming[k][i] + mi[k][j] * B[j][i] % 26 + 26 ) % 26;// cout << mi[i] << endl;}}cout << "明文为" << endl;for( i = 1; i <= len/n; i++ )//输出明文{for( j = 1; j <= n; j++ ){mingc = ming[i][j] + 'A';cout << mingc;}}cout << endl;}int main(){bool flag = 1;cout << "欢迎使用Hill体制进行加解密！" << endl;while( flag ){cout << "请输入加密矩阵的阶数n:";cin >> n;do{input();//数据输入}while( !gaosi() );output();//gaosi();//用高斯-约当消元求矩阵A%26的逆Bjiami();//加密过程jiemi();//解密过程cout << "是否继续加密解密？1：继续，0：否" << endl;cin >> flag;}return 0;}/*abcdefghijklmnopqrstuvwxyz*/。
hill密码算法
hill密码算法Hill密码算法是一种经典的密码算法，它采用矩阵运算来加密和解密数据。
该算法由美国数学家莱斯利·萨蒙·希尔于1929年发明，被广泛应用于信息安全领域。
在现代密码学中，Hill密码算法被认为是一种较为简单且易于实现的对称加密算法。
Hill密码算法的加密过程包括选择一个适当大小的密钥矩阵，将明文数据分组，并通过矩阵运算来对每个数据组进行加密。
解密过程则是通过逆矩阵运算来还原明文数据。
该算法的安全性取决于密钥矩阵的选取以及矩阵运算的复杂度。
然而，虽然Hill密码算法在理论上是安全的，但实际应用中存在一些缺陷。
首先，密钥矩阵的选择必须是非退化的，并且需要确保密钥矩阵的逆矩阵存在。
这就限制了Hill密码算法的密钥空间，使其容易受到穷举搜索等攻击。
此外，由于矩阵运算涉及到大量的数学计算，Hill密码算法在效率上存在一定的问题。
近年来，随着量子计算及深度学习等技术的发展，Hill密码算法的安全性也受到挑战。
量子计算可以在较短的时间内破解复杂度较高的矩阵运算，从而影响Hill密码算法的安全性。
同时，深度学习技术可以通过学习大量的数据样本来破译Hill密码算法所使用的密钥矩阵，使得该算法的加密效果变得不再可靠。
为了提高Hill密码算法的安全性，可以采取一些增强措施。
例如，可以结合其他加密算法来增加密码强度，或者采用更加复杂的矩阵运算方法来加密数据。
此外，定期更换密钥矩阵、增加密钥长度等方式也可以有效提升Hill密码算法的安全性。
梳理一下本文的重点，我们可以发现，Hill密码算法作为一种经典的密码算法，具有一定的加密效果和应用前景。
然而，在实际应用中需要注意该算法存在的一些安全风险，并采取相应的措施来提高其安全性。
希望未来能够通过技术的不断创新和发展，进一步加强Hill密码算法的安全性，使其更加适用于信息安全领域。
矩阵模运算与古典密码 Hill2 加密解密
模 m 可逆
问题：是否 Zm 中所有的数都存在模 m 倒数？
a 存在唯一的模 m 倒数
a 与 m 无公共素数因子
命题：定义在集合 Zm 上的 n 阶方阵 A 模 m 可逆的充要条 件是：m 和 det(A) 无公共素数因子，即 m 与 det(A) 互素。
Hill2 密码的加密矩阵必须满足上述条件。
AB BA E(mod m) 则称 A 模 m 可逆， B 为 A 的 模 m 逆矩阵，记为
B A1(mod m)
定义 2：设 a Zm ，若存在 b Zm 使得 ab=1 (mod m) ，则
称 b 为 a 的 模 m 倒数 或乘法逆，记作 b = a-1 (mod m) 。
注: a , b 都是 Zm 中的数
16 12
(mod
26)
16 12
,
67 72
(mod
26)
15 20
,
27 12
(mod
26)
1 12
72 72
(mod
26)
20 20
.
9
Hill2 加密举例
反查字母表值得每个向量对应的字母组为：
16
12
,
1 12
,
15
18
Hill2 解密过程
设加密矩阵
A
1 0
2 3
| A | 3,
A
3 0
2
1
A1 (mod
26)
31
(mod
26)
3 0
2 1
(mod
26)
B A1(mod 26)
9
3 0
2
1
(mod
26)
矩阵方程 希尔密码
矩阵方程希尔密码
希尔密码（Hill Cipher）是一种使用矩阵运算的对称加密算法。
它是基于线性代数的原理，通过将明文分块并使用矩阵乘法进行加密。
希尔密码的基本原理可以用矩阵方程表示。
设明文块为P，密文块为C，密钥矩阵为K，则希尔密码的加密过程可以用以下矩阵方程表示：
C≡K⋅P(mod26)
其中，(mod26) 表示结果对26取模，因为通常希尔密码被应用于26个字母的英文明文。
每个字母对应一个数值，比如A对应0，B 对应1，以此类推，Z对应25。
解释上述方程的步骤如下：
1将明文块P 按照字母和矩阵的对应关系转换为数值形式。
2将密钥矩阵K 与明文块矩阵相乘，得到加密后的矩阵。
3将加密后的矩阵转换回字母形式，即得到密文块C。
需要注意的是，矩阵K 必须是可逆的，并且其行列式模26不得为0。
否则，解密将会受到影响。
希尔密码的强度取决于矩阵的大小和选择，以及密钥的保密性。
然而，对于大多数简单的希尔密码，由于其线性性质，可能容易受到密码分析攻击。
因此，在实际应用中，可能会采用改进版的希尔密码或与其他技术结合使用以增强安全性。
古典密码-希尔密码Hill
古典密码-希尔密码Hill本⽂⽬的在于整合了⽹上的Hill Cipher 原理、解密及算法实现⼤部分均为转载，可以链接到原⽂地址查看，这⾥只是整合⽂章简介以下直接搬运原⽂，便于查看，也可以直接链接到原⽂地址查看ctf-wiki-Hill希尔密码（Hill ）使⽤每个字母在字母表中的顺序作为其对应的数字，即 A=0，B=1，C=2 等，然后将明⽂转化为 n 维向量，跟⼀个 n × n 的矩阵相乘，再将得出的结果模 26。
注意⽤作加密的矩阵（即密匙）在 Zn26Z26n 必须是可逆的，否则就不可能解码。
只有矩阵的⾏列式和 26 互质，才是可逆的。
下⾯举⼀个例⼦明⽂：ACT将明⽂化为矩阵。
219假设密钥为：6241131610201715加密过程为：62411316102017150219≡67222319mod 26密⽂即为密⽂：POH -Hill该⽹站详细地介绍了Hill 密码，包括历史、运⽤等等但是在线的脚本只能⽀持 2 × 2 矩阵Decrypto在线⽹页C 语⾔实现解密算法相关题⽬ISCC 2015 base decrypt 150这⾥我们以 ISCC 2015 base decrypt 150 为例进⾏介绍，题⽬为密⽂： 22,09,00,12,03,01,10,03,04,08,01,17 （wjamdbkdeibr ）使⽤的矩阵是 1 2 3 4 5 6 7 8 10请对密⽂解密.⾸先，矩阵是 3 × 3 的。
说明每次加密 3 个字符。
我们直接使⽤ Cryptool ，需要注意的是，这个矩阵是按照列来排布的。
即如下1 4 72 5 83 6 10参考WP ：最后的结果为 overthehillx 。
[][][][][]Processing math: 100%。
矩阵编制Hill密码
矩阵编制Hill密码密码学在经济和军事方面起着极其重要的作用. 现代密码学涉及很多高深的数学知识. 这里无法展开介绍.图29 保密通信的基本模型密码学中将信息代码称为密码, 尚未转换成密码的文字信息称为明文, 由密码表示的信息称为密文. 从明文到密文的过程称为加密, 反之为解密. 1929年, 希尔(Hill)通过线性变换对待传输信息进行加密处理, 提出了在密码史上有重要地位的希尔加密算法. 下面我们略去一些实际应用中的细节, 只介绍最基本的思想.【模型准备】若要发出信息action, 现需要利用矩阵乘法给出加密方法和加密后得到的密文, 并给出相应的解密方法.【模型假设】(1) 假定每个字母都对应一个非负整数, 空格和26个英文字母依次对应整数0~26(见下表).(2) 假设将单词中从左到右, 每3个字母分为一组, 并将对应的3个整数排成3维的行向量, 加密后仍为3维的行向量, 其分量仍为整数.【模型建立】设3维向量x为明文, 要选一个矩阵A使密文y= xA, 还要确保接收方能由y准确地解出x. 因此A必须是一个3阶可逆矩阵. 这样就可以由y = xA 得x = yA-1. 为了避免小数引起误差, 并且确保y也是整数向量, A和A-1的元素应该都是整数. 注意到, 当整数矩阵A的行列式= ±1时, A-1也是整数矩阵. 因此原问题转化为(1) 把action翻译成两个行向量: x1, x2.(2) 构造一个行列式= ±1的整数矩阵A(当然不能取A = E).(3) 计算x1A和x2A.(4) 计算A-1.【模型求解】(1) 由上述假设可见x1 = (1, 3, 20), x2 = (9, 15, 14).(2) 对3阶单位矩阵E =100010001⎛⎫⎪⎪⎝⎭进行几次适当的初等变换(比如把某一行的整数被加到另一行, 或交换某两行), 根据行列式的性质可知, 这样得到的矩阵A的行列式为1或-1. 例如A =110211322⎛⎫⎪⎪⎝⎭, |A| = -1.(3) y1 = x1A = (1, 3, 20)110211322⎛⎫⎪⎪⎝⎭= (67, 44, 43),y2 = Ax2 = (9, 15, 14)110211322⎛⎫⎪⎪⎝⎭= (81, 52, 43).(4) 由(A, E) =110100211010322001⎛⎫⎪⎪⎝⎭−−−−→初等行变换100021010121001111-⎛⎫⎪-⎪--⎝⎭可得A-1 =021121111-⎛⎫⎪-⎪--⎝⎭.这就是说, 接收方收到的密文是67, 44, 43, 81, 52, 43. 要还原成明文, 只要计算(67, 44, 43)A-1和(81, 52, 43)A-1, 再对照表9“翻译”成单词即可.【模型分析】如果要发送一个英文句子, 在不记标点符号的情况下, 我们仍然可以把句子(含空格)从左到右每3个字符分为一组(最后不足3个字母时用空格补上).【模型检验】(67, 44, 43) A-1 = (1, 3, 20), (81, 52, 43)A-1 = (9, 15, 14).参考文献杨威, 高淑萍, 线性代数机算与应用指导, 西安: 西安电子科技大学出版社, 2009. 页码: 98-102.Matlab实验题按照上面的加密方法, 设密文为: 112, 76, 57, 51, 38, 18, 84, 49, 49, 68, 41, 32, 83, 55, 37, 70, 45, 25, 问恢复为原来的信息是什么?。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
矩阵编制Hill密码
密码学在经济和军事方面起着极其重要的作用. 现代密码学涉及很多高深的数学知识. 这里无法展开介绍.
图29 保密通信的基本模型
密码学中将信息代码称为密码, 尚未转换成密码的文字信息称为明文, 由密码表示的信息称为密文. 从明文到密文的过程称为加密, 反之为解密. 1929年, 希尔(Hill)通过线性变换对待传输信息进行加密处理, 提出了在密码史上有重要地位的希尔加密算法. 下面我们略去一些实际应用中的细节, 只介绍最基本的思想.
【模型准备】若要发出信息action,现需要利用矩阵乘法给出加密方法和加密后得到的密文, 并给出相应的解密方法.
【模型假设】(1) 假定每个字母都对应一个非负整数, 空格和26个英文字母依次对应整数0~26(见下表).
(2)假设将单词中从左到右, 每3个字母分为一组, 并将对应的3个整数排成3维的行向量, 加密后仍为3维的行向量, 其分量仍为整数.
【模型建立】设3维向量x为明文, 要选一个矩阵A使密文y= xA, 还要确保接收方能由y准确地解出x. 因此A必须是一个3阶可逆矩阵. 这样就可以由y = xA 得x = yA-1. 为了避免小数引起误差, 并且确保y也是整数向量, A和A-1的元素应该都是整数. 注意到, 当整数矩阵A的行列式= ±1时, A-1也是整数矩阵. 因此原问题转化为
(1) 把action翻译成两个行向量: x1, x2.
(2) 构造一个行列式= ±1的整数矩阵A(当然不能取A = E).
(3) 计算x1A和x2A.
(4) 计算A-1.
【模型求解】(1) 由上述假设可见x1 = (1, 3, 20), x2 = (9, 15, 14).
(2) 对3阶单位矩阵E =
100
010
001
⎛⎫
⎪
⎪
⎝⎭
进行几次适当的初等变换(比如把某一行的
整数被加到另一行, 或交换某两行), 根据行列式的性质可知, 这样得到的矩阵A
的行列式为1或-1. 例如A =
110
211
322
⎛⎫
⎪
⎪
⎝⎭
, |A| = -1.
(3) y1 =x1A = (1, 3, 20)
110
211
322
⎛⎫
⎪
⎪
⎝⎭
= (67, 44, 43),
y2 =Ax2 = (9, 15, 14)
110
211
322
⎛⎫
⎪
⎪
⎝⎭
= (81, 52, 43).
(4) 由(A, E) =
110100
211010
322001
⎛⎫
⎪
⎪
⎝⎭
−−−−→
初等行变换
100021
010121
001111
-
⎛⎫
⎪
-
⎪
--
⎝⎭
可得A-1=
021
121
111
-
⎛⎫
⎪
-
⎪
--
⎝⎭
.
这就是说, 接收方收到的密文是67, 44, 43, 81, 52, 43. 要还原成明文, 只要计算(67, 44, 43)A-1和(81, 52, 43)A-1,再对照表9“翻译”成单词即可.
【模型分析】如果要发送一个英文句子, 在不记标点符号的情况下, 我们仍然可以把句子(含空格)从左到右每3个字符分为一组(最后不足3个字母时用空格补上).
【模型检验】(67, 44, 43)A-1=(1, 3, 20), (81, 52, 43)A-1 = (9, 15, 14).
参考文献
杨威,高淑萍, 线性代数机算与应用指导,西安: 西安电子科技大学出版社, 2009. 页码: 98-102.
Matlab实验题
按照上面的加密方法, 设密文为: 112, 76, 57, 51, 38, 18, 84, 49, 49, 68, 41, 32, 83, 55, 37, 70, 45, 25,问恢复为原来的信息是什么?。