Content list :
加密算法介绍
几种加密算法比较
DES
MD5
Java加密和数字签名编程快速入门 (转)
--------------------------------------------------------------------------------------
加密算法介绍
一. 密码学简介
据记载，公元前400年，古希腊人发明了置换密码。1881年世界上的第一个电话保密专利出现。在第二次世界大战期间，德国军方启用“恩尼格玛”密码机，密码学在战争中起着非常重要的作用。
随着信息化和数字化社会的发展，人们对信息安全和保密的重要性认识不断提高，于是在1997年，美国国家标准局公布实施了“美国数据加密标准（DES）”，民间力量开始全面介入密码学的研究和应用中，采用的加密算法有DES、RSA、SHA等。随着对加密强度需求的不断提高，近期又出现了AES、ECC等。
使用密码学可以达到以下目的：
保密性：防止用户的标识或数据被读取。
数据完整性：防止数据被更改。
身份验证：确保数据发自特定的一方。
二. 加密算法介绍
根据密钥类型不同将现代密码技术分为两类：对称加密算法（秘密钥匙加密）和非对称加密算法（公开密钥加密）。
对称钥匙加密系统是加密和解密均采用同一把秘密钥匙，而且通信双方都必须获得这把钥匙，并保持钥匙的秘密。
非对称密钥加密系统采用的加密钥匙（公钥）和解密钥匙（私钥）是不同的。
对称加密算法
对称加密算法用来对敏感数据等信息进行加密，常用的算法包括：
DES（Data Encryption Standard）：数据加密标准，速度较快，适用于加密大量数据的场合。
3DES（Triple DES）：是基于DES，对一块数据用三个不同的密钥进行三次加密，强度更高。
AES（Advanced EncryptionStandard）：高级加密标准，是下一代的加密算法标准，速度快，安全级别高；
算法原理
AES 算法基于排列和置换运算。排列是对数据重新进行安排，置换是将一个数据单元替换为另一个。AES使用几种不同的方法来执行排列和置换运算。
AES是一个迭代的、对称密钥分组的密码，它可以使用128、192 和 256 位密钥，并且用 128 位（16字节）分组加密和解密数据。与公共密钥密码使用密钥对不同，对称密钥密码使用相同的密钥加密和解密数据。通过分组密码返回的加密数据的位数与输入数据相同。迭代加密使用一个循环结构，在该循环中重复置换和替换输入数据。
AES与3DES的比较
|
算法名称 |
算法类型 |
密钥长度 |
速度 |
解密时间（建设机器每秒尝试255个密钥） |
资源消耗 |
|
AES |
对称block密码 |
128、192、256位 |
高 |
1490000亿年 |
低 |
|
3DES |
对称feistel密码 |
112位或168位 |
低 |
46亿年 |
中 |
非对称算法
常见的非对称加密算法如下：
RSA：由 RSA 公司发明，是一个支持变长密钥的公共密钥算法，需要加密的文件块的长度也是可变的；
DSA（Digital SignatureAlgorithm）：数字签名算法，是一种标准的 DSS（数字签名标准）；
ECC（Elliptic CurvesCryptography）：椭圆曲线密码编码学。
ECC
在1976年，由于对称加密算法已经不能满足需要，Diffie 和Hellman发表了一篇叫《密码学新动向》的文章，介绍了公匙加密的概念，由Rivet、Shamir、Adelman提出了RSA算法。
随着分解大整数方法的进步及完善、计算机速度的提高以及计算机网络的发展，为了保障数据的安全，RSA的密钥需要不断增加，但是，密钥长度的增加导致了其加解密的速度大为降低，硬件实现也变得越来越难以忍受，这对使用RSA的应用带来了很重的负担，因此需要一种新的算法来代替RSA。
1985年N.Koblitz和Miller提出将椭圆曲线用于密码算法，根据是有限域上的椭圆曲线上的点群中的离散对数问题ECDLP。ECDLP是比因子分解问题更难的问题，它是指数级的难度。
原理——椭圆曲线上的难题
椭圆曲线上离散对数问题ECDLP定义如下：给定素数p和椭圆曲线E，对Q＝kP，在已知P，Q的情况下求出小于p的正整数k。可以证明由k和P计算Q比较容易，而由Q和P计算k则比较困难。
将椭圆曲线中的加法运算与离散对数中的模乘运算相对应，将椭圆曲线中的乘法运算与离散对数中的模幂运算相对应，我们就可以建立基于椭圆曲线的对应的密码体制。
例如，对应Diffie-Hellman公钥系统，我们可以通过如下方式在椭圆曲线上予以实现：在E上选取生成元P，要求由P产生的群元素足够多，通信双方A和B分别选取a和b，a和b予以保密，但将aP和bP公开，A和B间通信用的密钥为abP，这是第三者无法得知的。
对应ELGamal密码系统可以采用如下的方式在椭圆曲线上予以实现：
将明文m嵌入到E上Pm点，选一点B∈E，每一用户都选一整数a，0＜a＜N，N为阶数已知，a保密，aB公开。欲向A送m，可送去下面一对数偶：［kB，Pm+k(aAB)］，k是随机产生的整数。A可以从kB求得k(aAB)。通过：Pm+k(aAB)-k(aAB)=Pm恢复Pm。同样对应DSA，考虑如下等式：
K=kG [其中 K，G为Ep(a,b)上的点，k为小于n（n是点G的阶）的整数]
不难发现，给定k和G，根据加法法则，计算K很容易；但给定K和G，求k就相对困难了。
这就是椭圆曲线加密算法采用的难题。我们把点G称为基点（base point），k（k<n，n为基点G的阶）称为私有密钥（privtekey），K称为公开密钥（public key)。
ECC与RSA的比较
ECC和RSA相比，在许多方面都有对绝对的优势，主要体现在以下方面：
抗攻击性强。相同的密钥长度，其抗攻击性要强很多倍。
计算量小，处理速度快。ECC总的速度比RSA、DSA要快得多。
存储空间占用小。ECC的密钥尺寸和系统参数与RSA、DSA相比要小得多，意味着它所占的存贮空间要小得多。这对于加密算法在IC卡上的应用具有特别重要的意义。
带宽要求低。当对长消息进行加解密时，三类密码系统有相同的带宽要求，但应用于短消息时ECC带宽要求却低得多。带宽要求低使ECC在无线网络领域具有广泛的应用前景。
ECC的这些特点使它必将取代RSA，成为通用的公钥加密算法。比如SET协议的制定者已把它作为下一代SET协议中缺省的公钥密码算法。
下面两张表示是RSA和ECC的安全性和速度的比较。
|
攻破时间(MIPS年) |
RSA/DSA(密钥长度) |
ECC密钥长度 |
RSA/ECC密钥长度比 |
|
104 |
512 |
106 |
5：1 |
|
108 |
768 |
132 |
6：1 |
|
1011 |
1024 |
160 |
7：1 |
|
1020 |
2048 |
210 |
10：1 |
|
1078 |
21000 |
600 |
35：1 |
RSA和ECC安全模长得比较
|
功能 |
Security Builder 1.2 |
BSAFE 3.0 |
|
163位ECC(ms) |
1,023位RSA(ms) |
|
|
密钥对生成 |
3.8 |
4,708.3 |
|
签名 |
2.1(ECNRA) |
228.4 |
|
3.0(ECDSA) |
||
|
认证 |
9.9(ECNRA) |
12.7 |
|
10.7(ECDSA) |
||
|
Diffie—Hellman密钥交换 |
7.3 |
1,654.0 |
RSA和ECC速度比较
散列算法
散列是信息的提炼，通常其长度要比信息小得多，且为一个固定长度。加密性强的散列一定是不可逆的，这就意味着通过散列结果，无法推出任何部分的原始信息。任何输入信息的变化，哪怕仅一位，都将导致散列结果的明显变化，这称之为雪崩效应。散列还应该是防冲突的，即找不出具有相同散列结果的两条信息。具有这些特 性的散列结果就可以用于验证信息是否被修改。
单向散列函数一般用于产生消息摘要，密钥加密等，常见的有：
· MD5（Message Digest Algorithm 5）：是RSA数据安全公司开发的一种单向散列算法。
· SHA（Secure Hash Algorithm）：可以对任意长度的数据运算生成一个160位的数值；
SHA-1
在1993年，安全散列算法（SHA）由美国国家标准和技术协会(NIST)提出，并作为联邦信息处理标准（FIPSPUB 180）公布；1995年又发布了一个修订版FIPS PUB 180-1，通常称之为SHA-1。SHA-1是基于MD4算法的，并且它的设计在很大程度上是模仿MD4的。现在已成为公认的最安全的散列算法之一，并被广泛使用。
原理
SHA1是一种数据加密算法，该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。
单向散列函数的安全性在于其产生散列值的操作过程具有较强的单向性。如果在输入序列中嵌入密码，那么任何人在不知道密码的情况下都不能产生正确的散列值，从而保证了其安全性。ＳＨＡ将输入流按照每块５１２位（６４个字节）进行分块，并产生２０个字节的被称为信息认证代码或信息摘要的输出。
该算法输入报文的最大长度不超过264位，产生的输出是一个160位的报文摘要。输入是按512位的分组进行处理的。SHA-1是不可逆的、防冲突，并具有良好的雪崩效应。
通过散列算法可实现数字签名实现，数字签名的原理是将要传送的明文通过一种函数运算（Hash）转换成报文摘要（不同的明文对应不同的报文摘要），报文摘要加密后与明文一起传送给接受方，接受方将接受的明文产生新的报文摘要与发送方的发来报文摘要解密比较，比较结果一致表示明文未被改动，如果不一致表示明文已被篡改。
SHA-1与MD5的比较
因为二者均由MD4导出，SHA1和MD5彼此很相似。相应的，他们的强度和其他特性也是相似，但还有以下几点不同：
· 对强行供给的安全性：最显著和最重要的区别是SHA1摘要比MD5摘要长32位。使用强行技术，产生任何一个报文使其摘要等于给定报摘要的难度对MD5是2128数量级的操作，而对SHA-1则是2160数量级的操作。这样，SHA-1对强行攻击有更大的强度。
· 对密码分析的安全性：由于MD5的设计，易受密码分析的攻击，SHA-1显得不易受这样的攻击。
· 速度：在相同的硬件上，SHA-1的运行速度比MD5慢。
对称与非对称算法比较
以上综述了两种加密方法的原理，总体来说主要有下面几个方面的不同：
· 在管理方面：公钥密码算法只需要较少的资源就可以实现目的，在密钥的分配上，两者之间相差一个指数级别（一个是n一个是n2）。所以私钥密码算法不适应广域网的使用，而且更重要的一点是它不支持数字签名。
· 在安全方面：由于公钥密码算法基于未解决的数学难题，在破解上几乎不可能。对于私钥密码算法，到了AES虽说从理论来说是不可能破解的，但从计算机的发展角度来看。公钥更具有优越性。
· 从速度上来看：AES的软件实现速度已经达到了每秒数兆或数十兆比特。是公钥的100倍，如果用硬件来实现的话这个比值将扩大到1000倍。
三. 加密算法的选择
前面的章节已经介绍了对称解密算法和非对称加密算法，有很多人疑惑：那我们在实际使用的过程中究竟该使用哪一种比较好呢？
我们应该根据自己的使用特点来确定，由于非对称加密算法的运行速度比对称加密算法的速度慢很多，当我们需要加密大量的数据时，建议采用对称加密算法，提高加解密速度。
对称加密算法不能实现签名，因此签名只能非对称算法。
由于对称加密算法的密钥管理是一个复杂的过程，密钥的管理直接决定着他的安全性，因此当数据量很小时，我们可以考虑采用非对称加密算法。
在实际的操作过程中，我们通常采用的方式是：采用非对称加密算法管理对称算法的密钥，然后用对称加密算法加密数据，这样我们就集成了两类加密算法的优点，既实现了加密速度快的优点，又实现了安全方便管理密钥的优点。
如果在选定了加密算法后，那采用多少位的密钥呢？一般来说，密钥越长，运行的速度就越慢，应该根据的我们实际需要的安全级别来选择，一般来说，RSA建议采用1024位的数字，ECC建议采用160位，AES采用128为即可。
四. 密码学在现代的应用
随着密码学商业应用的普及，公钥密码学受到前所未有的重视。除传统的密码应用系统外，PKI系统以公钥密码技术为主，提供加密、签名、认证、密钥管理、分配等功能。
保密通信：保密通信是密码学产生的动因。使用公私钥密码体制进行保密通信时，信息接收者只有知道对应的密钥才可以解密该信息。
数字签名：数字签名技术可以代替传统的手写签名，而且从安全的角度考虑，数字签名具有很好的防伪造功能。在政府机关、军事领域、商业领域有广泛的应用环境。
秘密共享：秘密共享技术是指将一个秘密信息利用密码技术分拆成n个称为共享因子的信息，分发给n个成员，只有k(k≤n)个合法成员的共享因子才可以恢复该秘密信息，其中任何一个或m(m≤k)个成员合作都不知道该秘密信息。利用秘密共享技术可以控制任何需要多个人共同控制的秘密信息、命令等。
认证功能：在公开的信道上进行敏感信息的传输，采用签名技术实现对消息的真实性、完整性进行验证，通过验证公钥证书实现对通信主体的身份验证。
密钥管理：密钥是保密系统中更为脆弱而重要的环节，公钥密码体制是解决密钥管理工作的有力工具；利用公钥密码体制进行密钥协商和产生，保密通信双方不需要事先共享秘密信息；利用公钥密码体制进行密钥分发、保护、密钥托管、密钥恢复等。
基于公钥密码体制可以实现以上通用功能以外，还可以设计实现以下的系统：安全电子商务系统、电子现金系统、电子选举系统、电子招投标系统、电子彩票系统等。
公钥密码体制的产生是密码学由传统的政府、军事等应用领域走向商用、民用的基础，同时互联网、电子商务的发展为密码学的发展开辟了更为广阔的前景。
五. 加密算法的未来
随着计算方法的改进，计算机运行速度的加快，网络的发展，越来越多的算法被破解。
在2004年国际密码学会议(Crypto’2004)上，来自中国山东大学的王小云教授做的破译MD5、HAVAL-128、MD4和RIPEMD算法的报告，令在场的国际顶尖密码学专家都为之震惊，意味着这些算法将从应用中淘汰。随后，SHA-1也被宣告被破解。
历史上有三次对DES有影响的攻击实验。1997年，利用当时各国7万台计算机，历时96天破解了DES的密钥。1998年，电子边境基金会（EFF）用25万美元制造的专用计算机，用56小时破解了DES的密钥。1999年，EFF用22小时15分完成了破解工作。因此。曾经有过卓越贡献的DES也不能满足我们日益增长的需求了。
最近，一组研究人员成功的把一个512位的整数分解因子，宣告了RSA的破解。
我们说数据的安全是相对的，可以说在一定时期一定条件下是安全的，随着硬件和网络的发展，或者是另一个王小云的出现，目前的常用加密算法都有可能在短时间内被破解，那时我们不得不使用更长的密钥或更加先进的算法，才能保证数据的安全，因此加密算法依然需要不断发展和完善，提供更高的加密安全强度和运算速度。
纵观这两种算法一个从DES到3DES再到AES，一个从RSA到ECC。 其发展角度无不是从密钥的简单性，成本的低廉性，管理的简易性，算法的复杂性，保密的安全性以及计算的快速性这几个方面去考虑。因此，未来算法的发展也必定是从这几个角度出发的，而且在实际操作中往往把这两种算法结合起来，也需将来一种集两种算法优点于一身的新型算法将会出现，到那个时候，电子商务的实现 必将更加的快捷和安全。
几种加密算法比较
对称加密算法(加解密密钥相同)
|
名称 |
密钥长度 |
运算速度 |
安全性 |
资源消耗 |
|
DES |
56位 |
较快 |
低 |
中 |
|
3DES |
112位或168位 |
慢 |
中 |
高 |
|
AES |
128、192、256位 |
快 |
高 |
低 |
非对称算法(加密密钥和解密密钥不同)
|
名称 |
成熟度 |
安全性(取决于密钥长度) |
运算速度 |
资源消耗 |
|
RSA |
高 |
高 |
慢 |
高 |
|
DSA |
高 |
高 |
慢 |
只能用于数字签名 |
|
ECC |
低 |
高 |
快 |
低(计算量小,存储空间占用小,带宽要求低) |
散列算法比较
|
名称 |
安全性 |
速度 |
|
SHA-1 |
高 |
慢 |
|
MD5 |
中 |
快 |
对称与非对称算法比较
|
名称 |
密钥管理 |
安全性 |
速度 |
|
对称算法 |
比较难,不适合互联网,一般用于内部系统 |
中 |
快好几个数量级(软件加解密速度至少快100倍,每秒可以加解密数M比特数据),适合大数据量的加解密处理 |
|
非对称算法 |
密钥容易管理 |
高 |
慢,适合小数据量加解密或数据签名 |
算法选择(从性能和安全性综合)
对称加密:AES(128位),
非对称加密: ECC(160位)或RSA(1024),
消息摘要: MD5
数字签名:DSA
Summary of rules forencrypting user passwords
I. Encrypt passwords using one-way techniques, this is, digests.
II. Match input and stored passwords by comparing digests, notunencrypted strings.
III. Use a salt containing at least 8 random bytes, and attach theserandom bytes, undigested, to the result.
IV. Iterate the hash function at least 1,000 times.
V. Prior to digesting, perform string-to-byte sequence translationusing a fixed encoding, preferably UTF-8.
VI. Finally, apply BASE64 encoding and store the digest asan US-ASCII character string.
DES -- Java program
DES算法为密码体制中的对称密码体制，又被成为美国数据加密标准 ，是1972年美国IBM 公司研制的对称密码体制加密算法。其密钥长度为56位，明文按64位进行分组，将分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。
DES加密算法特点：分组比较短、密钥太短、密码生命周期短、运算速度较慢。
DES工作的基本原理是，其入口参数有三个:key、data、mode。 key为加密解密使用的密钥 ，data为加密解密的数据，mode为其工作模式。当模式为加密模式时，明文按照64位进行分组，形成明文组，key用于对数据加密，当模式为解密模式时，key用于对数据解密。实际运用中，密钥只用到了64位中的56位，这样才具有高的安全性。
DES算法全称为Data Encryption Standard,
即数据加密算法,它是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密。
DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位，其算法主要分为两步：
1.初始置换
其功能是把输入的64位数据块按位重新组合,并把输出分为L0、R0两部分,每部分各长32位,其置换规则为将输入的第58位换到第一位,第50位换到第2位……依此类推,最后一位是原来的第7位。L0、R0则是换位输出后的两部分，L0是输出的左32位,R0是右32位,例:设置换前的输入值为D1D2D3……D64,则经过初始置换后的结果为:L0=D58D50……D8;R0=D57D49……D7。
2.逆置换
经过16次迭代运算后,得到L16、R16,将此作为输入,进行逆置换,逆置换正好是初始置换的逆运算，由此即得到密文输出。
package PasswordEncryption;
import java.io.*;
import java.security.*;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
public class DESUtil {
public final static String ENCODING = "UTF-8";
public static final String ALGORITHAM = "DES";
private static final String ENCRYPTION_KEY = "01010101"; //default encrypt key string
/**
* setKey used to encryption/decryption
* @param strKey
*/
private static Key getSecretKey(String strKey) {
Key secretKey = null;
try {
//keyFactory
/*
SecretKeyFactory keyFactory= SecretKeyFactory.getInstance(ALGORITHAM);
byte[] keyArr =strKey.getBytes();
DESKeySpec desKeySpec = newDESKeySpec(keyArr);
secretKey = keyFactory.generateSecret(desKeySpec);
*/
//KeyGenerator
KeyGenerator generator = KeyGenerator.getInstance(ALGORITHAM);
generator.init(newSecureRandom(strKey.getBytes()));
secretKey =generator.generateKey();
generator = null;
return secretKey;
} catch (Exception e) {
throw new RuntimeException(
"Error in getting secretKey. Cause: " + e);
}
}
/**
* encrypt String with default key
*/
private static String encryptStr(String OriginalStr) {
return encryptStr(OriginalStr,ENCRYPTION_KEY);
}
/**
* encrypt String with key
*/
private static String encryptStr(String OriginalStr,String keyStr) {
String retVal = "";
sun.misc.BASE64Encoderbase64Encoder = new sun.misc.BASE64Encoder();
try {
SecureRandom random = new SecureRandom();
//Key gen
Key key = getSecretKey(keyStr);
//cipher instance
Cipher cipher = Cipher.getInstance(ALGORITHAM);
cipher.init(Cipher.ENCRYPT_MODE,key,random);
//encryption&base64encode
byte[] oriBytes = cipher.doFinal(OriginalStr.getBytes(ENCODING));
retVal =base64Encoder.encode(oriBytes);
} catch (Exception e) {
throw new RuntimeException(
"Error initializing SqlMap class. Cause: " + e);
} finally {
base64Encoder = null;
}
return retVal;
}
/**
* Decrypt String with default key
*/
private static String decryptStr(String OriginalStr) {
return decryptStr(OriginalStr,ENCRYPTION_KEY);
}
/**
* Decrypt String with a key
* @param codeStr
* @return
*/
private static String decryptStr(String codeStr,String keyStr) {
sun.misc.BASE64Decoderbase64Decoder = new sun.misc.BASE64Decoder();
String retVal = "";
try {
SecureRandom random = new SecureRandom();
Key key = getSecretKey(keyStr);
Cipher cipher = Cipher.getInstance(ALGORITHAM);
cipher.init(Cipher.DECRYPT_MODE, key,random);
byte[] codeBytes =base64Decoder.decodeBuffer(codeStr);
byte[] decyptBytes =cipher.doFinal(codeBytes);
retVal = new String(decyptBytes, ENCODING);
} catch (Exception e) {
throw new RuntimeException(
"Error in decrtyptStr. Cause: " + e);
} finally {
base64Decoder = null;
}
return retVal;
}
/*****************************************************************
*
* File encryption/decryption
*
******************************************************************/
/**
* generate private key for file encryption/decryption
*/
private static void savePriveKey(String keyFile){
FileOutputStream fos=null;
try {
KeyGenerator keyGen=KeyGenerator.getInstance(ALGORITHAM);
SecureRandom sr=new SecureRandom();
keyGen.init(sr);
SecretKeykey=keyGen.generateKey();
byte[] rawKeyData=key.getEncoded();
fos=newFileOutputStream(keyFile);
fos.write(rawKeyData);
} catch (IOException e) {
e.printStackTrace();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}finally{
if(fos!=null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* Encryption
* @param text
* @param keyFile
*/
private static void encryptionFile(String file,String keyFile){
SecureRandom sr=new SecureRandom();
SecretKey key=getPrivetKey(keyFile);
FileInputStream fis=null;
FileOutputStream fos=null;
try {
Cipher cipher=Cipher.getInstance(ALGORITHAM);
cipher.init(Cipher.ENCRYPT_MODE, key,sr);
fis=new FileInputStream(new File(file));
byte[] data=new byte[fis.available()];
fis.read(data);
byte[] encryptedData=cipher.doFinal(data);
fos=new FileOutputStream(new File(file));
fos.write(encryptedData);
}catch (Exceptione) {
e.printStackTrace();
}finally{
try {
if(fis!=null){
fis.close();
}
if(fos!=null){
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* Decryption
* @param file
* @param keyFile
*/
private static void decryptionFile(String file,String keyFile){
SecretKey key=getPrivetKey(keyFile);
SecureRandom sr=new SecureRandom();
FileInputStream fis=null;
FileOutputStream fos=null;
try {
Cipher cipher=Cipher.getInstance(ALGORITHAM);
cipher.init(Cipher.DECRYPT_MODE,key,sr);
fis=new FileInputStream(new File(file));
byte[] encryptedData=new byte[fis.available()];
fis.read(encryptedData);
byte[] decryptedData=cipher.doFinal(encryptedData);
fos=new FileOutputStream(new File(file));
fos.write(decryptedData);
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
if(fis!=null){
fis.close();
}
if(fos!=null){
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* getPrivate key
* @param keyFile
* @return
*/
private static SecretKey getPrivetKey(String keyFile) {
FileInputStream fis=null;
SecretKey key=null;
try {
fis=new FileInputStream(new File(keyFile));
byte[] rawKeyData=new byte[fis.available()];
System.out.println( "== keyGet "+rawKeyData);
fis.read(rawKeyData);
DESKeySpec dks=new DESKeySpec(rawKeyData);
key=SecretKeyFactory.getInstance(ALGORITHAM).generateSecret(dks);
}catch (Exception e) {
e.printStackTrace();
}finally{
try {
if(fis!=null){
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return key;
}
/**
* @param args
*/
public static void main(String[] args) {
//TODOAuto-generated method stub
String str = "snow365";
//stringencryption test
System.out.println(encryptStr(str));
System.out.println(decryptStr(encryptStr(str)));
//fileencryption test
// savePriveKey("D://key.txt");
// encryptionFile("D://test.txt","D://key.txt");
decryptionFile("D://test.txt","D://key.txt");
}
}
AES- java API
packagePasswordEncryption;
importjava.io.UnsupportedEncodingException;
importjava.security.InvalidKeyException;
importjava.security.MessageDigest;
importjava.security.NoSuchAlgorithmException;
importjava.security.SecureRandom;
import javax.crypto.*;//Cipher;
importjavax.crypto.spec.DESKeySpec;
importjavax.crypto.spec.SecretKeySpec;
importsun.misc.BASE64Encoder;
public class EncryptUtil {
private static final String ALGORITHAM_DES="DES";
private static final String ALGORITHAM_AES="AES";
private static final String ALGORITHAM_MD5="MD5";
private static final String ENCRYPTION_KEY="01010101"; //default key
private final static String ENCODING = "UTF-8";
private static final String Key = "Qwer$ty6DREW";
/*******************************************************************************
* ****************************
* MD5
* ****************************
********************************************************************************/
private final static String[] hexDigits = { "0", "1", "2", "3", "4", "5",
"6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
private static StringbyteArrayToHexString(byte[] b) {
StringBufferresultSb = new StringBuffer();
for (int i = 0; i <b.length; i++) {
resultSb.append(byteToHexString(b[i]));
}
returnresultSb.toString();
}
private static StringbyteToHexString(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 booleanauthenticateCode(String code, String inputString) {
if (code.equals(encrypt_MD5(inputString))){
return true;
}else {
return false;
}
}
private static Stringencrypt_MD5(String originString) {
return encodeByMD5(originString);
}
private static StringencodeByMD5(String originString) {
if (originString!= null) {
try {
MessageDigestmd = MessageDigest.getInstance("MD5");
//MessageDigestmd = MessageDigest.getInstance("SHA-1");//SHA-1-106 bits
byte[] results =md.digest(originString.getBytes(ENCODING));
// md.update(results);
// byte[] digesta = md.digest();
// String resultString =byteArrayToHexString(digesta);
StringresultString = byteArrayToHexString(results);
System.out.println("=== stringdigest aft : " + resultString);
returnresultString.toUpperCase();
}catch (Exception ex){
ex.printStackTrace();
}
}
return null;
}
/*******************************************************************************
* ****************************
* DES
* ****************************
********************************************************************************/
private static Stringencrypt_DES(String oriString, String keyStr) {
StringretVal = "";
sun.misc.BASE64Encoderbase64Encoder = new sun.misc.BASE64Encoder();
try {
SecureRandomsr = new SecureRandom();
KeyGeneratorgenerator = KeyGenerator.getInstance(ALGORITHAM_DES);
generator.init(newSecureRandom(keyStr.getBytes()));
SecretKeysecretKey = generator.generateKey();
Ciphercipher = Cipher.getInstance(ALGORITHAM_DES);
cipher.init(Cipher.ENCRYPT_MODE, secretKey,sr);
byte[] encodedValue= cipher.doFinal(oriString.getBytes());
retVal= base64Encoder.encode(encodedValue);
System.out.println("FinalValue - " + retVal);
}catch (Exception x) {
x.printStackTrace();
}
return retVal;
}
/**
* AES
* @param content
* @param password
* @return
*/
public static byte[]encrypt_AES(String oriString, String keyStr) {
try {
SecureRandom sr = new SecureRandom();
KeyGenerator kgen =KeyGenerator.getInstance(ALGORITHAM_AES);
kgen.init(128, newSecureRandom(keyStr.getBytes()));
SecretKey secretKey =kgen.generateKey();
byte[] enCodeFormat= secretKey.getEncoded();
SecretKeySpec key = newSecretKeySpec(enCodeFormat, ALGORITHAM_AES);
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");//ALGORITHAM_AES);//cipher creation
byte[] byteContent =oriString.getBytes("utf-8");
cipher.init(Cipher.ENCRYPT_MODE, key,sr);// initiation
byte[] result =cipher.doFinal(byteContent);
return result;
} catch(NoSuchAlgorithmException e) {
e.printStackTrace();
} catch(NoSuchPaddingException e) {
e.printStackTrace();
} catch(InvalidKeyException e) {
e.printStackTrace();
} catch(UnsupportedEncodingException e) {
e.printStackTrace();
} catch(IllegalBlockSizeException e) {
e.printStackTrace();
} catch(BadPaddingException e) {
e.printStackTrace();
}
return null;
}
public static byte[] decrypt_AES(byte[] code, StringkeyStr) {
try {
KeyGeneratorkgen = KeyGenerator.getInstance(ALGORITHAM_AES);
kgen.init(128,newSecureRandom(keyStr.getBytes()));
SecretKeysecretKey = kgen.generateKey();
byte[] enCodeFormat= secretKey.getEncoded();
SecretKeySpeckey = new SecretKeySpec(enCodeFormat, ALGORITHAM_AES);
Ciphercipher = Cipher.getInstance(ALGORITHAM_AES);
cipher.init(Cipher.DECRYPT_MODE, key);
byte[] result =cipher.doFinal(code);
return result;
}catch(NoSuchAlgorithmException e) {
e.printStackTrace();
} catch(NoSuchPaddingException e) {
e.printStackTrace();
} catch(InvalidKeyException e) {
e.printStackTrace();
} catch(IllegalBlockSizeException e) {
e.printStackTrace();
} catch(BadPaddingException e) {
e.printStackTrace();
}
return null;
}
/**
* @param args
*/
public static void main(String[]args) {
// TODOAuto-generated method stub
Stringstr = encodeByMD5("message digest");
System.out.println(str);
System.out.println("encrypt_AES"+ encrypt_AES("abc",ENCRYPTION_KEY));
System.out.println( "encrypt_AES"+
new String (decrypt_AES(encrypt_AES("abc",ENCRYPTION_KEY),ENCRYPTION_KEY))
);
//System.out.println(authenticateCode("81DC9BDB52D04DC20036DBD8313ED055","1234"));
}
}
MD5简介
MD5的全称是Message-Digest Algorithm 5，在90年代初由MIT的计算机科学实验室和RSA Data Security Inc发明，经MD2、MD3和MD4发展而来。
Message-Digest泛指字节串(Message)的Hash变换，就是把一个任意长度的字节串变换成一定长的大整数。注意我使用了“字节串”而不是“字符串”，是因为这种变换只与字节的值有关，与字符集或编码方式无关。
MD5将任意长度的“字节串”变换成一个128bit的大整数，并且它是一个不可逆的字符串变换算法，换句话说就是，即使你看到源程序和算法描述，也无法 将一个MD5的值变换回原始的字符串，从数学原理上说，是因为原始的字符串有无穷多个，这有点象不存在反函数的数学函数。
MD5的典型应用是对一段Message(字节串)产生fingerprint(指纹)，以防止被“篡改”。举个例子，你将一段话写在一个叫readme.txt文件中，并对这个readme.txt产生一个MD5的值并记录在案，然后你可以传播这个文件给别人，别人如果修改了文件中的任何内 容，你对这个文件重新计算MD5时就会发现。如果再有一个第三方的认证机构，用MD5还可以防止文件作者的“抵赖”，这就是所谓的数字签名应用。
MD5还广泛用于加密和解密技术上，在很多操作系统中，用户的密码是以MD5值（或类似的其它算法）的方式保存的，用户Login的时候，系统是把用户输入的密码计算成MD5值，然后再去和系统中保存的MD5值进行比较，而系统并不“知道”用户的密码是什么。
一些黑客破获这种密码的方法是一种被称为“跑字典”的方法。有两种方法得到字典，一种是日常搜集的用做密码的字符串表，另一种是用排列组合方法生成的，先用MD5程序计算出这些字典项的MD5值，然后再用目标的MD5值在这个字典中检索。
即使假设密码的最大长度为8，同时密码只能是字母和数字，共26+26+10=62个字符，排列组合出的字典的项数则是P(62,1)+P(62,2)….+P(62,8)，那也已经是一个很天文的数字了，存储这个字典就需要TB级的磁盘组，而且这种方法还有一个前提，就 是能获得目标账户的密码MD5值的情况下才可以。
在很多电子商务和社区应用中，管理用户的Account是一种最常用的基本功能，尽管很多Application Server提供了这些基本组件，但很多应用开发者为了管理的更大的灵活性还是喜欢采用关系数据库来管理用户，懒惰的做法是用户的密码往往使用明文或简单 的变换后直接保存在数据库中，因此这些用户的密码对软件开发者或系统管理员来说可以说毫无保密可言，本文的目的是介绍MD5的JavaBean的实现，同时给出用MD5来处理用户的Account密码的例子，这种方法使得管理员和程序设计者都无法看到用户的密码，尽管他们可以初始化它 们。但重要的一点是对于用户密码设置习惯的保护。
有兴趣的读者可以从这里取得MD5也就是RFC1321的文本。http://www.ietf.org/rfc/rfc1321.txt
MD5算法说明
一、补位
二、补数据长度
三、初始化MD5参数
四、处理位操作函数
五、主要变换过程
六、输出结果
补位：
MD5算法先对输入的数据进行补位，使得数据位长度LEN对512求余的结果是448。即数据扩展至K*512+448位。即K*64+56个字节，K为整数。
具体补位操作：补一个1，然后补0至满足上述要求。
补数据长度：
用一个64位的数字表示数据的原始长度B，把B用两个32位数表示。这时，数
据就被填补成长度为512位的倍数。
初始化MD5参数：
四个32位整数(A,B,C,D) 用来计算信息摘要，初始化使用的是十六进制表
示的数字
A=0X01234567
B=0X89abcdef
C=0Xfedcba98
D=0X76543210
处理位操作函数：
X，Y，Z为32位整数。
F(X,Y,Z) = X&Y|NOT(X)&Z
G(X,Y,Z) = X&Z|Y?(Z)
H(X,Y,Z) = X xor Y xor Z
I(X,Y,Z) = Y xor (X|not(Z))
主要变换过程：
使用常数组T[1 ... 64]， T[i]为32位整数用16进制表示，数据用16个32位
的整数数组M[]表示。
具体过程如下：
/* 处理数据原文*/
For i = 0 to N/16-1 do
/*每一次，把数据原文存放在16个元素的数组X中. */
For j = 0 to 15 do
Set X[j] to M[i*16+j].
end /结束对J的循环
/* Save A as AA, B as BB, C as CC, and D as DD.
*/
AA = A
BB = B
CC = C
DD = D
/* 第1轮*/
/* 以[abcd k s i]表示如下操作
a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
/* Do the following 16 operations. */
[ABCD 0 7 1] [DABC 1 12 2] [CDAB 2 17 3] [BCDA 3
22 4]
[ABCD 4 7 5] [DABC 5 12 6] [CDAB 6 17 7] [BCDA 7
22 8]
[ABCD 8 7 9] [DABC 9 12 10] [CDAB 10 17 11] [BCDA
11 22 12]
[ABCD 12 7 13] [DABC 13 12 14] [CDAB 14 17 15]
[BCDA 15 22 16]
/* 第2轮* */
/* 以[abcd k s i]表示如下操作
a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
/* Do the following 16 operations. */
[ABCD 1 5 17] [DABC 6 9 18] [CDAB 11 14 19] [BCDA
0 20 20]
[ABCD 5 5 21] [DABC 10 9 22] [CDAB 15 14 23]
[BCDA 4 20 24]
[ABCD 9 5 25] [DABC 14 9 26] [CDAB 3 14 27] [BCDA
8 20 28]
[ABCD 13 5 29] [DABC 2 9 30] [CDAB 7 14 31] [BCDA
12 20 32]
/* 第3轮*/
/* 以[abcd k s i]表示如下操作
a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
/* Do the following 16 operations. */
[ABCD 5 4 33] [DABC 8 11 34] [CDAB 11 16 35]
[BCDA 14 23 36]
[ABCD 1 4 37] [DABC 4 11 38] [CDAB 7 16 39] [BCDA
10 23 40]
[ABCD 13 4 41] [DABC 0 11 42] [CDAB 3 16 43]
[BCDA 6 23 44]
[ABCD 9 4 45] [DABC 12 11 46] [CDAB 15 16 47]
[BCDA 2 23 48]
/* 第4轮*/
/* 以[abcd k s i]表示如下操作
a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
/* Do the following 16 operations. */
[ABCD 0 6 49] [DABC 7 10 50] [CDAB 14 15 51]
[BCDA 5 21 52]
[ABCD 12 6 53] [DABC 3 10 54] [CDAB 10 15 55]
[BCDA 1 21 56]
[ABCD 8 6 57] [DABC 15 10 58] [CDAB 6 15 59]
[BCDA 13 21 60]
[ABCD 4 6 61] [DABC 11 10 62] [CDAB 2 15 63]
[BCDA 9 21 64]
/* 然后进行如下操作 */
A = A + AA
B = B + BB
C = C + CC
D = D + DD
end /* 结束对I的循环*/
输出结果。
Java API :
packagePasswordEncryption;
importjava.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import sun.misc.BASE64Encoder;
public class EncryptUtil {
private final static String[] hexDigits = { "0", "1", "2", "3", "4", "5",
"6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
private 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;