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