加密，是以某种特殊的算法改变原有的信息数据，使得未授权的用户即使获得了已加密的信息，但因不知解密的方法，仍然无法了解信息的内容。大体上分为双向加密和单向加密，而双向加密又分为对称加密和非对称加密(有些资料将加密直接分为对称加密和非对称加密)。 

 双向加密大体意思就是明文加密后形成密文，可以通过算法还原成明文。而单向加密只是对信息进行了摘要计算，不能通过算法生成明文，单向加密从严格意思上说不能算是加密的一种，应该算是摘要算法吧。具体区分可以参考： 
 (本人解释不清呢 …… ) 
 http://security.group.iteye.com/group/wiki/1710-one-way-encryption-algorithm 
 
 
 
一、双向加密
 
(一)、对称加密
 
采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。 
 需要对加密和解密使用相同密钥的加密算法。由于其速度，对称性加密通常在消息发送方需要加密大量数据时使用。对称性加密也称为密钥加密。 
 所谓对称，就是采用这种加密方法的双方使用方式用同样的密钥进行加密和解密。密钥是控制加密及解密过程的指令。 

 算法是一组规则，规定如何进行加密和解密。因此对称式加密本身不是安全的。 　　 
 常用的对称加密有：DES、IDEA、RC2、RC4、SKIPJACK、RC5、AES算法等 
  
 
对称加密一般java类中中定义成员
 
Java代码
 
 
 
 
 
 
//KeyGenerator 提供对称密钥生成器的功能，支持各种算法
 
 
private KeyGenerator keygen;
 
 
//SecretKey 负责保存对称密钥
 
 
private SecretKey deskey;
 
 
//Cipher负责完成加密或解密工作
 
 
private Cipher c;
 
 
//该字节数组负责保存加密的结果
 
 
private byte[] cipherByte;
 
 
 
 
在构造函数中初始化
 
Java代码
 
 
 
 
 
 
Security.addProvider(new com.sun.crypto.provider.SunJCE());
 
 
//实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)
 
 
keygen = KeyGenerator.getInstance("DES");//
 
 
//生成密钥
 
 
deskey = keygen.generateKey();
 
 
//生成Cipher对象,指定其支持的DES算法
 
 
c = Cipher.getInstance("DES");
 
 
 
1. DES算法
 
 
 
DES算法为密码体制中的对称密码体制，又被成为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。 明文按64位进行分组, 密钥长64位，密钥事实上是56位参与DES运算（第8、16、24、32、40、48、56、64位是校验位， 使得每个密钥都有奇数个1）分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。 
  
 
Java代码
 
 
 
 
 
 
import java.security.InvalidKeyException;
 
 
import java.security.NoSuchAlgorithmException;
 
 
import java.security.Security;
 
 
 
import javax.crypto.BadPaddingException;
 
 
import javax.crypto.Cipher;
 
 
import javax.crypto.IllegalBlockSizeException;
 
 
import javax.crypto.KeyGenerator;
 
 
import javax.crypto.NoSuchPaddingException;
 
 
import javax.crypto.SecretKey;
 
 
 
public class EncrypDES {
 
 
 
//KeyGenerator 提供对称密钥生成器的功能，支持各种算法
 
 
private KeyGenerator keygen;
 
 
//SecretKey 负责保存对称密钥
 
 
private SecretKey deskey;
 
 
//Cipher负责完成加密或解密工作
 
 
private Cipher c;
 
 
//该字节数组负责保存加密的结果
 
 
private byte[] cipherByte;
 
 
 
public EncrypDES() throws NoSuchAlgorithmException, NoSuchPaddingException{
 
 
Security.addProvider(new com.sun.crypto.provider.SunJCE());
 
 
//实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)
 
 
keygen = KeyGenerator.getInstance("DES");
 
 
//生成密钥
 
 
deskey = keygen.generateKey();
 
 
//生成Cipher对象,指定其支持的DES算法
 
 
c = Cipher.getInstance("DES");
 
 
}
 
 
 
/**
 
 
* 对字符串加密
 
 
* 
 
 
* @param str
 
 
* @return
 
 
* @throws InvalidKeyException
 
 
* @throws IllegalBlockSizeException
 
 
* @throws BadPaddingException
 
 
*/
 
 
public byte[] Encrytor(String str) throws InvalidKeyException,
 
 
IllegalBlockSizeException, BadPaddingException {
 
 
// 根据密钥，对Cipher对象进行初始化，ENCRYPT_MODE表示加密模式
 
 
c.init(Cipher.ENCRYPT_MODE, deskey);
 
 
byte[] src = str.getBytes();
 
 
// 加密，结果保存进cipherByte
 
 
cipherByte = c.doFinal(src);
 
 
return cipherByte;
 
 
}
 
 
 
/**
 
 
* 对字符串解密
 
 
* 
 
 
* @param buff
 
 
* @return
 
 
* @throws InvalidKeyException
 
 
* @throws IllegalBlockSizeException
 
 
* @throws BadPaddingException
 
 
*/
 
 
public byte[] Decryptor(byte[] buff) throws InvalidKeyException,
 
 
IllegalBlockSizeException, BadPaddingException {
 
 
// 根据密钥，对Cipher对象进行初始化，DECRYPT_MODE表示加密模式
 
 
c.init(Cipher.DECRYPT_MODE, deskey);
 
 
cipherByte = c.doFinal(buff);
 
 
return cipherByte;
 
 
}
 
 
 
/**
 
 
* @param args
 
 
* @throws NoSuchPaddingException 
 
 
* @throws NoSuchAlgorithmException 
 
 
* @throws BadPaddingException 
 
 
* @throws IllegalBlockSizeException 
 
 
* @throws InvalidKeyException 
 
 
*/
 
 
public static void main(String[] args) throws Exception {
 
 
EncrypDES de1 = new EncrypDES();
 
 
String msg ="郭XX-搞笑相声全集";
 
 
byte[] encontent = de1.Encrytor(msg);
 
 
byte[] decontent = de1.Decryptor(encontent);
 
 
System.out.println("明文是:" + msg);
 
 
System.out.println("加密后:" + new String(encontent));
 
 
System.out.println("解密后:" + new String(decontent));
 
 
}
 
 
 
}
 
 
 
