加密 算法 & Java implementation


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是一种数据加密算法,该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。

单向散列函数的安全性在于其产生散列值的操作过程具有较强的单向性。如果在输入序列中嵌入密码,那么任何人在不知道密码的情况下都不能产生正确的散列值,从而保证了其安全性。SHA将输入流按照每块512位(64个字节)进行分块,并产生20个字节的被称为信息认证代码或信息摘要的输出。

该算法输入报文的最大长度不超过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;

              return hexDigits[d1] + hexDigits[d2];

       }

 

       public static boolean authenticateCode(String code, String inputString) {

              if (code.equals(encrypt(inputString))) {

                     return true;

              } else {

                     return false;

              }

       }

 

       private static String encrypt(String originString) {

 

              return encodeByMD5(originString);

       }

 

       private static String encodeByMD5(String originString) {

 

              if (originString != null) {

                     try {

                           MessageDigest md =MessageDigest.getInstance("MD5");

                           byte[] results =md.digest(originString.getBytes("UTF-8"));

 

                           System.out.println("=== string digest : "

                                         + new String(results, "UTF-8"));

                           String resultString =byteArrayToHexString(results);

                           System.out.println("=== string digest aft : " + resultString);

                           return resultString.toUpperCase();

                     } catch (Exception ex) {

                           ex.printStackTrace();

                     }

              }

              return null;

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              //TODOAuto-generated method stub

              String str = encodeByMD5("1234");

              System.out.println(str);

 

                 

System.out.println(authenticateCode("81DC9BDB52D04DC20036DBD8313ED055","1234"));

 

       }

 

}

 

在RFC 1321中,给出了Test suite用来检验你的实现是否正确:

MD5 ("") = d41d8cd98f00b204e9800998ecf8427e

MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661

MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72

MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0

MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b

 

Java加密和数字签名编程快速入门

 

本文主要谈一下密码学中的加密和数字签名,以及其在java中如何进行使用。对密码学有兴趣的伙伴,推荐看 Bruce Schneier的著作:Applied Crypotography。在jdk1.5的发行版本中安全性方面有了很大的改进,也提供了对RSA算法的直接支持,现在我们从实例入手解决问题(本文 仅是作为简单介绍):

  一、密码学上常用的概念 

  1)消息摘要:

   这是一种与消息认证码结合使用以确保消息完整性的技术。主要使用单向散列函数算法,可用于检验消息的完整性,和通过散列密码直接以文本形式保存等,目前 广泛使用的算法有MD4、MD5、SHA-1,jdk1.5对上面都提供了支持,在java中进行消息摘要很简单, java.security.MessageDigest提供了一个简易的操作方法:

/**
*MessageDigestExample.java
*Copyright 2005-2-16
*/
import java.security.MessageDigest;
/**
*单一的消息摘要算法,不使用密码.可以用来对明文消息(如:密码)隐藏保存
*/
public class MessageDigestExample{
 public static void main(String[] args) throws Exception{
  if(args.length!=1){
   System.err.println("Usage:java MessageDigestExample text");
   System.exit(1);
  }

  byte[] plainText=args[0].getBytes("UTF8");

  //使用getInstance("算法")来获得消息摘要,这里使用SHA-1的160位算法
  MessageDigest messageDigest=MessageDigest.getInstance("SHA-1");

  System.out.println("\n"+messageDigest.getProvider().getInfo());
  //开始使用算法
  messageDigest.update(plainText);
  System.out.println("\nDigest:");
  //输出算法运算结果
  System.out.println(new String(messageDigest.digest(),"UTF8"));
 }
}


  还可以通过消息认证码来进行加密实现,javax.crypto.Mac提供了一个解决方案,有兴趣者可以参考相关API文档,本文只是简单介绍什么是摘要算法。

  2)私钥加密:

  消息摘要只能检查消息的完整性,但是单向的,对明文消息并不能加密,要加密明文的消息的话,就要使用其他的算法,要确保机密性,我们需要使用私钥密码术来交换私有消息。

  这种最好理解,使用对称算法。比如:A用一个密钥对一个文件加密,而B读取这个文件的话,则需要和A一样的密钥,双方共享一个私钥(而在web环境下,私钥在传递时容易被侦听):

   使用私钥加密的话,首先需要一个密钥,可用javax.crypto.KeyGenerator产生一个密钥(java.security.Key),然后传递给一个加密工具(javax.crypto.Cipher),该工具再使用相应的算法来进行加密,主要对称算法有:DES(实际密钥只用到56位),AES(支持三种密钥长度:128、192、256位),通常首先128位,其他的还有DESede等,jdk1.5种也提供了对对称算法的支持, 以下例子使用AES算法来加密:

