java加密 常用类

Base64
public class Base64 {

	private static char base64EncodeChars[] = {
		'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 
		'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 
		'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 
		'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 
		'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 
		'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', 
		'8', '9', '+', '/'
	};
	private static byte base64DecodeChars[] = {
		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
		-1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 
		54, 55, 56, 57, 58, 59, 60, 61, -1, -1, 
		-1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 
		5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 
		15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 
		25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 
		29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 
		39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 
		49, 50, 51, -1, -1, -1, -1, -1
	};

	public Base64() {
	}

	public static String encode(byte data[]) {
		StringBuffer sb = new StringBuffer();
		int len = data.length;
		for (int i = 0; i < len;) {
			int b1 = data[i++] & 0xff;
			if (i == len) {
				sb.append(base64EncodeChars[b1 >>> 2]);
				sb.append(base64EncodeChars[(b1 & 3) << 4]);
				sb.append("==");
				break;
			}
			int b2 = data[i++] & 0xff;
			if (i == len) {
				sb.append(base64EncodeChars[b1 >>> 2]);
				sb.append(base64EncodeChars[(b1 & 3) << 4 | (b2 & 0xf0) >>> 4]);
				sb.append(base64EncodeChars[(b2 & 0xf) << 2]);
				sb.append("=");
				break;
			}
			int b3 = data[i++] & 0xff;
			sb.append(base64EncodeChars[b1 >>> 2]);
			sb.append(base64EncodeChars[(b1 & 3) << 4 | (b2 & 0xf0) >>> 4]);
			sb.append(base64EncodeChars[(b2 & 0xf) << 2 | (b3 & 0xc0) >>> 6]);
			sb.append(base64EncodeChars[b3 & 0x3f]);
		}

		return sb.toString();
	}

	public static byte[] decode(String str) {
		byte data[] = str.getBytes();
		int len = data.length;
		ByteArrayOutputStream buf = new ByteArrayOutputStream(len);
		for (int i = 0; i < len;) {
			int b1;
			do {
				b1 = base64DecodeChars[data[i++]];
			} while (i < len && b1 == -1);
			if (b1 == -1) {
				break;
			}
			int b2;
			do {
				b2 = base64DecodeChars[data[i++]];
			} while (i < len && b2 == -1);
			if (b2 == -1) {
				break;
			}
			buf.write(b1 << 2 | (b2 & 0x30) >>> 4);
			int b3;
			do {
				b3 = data[i++];
				if (b3 == 61) {
					return buf.toByteArray();
				}
				b3 = base64DecodeChars[b3];
			} while (i < len && b3 == -1);
			if (b3 == -1) {
				break;
			}
			buf.write((b2 & 0xf) << 4 | (b3 & 0x3c) >>> 2);
			int b4;
			do {
				b4 = data[i++];
				if (b4 == 61) {
					return buf.toByteArray();
				}
				b4 = base64DecodeChars[b4];
			} while (i < len && b4 == -1);
			if (b4 == -1) {
				break;
			}
			buf.write((b3 & 3) << 6 | b4);
		}

		return buf.toByteArray();
	}

	public static String getBase64Code(String src) {
		String result = (new StringBuilder(String.valueOf((new String(src)).replace("=", "")))).append("==".substring(0, (src.length() % 8) / 3)).toString();
		return result.substring(0, result.length() - result.length() % 4);
	}

EncrypDES
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;
	}
EncrypMD5
public EncrypMD5() {
	}

	public String getMD5(String source) {
		String result = null;
		char hexDigits[] = {
			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
			'a', 'b', 'c', 'd', 'e', 'f'
		};
		try {
			MessageDigest md = MessageDigest.getInstance("MD5");
			md.update(source.getBytes());
			byte tmp[] = md.digest();
			char str[] = new char[32];
			int k = 0;
			for (int i = 0; i < 16; i++) {
				byte byte0 = tmp[i];
				str[k++] = hexDigits[byte0 >>> 4 & 0xf];
				str[k++] = hexDigits[byte0 & 0xf];
			}

			result = new String(str);
		}
		catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}

	public void testGetMD5() {
		String msg = "郭XX-精品相声技术";
		EncrypMD5 md5 = new EncrypMD5();
		System.out.println(md5.getMD5(msg));
	}

	public String getMD5(String source, int count) {
		for (int i = 0; i < count; i++) {
			source = getMD5(source);
		}

		return source;
	}

	public void testGetMD52() {
		String msg = "郭XX-精品相声技";
		EncrypMD5 md5 = new EncrypMD5();
		System.out.println(md5.getMD5(msg, 10));
		System.out.println(md5.getMD5("郭XX-精品相声技术", 10));
	}