2. 3DES
 
 
 
  3DES又称Triple DES，是DES加密算法的一种模式，它使用3条56位的密钥对3DES 
 数据进行三次加密。数据加密标准（DES）是美国的一种由来已久的加密标准，它使用对称密钥加密法，并于1981年被ANSI组织规范为ANSI X.3.92。DES使用56位密钥和密码块的方法，而在密码块的方法中，文本被分成64位大小的文本块然后再进行加密。比起最初的DES，3DES更为安全。 　　 
 3DES（即Triple DES）是DES向AES过渡的加密算法（1999年，NIST将3-DES指定为过渡的加密标准），是DES的一个更安全的变形。它以DES为基本模块，通过组合分组方法设计出分组加密算法，其具体实现如下： 
 设Ek()和Dk()代表DES算法的加密和解密过程，K代表DES算法使用的密钥，P代表明文，C代表密文， 
 这样， 　　 
 3DES加密过程为：C=Ek3(Dk2(Ek1(P))) 
 3DES解密过程为：P=Dk1((EK2(Dk3(C))) 
 
 
 
Java代码
 
 
 
 
 
 
import java.security.InvalidKeyException;
 
 
import java.security.NoSuchAlgorithmException;
 
 
import java.security.Security;
 
 
 
import javax.crypto.BadPaddingException;
 
 
import javax.crypto.Cipher;
 
 
import javax.crypto.IllegalBlockSizeException;
 
 
import javax.crypto.KeyGenerator;
 
 
import javax.crypto.NoSuchPaddingException;
 
 
import javax.crypto.SecretKey;
 
 
 
public class EncrypDES3 {
 
 
 
// KeyGenerator 提供对称密钥生成器的功能，支持各种算法
 
 
private KeyGenerator keygen;
 
 
// SecretKey 负责保存对称密钥
 
 
private SecretKey deskey;
 
 
// Cipher负责完成加密或解密工作
 
 
private Cipher c;
 
 
// 该字节数组负责保存加密的结果
 
 
private byte[] cipherByte;
 
 
 
public EncrypDES3() throws NoSuchAlgorithmException, NoSuchPaddingException {
 
 
Security.addProvider(new com.sun.crypto.provider.SunJCE());
 
 
// 实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)
 
 
keygen = KeyGenerator.getInstance("DESede");
 
 
// 生成密钥
 
 
deskey = keygen.generateKey();
 
 
// 生成Cipher对象,指定其支持的DES算法
 
 
c = Cipher.getInstance("DESede");
 
 
}
 
 
 
/**
 
 
* 对字符串加密
 
 
* 
 
 
* @param str
 
 
* @return
 
 
* @throws InvalidKeyException
 
 
* @throws IllegalBlockSizeException
 
 
* @throws BadPaddingException
 
 
*/
 
 
public byte[] Encrytor(String str) throws InvalidKeyException,
 
 
IllegalBlockSizeException, BadPaddingException {
 
 
// 根据密钥，对Cipher对象进行初始化，ENCRYPT_MODE表示加密模式
 
 
c.init(Cipher.ENCRYPT_MODE, deskey);
 
 
byte[] src = str.getBytes();
 
 
// 加密，结果保存进cipherByte
 
 
cipherByte = c.doFinal(src);
 
 
return cipherByte;
 
 
}
 
 
 
/**
 
 
* 对字符串解密
 
 
* 
 
 
* @param buff
 
 
* @return
 
 
* @throws InvalidKeyException
 
 
* @throws IllegalBlockSizeException
 
 
* @throws BadPaddingException
 
 
*/
 
 
public byte[] Decryptor(byte[] buff) throws InvalidKeyException,
 
 
IllegalBlockSizeException, BadPaddingException {
 
 
// 根据密钥，对Cipher对象进行初始化，DECRYPT_MODE表示加密模式
 
 
c.init(Cipher.DECRYPT_MODE, deskey);
 
 
cipherByte = c.doFinal(buff);
 
 
return cipherByte;
 
 
}
 
 
 
/**
 
 
* @param args
 
 
* @throws NoSuchPaddingException 
 
 
* @throws NoSuchAlgorithmException 
 
 
* @throws BadPaddingException 
 
 
* @throws IllegalBlockSizeException 
 
 
* @throws InvalidKeyException 
 
 
*/
 
 
public static void main(String[] args) throws Exception {
 
 
EncrypDES3 des = new EncrypDES3();
 
 
String msg ="郭XX-搞笑相声全集";
 
 
byte[] encontent = des.Encrytor(msg);
 
 
byte[] decontent = des.Decryptor(encontent);
 
 
System.out.println("明文是:" + msg);
 
 
System.out.println("加密后:" + new String(encontent));
 
 
System.out.println("解密后:" + new String(decontent));
 
 
 
}
 
 
 
}
 
 
 
3. AES
 
 
 
AES密码学中的高级加密标准（Advanced Encryption Standard，AES），又称 高级加密标准 
 Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。 　　该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计，结合两位作者的名字，以Rijndael之命名之，投稿高级加密标准的甄选流程。（Rijdael的发音近于 "Rhinedoll"。） 
 
 
 
Java代码：
 
 
 
 
 
 
import java.security.InvalidKeyException;
 
 
import java.security.NoSuchAlgorithmException;
 
 
import java.security.Security;
 
 
 
import javax.crypto.BadPaddingException;
 
 
import javax.crypto.Cipher;
 
 
import javax.crypto.IllegalBlockSizeException;
 
 
import javax.crypto.KeyGenerator;
 
 
import javax.crypto.NoSuchPaddingException;
 
 
import javax.crypto.SecretKey;
 
 
 
public class EncrypAES {
 
 
 
//KeyGenerator 提供对称密钥生成器的功能，支持各种算法
 
 
private KeyGenerator keygen;
 
 
//SecretKey 负责保存对称密钥
 
 
private SecretKey deskey;
 
 
//Cipher负责完成加密或解密工作
 
 
private Cipher c;
 
 
//该字节数组负责保存加密的结果
 
 
private byte[] cipherByte;
 
 
 
public EncrypAES() throws NoSuchAlgorithmException, NoSuchPaddingException{
 
 
Security.addProvider(new com.sun.crypto.provider.SunJCE());
 
 
//实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)
 
 
keygen = KeyGenerator.getInstance("AES");
 
 
//生成密钥
 
 
deskey = keygen.generateKey();
 
 
//生成Cipher对象,指定其支持的DES算法
 
 
c = Cipher.getInstance("AES");
 
 
}
 
 
 
/**
 
 
* 对字符串加密
 
 
* 
 
 
* @param str
 
 
* @return
 
 
* @throws InvalidKeyException
 
 
* @throws IllegalBlockSizeException
 
 
* @throws BadPaddingException
 
 
*/
 
 
public byte[] Encrytor(String str) throws InvalidKeyException,
 
 
IllegalBlockSizeException, BadPaddingException {
 
 
// 根据密钥，对Cipher对象进行初始化，ENCRYPT_MODE表示加密模式
 
 
c.init(Cipher.ENCRYPT_MODE, deskey);
 
 
byte[] src = str.getBytes();
 
 
// 加密，结果保存进cipherByte
 
 
cipherByte = c.doFinal(src);
 
 
return cipherByte;
 
 
}
 
 
 
/**
 
 
* 对字符串解密
 
 
* 
 
 
* @param buff
 
 
* @return
 
 
* @throws InvalidKeyException
 
 
* @throws IllegalBlockSizeException
 
 
* @throws BadPaddingException
 
 
*/
 
 
public byte[] Decryptor(byte[] buff) throws InvalidKeyException,
 
 
IllegalBlockSizeException, BadPaddingException {
 
 
// 根据密钥，对Cipher对象进行初始化，DECRYPT_MODE表示加密模式
 
 
c.init(Cipher.DECRYPT_MODE, deskey);
 
 
cipherByte = c.doFinal(buff);
 
 
return cipherByte;
 
 
}
 
 
 
/**
 
 
* @param args
 
 
* @throws NoSuchPaddingException 
 
 
* @throws NoSuchAlgorithmException 
 
 
* @throws BadPaddingException 
 
 
* @throws IllegalBlockSizeException 
 
 
* @throws InvalidKeyException 
 
 
*/
 
 
public static void main(String[] args) throws Exception {
 
 
EncrypAES de1 = new EncrypAES();
 
 
String msg ="郭XX-搞笑相声全集";
 
 
byte[] encontent = de1.Encrytor(msg);
 
 
byte[] decontent = de1.Decryptor(encontent);
 
 
System.out.println("明文是:" + msg);
 
 
System.out.println("加密后:" + new String(encontent));
 
 
System.out.println("解密后:" + new String(decontent));
 
 
}
 
 
 
}
 
 
 
 
 
 
 
(二)、非对称加密
 
1976年，美国学者Dime和Henman为解决信息公开传送和密钥管理问题，提出一种新的密钥交换协议，允许在不安全的媒体上的通讯双方交换信息，安全地达成一致的密钥，这就是“公开密钥系统”。相对于“对称加密算法”这种方法也叫做“非对称加密算法”。 与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥 （privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。 
  
 
1. RSA 公钥加密算法
 
 
 
RSA 公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在（美国麻省理工学院）开发的。RSA取名来自开发他们三者的名字。RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的所有密码攻击，已被ISO推荐为公钥数据加密标准。RSA算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。 
 
 
 
Java代码：
 
 
 
 
 
 
import java.security.InvalidKeyException;
 
 
import java.security.KeyPair;
 
 
import java.security.KeyPairGenerator;
 
 
import java.security.NoSuchAlgorithmException;
 
 
import java.security.interfaces.RSAPrivateKey;
 
 
import java.security.interfaces.RSAPublicKey;
 
 
 
import javax.crypto.BadPaddingException;
 
 
import javax.crypto.Cipher;
 
 
import javax.crypto.IllegalBlockSizeException;
 
 
import javax.crypto.NoSuchPaddingException;
 
 
 
public class EncrypRSA {
 
 
 
/**
 
 
* 加密
 
 
* @param publicKey
 
 
* @param srcBytes
 
 
* @return
 
 
* @throws NoSuchAlgorithmException
 
 
* @throws NoSuchPaddingException
 
 
* @throws InvalidKeyException
 
 
* @throws IllegalBlockSizeException
 
 
* @throws BadPaddingException
 
 
*/
 
 
protected byte[] encrypt(RSAPublicKey publicKey,byte[] srcBytes) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{
 
 
if(publicKey!=null){
 
 
//Cipher负责完成加密或解密工作，基于RSA
 
 
Cipher cipher = Cipher.getInstance("RSA");
 
 
//根据公钥，对Cipher对象进行初始化
 
 
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
 
 
byte[] resultBytes = cipher.doFinal(srcBytes);
 
 
return resultBytes;
 
 
}
 
 
return null;
 
 
}
 
 
 
/**
 
 
* 解密 
 
 
* @param privateKey
 
 
* @param srcBytes
 
 
* @return
 
 
* @throws NoSuchAlgorithmException
 
 
* @throws NoSuchPaddingException
 
 
* @throws InvalidKeyException
 
 
* @throws IllegalBlockSizeException
 
 
* @throws BadPaddingException
 
 
*/
 
 
protected byte[] decrypt(RSAPrivateKey privateKey,byte[] srcBytes) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{
 
 
if(privateKey!=null){
 
 
//Cipher负责完成加密或解密工作，基于RSA
 
 
Cipher cipher = Cipher.getInstance("RSA");
 
 
//根据公钥，对Cipher对象进行初始化
 
 
cipher.init(Cipher.DECRYPT_MODE, privateKey);
 
 
byte[] resultBytes = cipher.doFinal(srcBytes);
 
 
return resultBytes;
 
 
}
 
 
return null;
 
 
}
 
 
 
/**
 
 
* @param args
 
 
* @throws NoSuchAlgorithmException 
 
 
* @throws BadPaddingException 
 
 
* @throws IllegalBlockSizeException 
 
 
* @throws NoSuchPaddingException 
 
 
* @throws InvalidKeyException 
 
 
*/
 
 
public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
 
 
EncrypRSA rsa = new EncrypRSA();
 
 
String msg = "郭XX-精品相声";
 
 
//KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
 
 
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
 
 
//初始化密钥对生成器，密钥大小为1024位
 
 
keyPairGen.initialize(1024);
 
 
//生成一个密钥对，保存在keyPair中
 
 
KeyPair keyPair = keyPairGen.generateKeyPair();
 
 
//得到私钥
 
 
RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate(); 
 
 
//得到公钥
 
 
RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();
 
 
 
//用公钥加密
 
 
byte[] srcBytes = msg.getBytes();
 
 
byte[] resultBytes = rsa.encrypt(publicKey, srcBytes);
 
 
 
//用私钥解密
 
 
byte[] decBytes = rsa.decrypt(privateKey, resultBytes);
 
 
 
System.out.println("明文是:" + msg);
 
 
System.out.println("加密后是:" + new String(resultBytes));
 
 
System.out.println("解密后是:" + new String(decBytes));
 
 
}
 
 
 
}
 
 
 
2. DSA
 
Digital Signature Algorithm (DSA)是Schnorr和ElGamal签名算法的变种，被美国NIST作为DSS(DigitalSignature Standard)。(感觉有点复杂，没有附代码) 
 详见http://63938525.iteye.com/blog/1051565 
 
 
 

 (三)、题外话 MySQL加密解密函数
 
MySQL有两个函数来支持这种类型的加密，分别叫做ENCODE()和DECODE()。 
 下面是一个简单的实例： 
  
 
Mysql代码
 
 
 
 
 
 
mysql> INSERT INTO users (username,password) VALUES ('joe',ENCODE('guessme','abr'));
 
 
 
Query OK， 1 row affected （0.14 sec）
 
 

 其中，Joe的密码是guessme，它通过密钥abracadabra被加密。要注意的是，加密完的结果是一个二进制字符串，如下所示： 

 提示：虽然ENCODE()和DECODE()这两个函数能够满足大多数的要求，但是有的时候您希望使用强度更高的加密手段。在这种情况下，您可以使用AES_ENCRYPT()和AES_DECRYPT()函数，它们的工作方式是相同的，但是加密强度更高。 


 单向加密与双向加密不同，一旦数据被加密就没有办法颠倒这一过程。因此密码的验证包括对用户输入内容的重新加密，并将它与保存的密文进行比对，看是否匹配。一种简单的单向加密方式是MD5校验码。MySQL的MD5（）函数会为您的数据创建一个“指纹”并将它保存起来，供验证测试使用。下面就是如何使用它的一个简单例子： 

 Mysql代码：
 
 
 
 
 
 
mysql> INSERT INTO users (username,password) VALUES ('joe',MD5('guessme'));
 
 
 
Query OK， 1 row affected （0.00 sec）
 

 或者，您考虑一下使用ENCRYPT（）函数，它使用系统底层的crypt（）系统调用来完成加密。这个函数有两个参数：一个是要被加密的字符串，另一个是双（或者多）字符的“salt”。它然后会用salt加密字符串；这个salt然后可以被用来再次加密用户输入的内容，并将它与先前加密的字符串进行比对。下面一个例子说明了如何使用它：
 
 
 
Mysql代码：
 
 
 
 
 
 
mysql> INSERT INTO users (username,password) VALUES('joe'， ENCRYPT('guessme','ab'));
 
 
 
Query OK， 1 row affected （0.00 sec）
 

 提示：ENCRYPT()只能用在UNIX、LINIX系统上，因为它需要用到底层的crypt()库。
 
 
 
 
 
 
 
 
 
二、单向加密(信息摘要)
 
Java一般需要获取对象MessageDigest来实现单项加密(信息摘要)。
 
 
 
 
 
1. MD5
 
 
 
MD5  即Message-Digest Algorithm 5（信息-摘要算法 5），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD5实现。将数据（如汉字）运算为另一固定长度值，是杂凑算法的基础原理，MD5的前身有MD2、MD3和MD4。MD5的作用是让大容量信息在用数字签名软件签署私人密钥前被"压缩"成一种保密的格式（就是把一个任意长度的字节串变换成一定长的十六进制数字串）。 
 除了MD5以外，其中比较有名的还有sha-1、RIPEMD以及Haval等 
 
 
 
