當前位置:首頁 » 密碼管理 » 簡單可逆加密

簡單可逆加密

發布時間: 2022-08-23 17:02:00

『壹』 php寫一個簡單的 數字轉化為同位數的數字 的加密可逆函數,帶干擾數的(可以用加減乘除)

<?php
/**
* DES Encrypt
*
* @param $input - stuff to decrypt
* @param $key - the secret key to use
* @return string
**/
function DES_Encrypt($input, $key)
{
$input = trim($input);
$key = substr(md5($key), 0, 24);
$td = mcrypt_mole_open('tripledes', '', 'ecb', '');
$iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);
mcrypt_generic_init($td, $key, $iv);
$encrypted_data = mcrypt_generic($td, $input);
mcrypt_generic_deinit($td);
mcrypt_mole_close($td);
return base64_encode($encrypted_data);
}

/**
* DES Decrypt
*
* @param $input - stuff to decrypt
* @param $key - the secret key to use
* @return string
**/
function DES_Decrypt($input, $key)
{
$input = base64_decode($input);
$td = mcrypt_mole_open('tripledes', '', 'ecb', '');
$key = substr(md5($key), 0, 24);
$iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);
mcrypt_generic_init($td, $key, $iv);
$decrypted_data = mdecrypt_generic($td, $input);
mcrypt_generic_deinit($td);
mcrypt_mole_close($td);
return trim(chop($decrypted_data));
}

『貳』 C#將字元串加密成數字,可逆解密,能實現不

再貼一個我昨晚寫的優化過的演算法,效率有明顯提升: string s = File.ReadAllText(@"c:\C語言概念題解答選編.txt", Encoding.GetEncoding("gb2312")); int key = 12345; StringBuilder sb = new StringBuilder(5 * s.Length); foreach (char c in s) sb.Append((c ^ key).ToString("D5")); string r1 = sb.ToString(); Response.Write("加密後:" + r1 + "<br/>"); sb = new StringBuilder(r1.Length / 5); for (int i = 0; i < r1.Length; i += 5) { int value = int.Parse(r1.Substring(i, 5)) ^ key; sb.Append((char)value); } string r2 = sb.ToString(); Response.Write("解密後:" + r2);測試100KB左右大小的文本文件,加密部分用時35毫秒、解密部分用時45毫秒。密鑰為0~65535的整數。

『叄』 傳統的加密方法有哪些

本文只是概述幾種簡單的傳統加密演算法,沒有DES,沒有RSA,沒有想像中的高端大氣上檔次的東東。。。但是都是很傳統很經典的一些演算法

首先,提到加密,比如加密一段文字,讓其不可讀,一般人首先會想到的是將其中的各個字元用其他一些特定的字元代替,比如,講所有的A用C來表示,所有的C用E表示等等…其中早的代替演算法就是由Julius Caesar發明的Caesar,它是用字母表中每個字母的之後的第三個字母來代替其本身的(C=E(3,p)=(p+3) mod 26),但是,這種加密方式,很容易可以用窮舉演算法來破解,畢竟只有25種可能的情況..

為了改進上訴演算法,增加其破解的難度,我們不用簡單的有序的替代方式,我們讓替代無序化,用其中字母表的一個置換(置換:有限元素的集合S的置換就是S的所有元素的有序排列,且每個元素就出現一次,如S={a,b}其置換就只有兩種:ab,ba),這樣的話,就有26!種方式,大大的增加了破解的難度,但是這個世界聰明人太多,雖然26!很多,但是語言本身有一定的特性,每個字母在語言中出現的相對頻率可以統計出來的,這樣子,只要密文有了一定數量,就可以從統計學的角度,得到准確的字母匹配了。

上面的演算法我們稱之為單表代替,其實單表代替密碼之所以較容易被攻破,因為它帶有原始字母使用頻率的一些統計學特徵。有兩種主要的方法可以減少代替密碼里明文結構在密文中的殘留度,一種是對明文中的多個字母一起加密,另一種是採用多表代替密碼。

先說多字母代替吧,最著名的就是playfair密碼,它把明文中的雙字母音節作為一個單元並將其轉換成密文的雙字母音節,它是一個基於由密鑰詞構成的5*5的字母矩陣中的,一個例子,如密鑰為monarchy,將其從左往右從上往下填入後,將剩餘的字母依次填入剩下的空格,其中I/J填入同一個空格:

