各种常见加密算法的Java实现-------RSA+AES+DES+3DES

编程语言 2018-07-02 14:26:28 阅读次数: 0

RSA算法的介绍可以参照百度百科：

https://baike.baidu.com/item/RSA%E7%AE%97%E6%B3%95/263310?fr=aladdin

RSA具体的实现

package EncryptionAlgorithm;

import org.apache.commons.codec.binary.Base64;
//import org.apache.commons.io.IOUtils;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;


/**
 * RSA加密算法
 * @author WilsonSong
 * @version 2018-05-21
 */
public class RSAUtil {

    public static final String CHARSET = "UTF-8";
    public static final String RSA_ALGORITHM = "RSA";


    public static Map<String, String> createKeys(int keySize){
        //为RSA算法创建一个KeyPairGenerator对象
        KeyPairGenerator kpg;
        try{
            kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
        }catch(NoSuchAlgorithmException e){
            throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
        }

        //初始化KeyPairGenerator对象,密钥长度
        kpg.initialize(keySize);
        //生成密匙对
        KeyPair keyPair = kpg.generateKeyPair();
        //得到公钥
        Key publicKey = keyPair.getPublic();
        String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded());
        //得到私钥
        Key privateKey = keyPair.getPrivate();
        String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded());
        Map<String, String> keyPairMap = new HashMap<String, String>();
        keyPairMap.put("publicKey", publicKeyStr);
        keyPairMap.put("privateKey", privateKeyStr);

        return keyPairMap;
    }

    /**
     * 得到公钥
     * @param publicKey 密钥字符串（经过base64编码）
     * @throws Exception
     */
    public static RSAPublicKey getPublicKey(String publicKey) {
        try {
	    	//通过X509编码的Key指令获得公钥对象
	        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
	        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
	        RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
	        return key;
        } catch(NoSuchAlgorithmException e) {
        	e.printStackTrace();
        } catch(InvalidKeySpecException e) {
        	e.printStackTrace();
        }
        return null;
    }

    /**
     * 得到私钥
     * @param privateKey 密钥字符串（经过base64编码）
     * @throws Exception
     */
    public static RSAPrivateKey getPrivateKey(String privateKey)  {
        try {
	    	//通过PKCS#8编码的Key指令获得私钥对象
	        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
	        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
	        //PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKey);
	        RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
	        return key;
        } catch(NoSuchAlgorithmException e) {
        	e.printStackTrace();
        } catch(InvalidKeySpecException e) {
        	e.printStackTrace();
        }
        return null;
    }

    /**
     * 公钥加密
     * @param data
     * @param publicKey
     * @return
     */
    public static String publicEncrypt(String data, RSAPublicKey publicKey){
        try{
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength()));
        }catch(Exception e){
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 私钥解密
     * @param data
     * @param privateKey
     * @return
     */

    public static String privateDecrypt(String data, RSAPrivateKey privateKey){
        try{
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), privateKey.getModulus().bitLength()), CHARSET);
        }catch(Exception e){
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 私钥加密
     * @param data
     * @param privateKey
     * @return
     */

    public static String privateEncrypt(String data, RSAPrivateKey privateKey){
        try{
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), privateKey.getModulus().bitLength()));
        }catch(Exception e){
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 公钥解密
     * @param data
     * @param publicKey
     * @return
     */

    public static String publicDecrypt(String data, RSAPublicKey publicKey){
        try{
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), publicKey.getModulus().bitLength()), CHARSET);
        }catch(Exception e){
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        }
    }

    private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize){
        int maxBlock = 0;
        if(opmode == Cipher.DECRYPT_MODE){
            maxBlock = keySize / 8;
        }else{
            maxBlock = keySize / 8 - 11;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] buff;
        int i = 0;
        try{
            while(datas.length > offSet){
                if(datas.length-offSet > maxBlock){
                    buff = cipher.doFinal(datas, offSet, maxBlock);
                }else{
                    buff = cipher.doFinal(datas, offSet, datas.length-offSet);
                }
                out.write(buff, 0, buff.length);
                i++;
                offSet = i * maxBlock;
            }
        }catch(Exception e){
            throw new RuntimeException("加解密阀值为["+maxBlock+"]的数据时发生异常", e);
        }
        byte[] resultDatas = out.toByteArray();
        //IOUtils.closeQuietly(out);
        return resultDatas;
    }
}

AES的实现

package EncryptionAlgorithm;

import java.security.NoSuchAlgorithmException;
import java.security.InvalidKeyException;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import javax.crypto.BadPaddingException;  
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

/**
 * AES算法编程实现
 * @author WilsonSong
 * @version 2018-05-21
 */
public class AESUtil {

	/**
	 * 生成密钥
	 * @throws NoSuchAlgorithmException 
	 * @throws Exception 
	 */
	public static byte[] initKey() {  
        try {  
        	KeyGenerator keyGen = KeyGenerator.getInstance("AES");
    		//初始化密钥生成器
    		keyGen.init(128);  //默认128，获得无政策权限后可选择192或256
    		//生成密钥
    		SecretKey secretKey = keyGen.generateKey();
    		return secretKey.getEncoded();
        } catch (NoSuchAlgorithmException e) {  
            e.printStackTrace(); 
        }
        return null;  
    }  
	