Java代码：
 
 
 
 
 
 
import java.security.MessageDigest;
 
 
import java.security.NoSuchAlgorithmException;
 
 
 
public class EncrypMD5 {
 
 
 
public byte[] eccrypt(String info) throws NoSuchAlgorithmException{
 
 
//根据MD5算法生成MessageDigest对象
 
 
MessageDigest md5 = MessageDigest.getInstance("MD5");
 
 
byte[] srcBytes = info.getBytes();
 
 
//使用srcBytes更新摘要
 
 
md5.update(srcBytes);
 
 
//完成哈希计算，得到result
 
 
byte[] resultBytes = md5.digest();
 
 
return resultBytes;
 
 
}
 
 
 
 
public static void main(String args[]) throws NoSuchAlgorithmException{
 
 
String msg = "郭XX-精品相声技术";
 
 
EncrypMD5 md5 = new EncrypMD5();
 
 
byte[] resultBytes = md5.eccrypt(msg);
 
 
 
System.out.println("密文是：" + new String(resultBytes));
 
 
System.out.println("明文是：" + msg);
 
 
}
 
 
 
}
 
 
 
2. SHA 
 
 
 
SHA 是一种数据加密算法，该算法经过加密专家多年来的发展和改进已日益完善，现在已成为公认的最安全的散列算法之一，并被广泛使用。该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。散列函数值可以说时对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。
 
 
 
Java代码：
 
  
 
 
 
 
import java.security.MessageDigest;
 
 
import java.security.NoSuchAlgorithmException;
 
 
 
public class EncrypSHA {
 
 
 
public byte[] eccrypt(String info) throws NoSuchAlgorithmException{
 
 
MessageDigest md5 = MessageDigest.getInstance("SHA");
 
 
byte[] srcBytes = info.getBytes();
 
 
//使用srcBytes更新摘要
 
 
md5.update(srcBytes);
 
 
//完成哈希计算，得到result
 
 
byte[] resultBytes = md5.digest();
 
 
return resultBytes;
 
 
}
 
 
 
/**
 
 
* @param args
 
 
* @throws NoSuchAlgorithmException 
 
 
*/
 
 
public static void main(String[] args) throws NoSuchAlgorithmException {
 
 
String msg = "郭XX-精品相声技术";
 
 
EncrypSHA sha = new EncrypSHA();
 
 
byte[] resultBytes = sha.eccrypt(msg);
 
 
System.out.println("明文是：" + msg);
 
 
System.out.println("密文是：" + new String(resultBytes));
 
 
 
}
 
 
 
}
 

 附件中是以上几种的源代码，附带额外的两种使用方式。 

 增加一种关于文件的哈希算法源代码： 
 
Java代码：
 
 
 
 
 
 
import java.io.FileInputStream;
 
 
import java.io.InputStream;
 
 
import java.security.MessageDigest;
 
 
 
public class FileHashUtil {
 
 
 
public static final char[] hexChar = { 
 
 
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
 
 
public static final String[] hashTypes = new String[] { "MD2", "MD5", "SHA1", "SHA-256", "SHA-384", "SHA-512" };
 
 
 
public void MD5File(String fileName) throws Exception{
 
 
//String fileName = args[0];
 
 
System.out.println("需要获取hash的文件为：　" + fileName);
 
 
java.util.List<MessageDigest> mds = new java.util.ArrayList<MessageDigest>();
 
 
for (String hashType : hashTypes) {
 
 
MessageDigest md = MessageDigest.getInstance(hashType);
 
 
mds.add(md);
 
 
}
 
 
InputStream fis = null;
 
 
try {
 
 
fis = new FileInputStream(fileName);
 
 
byte[] buffer = new byte[1024];
 
 
int numRead = 0;
 
 
while ((numRead = fis.read(buffer)) > 0) {
 
 
for (MessageDigest md : mds) {
 
 
md.update(buffer, 0, numRead);
 
 
}
 
 
}
 
 
} catch (Exception ex) {
 
 
ex.printStackTrace();
 
 
} finally {
 
 
if (fis != null) {
 
 
fis.close();
 
 
}
 
 
}
 
 
for (MessageDigest md : mds) {
 
 
System.out.println(md.getAlgorithm() + " == " + toHexString(md.digest()));
 
 
}
 
 
}
 
 
 
 
public static void main(String[] args) throws Exception {
 
 
String[] fileName = new String[] {"D:/hapfish/ShellFolder.java","D:/hapfish/ShellFolder - 副本.java",
 
 
"E:/ShellFolder - 副本.java","E:/ShellFolder.txt","D:/hapfish/ShellFolder.jpg",
 
 
"E:/ShellFolder增加字符.txt","D:/hapfish/birosoft.jar"};
 
 
FileHashUtil files = new FileHashUtil();
 
 
for(int i=0;i<fileName.length;i++){
 
 
files.MD5File(fileName[i]);
 
 
} 
 
 
 
 
}
 
 
 
public static String toHexString(byte[] b) {
 
 
StringBuilder sb = new StringBuilder(b.length * 2);
 
 
for (int i = 0; i < b.length; i++) {
 
 
sb.append(hexChar[(b[i] & 0xf0) >>> 4]);
 
 
sb.append(hexChar[b[i] & 0x0f]);
 
 
}
 
 
return sb.toString();
 
 
}
 
 
 
}
 

 运行说明 ：
 
 
 
"D:/hapfish/ShellFolder.java",
"D:/hapfish/ShellFolder - 副本.java",
"E:/ShellFolder - 副本.java",
"E:/ShellFolder.txt",
"D:/hapfish/ShellFolder.jpg",
以上五个文件是同一文件经过复制、改扩展名的，最后计算哈希结果是一致的。

"E:/ShellFolder增加字符.txt" 增加了几个字符串，就不一样了

"D:/hapfish/birosoft.jar" 完全不相关的另外一个文件
 
 
 
运行结果：
 
 
 
需要获取hash的文件为：　D:/hapfish/ShellFolder.java
MD2 == 3a755a99c5e407005cd45ebd856b4649
MD5 == 5d08d440fa911d1e418c69a90b83cd86
SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63
SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99
SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6
SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458
需要获取hash的文件为：　D:/hapfish/ShellFolder - 副本.java
MD2 == 3a755a99c5e407005cd45ebd856b4649
MD5 == 5d08d440fa911d1e418c69a90b83cd86
SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63
SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99
SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6
SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458
需要获取hash的文件为：　E:/ShellFolder - 副本.java
MD2 == 3a755a99c5e407005cd45ebd856b4649
MD5 == 5d08d440fa911d1e418c69a90b83cd86
SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63
SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99
SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6
SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458
需要获取hash的文件为：　E:/ShellFolder.txt
MD2 == 3a755a99c5e407005cd45ebd856b4649
MD5 == 5d08d440fa911d1e418c69a90b83cd86
SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63
SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99
SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6
SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458
需要获取hash的文件为：　D:/hapfish/ShellFolder.jpg
MD2 == 3a755a99c5e407005cd45ebd856b4649
MD5 == 5d08d440fa911d1e418c69a90b83cd86
SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63
SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99
SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6
SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458
需要获取hash的文件为：　E:/ShellFolder增加字符.txt
MD2 == f2717c24c6c0e110457bd17221c9ca6c
MD5 == c49e353a7c4c26bd7ccb5e90917c230f
SHA1 == 477c8a9e465bfaa4be42d35c032a17f7e6b42b97
SHA-256 == 9fa18adaf242ebcdc6563922d84c2a163c82e1a24db2eb2b73978ed1f354a8a3
SHA-384 == 4eee8f8e6d64d21c15dc01fa049f4d12a3b8e1d94d87763fe0bea75ab5ea8432fa8251289ece45ee39fe3d36b3c3020c
SHA-512 == e852ec0ff77250be497389d2f5a1818c18bb66106b9905c4ee26fe0d256eb3b77e0ce9a28a84e4b67e4332ba37ec3aa7518148e3a682318c0fc34c391f45c201
需要获取hash的文件为：　D:/hapfish/birosoft.jar
MD2 == 38c5e1404718916dec59c33cafc909b3
MD5 == dc3e2cc4fb3949cf3660e0f5f8c3fba3
SHA1 == cde3dc25498afc5a563af0bb0eb54dc45f71bb28
SHA-256 == adf6a961c70c6ea677dff066fc5d896fb0beb4dd442ca0eb619ae1d1b04291e5
SHA-384 == fe7c6b754893c53ebd82bb53703fb5cc32115c9a38f98072f73def90729b271ee3c5c78e258bd9ff5ee5476193c2178b
SHA-512 == a15376f327256a6e049dfbdc5c2ad3a98bffccc6fa92ee01ff53db6b04471ca0f45ca28f76ff4a6911b57825afa046671299141f2499d71f1dac618c92385491

 

