数据加密的一些理解

（一）加密算法分为：

（1）对称加密算法：

DES算法，3DES算法，TDEA算法，Blowfish算法，RC5算法，IDEA算法，AES算法。

（2）非对称加密算法 :

RSA、Elgamal、背包算法、Rabin、D-H、ECC。

（3）哈希算法 :

MD2、MD4、MD5 和 SHA-1

(二) 区别及特点：

对称加密算法：

秘钥只有一个，通过该秘钥可以对加密过后的数据进行解密。加密解密速度相对快，安全性低一点。解密加密都用同一个秘钥所以叫对称加密算法。

非对称加密算法 ：

一般分为两个秘钥 一个加密秘钥一个解密秘钥， 称为公钥和秘钥。

公钥进行加密，可以公开。秘钥进行解密不公开。加密解密速度较慢一点。安全性高。两个秘钥不一样所以叫非对称加密算法 。

哈希算法 ：

目的是将任意长输入通过算法变为固定长输出，且保证输入变化一点输出都不同，且不能反向解密。

(三) 举例

对称加密算法 （AES）：

/**
* Created by linving on 2016/11/10.
*/

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.math.BigInteger;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

/**
* 编码工具类
* 1.将byte[]转为各种进制的字符串
* 2.base 64 encode
* 3.base 64 decode
* 4.获取byte[]的md5值
* 5.获取字符串md5值
* 6.结合base64实现md5加密
* 7.AES加密
* 8.AES加密为base 64 code
* 9.AES解密
* 10.将base 64 code AES解密
*
* @author uikoo9
* @version 0.0.7.20140601
*/
public class AESUtil {

/**
* 将byte[]转为各种进制的字符串
*
* @param bytes byte[]
* @param radix 可以转换进制的范围，从Character.MIN_RADIX到Character.MAX_RADIX，超出范围后变为10进制
* @return 转换后的字符串
*/
public static String binary(byte[] bytes, int radix) {
return new BigInteger(1, bytes).toString(radix);// 这里的1代表正数
}

/**
* base 64 encode
*
* @param bytes 待编码的byte[]
* @return 编码后的base 64 code
*/
public static String base64Encode(byte[] bytes) {
return new BASE64Encoder().encode(bytes);
}

/**
* base 64 decode
*
* @param base64Code 待解码的base 64 code
* @return 解码后的byte[]
* @throws Exception
*/
public static byte[] base64Decode(String base64Code) throws Exception {
return new BASE64Decoder().decodeBuffer(base64Code);
}

/**
* 获取byte[]的md5值
*
* @param bytes byte[]
* @return md5
* @throws Exception
*/
public static byte[] md5(byte[] bytes) throws Exception {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(bytes);

return md.digest();
}

/**
* 获取字符串md5值
*
* @param msg
* @return md5
* @throws Exception
*/
public static byte[] md5(String msg) throws Exception {
return md5(msg.getBytes());
}

/**
* 结合base64实现md5加密
*
* @param msg 待加密字符串
* @return 获取md5后转为base64
* @throws Exception
*/
public static String md5Encrypt(String msg) throws Exception {
return base64Encode(md5(msg));
}

/**
* AES加密
*
* @param content    待加密的内容
* @param encryptKey 加密密钥
* @return 加密后的byte[]
* @throws Exception
*/
public static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128, new SecureRandom(encryptKey.getBytes()));

Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));

return cipher.doFinal(content.getBytes("utf-8"));
}

/**
* AES加密为base 64 code
*
* @param content    待加密的内容
* @param encryptKey 加密密钥
* @return 加密后的base 64 code
* @throws Exception
*/
public static String aesEncrypt(String content, String encryptKey) {
try {
return base64Encode(aesEncryptToBytes(content, encryptKey));
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

/**
* AES解密
*
* @param encryptBytes 待解密的byte[]
* @param decryptKey   解密密钥
* @return 解密后的String
* @throws Exception
*/
public static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) {

try {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128, new SecureRandom(decryptKey.getBytes()));
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
byte[] decryptBytes = cipher.doFinal(encryptBytes);
return new String(decryptBytes);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
}
return null;
}

