java中RSA加密工具类

最新推荐文章于 2024-07-25 11:27:30 发布
最新推荐文章于 2024-07-25 11:27:30 发布
阅读量663 收藏
点赞数
分类专栏： java中常用工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zr_rensheng/article/details/80194527
版权


import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

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

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

public class RSAEncrypt {
 /** 密钥算法 */
 private static final String AES_KEY_ALGORITHM = "AES";
 private static final int AES_KEY_SIZE = 128;

 /** 加密/解密算法/工作模式/填充方法 */
 // public static final String CIPHER_ALGORITHM = "AES/ECB/NoPadding";
 
  /** *//**
     * 加密算法RSA
     */
    public static final String KEY_ALGORITHM = "RSA";
   
    /** *//**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";

    /** *//**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    private static final int KEY_SIZE = 1024;
   
    /** *//**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = KEY_SIZE / 8 - 11;

    /** *//**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = KEY_SIZE / 8;

 /**
  * 获取密钥
  *
  * @return
  * @throws Exception
  */
 private static Key getKey() throws Exception {
  // 实例化
  KeyGenerator kg = KeyGenerator.getInstance(AES_KEY_ALGORITHM);
  // AES 要求密钥长度为128位、192位或256位
  kg.init(AES_KEY_SIZE);
  // 生成密钥
  SecretKey secretKey = kg.generateKey();
  return secretKey;
 }

 /**
  * 转化密钥
  *
  * @param key
  *            密钥
  * @return Key 密钥
  * @throws Exception
  */
 public static Key codeToKey(String key) throws Exception {
  
  
  SecretKey secretKey = new SecretKeySpec(key.getBytes("UTF-8"), AES_KEY_ALGORITHM);
  return secretKey;
 }

 /**
  * 解密
  *
  * @param data
  *            待解密数据
  * @param key
  *            密钥
  * @return byte[] 解密数据
  * @throws Exception
  */
 private static String decrypt(byte[] data, byte[] key) throws Exception {
  // 还原密钥
  Key k = new SecretKeySpec(key, AES_KEY_ALGORITHM);
  /**
   * 实例化 使用PKCS7Padding填充方式，按如下方式实现
   * Cipher.getInstance(CIPHER_ALGORITHM,"BC");
   */
  Cipher cipher = Cipher.getInstance(AES_KEY_ALGORITHM);
  // 初始化，设置解密模式
  cipher.init(Cipher.DECRYPT_MODE, k);
  // 执行操作
  return new String(cipher.doFinal(data), "UTF-8");
 }

 /**
  * 解密
  * @param data 待解密数据
  * @param key 密钥
  * @return String 解密数据
  * @throws Exception
  */
 public static String decrypt(String data, String key) throws Exception {
  return decrypt(org.apache.commons.codec.binary.Base64.decodeBase64(data), Base64.decodeBase64(key));
 }
 
 public static String decrypt(String dataStr, Key key) throws Exception {
  byte[] data = Base64.decodeBase64(dataStr);
  
  
       
  Cipher cipher = Cipher.getInstance(AES_KEY_ALGORITHM);
  // 初始化，设置解密模式
  cipher.init(Cipher.DECRYPT_MODE, key);
  // 执行操作
  return new String(cipher.doFinal(data), "UTF-8");
 }