 最后，把运行结果贴出来有点占空间，主要为了说明表述自己的猜想。一般来说同一哈希算法对同一文件(镜像、扩展名被修改)所产生的结果应该是一致的。 

 因此有个猜想，在baidu文库、腾讯的群共享上传时，先会判断是否有相同文件，从某种可能上来说也采用了对文件的哈希算法，毕竟从本地运算一个哈希算法后获得的数值要比把整个文件传过去比较实惠得多。而且字符串的比较也是很方便的。 

 对于某一种哈希算法，存在一种可能：就是两个不同的文件，计算出来的哈希值可能是一样的。当然为了保险，可以用两种甚至更多的哈希算法，只有在每种算法获得的哈希值都相同时，才能判断是同一个文件。 
 如果我们也对用户上传的文件进行哈希计算的话，就可以节省资源，同样的文件按理说可以减少上传次数……

一、Java常用加密方式
 
Base64加密算法(编码方式)
MD5加密(消息摘要算法，验证信息完整性)
对称加密算法
非对称加密算法
数字签名算法
数字证书
 
二、分类
 
按加密算法是否需要key被分为两类： 
 
  
不基于key的有: Base64算法、MD5
基于key的有: 对称加密算法、非对称加密算法、数字签名算法、数字证书、HMAC、RC4(对称加密)
按加密算法是否可逆被分为两类： 
 
  
单向加密算法(不可解密)：MD5、SHA、HMAC
非单项加密算法(可解密)：BASE64、对称加密算法、非对称加密算法、数字签名算法、数字证书
 
三、算法介绍
 
1.对称加密
 
对称加密是最快速、最简单的一种加密方式，加密（encryption）与解密（decryption）用的是同样的密钥（secret key）。对称加密有很多种算法，由于它效率很高，所以被广泛使用在很多加密协议的核心当中。
 
对称加密通常使用的是相对较小的密钥，一般小于256 bit。因为密钥越大，加密越强，但加密与解密的过程越慢。如果你只用1 bit来做这个密钥，那黑客们可以先试着用0来解密，不行的话就再用1解；但如果你的密钥有1 MB大，黑客们可能永远也无法破解，但加密和解密的过程要花费很长的时间。密钥的大小既要照顾到安全性，也要照顾到效率，是一个trade-off。
 
DES(Data Encryption Standard)和TripleDES是对称加密的两种实现。
 
DES和TripleDES基本算法一致，只是TripleDES算法提供的key位数更多，加密可靠性更高。 
 DES使用的密钥key为8字节，初始向量IV也是8字节。 
 TripleDES使用24字节的key，初始向量IV也是8字节。 
 两种算法都是以8字节为一个块进行加密，一个数据块一个数据块的加密，一个8字节的明文加密后的密文也是8字节。如果明文长度不为8字节的整数倍，添加值为0的字节凑满8字节整数倍。所以加密后的密文长度一定为8字节的整数倍
 
下面举个例子：
 
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

import org.apache.commons.codec.binary.Base64;

public class DESDemo {
    // 算法名称
    public static final String KEY_ALGORITHM = "DES";
    // 算法名称/加密模式/填充方式
    // DES共有四种工作模式-->>ECB：电子密码本模式、CBC：加密分组链接模式、CFB：加密反馈模式、OFB：输出反馈模式
    public static final String CIPHER_ALGORITHM = "DES/ECB/NoPadding";

    /**
     *
     * 生成密钥key对象
     *
     * @param KeyStr
     *            密钥字符串
     * @return 密钥对象
     * @throws InvalidKeyException
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     * @throws Exception
     */
    private static SecretKey keyGenerator(String keyStr) throws Exception {
        byte input[] = HexString2Bytes(keyStr);
        DESKeySpec desKey = new DESKeySpec(input);
        // 创建一个密匙工厂，然后用它把DESKeySpec转换成
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey securekey = keyFactory.generateSecret(desKey);
        return securekey;
    }

    private static int parse(char c) {
        if (c >= 'a')
            return (c - 'a' + 10) & 0x0f;
        if (c >= 'A')
            return (c - 'A' + 10) & 0x0f;
        return (c - '0') & 0x0f;
    }

    // 从十六进制字符串到字节数组转换
    public static byte[] HexString2Bytes(String hexstr) {
        byte[] b = new byte[hexstr.length() / 2];
        int j = 0;
        for (int i = 0; i < b.length; i++) {
            char c0 = hexstr.charAt(j++);
            char c1 = hexstr.charAt(j++);
            b[i] = (byte) ((parse(c0) << 4) | parse(c1));
        }
        return b;
    }

    /**
     * 加密数据
     *
     * @param data
     *            待加密数据
     * @param key
     *            密钥
     * @return 加密后的数据
     */
    public static String encrypt(String data, String key) throws Exception {
        Key deskey = keyGenerator(key);
        // 实例化Cipher对象，它用于完成实际的加密操作
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        SecureRandom random = new SecureRandom();
        // 初始化Cipher对象，设置为加密模式
        cipher.init(Cipher.ENCRYPT_MODE, deskey, random);
        byte[] results = cipher.doFinal(data.getBytes());
        // 该部分是为了与加解密在线测试网站（http://tripledes.online-domain-tools.com/）的十六进制结果进行核对
        for (int i = 0; i < results.length; i++) {
            System.out.print(results[i] + " ");
        }
        System.out.println();
        // 执行加密操作。加密后的结果通常都会用Base64编码进行传输
        return Base64.encodeBase64String(results);
    }

    /**
     * 解密数据
     *
     * @param data
     *            待解密数据
     * @param key
     *            密钥
     * @return 解密后的数据
     */
    public static String decrypt(String data, String key) throws Exception {
        Key deskey = keyGenerator(key);
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        // 初始化Cipher对象，设置为解密模式
        cipher.init(Cipher.DECRYPT_MODE, deskey);
        // 执行解密操作
        return new String(cipher.doFinal(Base64.decodeBase64(data)));
    }