/**
*PrivateExmaple.java
*Copyright 2005-2-16
*/
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import java.security.Key;

/**
*私鈅加密,保证消息机密性
*/
public class PrivateExample{
 public static void main(String[] args) throws Exception{
  if(args.length!=1){
   System.err.println("Usage:java PrivateExample <text>");
   System.exit(1);
  }
  byte[] plainText=args[0].getBytes("UTF8");

  //通过KeyGenerator形成一个key
  System.out.println("\nStart generate AES key");
  KeyGenerator keyGen=KeyGenerator.getInstance("AES");
  keyGen.init(128);
  Key key=keyGen.generateKey();
  System.out.println("Finish generating DES key");

  //获得一个私鈅加密类Cipher,ECB是加密方式,PKCS5Padding是填充方法
  Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
  System.out.println("\n"+cipher.getProvider().getInfo());

  //使用私鈅加密
  System.out.println("\nStart encryption:");
  cipher.init(Cipher.ENCRYPT_MODE,key);
  byte[] cipherText=cipher.doFinal(plainText);
  System.out.println("Finish encryption:");
  System.out.println(new String(cipherText,"UTF8"));

  System.out.println("\nStart decryption:");
  cipher.init(Cipher.DECRYPT_MODE,key);
  byte[] newPlainText=cipher.doFinal(cipherText);
  System.out.println("Finish decryption:");

  System.out.println(new String(newPlainText,"UTF8"));

 }
}


  3)公钥加密:

   上面提到,私钥加密需要一个共享的密钥,那么如何传递密钥呢?web环境下,直接传递的话很容易被侦听到,幸好有了公钥加密的出现。公钥加密也叫不对称加密,不对称算法使用一对密钥对,一个公钥,一个私钥,使用公钥加密的数据,只有私钥能解开(可用于加密);同时,使用私钥加密的数据,只有公钥能解开(签名)。但是速度很慢(比私钥加密慢100到1000倍),公钥的主要算法有RSA,还包括Blowfish,Diffie-Helman 等,jdk1.5种提供了对RSA的支持,是一个改进的地方:

/**
*PublicExample.java
*Copyright 2005-2-16
*/
import java.security.Key;
import javax.crypto.Cipher;
import java.security.KeyPairGenerator;
import java.security.KeyPair;
/**
*一个简单的公鈅加密例子,Cipher类使用KeyPairGenerator生成的公鈅和私鈅
*/
public class PublicExample{
 public static void main(String[] args) throws Exception{
  if(args.length!=1){
   System.err.println("Usage:java PublicExample <text>");
   System.exit(1);
  }

  byte[] plainText=args[0].getBytes("UTF8");
  //构成一个RSA密钥
  System.out.println("\nStart generating RSA key");
  KeyPairGenerator keyGen=KeyPairGenerator.getInstance("RSA");
  keyGen.initialize(1024);
  KeyPair key=keyGen.generateKeyPair();
  System.out.println("Finish generating RSA key");

  //获得一个RSA的Cipher类,使用公鈅加密
  Cipher cipher=Cipher.getInstance("RSA/ECB/PKCS1Padding");
  System.out.println("\n"+cipher.getProvider().getInfo());

  System.out.println("\nStart encryption");
  cipher.init(Cipher.ENCRYPT_MODE,key.getPublic());
  byte[] cipherText=cipher.doFinal(plainText);
  System.out.println("Finish encryption:");
  System.out.println(new String(cipherText,"UTF8"));

  //使用私鈅解密
  System.out.println("\nStart decryption");
  cipher.init(Cipher.DECRYPT_MODE,key.getPrivate());
  byte[] newPlainText=cipher.doFinal(cipherText);
  System.out.println("Finish decryption:");
  System.out.println(new String(newPlainText,"UTF8"));
 }
}

 

 

