Java加密解密

package com.joye3g.ed;

public class Main {
	public static void main(String[] args) throws Exception {
//		initThreeDES();
//		initAES();
//		initRSA();
//		initMD5();
//		initSHA();
		initHMAC();
	}

	public static void initThreeDES(){
		ThreeDES des = new ThreeDES();        
		String msg = "安全编程技术_加密解密";      
		System.out.println("明文是" + msg);   
		byte[] enc = des.createEncryptor(msg);   
		System.out.println("密文是" + new String(enc));     
		byte[] dec = des.createDecryptor(enc);      
		System.out.println("解密后的结果是" + new String(dec)); 

	}
	
	public static void initAES(){
		AES aes = new AES();        
		String msg = "安全编程技术_加密解密";      
		System.out.println("明文是" + msg);   
		byte[] enc = aes.createEncryptor(msg);   
		System.out.println("密文是" + new String(enc));     
		byte[] dec = aes.createDecryptor(enc);      
		System.out.println("解密后的结果是" + new String(dec)); 
	}

	public static void initRSA(){
		RSA rsa = new RSA();
		String msg = "安全编程技术_加密解密";    
		System.out.println("明文是:" + msg);   
		//用公钥加密    
		byte[] srcBytes = msg.getBytes();    
		byte[] resultBytes = rsa.encrypt(srcBytes);    
		String result = new String(resultBytes);   
		System.out.println("用公钥加密后密文是:" + result);       
		//用私钥解密   
		byte[] decBytes = rsa.decrypt(resultBytes);    
		String dec = new String(decBytes);    
		System.out.println("用私钥解密后结果是:" + dec); 
	}

	public static void initMD5(){
		String msg = "安全编程技术_加密解密";    
		System.out.println("明文是" + msg);
		MD5 md5 = new MD5();   
		byte[] resultBytes = md5.encrypt(msg);   
		String result = new String(resultBytes);   
		System.out.println("密文是" + result);
	}

	public static void initSHA(){
		String msg = "安全编程技术_加密解密";    
		System.out.println("明文是" + msg);
		SHA sha = new SHA();   
		byte[] resultBytes = sha.encrypt(msg);   
		String result = new String(resultBytes);   
		System.out.println("密文是" + result);
	}

	public static void initHMAC(){
		//要计算消息验证码的字符串   
		String str="安全编程技术_加密解密";  
		System.out.println("明文是:" + str);  
		HMAC hmac = new HMAC();
		byte[] certifyCode = hmac.createEncryptor(str);
		System.out.println("密文是:" + new String(certifyCode));
	}
}

AES：

package com.joye3g.ed;

import java.security.NoSuchAlgorithmException;
import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;

public class AES {
	// KeyGenerator提供对称密钥生成器的功能，支持各种算法
	private KeyGenerator keyGenerator;
	// SecretKey负责保存对称密钥
	private SecretKey secretKey;
	// Cipher负责完成加密或解密工作
	private Cipher cipher;
	// 该字节数组负责保存加密的结果
	private byte[] cipherByte;

	@SuppressWarnings("restriction")
	public AES() {
		Security.addProvider(new com.sun.crypto.provider.SunJCE());
		// 实例化支持AES算法的密钥生成器，算法名称用AES
		try {
			keyGenerator = KeyGenerator.getInstance("AES");
			// 生成密钥
			secretKey = keyGenerator.generateKey();
			// 生成Cipher对象，指定其支持AES算法
			cipher = Cipher.getInstance("AES");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		}
	}

	/* 对字符串str加密 */
	public byte[] createEncryptor(String str) {
		try {
			// 根据密钥对Cipher对象进行初始化,ENCRYPT_MODE表示加密模式
			cipher.init(Cipher.ENCRYPT_MODE, secretKey);
			byte[] src = str.getBytes();
			// 将加密结果保存进cipherByte
			cipherByte = cipher.doFinal(src);
		} catch (java.security.InvalidKeyException ex) {
			ex.printStackTrace();
		} catch (javax.crypto.BadPaddingException ex) {
			ex.printStackTrace();
		} catch (javax.crypto.IllegalBlockSizeException ex) {
			ex.printStackTrace();
		}
		return cipherByte;
	}

