加密工具
博客专区 > yabushan 的博客 > 博客详情
加密工具
yabushan 发表于2年前
加密工具
  • 发表于 2年前
  • 阅读 6
  • 收藏 1
  • 点赞 1
  • 评论 0

1.PBE加密

package yabushan.password;

import java.security.Key;
import java.security.NoSuchAlgorithmException;
import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;

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

public class PBE {

	private static String src="美女";
	
	private static byte[] salt={-29,100,93,104,-23,-25,33,34};
	
	private static String password="sanyuepwd";
	public static void main(String[] args) throws Exception {
		//bcPBE();
	for(int i=0; i<10;i++){
		String target=encrypt(src+i);
		
		decrypt(target);
	}
		
	}
	
	public static void bcPBE() throws Exception{
		
		//初始化盐
		//SecureRandom random=new SecureRandom();
	//	byte[] salt=random.generateSeed(8);
		byte[] salt={-29,100,93,104,-23,-25,33,34};
		for(int i=0;i<salt.length;i++){
			System.out.println(salt[i]+">>>");
		}
		System.out.println(Base64.encodeBase64String(salt));
		//口令与秘钥
	
		
		try {
			String password="mypass";
			PBEKeySpec pbeKeySpec=new PBEKeySpec(password.toCharArray());
			SecretKeyFactory factory=SecretKeyFactory.getInstance("PBEWITHMD5andDES");
			Key key=factory.generateSecret(pbeKeySpec);
			
			//加密
			
			PBEParameterSpec parameterSpec=new PBEParameterSpec(salt, 100);//100是指迭代次数
			Cipher cipher=Cipher.getInstance("PBEWITHMD5andDES");
			cipher.init(Cipher.ENCRYPT_MODE, key, parameterSpec);
			byte[] result=cipher.doFinal(src.getBytes());
			System.out.println("jdk pbe encrypt:"+Base64.encodeBase64String(result));
		
			
			//解密
			cipher.init(Cipher.DECRYPT_MODE, key,parameterSpec);
			result=cipher.doFinal(result);
			System.out.println("jdk pbe decrypt:"+new String(result));
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	//加密
	
	public static String encrypt(String src){
		try {
			PBEKeySpec pbeKeySpec=new PBEKeySpec(password.toCharArray());
			SecretKeyFactory factory=SecretKeyFactory.getInstance("PBEWITHMD5andDES");
			Key key=factory.generateSecret(pbeKeySpec);
			
			
			
			PBEParameterSpec parameterSpec=new PBEParameterSpec(salt, 100);//100是指迭代次数
			Cipher cipher=Cipher.getInstance("PBEWITHMD5andDES");
			cipher.init(Cipher.ENCRYPT_MODE, key, parameterSpec);
			byte[] result=cipher.doFinal(src.getBytes());
			System.out.println("jdk pbe encrypt:"+Base64.encodeBase64String(result));
			return Base64.encodeBase64String(result);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
		
	}
	//解密
	public static String decrypt(String target){
		try {
			PBEKeySpec pbeKeySpec=new PBEKeySpec(password.toCharArray());
			SecretKeyFactory factory=SecretKeyFactory.getInstance("PBEWITHMD5andDES");
			Key key=factory.generateSecret(pbeKeySpec);
			
			
			PBEParameterSpec parameterSpec=new PBEParameterSpec(salt, 100);//100是指迭代次数
			byte[] result=Base64.decodeBase64(target);
			Cipher cipher=Cipher.getInstance("PBEWITHMD5andDES");
			cipher.init(Cipher.ENCRYPT_MODE, key, parameterSpec);
			//解密
			cipher.init(Cipher.DECRYPT_MODE, key,parameterSpec);
			result=cipher.doFinal(result);
			System.out.println("jdk pbe decrypt:"+new String(result));
			return new String(result);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	
	
	
}

2.对称加解密

package yabushan.password;

import java.io.ByteArrayOutputStream;
import java.security.Security;

import javax.crypto.Cipher; 
import javax.crypto.SecretKey;  
import javax.crypto.spec.SecretKeySpec;
/**
 * 对称加密
 * <code>{@link ThreeDes}</code>
 *
 * TODO : document me
 *
 * @author yabushan
 */
public class ThreeDes {
	
	private static final String Algorithm = "TripleDES";
	
	public static byte[] ecrypt(byte[] keybyte, byte[] source){
		try {            
			//生成密钥
			SecretKey deskey = new SecretKeySpec(keybyte, Algorithm);
			//加密           
			Cipher c1 = Cipher.getInstance("TripleDES/ECB/PKCS5Padding");
			c1.init(Cipher.ENCRYPT_MODE, deskey);
			return c1.doFinal(source);        
		} catch (java.security.NoSuchAlgorithmException e1) {
			e1.printStackTrace();        
		} catch (javax.crypto.NoSuchPaddingException e2) {
			e2.printStackTrace();        
		} catch (java.lang.Exception e3) {
			e3.printStackTrace();        
		}
		return null;
	}
	
	public static byte[] decrypt(byte[] keybyte, byte[] source)throws Exception{
		try {
			//生成密钥
			SecretKey deskey = new SecretKeySpec(keybyte,Algorithm);
			//解密           
			Cipher c1 = Cipher.getInstance("TripleDES/ECB/PKCS5Padding");
			c1.init(Cipher.DECRYPT_MODE, deskey);
			return c1.doFinal(source);        
		} catch (java.security.NoSuchAlgorithmException e1) {
			e1.printStackTrace();        
			throw e1;
		} catch (javax.crypto.NoSuchPaddingException e2) {
			e2.printStackTrace();
			throw e2;
		} catch (java.lang.Exception e3) {    
			e3.printStackTrace();
			throw e3;
		}
	}
	
    public static byte[] hexStringToBytes(String in) {  
    	byte[] arrB = in.getBytes();  
    	int iLen = arrB.length;  
    	// 两个字符表示一个字节,所以字节数组长度是字符串长度除以2   
    	byte[] arrOut = new byte[iLen / 2];  
    	for (int i = 0; i < iLen; i = i + 2) {  
    		String strTmp = new String(arrB, i, 2);  
    		arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);  
    	}  
    	return arrOut;  
    }
    
    public static byte[] decode(String bytes) 

    { 

	    ByteArrayOutputStream baos=new ByteArrayOutputStream(bytes.length()/2); 
	
	    //将每2位16进制整数组装成一个字节 
	
	    String hexString="0123456789ABCDEF"; 
	
	    for(int i=0;i<bytes.length();i+=2){
	    	 baos.write((hexString.indexOf(bytes.charAt(i))<<4 |hexString.indexOf(bytes.charAt(i+1))));
	    }
	    return baos.toByteArray(); 
    }
    
    public static byte[] decode2(String hexString) throws Exception{
    	byte[] bts = new byte[hexString.length()/2];
    	for (int i = 0; i < bts.length; i++) {
			bts[i] = (byte)Integer.parseInt(hexString.substring(2*i, 2*i+2),16);
		}
    	return bts;
    }

    public static String byte2hex(byte[] b) {
        String hs="";
        String stmp="";
        for (int n=0;n<b.length;n++){
          stmp=(java.lang.Integer.toHexString(b[n] & 0XFF));
          if (stmp.length()==1)
            hs=hs+"0"+stmp;
          else hs=hs+stmp;
            if (n<b.length-1)  hs=hs+"";
          }
        return hs.toUpperCase();
      }
    
    public static void main(String[] args) throws Exception {
		Security.addProvider(new com.sun.crypto.provider.SunJCE());
		String authenticator = "69556765$2F8997E4234BFDDD9B6557E8$8002002601147666$001001990070114000034C09B4BE1B65$192.168.1.104$4C:09:B4:BE:1B:65$990070|$CTC";
//		byte[] source = decode(authenticator);
		//byte[] source = authenticator.getBytes();
		String userID = "1234567";
		int lenth = userID.length();
		for (int i = 0; i < 24-lenth; i++) {
			userID = userID+"0";
		}
		System.out.println("userID:"+userID);
		byte[] keybyte = userID.getBytes();
		
		System.out.println("keybyte="+new String(keybyte)+"--length:"+keybyte.length);
		
		
		byte[] source = authenticator.getBytes();
		
		/**
		 * 加密
		 */
		byte[] data3 = ecrypt(keybyte, source);
		String data = byte2hex(data3);
		System.out.println("密文:"+data+"--length:"+data.length());
		/**
		 * 解密
		 */
		source =decode(data);
		byte[] data2 = decrypt(keybyte, source);
		
		System.out.println("data2:"+data2);
		
		String realData = new String(data2);
//		String realData = "12639364$ 3DE1B6ED6EDD0C47AB6F013CADF0309E$11111111$001001990070114000034C09B4BE1B65$192.168.200.70$4C:09:B4:BE:1B:65$990070|$CTC";
		System.out.println("明文:"+realData+"---"+realData.indexOf("$"));
		String[] dataStr = realData.split("\\$");
		System.out.println(dataStr.length+"--"+dataStr[0]);
		String stbid = dataStr[3];
		String stbip = dataStr[4];
		String mac = dataStr[5];
		
		System.out.println("STBID = " + stbid);
		System.out.println("IP = " + stbip);
		System.out.println("MAC = " + mac);
    	
	}
}

3.MD5加密

package yabushan.password;

import java.security.MessageDigest;

public class MD5Util {
    public final static String MD5(String s) {
        char hexDigits[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};       

        try {
            byte[] btInput = s.getBytes();
            // 获得MD5摘要算法的 MessageDigest 对象
            MessageDigest mdInst = MessageDigest.getInstance("MD5");
            // 使用指定的字节更新摘要
            mdInst.update(btInput);
            // 获得密文
            byte[] md = mdInst.digest();
            // 把密文转换成十六进制的字符串形式
            int j = md.length;
            char str[] = new char[j * 2];
            int k = 0;
            for (int i = 0; i < j; i++) {
                byte byte0 = md[i];
                str[k++] = hexDigits[byte0 >>> 4 & 0xf];
                str[k++] = hexDigits[byte0 & 0xf];
            }
            return new String(str);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        System.out.println(MD5Util.MD5("a123456"+"ease.shopping"));
       //System.out.println(MD5Util.MD5("加密"));
    }
}

4.3DES加解密

package yabushan.password;

import java.io.UnsupportedEncodingException;
import java.security.Security;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

/*字符串 DESede(3DES) 加密
 * ECB模式/使用PKCS7方式填充不足位,目前给的密钥是192位
 * 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)))
 * */
public class DesUtils {

	/**
	 * @param args在java中调用sun公司提供的3DES加密解密算法时
	 *            ,需要使 用到$JAVA_HOME/jre/lib/目录下如下的4个jar包: jce.jar
	 *            security/US_export_policy.jar security/local_policy.jar
	 *            ext/sunjce_provider.jar
	 */
	

	private static final String Algorithm = "DESede"; // 定义加密算法,可用
														// DES,DESede,Blowfish

	// keybyte为加密密钥,长度为24字节
	// src为被加密的数据缓冲区(源)
	public static byte[] encryptMode(byte[] keybyte, byte[] src) {
		try {
			// 生成密钥
			SecretKey deskey = new SecretKeySpec(keybyte, Algorithm);
			// 加密
			Cipher c1 = Cipher.getInstance(Algorithm);
			c1.init(Cipher.ENCRYPT_MODE, deskey);
			return c1.doFinal(src);// 在单一方面的加密或解密
		} catch (java.security.NoSuchAlgorithmException e1) {
			// TODO: handle exception
			e1.printStackTrace();
		} catch (javax.crypto.NoSuchPaddingException e2) {
			e2.printStackTrace();
		} catch (java.lang.Exception e3) {
			e3.printStackTrace();
		}
		return null;
	}

	// keybyte为加密密钥,长度为24字节
	// src为加密后的缓冲区
	public static byte[] decryptMode(byte[] keybyte, byte[] src) {
		try {
			// 生成密钥
			SecretKey deskey = new SecretKeySpec(keybyte, Algorithm);
			// 解密
			Cipher c1 = Cipher.getInstance(Algorithm);
			c1.init(Cipher.DECRYPT_MODE, deskey);
			return c1.doFinal(src);
		} catch (java.security.NoSuchAlgorithmException e1) {
			// TODO: handle exception
			e1.printStackTrace();
		} catch (javax.crypto.NoSuchPaddingException e2) {
			e2.printStackTrace();
		} catch (java.lang.Exception e3) {
			e3.printStackTrace();
		}
		return null;
	}

	// 转换成十六进制字符串
	public static String byte2Hex(byte[] b) {
		String hs = "";
		String stmp = "";
		for (int n = 0; n < b.length; n++) {
			stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
			if (stmp.length() == 1) {
				hs = hs + "0" + stmp;
			} else {
				hs = hs + stmp;
			}
			if (n < b.length - 1)
				hs = hs + ":";
		}
		return hs.toUpperCase();
	}

	public static String getCharEncode(String str) {

		String charEncode = "GB2312";
		try {
			if (str.equals(new String(str.getBytes(charEncode), charEncode))) {

				return charEncode;
			}
		} catch (UnsupportedEncodingException e) {

		}

		charEncode = "GBK";
		try {
			if (str.equals(new String(str.getBytes(charEncode), charEncode))) {

				return charEncode;
			}
		} catch (UnsupportedEncodingException e) {

		}

		charEncode = "ISO-8859-1";
		try {
			if (str.equals(new String(str.getBytes(charEncode), charEncode))) {

				return charEncode;
			}
		} catch (UnsupportedEncodingException e) {

		}

		charEncode = "UTF-8";
		try {
			if (str.equals(new String(str.getBytes(charEncode), charEncode))) {

				return charEncode;
			}
		} catch (UnsupportedEncodingException e) {

		}

		return "";

	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 添加新安全算法,如果用JCE就要把它添加进去
		Security.addProvider(new com.sun.crypto.provider.SunJCE());
		final byte[] keyBytes = { 0x11, 0x22, 0x4F, 0x58, (byte) 0x88, 0x50,
				0x40, 0x38, 0x18, 0x25, 0x79, 0x51, (byte) 0xCB, (byte) 0xDD,
				0x55, 0x66, 0x27, 0x29, 0x74, (byte) 0x98, 0x30, 0x40, 0x38,
				(byte) 0xE2 }; // 24字节的密钥
		// final byte[] keyBytes = "123456".getBytes();
		String szSrc = "123456789012345";
		System.out.println("加密前的字符串:" + szSrc);
		byte[] encoded = encryptMode(keyBytes, szSrc.getBytes());
		System.out.println("加密后的字符串:" + new String(encoded));
	//	System.out.println("加密后的编码:" + getCharEncode(new String(encoded)));
		byte[] srcBytes = decryptMode(keyBytes, encoded);
		System.out.println("解密后的字符串:" + (new String(srcBytes)));
		
	/*	byte[] test=encoderStr("123456789");
		System.out.println("加密后:"+new String(test));*/
		
		/*String test2=decoderStr(test);
		System.out.print(test2);
		String string=new String(test);
		System.out.print(decoderStr(string.getBytes()));*/
	}
	
	
	//加密
	public static  byte[] encoderStr(String src){
	final  byte[] keyBytes = { 0x11, 0x22, 0x4F, 0x58, (byte) 0x88, 0x50,
			0x40, 0x38, 0x18, 0x25, 0x79, 0x51, (byte) 0xCB, (byte) 0xDD,
			0x55, 0x66, 0x27, 0x29, 0x74, (byte) 0x98, 0x30, 0x40, 0x38,
			(byte) 0xE2 }; // 24字节的密钥
		
		byte[] encoded = encryptMode(keyBytes, src.getBytes());
		return encoded;
	}
	

	
	//解密
	public static  String decoderStr(byte[] target){
		final byte[] keyBytes = { 0x11, 0x22, 0x4F, 0x58, (byte) 0x88, 0x50,
			0x40, 0x38, 0x18, 0x25, 0x79, 0x51, (byte) 0xCB, (byte) 0xDD,
			0x55, 0x66, 0x27, 0x29, 0x74, (byte) 0x98, 0x30, 0x40, 0x38,
			(byte) 0xE2 }; // 24字节的密钥
		byte[] srcBytes = decryptMode(keyBytes, target);
		return new String(srcBytes);
	}
	
}

5.基础加密组件

package yabushan.password;

import java.security.MessageDigest;

import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import com.cloopen.rest.sdk.utils.encoder.BASE64Decoder;
import com.cloopen.rest.sdk.utils.encoder.BASE64Encoder;


/**
 * 基础加密组件
 * <code>{@link Coder}</code>
 *
 * TODO : document me
 *
 * @author yabushan
 */
public abstract class Coder {
	public static final String KEY_SHA = "SHA";
	public static final String KEY_MD5 = "MD5";

	/**
	 * MAC算法可选以下多种算法
	 * 
	 * <pre>
	 * HmacMD5 
	 * HmacSHA1 
	 * HmacSHA256 
	 * HmacSHA384 
	 * HmacSHA512
	 * </pre>
	 */
	public static final String KEY_MAC = "HmacMD5";

	/**
	 * BASE64解密
	 * 
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptBASE64(String key) throws Exception {
		return (new BASE64Decoder()).decodeBuffer(key);
	}

	/**
	 * BASE64加密
	 * 
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static String encryptBASE64(byte[] key) throws Exception {
		return (new BASE64Encoder()).encodeBuffer(key);
	}

	/**
	 * MD5加密
	 * 
	 * @param data
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptMD5(byte[] data) throws Exception {

		MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
		md5.update(data);

		return md5.digest();

	}

	/**
	 * SHA加密
	 * 
	 * @param data
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptSHA(byte[] data) throws Exception {

		MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
		sha.update(data);

		return sha.digest();

	}

	/**
	 * 初始化HMAC密钥
	 * 
	 * @return
	 * @throws Exception
	 */
	public static String initMacKey() throws Exception {
		KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);

		SecretKey secretKey = keyGenerator.generateKey();
		return encryptBASE64(secretKey.getEncoded());
	}

	/**
	 * HMAC加密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptHMAC(byte[] data, String key) throws Exception {

		SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);
		Mac mac = Mac.getInstance(secretKey.getAlgorithm());
		mac.init(secretKey);

		return mac.doFinal(data);

	}
}
package yabushan.password;

import java.math.BigInteger;



/**
 * 
 * <code>{@link CoderTest}</code>
 *
 * TODO : document me
 *
 * @author yabushan
 */
public class CoderTest {


	public static void main(String[] args) throws Exception {
		
	
		String inputStr = "简单加密";
		

		byte[] inputData = inputStr.getBytes();
		String code = Coder.encryptBASE64(inputData);
		System.out.println("BASE64加密后:\n" + code);

		byte[] output = Coder.decryptBASE64(code);

		String outputStr = new String(output);

		System.err.println("BASE64解密后:\n" + outputStr);
		// 验证BASE64加密解密一致性
				assertEquals(inputStr, outputStr);

				// 验证MD5对于同一内容加密是否一致
				assertArrayEquals(Coder.encryptMD5(inputData), Coder
						.encryptMD5(inputData));

				// 验证SHA对于同一内容加密是否一致
				assertArrayEquals(Coder.encryptSHA(inputData), Coder
						.encryptSHA(inputData));

				String key = Coder.initMacKey();
				System.err.println("Mac密钥:\n" + key);

				// 验证HMAC对于同一内容,同一密钥加密是否一致
				assertArrayEquals(Coder.encryptHMAC(inputData, key), Coder.encryptHMAC(
						inputData, key));

				BigInteger md5 = new BigInteger(Coder.encryptMD5(inputData));
				System.err.println("MD5:\n" + md5.toString(16));

				BigInteger sha = new BigInteger(Coder.encryptSHA(inputData));
				System.err.println("SHA:\n" + sha.toString(32));

				BigInteger mac = new BigInteger(Coder.encryptHMAC(inputData, inputStr));
				System.err.println("HMAC:\n" + mac.toString(16));
		
	}

	private static void assertEquals(String inputStr, String outputStr) {
	System.out.println(inputStr==outputStr);
		
	}

	private static void assertArrayEquals(byte[] encryptHMAC, byte[] encryptHMAC2) {
		System.out.println(encryptHMAC==encryptHMAC2);
		
	}
}


共有 人打赏支持
粉丝 2
博文 36
码字总数 32786
×
yabushan
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: