hill加密算法计算密文

Ⅰ c语言编写hill密码

花了些时间写的，希望对你有帮助~

#include<stdio.h>
#define N 3 //可加密的字符串长度

char plaintext[N]=; //明文，输入时输入字符，参与运算时强制转换成整数
int ciphertext[N]=; //密文，保存成整数，输出时强制转换成字符
int key[N][N]; //密钥矩阵

void getPlainText() //获得明文字符串
{
printf("请输入明文:");
scanf("%s",plaintext);
printf("\n");
}

void getKey() //输入密钥矩阵
{
int i,j;
printf("请输入加密矩阵:\n");
for(i=0;i<N;i++)
for(j=0;j<N;j++)
scanf("%d",&key[i][j]);
printf("\n");

}

void hill() //Hill加密算法
{
int i,j;
for(i=0;i<N;i++){ //矩阵的乘法
for(j=0;j<N;j++){ //计算转换依据，0~25对应a~z
ciphertext[i]+=key[i][j]*(int)(plaintext[j]-'a');
ciphertext[i]%=26;
}
}
printf("\n");
}

void printCipherText() //输出加密后的密文
{
int i;
printf("加密后的密文是:");
for(i=0;i<N;i++) //把参与计算后是整数强制转换成对应的字符
printf("%c",(char)(ciphertext[i]+'a'));
printf("\n");

}

void main()
{
getPlainText(); //明文
getKey(); //密钥
hill(); //加密
printCipherText(); //密文
}

Ⅱ 区块链技术中的哈希算法是什么

1.1. 简介

计算机行业从业者对哈希这个词应该非常熟悉，哈希能够实现数据从一个维度向另一个维度的映射，通常使用哈希函数实现这种映射。通常业界使用y = hash(x)的方式进行表示，该哈希函数实现对x进行运算计算出一个哈希值y。
区块链中哈希函数特性：

• 函数参数为string类型；

• 固定大小输出；

• 计算高效；

• collision-free 即冲突概率小：x != y => hash(x) != hash(y)
  
  隐藏原始信息：例如区块链中各个节点之间对交易的验证只需要验证交易的信息熵，而不需要对原始信息进行比对，节点间不需要传输交易的原始数据只传输交易的哈希即可，常见算法有SHA系列和MD5等算法
  

1.2. 哈希的用法

哈希在区块链中用处广泛，其一我们称之为哈希指针（Hash Pointer）
哈希指针是指该变量的值是通过实际数据计算出来的且指向实际的数据所在位置，即其既可以表示实际数据内容又可以表示实际数据的存储位置。下图为Hash Pointer的示意图

Ⅲ 希尔密码原理

希尔密码（Hill Cipher）是运用基本矩阵论原理的替换密码，由Lester S. Hill在1929年发明。每个字母当作26进制数字：A=0, B=1, C=2... 一串字母当成n维向量，跟一个n×n的矩阵相乘，再将得出的结果MOD26。

中文名
希尔密码
外文名
Hill Cipher
原理
基本矩阵论
类别
替换密码
提出者
Lester S. Hill
快速
导航
产生原因

原理

安全性分析

例子
简介
希尔密码是运用基本矩阵论原理的替换密码，由Lester S. Hill在1929年发明。
每个字母当作26进制数字：A=0, B=1, C=2... 一串字母当成n维向量，跟一个n×n的矩阵相乘，再将得出的结果模26。
注意用作加密的矩阵（即密匙）在必须是可逆的，否则就不可能解码。只有矩阵的行列式和26互质，才是可逆的。
产生原因
随着科技的日新月异和人们对信用卡、计算机的依赖性的加强，密码学显得愈来愈重要。密码学是一门关于加密和解密、密文和明文的学科。若将原本的符号代换成另一种符号，即可称之为广义的密码。狭义的密码主要是为了保密，是一种防止窃文者得知内容而设的另一种符号文字，也是一般人所熟知的密码。
使用信用卡、网络账号及密码、电子信箱、电子签名等都需要密码。为了方便记忆，许多人用生日、电话号码、门牌号码记做密码，但是这样安全性较差。
为了使密码更加复杂，更难解密，产生了许多不同形式的密码。密码的函数特性是明文对密码为一对一或一对多的关系，即明文是密码的函数。传统密码中有一种叫移位法，移位法基本型态是加法加密系统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次，机密的信息就会泄漏出去。
由此看来，日常生活中的密码和传统的密码的可靠性较差，我们有必要寻求一种容易将字母的自然频度隐蔽或均匀化，从而有利于统计分析的安全可靠的加密方法。希尔密码能基本满足这一要求。
原理
希尔加密算法的基本思想是，将d个明文字母通过线性变换将它们转换为d个密文字母。解密只要作一次逆变换就可以了，密钥就是变换矩阵本身。[1]
希尔密码是多字母代换密码的一种。多字母代换密码可以利用矩阵变换方便地描述，有时又称为矩阵变换密码。令明文字母表为Z，若采用L个字母为单位进行代换，则多码代换是映射f：Z→Z。若映射是线性的，则f是线性变换，可以用Z上的L×L矩阵K表示。若是满秩的，则变换为一一映射，且存在有逆变换K。将L个字母的数字表示为Z上的L维矢量m，相应的密文矢量c，且mK=c，以K作为解密矩阵，可由c恢复出相应的明文c·K=m。
在军事通讯中，常将字符（信息）与数字对应（为方便起见，我们将字符和数字按原有的顺序对应，事实上这种对应规则是极易被破解的）：
abcde…x y z
12345…242526
如信息“NOSLEEPPING”对应着一组编码14,15,19,12,5,5,16,16,9,14,7。但如果按这种方式直接传输出去，则很容易被敌方破译。于是必须采取加密措施，即用一个约定的加密矩阵K乘以原信号B，传输信号为C=KB（加密），收到信号的一方再将信号还原（破译）为B=KC。