	/* 对字节数组buff解密 */
	public byte[] createDecryptor(byte[] buff) {
		try {
			// 根据密钥对Cipher对象进行初始化,ENCRYPT_MODE表示解密模式
			cipher.init(Cipher.DECRYPT_MODE, secretKey);
			// 将得到明文存入cipherByte字符数组
			cipherByte = cipher.doFinal(buff);
		} catch (java.security.InvalidKeyException ex) {
			ex.printStackTrace();
		} catch (javax.crypto.BadPaddingException ex) {
			ex.printStackTrace();
		} catch (javax.crypto.IllegalBlockSizeException ex) {
			ex.printStackTrace();
		}
		return cipherByte;
	}
}

DES：

package com.joye3g.ed;

import java.security.NoSuchAlgorithmException;
import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;

public class DES {
	// KeyGenerator提供对称密钥生成器的功能,支持各种算法
	private KeyGenerator keyGenerator;
	// SecretKey负责保存对称密钥
	private SecretKey secretKey;
	// Cipher负责完成加密或解密工作
	private Cipher cipher;
	// 该字节数组负责保存加密的结果
	private byte[] cipherByte;

	@SuppressWarnings("restriction")
	public DES() {
		Security.addProvider(new com.sun.crypto.provider.SunJCE());
		try {
			// 实例化支持DES算法的密钥生成器(算法名称命名需按规定,否则抛出异常)
			keyGenerator = KeyGenerator.getInstance("DES");
			// 生成密钥
			secretKey = keyGenerator.generateKey();
			// 生成Cipher对象,指定其支持DES算法
			cipher = Cipher.getInstance("DES");
		} catch (NoSuchAlgorithmException ex) {
			ex.printStackTrace();
		} catch (NoSuchPaddingException ex) {
			ex.printStackTrace();
		}
	}

	/* 对字符串str加密 */
	public byte[] createEncryptor(String str) {
		try {
			// 根据密钥对Cipher对象进行初始化,ENCRYPT_MODE表示加密模式
			cipher.init(Cipher.ENCRYPT_MODE, secretKey);
			byte[] src = str.getBytes();
			// 将加密结果保存进cipherByte
			cipherByte = cipher.doFinal(src);
		} catch (java.security.InvalidKeyException ex) {
			ex.printStackTrace();
		} catch (javax.crypto.BadPaddingException ex) {
			ex.printStackTrace();
		} catch (javax.crypto.IllegalBlockSizeException ex) {
			ex.printStackTrace();
		}
		return cipherByte;
	}

	/* 对字节数组buff解密 */
	public byte[] createDecryptor(byte[] buff) {
		try {
			// 根据密钥对Cipher对象进行初始化,ENCRYPT_MODE表示解密模式
			cipher.init(Cipher.DECRYPT_MODE, secretKey);
			// 将得到的明文存入cipherByte字符数组
			cipherByte = cipher.doFinal(buff);
		} catch (java.security.InvalidKeyException ex) {
			ex.printStackTrace();
		} catch (javax.crypto.BadPaddingException ex) {
			ex.printStackTrace();
		} catch (javax.crypto.IllegalBlockSizeException ex) {
			ex.printStackTrace();
		}
		return cipherByte;
	}
}

HMAC：