對明文加密規則如下:
1 若p1 p2在同一行,對應密文c1 c2分別是緊靠p1 p2 右端的字母。其中第一列被看做是最後一列的右方。
2 若p1 p2在同一列,對應密文c1 c2分別是緊靠p1 p2 下方的字母。其中第一行被看做是最後一行的下方。
3 若p1 p2不在同一行,不在同一列,則c1 c2是由p1 p2確定的矩形的其他兩角的字母,並且c1和p1, c2和p2同行。
4 若p1 p2相同,則插入一個事先約定的字母,比如Q 。
5 若明文字母數為奇數時,則在明文的末端添加某個事先約定的字母作為填充。

雖然相對簡單加密,安全性有所提高,但是還是保留了明文語言的大部分結構特徵,依舊可以破解出來,另一個有意思的多表代替密碼是Hill密碼,由數學家Lester Hill提出來的,其實就是利用了線性代數中的可逆矩陣,一個矩陣乘以它的逆矩陣得到單位矩陣,那麼假設我們對密文每m個字母進行加密,那麼將這m個字母在字母表中的序號寫成矩陣形式設為P(如abc,[1,2,3]),密鑰就是一個m階的矩陣K,則C=P*K mod26,,解密的時候只要將密文乘上K的逆矩陣模26就可以了。該方法大大的增加了安全性。

『肆』 求一個用java編寫的可逆的加密演算法程序,自己寫的小程序也行。

public class mySecurity {
private static KeyGenerator keygen ;
private static SecretKey secretKey;
private static Cipher cipher;
private static mySecurity security = null;

private mySecurity(){
}
public static mySecurity getInstance() throws Exception{
if(security == null){
security = new mySecurity();
keygen = KeyGenerator.getInstance("AES");
secretKey = keygen.generateKey();
cipher =Cipher.getInstance("AES");
}
return security;
}

//加密
public String encrypt(String str) throws Exception{
cipher.init(Cipher.ENCRYPT_MODE,secretKey);

byte [] src = str.getBytes(); byte [] enc = cipher.doFinal(src);
return parseByte2HexStr(enc); }
//解密
public String decrypt(String str) throws Exception{
cipher.init(Cipher.DECRYPT_MODE,secretKey);

byte[] enc = parseHexStr2Byte(str); byte [] dec = cipher.doFinal(enc);
return new String(dec); }
/**將16進制轉換為二進制
* @param hexStr
* @return
*/
public static byte[] parseHexStr2Byte(String hexStr) {
if (hexStr.length() < 1)
return null;
byte[] result = new byte[hexStr.length()/2];
for (int i = 0;i< hexStr.length()/2; i++) {
int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);
int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);
result[i] = (byte) (high * 16 + low);
}
return result;
}

/**將二進制轉換成16進制
* @param buf
* @return
*/
public static String parseByte2HexStr(byte buf[]) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < buf.length; i++) {
String hex = Integer.toHexString(buf[i] & 0xFF);
if (hex.length() == 1) {
hex = '0' + hex;
}
sb.append(hex.toUpperCase());
}
return sb.toString();
}

public static void main(String[] args) throws Exception{
String str = "abc haha 我";
String ss = mySecurity.getInstance().encrypt(str) ;
System.out.println(ss);
System.out.println(mySecurity.getInstance().decrypt(ss));

}
}

『伍』 求簡潔的ASP可逆加密演算法,要求看不出規律。

<%
functionjiami(byvals)'加密
randomize
s=escape(s)
fori=1tolen(s)
k=int(rnd*256)
jiami=jiami&right("0"&hex(asc(mid(s,i,1))xork),2)&right("0"&hex(k),2)
next
endfunction

functionjiemi(byvals)'解密
fori=1tolen(s)step4
jiemi=jiemi&chr(int("&H"&mid(s,i,2))xorint("&H"&mid(s,i+2,2)))
next
jiemi=unescape(jiemi)
endfunction

s="123網路知道abc"
response.write"要加密的字元串:"&s&"<br>"
s=jiami(s)
response.write"加密後的字元串:"&s&"<br>"
s=jiemi(s)
response.write"解密後的字元串:"&s&"<br>"
%>

