今天给各位分享通用加密算法的知识，如果能碰巧解决你现在面临的问题，别忘了关注本站。
移动端越来越火了，我们在开发过程中，总会碰到要和移动端打交道的场景，比如.NET和android或者iOS的打交道。为了让数据交互更安全，我们需要对数据进行加密传输。今天研究了一下，把几种语言的加密都实践了一遍，实现了.NET，java(android)，iOS都同一套的加密算法，下面就分享给大家。
aes加密有多种算法模式，下面提供两套模式的可用源码。
加密方式：
先将文本aes加密
返回Base64转码
解密方式：
将数据进行Base64解码
进行aes解密
一、CBC（Cipher Block Chaining，加密块链）模式
是一种循环模式，前一个分组的密文和当前分组的明文异或操作后再加密，这样做的目的是增强破解难度.
密钥
密钥偏移量
java/adroid加密aesOperator类：
package com.bci.wx.base.util;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/**
* aes 是一种可逆加密算法，对用户的敏感信息加密处理 对原始数据进行aes加密后，在进行Base64编码转化；
*/
public class aesOperator {
/*
* 加密用的Key 可以用26个字母和数字组成 此处使用aes-128-CBC加密模式，key需要为16位。
*/
private String sKey = "smkldospdosldaaa";//key，可自行修改
private String ivParameter = "0392039203920300";//偏移量,可自行修改
private static aesOperator instance = null;
private aesOperator() {
}
public static aesOperator getInstance() {
if (instance == null)
instance = new aesOperator();
return instance;
}
public static String Encrypt(String encData ,String secretKey,String vector) throws Exception {
if(secretKey == null) {
return null;
}
if(secretKey.length() != 16) {
return null;
}
Cipher cipher = Cipher.getInstance("aes/CBC/PKCS5Padding");
byte[] raw = secretKey.getBytes();
SecretKeySpec skeySpec = new SecretKeySpec(raw, "aes");
IvParameterSpec iv = new IvParameterSpec(vector.getBytes());// 使用CBC模式，需要一个向量iv，可增加加密算法的强度
cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
byte[] encrypted = cipher.doFinal(encData.getBytes("utf-8"));
return new BASE64Encoder().encode(encrypted);// 此处使用BASE64做转码。
}
// 加密
public String encrypt(String sSrc) throws Exception {
Cipher cipher = Cipher.getInstance("aes/CBC/PKCS5Padding");
byte[] raw = sKey.getBytes();
SecretKeySpec skeySpec = new SecretKeySpec(raw, "aes");
IvParameterSpec iv = new IvParameterSpec(ivParameter.getBytes());// 使用CBC模式，需要一个向量iv，可增加加密算法的强度
cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
byte[] encrypted = cipher.doFinal(sSrc.getBytes("utf-8"));
return new BASE64Encoder().encode(encrypted);// 此处使用BASE64做转码。
}
// 解密
public String decrypt(String sSrc) throws Exception {
try {
byte[] raw = sKey.getBytes("ASCII");
SecretKeySpec skeySpec = new SecretKeySpec(raw, "aes");
Cipher cipher = Cipher.getInstance("aes/CBC/PKCS5Padding");
IvParameterSpec iv = new IvParameterSpec(ivParameter.getBytes());
cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
byte[] encrypted1 = new BASE64Decoder().decodeBuffer(sSrc);// 先用base64解密
byte[] original = cipher.doFinal(encrypted1);
String originalString = new String(original, "utf-8");
return originalString;
} catch (Exception ex) {
return null;
}
}
public String decrypt(String sSrc,String key,String ivs) throws Exception {
try {
byte[] raw = key.getBytes("ASCII");
SecretKeySpec skeySpec = new SecretKeySpec(raw, "aes");
Cipher cipher = Cipher.getInstance("aes/CBC/PKCS5Padding");
IvParameterSpec iv = new IvParameterSpec(ivs.getBytes());
cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
byte[] encrypted1 = new BASE64Decoder().decodeBuffer(sSrc);// 先用base64解密
byte[] original = cipher.doFinal(encrypted1);
String originalString = new String(original, "utf-8");
return originalString;
} catch (Exception ex) {
return null;
}
}
public static String encodeBytes(byte[] bytes) {
StringBuffer strBuf = new StringBuffer();
for (int i = 0; i bytes.length; i++) {
strBuf.append((char) (((bytes[i] 4) 0xF) + ((int) 'a')));
strBuf.append((char) (((bytes[i]) 0xF) + ((int) 'a')));
}
return strBuf.toString();
}
md5加密是比较通用的加密算法
如果你想要可逆的加密算法的话，可以用随机数做种子来写，一般可逆的算法都是按自己的想法去写的，最简单的就是字母的移位，ASCII码加密等等。
一．加密
DES算法处理的数据对象是一组64比特的明文串。设该明文串为m=m1m2…m64 (mi=0或1)。明文串经过64比特的密钥K来加密，最后生成长度为64比特的密文E。其加密过程图示如下：
DES算法加密过程
对DES算法加密过程图示的说明如下：待加密的64比特明文串m，经过IP置换后，得到的比特串的下标列表如下：
IP 58 50 42 34 26 18 10 2
60 52 44 36 28 20 12 4
62 54 46 38 30 22 14 6
64 56 48 40 32 24 16 8
57 49 41 33 25 17 9 1
59 51 43 35 27 19 11 3
61 53 45 37 29 21 13 5
63 55 47 39 31 23 15 7
该比特串被分为32位的L0和32位的R0两部分。R0子密钥K1(子密钥的生成将在后面讲)经过变换f(R0,K1)（f变换将在下面讲）输出32位的比特串f1,f1与L0做不进位的二进制加法运算。运算规则为：
f1与L0做不进位的二进制加法运算后的结果赋给R1，R0则原封不动的赋给L1。L1与R0又做与以上完全相同的运算，生成L2，R2…… 一共经过16次运算。最后生成R16和L16。其中R16为L15与f(R15,K16)做不进位二进制加法运算的结果，L16是R15的直接赋值。
R16与L16合并成64位的比特串。值得注意的是R16一定要排在L16前面。R16与L16合并后成的比特串，经过置换IP-1后所得比特串的下标列表如下：
IP-1 40 8 48 16 56 24 64 32
39 7 47 15 55 23 63 31
38 6 46 14 54 22 62 30
37 5 45 13 53 21 61 29
36 4 44 12 52 20 60 28
35 3 43 11 51 19 59 27
34 2 42 10 50 18 58 26
33 1 41 9 49 17 57 25
经过置换IP-1后生成的比特串就是密文e.。
下面再讲一下变换f(Ri-1,Ki)。
它的功能是将32比特的输入再转化为32比特的输出。其过程如图所示：
对f变换说明如下：输入Ri-1(32比特)经过变换E后，膨胀为48比特。膨胀后的比特串的下标列表如下：
E: 32 1 2 3 4 5
4 5 6 7 8 9
8 9 10 11 12 13
12 13 14 15 16 17
16 17 18 19 20 21
20 21 22 23 24 25
24 25 26 27 28 29
28 29 30 31 32 31
膨胀后的比特串分为8组，每组6比特。各组经过各自的S盒后，又变为4比特(具体过程见后)，合并后又成为32比特。该32比特经过P变换后，其下标列表如下：
P: 16 7 20 21
29 12 28 17
1 15 23 26
5 18 31 10
2 8 24 14
32 27 3 9
19 13 30 6
22 11 4 25
经过P变换后输出的比特串才是32比特的f (Ri-1,Ki)。
下面再讲一下S盒的变换过程。任取一S盒。见图：
在其输入b1,b2,b3,b4,b5,b6中，计算出x=b1*2+b6, y=b5+b4*2+b3*4+b2*8，再从Si表中查出x 行，y 列的值Sxy。将Sxy化为二进制，即得Si盒的输出。（S表如图所示）
至此，DES算法加密原理讲完了。在VC++6.0下的程序源代码为：
for(i=1;i=64;i++)
m1[i]=m[ip[i-1]];//64位明文串输入，经过IP置换。
下面进行迭代。由于各次迭代的方法相同只是输入输出不同，因此只给出其中一次。以第八次为例：//进行第八次迭代。首先进行S盒的运算，输入32位比特串。
for(i=1;i=48;i++)//经过E变换扩充，由32位变为48位
RE1[i]=R7[E[i-1]];
for(i=1;i=48;i++)//与K8按位作不进位加法运算
RE1[i]=RE1[i]+K8[i];
for(i=1;i=48;i++)
{
if(RE1[i]==2)
RE1[i]=0;
}
for(i=1;i7;i++)//48位分成8组
{
s11[i]=RE1[i];
s21[i]=RE1[i+6];
s31[i]=RE1[i+12];
s41[i]=RE1[i+18];
s51[i]=RE1[i+24];
s61[i]=RE1[i+30];
s71[i]=RE1[i+36];
s81[i]=RE1[i+42];
}//下面经过S盒，得到8个数。S1,s2,s3,s4,s5,s6,s7,s8分别为S表
s[1]=s1[s11[6]+s11[1]*2][s11[5]+s11[4]*2+s11[3]*4+s11[2]*8];
s[2]=s2[s21[6]+s21[1]*2][s21[5]+s21[4]*2+s21[3]*4+s21[2]*8];
s[3]=s3[s31[6]+s31[1]*2][s31[5]+s31[4]*2+s31[3]*4+s31[2]*8];
s[4]=s4[s41[6]+s41[1]*2][s41[5]+s41[4]*2+s41[3]*4+s41[2]*8];
s[5]=s5[s51[6]+s51[1]*2][s51[5]+s51[4]*2+s51[3]*4+s51[2]*8];
s[6]=s6[s61[6]+s61[1]*2][s61[5]+s61[4]*2+s61[3]*4+s61[2]*8];
s[7]=s7[s71[6]+s71[1]*2][s71[5]+s71[4]*2+s71[3]*4+s71[2]*8];
s[8]=s8[s81[6]+s81[1]*2][s81[5]+s81[4]*2+s81[3]*4+s81[2]*8];
for(i=0;i8;i++)//8个数变换输出二进制
{
for(j=1;j5;j++)
{
temp[j]=s[i+1]%2;
s[i+1]=s[i+1]/2;
}
for(j=1;j5;j++)
f[4*i+j]=temp[5-j];
}
for(i=1;i33;i++)//经过P变换
frk[i]=f[P[i-1]];//S盒运算完成
for(i=1;i33;i++)//左右交换
L8[i]=R7[i];
for(i=1;i33;i++)//R8为L7与f(R,K)进行不进位二进制加法运算结果
{
R8[i]=L7[i]+frk[i];
if(R8[i]==2)
R8[i]=0;
}
[ 原创文档 本文适合中级读者 已阅读21783次 ] 文档 代码 工具
DES算法及其在VC++6.0下的实现(下)
作者：航天医学工程研究所四室 朱彦军
在《DES算法及其在VC++6.0下的实现(上)》中主要介绍了DES算法的基本原理，下面让我们继续：
二．子密钥的生成
64比特的密钥生成16个48比特的子密钥。其生成过程见图：
子密钥生成过程具体解释如下：
64比特的密钥K，经过PC-1后，生成56比特的串。其下标如表所示：
PC-1 57 49 41 33 25 17 9
1 58 50 42 34 26 18
10 2 59 51 43 35 27
19 11 3 60 52 44 36
63 55 47 39 31 23 15
7 62 54 46 38 30 22
14 6 61 53 45 37 29
21 13 5 28 20 12 4
该比特串分为长度相等的比特串C0和D0。然后C0和D0分别循环左移1位，得到C1和D1。C1和D1合并起来生成C1D1。C1D1经过PC-2变换后即生成48比特的K1。K1的下标列表为：
PC-2 14 17 11 24 1 5
3 28 15 6 21 10
23 19 12 4 26 8
16 7 27 20 13 2
41 52 31 37 47 55
30 40 51 45 33 48
44 49 39 56 34 53
46 42 50 36 29 32
C1、D1分别循环左移LS2位，再合并，经过PC-2，生成子密钥K2……依次类推直至生成子密钥K16。
注意：Lsi (I =1,2,….16)的数值是不同的。具体见下表：
迭代顺序 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
左移位数 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1
生成子密钥的VC程序源代码如下：
for(i=1;i57;i++)//输入64位K，经过PC-1变为56位 k0[i]=k[PC_1[i-1]];
56位的K0，均分为28位的C0，D0。C0，D0生成K1和C1，D1。以下几次迭代方法相同，仅以生成K8为例。 for(i=1;i27;i++)//循环左移两位
{
C8[i]=C7[i+2];
D8[i]=D7[i+2];
}
C8[27]=C7[1];
D8[27]=D7[1];
C8[28]=C7[2];
D8[28]=D7[2];
for(i=1;i=28;i++)
{
C[i]=C8[i];
C[i+28]=D8[i];
}
for(i=1;i=48;i++)
K8[i]=C[PC_2[i-1]];//生成子密钥k8
注意：生成的子密钥不同，所需循环左移的位数也不同。源程序中以生成子密钥 K8为例，所以循环左移了两位。但在编程中，生成不同的子密钥应以Lsi表为准。
三．解密
DES的解密过程和DES的加密过程完全类似，只不过将16圈的子密钥序列K1，K2……K16的顺序倒过来。即第一圈用第16个子密钥K16，第二圈用K15，其余类推。
第一圈：
加密后的结果
L=R15, R=L15⊕f(R15,K16)⊕f(R15,K16)=L15
同理R15=L14⊕f(R14,K15), L15=R14。
同理类推：
得 L=R0, R=L0。
其程序源代码与加密相同。在此就不重写。
四．示例
例如：已知明文m=learning, 密钥 k=computer。
明文m的ASCII二进制表示：
m= 01101100 01100101 01100001 01110010
01101110 01101001 01101110 01100111
密钥k的ASCII二进制表示：
k=01100011 01101111 01101101 01110000
01110101 01110100 01100101 01110010
明文m经过IP置换后，得：
11111111 00001000 11010011 10100110 00000000 11111111 01110001 11011000
等分为左右两段：
L0=11111111 00001000 11010011 10100110 R0=00000000 11111111 01110001 11011000
经过16次迭代后，所得结果为：
L1=00000000 11111111 01110001 11011000 R1=00110101 00110001 00111011 10100101
L2=00110101 00110001 00111011 10100101 R2=00010111 11100010 10111010 10000111
L3=00010111 11100010 10111010 10000111 R3=00111110 10110001 00001011 10000100
L4=00111110101100010000101110000100 R4=11110111110101111111101000111110
L5=11110111110101111111101000111110 R5=10010110011001110100111111100101
L6=10010110011001110100111111100101 R6=11001011001010000101110110100111
L7=11001011001010000101110110100111 R7=01100011110011101000111011011001
L8=01100011110011101000111011011001 R8=01001011110100001111001000000100
L9=01001011110100001111001000000100 R9=00011101001101111010111011100001
L10=00011101001101111010111011100001 R10=11101110111110111111010100000101
L11=11101110111110111111010100000101 R11=01101101111011011110010111111000
L12=01101101111011011110010111111000 R12=11111101110011100111000110110111
L13=11111101110011100111000110110111 R13=11100111111001011010101000000100
L14=11100111111001011010101000000100 R14=00011110010010011011100001100001
L15=00011110010010011011100001100001 R15=01010000111001001101110110100011
L16=01010000111001001101110110100011 R16=01111101101010000100110001100001
其中，f函数的结果为：
f1=11001010001110011110100000000011 f2=00010111000111011100101101011111
f3=00001011100000000011000000100001 f4=11100000001101010100000010111001
f5=10101000110101100100010001100001 f6=00111100111111111010011110011001
f7=11110101101010011100000100111100 f8=10000000111110001010111110100011
f9=01111110111110010010000000111000 f10=10100101001010110000011100000001
f11=01110000110110100100101100011001 f12=00010011001101011000010010110010
f13=10001010000010000100111111111100 f14=11100011100001111100100111010110
f15=10110111000000010111011110100111 f16=01100011111000011111010000000000
16个子密钥为：
K1=11110000101111101110111011010000 K2=11100000101111101111011010010101
K3=11110100111111100111011000101000 K4=11100110111101110111001000011010
K5=11101110110101110111011100100110 K6=11101111110100110101101110001011
K7=00101111110100111111101111100110 K8=10111111010110011101101101010000
K9=00011111010110111101101101000100 K10=00111111011110011101110100001001
K11=00011111011011011100110101101000 K12=01011011011011011011110100001010
K13=11011101101011011010110110001111 K14=11010011101011101010111110000000
K15=11111001101111101010011011010011 K16=11110001101111100010111000000001
S盒中，16次运算时，每次的8 个结果为：
第一次：5，11，4，1，0，3，13，9；
第二次：7，13，15，8，12，12，13，1；
第三次：8，0，0，4，8，1，9，12；
第四次：0，7，4，1，7，6，12，4；
第五次：8，1，0，11，5，0，14，14；
第六次：14，12，13，2，7，15，14，10；
第七次：12，15，15，1，9，14，0，4；
第八次：15，8，8，3，2，3，14，5；
第九次：8，14，5，2，1，15，5，12；
第十次：2，8，13，1，9，2，10，2；
第十一次：10，15，8，2，1，12，12，3；
第十二次：5，4，4，0，14，10，7，4；
第十三次：2，13，10，9，2，4，3，13；
第十四次：13，7，14，9，15，0，1，3；
第十五次：3，1，15，5，11，9，11，4；
第十六次：12，3，4，6，9，3，3，0；
子密钥生成过程中，生成的数值为：
C0=0000000011111111111111111011 D0=1000001101110110000001101000
C1=0000000111111111111111110110 D1=0000011011101100000011010001
C2=0000001111111111111111101100 D2=0000110111011000000110100010
C3=0000111111111111111110110000 D3=0011011101100000011010001000
C4=0011111111111111111011000000 D4=1101110110000001101000100000
C5=1111111111111111101100000000 D5=0111011000000110100010000011
C6=1111111111111110110000000011 D6=1101100000011010001000001101
C7=1111111111111011000000001111 D7=0110000001101000100000110111
C8=1111111111101100000000111111 D8=1000000110100010000011011101
C9=1111111111011000000001111111 D9=0000001101000100000110111011
C10=1111111101100000000111111111 D10=0000110100010000011011101100
C11=1111110110000000011111111111 D11=0011010001000001101110110000
C12=1111011000000001111111111111 D12=1101000100000110111011000000
C13=1101100000000111111111111111 D13=0100010000011011101100000011
C14=0110000000011111111111111111 D14=0001000001101110110000001101
C15=1000000001111111111111111101 D15=0100000110111011000000110100
C16=0000000011111111111111111011 D16=1000001101110110000001101000
加密算法
加密技术是对信息进行编码和解码的技术，编码是把原来可读信息（又称明文）译成代码形式（又称密文），其逆过程就是解码（解密）。加密技术的要点是加密算法，加密算法可以分为对称加密、不对称加密和不可逆加密三类算法。
对称加密算法 对称加密算法是应用较早的加密算法，技术成熟。在对称加密算法中，数据发信方将明文（原始数据）和加密密钥一起经过特殊加密算法处理后，使其变成复杂的加密密文发送出去。收信方收到密文后，若想解读原文，则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。在对称加密算法中，使用的密钥只有一个，发收信双方都使用这个密钥对数据进行加密和解密，这就要求解密方事先必须知道加密密钥。对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。不足之处是，交易双方都使用同样钥匙，安全性得不到保证。此外，每对用户每次使用对称加密算法时，都需要使用其他人不知道的惟一钥匙，这会使得发收信双方所拥有的钥匙数量成几何级数增长，密钥管理成为用户的负担。对称加密算法在分布式网络系统上使用较为困难，主要是因为密钥管理困难，使用成本较高。在计算机专网系统中广泛使用的对称加密算法有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这样的新成员，新成员的一个主要特征就是在算法上有创新和突破，而不仅仅是对传统算法进行修正或改进。密码学是一个正在不断发展的年轻学科，任何未被认识的加/解密机制都有可能在其中占有一席之地。
目前，对信息系统或电子邮件的安全问题，还没有一个非常有效的解决方案，其主要原因是由于互联网固有的异构性，没有一个单一的信任机构可以满足互联网全程异构性的所有需要，也没有一个单一的协议能够适用于互联网全程异构性的所有情况。解决的办法只有依靠软件代理了，即采用软件代理来自动管理用户所持有的证书（即用户所属的信任结构）以及用户所有的行为。每当用户要发送一则消息或一封电子邮件时，代理就会自动与对方的代理协商，找出一个共同信任的机构或一个通用协议来进行通信。在互联网环境中，下一代的安全信息系统会自动为用户发送加密邮件，同样当用户要向某人发送电子邮件时，用户的本地代理首先将与对方的代理交互，协商一个适合双方的认证机构。当然，电子邮件也需要不同的技术支持，因为电子邮件不是端到端的通信，而是通过多个中间机构把电子邮件分程传递到各自的通信机器上，最后到达目的地。
unit aes;
interface
uses
SysUtils, Classes, Math, Elaes;
type
TKeyBit = (kb128, kb192, kb256);
function StrToHex(Value: string): string;
function HexToStr(Value: string): string;
function EncryptString(Value: string; Key: string;
KeyBit: TKeyBit = kb128): string;
function DecryptString(Value: string; Key: string;
KeyBit: TKeyBit = kb128): string;
function EncryptStream(Stream: TStream; Key: string;
KeyBit: TKeyBit = kb128): TStream;
function DecryptStream(Stream: TStream; Key: string;
KeyBit: TKeyBit = kb128): TStream;
procedure EncryptFile(SourceFile, DestFile: string;
Key: string; KeyBit: TKeyBit = kb128);
procedure DecryptFile(SourceFile, DestFile: string;
Key: string; KeyBit: TKeyBit = kb128);
implementation
function StrToHex(Value: string): string;
var
I: Integer;
begin
Result := '';
for I := 1 to Length(Value) do
Result := Result + IntToHex(Ord(Value[I]), 2);
end;
function HexToStr(Value: string): string;
var
I: Integer;
begin
Result := '';
for I := 1 to Length(Value) do
begin
if ((I mod 2) = 1) then
Result := Result + Chr(StrToInt('0x'+ Copy(Value, I, 2)));
end;
end;
{ -- 字符串加密函数 默认按照 128 位密匙加密 -- }
function EncryptString(Value: string; Key: string;
KeyBit: TKeyBit = kb128): string;
var
SS, DS: TStringStream;
Size: Int64;
aesKey128: TaesKey128;
aesKey192: TaesKey192;
aesKey256: TaesKey256;
begin
Result := '';
SS := TStringStream.Create(Value);
DS := TStringStream.Create('');
try
Size := SS.Size;
DS.WriteBuffer(Size, SizeOf(Size));
{ -- 128 位密匙最大长度为 16 个字符 -- }
if KeyBit = kb128 then
begin
FillChar(aesKey128, SizeOf(aesKey128), 0 );
Move(PChar(Key)^, aesKey128, Min(SizeOf(aesKey128), Length(Key)));
EncryptaesStreamECB(SS, 0, aesKey128, DS);
end;
{ -- 192 位密匙最大长度为 24 个字符 -- }
if KeyBit = kb192 then
begin
FillChar(aesKey192, SizeOf(aesKey192), 0 );
Move(PChar(Key)^, aesKey192, Min(SizeOf(aesKey192), Length(Key)));
EncryptaesStreamECB(SS, 0, aesKey192, DS);
end;
{ -- 256 位密匙最大长度为 32 个字符 -- }
if KeyBit = kb256 then
begin
FillChar(aesKey256, SizeOf(aesKey256), 0 );
Move(PChar(Key)^, aesKey256, Min(SizeOf(aesKey256), Length(Key)));
EncryptaesStreamECB(SS, 0, aesKey256, DS);
end;
Result := StrToHex(DS.DataString);
finally
SS.Free;
DS.Free;
end;
end;
{ -- 字符串解密函数 默认按照 128 位密匙解密 -- }
function DecryptString(Value: string; Key: string;
KeyBit: TKeyBit = kb128): string;
var
SS, DS: TStringStream;
Size: Int64;
aesKey128: TaesKey128;
aesKey192: TaesKey192;
aesKey256: TaesKey256;
begin
Result := '';
SS := TStringStream.Create(HexToStr(Value));
DS := TStringStream.Create('');
try
Size := SS.Size;
SS.ReadBuffer(Size, SizeOf(Size));
{ -- 128 位密匙最大长度为 16 个字符 -- }
if KeyBit = kb128 then
begin
FillChar(aesKey128, SizeOf(aesKey128), 0 );
Move(PChar(Key)^, aesKey128, Min(SizeOf(aesKey128), Length(Key)));
DecryptaesStreamECB(SS, SS.Size - SS.Position, aesKey128, DS);
end;
{ -- 192 位密匙最大长度为 24 个字符 -- }
if KeyBit = kb192 then
begin
FillChar(aesKey192, SizeOf(aesKey192), 0 );
Move(PChar(Key)^, aesKey192, Min(SizeOf(aesKey192), Length(Key)));
DecryptaesStreamECB(SS, SS.Size - SS.Position, aesKey192, DS);
end;
{ -- 256 位密匙最大长度为 32 个字符 -- }
if KeyBit = kb256 then
begin
FillChar(aesKey256, SizeOf(aesKey256), 0 );
Move(PChar(Key)^, aesKey256, Min(SizeOf(aesKey256), Length(Key)));
DecryptaesStreamECB(SS, SS.Size - SS.Position, aesKey256, DS);
end;
Result := DS.DataString;
finally
SS.Free;
DS.Free;
end;
end;
{ -- 流加密函数 默认按照 128 位密匙解密 -- }
function EncryptStream(Stream: TStream; Key: string;
KeyBit: TKeyBit = kb128): TStream;
var
Count: Int64;
OutStrm: TStream;
aesKey128: TaesKey128;
aesKey192: TaesKey192;
aesKey256: TaesKey256;
begin
OutStrm := TStream.Create;
Stream.Position := 0;
Count := Stream.Size;
OutStrm.Write(Count, SizeOf(Count));
try
{ -- 128 位密匙最大长度为 16 个字符 -- }
if KeyBit = kb128 then
begin
FillChar(aesKey128, SizeOf(aesKey128), 0 );
Move(PChar(Key)^, aesKey128, Min(SizeOf(aesKey128), Length(Key)));
EncryptaesStreamECB(Stream, 0, aesKey128, OutStrm);
end;
{ -- 192 位密匙最大长度为 24 个字符 -- }
if KeyBit = kb192 then
begin
FillChar(aesKey192, SizeOf(aesKey192), 0 );
Move(PChar(Key)^, aesKey192, Min(SizeOf(aesKey192), Length(Key)));
EncryptaesStreamECB(Stream, 0, aesKey192, OutStrm);
end;
{ -- 256 位密匙最大长度为 32 个字符 -- }
if KeyBit = kb256 then
begin
FillChar(aesKey256, SizeOf(aesKey256), 0 );
Move(PChar(Key)^, aesKey256, Min(SizeOf(aesKey256), Length(Key)));
EncryptaesStreamECB(Stream, 0, aesKey256, OutStrm);
end;
Result := OutStrm;
finally
OutStrm.Free;
end;
end;
{ -- 流解密函数 默认按照 128 位密匙解密 -- }
function DecryptStream(Stream: TStream; Key: string;
KeyBit: TKeyBit = kb128): TStream;
var
Count, OutPos: Int64;
OutStrm: TStream;
aesKey128: TaesKey128;
aesKey192: TaesKey192;
aesKey256: TaesKey256;
begin
OutStrm := TStream.Create;
Stream.Position := 0;
OutPos :=OutStrm.Position;
Stream.ReadBuffer(Count, SizeOf(Count));
try
{ -- 128 位密匙最大长度为 16 个字符 -- }
if KeyBit = kb128 then
begin
FillChar(aesKey128, SizeOf(aesKey128), 0 );
Move(PChar(Key)^, aesKey128, Min(SizeOf(aesKey128), Length(Key)));
DecryptaesStreamECB(Stream, Stream.Size - Stream.Position,
aesKey128, OutStrm);
end;
{ -- 192 位密匙最大长度为 24 个字符 -- }
if KeyBit = kb192 then
begin
FillChar(aesKey192, SizeOf(aesKey192), 0 );
Move(PChar(Key)^, aesKey192, Min(SizeOf(aesKey192), Length(Key)));
DecryptaesStreamECB(Stream, Stream.Size - Stream.Position,
aesKey192, OutStrm);
end;
{ -- 256 位密匙最大长度为 32 个字符 -- }
if KeyBit = kb256 then
begin
FillChar(aesKey256, SizeOf(aesKey256), 0 );
Move(PChar(Key)^, aesKey256, Min(SizeOf(aesKey256), Length(Key)));
DecryptaesStreamECB(Stream, Stream.Size - Stream.Position,
aesKey256, OutStrm);
end;
OutStrm.Size := OutPos + Count;
OutStrm.Position := OutPos;
Result := OutStrm;
finally
OutStrm.Free;
end;
end;
智能化时代的到来涉及了各种核心算法，保护算法就能保障开发者权益，杜绝市面上各种山寨品，加密芯片恰好能起到很好的保护作用，如何选择加密芯片呢？KEROS加密芯片专注于加密领域十余年，行业首选。
1.安全性：采用国际通用aes256算法加密并同时通过KAS传送，除基本认证之外，利用2K安全EEPROM，用户可以自己管理密钥和数据，实现双重保护。
2.唯一性：以定制的方式为每一位用户单独定制“专属型号CID”，多用户之间算法不兼容，并且采用固化的方法直接将算法固化到晶圆上而无需烧入。
3.序列号：每颗芯片制造生产时具有5字节全球唯一SN序列号，每颗芯片SN都不会重复。
4.防抄特性：每颗芯片都有自己独特的密钥系统，破解单颗芯片只对这颗芯片对应的产品有效，对整个同类型的产品是无效的，依旧无法通过验证。而且KEROS采用ASIC方法设计，芯片内为纯逻辑电路，封装内有40多层逻辑电路整合了10万多个逻辑门，爆力刨片破解难度可想而知。
5.安全存储：用户可以将保密数据加密之后安全的存放到EEPROM中。通用加密算法的介绍就聊到这里吧，感谢你花时间阅读本站内容。
