❶ 请问，用c语言如何实现密码输入
c语言中可采用getch()函数来实现输入密码字符时，不显示字符到终端上，这时，只需要显示出一个相应的*就可以达到效果了。参考代码及运行效果如下图：
❷ C++实现2X2Hill密码的加解密算法
#include <iostream>
using namespace std;
#define NUM 1000//定义最大值
void main ()
{
int key[2][2];
char word[NUM];
int word1[NUM];
char word2[NUM];
int num;
char voa[26]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
cout<<"请输入需要加(解)密的密钥矩阵：(范围:0~25)"<<endl;
cin>>key[0][0]; cin>>key[0][1]; cin>>key[1][0]; cin>>key[1][1];
cout<<"输入需要加（解）密的明文，需要偶数位："<<endl;
cin>>word;
num=strlen(word);
for (int i=0;i<num;i++)//将字母转换为数字
{
for (int j=0;j<26;j++)
if ((word[i]==voa[j])||(word[i]==(voa[j]+32)))
word1[i]=j;
}
for (int i=0;i<num;)//加解密算法
{
word2[i]=(key[0][0]*word1[i]+key[0][1]*word1[i+1])%26;
word2[i+1]=(key[1][0]*word1[i]+key[1][1]*word1[i+1])%26;
i+=2;
}
for(int j=0;j<num;j++)
{
for(int k=0;k<26;k++)
if (word2[j]==k)
word2[j]=voa[k];
}
cout<<"经过加（解）密变换后的值为："<<endl;
for (int i=0;i<num;i++)
cout<<word2[i];
cout<<endl;
system("pause");
}
❸ c语言怎么编写hill密码
// 希尔算法的加密与解密x0dx0a#include
❹ 希尔密码原理
希尔密码（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。
❺ 如何用C语言编写密码程序
1、用一个字符数组来存密码
再用一个字符数组接收你的输入，然后用strcmp
来比较，如果返回0则密码是正确的
2、例程：
#include"stdio.h"
#include"string.h"
intmain()
{
charmima[100]="YuanShi888";
charinput[100]={0};
printf("请输入密码:");
gets(input);
if(strcmp(mima,input)==0)
printf("恭喜你，密码正确! ");
else
printf("对不起，密码输入错误! ");
}
❻ 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(); //密文
}
❼ 用c语言编写一个设置密码的程序
#include "stdio.h"
int* set(void);
int* set(void)
{
int i;
static a[4];
printf("请输入要设置的4位密码 ：");
for(i=0;i<4;i++)
{
scanf("%d",&a[i]);
}
return a;
}
int main()
{
int i,*a,b[4];
a=set();
printf("请输入4位密码 ：");
for(i=0;i<4;i++)
{
scanf("%d",&b[i]);
}
i=0;
while(i<4)
{
if(a[i]==b[i])
{
printf("%d",a[i]);
i++;
}
else
{
break;
}
}
if(i==4)
{
printf("密码正确\n");
}
else
{
printf("密码错误\n");
}
return 0;
}
❽ 希尔密码的示例
例：对明文attack，利用密钥 进行加密。
第一步：将明文分为两两一组：at ta ck
第二步：计算：
同理，
因此，密文为VBDEKQ
解密算法：因为 ，由于K必须可逆，即 ，所以 ，如何计算K的逆，有两种算法：一种是利用伴随矩阵，另一种是利用初等变换，无论采用何种算法都可以。 例；设 ，求K的逆。
解法一、因为 ，因此K的逆存在。显然在mod26下 的余为1，即337/26=1
或337=x mod26，显然x=1。所以
，即：
注意：， ， 在mod26下是7。由此我们有在 在mod26下的逆分别是：， ， ， ，。
例：密文为：YIFZMA 设密钥为 ，找出它的明文。
解：，所以
因此明文为cureka。 例子：
原文：Mr Hill made this code.
abcdefghijklmnopqrstuvwxyz
01234567890123456789012345
_______m___r___h___i___l___l___m___a___d___e___t___h___i___s___c___o___d___e
______12__17___7___8__11__11__12___0___3___4__19___7___8__18___2__14___3___4
m_12_144_204__84__96_132_132_144___0__36__48_228__84__96_216__24_168__36__48
r_17_204_289_119_136_187_187_204___0__51__68_323_119_136_306__34_238__51__68
h__7__88_119__49__56__77__77__84___0__21__28_133__49__49_126__14__98__21__28
i__8__96_136__56__64__88__88__96___0__24__32_154__56__56_144__16_112__24__32
l_11_132_187__77__88_121_121_132___0__33__44_209__77__88_198__22_154__33__44
l_11_132_187__77__88_121_121_132___0__33__44_209__77__88_198__22_154__33__44
m_12_144_204__84__96_132_132_144___0__36__48_228__84__96_216__24_168__36__48
a__0___0___0___0___0___0___0___0___0___0___0___0___0___0___0___0___0___0___0
d__3__36__51__21__24__33__33__36___0___9__12__57__21__24__54___6__52___9__12
e__4__48__68__28__32__44__44__48___0__12__16__76__28__32__72___8__56__12__16
t_19_228_323_133_152_209_209_228___0__57__76_361_133_152_342__38_266__57__76
h__7__84_119__49__56__77__77__98___0__21__28_133__49__56_126__14__98__21__28
i__8__96_136__56__64__88__88__96___0__24__32_152__56__56_144__16_112__24__32
s_18_216_306_126_144_198_198_216___0__54__72_342_126_144_324__36_252__54__72
c__2__24__34__14__16__22__22__24___0___6___8__38__14__16__36___4__28___6___8
o_14_168_238__98_112_154_154_168___0__42__56_266__98_112_252__28_169__42__56
d__3__36__51__21__24__33__33__36___0___9__12__57__21__24__54___6__52___9__12
e__4__48__68__28__32__44__44__48___0__12__16__76__28__32__72___8__56__12__16
用其中的一行作为密文既可 例子：
密文：l 11 242 44 121 22 154 132 44 209 154 154 220 187 22 121 220 11
解答：根据第一项，全部除以11，因为l是第12个字母，即l=12-k，得k=1 按a=0 …… z=25，列出字母 WELCOME TO OUR CLUB
希尔密码
加密
例如：密钥（密码学中好象没有密匙一词）矩阵
1 3
0 2
明文：HI THERE
去空格，2个字母一组，根据字母表顺序换成矩阵数值如下，末尾的E为填充字符：
HI TH ER EE
8 20 5 5
9 8 18 5
HI 经过矩阵运算转换为 IS，具体算法参考下面的说明：
|1 3| 8 e1*8+3*9=35 MOD26=9 =I
|0 2| 9 e0*8+2*9=18 MOD26=18=R
用同样的方法把“HI THERE”转换为密文“IR RPGJTJ”，注意明文中的两个E分别变为密文中的G和T。
解密
解密时，必须先算出密钥的逆矩阵，然后再根据加密的过程做逆运算。
逆矩阵算法公式：
|A B| = 1/(AD-BC) * | D -B|
|C D| |-C A|
例如密钥矩阵=
|1 7|
|0 3|
AD-BC=1*3-0*7=3 3*X=1 mod26 所以 X=9
因此
|1 7| 的逆矩阵为：9 * |3 -7|
|0 3| |0 1|
假设密文为“FOAOESWO”
FO AO ES WO
6 1 5 23
15 15 19 15
9* |3 -7| | 6| = 9*（3*6-7*15）=-783 mod26 = 23=W
|0 1| |15| = 9*(0*6+1*15）= 135 mod26 = 5 =E
所以密文“FOAOESWO”的明文为“WEREDONE”
❾ 希尔密码，C语言实现
在网络文库里面搜索下，有不少说明的
这就是其中一个，里面有自带程序，看看是不是你想要的
http://wenku..com/view/f9ebdc6727d3240c8447efa4.html
❿ 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;// 矩阵相乘，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