這個加密程序的妙處在於,同一個字元串每次加密後的字元串都是不相同的,但都能夠解密回原來的字元串。

『陸』 使用高級語言(C、C++、C#語言)實現一個加密/解密程序,調試並通過該程序。

同意一樓的看法,要不你就要赫夫曼編碼原理吧,這個比較簡單,實現也比較容易;根據字元出現的頻率作為字元權值,利用Huffman演算法進行處理,形成Huffman樹,得到Huffman碼,利用Huffman碼對字元進行加密,已二進制的形式存儲到磁碟。 再利用Huffman碼對加密後的文件解密。

#include<stdio.h>

typedef struct LNode{ /*-------------鏈表-------------------*/

int data;

struct LNode *next;

}LNode,*Linklist;

typedef struct Character{ /*-------------字元結構體-------------*/

char data; /*--------------字元值----------------*/

int frequency; /*-------------字元出現頻率-----------*/

}Character;

typedef struct HTNode{ /*-------------哈夫曼接點-------------*/

char data; /*-------------接點值-----------------*/

unsigned int weight; /*--------------權值------------------*/

unsigned int parent,lchild,rchild;

}HTNode,*HuffmanTree;

Linklist L; /*-------------鏈表頭接點--------------*/

Character T[256]; /*-----存放信息中出現的字元(不含漢字)----*/

HuffmanTree HT; /*--------------存放哈夫曼接點--------------*/

char *HC[257],*HA[256]; /*------HC中緊密存放哈夫曼編碼,HA中按字元值位置存放該字元的編碼,如A存放於HA中第65號元---*/

int len=0; /*-------------信息中出現的字元數量-----------*/

int s1,s2;

int i,j;

char ch;

char Infile[10],Outfile[10],decfile[10]; /*------分別為源信息文件,加密後的2進制文件(解密源文件),解密後的文件------*/

FILE *fp,*fin,*fout;

void Create_L(int n) /*------對有n接點建一條帶頭接點的鏈表(頭插法)-----*/

{

int i;

Linklist p,k;

L=(Linklist)malloc(sizeof(LNode));

k=L;

for(i=1;i<=n;i++)

{

p=(Linklist)malloc(sizeof(LNode));

p->next=NULL;

p->data=i;

k->next=p;k=p;

}

}

void Init() /*-------初始化,統計Infile中的字元數目len及每個字元出現的頻率------*/

{ /*-------將這len個字元存於T[0]到T[len-1]中,然後按頻率值將這len個字元按升序排列------*/

void QuickSort(Character A[],int p,int r);

printf("Input the Infilename:\n");

scanf("%s",Infile);

if((fp=fopen(Infile,"r"))==NULL)

{

printf("Cannot open Infile!\n");

exit(0);

}

for(i=0;i<256;i++)

{

T[i].data=i;

T[i].frequency=0;

}

while(!feof(fp))

{

ch=fgetc(fp);

T[ch].frequency++;

}

for(i=0,j=0;i<256;i++)

{

while(!T[i].frequency&&i<256)

T[i++].data=0;

if(i<256)

T[j++]=T[i];

}

len=j;

Create_L(len);

QuickSort(T,0,len-1);

fclose(fp);

}

void QuickSort(Character A[],int p,int r) /*--------冒泡法對A數組元素按頻率升序排列---------*/

{

Character t;

for(i=p;i<r;i++)

for(j=p;j<r-i;j++)

if(A[j].frequency>A[j+1].frequency)

{

t=A[j]; A[j]=A[j+1]; A[j+1]=t;

}

}

void Select() /*------------取出鏈表的前兩個權值最小的元素,將新增元素按升序規則插於鏈表-------*/

{

Linklist p,q;

int w,t;

p=L->next;

s1=p->data;

q=p->next;

s2=q->data;

w=HT[s1].weight+HT[s2].weight;

q->data=i;

L->next=q;

free(p);

while(q->next)

{

if(w>HT[q->next->data].weight)

{ t=q->data;q->data=q->next->data;q->next->data=t;}

q=q->next;

}

}

void HuffmanCoding(int n) /*-------對n種字元進行編碼存於*HA[257]中---------*/

{

int m,c,f,start;

int lencd;

HuffmanTree p;

char *cd;

if(n<=1) return;

m=2*n-1;

HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));

