实验四 Hill密码

合集下载

希尔密码[精华]

希尔密码(Hill Cipher)简介: 希尔密码是基于矩阵的线性变换, 希尔密码相对于前面介绍的移位密码以及放射密码而言, 其最大的好处就是隐藏了字符的频率信息, 使得传统的通过字频来破译密文的方法失效.安全性: 希尔密码不是足够安全的, 如今已被证实, 关于希尔密码的破解不在本文范围内, 有兴趣的朋友可以研读相关书籍以了解相关破译方法.希尔密码所需要掌握的前置知识:1) 线性代数基础知识.2) 初等数论基础知识.坦白来说, 大部分密码学都要用到线性代数以及初等数论中的知识, 所以我希望大家可以自行找来相关书籍完成基础知识的学习, 所以关于什么是矩阵,什么是单位矩阵我不打算细讲. 在希尔密码中, 具体的话, 会涉及到矩阵的运算, 及其初等变化等.约定:1) 希尔密码常使用Z26字母表, 在此贴中, 我们也以Z26最为字母表进行讲解.在附带源码中有两种字母表选择.2) 大家都知道最小的质数是2, 1 既不是质数也不是合数. 在此我们定义1对任何质数的模逆为其本身.因为对于任意质数n, 有: 1*1 % n = 1 的. 也应该是很好理解的.相关概念:线性代数中的逆矩阵: 在线性代数中, 大家都知道,对于一个n阶矩阵M , 如果存在一个n阶矩阵N ,使得M * N = E (其中:E为n阶单位矩阵), 则称矩阵N 为矩阵M 的逆矩阵, 并记为M^-1.比如2阶矩阵M = [3,6] , 则很容易得知其逆矩阵:[2,7]M^-1 = [7/9, -2/3][-2/9, 1/3] .关于这个逆矩阵是如何计算出的, 通常的有两种方法:一是使用伴随矩阵, 通过计算行列式得到. 所用公式为: M^-1 = M^* / D . (其中M^*为M 的伴随矩阵, D为M的行列式的值)二是通过增广矩阵, 在M右侧附加一个n阶单位矩阵, 再通过初等变换将增广矩阵的左侧变换为一个n阶单位矩阵, 这时右侧便是所求的逆矩阵.希尔密码原理:加密者在对明文加密前会选择一个加密秘匙, 这个秘匙最终会以一个m矩阵的形式参与到加密算法中的. 在加密者选定了加密秘匙后, m便得到了确定,这时,加密者将明文按m个字母一组的形式分成多组, 最后一组不足m个字母的按特定的方式补齐. 这样就形成了很多组由m个字母组成的单个向量, 然后对每一个m阶向量, 我们用它去乘以确定好了的秘匙.如下为其中的一个分组A向量加密后变为B向量的过程:[A1,A2,A3 ... Am] * M = [B1,B2,B3 ... Bm] .我们将所有相乘后的向量连在一起, 便得到了密文. 这便是希尔密码的加密.加密是非常简单的, 我们接下来来看一下解密部分, 解密部分要比加密部分稍微复杂一点点.上面我们提到了矩阵的逆矩阵. 大家可能会想, 既然明文A向量乘以秘匙M矩阵就得到了密文B向量, 那么我们将B向量乘以M的逆矩阵, 不就可以得到A了吗?大家的想法不错, 但是请注意:我们上面的那个例子矩阵[3,6]的逆矩阵为[7/9, -2/3] , 发现了吧, 我们如果硬是去按常规方法计算M的逆矩阵的话, 你得到的[2,7] [-2/9, 1/3]很可能是一个含有分式的矩阵. 这显然是不符合要求的.(为什么? )__asm{cmp you, "想知道为什么"jnz @F]有的人会说,就算有分式又怎么样? 虽然分式在计算机中以浮点数体现, 但我还是让B乘以这个浮点数表示的M^1, 然后对结果进行四舍五入, 不久OK了? 不错这样是可以达到效果. 但是! 有以下几个缺点:1): 平白无辜的扯到了浮点运算, 还要进行四舍五入, 降低了算法效率使其看起来相当愚蠢.2): 解密秘匙体现的局限性, 其实是这个意思: 假如现在为二战时期, 我们需要派一位特工在盟军的两个司令部之间传达密钥. 而且规定密钥只能以A~Z这26个字母的形式体现. 也即你的秘匙只能是字母构成的, 接受方得到秘匙后按照Z26表对应将A当作0,B当作1,... Z当作25 来翻译, 然后解密. 这种情况下, 上面的分式就不好表示了. 当然在真实情况下, 密钥是怎么个传输法, 那还要区别对待.于是, 我们想对于一个矩阵能否有另外一种的逆使得其各元素皆为Z26范围中的元素同时可以顺利地完成解密了? 当然有.方法一: 最小公倍数法这种方法是在前面的矩阵逆的基础上来做文章的. 如下.我们接着上面那个带分式的M^-1来说, 大家观察一下, 很容易知道, 其中的分母9 其实为原矩阵M的行列式值: 9 = 3*7 - 2*6;那我们将M^-1乘以9, 不就可以消掉分母了吗? 呵呵. 不行的.我们要想消掉分母, 肯定得乘以一个数, 那到底要乘以多少了. 这里因为我们是Z26的字母表. 我们要保证乘以一个数之后, 原来的明文字母所增大的部分一定得是26的整数倍. 也即如下第一步:设a为明文中的一个字母. x 为需要对当前的M^-1乘以的倍数. t为任意整数.ax = a + 26t. 恒成立. ==>> t = a(x-1)/26 .要想t为整数, 则x = 26p+1 .p >=1. 这里我们一般取p =1 即可. 因此x = 27.(及字母表个数加一)第二步:要消掉分母, 我们必须乘以分母D(M)的倍数. 其中D(M)为M的行列式值.得结果:所求x = 最小公倍数( 27, D(M) ) .具体到上例中, x = 最小公倍数(27,9) = 27.我们将上面的M^-1 乘以27 得到: [21, -18][-6, 9 ]到了这一步, 我们得到了含负数的希尔逆矩阵.(注意: 从这里开始我们区别对待两种逆矩阵).而负数还是不能用Z26中的字母表示, 怎么办? 没关系, 对于负数我们加上26即可. 因为我们加上的是26,所以对于最终的取模是没有影响的. 因此我们得到:希尔逆矩阵M^-1 = [21,8][20,9]方法二:纯整数初等变化法(这个名字和上面那个最小公倍数法都是我自己想出来的名字, 可能不好听. 呵呵.)这一种方法的思想就是元素的模逆. 因为我们这里是Z26, 我们不关心元素的实际大小, 只关心它对26取模后的数值.因此, 在对原矩阵M求逆时, 我们先将M变为增广矩阵A, 再对A的每一列进行循环, 在第j列中, 从第j行开始, 每个元素遍历, 依次检查是否对26存在模逆. 否的话, 检查下一个, 是的话,乘以其模逆, 于是该元素结果得1, 再得到其行数为i ,将此行与第j行互换(目的就是为了形成对角线的n个1), 然后对余下的行, 用此行乘以余下行的第j个元素的值去依次减余下的行,这样就使得当前第j列的n-1个0得以生成. 如果某列一直检查下去都没有元素存在模逆的话, 则该矩阵M不存在希尔逆矩阵.文字有时还是不如代码好说话, 看代码吧:(这次的希尔密码辅助软件,我使用的是C#.我嫌用C弄一些框框太麻烦,所以选择了简单的C#,弄一些框框是为了看中间过程.同时, 也能布置大家一个作业: 即读懂附件中的C#代码, 用C或C++重写之. 呵呵, 我想未装.NET Framework的非Vista朋友如果为了使用附件中的bin的话, 还是得自己用其他语言重写一边的吧//检查元素a是否对n存在模逆代码:public bool CheckReverse(int a){int n = (int)zt;int p = 2;while(p*p<n){if (a%p == n%p && 0 == a%p){return false;}p++;}//when a equals with 1 , it's also reversiablereturn true;}//得到元素a对n的模逆代码:public int GetReverse(int a){int n = (int)zt;int q, p, t;int x = 0, y = 1, z;q = n;p = a;z = (int)q / p;while (1 != p && 1 != q) {t = p;p = q % p;q = t;t = y;y = x - y * z;x = t;z = (int)q / p;}y = y % n;if (y < 0){y += n;}//when a equals with 1 , it return 1. return y;}//使用纯整数初等变换法计算M的希尔逆矩阵.代码:public bool Calc_M_1(){int[,] A = new int[nRank, nRank * 2]; int[] T = new int[nRank*2];int i,j,k;//construct the [M|E] matrix Afor (i = 0; i < nRank;++i){for (j = 0; j < nRank * 2;++j){if (j<nRank){A[i, j] = nMatrix[i, j]; }else{if (nRank == j-i){A[i, j] = 1;}else{A[i, j] = 0;}}}}//begin to metamorphose Aint a_1 = 0;for (j = 0; j < nRank;++j){//step1: get one reversiable element for (i = j; i < nRank /*+ 1*/; ++i){if (CheckReverse(A[i,j])){a_1 = GetReverse(A[i, j]);for (k = 0; k < nRank * 2;++k) {A[i, k] *= a_1;A[i, k] %= (int)zt;T[k] = A[i, k];A[i, k] = A[j, k];A[j, k] = T[k];}goto step2;}if (nRank - 1 == i) //last element of the column, still no one is reversiable{return false;}}step2: //create the n-1 zeros of the columnfor (i = 0; i < nRank ; ++i){if (i != j){int t = A[i, j]; //first element of Row i .for (k = 0; k < nRank * 2; k++){A[i, k] -= t * A[j, k];A[i, k] %= (int)zt;if (A[i, k]<0){A[i, k] += (int)zt;}}}}}//construct M_1for (i = 0; i < nRank;++i){for (j = 0; j < nRank;++j){nDeMatrix[i,j] = A[i,j+nRank];}}return true;}效果图:我们来截几张图看看:n阶希尔逆矩阵的计算:加密测试:(注意明文中的3个O分别变为了O,S,A . 很好地隐藏了字频信息.)。

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.退出：。

实验报告书-Hilln密码体系

东南大学《数学实验》报告
实验内容：Hill n 密码体系一实验目的
实现Hill n 密码体系的关键环节（加密、解密、破译）二预备知识
熟悉mod 、det 、find 等Matlab 命令三实验内容与要求（1）假设加密矩阵为
A =⎪⎪⎭
⎫
⎝⎛3201，用M A T L A B 编制程序，加密下面一段
明文：SHUXUEJIANMOJINGSAI
（2）假设加密矩阵为A=
11
03
⎛⎫
⎪
⎝⎭
，用M A T L A B编制程序，解密下面一段密
文：AXSTZOSAOPBSTKSAN OPSAHAUUNSUUAKGAUZC
K KOP D O
（3）甲方截获了一段密文:
BKOPGATRHMMBFC SDJC CAUU
经分析这段密文是用Hill2密码编译的,且这段密文的字母SDJC依次代表字母IJIA，请破译这段密文的内容
（4）编写通用的Hill密码软件(Matlab或C++)
以上加密、解密、破解矩阵都是通用Hill密码，可推广到HILL N维加密解密破解。

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密码算法的优点是可以同时处理多个字符，提高了加密的效率和安全性。

然而，它的缺点是对于大型密钥矩阵的逆矩阵计算较为困难，且算法的安全性依赖于密钥的保密性。

希尔密码与V密码

河北科技大学实验报告级专业班学号年月日姓名同组人指导教师实验名称成绩实验类型批阅教师一、实验目的实现密码算法（Hill密码、Vigenere密码）二、实验原理古典密码算法的基本原理（单表密码、多表密码、密码分析）。

三、验内容以及步骤(1)Hill密码的基本原理：希尔密码（Hill Password）是运用基本矩阵理论的替换密码算法如下：1、假设要加密的明文是有26个英文字母组成，其他字符不做变换。

2、将每个字符与0-25中的数字一一对应（例如：a/A—0，b/B—1，c/C—2……z/Z—25）。

3、选择加密矩阵A（A为n*n可逆矩阵）。

4、将明文中字母依照次序分成每n个一组（最后一组不足n个，则不做处理）利用矩阵乘法进行加密。

5、解密与加密基本一致。

核心代码：public class Hill{int[][] Matrix;int[][] InverseMatrix;public Hill(int[][] Matrix) {this.Matrix = Matrix;}private StringBuffer transform(String message) {StringBuffer cipmessage = new StringBuffer();int[] queue = new int[3];char[] buffer = new char[100];int index = 0;int count = 0;int i = 0;int j = 0;for (i = 0; i < message.length(); i++) {if (message.charAt(i) >= 'a' && message.charAt(i) <= 'z') {queue[count] = message.charAt(i) - 'a';buffer[index] = 'a';index++;count++;} else if (message.charAt(i) >= 'A' && message.charAt(i) <= 'Z') { queue[count] = message.charAt(i) - 'A';buffer[index] = 'A';index++;count++;} else {if (count == 0) {cipmessage.append(message.charAt(i));} else {buffer[index] = message.charAt(i);index++;}}if (count == 3) {int x = 0;for (j = 0; j < index; j++) {if (buffer[j] == 'a' || buffer[j] == 'A') {int temp = 0;for (int y = 0; y < 3; y++) {temp += Matrix[x][y] * queue[y];}cipmessage.append((char) (temp % 26 + buffer[j]));x++;} else {cipmessage.append(buffer[j]);}}index = 0;count = 0;}}if (count != 0) {for (i = 0; i < count; i++) {if (buffer[i] == 'a' || buffer[i] == 'A') {cipmessage.append((char) (buffer[i] + queue[i]));} else {cipmessage.append(buffer[i]);}}}return cipmessage;}public static void main(String[] args) {String message = "Hello Password!!!";StringBuffer cipmessage;StringBuffer finalMessage;int[][] Matrix = {{17, 17, 5}, {21, 18, 21}, {2, 2, 19}};int[][] InverseMatrix = {{4, 9, 15}, {15, 17, 6}, {24, 0, 17}};Hill hill = new Hill(Matrix);cipmessage = hill.transform (message);System.out.println(cipmessage);Hill hill1 = new Hill(InverseMatrix);finalMessage = hill1.transform (cipmessage.toString());System.out.println(finalMessage);}}(2)Vigenere密码代码如下：public class Vigenere{String plaintext;public Vigenere(String plaintext) {this.plaintext = plaintext;}private StringBuffer jiami(String message) {StringBuffer cipmessage = new StringBuffer();int index = 0;int i = 0;for (i = 0; i < message.length(); i++) {if (message.charAt(i) >= 'a' && message.charAt(i) <= 'z') {cipmessage.append((char) (((message.charAt(i) - 'a') + (plaintext.charAt(index) - 'a')) % 26 + 'a'));index++;} else if (message.charAt(i) >= 'A' && message.charAt(i) <= 'Z') {cipmessage.append((char) (((message.charAt(i) - 'A') + (plaintext.charAt(index) - 'a')) % 26 + 'A'));index++;} else {cipmessage.append(message.charAt(i));}if (index == plaintext.length()) {index = 0;}}return cipmessage;}private StringBuffer jiemi(String message) {StringBuffer cipmessage = new StringBuffer();int index = 0;int i = 0;for (i = 0; i < message.length(); i++) {if (message.charAt(i) >= 'a' && message.charAt(i) <= 'z') {cipmessage.append((char) (((message.charAt(i) - 'a') - (plaintext.charAt(index) - 'a') + 26) % 26 + 'a'));index++;} else if (message.charAt(i) >= 'A' && message.charAt(i) <= 'Z') {cipmessage.append((char) (((message.charAt(i) - 'A') - (plaintext.charAt(index) - 'a') + 26) % 26 + 'A'));index++;} else {cipmessage.append(message.charAt(i));}if (index == plaintext.length()) {index = 0;}}return cipmessage;}public static void main(String[] args) {String message = "We are discovered save yourself!";StringBuffer cipmessage;StringBuffer finalMessage;String plaintext = "deceptive";Vigenere vigenere = new Vigenere(plaintext);cipmessage = vigenere.jiami (message);System.out.println(cipmessage);finalMessage = vigenere.jiemi (cipmessage.toString());System.out.println(finalMessage);}}四、实验结果。

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同态"。

为了避免这种情况，通常会对字母表进行扩展或使用其他技巧进行加密。

密码学实验报告

密码学实验报告摘要：本实验旨在通过实践掌握基本密码学算法的原理和应用。

在本次实验中我们完成了Caesar密码、仿射密码、VIC密码和Hill密码的加密和解密过程，并进行了相应的分析和评价。

实验结果表明，不同的密码算法有各自的优缺点，应根据具体需求进行选择。

一、实验目的1.了解基本密码学算法的原理和应用。

2.通过实践掌握Caesar密码、仿射密码、VIC密码和Hill密码的加密和解密过程。

3.分析和评价各个密码算法的优缺点。

二、实验原理Caesar密码：是一种非常简单的单字母替换密码。

按照字母表上旋转的位置，每个字母都用它在字母表中的下一个字母替代。

仿射密码：通过将明文中的每个字母转换为另一个字母，实现加密。

明文中的每个字母通过使用一组固定的数学函数进行加密。

随机选择这些函数，并按正确的顺序应用它们。

VIC密码：将某些字母替换为其他字母组合的运算称为置换。

VIC密码使用10个钥匙，其中每个钥匙是一个置换。

通过使用不同的键，VIC密码可以很容易地产生四十亿多个不同的密码。

Hill密码：是一种基于线性代数理论的密码算法。

对于一个给定的矩阵α，Hill密码通过将明文划分为每个字母，然后将其与矩阵α乘法来加密，最后将结果映射回字母表中的字母。

三、实验过程1.实现Caesar密码的加密和解密。

2.实现仿射密码的加密和解密。

3.实现VIC密码的加密和解密。

4.实现Hill密码的加密和解密。

5.对各个密码算法进行分析和评价。

四、实验结果1.在Caesar密码中，明文是将每个字母按照一定的步长向右或向左移动来进行加密。

由于其简单性，Caesar密码的加密和解密都很容易，但安全性较低。

2.仿射密码是Caesar密码的扩展版本。

通过随机选择两个数字，仿射密码在加密的过程中使用模运算和线性函数组合对明文进行加密。

由于消息加密和解密都使用数学功能进行计算，因此密钥空间大于Caesar，也比较安全。

3.VIC密码使用多个置换键（通常为10），交替使用它们来完成加密和解密过程。

实验报告书-Hill密码体系

bkopgatrhmmbfcsdjccauu经分析这段密文是用hill2密码编译的且这段密文的字母sdjc依次代表字母ijia请破译这段密文的内容matlab命令结果的编写通用的hill密码程序并存放在hillm文件中hill程序会调用translatem文件中的translate函数用来对函数用来对ascii码串和字符串的转换
3
disp('输入密钥，按行输入'); A=[]; for i=1:n for j=1:n A(i,j)=input(''); end end if gcd(det(A),26)~=1 error('密钥矩阵模 26 不可逆，无法实现 Hill 密码'); end disp('输入所要加密的明文（A-Z）：'); message1=input('','s'); %translate 函数功能为返回 A*message1 message2=translate(A,message1,n); disp(['加密后密文为：',message2]); break; case 2 %输入密钥 disp('输入密钥矩阵的阶数：'); n=input(''); disp('输入密钥，按行输入'); A=[]; for i=1:n for j=1:n A(i,j)=input(''); end end X=[1 0 9 0 21 0 15 0 3 0 19 0 0 0 7 0 23 0 11 0 5 0 17 0 25 0]; %按顺序存放 1-25 的模 26 的倒数,0 代表无倒数 d=mod(det(A),26); %求矩阵的行列式并对 26 取模 if d==0 x=0; else x=X(d); end AA=[];%AA 为 A 的模 26 逆矩阵 if x==0 %判断矩阵是否模 26 可逆 error('密钥矩阵模 26 不可逆，无法实现 Hill 密码'); end B=det(A)*inv(A); %A 的伴随矩阵 AA=mod(round(x*B),26); disp('A 的模 26 的逆矩阵为 AA：'); disp(AA);

hill密码算法

Hill密码算法详解一、引言Hill密码算法是一种对称加密算法，早在20世纪早期就已经出现。

它是基于线性代数的群论中的一次同余方程的理论而设计的。

Hill密码算法的安全性依赖于求解一个大的二次或者更高次的一次同余方程组的困难性。

尽管Hill密码算法在当今的加密标准中已经被废弃，但是了解和学习它仍然具有很高的价值，因为它是许多现代加密算法的基础。

二、基本理论1. 线性代数基础：Hill密码算法涉及到一些线性代数的概念，包括向量空间、基、维度、线性变换等。

理解这些概念对于理解Hill密码算法至关重要。

2. 群论基础：Hill密码算法也涉及到群论的一些基本概念，如群、子群、同态、原像和象等。

群论是解决Hill密码算法的关键工具。

3. 一次同余方程：Hill密码算法的安全性基于求解大的一次同余方程组的困难性。

一次同余方程是数论的基本问题之一，也是现代密码学的基础。

三、Hill密码算法原理Hill密码算法的核心思想是将明文消息映射到密文消息，这个映射是通过一个密钥控制的线性变换来实现的。

具体来说，Hill密码算法包括以下步骤：1. 密钥生成：首先，需要生成一个密钥矩阵。

这个密钥矩阵是一个n×n的矩阵，其中n是明文消息的长度。

密钥矩阵的元素是随机选择的整数。

2. 加密过程：加密过程包括两个步骤。

第一步，将明文消息转换为一个n维的向量。

第二步，通过密钥矩阵对明文向量进行线性变换，得到密文向量。

3. 解密过程：解密过程与加密过程相反。

首先，通过密钥矩阵对密文向量进行逆线性变换，得到一个n维的向量。

然后，将这个向量转换回明文消息。

四、安全性分析Hill密码算法的安全性基于求解大的一次同余方程组的困难性。

如果能够有效地求解这个方程组，那么就能够破解Hill密码算法。

然而，尽管计算机技术的快速发展使得求解一次同余方程组变得相对容易，但是对于大规模的一次同余方程组，仍然需要消耗大量的时间和计算资源。

因此，只要密钥矩阵足够大，Hill 密码算法就是安全的。

Hill密码

称A为模m可逆，B为A的模m 逆矩阵,记
--1
B=A （mod m）
12
例： A={ 0 3 }
18
B ={ 0 9 }
有AB = E(mod m)
--1
A可逆， A= B A模ｍ可逆的判定：
A模ｍ可逆的充要条件是，ｍ和|Ａ|没有公共素数因子。
证明：如果ａｂ＝１（ｍｏｄｍ）称ａ模ｍ可逆，ｂ
收到的加密消息。尽管加密消息的办法众所周知，但只
有那些指定的人才能解开它们。这种想法基于这样的事
实：存在数秒内能找到非常大的素数（譬如100位长）以及使它们相乘的方法，但是，用已知的算法，即使用最快的计算机也需要数年的时间来分解具有200位的整数。
（2）因此，收到这个消息的人，找到两个较大的素数p和 q (p，q保密)。
找出元素属于Z26 的所有可能的Hill2 密码加密矩阵，若截获了如下一段密文
UTCQCVFOYQUVMGMGULFOLEYHDUHOPEASWXTI
FBAMWT 且已知它是根据表1，且按 Hill2 密码体制加密，你能否将其解密？
六：RSA公钥加密方案。 1：原理（1）这是一种每个人都公开知道如何解开他或她所

72 mod 85=13 M
6：任务：（1）：当n=85，r=3时用RSA方案确定发送电文
CHINA。（2）：当p=5，q=17，r=3时用RSA方案对接收52和
72解密。（3）：在RSA方案中，当p=5，q=17，r=5时，确定s
的值；问如取r=4来解密，能否可行？
m为1，r 的这个幂指数的前一个的幂的 mod m就是s 。
4
3
例：r = 3 ， m = 16 有3 = 1（mod 16）则有s = 3

Hill密码的加密、解密与破译

Hill密码的加密、解密与破译
一、问题背景和实验目的
保密通讯在军事、政治、经济斗争和竞争中的重要性是不言而喻的．他采用的一种方式是：将原来的信息(称为明文) 经过加密，变成密文之后发送出去，使敌方即使得到密文也读不懂，而合法的接收者收到密文之后却可以按照预先约定好的方法加以解密，再翻译成明文．而敌方却要千方百计从密文破译出明文来．一方如何编制密码使之不易被破译，另一方则要找到其弱点加以破译，这就构成了密码学的主要内容．
a (modm)(modm) a a (mod m ) a (mod m ) 1 2 1 2 * *
模运算意义下的矩阵逆概念
定义１对于一个元素属于集合Gm的n阶方阵A,若存在一个元素属于Gm的方阵B,使得 A B=B A=E(mod m) x 则称A为模m可逆,B为A的模 m的逆矩阵,记为 1 A B= (mod)。定义2 对Gm的一个整数x，存在Gm的一个整数y，使得xy＝１（mod m），则称y为x的乘法逆(或 1 者称为倒数)，记y= （x mod m）。可以证明，如果x与m无公共素数因子，则x有唯一的模m倒数。
加密过程的具体步
A乘以 ,得一新的2维列向量 Aa ,由的两个分量反查字母表值得到的两个字母即为密文字母。
骤
例如明文为 SHUXUEJIANMOJINGSAI ，加密矩阵为A=1 2 0 3Fra bibliotek 。
密文为
IX QT EO BA CP QS BA BU UC AA 在查字母表时利用了模运算概念关于模运算有如下运算律

1
据此我们不加证明地给出如下命题：命题元素属于Gm的方阵A模m可逆的充要条件是: m和detA没有公因子。易见，所选加密矩阵必须符合模A可逆的条件。

数学实验-希尔密码的破译

数学实验：希尔密码的破译一、问题重述：找出元素属于Z（26）的所有可能的Hill密码加密矩阵，若截获了如下一段密文：CKYNOHKQMAXJQBHAZWUHDAOQWXIPQZBKMPUTIPVSWSBYXKKWQHADMBDM且知道它是根据表10.1按Hill（2）密码加密的，你能否将他解密？二、基本思路：（1）先穷举列出所有可以作为解密矩阵的矩阵，然后依次解密得到明文对应的数字矩阵，通过程序运行可以得到明文（2）通过频率统计攻击不符合要求的明文进行筛选，得到符合要求的明文，然后进行人工选择即可。

三、解答：1、将字母转化为数字矩阵。

我们通过matlab编程实现，代码如下：function [Z] = zimu_shuzi(X,a)%a是字符串长度除以2X=strrep(X,'Z','@');Y=abs(X)-64;for i=1:aZ(:,i)=Y(1,2*i-1:2*i)';endZ=mod(Z,26);%此程序经检验无误。

End经过此程序后我们得到2、将此值赋给C，对C应用程序暴力破解，其代码如下：function[]= Copyblpj_hypy(a,d,C)%输入解密矩阵的第一个元素a，密文长度的一半d，及密文矩阵。

for b=0:25for i=0:25for j=0:25X=[a,b;i,j];D=det(X);D=round(D);if gcd(D,26)~=1elseH=mod(X*C,26);D=0;for k=1:dD(1,2*k-1:2*k)=H(:,k)';endD=mod(D,26);M=char(D+64);M=strrep(M,'@','Z');%由于表10-1中Z的值域ascii码不能应用其他字母的对应关系，所以先用替换的方法换成@保证程序正确运行ifsize(strfind(M,'I'),2)>=3&&size(strfind(M,'N'),2)>=3&&size(strfind(M, 'D'),2)<=2&&size(strfind(M,'C'),2)<=2&&size(strfind(M,'L'),2)<=2&&siz e(strfind(M,'Q'),2)<=2&&size(strfind(M,'K'),2)<=2&&size(strfind(M,'V' ),2)==0%通过汉语拼音的频率来攻击、筛选。

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密码体制的加密、解密和破译过程二、实验任务任务五找出元素属于Z26的所有可能的Hill2密码加密矩阵。

若截获了如下一段密文：UTCQCVFOYQUVMGMGULFOLEYHDUHOPEASWXTIFBAMWT且已知它是根据表10.1按Hill2密码体制加密的，你能否将其解密?分析：对于第一问，找出元素属于Z26的所有可能的Hill2密码加密矩阵，我们只需要用枚举法即可。

关键在于第二问的解密，根据我们编写的C++程序，共有约15万个可能的加密矩阵，也就对应着同等数量的可能明文。

所以问题的重点就在于如何从这么多数量的明文中筛选出有意义的信息。

1、找出元素属于Z26的所有可能的Hill2密码加密矩阵C++源代码（枚举加密矩阵部分）：chain_mat* head=new chain_mat; //加密矩阵用链表储存head->next=NULL;chain_mat* now=head;int n=0;for(int a=0;a<26;a++)for(int b=0;b<26;b++)for(int c=0;c<26;c++)for(int d=0;d<26;d++){intdet=a*d-b*c;if(det%2!=0&&det%13!=0) //判断是否模26可逆{chain_mat* newm=new chain_mat;newm->dat[0][0]=a;newm->dat[0][1]=b;newm->dat[1][0]=c;newm->dat[1][1]=d;n++; //累加符合要求的矩阵数量now->next=newm;now=now->next;now->next=NULL;}}运行结果：n=157248由于矩阵数量过多，我们将其存储在matrixlist.txt文件中C++源代码（输出矩阵部分）：voidoutput_mat(chain_mat* head){ofstreamoutfile;outfile.open("matrixlist.txt");chain_mat* now=head->next;while(now!=NULL){outfile<<now->dat[0][0]<<'\t'<<now->dat[0][1]<<'\n'<<now->dat [1][0]<<'\t'<<now->dat[1][1]<<"\n=========="<<endl;now=now->next;}outfile.close();}下面给出matrixlist.txt中部分内容（完整文件将发至邮箱）：0 11 0==========0 11 1==========0 11 2==========0 11 3==========0 11 4==========0 11 5==========0 11 6==========0 11 7==========0 11 8==========0 11 9==========0 11 10==========2.解密题中密文首先需要做的是对矩阵进行模逆运算C++源代码（模26逆矩阵运算部分）：voidinv(chain_mat* m1){intdet=m1->dat[0][0]*m1->dat[1][1]-m1->dat[0][1]*m1->dat[1][0];det=reci(det);inttmp;tmp=m1->dat[0][0]*det;m1->dat[0][0]=m1->dat[1][1]*det;m1->dat[1][ 1]=tmp;m1->dat[0][1]*=-1*det;m1->dat[1][0]*=-1*det;for(inti=0;i<2;i++)for(int j=0;j<2;j++){m1->dat[i][j]%=26;if(m1->dat[i][j]<0)m1->dat[i][j]+=26;}}然后用逆矩阵乘密文向量，得到可能明文序列，存入名为me1的string数组中C++源代码（模26逆矩阵运算部分）：n=0;while(now!=NULL)inv(now);for(inti=0;i<sizeof(str)-1;i+=2){int s1=now->dat[0][0]*co1[i]+now->dat[0][1]*co1[i+1];int s2=now->dat[1][0]*co1[i]+now->dat[1][1]*co1[i+1];s1%=26;s2%=26;if(s1<0)s1+=26;if(s2<0)s2+=26;if(s1==0)s1=26;if(s2==0)s2=26;me1[n]+=('A'+s1-1);me1[n]+=('A'+s2-1);}n++;inv(now);now=now->next;}至此，我们得到了157248条可能的明文，接下来就要考虑筛选的问题。

数学模型中HILl密码加解密

明文分组(两个一组)，按组转换成密文同一字母在不同组中所对应密码不同
HILL2密码的加密与解密
★ 假设要加密的明文是由26个字母所构成 ★ 将每个明文字母与 0 – 25 的一个数字建立
1–1对应关系，称为明文字母的表值
字母 A B C D E F G H I J K L M 表值 1 2 3 4 5 6 7 8 9 10 11 12 13 字母 N O P Q R S T U V W X Y Z 表值 14 15 16 17 18 19 20 21 22 23 24 25 0
b3
b4
A
a3 a4
b1
b2
b3 b4
A
a1 a2
a3
a4
A
b1 b2
b3 a1
b4
a2
a3 1
a4
一个破译例子
甲方截获了一段密文：OJWPISWAZUXAU UISEABAUCRSIPLBHAAMMLPJJOTENH
经分析这段密文是用HILL2密码编译的，且这段密文的字母 UCRS 依次代表了字母 TACO，若明文字母的表值如前，试破译这密文的内容？
设a Zm，若存在 b Zm 使得
ab 1(mod m)，称 a 有模 m 的逆记作 b a1(mod m)
整数 a有模 m 逆元的充要条件为 a 与 m 无公共素因子
模 26 倒数表----如何得出？
a
1 3 5 7 9 11 15 17 19 21 23 25
a –1(mod26) 1 9 21 15 3 19 7 23 11 5 17 25
20
加密：左乘加密矩阵 A 1 2
0 3
直接结果
57 4437 35 25 25 57 38 60

实验十【Hill密码的加密解密与破译】

Hill 密码的加密、解密与破译[实验十] Hill 密码的加密、解密与破译一、实验目的本实验主要涉及代数，利用模运算意义下的矩阵乘法、求逆矩阵、线性无关、线性空间与线性变换等概念和运算，学习Hill 密码体制的加密、解密和破译过程。

二、实验内容(1)甲方收到与之有秘密通信往来的乙方的一个密文信息，密文内容： W O W U Y S B A C P G Z S A V C O V K P E W C P A D K P P A B U J C Q L Y X Q E Z A A C P P按照甲方与乙方的约定，他们之间的密文通信采用Hill 2密码，密钥为二阶矩阵且汉语拼音的26个字母与0~25之间的整数建立一一对应的关系，称之为字母的表值，具体的表值见表10. 1 明文字母的表值。

问这段密文的原文是什么？(2)甲方截获了一段密文： O J W P I S W A Z U X A U U I S E A B A U CR S I P L B H A A M M L P J J O T E N H 经分析这段密文是用Hill 2密码编译的，且这段密文的字母UCRS 依次代表字母TACO ，问能否破译这段密文的内容？三、Hill 2密码的数学模型 Ⅰ、加密与解密过程Hill 2密码是一种传统的密码体制，它的加密过程可用以下框图描述：⎪⎭⎫⎝⎛=3021A明文------加密器------密文------普通信道------解密器密码分析（敌方截获）----- 明文在这个过程中，运用的数学手段是矩阵运算，加密过程的具体步骤如下： 1．根据明文字母的表值将明文信息用数字表示，设明文信息只需要26个拼音字母A~Z （也可能不止26个，如还有数字、标点符号等），通信双方给出这26个字母表值（见表10.1明文字母的表值）。

2．选择一个二阶可逆整数方阵A ，称为Hill 2密码的加密矩阵，它是这个加密体制的“密钥”（是加密的关键，仅通讯双方掌握）。

Hill密码的加解密

1(mod26) 1
21 15 3 19 7 23 11 5 17 25
怎样求模 m 倒数
即解方程
ax 1 (mod m)
定义 Euler 函数：
设 m 为一自然数，Zm中与m 互素的数的个数称为m 的Euler 函数，记为 (m) Euler 定理对任意整数 k, m, 若k, m互素，则
HILL2密码的破译

关键是求得加密矩阵的逆—解密矩阵只要分析出两个明文向量（线性无关）与相应的密文向量

若有 b1
a1 b3 a3 A A b2 a2 b4 a4

b1 b3 a1 A b2 b4 a2
i A i
1
关于模运算（mon26）
模 m 等价设 a , b为两个整数, 若 a b km, k Z 记作 a b(mod m) 称 a 模 m 等价于b，剩余集
Zm {0,1, 2, , m 1} 称为模m的剩余集
设 a , b 为两个整数，
a b (mod m) a (mod m) b(mod m) (mod m)
inva=
1.0000 0.6667 0 0.3333
%求矩阵a的行列式 %求矩阵a的逆矩阵
compa=deta*inva
compa= 3 2 0 1
%求矩阵a的伴随矩阵
ideta = 9
inva1=mod(ideta*compa, 26) inva1= 1 8
加密过程将明文变换成另一种不能被非授权者所

Hill密码的加解密过程

输入明文I
输入明文N
输入明文G
H =2 15 7 20 8 13 6 19 10 3 21
11 16 1 18 13 2 3 4 3 1 21
ans =B
ans =K
ans =O
ans =P
ans =G
ans =A
ans =T
ans =R
ans =H
ans =M
ans =M
ans =B
ans =F
ans =C
ans =F
ans =U
ans =M
ans =U
ans =R
ans =E
ans =A
ans =I
ans =J
ans =I
ans =A
ans =T
ans =I
ans =N
ans =G中文意思为：关心父母，热爱家庭
2,已知密文与密钥，求对应的明文,如将上述的密文翻译成明文，设密钥为A=[1,1;0,3]
end
for n=1:11
D(1,n)=y(2*n-1);
D(2,n)=y(2*n);
end
H=mod(B*D,26);
for u=1:11
for v=1:2
setstr(H(v,u)+64)
end
end
输出的结果为：
ans =G
ans =U
ans =A
ans =N
ans =X
ans =I
ans =N
m=input('输入要加密的明文字母的个数');
if mod(m,2)==0
for i=1:m
a=input('输入明文','s');