简单可逆加密

‘壹’ 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这样的新成员，新成员的一个主要特征就是在算法上有创新和突破，而不仅仅是对传统算法进行修正或改进。密码学是一个正在不断发展的年轻学科，任何未被认识的加/解密机制都有可能在其中占有一席之地。

目前，对信息系统或电子邮件的安全问题，还没有一个非常有效的解决方案，其主要原因是由于互联网固有的异构性，没有一个单一的信任机构可以满足互联网全程异构性的所有需要，也没有一个单一的协议能够适用于互联网全程异构性的所有情况。解决的办法只有依靠软件代理了，即采用软件代理来自动管理用户所持有的证书（即用户所属的信任结构）以及用户所有的行为。每当用户要发送一则消息或一封电子邮件时，代理就会自动与对方的代理协商，找出一个共同信任的机构或一个通用协议来进行通信。在互联网环境中，下一代的安全信息系统会自动为用户发送加密邮件，同样当用户要向某人发送电子邮件时，用户的本地代理首先将与对方的代理交互，协商一个适合双方的认证机构。当然，电子邮件也需要不同的技术支持，因为电子邮件不是端到端的通信，而是通过多个中间机构把电子邮件分程传递到各自的通信机器上，最后到达目的地。