for(p=HT+1,i=1;i<=n;++i,++p)

{

p->data=T[i-1].data;

p->weight=T[i-1].frequency;

p->parent=0;

p->lchild=0;

p->rchild=0;

}

for(;i<=m;++i,++p)

{

p->data=0;

p->weight=0;

p->parent=0;

p->lchild=0;

p->rchild=0;

}

for(i=n+1;i<=m;++i)

{

Select();

HT[s1].parent=i;

HT[s2].parent=i;

HT[i].lchild=s1;

HT[i].rchild=s2;

HT[i].weight=HT[s1].weight+HT[s2].weight;

}

cd=(char *)malloc(n*sizeof(char));

for(start=0;start<n;start++) cd[i]='\0';

for(i=1;i<=n;++i)

{

start=0;

for(c=i,f=HT[i].parent;f!=0;f=HT[f].parent,c=HT[c].parent)

{

if(HT[f].lchild==c)

cd[start++]='0';

else

cd[start++]='1';

}

lencd=start;

HC[i]=(char *)malloc((lencd+1)*sizeof(char));

ch=HT[i].data;

HA[ch]=(char *)malloc((lencd+1)*sizeof(char));

for(start=lencd-1,j=0;start>=0;start--)

{

HC[i][j]=cd[start];

j++;

}

HC[i][j]='\0';

strcpy(HA[ch],HC[i]);

}

free(cd);

}

void Encrytion() /*-------按HA中的編碼把Infile文件中的每一個字元翻譯成2進制文件存於outfile文件中----*/

{

printf("Input the outfilename:\n");

scanf("%s",Outfile);

if((fout=fopen(Outfile,"a"))==NULL)

{

printf("Cannot open outfile!\n");

exit(0);

}

if((fin=fopen(Infile,"r"))==NULL)

{

printf("Cannot open Infile in the Encrytion!\n");

exit(0);

}

while(!feof(fin))

{

ch=fgetc(fin);

fputs(HA[ch],fout);

}

fclose(fin);

fclose(fout);

}

void Decryption() /*--------對存於outfile文件中的密文解碼,從哈夫曼樹的根接點按0,1分別選擇左右子樹,

直到葉子接點,輸出葉子接點值-----*/

{

int m=2*len-1;

if((fin=fopen(Outfile,"r"))==NULL)

{

printf("Cannot open sourcefile!\n");

exit(0);

}

printf("Input the decfile!\n");

scanf("%s",decfile);

if((fout=fopen(decfile,"a"))==NULL)

{

printf("Cannot open decfile!\n");

exit(0);

}

while(!feof(fin))

{

i=m;

while(HT[i].lchild&&HT[i].rchild)

{

ch=fgetc(fin);

if(ch=='0') i=HT[i].lchild;

else if(ch=='1') i=HT[i].rchild;

else

{

printf("END!\n");

exit(0);

}

}

printf("%c",HT[i].data);

fprintf(fout,"%c",HT[i].data);

}

fclose(fin);

fclose(fout);

}

/*----------------主函數----------------------*/

void main()

{

void Init(); /*---------------聲明部分-------------------*/

void HuffmanCoding(int n);

void Encrytion();

void Decryption();

Init(); /*--------------初始化函數------------------*/

HuffmanCoding(len); /*--------------編碼函數--------------------*/

Encrytion(); /*--------------加密函數--------------------*/

Decryption(); /*--------------解密函數--------------------*/

}

『柒』 誰能給個DELPHI寫的可逆加密函數

給你個簡單的字元串加密函數,第二次加密就等於解密。
function StrCrypt(ss: String): String;
const
c = 158;
var
i: Integer;
b: Byte;
begin
Result := ss;
for i := 1 to Length(ss) do begin
b := c - Ord(ss[i]);
Result[i] := Chr(b);
end;
end;
要安全的話,找 base64 或 MD5 等。

『捌』 求一簡單的php可逆加密

$arr1 = array('1','2','3');

function jiami($arr){
$newarr= array_reverse($arr);
return $newarr;
}
//到排後的新數組
$arr2 = jiami($arr1);
print_r($arr2);