EncrypPBE
public static final String ALGORITHM = "PBEWITHMD5andDES";

	public EncrypPBE() {
	}

	public static byte[] initSalt() throws Exception {
		byte salt[] = new byte[8];
		Random random = new Random();
		random.nextBytes(salt);
		return salt;
	}

	private static Key toKey(String password) throws Exception {
		PBEKeySpec keySpec = new PBEKeySpec(password.toCharArray());
		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWITHMD5andDES");
		javax.crypto.SecretKey secretKey = keyFactory.generateSecret(keySpec);
		return secretKey;
	}

	public static byte[] encrypt(byte data[], String password, byte salt[]) throws Exception {
		Key key = toKey(password);
		PBEParameterSpec paramSpec = new PBEParameterSpec(salt, 100);
		Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
		cipher.init(1, key, paramSpec);
		return cipher.doFinal(data);
	}

	public static byte[] decrypt(byte data[], String password, byte salt[]) throws Exception {
		Key key = toKey(password);
		PBEParameterSpec paramSpec = new PBEParameterSpec(salt, 100);
		Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
		cipher.init(2, key, paramSpec);
		return cipher.doFinal(data);
	}

	public static byte[] decryptBASE64(String key) throws Exception {
		return (new BASE64Decoder()).decodeBuffer(key);
	}

	public static String encryptBASE64(byte key[]) throws Exception {
		return (new BASE64Encoder()).encodeBuffer(key);
	}

	public static String encryptPBE(String src, String pwd, byte salt[]) throws Exception {
		byte input[] = src.getBytes();
		byte data[] = encrypt(input, pwd, salt);
		return encryptBASE64(data);
	}

	public static String decryptPBE(String src, String pwd, byte salt[]) throws Exception {
		byte output[] = decrypt(decryptBASE64(src), pwd, salt);
		return new String(output);
	}
EncrypRSA
public static final String KEY_ALGORITHM = "RSA";
	public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
	private static final String PUBLIC_KEY = "RSAPublicKey";
	private static final String PRIVATE_KEY = "RSAPrivateKey";

	public EncrypRSA() {
	}

	public static String sign(byte data[], String privateKey) throws Exception {
		byte keyBytes[] = decryptBASE64(privateKey);
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		java.security.PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
		Signature signature = Signature.getInstance("MD5withRSA");
		signature.initSign(priKey);
		signature.update(data);
		return encryptBASE64(signature.sign());
	}

	public static boolean verify(byte data[], String publicKey, String sign) throws Exception {
		byte keyBytes[] = decryptBASE64(publicKey);
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		java.security.PublicKey pubKey = keyFactory.generatePublic(keySpec);
		Signature signature = Signature.getInstance("MD5withRSA");
		signature.initVerify(pubKey);
		signature.update(data);
		return signature.verify(decryptBASE64(sign));
	}

	public static byte[] decryptByPrivateKey(byte data[], String key) throws Exception {
		byte keyBytes[] = decryptBASE64(key);
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(2, privateKey);
		return cipher.doFinal(data);
	}

	public static byte[] decryptByPublicKey(byte data[], String key) throws Exception {
		byte keyBytes[] = decryptBASE64(key);
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		Key publicKey = keyFactory.generatePublic(x509KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(2, publicKey);
		return cipher.doFinal(data);
	}

	public static byte[] encryptByPublicKey(byte data[], String key) throws Exception {
		byte keyBytes[] = decryptBASE64(key);
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		Key publicKey = keyFactory.generatePublic(x509KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(1, publicKey);
		return cipher.doFinal(data);
	}

	public static byte[] encryptByPrivateKey(byte data[], String key) throws Exception {
		byte keyBytes[] = decryptBASE64(key);
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(1, privateKey);
		return cipher.doFinal(data);
	}

	public static String getPrivateKey(Map keyMap) throws Exception {
		Key key = (Key)keyMap.get("RSAPrivateKey");
		return encryptBASE64(key.getEncoded());
	}

	public static String getPublicKey(Map keyMap) throws Exception {
		Key key = (Key)keyMap.get("RSAPublicKey");
		return encryptBASE64(key.getEncoded());
	}

	public static Map initKey() throws Exception {
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
		keyPairGen.initialize(1024);
		KeyPair keyPair = keyPairGen.generateKeyPair();
		RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();
		RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();
		Map keyMap = new HashMap(2);
		keyMap.put("RSAPublicKey", publicKey);
		keyMap.put("RSAPrivateKey", privateKey);
		return keyMap;
	}

	public static byte[] decryptBASE64(String key) throws Exception {
		return (new BASE64Decoder()).decodeBuffer(key);
	}

	public static String encryptBASE64(byte key[]) throws Exception {
		return (new BASE64Encoder()).encodeBuffer(key);
	}
EncrypSHA
public EncrypSHA() {
	}

	public byte[] eccrypt(String info) throws NoSuchAlgorithmException {
		MessageDigest md5 = MessageDigest.getInstance("SHA");
		byte srcBytes[] = info.getBytes();
		md5.update(srcBytes);
		byte resultBytes[] = md5.digest();
		return resultBytes;
	}