rsa 加密解密工具类

最新推荐文章于 2024-05-06 20:08:09 发布
最新推荐文章于 2024-05-06 20:08:09 发布
阅读量2.4k 收藏 1
点赞数
分类专栏： java
base64 加密解密  依赖于 common-codec jar包; 
package net.nxmax.sws.client;
import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
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 org.apache.commons.codec.binary.Base64;

/**
 * <p>
 *  rsa 加密工具
 */
public class RSAUtils {

    /**
     * 加密算法RSA
     */
    public static final String KEY_ALGORITHM = "RSA";
    
    /**
     * 签名算法
     */
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    /**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";
    
    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";
    
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;
    
    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

    /**
     * <p>
     * 生成密钥对(公钥和私钥)
     * </p>
     * 
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        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 data 已加密数据
     * @param privateKey 私钥(BASE64编码)
     * 
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        return encode(signature.sign());
    }

    /**
     * <p>
     * 校验数字签名
     * </p>
     * 
     * @param data 已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @param sign 数字签名
     * 
     * @return
     * @throws Exception
     * 
     */
    public static boolean verify(byte[] data, String publicKey, String sign)
            throws Exception {
        byte[] keyBytes = decode(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(decode(sign));
    }

    /**
     * <P>
     * 私钥解密
     * </p>
     * 
     * @param encryptedData 已加密数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
            throws Exception {
        byte[] keyBytes = decode(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;
    }

    /**
     * <p>
     * 公钥解密
     * </p>
     * 
     * @param encryptedData 已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
            throws Exception {
        byte[] keyBytes = decode(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
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey)
            throws Exception {
        byte[] keyBytes = decode(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;
    }

    /**
     * <p>
     * 私钥加密
     * </p>
     * 
     * @param data 源数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
            throws Exception {
        byte[] keyBytes =decode(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 encode(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 encode(key.getEncoded());
    }
    
    /**
     * base64 加密
     * @param bytes
     * @return
     * @throws Exception
     */
    public static String encode(byte[] bytes) throws Exception {
        return new String(Base64.encodeBase64(bytes));
    }
    /**
     * base64 解密
     * @param base64
     * @return
     * @throws Exception
     */
    public static byte[] decode(String base64) throws Exception {
        return Base64.decodeBase64(base64.getBytes());
    }

    public static void main(String[] args) throws Exception {
		
    	
    	 Map<String, Object> keyMap = RSAUtils.genKeyPair();
         String publicKey = RSAUtils.getPublicKey(keyMap);
         String privateKey = RSAUtils.getPrivateKey(keyMap);
         
         System.out.println("publicKey:"+publicKey);
         System.out.println("privateKey:"+privateKey);
         
         String data="这是测试的文字?";
         
         //公钥加密 私钥解密
         byte[] bytes= RSAUtils.encryptByPublicKey(data.getBytes(), publicKey);
         byte[] bytess= RSAUtils.decryptByPrivateKey(bytes, privateKey);
         System.out.println(new String(bytess));
         
         
         //私钥加密  公钥解密
         byte[] privateByte= RSAUtils.encryptByPrivateKey(data.getBytes(), privateKey);
         byte[] publicByte= RSAUtils.decryptByPublicKey(privateByte, publicKey);
         System.out.println(new String(publicByte));
         
         //私钥加密并生成数字签名     公钥验证
          byte[] privateBytes= RSAUtils.encryptByPrivateKey(data.getBytes(), privateKey);
          String signs=  RSAUtils.sign(privateBytes, privateKey);
          System.out.println(signs);
          boolean bool= RSAUtils.verify(privateBytes, publicKey, signs);
          System.out.println(bool);
    	
	}
    
    
}


WD4871
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
SQL Server关联表更新
cl103811的专栏
06-17 1525
关联表更新是SQL Server中常用的操作方法之一，可以使用INNER JOIN或UPDATE FROM语句来实现。关联表更新可以提高代码的可读性和效率，同时保证数据的一致性。在实际应用中，我们可以根据具体需求选择合适的关联表更新方法。
SQL Update多表联合更新的方法
09-10
主要介绍了SQL Update多表联合更新的方法,需要的朋友可以参考下
SQL update 多表关联更新的实现代码
09-09
主要介绍了SQL update 多表关联更新的实现代码,需要的朋友可以参考下
SQLServer批量更新两个关联表数据的方法
09-10
主要介绍了SQLServer批量更新两个关联表数据的方法,提供了2种关联查询与更新语句的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
T-SQL 更新表操作
呼呼的博客
08-31 545
T-SQL 更新表操作 1. SQL server 2. mysql
两表(多表)关联update的写法
04-20 1791
关于两表关联的update，可以把SQL写成了在SQL Server下面的特有形式，但是这种语法在Oracle下面是行不通的   update customers a    set    city_name=(select b.city_name from tmp_cust_city b where b.customer_id=a.customer_id)   where  exists (s
Oracle两表关联更新
.NET 人工智能实践
06-14 9944
Oracle两表关联更新 方式1：update 方式2：内联视图更新 方式3：merge
【数据库】sql实现两表关联更新
qq_43429919的博客
04-08 7258
postgresql 实现两表关联更新 UPDATE (要更新的表) table1 t1 SET t1.字段1 = t2.字段1, t1.字段2 = t2.字段2, FROM (数据来源表) table2 t2 WHERE t1.key = t2.key mysql 实现两表关联更新 UPDATE (要更新的表) table1 t1, table2 t2 SET t1.字段1 = t2.字段1, t1.字段2 = t2.字段2, WHERE t1.key = t2.key
数据库更新两张相关联的表
二粒米的博客
04-04 1054
在SQL Server中，更新两张相关联的表是经常需要的操作，假设我们有两张表 Employees 和 SalaryUpdates，我们想要根据 SalaryUpdates 中的新工资来更新 Employees 表中的工资。
sql两张表关联更新字段
qq_18932003的博客
07-18 1451
--第一种写法,之前一直用，没有在意 UPDATE sr_t_TCodeUserReciveCfg SET fUserID=a.fUserID,fImportFlag=NULL FROM dbo.vw_userinfo AS a INNER JOIN dbo.sr_t_TCodeUserReciveCfg AS b ON a.sLoginName=b.fImportFlag WHERE b.fImportFlag IS NOT NULL --第二种写法,发现第一种写法有...
mysql用一个表更新另一个表的方法
12-16
Solution 1:  修改1列 update student s, city c set s.city_name = c.name where s.city_code = c.code; Solution 2:  修改多个列 update  a,  b set a.title=b.title, a.name=b.name where a.id=b.id Solution 3: 采用子查询 update student s set city_name = (select name from city where code = s.city_code); 以上这篇mysql用一个表更新另一个表
Oracle两张表关联批量更新其中一张表的数据
09-09
本文给大家分享两种方法解决Oracle两张表关联批量更新其中一张表的数据，方法非常简单，具有参考借鉴价值，需要的的朋友参考下吧
sql update 多表关联 inner join
最新发布
晴天的博客
05-06 890
sql update 多表关联 inner join
PostgreSQL update/delete/upsert关联更新字段数据
chimchim66的博客
02-07 5455
PostgreSQL update/delete/upsert关联更新字段数据
实例说明SQL实现用一张表数据更新另一张表
郝伟老师的博客——大数据、并行计算与人工智能时代
06-24 1万+
前言 在SQL中，如果将一个表的数据插入另一张表，常用的是 SELECT INTO 或 INSERT INTO SELECT. 但是，并没有UPDATE SELECT这样的语句， 所以如果我们需要根据一个表对另一个表进行更新应该怎么办？本文将以实例说明这个过程。 应用实例 在某公司的客户访问信息记录中，有用户信息表users和访问记录表visit，在访问记录表中，会记录时间和访客，访客名和电话信息...
【SQL update 多表关联更新方法总结】
热门推荐
m0_46459413的博客
04-18 1万+
1. MySQL update test1,test2 set test1.name=test2.name,test1.age=test2.age where test1.id=test2.id 2. oracle update test1 set (test1.name,test1.age)= (select test2.name,test2.age from test2 where test2.id=test1.id) 3. SQLServer update test1 set test1.na
俩表关联更新
weixin_42023748的博客
08-04 779
数据库 ~
SQL两表关联更新UPDATE
zuoming120的专栏
10-26 6920
亲测有用
sqlserver 三个表关联更新数据
09-02
要实现三个表的关联更新数据，可以使用SQL Server中的UPDATE语句和JOIN子句。以下是一个示例： 假设有三个表：表A、表B和表C，它们之间有关联关系。需要根据表B和表C的数据更新表A的数据。 可以使用以下的SQL语句进行关联更新操作： UPDATE A SET A.column1 = B.column1, A.column2 = C.column2 FROM A JOIN B ON A.id = B.id JOIN C ON A.id = C.id 上述语句的含义是，根据表A中的id字段和表B、表C中的id字段进行关联，然后将表B的column1字段的值更新到表A的column1字段中，将表C的column2字段的值更新到表A的column2字段中。 需要确保联接条件（ON语句中的条件）是正确的，以确保准确地将数据更新到表A中的对应行。 注意：上述示例是一种常见的情况，实际应用中根据情况可能会有不同的列名、表名和条件。在实际使用时，请根据具体需求进行调整。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值