//恢復的數組
$arr1 = jiami($arr2);
print_r($arr1);

『玖』 用JAVA設計一個簡單的加密、解密演算法,用該演算法來實現對數據的加密、解密

給你個MD5的加密演算法

package test;
import java.security.MessageDigest;
/**
* <p>Title: </p>
* <p>Description: </p>
* <p>Copyright: Copyright (c) 2003</p>
* <p>Company: </p>
* @author unascribed
* @version 1.0
*/

public class StringUtil {

private final static String[] hexDigits = {
"0", "1", "2", "3", "4", "5", "6", "7",
"8", "9", "a", "b", "c", "d", "e", "f"};

/**
* 轉換位元組數組為16進制字串
* @param b 位元組數組
* @return 16進制字串
*/

public static String byteArrayToHexString(byte[] b) {
StringBuffer resultSb = new StringBuffer();
for (int i = 0; i < b.length; i++) {
resultSb.append(byteToHexString(b[i]));
}
return resultSb.toString();
}

private static String byteToHexString(byte b) {
int n = b;
if (n < 0)
n = 256 + n;
int d1 = n / 16;
int d2 = n % 16;
return hexDigits[d1] + hexDigits[d2];
}

public static String MD5Encode(String origin) {
String resultString = null;

try {
resultString=new String(origin);
MessageDigest md = MessageDigest.getInstance("MD5");
resultString=byteArrayToHexString(md.digest(resultString.getBytes()));
}
catch (Exception ex) {

}
return resultString;
}

public static void main(String[] args){
System.err.println(MD5Encode("a"));
}
}

在RFC 1321中,給出了Test suite用來檢驗你的實現是否正確:

MD5 ("") =
MD5 ("a") =
MD5 ("abc") =
MD5 ("message digest") =
MD5 ("abcdefghijklmnopqrstuvwxyz") =

『拾』 目前常用的加密解密演算法有哪些

加密演算法

加密技術是對信息進行編碼和解碼的技術,編碼是把原來可讀信息(又稱明文)譯成代碼形式(又稱密文),其逆過程就是解碼(解密)。加密技術的要點是加密演算法,加密演算法可以分為對稱加密、不對稱加密和不可逆加密三類演算法。

對稱加密演算法 對稱加密演算法是應用較早的加密演算法,技術成熟。在對稱加密演算法中,數據發信方將明文(原始數據)和加密密鑰一起經過特殊加密演算法處理後,使其變成復雜的加密密文發送出去。收信方收到密文後,若想解讀原文,則需要使用加密用過的密鑰及相同演算法的逆演算法對密文進行解密,才能使其恢復成可讀明文。在對稱加密演算法中,使用的密鑰只有一個,發收信雙方都使用這個密鑰對數據進行加密和解密,這就要求解密方事先必須知道加密密鑰。對稱加密演算法的特點是演算法公開、計算量小、加密速度快、加密效率高。不足之處是,交易雙方都使用同樣鑰匙,安全性得不到保證。此外,每對用戶每次使用對稱加密演算法時,都需要使用其他人不知道的惟一鑰匙,這會使得發收信雙方所擁有的鑰匙數量成幾何級數增長,密鑰管理成為用戶的負擔。對稱加密演算法在分布式網路系統上使用較為困難,主要是因為密鑰管理困難,使用成本較高。在計算機專網系統中廣泛使用的對稱加密演算法有DES和IDEA等。美國國家標准局倡導的AES即將作為新標准取代DES。

不對稱加密演算法不對稱加密演算法使用兩把完全不同但又是完全匹配的一對鑰匙—公鑰和私鑰。在使用不對稱加密演算法加密文件時,只有使用匹配的一對公鑰和私鑰,才能完成對明文的加密和解密過程。加密明文時採用公鑰加密,解密密文時使用私鑰才能完成,而且發信方(加密者)知道收信方的公鑰,只有收信方(解密者)才是唯一知道自己私鑰的人。不對稱加密演算法的基本原理是,如果發信方想發送只有收信方才能解讀的加密信息,發信方必須首先知道收信方的公鑰,然後利用收信方的公鑰來加密原文;收信方收到加密密文後,使用自己的私鑰才能解密密文。顯然,採用不對稱加密演算法,收發信雙方在通信之前,收信方必須將自己早已隨機生成的公鑰送給發信方,而自己保留私鑰。由於不對稱演算法擁有兩個密鑰,因而特別適用於分布式系統中的數據加密。廣泛應用的不對稱加密演算法有RSA演算法和美國國家標准局提出的DSA。以不對稱加密演算法為基礎的加密技術應用非常廣泛。