Ⅳ 希尔密码求解

希尔加密算法的基本思想是，将d个明文字母通过线性变换将它们转换为d个密文字母。解密只要作一次逆变换就可以了，密钥就是变换矩阵本身。如信息“NOSLEEPPING”对应着一组编码14，15，19，12，5，5，16，16，9，14，7。但如果按这种方式直接传输出去，则很容易被敌方破译。于是必须采取加密措施，即用一个约定的加密矩阵K乘以原信号B，传输信号为C=KB（加密），收到信号的一方再将信号还原（破译）为B=KC。如果敌方不知道加密矩阵，则很难破译。
解密
第一步，求密匙矩阵K的逆矩阵［2］K。K可用Mathematica计算。
Inverse123-120213∥MatrixForm=-614-3125-1-3，
即K=-614-3125-1-3。
第二步，由得Y=KX得X=KY（i=1，2，3，4），再次进行矩阵乘法运算：
X=KY=-614-3125-1-3671610=141519；
X=KY=-614-3125-1-327-244=1255；
X=KY=-614-3125-1-3501675=16169；
X=KY=-614-3125-1-321035=1470。
这样原来的信息编码为14，15，19，12，5，5，16，16，9，14，7。
第三步，对照编码表，即可获得对方发来的信息内容为“NOSLEEPPING”。

Ⅳ 为什么说加法密码、乘法密码、仿射密码、置换密码、Hill密码以及Vigenere密码

加法密码就是真典密码学中的恺撒密码格式是：密文=(明文+密钥)mod26,剩法密码是恺撒密码发展出来，格式是：密文=明文x实钥mon26；置换密码就是在简单的纵行换位密码中，明文以固定的宽度水平的写在一张图表纸上，密文按垂直方向读出，解密就是密文按相同的宽度垂直的写在图表纸上，然后水平的读出明文。希尔密码（Hill Cipher）是运用基本矩阵论原理的替换密码，由Lester S. Hill在1929年发明。每个字母当作26进制数字：A=0, B=1, C=2... 一串字母当成n维向量，跟一个n×n的矩阵相乘，再将得出的结果MOD26；Vigenere是恺撒密码演变而来。使用一系列凯撒密码组成密码字母表的加密算法，属于多表密码的一种简单形式。
有兴趣可以了解一下古典密码学，这里面都有。

Ⅵ c璇瑷缂栧啓hill瀵嗙爜

// 甯屽皵绠楁硶镄勫姞瀵嗕笌瑙ｅ瘑
#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;// 鐭╅樀鐩镐箻锛宎鏄涓涓鍒椾负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鐭╅樀涓巑鐭╅樀浜挜
void ConverseMatrix(int m[][10], int cm[][10])
{
// 鐭╅樀姹傞嗭纴鍒╃敤鏁板﹀叕寮廇锛堥嗭级= (1 / |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++; // 鐭╅樀鐩镐箻
// 灏哋Text鍒嗘垚镄勫嚑閮ㄥ垎鍒嗗埆涓巑atrix鐭╅樀鐩镐箻
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瀛樻斁铡熸枃杞鎹涓烘櫘阃氭暟瀛楋纴濡侫~1锛孼~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");
// 鍙阃嗙烦阒靛嵆锛岃続涓簄阒剁烦阒碉纴濡傛灉瀛榥鍦ㄩ桩鐭╅樀B浣垮缑AB=BA=1
// 鍒欑烦阒础鏄鍙阃嗙殑锛岀ОB鏄疉镄勯嗙烦阒
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瀛樻斁灏嗗瓧姣嶈浆鎹涓虹浉搴旀暟锛屽侫~1锛孼~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