4)数字签名:

  数字签名,它是确定交换消息的通信方身份的第一个级别。上面A通过使用公钥加密 数据后发给B,B利用私钥解密就得到了需要的数据,问题来了,由于都是使用公钥加密,那么如何检验是A发过来的消息呢?上面也提到了一点,私钥是唯一的,那么A就可以利用A自己的私钥进行加密,然后B再利用A的公钥来解密,就可以了;数字签名的原理就基于此,而通常为了证明发送数据的真实性,通过利用消息摘要获得简短的消息内容,然后再利用私钥进行加密散列数据和消息一起发送。java中为数字签名提供了良好的支持,java.security.Signature类提供了消息签名:

/**
*DigitalSignature2Example.java
*Copyright 2005-2-16
*/
import java.security.Signature;
import java.security.KeyPairGenerator;
import java.security.KeyPair;
import java.security.SignatureException;

/**
*数字签名,使用RSA私钥对对消息摘要签名,然后使用公鈅验证 测试
*/
public class DigitalSignature2Example{
 public static void main(String[] args) throws Exception{
  if(args.length!=1){
   System.err.println("Usage:java DigitalSignature2Example <text>");
   System.exit(1);
  }

  byte[] plainText=args[0].getBytes("UTF8");
  //形成RSA公钥对
  System.out.println("\nStart generating RSA key");
  KeyPairGenerator keyGen=KeyPairGenerator.getInstance("RSA");
  keyGen.initialize(1024);

  KeyPair key=keyGen.generateKeyPair();
  System.out.println("Finish generating RSA key");
  //使用私鈅签名
  Signature sig=Signature.getInstance("SHA1WithRSA");
  sig.initSign(key.getPrivate());
  sig.update(plainText);
  byte[] signature=sig.sign();
  System.out.println(sig.getProvider().getInfo());
  System.out.println("\nSignature:");
  System.out.println(new String(signature,"UTF8"));

  //使用公鈅验证
  System.out.println("\nStart signature verification");
  sig.initVerify(key.getPublic());
  sig.update(plainText);
  try{
   if(sig.verify(signature)){
    System.out.println("Signature verified");
   }else System.out.println("Signature failed");
   }catch(SignatureException e){
    System.out.println("Signature failed");
   }
  }
}


  5)数字证书。

   还有个问题,就是公钥问题,A用私钥加密了,那么B接受到消息后,用A提供的公钥解密;那么现在有个讨厌的C,他把消息拦截了,然后用自己的私钥加密, 同时把自己的公钥发给B,并告诉B,那是A的公钥,结果....,这时候就需要一个中间机构出来说话了(相信权威,我是正确的),就出现了 Certificate Authority(也即CA),有名的CA机构有Verisign等,目前数字认证的工业标准是:CCITT的X.509:
数字证书:它将一个身份标识连同公钥一起进行封装,并由称为认证中心或 CA 的第三方进行数字签名。

   密钥库:java平台为你提供了密钥库,用作密钥和证书的资源库。从物理上讲,密钥库是缺省名称为 .keystore 的文件(有一个选项使它成为加密文件)。密钥和证书可以拥有名称(称为别名),每个别名都由唯一的密码保护。密钥库本身也受密码保护;您可以选择让每个别 名密码与主密钥库密码匹配。

  使用工具keytool,我们来做一件自我认证的事情吧(相信我的认证):

  1、创 建密钥库keytool -genkey -v -alias feiUserKey -keyalg RSA 默认在自己的home目录下(windows系统是c:\documents and settings\<你的用户名> 目录下的.keystore文件),创建我们用 RSA 算法生成别名为 feiUserKey 的自签名的证书,如果使用了-keystore mm 就在当前目录下创建一个密钥库mm文件来保存密钥和证书。

  2、查看证书:keytool -list 列举了密钥库的所有的证书

  也可以在dos下输入keytool -help查看帮助。

