希尔密码已知密文和明文（希尔密码是古典密码吗）
希尔密码已知密文和明文（希尔密码是古典密码吗）
希尔(Robert.Hill)发现在叶绿体悬浮液中加入适当的电子受体(如草酸铁),照光时可使水分解而释放氧气:
4Fe3++2H2O =====光破碎的叶绿体===== 4Fe2++4H++O2
这个反应称为希尔反应.此反应证明了氧的释放与CO2还原是两个不同的过程,而且是第一次用离体的叶绿体做试验,把对光合作用的研究深入到细胞器水平,为光合作用研究开创了新的途径。 以后发现生物中重要的氢载体NADP+也可以作为生理性的希尔氧化剂,从而使得希尔反应的生理意义得到了进一步肯定
希尔密码（Hill Cipher）是运用基本矩阵论原理的替换密码，由Lester S. Hill在1929年发明。每个字母当作26进制数字：A=0, B=1, C=2... 一串字母当成n维向量，跟一个n×n的矩阵相乘，再将得出的结果MOD26。
随着科技的日新月异和人们对信用卡、计算机的依赖性的加强，密码学显得愈来愈重要。密码学是一门关于加密和解密、密文和明文的学科。若将原本的符号代换成另一种符号，即可称之为广义的密码。狭义的密码主要是为了保密，是一种防止窃文者得知内容而设的另一种符号文字，也是一般人所熟知的密码。
使用信用卡、网络账号及密码、电子信箱、电子签名等都需要密码。为了方便记忆，许多人用生日、电话号码、门牌号码记做密码，但是这样安全性较差。
为了使密码更加复杂，更难解密，产生了许多不同形式的密码。密码的函数特性是明文对密码为一对一或一对多的关系，即明文是密码的函数。传统密码中有一种叫移位法，移位法基本型态是加法加密系统C=P+s(mod m)。一般来说，我们以1表示A，2表示B，……，25表示Y，26表示Z，以此类推。由于s=0时相当于未加密，而0≤s≤m-1（s≥m都可用0≤s≤m-1取代），因此，整个系统只有m-1种变化。换言之，只要试过m-1次，机密的信息就会泄漏出去。
由此看来，日常生活中的密码和传统的密码的可靠性较差，我们有必要寻求一种容易将字母的自然频度隐蔽或均匀化，从而有利于统计分析的安全可靠的加密方法。希尔密码能基本满足这一要求。
不难看出，希尔密码算法中有两个非常重要的条件。第一个条件是字符（信息）与数字对应表，当加密矩阵的阶数n（本文实例中的加密矩阵的阶数n=3）越大，破译的难度就会增大，此时计算量也大，我们可以借助有关数学软件如Mathematica提高运算效率。第二个条件是加密矩阵，如何定义、求解这个矩阵对于密码的加密和破译至关重要。
从破译密码的角度来看，传统的密码有一个致命弱点，就是破译者可从统计出来的字符频率中找到规律，进而找出破译的突破口，尤其是在计算机技术高度发达的今天，破译的速度更快。希尔密码算法则完全克服了这一缺陷，它通过采用线性代数中的矩阵乘法运算和逆运算，能够较好地抵抗频率分析，很难被攻破。
希尔密码体系为破译者至少设置了三道关口，加大了破译难度。破译希尔密码的关键是猜测文字被转换成几维向量（列矩阵的行数）、所对应的字母表是怎样排列的，更为重要的是要设法获取加密矩阵A。要破解密码，向量的维数、字母的排列表和加密矩阵三者缺一不可。古今中外的谍报战中，敌对双方总是千方百计地获取破解对方密码的钥匙，但要想获取希尔密码的三把钥匙谈何容易。
世界上没有攻不破的密码，希尔密码也不例外。希尔密码算法的缺点在于线性变换的安全性很脆弱，易被攻击击破，黑客正是利用各种密码的弱点来向用户频频发起攻击的。尽管如此，希尔密码仍不失为一种简便高效的密码。
// 希尔算法的加密与解密
#include stdio.h
#include string.h
#include conio.h
#include ctype.h
#include memory.h// nDime为全部变量，可逆矩阵的维数
int nDime;
int index = 0;// MAXN为明文的最大长度
const int MAXN = 256;// 矩阵相乘，a是一个列为1的矩阵
void MultiplyMatrix(int a[], int b[][10], int *text)
{
int i, j, t; for (i = 0; i nDime; i++)
{
t = 0;
for (j = 0;j nDime; j++)
t += b[i][j] * a[j];
text[index++] = t;
}
}// 求行列式的值
int determinant(int m[][10], int size)
{
int row, column;
int temp1[10], temp2[10], t; for (column = 0; column size; column++)
{
temp1[column] = m[0][column];
temp2[column] = m[0][column];
}
for (row = 1; row size; row++)
{
for (column = 0; column size; column++)
{
int diff = column - row;
int sum = column + row;
if (diff 0)
diff += size;
if (sum = size)
sum %= size;
temp1[diff] *= m[row][column];
temp2[sum] *= m[row][column];
}
}
t = 0;
for (row = 0; row size; row++)
t += temp1[row] - temp2[row]; return t;
}// 求矩阵中某一元素的代数余子式
int func(int matrix[][10], const int i, const int j)
{
int row, column, m, n;
int NewMatrix[10][10]; m = n = 0;
for (row = 0; row nDime; row++)
{
if (i == row)
continue;
for (column = 0; column nDime; column++)
{
if (j == column)
continue;
NewMatrix[m++][n++] = matrix[row][column];
}
}
printf ("New Array:\n");
for (row = 0; row nDime - 1; row++)
{
for (column = 0; column nDime - 1; column++)
printf("%d ", NewMatrix[row][column]);
printf("\n");
} int sign = (!((i + j) % 2)) ? 1 : -1;
return sign * determinant(NewMatrix, nDime - 1);
}// 对矩阵求逆，cm矩阵与m矩阵互逆
void ConverseMatrix(int m[][10], int cm[][10])
{
// 矩阵求逆，利用数学公式A（逆）= (1 / |A|)乘以A*
// 其中，|A|表示行列式A的值，而A*表示矩阵A的伴随矩阵
int row, column;
int StarMat[10][10]; // StarMat表示m的伴随矩阵
int t; // 初始化伴随矩阵
for (row = 0; row 10; row++)
for (column = 0; column 10; column++)
StarMat[row][column] = 0; // 求伴随矩阵
for (row = 0; row nDime; row++)
for (column = 0; column nDime; column++)
{
StarMat[row][column] = func(m, row, column);
printf("伴随矩阵：%d", StarMat[row][column]);
} // 求行列式的值
t = determinant(m, nDime); // 求出逆向矩阵
for (row = 0; row nDime; row++)
for (column = 0; column nDime; column++)
cm[row][column] = StarMat[row][column] / t;
// 输出逆向矩阵
for (row = 0; row nDime; row++)
for (column = 0; column nDime; column++)
printf("%d ", cm[row][column]);
printf("\n");
}// 希尔加密及解密算法
void ShellPassword(int *OText, int TextLen, int matrix[][10], int *text)
{
int i, j, n, a[10];
// 判断要将OText分成几部分
n = TextLen / nDime;
if (TextLen % nDime)
n++; // 矩阵相乘
// 将OText分成的几部分分别与matrix矩阵相乘
for (i = 0; i n; i++)
{
for (j = 0; j 10; j++)
a[j] = 0;
for (j = 0; j nDime; j++)
a[j] = OText[i * nDime + j];
MultiplyMatrix(a, matrix, text);
}
}
int main(void)
{
int i, temp, row, column;
// matrix存放加密或解密矩阵，Password为加密后的结果
// OText存放原文转换为普通数字，如A~1，Z~26
int matrix[10][10], ConMatrix[10][10], OText[MAXN], Password[MAXN], OriText[MAXN];
char text[MAXN];
char sel; printf("=================================================\n");
putchar('\n');
printf(" SHELL加密解密器\n");
putchar('\n');
printf("=================================================\n"); while (1)
{
// 初始化矩阵
for (row = 0; row 10; row++)
for (column = 0; column 10; column++)
matrix[row][column] = 0; putchar('\n');
printf("1.加密\n");
printf("2.解密\n");
printf("0.退出\n");
printf("请输入你的选择:\n");
sel = getche(); switch (sel)
{
case '1':
printf("\n请输入原文:\n");
memset(text, '\0', sizeof(text) / sizeof(char));
memset(Password, 0, sizeof(Password) / sizeof(int));
gets(text); printf("输入加密矩阵的维数，维数不能超过10维:\n");
scanf("%d", nDime);
printf("输入矩阵，该矩阵必须为可逆矩阵，否则将不能进行解密:\n");
// 可逆矩阵即，设A为n阶矩阵，如果存n在阶矩阵B使得AB=BA=1
// 则矩阵A是可逆的，称B是A的逆矩阵
for (row = 0; row nDime; row++)
for (column = 0; column nDime; column++)
scanf("%d", matrix[row][column]);
// 将小写字母转换为大写字母
for (i = 0; text[i] != '\0'; i++)
if (islower(text[i]))
text[i] |= 0x20;
// OText存放将字母转换为相应数，如A~1，Z~26
for (i = 0; i MAXN; i++)
OText[i] = 0;
for (i = 0; text[i] != '\0'; i++)
OText[i] = text[i] - 'A' + 1;
// 加密
ShellPassword(OText, strlen(text), matrix, Password);
// 将加密后的内容打印出来
printf("加密后的内容为:\n");
for (i = 0; i strlen(text); i++)
printf("%d ", Password[i]);
putchar('\n');
break;
case '2':
break;
case '0':
return 0;
default:
break;
}
getchar();
} return 0;
} 译码算法我会在明天上传上来，你的加密密钥是一个三阶的数组，密文C是：1729 2514 811 1659 2472 858 1739 2514 849 1902 2736 905 1659 2472 858
希尔密码(Hill Password)是运用基本矩阵论原理的替换密码，由Lester S. Hill在1929年发明。每个字母当作26进制数字:A=0, B=1, C=2... 一串字母当成n维向量，跟一个n×n的矩阵相乘，再将得出的结果模26。注意用作加密的矩阵(即密匙)在\mathbb_^n必须是可逆的，否则就不可能译码。只有矩阵的行列式和26互质，才是可逆的。
希尔密码是基于矩阵的线性变换，希尔密码相对于前面介绍的移位密码以及放射密码而言，其最大的好处就是隐藏了字符的频率信息，使得传统的通过字频来破译密文的方法失效.希尔密码不是足够安全的，如今已被证实。