不可逆加密演算法 不可逆加密演算法的特徵是加密過程中不需要使用密鑰,輸入明文後由系統直接經過加密演算法處理成密文,這種加密後的數據是無法被解密的,只有重新輸入明文,並再次經過同樣不可逆的加密演算法處理,得到相同的加密密文並被系統重新識別後,才能真正解密。顯然,在這類加密過程中,加密是自己,解密還得是自己,而所謂解密,實際上就是重新加一次密,所應用的「密碼」也就是輸入的明文。不可逆加密演算法不存在密鑰保管和分發問題,非常適合在分布式網路系統上使用,但因加密計算復雜,工作量相當繁重,通常只在數據量有限的情形下使用,如廣泛應用在計算機系統中的口令加密,利用的就是不可逆加密演算法。近年來,隨著計算機系統性能的不斷提高,不可逆加密的應用領域正在逐漸增大。在計算機網路中應用較多不可逆加密演算法的有RSA公司發明的MD5演算法和由美國國家標准局建議的不可逆加密標准SHS(Secure Hash Standard:安全雜亂信息標准)等。

加密技術

加密演算法是加密技術的基礎,任何一種成熟的加密技術都是建立多種加密演算法組合,或者加密演算法和其他應用軟體有機結合的基礎之上的。下面我們介紹幾種在計算機網路應用領域廣泛應用的加密技術。

非否認(Non-repudiation)技術 該技術的核心是不對稱加密演算法的公鑰技術,通過產生一個與用戶認證數據有關的數字簽名來完成。當用戶執行某一交易時,這種簽名能夠保證用戶今後無法否認該交易發生的事實。由於非否認技術的操作過程簡單,而且直接包含在用戶的某類正常的電子交易中,因而成為當前用戶進行電子商務、取得商務信任的重要保證。

PGP(Pretty Good Privacy)技術 PGP技術是一個基於不對稱加密演算法RSA公鑰體系的郵件加密技術,也是一種操作簡單、使用方便、普及程度較高的加密軟體。PGP技術不但可以對電子郵件加密,防止非授權者閱讀信件;還能對電子郵件附加數字簽名,使收信人能明確了解發信人的真實身份;也可以在不需要通過任何保密渠道傳遞密鑰的情況下,使人們安全地進行保密通信。PGP技術創造性地把RSA不對稱加密演算法的方便性和傳統加密體系結合起來,在數字簽名和密鑰認證管理機制方面採用了無縫結合的巧妙設計,使其幾乎成為最為流行的公鑰加密軟體包。

數字簽名(Digital Signature)技術 數字簽名技術是不對稱加密演算法的典型應用。數字簽名的應用過程是,數據源發送方使用自己的私鑰對數據校驗和或其他與數據內容有關的變數進行加密處理,完成對數據的合法「簽名」,數據接收方則利用對方的公鑰來解讀收到的「數字簽名」,並將解讀結果用於對數據完整性的檢驗,以確認簽名的合法性。數字簽名技術是在網路系統虛擬環境中確認身份的重要技術,完全可以代替現實過程中的「親筆簽字」,在技術和法律上有保證。在公鑰與私鑰管理方面,數字簽名應用與加密郵件PGP技術正好相反。在數字簽名應用中,發送者的公鑰可以很方便地得到,但他的私鑰則需要嚴格保密。

PKI(Public Key Infrastructure)技術 PKI技術是一種以不對稱加密技術為核心、可以為網路提供安全服務的公鑰基礎設施。PKI技術最初主要應用在Internet環境中,為復雜的互聯網系統提供統一的身份認證、數據加密和完整性保障機制。由於PKI技術在網路安全領域所表現出的巨大優勢,因而受到銀行、證券、政府等核心應用系統的青睞。PKI技術既是信息安全技術的核心,也是電子商務的關鍵和基礎技術。由於通過網路進行的電子商務、電子政務等活動缺少物理接觸,因而使得利用電子方式驗證信任關系變得至關重要,PKI技術恰好能夠有效解決電子商務應用中的機密性、真實性、完整性、不可否認性和存取控制等安全問題。一個實用的PKI體系還必須充分考慮互操作性和可擴展性。PKI體系所包含的認證中心(CA)、注冊中心(RA)、策略管理、密鑰與證書管理、密鑰備份與恢復、撤銷系統等功能模塊應該有機地結合在一起。