/**
* 将base 64 code AES解密
*
* @param encryptStr 待解密的base 64 code
* @param decryptKey 解密密钥
* @return 解密后的string
* @throws Exception
*/
public static String aesDecrypt(String encryptStr, String decryptKey)  {
try {
return aesDecryptByBytes(base64Decode(encryptStr), decryptKey);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

}

非对称加密算法（RSA）

/**
* Created by linving on 2016/11/10.
*/

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
* RSA算法，实现数据的加密解密。
* @author ShaoJiang
*
*/
public class RSAUtil {

private static Cipher cipher;

static{
try {
cipher = Cipher.getInstance("RSA");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
}
}

/**
* 生成密钥对
* @return
*/
public static Map<String,String> generateKeyPair(){
try {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
// 密钥位数
keyPairGen.initialize(1024);
// 密钥对
KeyPair keyPair = keyPairGen.generateKeyPair();
// 公钥
PublicKey publicKey = keyPair.getPublic();
// 私钥
PrivateKey privateKey = keyPair.getPrivate();
//得到公钥字符串
String publicKeyString = getKeyString(publicKey);
//得到私钥字符串
String privateKeyString = getKeyString(privateKey);
//将生成的密钥对返回
Map<String,String> map = new HashMap<>();
map.put("publicKey",publicKeyString);
map.put("privateKey",privateKeyString);
return map;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

/**
* 得到公钥
*
* @param key
*            密钥字符串（经过base64编码）
* @throws Exception
*/
public static PublicKey getPublicKey(String key) throws Exception {
byte[] keyBytes;
keyBytes = (new BASE64Decoder()).decodeBuffer(key);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(keySpec);
return publicKey;
}

/**
* 得到私钥
*
* @param key
*            密钥字符串（经过base64编码）
* @throws Exception
*/
public static PrivateKey getPrivateKey(String key) throws Exception {
byte[] keyBytes;
keyBytes = (new BASE64Decoder()).decodeBuffer(key);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
return privateKey;
}

/**
* 得到密钥字符串（经过base64编码）
*
* @return
*/
public static String getKeyString(Key key) throws Exception {
byte[] keyBytes = key.getEncoded();
String s = (new BASE64Encoder()).encode(keyBytes);
return s;
}

/**
* 使用公钥对明文进行加密，返回BASE64编码的字符串
* @param publicKey
* @param plainText
* @return
*/
public static String encrypt(PublicKey publicKey,String plainText){
try {
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] enBytes = cipher.doFinal(plainText.getBytes());
return (new BASE64Encoder()).encode(enBytes);
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}

/**
* 使用keystore对明文进行加密
* @param
* @param plainText      明文
* @return
*/
public static String encrypt(String publicKey,String plainText){
try {
cipher.init(Cipher.ENCRYPT_MODE,getPublicKey(publicKey));
byte[] enBytes = cipher.doFinal(plainText.getBytes());
return (new BASE64Encoder()).encode(enBytes);
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

/**
* 使用私钥对明文密文进行 解密
* @param privateKey
* @param enStr
* @return
*/
public static String decrypt(PrivateKey privateKey,String enStr){
try {
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));
return new String(deBytes);
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}

/**
* 使用keystore对密文进行解密
* @param enStr   密文
* @return
*/
public static String decrypt(String privateKey,String enStr){
try {
cipher.init(Cipher.DECRYPT_MODE, getPrivateKey(privateKey));
byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));
return new String(deBytes);
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}

散列算法 /哈希算法(MD5 )

import java.io.IOException;
import java.io.StringReader;

public class HexDump {
class HexTablifier {
private int m_row = 8;

private String m_pre = "";

private String m_post = "\n";

public HexTablifier() {
}

public HexTablifier(int row) {
this(row, "", "\n");
}

public HexTablifier(int row, String pre) {
this(row, pre, "\n");
}

public HexTablifier(int row, String pre, String post) {
m_row = row;
m_pre = pre;
m_post = post;
}

public String format(String hex) {
StringReader reader = new StringReader(hex);
StringBuilder builder = new StringBuilder(hex.length() * 2);

try {
while (getHexLine(builder, reader)) {
}
} catch (IOException e) {
// 不应该有异常出现。
}

return builder.toString();
}

private boolean getHexLine(StringBuilder builder, StringReader reader)
throws IOException {
StringBuilder lineBuilder = new StringBuilder();
boolean result = true;

for (int i = 0; i < m_row; i++) {
result = getHexByte(lineBuilder, reader);

if (result == false)
break;
}

if (lineBuilder.length() > 0) {
builder.append(m_pre);
builder.append(lineBuilder);
builder.append(m_post);
}

return result;
}

private boolean getHexByte(StringBuilder builder, StringReader reader)
throws IOException {
char[] hexByte = new char[4];
int bytesRead = reader.read(hexByte);

if (bytesRead == -1)
return false;

builder.append(hexByte, 0, bytesRead);
builder.append(" ");

return bytesRead == 4;
}
}

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

private static final int m_shifts[] = { 60, 56, 52, 48, 44, 40, 36, 32, 28,
24, 20, 16, 12, 8, 4, 0 };

public static String tablify(byte[] bytes) {
return (new HexDump()).new HexTablifier().format(HexDump.toHex(bytes));
}

public static String tablify(byte[] bytes, int row) {
return (new HexDump()).new HexTablifier(row).format(HexDump
.toHex(bytes));
}

public static String tablify(byte[] bytes, int row, String pre) {
return (new HexDump()).new HexTablifier(row, pre).format(HexDump
.toHex(bytes));
}

public static String tablify(String hex, int row, String pre, String post) {
return (new HexDump()).new HexTablifier(row, pre, post).format(hex);
}

private static String toHex(final long value, final int digitNum) {
StringBuilder result = new StringBuilder(digitNum);

for (int j = 0; j < digitNum; j++) {
int index = (int) ((value >> m_shifts[j + (16 - digitNum)]) & 15);
result.append(m_hexCodes[index]);
}

return result.toString();
}

public static String toHex(final byte value) {
return toHex(value, 2);
}

public static String toHex(final short value) {
return toHex(value, 4);
}

public static String toHex(final int value) {
return toHex(value, 8);
}

public static String toHex(final long value) {
return toHex(value, 16);
}

public static String toHex(final byte[] value) {
return toHex(value, 0, value.length);
}

public static String toHex(final byte[] value, final int offset,
final int length) {
StringBuilder retVal = new StringBuilder();

int end = offset + length;
for (int x = offset; x < end; x++)
retVal.append(toHex(value[x]));

return retVal.toString();
}

public static byte[] restoreBytes(String hex) {
byte[] bytes = new byte[hex.length() / 2];
for (int i = 0; i < bytes.length; ++i) {
int c1 = charToNumber(hex.charAt(2 * i));
int c2 = charToNumber(hex.charAt(2 * i + 1));
if (c1 == -1 || c2 == -1) {
return null;
}
bytes[i] = (byte) ((c1 << 4) + c2);
}

return bytes;
}

private static int charToNumber(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
} else if (c >= 'a' && c <= 'f') {
return c - 'a' + 0xa;
} else if (c >= 'A' && c <= 'F') {
return c - 'A' + 0xA;
} else {
return -1;
}
}
}

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;

/**
* Created by linving on 2016/11/12.
*/
public class MD5Util {

public static String getStringMD5(String value) {
if (value == null || value.trim().length() < 1) {
return null;
}
try {
return getMD5(value.getBytes("UTF-8"));
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e.getMessage(), e);
}
}

public static String getMD5(byte[] source) {
try {
MessageDigest md5 = MessageDigest.getInstance("MD5");
return HexDump.toHex(md5.digest(source));
} catch (Exception e) {
throw new RuntimeException(e.getMessage(), e);
}
}

}

Test :

import java.util.Map;

/**
* Created by linving on 2016/11/10.
*/
public class Test {
public static void main(String[] args) {
testRSA();
testAES();
tetsMD5();
}

private static void testAES() {

String data = "adcb";
System.out.println("AES加密前：" + data);

String key = "123456";
System.out.println("AES加密密钥和解密密钥：" + key);

String encrypt = AESUtil.aesEncrypt(data, key);
System.out.println("AES加密后：" + encrypt);

String decrypt = AESUtil.aesDecrypt(encrypt, key);
System.out.println("AES解密后：" + decrypt);

}

private static void testRSA() {

String data = "adsbc";
String publicKey = "";
String privateKey = "";
System.out.println("RSA原始数据: " + data);

Map<String, String> keyPair = RSAUtil.generateKeyPair();
publicKey = keyPair.get("publicKey");
privateKey = keyPair.get("privateKey");
System.out.println("RSA公钥: " + publicKey);
System.out.println("RSA私钥: " + privateKey);

String encryptData = RSAUtil.encrypt(publicKey, data);
System.out.println("RSA加密数据: " + encryptData);
String decryptData = RSAUtil.decrypt(privateKey, encryptData);
System.out.println("RSA解密数据: " + decryptData);
}

private static void tetsMD5() {
String data = "adsbc";
System.out.println("MD5原始数据: " + data);
String encryptData = MD5Util.getStringMD5(data);
System.out.println("MD5 加密数据: " + encryptData);

}

}

结果：

RSA原始数据: adsbc

RSA公钥: MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCwUnEo/9+NI8GJbQtwl6X7MuALqe7YzuDNEeGn

3zEuiktxbXj53duJoYtGqO+rY+Vae7Ypt7UwolgnFtfJbfSmoBJc7wuBPOdTFkpsb7nYZXTvNoFI

fYdjT2mQgcOnZGSoz7alApPQ1sxXkkZ2tx+H+hsSaHxTBHW1Pq6Eyqi8LQIDAQAB

RSA私钥: MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBALBScSj/340jwYltC3CXpfsy4Aup

7tjO4M0R4affMS6KS3FtePnd24mhi0ao76tj5Vp7tim3tTCiWCcW18lt9KagElzvC4E851MWSmxv

udhldO82gUh9h2NPaZCBw6dkZKjPtqUCk9DWzFeSRna3H4f6GxJofFMEdbU+roTKqLwtAgMBAAEC

gYEAjAquvfWcRKllihUFxQNtXTpnIFxzy9dkTPwq0f4/PcuxaAGe2DYRrBqWWCTNVr8c5uTjJfc2

/c2zXjiSYvXmHS8EGFglwsJ8Dos+FiPtWTJl0Xo3Qhnbs2+F2z9Idgg0ddzrLK5r2o6l8VWuv/43

vdrjnvc4ArF/Kas/RHKyzzECQQDlVI2aiAqkOjs44sxr2rrRZRcRp5qxz8k/M31yRJnHWEVL6DXx

9IxGtkZNYdaD6fHgfbxd/5Xano7iyxvoJGmjAkEAxNPEh1ZW8SFQaE9mt/AMU6OMDM6F399uunOs

7yzz6vCUxLOIko6oyFj0WiilQEr9Y1wr1EZGkcMHYeJFK1k/7wJANJqtlKnqDvvQg976Vy8oNUoD

/ae9g1YParDr8J8tyx1DYAMXBLY8yyeafruXklDCi+UrpUAwZqKCUiGW+CwKEwJBAMHiTMx3+0qp

41ftJyT3fF0DVJjk8zD1GlDmU6qCoH+EnzcoFtcvWgmIvqL1ONsdQ38Vs0L2OtuovuPoDPTHhNcC

QBkOkrgFhJYnmDDTMUj4TCEO64RIdOyzzpFeQ0TgpjMJ99QOv8Q2kEFpylCw9bYMk1uioCStYSR8

ZOhE+H2N+yg=

RSA加密数据: Olsmy/qEigtaXIhlY8g41ktk1pXo/Kr098hA0keGM718yc6vnS2Mzc0YFXCQUMnpYS3ZEa7mm0Lg

CBIQNaPC8LPRmVS+giXui5Us9vbtYmejSRC0aDqnFqlONaoQidxHGSow65vpvgPTTfm3Hec/xOnC

6iEaslW4bsaEQcTHm6k=

RSA解密数据: adsbc

AES加密前：adcb

AES加密密钥和解密密钥：123456

AES加密后：F0QsZk5pFhDME01ZT7sQ0Q==

AES解密后：adcb

MD5原始数据: adsbc

MD5 加密数据: 51d84a98aeb971d801a9e1bed8803bd1

Process finished with exit code 0

这就是常用的加密算法了， 通常如果数据比较隐私的话，会采用多重加密算法。比如先经过 RSA 再经过 AＥＳ　算法进行加密。

用ＲＳＡ算法将ＡＥＳ的秘钥和数据绑定在一起，解密后拿到ＡＥＳ的秘钥再解密。

更多精彩内容：

http://jblog.top/