Java Web_几种加密算法
一.几种加密算法
1:消息摘要:(数字指纹):既对一个任意长度的一个数据块进行计算,产生一个唯一指纹。MD5/SHA1
发送给其他人你的信息和摘要,其他人用相同的加密方法得到摘要,最后进行比较摘要是否相同。
MD5的全称是Message-Digest Algorithm 5(信息-摘要算法)。过程不可逆,是单向加密。SHA加密,与MD5相似的用法,只是两者的算法不同。
2:单匙密码体制:DES:比较简便高效,密钥简短,加解密速度快,破译极其困难,但其安全性依赖于密匙的安全性。
DES(Data Encryption Standard)是发明最早的最广泛使用的分组对称加密算法。DES算法的入口参数有三个:Key、Data、Mode。
其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密
3:数字签名:就是信息发送者用其私钥对从所传报文中提取出的特征数据(或称数字指纹)进行RSA算法操作,以保证发信人无法抵赖曾发过该信息(即不可抵赖性),
同时也确保信息报文在经签名后末被篡改(即完整性)。当信息接收者收到报文后,就可以用发送者的公钥对数字签名进行验证。
代表:DSA
4:非对称密匙密码体制(公匙体系):加密密匙不同于解密密匙,加密密匙公之于众,谁都可以使用,解密密匙只有解密人自己知道。代表:RSA
下面是对上面几个例子进行的简单实现:
二.代码解析
1. MD5/SHA
packagecom.text;
importjava.security.MessageDigest;
importjava.security.NoSuchAlgorithmException;
publicclassMD5{
/**
*进行MD5/SHA加密
*
*@paraminfo
*要加密的信息
*@returnString加密后的字符串
*/
privateString encryptToMD5(String str) {
byte[] byteArray =null;
try{
//得到一个MD5的消息摘要
MessageDigest messageDigest = MessageDigest.getInstance("MD5");
//得到一个SHA-1的消息摘要
// messageDigest = MessageDigest.getInstance("SHA-1");
//messageDigest.reset();
//添加要进行计算摘要的信息
messageDigest.update(str.getBytes());
//messageDigest.update(str.getBytes("UTF-8"));
//得到该摘要
byteArray = messageDigest.digest();
}catch(NoSuchAlgorithmException e) {
e.printStackTrace();
}
//将摘要转为字符串返回
returnbyte2hex(byteArray);
}
/**
*将二进制转化为16进制字符串
*
*@paramb
*二进制字节数组
*@returnString
*/
publicString byte2hex(byte[] b){
String hs="";
String stmp="";
for(inti = 0; i < b.length; i++) {
stmp = (java.lang.Integer.toHexString(b[i] & 0XFF));
if(stmp.length() == 1){
hs = hs +"0"+ stmp;
}else{
hs = hs + stmp;
}
}
returnhs.toUpperCase();
}
publicstaticvoidmain(String[] args) {
String msg ="Hello";
System.out.println("明文是:"+ msg);
//执行MD5加密"Hello"
System.out.println("MD5加密了是:"+newMD5().encryptToMD5(msg));
//8B1A9953C4611296A827ABF8C47804D7
}
}
2. DES
packagecom.text;
importjava.security.NoSuchAlgorithmException;
importjava.security.SecureRandom;
importjavax.crypto.Cipher;
importjavax.crypto.KeyGenerator;
importjavax.crypto.SecretKey;
publicclassDES {
/**
*创建密匙
*
*@paramalgorithm
*加密算法,可用DES,DESede,Blowfish
*@returnSecretKey秘密(对称)密钥
*/
publicSecretKey createSecretKey(String algorithm) {
//声明KeyGenerator对象
KeyGenerator keygen;
//声明密钥对象
SecretKey deskey =null;
try{
//返回生成指定算法的秘密密钥的KeyGenerator对象
keygen = KeyGenerator.getInstance(algorithm);
//生成一个密钥
deskey = keygen.generateKey();
}catch(NoSuchAlgorithmException e) {
e.printStackTrace();
}
//返回密匙
returndeskey;
}
/**
*根据密匙进行DES加密
*
*@paramkey
*密匙
*@paraminfo
*要加密的信息
*@returnString加密后的信息
*/
publicString encryptToDES(SecretKey key, String info) {
//定义加密算法,可用DES,DESede,Blowfish
String Algorithm ="DES";
//加密随机数生成器(RNG),(可以不写)
SecureRandom sr =newSecureRandom();
//定义要生成的密文
byte[] cipherByte =null;
try{
//得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
//用指定的密钥和模式初始化Cipher对象
//参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)
c1.init(Cipher.ENCRYPT_MODE, key, sr);
//对要加密的内容进行编码处理,
cipherByte = c1.doFinal(info.getBytes());
}catch(Exception e) {
e.printStackTrace();
}
//返回密文的十六进制形式
returnbyte2hex(cipherByte);
}
/**
*根据密匙进行DES解密
*
*@paramkey
*密匙
*@paramsInfo
*要解密的密文
*@returnString返回解密后信息
*/
publicString decryptByDES(SecretKey key, String sInfo) {
//定义加密算法,
String Algorithm ="DES";
//加密随机数生成器(RNG)
SecureRandom sr =newSecureRandom();
byte[] cipherByte =null;
try{
//得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
//用指定的密钥和模式初始化Cipher对象
c1.init(Cipher.DECRYPT_MODE, key, sr);
//对要解密的内容进行编码处理
cipherByte = c1.doFinal(hex2byte(sInfo));
}catch(Exception e) {
e.printStackTrace();
}
// return byte2hex(cipherByte);
returnnewString(cipherByte);
}
/**
*将二进制转化为16进制字符串
*
*@paramb
*二进制字节数组
*@returnString
*/
publicString byte2hex(byte[] b) {
String hs ="";
String stmp ="";
for(intn = 0; n < b.length; n++) {
stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
if(stmp.length() == 1) {
hs = hs +"0"+ stmp;
}else{
hs = hs + stmp;
}
}
returnhs.toUpperCase();
}
/**
*十六进制字符串转化为2进制
*
*@paramhex
*@return
*/
publicbyte[] hex2byte(String hex) {
byte[] ret =newbyte[8];
byte[] tmp = hex.getBytes();
for(inti = 0; i < 8; i++) {
ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
}
returnret;
}
避免输入较长数据而引发的错误,将上述十六进制字符串转化为2进制方法做以下修改:
/*** 当输入一定长度的数据时,会发现输入数据的长度和加密后数据的长度之间是有一定规律的。
* 输入0-7位数据,加密后为16位;输入8-15位加密后为32位;输入16-23位加密后为48位。。。
* 将输入数据按8的倍数的长度范围来划分。
* 加密后数据的长度会根据输入数据的长度而确定,为16的倍数。
* 得到的十六进制byte数组(byte[] ret)的大小,根据输入数据的长度/加密后数据的长度而变化,为8的倍数。*/
/*** 十六进制字符串转化为2进制
*
*@paramhex
*@return*/
public byte[] hex2byte(String hex) {
//根据输入数据的长度决定加密后数据的长度。 /*** input:[8(x-1),8x)---output:16x---param:8x
* eg:
* input:0-7位---output:16位---param:8
* input:8-15位---output:32位---param:16
* input:16-23位---output:48位---param:24*/
int x=hex.length()/16;
byte[] ret = new byte[8*x];
byte[] tmp = hex.getBytes();
for (int i = 0; i < 8*x; i++) {
ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
}
return ret;
}
/**
*将两个ASCII字符合成一个字节;如:"EF"-->0xEF
*
*@paramsrc0
*byte
*@paramsrc1
*byte
*@returnbyte
*/
publicstaticbyteuniteBytes(bytesrc0,bytesrc1) {
byte_b0 = Byte.decode("0x"+newString(newbyte[] { src0 }))
.byteValue();
_b0 = (byte) (_b0 << 4);
byte_b1 = Byte.decode("0x"+newString(newbyte[] { src1 }))
.byteValue();
byteret = (byte) (_b0 ^ _b1);
returnret;
}
publicstaticvoidmain(String[] args) {
DES des =newDES();
//生成一个DES算法的密匙
SecretKey key = des.createSecretKey("DES");
//用密匙加密信息"Hello"
String str1 = des.encryptToDES(key,"Hello");
System.out.println("使用des加密信息Hello为:"+ str1);
// 02E7AADB2E1DBCF6
//使用这个密匙解密
String str2 = des.decryptByDES(key, str1);
System.out.println("解密后为:"+ str2);
}
}
3. DSA
packagecom.text;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.security.*;
publicclassDSA {
/**
*创建密匙组,并将公匙,私匙放入到指定文件中
*
*默认放入mykeys.bat文件中
*/
publicvoidcreatePairKey() {
try{
//根据特定的算法一个密钥对生成器
KeyPairGenerator keygen = KeyPairGenerator.getInstance("DSA");
//加密随机数生成器(RNG)
SecureRandom random =newSecureRandom();
//重新设置此随机对象的种子
random.setSeed(1000);
//使用给定的随机源(和默认的参数集合)初始化确定密钥大小的密钥对生成器
keygen.initialize(512, random);// keygen.initialize(512);
//生成密钥组
KeyPair keys = keygen.generateKeyPair();
//得到公匙
PublicKey pubkey = keys.getPublic();
//得到私匙
PrivateKey prikey = keys.getPrivate();
//将公匙私匙写入到文件当中
doObjToFile("mykeys.bat",newObject[] { prikey, pubkey });
}catch(NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
/**
*利用私匙对信息进行签名把签名后的信息放入到指定的文件中
*
*@paraminfo
*要签名的信息
*@paramsignfile
*存入的文件
*/
publicvoidsignToInfo(String info, String signfile) {
//从文件当中读取私匙
PrivateKey myprikey = (PrivateKey) getObjFromFile("mykeys.bat", 1);
//从文件中读取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile("mykeys.bat", 2);
try{
// Signature对象可用来生成和验证数字签名
Signature signet = Signature.getInstance("DSA");
//初始化签署签名的私钥
signet.initSign(myprikey);
//更新要由字节签名或验证的数据
signet.update(info.getBytes());
//签署或验证所有更新字节的签名,返回签名
byte[] signed = signet.sign();
//将数字签名,公匙,信息放入文件中
doObjToFile(signfile,newObject[] { signed, mypubkey, info });
}catch(Exception e) {
e.printStackTrace();
}
}
/**
*读取数字签名文件根据公匙,签名,信息验证信息的合法性
*
*@returntrue验证成功false验证失败
*/
publicbooleanvalidateSign(String signfile) {
//读取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile(signfile, 2);
//读取签名
byte[] signed = (byte[]) getObjFromFile(signfile, 1);
//读取信息
String info = (String) getObjFromFile(signfile, 3);
try{
//初始一个Signature对象,并用公钥和签名进行验证
Signature signetcheck = Signature.getInstance("DSA");
//初始化验证签名的公钥
signetcheck.initVerify(mypubkey);
//使用指定的byte数组更新要签名或验证的数据
signetcheck.update(info.getBytes());
System.out.println(info);
//验证传入的签名
returnsignetcheck.verify(signed);
}catch(Exception e) {
e.printStackTrace();
returnfalse;
}
}
/**
*将指定的对象写入指定的文件
*
*@paramfile
*指定写入的文件
*@paramobjs
*要写入的对象
*/
publicvoiddoObjToFile(String file, Object[] objs) {
ObjectOutputStream oos =null;
try{
FileOutputStream fos =newFileOutputStream(file);
oos =newObjectOutputStream(fos);
for(inti = 0; i < objs.length; i++) {
oos.writeObject(objs[i]);
}
}catch(Exception e) {
e.printStackTrace();
}finally{
try{
oos.close();
}catch(IOException e) {
e.printStackTrace();
}
}
}
/**
*返回在文件中指定位置的对象
*
*@paramfile
*指定的文件
*@parami
*从1开始
*@return
*/
publicObject getObjFromFile(String file,inti) {
ObjectInputStream ois =null;
Object obj =null;
try{
FileInputStream fis =newFileInputStream(file);
ois =newObjectInputStream(fis);
for(intj = 0; j < i; j++) {
obj = ois.readObject();
}
}catch(Exception e) {
e.printStackTrace();
}finally{
try{
ois.close();
}catch(IOException e) {
e.printStackTrace();
}
}
returnobj;
}
publicstaticvoidmain(String[] args) {
DSA dsa =newDSA();
//创建公匙和私匙
dsa.createPairKey();
//对Hello使用私匙进行签名
dsa.signToInfo("Hello","mysign.bat");
//利用公匙对签名进行验证。
if(dsa.validateSign("mysign.bat")) {
System.out.println("Success!");
}else{
System.out.println("Fail!");
}
}
}
/**
用到的重要的类
javax.crypto.KeyGenerator
public final SecretKey generateKey()生成一个密钥
public static final KeyGenerator getInstance(String algorithm)返回生成指定算法的秘密密钥的KeyGenerator对象。
javax.crypto接口SecretKey
javax.crypto.Cipher此类为加密和解密提供密码功能。它构成了Java Cryptographic Extension (JCE)框架的核心
public final void init(int opmode,Key key)
public final byte[] A(byte[] input)按单部分操作加密或解密数据,或者结束一个多部分操作
java.security.KeyPairGenerator
static KeyPairGenerator getInstance(String algorithm)
回生成指定算法的public/private密钥对的KeyPairGenerator对象。
java.security.Signature
使用Signature对象签名数据或验证签名包括以下三个阶段:
1:初始化,使用
初始化验证签名的公钥(请参见initVerify),或使用
初始化签署签名的私钥(也可以选择“安全随机数生成器”)initSign(PrivateKey)和initSign(PrivateKey, SecureRandom))。
2:更新
根据初始化类型,这可更新要签名或验证的字节。请参见update方法。
3:签署或验证所有更新字节的签名。请参见sign方法和verify方法。
*/