加密的未來趨勢

盡管雙鑰密碼體制比單鑰密碼體制更為可靠,但由於計算過於復雜,雙鑰密碼體制在進行大信息量通信時,加密速率僅為單鑰體制的1/100,甚至是 1/1000。正是由於不同體制的加密演算法各有所長,所以在今後相當長的一段時期內,各類加密體制將會共同發展。而在由IBM等公司於1996年聯合推出的用於電子商務的協議標准SET(Secure Electronic Transaction)中和1992年由多國聯合開發的PGP技術中,均採用了包含單鑰密碼、雙鑰密碼、單向雜湊演算法和隨機數生成演算法在內的混合密碼系統的動向來看,這似乎從一個側面展示了今後密碼技術應用的未來。

在單鑰密碼領域,一次一密被認為是最為可靠的機制,但是由於流密碼體制中的密鑰流生成器在演算法上未能突破有限循環,故一直未被廣泛應用。如果找到一個在演算法上接近無限循環的密鑰流生成器,該體制將會有一個質的飛躍。近年來,混沌學理論的研究給在這一方向產生突破帶來了曙光。此外,充滿生氣的量子密碼被認為是一個潛在的發展方向,因為它是基於光學和量子力學理論的。該理論對於在光纖通信中加強信息安全、對付擁有量子計算能力的破譯無疑是一種理想的解決方法。

由於電子商務等民用系統的應用需求,認證加密演算法也將有較大發展。此外,在傳統密碼體制中,還將會產生類似於IDEA這樣的新成員,新成員的一個主要特徵就是在演算法上有創新和突破,而不僅僅是對傳統演算法進行修正或改進。密碼學是一個正在不斷發展的年輕學科,任何未被認識的加/解密機制都有可能在其中佔有一席之地。

目前,對信息系統或電子郵件的安全問題,還沒有一個非常有效的解決方案,其主要原因是由於互聯網固有的異構性,沒有一個單一的信任機構可以滿足互聯網全程異構性的所有需要,也沒有一個單一的協議能夠適用於互聯網全程異構性的所有情況。解決的辦法只有依靠軟體代理了,即採用軟體代理來自動管理用戶所持有的證書(即用戶所屬的信任結構)以及用戶所有的行為。每當用戶要發送一則消息或一封電子郵件時,代理就會自動與對方的代理協商,找出一個共同信任的機構或一個通用協議來進行通信。在互聯網環境中,下一代的安全信息系統會自動為用戶發送加密郵件,同樣當用戶要向某人發送電子郵件時,用戶的本地代理首先將與對方的代理交互,協商一個適合雙方的認證機構。當然,電子郵件也需要不同的技術支持,因為電子郵件不是端到端的通信,而是通過多個中間機構把電子郵件分程傳遞到各自的通信機器上,最後到達目的地。

熱點內容
完美跑圖伺服器是什麼 發布:2025-07-08 01:52:31 瀏覽:667
連王者榮耀伺服器失敗是什麼原因 發布:2025-07-08 01:48:34 瀏覽:593
安卓設置橫向豎向在哪裡 發布:2025-07-08 01:45:33 瀏覽:882
安卓的語音助手叫什麼 發布:2025-07-08 01:45:22 瀏覽:639
如何運行android項目 發布:2025-07-08 01:44:47 瀏覽:264
腳本韓信 發布:2025-07-08 01:30:59 瀏覽:949
lua腳本linux 發布:2025-07-08 01:20:57 瀏覽:220
平板如何關掉appstore密碼 發布:2025-07-08 00:59:17 瀏覽:406
安卓版軒轅劍劍之源哪裡下載 發布:2025-07-08 00:55:06 瀏覽:676
安卓的軟體怎麼關閉 發布:2025-07-08 00:53:38 瀏覽:778