	/**
	 * 加密
	 * @throws Exception 
	 */
	public static byte[] encryptAES(byte[] data, byte[] key){
		//恢复密钥
		SecretKey secretKey = new SecretKeySpec(key, "AES");
		//Cipher完成加密
		Cipher cipher;
		try {
			cipher = Cipher.getInstance("AES");
			//根据密钥对cipher进行初始化
			cipher.init(Cipher.ENCRYPT_MODE, secretKey);
			//加密
			byte[] encrypt = cipher.doFinal(data);
			return encrypt;
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvalidKeyException e) {  
            e.printStackTrace();  
        } catch (IllegalBlockSizeException e) {  
            e.printStackTrace();  
        } catch (BadPaddingException e) {  
            e.printStackTrace();  
        }
		return null;  
	}
	/**
	 * 解密
	 */
	public static byte[] decryptAES(byte[] data, byte[] key) {
		//恢复密钥生成
		SecretKey secretKey = new SecretKeySpec(key, "AES");
		//Cipher完成解密
		Cipher cipher;
		try {
			cipher = Cipher.getInstance("AES");
			//根据密钥对cipher进行初始化
			cipher.init(Cipher.DECRYPT_MODE, secretKey);
			byte[] plain = cipher.doFinal(data);
			return plain;
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}catch (InvalidKeyException e) {  
            e.printStackTrace();  
        } catch (IllegalBlockSizeException e) {  
            e.printStackTrace();  
        } catch (BadPaddingException e) {  
            e.printStackTrace();  
        }  
        return null; 	
	}
}

DES的实现

package EncryptionAlgorithm;

import java.security.NoSuchAlgorithmException;
import java.security.InvalidKeyException;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import javax.crypto.BadPaddingException;  
import javax.crypto.IllegalBlockSizeException;  

/**
 * DES加密算法
 * @author WilsonSong
 * @version 2018-05-21
 */
public class DESUtil {
	/**
	 * 生成密钥
	 * @throws Exception 
	 */
	public static byte[] initKey() {
		
		try {
			//密钥生成
			KeyGenerator keyGen;
			keyGen = KeyGenerator.getInstance("DES");
			//初始化密钥生成器
			keyGen.init(56);
			//生成密钥

			SecretKey  secretKey = keyGen.generateKey();
			return secretKey.getEncoded();
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 加密
	 * @throws Exception 
	 */
	public static byte[] encryptDES(byte[] data, byte[] key){
		try {
          	//获得密钥
			SecretKey secretKey = new SecretKeySpec(key, "DES");
			//Cipher完成加密
			Cipher cipher;
			cipher = Cipher.getInstance("DES");
			//初始化cipher
			cipher.init(Cipher.ENCRYPT_MODE, secretKey);
			//加密
			byte[] encrypt = cipher.doFinal(data);
			
			return encrypt;
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch(BadPaddingException e) {
			e.printStackTrace();
		} catch(IllegalBlockSizeException e) {
			e.printStackTrace();
		} 
		return null;
		
	}
	
	/**
	 * 解密
	 */
	public static byte[] decryptDES(byte[] data, byte[] key){
		try {
			//恢复密钥
			SecretKey secretKey = new SecretKeySpec(key, "DES");
			//Cipher完成解密
			Cipher cipher;
			cipher = Cipher.getInstance("DES");
			//初始化cipher
			cipher.init(Cipher.DECRYPT_MODE, secretKey);
			//解密
			byte[] plain = cipher.doFinal(data);
			
			return plain;
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch(BadPaddingException e) {
			e.printStackTrace();
		} catch(IllegalBlockSizeException e) {
			e.printStackTrace();
		}
		return null;
		
	}
}

3DES的实现

package EncryptionAlgorithm;

import java.security.NoSuchAlgorithmException;
import java.security.InvalidKeyException;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.BadPaddingException;  
import javax.crypto.IllegalBlockSizeException;  

/**
 * 3DES加密算法
 * @author WilsonSong
 * @version 2018-05-21
 */
public class DESede {

	/**
	 * 生成密钥
	 * @throws Exception 
	 */
	public static byte[] initKey(){
		try {
			//密钥生成
			KeyGenerator keyGen;
			keyGen = KeyGenerator.getInstance("DESede");
			//初始化密钥生成器
			keyGen.init(168);   //可指定密钥长度为128或者168，默认168
			//生成密钥
			SecretKey secretKey = keyGen.generateKey();
			return secretKey.getEncoded();
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return  null;
		
	}
	
	/**
	 * 加密
	 * @throws Exception 
	 */
	public static byte[] encrypt3DES(byte[] data, byte[] key){
		try {
			//恢复密钥
			SecretKey secretKey = new SecretKeySpec(key, "DESede");
			//Cipher完成加密
			Cipher cipher;
			cipher = Cipher.getInstance("DESede");
			//cipher初始化
			cipher.init(Cipher.ENCRYPT_MODE, secretKey);
			byte[] encrypt = cipher.doFinal(data);
			return encrypt;
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch(BadPaddingException e) {
			e.printStackTrace();
		} catch(IllegalBlockSizeException e) {
			e.printStackTrace();
		}
		return null;
		
	}
	
	/**
	 * 解密
	 */
	public static byte[] decrypt3DES(byte[] data, byte[] key) {
		try {
		//恢复密钥
		SecretKey secretKey = new SecretKeySpec(key, "DESede");
		//Cipher完成解密
		Cipher cipher = Cipher.getInstance("DESede");
		//初始化cipher
		cipher.init(Cipher.DECRYPT_MODE, secretKey);
		byte[] plain = cipher.doFinal(data);
		
		return plain;
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch(BadPaddingException e) {
			e.printStackTrace();
		} catch(IllegalBlockSizeException e) {
			e.printStackTrace();
		}
		return null;
	}
}

猜你喜欢

转载自blog.csdn.net/WilsonSong1024/article/details/80866815
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022