Java加解密——Base64与DES

一、BASE64

这里选用Java自带的BASE64Encoder和BASE64Decoder进行BASE64编码，除此之外，可以选择commons-codec.jar等第三方jar包进行实现。

BASE64Encoder和BASE64Decoder为实现BASE64的API，为了解决高并发问题，提高运行效率，本例将encoder和decoder作为全局静态属性，并通过ThreadLocal进行管理。

package com.fhp.testencrypt;

import sun.misc.BASE64Encoder;
import java.io.IOException;
import sun.misc.BASE64Decoder;

public class Base64Utils {
	
	private static ThreadLocal<BASE64Encoder> encoder = new ThreadLocal<BASE64Encoder>() {
		@Override
		protected BASE64Encoder initialValue() {
			return new BASE64Encoder();
		}
	};
	
	private static ThreadLocal<BASE64Decoder> decoder = new ThreadLocal<BASE64Decoder>() {
		@Override
		protected BASE64Decoder initialValue() {
			return new BASE64Decoder();
		}
	};
	
	public static String encode(byte[] bytes) {
		return encoder.get().encode(bytes);
	}
	
	public static byte[] decode(String str) {
		try {
			return decoder.get().decodeBuffer(str);
		} catch (IOException e) {
			throw new RuntimeException("Cannot decode string:" + str, e);
		}
	}
}

二、DES

package com.fhp.testencrypt;

import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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 DESUtils {
	
	// 算法名称  
    private static final String KEY_ALGORITHM = "DES";  
    // 算法名称/加密模式/填充方式  
    private static final String CIPHER_ALGORITHM_ECB = "DES/ECB/PKCS5Padding";
    
    private static final Key defaultKey = generateKey();
    
    /**
     * 生成密钥
     */
    public static Key generateKey() {
    	KeyGenerator keyGenerator;
		try {
			keyGenerator = KeyGenerator.getInstance(KEY_ALGORITHM);
		} catch (NoSuchAlgorithmException e) {
			throw new RuntimeException("Unable to generate DES key.", e);
		}
    	keyGenerator.init(56);//这里必须填56
    	SecretKey secretKey = keyGenerator.generateKey();
    	return secretKey;
    }
    
    /**
     * 使用默认密钥对字节数组进行加密，返回加密后的字节数组
     */
    public static byte[] encrypt(byte[] source) {
    	return encrypt(source, null);
    }
    
    /**
     * 使用默认密钥对字节数组进行解密，返回解密后的字节数组
     */
    public static byte[] decrypt(byte[] source) {
    	return decrypt(source, null);
    }
    
    /**
     * 使用指定密钥对字节数组进行加密，返回加密后的字节数组
     */
	public static byte[] encrypt(byte[] source, Key key) {
		try {
			Key currentKey = key == null ? defaultKey : key;
			Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM_ECB);
			cipher.init(Cipher.ENCRYPT_MODE, currentKey, new SecureRandom());  
	        return cipher.doFinal(source);  
		} catch (NoSuchAlgorithmException e) {
			throw new RuntimeException("Unable to encrypt.", e);
		} catch (NoSuchPaddingException e) {
			throw new RuntimeException("Unable to encrypt.", e);
		} catch (InvalidKeyException e) {
			throw new RuntimeException("Unable to encrypt.", e);
		} catch (IllegalBlockSizeException e) {
			throw new RuntimeException("Unable to encrypt.", e);
		} catch (BadPaddingException e) {
			throw new RuntimeException("Unable to encrypt.", e);
		}  
	}
	
	 /**
     * 使用指定密钥对字节数组进行解密，返回解密后的字节数组
     */
	public static byte[] decrypt(byte[] source, Key key) {
		try {
			Key currentKey = key == null ? defaultKey : key;
			Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM_ECB);
			cipher.init(Cipher.DECRYPT_MODE, currentKey, new SecureRandom());  
	        return cipher.doFinal(source);  
		} catch (NoSuchAlgorithmException e) {
			throw new RuntimeException("Unable to decrypt.", e);
		} catch (NoSuchPaddingException e) {
			throw new RuntimeException("Unable to decrypt.", e);
		} catch (InvalidKeyException e) {
			throw new RuntimeException("Unable to decrypt.", e);
		} catch (IllegalBlockSizeException e) {
			throw new RuntimeException("Unable to decrypt.", e);
		} catch (BadPaddingException e) {
			throw new RuntimeException("Unable to decrypt.", e);
		}  
	}
	
	public static void main(String[] args) {
		String str = "测试字符串";
		byte[] encrypted = DESUtils.encrypt(str.getBytes());
				
		byte[] decrypted = DESUtils.decrypt(encrypted);
		System.out.println("cipher text:" + new String(encrypted));
		System.out.println("normal text:" + new String(decrypted));
	}
}