二、JAR的签名

  我们已经学会了怎样创建自己的证书了,现在可以开始了解怎样对JAR文件签名,JAR文件在Java中相当于ZIP 文件,允许将多个 Java 类文件打包到一个具有 .jar扩展名的文件中,然后可以对这个jar文件进行数字签名,以证实其来源和真实性。该JAR 文件的接收方可以根据发送方的签名决定是否信任该代码,并可以确信该内容在接收之前没有被篡改过。同时在部署中,可以通过在策略文件中放置访问控制语句根据签名者的身份分配对机器资源的访问权。这样,有些Applet的安全检验访问就得以进行。

  使用jarsigner工具可以对jar文件进行签名:

  现在假设我们有个Test.jar文件(可以使用jar命令行工具生成):

  jarsignerTest.jar feiUserKey (这里我们上面创建了该别名的证书) ,详细信息可以输入jarsigner查看帮助

  验证其真实性:jarsigner-verify Test.jar(注意,验证的是jar是否被修改了,但不检验减少的,如果增加了新的内容,也提示,但减少的不会提示。)

  使用Applet中:<appletcode="Test.class" archive="Test.jar" width="150"height="100"></applet>然后浏览器就会提示你:准许这个会话-拒绝-始终准许-查看证书等。

  三、安全套接字层(SSLSecure Sockets Layer)和传输层安全性(TLSTransport Layer Security)

  安全套接字层和传输层安全性是用于在客户机和服务器之间构建安全的通信通道的协议。它也用来为客户机认证服务器,以及(不太常用的)为服务器认证客户机。该协议在浏览器应用程序中比较常见,浏览器窗口底部的锁表明SSL/TLS 有效:

  1)当使用SSL/TLS(通常使用 https:// URL)向站点进行请求时,从服务器向客户机发送一个证书。客户机使用已安装的公共CA 证书通过这个证书验证服务器的身份,然后检查 IP 名称(机器名)与客户机连接的机器是否匹配。

  2)客户机生成一些可以用来生成对话的私钥(称为会话密钥)的随机信息,然后用服务器的公钥对它加密并将它发送到服务器。服务器用自己的私钥解密消息,然后用该随机信息派生出和客户机一样的私有会话密钥。通常在这个阶段使用RSA 公钥算法。

  3)客户机和服务器使用私有会话密钥和私钥算法(通常是RC4)进行通信。使用另一个密钥的消息认证码来确保消息的完整性。

  java中javax.net.ssl.SSLServerSocketFactory类提供了一个很好的SSLServerSocker的工厂类,熟悉Socket编程的读者可以去练习。当编写完服务器端之后,在浏览器上输入https://主机名:端口就会通过SSL/TLS进行通话了。注意:运行服务端的时候要带系统环境变量运行:javax.net.ssl.keyStore=密钥库(创建证书时,名字应该为主机名,比如localhost)和javax.net.ssl.keyStorePassword=你的密码

 

References:

http://news.csdn.net/n/20070425/103328.html

http://blog.csdn.net/pengrg166/article/details/5912936

http://www.jasypt.org/howtoencryptuserpasswords.html

http://blog.csdn.net/javaman_chen/article/details/5936774

http://blog.csdn.net/javaman_chen/article/details/5939477

http://blog.csdn.net/guo2777/article/details/1791399 (AES)

http://blog.csdn.net/hbcui1984/article/details/5201247 (AES)

http://docstore.mik.ua/orelly/java-ent/security/ch13_04.htm

http://www.yesky.com/SoftChannel/72342371961929728/20050217/1911753_2.shtml (good)

http://www.ietf.org/rfc/rfc1321.txt (MD5 good)

 



评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值