    public static void main(String[] args) throws Exception {
        String source = "helloittx";
        System.out.println("原文: " + source);
        String key = "A1B2C3D4E5F60708";
        String encryptData = encrypt(source, key);
        System.out.println("加密后: " + encryptData);
        String decryptData = decrypt(encryptData, key);
        System.out.println("解密后: " + decryptData);
    }
}
 
2.非对称加密
 
非对称加密为数据的加密与解密提供了一个非常安全的方法，它使用了一对密钥，公钥（public key）和私钥（private key）。私钥只能由一方安全保管，不能外泄，而公钥则可以发给任何请求它的人。非对称加密使用这对密钥中的一个进行加密，而解密则需要另一个密钥。比如，你向银行请求公钥，银行将公钥发给你，你使用公钥对消息加密，那么只有私钥的持有人–银行才能对你的消息解密。与对称加密不同的是，银行不需要将私钥通过网络发送出去，因此安全性大大提高。
 
目前最常用的非对称加密算法是RSA算法，是Rivest, Shamir, 和Adleman于1978年发明，他们那时都是在MIT。请看下面的例子：
 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.math.BigInteger;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.spec.RSAPrivateCrtKeySpec;
import java.security.spec.RSAPublicKeySpec;

import javax.crypto.Cipher;

import com.lxh.rsatest.HexUtil;

import Decoder.BASE64Decoder;
import Decoder.BASE64Encoder;

public class RSAEncrypt {
    /** 指定加密算法为DESede */
    private static String ALGORITHM = "RSA";
    /** 指定key的大小 */
    private static int KEYSIZE = 1024;
    /** 指定公钥存放文件 */
    private static String PUBLIC_KEY_FILE = "public.keystore";
    /** 指定私钥存放文件 */
    private static String PRIVATE_KEY_FILE = "private.keystore";

    /**
     * 生成密钥对
     */
    private static void generateKeyPair() throws Exception {
        /** RSA算法要求有一个可信任的随机数源 */
        SecureRandom sr = new SecureRandom();
        /** 为RSA算法创建一个KeyPairGenerator对象 */
        KeyPairGenerator kpg = KeyPairGenerator.getInstance(ALGORITHM);
        /** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */
        kpg.initialize(KEYSIZE, sr);
        /** 生成密匙对 */
        KeyPair kp = kpg.generateKeyPair();
        /** 得到公钥 */
        Key publicKey = kp.getPublic();
        /** 得到私钥 */
        Key privateKey = kp.getPrivate();
        /** 用对象流将生成的密钥写入文件 */
        ObjectOutputStream oos1 = new ObjectOutputStream(new FileOutputStream(PUBLIC_KEY_FILE));
        ObjectOutputStream oos2 = new ObjectOutputStream(new FileOutputStream(PRIVATE_KEY_FILE));
        oos1.writeObject(publicKey);
        oos2.writeObject(privateKey);
        /** 清空缓存，关闭文件输出流 */
        oos1.close();
        oos2.close();
    }

    /**
     * 生成密钥对字符串
     */
    private static void generateKeyPairString() throws Exception {
        /** RSA算法要求有一个可信任的随机数源 */
        SecureRandom sr = new SecureRandom();
        /** 为RSA算法创建一个KeyPairGenerator对象 */
        KeyPairGenerator kpg = KeyPairGenerator.getInstance(ALGORITHM);
        /** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */
        kpg.initialize(KEYSIZE, sr);
        /** 生成密匙对 */
        KeyPair kp = kpg.generateKeyPair();
        /** 得到公钥 */
        Key publicKey = kp.getPublic();
        /** 得到私钥 */
        Key privateKey = kp.getPrivate();
        /** 用字符串将生成的密钥写入文件 */

        String algorithm = publicKey.getAlgorithm(); // 获取算法
        KeyFactory keyFact = KeyFactory.getInstance(algorithm);
        BigInteger prime = null;
        BigInteger exponent = null;

        RSAPublicKeySpec keySpec = (RSAPublicKeySpec) keyFact.getKeySpec(publicKey, RSAPublicKeySpec.class);

        prime = keySpec.getModulus();
        exponent = keySpec.getPublicExponent();
        System.out.println("公钥模量：" + HexUtil.bytes2Hex(prime.toByteArray()));
        System.out.println("公钥指数:" + HexUtil.bytes2Hex(exponent.toByteArray()));

        System.out.println(privateKey.getAlgorithm());
        RSAPrivateCrtKeySpec privateKeySpec = (RSAPrivateCrtKeySpec) keyFact.getKeySpec(privateKey,
                RSAPrivateCrtKeySpec.class);
        BigInteger privateModulus = privateKeySpec.getModulus();
        BigInteger privateExponent = privateKeySpec.getPrivateExponent();

        System.out.println("私钥模量：" + HexUtil.bytes2Hex(privateModulus.toByteArray()));
        System.out.println("私钥指数:" + HexUtil.bytes2Hex(privateExponent.toByteArray()));

    }

    /**
     * 加密方法 source： 源数据
     */
    public static String encrypt(String source) throws Exception {
        generateKeyPair();
        /** 将文件中的公钥对象读出 */
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PUBLIC_KEY_FILE));
        Key key = (Key) ois.readObject();
        ois.close();

        String algorithm = key.getAlgorithm(); // 获取算法
        KeyFactory keyFact = KeyFactory.getInstance(algorithm);
        BigInteger prime = null;
        BigInteger exponent = null;
        if ("RSA".equals(algorithm)) { // 如果是RSA加密
            RSAPublicKeySpec keySpec = (RSAPublicKeySpec) keyFact.getKeySpec(key, RSAPublicKeySpec.class);
            prime = keySpec.getModulus();
            exponent = keySpec.getPublicExponent();

//          System.out.println("公钥模量：" + HexUtil.bytes2Hex(prime.toByteArray()));
//          System.out.println("公钥指数:" + HexUtil.bytes2Hex(exponent.toByteArray()));

        }

        /** 得到Cipher对象来实现对源数据的RSA加密 */
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] b = source.getBytes();
        /** 执行加密操作 */
        byte[] b1 = cipher.doFinal(b);
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(b1);
    }

    /**
     * 解密算法 cryptograph:密文
     */
    public static String decrypt(String cryptograph) throws Exception {
        /** 将文件中的私钥对象读出 */
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PRIVATE_KEY_FILE));
        Key key = (Key) ois.readObject();

        String algorithm = key.getAlgorithm(); // 获取算法
        KeyFactory keyFact = KeyFactory.getInstance(algorithm);
        RSAPrivateCrtKeySpec privateKeySpec = (RSAPrivateCrtKeySpec) keyFact.getKeySpec(key,
                RSAPrivateCrtKeySpec.class);
        BigInteger privateModulus = privateKeySpec.getModulus();
        BigInteger privateExponent = privateKeySpec.getPrivateExponent();

//      System.out.println("私钥模量：" + HexUtil.bytes2Hex(privateModulus.toByteArray()));
//      System.out.println("私钥指数:" + HexUtil.bytes2Hex(privateExponent.toByteArray()));

        /** 得到Cipher对象对已用公钥加密的数据进行RSA解密 */
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key);
        BASE64Decoder decoder = new BASE64Decoder();

        byte[] b1 = decoder.decodeBuffer(cryptograph);
        /** 执行解密操作 */
        byte[] b = cipher.doFinal(b1);
        return new String(b);
    }

    public static void main(String[] args) throws Exception {
        generateKeyPair(); //生成文件形式公钥和私钥
        //generateKeyPairString();//生成字符串形式公钥和私钥

        String source = "非对称加密RSA";// 要加密的字符串

        String cryptograph = encrypt(source);// 生成的密文
        String hexCrypt = HexUtil.bytes2Hex(cryptograph.getBytes(), false);
        System.out.println("生成的密文--->" + hexCrypt);

        String target = decrypt(HexUtil.hex2String(hexCrypt));// 解密密文
        System.out.println("解密密文--->" + target);

    }
}
 
虽然非对称加密很安全，但是和对称加密比起来，它非常的慢，所以我们还是要用对称加密来传送消息，但对称加密所使用的密钥我们可以通过非对称加密的方式发送出去。 
 （1） 对称加密加密与解密使用的是同样的密钥，所以速度快，但由于需要将密钥在网络传输，所以安全性不高。 
 （2） 非对称加密使用了一对密钥，公钥与私钥，所以安全性高，但加密与解密速度慢。 
 （3） 解决的办法是将对称加密的密钥使用非对称加密的公钥进行加密，然后发送出去，接收方使用私钥进行解密得到对称加密的密钥，然后双方可以使用对称加密来进行沟通。
 
3.Base64编码
 
Base 64 Encoding有什么用？举个简单的例子，你使用SMTP协议 （Simple Mail Transfer Protocol 简单邮件传输协议）来发送邮件。因为这个协议是基于文本的协议，所以如果邮件中包含一幅图片，我们知道图片的存储格式是二进制数据（binary data），而非文本格式，我们必须将二进制的数据编码成文本格式，这时候Base 64 Encoding就派上用场了。
 
public void testJDKBase64(){
    String encoderStr = java.util.Base64.getEncoder().encodeToString(s.getBytes());
    System.out.println("encode :"+encoderStr);

    String decodeStr = new String(java.util.Base64.getDecoder().decode(encoderStr));
    System.out.println("decodeStr :"+decodeStr);
}

public void testCodecBase64(){
    String encoderStr = org.apache.commons.codec.binary.Base64.encodeBase64String(s.getBytes());
    System.out.println("encode :"+encoderStr);

    String decodeStr = new String(org.apache.commons.codec.binary.Base64.decodeBase64(encoderStr));
    System.out.println("decodeStr :"+decodeStr);
}
 
4.MD5加密
 
Message Digest Algorithm MD5（中文名为消息摘要算法第五版）为计算机安全领域广泛使用的一种散列函数，用以提供消息的完整性保护。该算法的文件号为RFC 1321（R.Rivest,MIT Laboratory for Computer Science and RSA Data Security Inc. April 1992）.
 
MD5的全称是Message-Digest Algorithm 5（信息-摘要算法），在90年代初由MIT Laboratory for Computer Science和RSA Data Security Inc的Ronald L. Rivest开发出来，经MD2、MD3和MD4发展而来。
 
MD5用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD5实现。将数据（如汉字）运算为另一固定长度值，是杂凑算法的基础原理，MD5的前身有MD2、MD3和MD4。
 
MD5的作用是让大容量信息在用数字签名软件签署私人密钥前被”压缩”成一种保密的格式（就是把一个任意长度的字节串变换成一定长的十六进制数字串）。
 
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * Java消息摘要算法 MD5 工具类,其实其他摘要算法的实现也类似
 */
public class MD5Util {
    /**
     * 对文本执行 md5 摘要加密, 此算法与 mysql,JavaScript生成的md5摘要进行过一致性对比.
     * @param plainText
     * @return 返回值中的字母为小写
     */
    public static String md5(String plainText) {
        if (null == plainText) {
            plainText = "";
        }
        String MD5Str = "";
        try {
            // JDK 6 支持以下6种消息摘要算法，不区分大小写
            // md5,sha(sha-1),md2,sha-256,sha-384,sha-512
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(plainText.getBytes());
            byte b[] = md.digest();

            int i;

            StringBuilder builder = new StringBuilder(32);
            for (int offset = 0; offset < b.length; offset++) {
                i = b[offset];
                if (i < 0)
                    i += 256;
                if (i < 16)
                    builder.append("0");
                builder.append(Integer.toHexString(i));
            }
            MD5Str = builder.toString();
            // LogUtil.println("result: " + buf.toString());// 32位的加密
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return MD5Str;
    }
    // 一个简版测试
    public static void main(String[] args) {
        String m1 = md5("1");
        String m2 = md5(m1);
        /* 输出为
         * m1=c4ca4238a0b923820dcc509a6f75849b
         * m2=28c8edde3d61a0411511d3b1866f0636
         */
        System.out.println("m1="+m1);
        System.out.println("m2="+m2);
    }
}
 
通常我们不直接使用上述MD5加密。通常将MD5产生的字节数组交给Base64再加密一把，得到相应的字符串。 
 
5.数字签名算法
 
签名：就有安全性，抗否认性 
 数字签名：带有密钥（公钥，私钥）的消息摘要算法 
 作用： 
 1. 验证数据的完整性 
 2. 认证数据来源 
 3. 抗否认
 
数字签名遵循：私钥签名，公钥验证 
 常用的数字签名算法：RSA，DSA，ECDSA
 
RSA介绍：
 
是经典算法，是目前为止使用最广泛的数字签名算法。
 
RSA数字签名算法的密钥实现与RSA的加密算法是一样的，算法的名称都叫RSA。密钥的产生和转换都是一样的。
 
RSA数字签名算法主要包括MD和SHA两类。
 
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import org.apache.commons.codec.binary.Hex;

public class RSATest {
    public static final String src = "hello world";

    public static void main(String[] args) {
        jdkRSA();

    }