package com.joye3g.ed;

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class HMAC {
	
	private Mac mac;
	
	public HMAC() {
		try {
			// 用DES算法得到计算验证码的密钥
			KeyGenerator keyGen = KeyGenerator.getInstance("DESede");
			SecretKey key = keyGen.generateKey();
			byte[] keyByte = key.getEncoded();
			// 生成MAC对象
			SecretKeySpec SKS = new SecretKeySpec(keyByte, "HMACMD5");
			mac = Mac.getInstance("HMACMD5");
			mac.init(SKS);
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
	}

	public byte[] createEncryptor(String str) {
		// 传入要计算验证码的字符串
		byte[] certifyCode = null;
		try {
			mac.update(str.getBytes("UTF8"));
			// 计算验证码
			certifyCode = mac.doFinal();
			return certifyCode;
		} catch (IllegalStateException e) {
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return null;
	}

}

MD5：

package com.joye3g.ed;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MD5 {
	private MessageDigest md5;

	public MD5() {
		//根据MD5算法生成MessageDigest对象   
		try {
			md5 = MessageDigest.getInstance("MD5");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}   
	}

	// MD5加密 
	public byte[] encrypt(String msg) {  
		byte[] srcBytes = msg.getBytes();  
		//使用srcBytes更新摘要   
		md5.update(srcBytes);    
		//完成哈希计算,得到并返回密文  
		return md5.digest();  
	}
}

RSA：

package com.joye3g.ed;

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.Cipher;
import javax.crypto.NoSuchPaddingException;

public class RSA {
	private RSAPrivateKey privateKey;
	private RSAPublicKey publicKey;
	private Cipher cipher;

	public RSA() {
		try {
			// KeyPairGenerator类用于生成公钥和私钥对,基于RSA算法生成对象
			KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
			// 初始化密钥对生成器,密钥大小为1024位
			keyPairGen.initialize(1024);
			// 生成一个密钥对保存在keyPair中
			KeyPair keyPair = keyPairGen.generateKeyPair();
			// 得到私钥
			privateKey = (RSAPrivateKey) keyPair.getPrivate();
			// 得到公钥
			publicKey = (RSAPublicKey) keyPair.getPublic();
			// 根据私钥对Cipher对象进行初始化
			cipher = Cipher.getInstance("RSA");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		}
	}

	/* 对srcBytes加密 */
	public byte[] encrypt(byte[] srcBytes) {
		if (publicKey != null) {
			try {
				// 根据公钥,对Cipher对象进行初始化
				cipher.init(Cipher.ENCRYPT_MODE, publicKey);
				// 将加密结果保存进resultBytes
				byte[] resultBytes = cipher.doFinal(srcBytes);
				return resultBytes;
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	/* 对encBytes解密 */
	public byte[] decrypt(byte[] encBytes) {
		if (privateKey != null) {
			try {
				cipher.init(Cipher.DECRYPT_MODE, privateKey);
				// 将解密结果保存进resultBytes
				byte[] decBytes = cipher.doFinal(encBytes);
				return decBytes;
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}
}

SHA：

package com.joye3g.ed;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class SHA {
	private MessageDigest md5;
	public SHA() {
		//根据MD5算法生成MessageDigest对象   
		try {
			md5 = MessageDigest.getInstance("MD5");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}   
	}

	// MD5加密 
	public byte[] encrypt(String msg) {  
		byte[] srcBytes = msg.getBytes();  
		//使用srcBytes更新摘要   
		md5.update(srcBytes);    
		//完成哈希计算,得到并返回密文  
		return md5.digest();  
	}
}

3DES：

package com.joye3g.ed;

import java.security.NoSuchAlgorithmException;
import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;

public class ThreeDES {
	// KeyGenerator提供对称密钥生成器的功能，支持各种算法
	private KeyGenerator keyGenerator;
	// SecretKey负责保存对称密钥
	private SecretKey secretKey;
	// Cipher负责完成加密或解密工作
	private Cipher cipher;
	// 该字节数组负责保存加密的结果
	private byte[] cipherByte;

	@SuppressWarnings("restriction")
	public ThreeDES() {
		Security.addProvider(new com.sun.crypto.provider.SunJCE());
		// 实例化支持3DES算法的密钥生成器，算法名称用DESede
		try {
			keyGenerator = KeyGenerator.getInstance("DESede");
			// 生成密钥
			secretKey = keyGenerator.generateKey();
			// 生成Cipher对象，指定其支持3DES算法
			cipher = Cipher.getInstance("DESede");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		}
	}

	/* 对字符串str加密 */
	public byte[] createEncryptor(String str) {
		try {
			// 根据密钥对Cipher对象进行初始化,ENCRYPT_MODE表示加密模式
			cipher.init(Cipher.ENCRYPT_MODE, secretKey);
			byte[] src = str.getBytes();
			// 将加密结果保存进cipherByte
			cipherByte = cipher.doFinal(src);
		} catch (java.security.InvalidKeyException ex) {
			ex.printStackTrace();
		} catch (javax.crypto.BadPaddingException ex) {
			ex.printStackTrace();
		} catch (javax.crypto.IllegalBlockSizeException ex) {
			ex.printStackTrace();
		}
		return cipherByte;
	}

	/* 对字节数组buff解密 */
	public byte[] createDecryptor(byte[] buff) {
		try {
			// 根据密钥对Cipher对象进行初始化,ENCRYPT_MODE表示解密模式
			cipher.init(Cipher.DECRYPT_MODE, secretKey);
			// 将得到明文存入cipherByte字符数组
			cipherByte = cipher.doFinal(buff);
		} catch (java.security.InvalidKeyException ex) {
			ex.printStackTrace();
		} catch (javax.crypto.BadPaddingException ex) {
			ex.printStackTrace();
		} catch (javax.crypto.IllegalBlockSizeException ex) {
			ex.printStackTrace();
		}
		return cipherByte;
	}
}