 /**
  * 加密
  *
  * @param data
  *            待加密数据
  * @param key
  *            密钥
  * @return bytes[] 加密数据
  * @throws Exception
  */
 private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
  // 还原密钥
  Key k = new SecretKeySpec(key, AES_KEY_ALGORITHM);
  /**
   * 实例化 使用PKCS7Padding填充方式，按如下方式实现
   * Cipher.getInstance(CIPHER_ALGORITHM,"BC");
   */
  Cipher cipher = Cipher.getInstance(AES_KEY_ALGORITHM);
  // 初始化，设置为加密模式
  cipher.init(Cipher.ENCRYPT_MODE, k);
  // 执行操作
  return cipher.doFinal(data);
 }

 /**
  * 加密
  * @param data 原字符串 json标准字符串
  * @param key 加密密钥
  * @return String base64字符串
  * @throws Exception
  */
 public static String encrypt(String data, String key) throws Exception {
  byte[] dataBytes = data.getBytes("UTF-8");
  byte[] keyBytes = Base64.decodeBase64(key);
  return Base64.encodeBase64String(encrypt(dataBytes, keyBytes));
 }

 /**
  * 初始化密钥
  *
  * @return
  * @throws Exception
  */
 public static String getKeyStr() throws Exception {
  return Base64.encodeBase64String(getKey().getEncoded());
 }
 
 
 
 //rsa部分
   /** *//**
     * <p>
     * 生成密钥对(公钥和私钥)
     * </p>
     *
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(KEY_SIZE);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }
   
    /** *//**
     * <P>
     * 私钥解密
     * </p>
     *
     * @param encryptedData 已加密数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
            throws Exception {
        byte[] keyBytes = Base64.decodeBase64(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /**
     * 私钥解密
     * @param dataString
     * @param privatekey
     * @return
     * @throws Exception
     */
    public static String decryptByPrivateKey(String dataString,String privatekey) throws Exception{
     String mingwen = new String(decryptByPrivateKey(Base64.decodeBase64(dataString), privatekey),"UTF-8");
     return mingwen;
    }
   
    public static String decryptByPublicKey(String dataString, String publicKey) throws Exception{
     String mingwen = new String(decryptByPublicKey(Base64.decodeBase64(dataString), publicKey),"UTF-8");
     return mingwen;
      
    }
   
    /** *//**
     * <p>
     * 公钥解密
     * </p>
     *
     * @param encryptedData 已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
            throws Exception {
        byte[] keyBytes = Base64.decodeBase64(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /** *//**
     * <p>
     * 公钥加密
     * </p>
     *
     * @param data 源数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    private static byte[] encryptByPublicKey(byte[] data, String publicKey)  throws Exception {
        byte[] keyBytes = Base64.decodeBase64(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /**
     * 公钥加密
     * @param datastring 原文字符串
     * @param publickey  加密公钥（主账户提供）
     * @return
     * @throws Exception
     */
    public static String encryptByPublicKey(String datastring,String publickey) throws Exception{
     return Base64.encodeBase64String(encryptByPublicKey(datastring.getBytes("UTF-8"), publickey));
    }

   
    public static String encryptByPrivateKey(String datastring,String privatekey) throws Exception{
     return Base64.encodeBase64String(encryptByPrivateKey(datastring.getBytes("UTF-8"), privatekey));
    }
   
    /** *//**
     * <p>
     * 私钥加密
     * </p>
     *
     * @param data 源数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
            throws Exception {
        byte[] keyBytes = Base64.decodeBase64(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /** *//**
     * <p>
     * 获取私钥
     * </p>
     *
     * @param keyMap 密钥对
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return Base64.encodeBase64String(key.getEncoded());
    }
 
    /** *//**
     * <p>
     * 获取公钥
     * </p>
     *
     * @param keyMap 密钥对
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return Base64.encodeBase64String(key.getEncoded());
    }

}

zr_rensheng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rsa工具类 java_Java实现RSA加密工具类
weixin_32384503的博客
02-13 1208
公钥加密算法，也就是 非对称加密算法，这种算法加密和解密的密码不一样，一个是公钥，另一个是私钥：公钥和私钥成对出现公开的密钥叫公钥，只有自己知道的叫私钥用公钥加密的数据只有对应的私钥可以解密用私钥加密的数据只有对应的公钥可以解密如果可以用公钥解密，则必然是对应的私钥加的密如果可以用私钥解密，则必然是对应的公钥加的密公钥和私钥是相对的，两者本身并没有规定哪一个必须是公钥或私钥。代码如下package...
JAVA中RSA加密解密工具类
07-13
JAVA中RSA加密解密工具类
RSA工具类java加密解密非常全
01-31
设计到的方法如下： DigitalSign init getInstance SignMsgByRelativePath SignMsgByInputStream signMsgByAbsolutePath verifyMsgByInputSteam verifyMsgByAbsolutePath verifyMsgByRelativePath encryptMsg decodeMsg getPriKeyByInputStream getPriKeyByAbsolutePath getPriKeyByRelativePath getPubKeyByInputSteam getPublicKey getPriKey sign appendMap verify
Java：实现RSA加密与验证的方法详解
最新发布
u013938578的博客
07-25 2003
RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。非对称加密： RSA是一种非对称加密算法，意味着它使用不同的密钥进行加密和解密。公钥用于加密数据，只有拥有相应私钥的用户才能解密它。
JAVA中RSA加密解密工具类加强版
07-14
博客地址 http://blog.csdn.net/sbsujjbcy/article/details/46873403
Java实现RSA加密解密工具类
hakood的博客
04-18 443
Java实现RSA加密解密工具类
JAVA：RSA加密工具类
05-23
JAVA：RSA加密工具类
JAVA-RSA加密工具类
10-18
RSA加密加签工具类，支持公钥私钥加签验签，数据分块加密解密
RSA+AES 加密工具类 Java
03-13
在这个“RSA+AES加密工具类 Java”中，我们将深入探讨这两种加密技术以及如何在Java环境中，包括Android和Web应用，实现它们。 首先，RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，基于大整数因子分解的困难...
RSA加密工具类
11-06
RSA非对称加密是可逆的，有的时候数据出现问题，需要解密进行排解问题
rsa加密工具类
07-13
非常实用的rsa加解密工具类，加签验签，拿过去就能用，包含测试代码
RSA加密用工具类
03-29
RSA非对称加密，所需要的工具类。简单实用。静态代码块生成公钥私钥对
RAS生成非对称加密公私钥Base64转换显示
小屁孩的博客
01-02 950
测试main方法 package RSA; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; /** *功能描述 * @author kangjinfan * @date 2020/1/2 */ public class Base64Main {...
Android网络传输中必用的两个加密算法:MD5 和 RSA 及Base64加密总结
weixin_30780221的博客
03-18 111
(1)commons-codec包简介 包含一些通用的编码解码算法。包括一些语音编码器，Hex,Base64.MD5 一、md5.base64.commons-codec包 commons-codec包可以从apache下载，最新版是1.3 不可逆算法 1.MD5 <!---->Stringstr="abc"; DigestUti...
RSA公私钥加密工具类
tjd5214的博客
08-26 511
import org.apache.commons.codec.binary.Base64; import javax.crypto.Cipher; import java.nio.charset.StandardCharsets; import java.security.*; import java.security.interfaces.RSAPrivateKey; import java.security.interfaces.RSAPublicKey; import java.security..
Java RSA加密工具类实现详解
本文主要介绍了Java中的非对称加密技术，特别是RSA算法的代码实现，包括公钥和私钥的加载方法。文章提供了多种加载方式，如从PEM格式文件、二进制数据、Base64编码、Hex字符串以及证书和keystore文件加载。 在Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值