    /**
     * 说明： 用java的jdk里面相关方法实现rsa的签名及签名验证
     */
    public static void jdkRSA() {
        try {
            // 1.初始化密钥
            KeyPairGenerator keyPairGenerator = KeyPairGenerator
                    .getInstance("RSA");
            //设置KEY的长度
            keyPairGenerator.initialize(512);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            //得到公钥
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            //得到私钥
            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

            // 2.进行签名
            //用私钥进行签名
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(
                    rsaPrivateKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            //构造一个privateKey
            PrivateKey privateKey = keyFactory
                    .generatePrivate(pkcs8EncodedKeySpec);
            //声明签名的对象
            Signature signature = Signature.getInstance("MD5withRSA");
            signature.initSign(privateKey);
            signature.update(src.getBytes());
            //进行签名
            byte[] result = signature.sign();
            System.out.println("jdk rsa sign:" + Hex.encodeHexString(result));

            // 3.验证签名
            //用公钥进行验证签名
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(
                    rsaPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("RSA");
            //构造一个publicKey
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            //声明签名对象
            signature = Signature.getInstance("MD5withRSA");
            signature.initVerify(publicKey);
            signature.update(src.getBytes());
            //验证签名
            boolean bool = signature.verify(result);
            System.out.println("jdk rsa verify:" + bool);
        } catch (Exception e) {
            System.out.println(e.toString());
        }

    }

}
 
四、应用场景
 
Base64应用场景：图片转码(应用于邮件，img标签，http加密)
MD5应用场景：密码加密、imei加密、文件校验
非对称加密：电商订单付款、银行相关业务

java中常用的加密工具
 
1. md5加密工具类
 

public class MD5Utils {

    private static final String hexDigIts[] = {"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"};

    /**
     * MD5加密
     * @param origin 字符
     * @param charsetname 编码
     * @return
     */
    public static String MD5Encode(String origin, String charsetname){
        String resultString = null;
        try{
            resultString = new String(origin);
            MessageDigest md = MessageDigest.getInstance("MD5");
            if(null == charsetname || "".equals(charsetname)){
                resultString = byteArrayToHexString(md.digest(resultString.getBytes()));
            }else{
                resultString = byteArrayToHexString(md.digest(resultString.getBytes(charsetname)));
            }
        }catch (Exception e){
        }
        return resultString;
    }


    public static String byteArrayToHexString(byte b[]){
        StringBuffer resultSb = new StringBuffer();
        for(int i = 0; i < b.length; i++){
            resultSb.append(byteToHexString(b[i]));
        }
        return resultSb.toString();
    }

    public static String byteToHexString(byte b){
        int n = b;
        if(n < 0){
            n += 256;
        }
        int d1 = n / 16;
        int d2 = n % 16;
        return hexDigIts[d1] + hexDigIts[d2];
    }

}
 
2. base64加密工具类
 
public class Base64Util {

    // 字符串编码
    private static final String UTF_8 = "UTF-8";

    /**
     * 加密字符串
     * @param inputData
     * @return
     */
    public static String decodeData(String inputData) {
        try {
            if (null == inputData) {
                return null;
            }
            return new String(Base64.decodeBase64(inputData.getBytes(UTF_8)), UTF_8);
        } catch (UnsupportedEncodingException e) {
        }
        return null;
    }

    /**
     * 解密加密后的字符串
     * @param inputData
     * @return
     */
    public static String encodeData(String inputData) {
        try {
            if (null == inputData) {
                return null;
            }
            return new String(Base64.encodeBase64(inputData.getBytes(UTF_8)), UTF_8);
        } catch (UnsupportedEncodingException e) {
        }
        return null;
    }

    public static void main(String[] args) {
        System.out.println(Base64Util.encodeData("我是中文"));
        String enStr = Base64Util.encodeData("我是中文");
        System.out.println(Base64Util.decodeData(enStr));
    }
}
 
3. Bcrypt工具类
 
public class BcryptCipher {
  // generate salt seed
  private static final int SALT_SEED = 12;
  // the head fo salt
  private static final String SALT_STARTSWITH = "$2a$12";
  
  public static final String SALT_KEY = "salt";
  
  public static final String CIPHER_KEY = "cipher";
  
  /**
   * Bcrypt encryption algorithm method
   * @param encryptSource
   * need to encrypt the string
   * @return Map , two values in Map , salt and cipher
   */
  public static Map<String, String> Bcrypt(final String encryptSource) {
    String salt = BCrypt.gensalt(SALT_SEED);
    Map<String, String> bcryptResult = Bcrypt(salt, encryptSource);
    return bcryptResult;
  }
  /**
   *
   * @param salt encrypt salt, Must conform to the rules
   * @param encryptSource
   * @return
   */
  public static Map<String, String> Bcrypt(final String salt, final String encryptSource) {
    if (StringUtils.isBlank(encryptSource)) {
      throw new RuntimeException("Bcrypt encrypt input params can not be empty");
    }
    
    if (StringUtils.isBlank(salt) || salt.length() != 29) {
      throw new RuntimeException("Salt can't be empty and length must be to 29");
    }
    if (!salt.startsWith(SALT_STARTSWITH)) {
      throw new RuntimeException("Invalid salt version, salt version is $2a$12");
    }
    
    String cipher = BCrypt.hashpw(encryptSource, salt);
    Map<String, String> bcryptResult = new HashMap<String, String>();
    bcryptResult.put(SALT_KEY, salt);
    bcryptResult.put(CIPHER_KEY, cipher);
    return bcryptResult;
  }
  
}

在爬虫的时候经常会遇到URL中包含中文字符，可以直接指示到.jpg .gif .mp3/4…等文件的地址。但是因为是中文，URL中无法直接显示。网站一般会采用编码或者加密的方式对中文字符进行处理。但是对于编码或者加密的方式不同网站有不同的方法。
 通常采用的方式有一下几种：
 
一、Unicode编码
 
Unicode编码通常由两个字节组成，称作USC-2，个别偏僻字由四个字节组成，称作USC-4。前127个还表示原来ASCII码里的字符，只不过由一个字节变成了两个字节。
 
unicode编码基本格式为U开头，以斜杠分开。如图所示：
 
 优点：可以囊括多国语言，囊括了常用汉字
 
不足：表示一个英文字符由一个字节变成了两个，浪费存储空间和传输速度。生僻字表示不足
 
二、UTF-8编码
 
Unicode编码的一种，Unicode用一些基本的保留字符制定了三套编码方式，它们分别为UTF-8，UTF-16，UTF-32.在UTF-8中，字符是以8位序列来编码的，用一个或几个字节来表示一个字符。这种方式的最大好处是UTF-8保留了ASCII字符的编码作为它的一部分。UTF-8俗称“万国码”，可以同屏显示多语种，一个汉字通常占用3字节（生僻字占6个）。为了做到国际化，网页尽可能采用UTF-8编码
 
以&#x开头，分号分隔。如图所示：
 
 
 
三、GB2312
 
GB2312简体中文编码，一个汉字占用2个字节，在大陆是主要的编码方式。当文章/网页中包含繁体中文、日文、韩文等时，这些内容可能无法被正确编码。
 
作用：国家简体中文字符集，兼容ASCII
 
位数：使用2个字节表示，能表示7445个符号，包括6763个汉字，几乎覆盖所有高频率汉字。
 
范围：高字节从A1-A7，低字节从A1到FE。将高字节和低字节分别加上0xA0即可得到编码。
 编码格式如下图，基本是四个字符代表一个汉字字符。
 
 
四、BIG5编码
 
称为繁体中文编码，主要在台湾地区使用。
 
五、GBK编码
 
作用：它是GB2312的扩展，转换后的格式和GBK2312一样，加入对繁体字的支持，兼容GB2312.
 
位数：使用2个字节表示，可表示21886个字符。
 
范围：高字节从81到FE，低字节从40到FE.
 
六、GB18030编码
 
作用：它解决了中文、日文、朝鲜语等的编码，兼容GBK。
 
位数：它采用变字节表示（1ASCII, 2,4字节）。可表示27484个文字。
 
范围：1字节从00到7F；2字节高字节从81到FE，低字节从40到7E和80到FE；4字节第一三字节从81到FE，第二四字节从30到39.
 
加密方式：
 
对于有些url中的代表中文的部分并不是如上的格式编码的情况，可能是进行过加密。验证是否是标准加密方式加密的土方法，就是将汉字部分，直接进行搜索。如果能跳出多个不同的网站，可证明是某种标准的加密方式。
 如图所示，我搜索的这段字符串实际代表的就是“云”这个汉字。在直接将加密后的字符串进行搜索后，跳出很多不同的网页。表明不止那个网站用这种加密，即这是一个标准统一的加密方式。
 
 详细数一下位数，整个编码是32个数字。查询一下32位加密的方式，可能是MD5。通过代码逆向加密进行验证。
 
 验证正确。
 
python3中，MD5加密归纳到了Hashlib库中了。
 代码：
 
import hashlib
data = "云"
hashlib.md5(data.encode(encoding = 'utf-8')).hexdigest()
 
其他加密方式还有base64，RSA加密等。这些在爬虫工作中暂时还没有遇到。不展开记述。