devbox
代码探险家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

前后端加密传输，采用RSA算法_rsa 实现前后端加解密

作者：代码探险家 | 2024-08-08 13:34:07

赞

踩

rsa 实现前后端加解密

后端代码 

  1. package org.jeecg.modules.system.util;
  2.  
  3. import java.io.ByteArrayOutputStream;
  4. import java.security.Key;
  5. import java.security.KeyFactory;
  6. import java.security.KeyPair;
  7. import java.security.KeyPairGenerator;
  8. import java.security.NoSuchAlgorithmException;
  9. import java.security.SecureRandom;
  10. import java.security.interfaces.RSAPrivateKey;
  11. import java.security.interfaces.RSAPublicKey;
  12. import java.security.spec.InvalidKeySpecException;
  13. import java.security.spec.PKCS8EncodedKeySpec;
  14. import java.security.spec.X509EncodedKeySpec;
  15. import java.util.HashMap;
  16. import java.util.Map;
  17.  
  18. import javax.crypto.Cipher;
  19.  
  20. import org.apache.commons.codec.binary.Base64;
  21. import org.apache.commons.io.IOUtils;
  22.  
  23.  
  24. public class RSAUtils {
  25.  
  26.     public static final String CHARSET = "UTF-8";
  27.     public static final String RSA_ALGORITHM = "RSA";
  28.     public static final KeyPair keyPair = initKeys();
  29.  
  30.     private static KeyPair initKeys() {
  31.         KeyPairGenerator kpg;
  32.         try{
  33.             kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
  34.         }catch(NoSuchAlgorithmException e){
  35.             throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
  36.         }
  37.         int keySize = 1024;
  38.         SecureRandom random = new SecureRandom();
  39.         //初始化KeyPairGenerator对象,密钥长度
  40.         kpg.initialize(keySize, random);
  41.         //生成密匙对
  42.         KeyPair keyPair = kpg.generateKeyPair();
  43.         return keyPair;
  44.     }
  45.     
  46.     public static Map<String, String> createKeys(){
  47.         //为RSA算法创建一个KeyPairGenerator对象
  48.         KeyPairGenerator kpg;
  49.         try{
  50.             kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
  51.         }catch(NoSuchAlgorithmException e){
  52.             throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
  53.         }
  54.         int keySize = 1024;
  55.         //初始化KeyPairGenerator对象,密钥长度
  56.         kpg.initialize(keySize);
  57.         //生成密匙对
  58.         //KeyPair keyPair = kpg.generateKeyPair();
  59.         //得到公钥
  60.         Key publicKey = keyPair.getPublic();
  61.         String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded());
  62.         //得到私钥
  63.         Key privateKey = keyPair.getPrivate();
  64.         String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded());
  65.         Map<String, String> keyPairMap = new HashMap<String, String>();
  66.         keyPairMap.put("publicKey", publicKeyStr);
  67.         keyPairMap.put("privateKey", privateKeyStr);
  68.  
  69.         return keyPairMap;
  70.     }
  71.     
  72.     public static String getPublicKey() {
  73.         Key publicKey = keyPair.getPublic();
  74.         String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded());
  75.         return publicKeyStr;
  76.     }
  77.     
  78.     public static String getPrivateKey() {
  79.     	Key privateKey = keyPair.getPrivate();
  80.         String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded());
  81.         return privateKeyStr;
  82.     }
  83.  
  84.     /**
  85.      * 得到公钥
  86.      * @param publicKey 密钥字符串（经过base64编码）
  87.      * @throws Exception
  88.      */
  89.     public static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
  90.         //通过X509编码的Key指令获得公钥对象
  91.         KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
  92.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
  93.         RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
  94.         return key;
  95.     }
  96.  
  97.     /**
  98.      * 得到私钥
  99.      * @param privateKey 密钥字符串（经过base64编码）
  100.      * @throws Exception
  101.      */
  102.     public static RSAPrivateKey getPrivateKey(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
  103.         //通过PKCS#8编码的Key指令获得私钥对象
  104.         KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
  105.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
  106.         RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
  107.         return key;
  108.     }
  109.  
  110.     /**
  111.      * 公钥加密
  112.      * @param data
  113.      * @param publicKey
  114.      * @return
  115.      */
  116.     public static String publicEncrypt(String data, RSAPublicKey publicKey){
  117.         try{
  118.             Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
  119.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  120.             return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength()));
  121.         }catch(Exception e){
  122.             throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
  123.         }
  124.     }
  125.  
  126.     /**
  127.      * 私钥解密
  128.      * @param data
  129.      * @param privateKey
  130.      * @return
  131.      */
  132.  
  133.     public static String privateDecrypt(String data, RSAPrivateKey privateKey){
  134.         try{
  135.             Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
  136.             cipher.init(Cipher.DECRYPT_MODE, privateKey);
  137.             return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), privateKey.getModulus().bitLength()), CHARSET);
  138.         }catch(Exception e){
  139.             throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
  140.         }
  141.     }
  142.  
  143.     /**
  144.      * 私钥加密
  145.      * @param data
  146.      * @param privateKey
  147.      * @return
  148.      */
  149.  
  150.     public static String privateEncrypt(String data, RSAPrivateKey privateKey){
  151.         try{
  152.             Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
  153.             cipher.init(Cipher.ENCRYPT_MODE, privateKey);
  154.             return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), privateKey.getModulus().bitLength()));
  155.         }catch(Exception e){
  156.             throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
  157.         }
  158.     }
  159.  
  160.     /**
  161.      * 公钥解密
  162.      * @param data
  163.      * @param publicKey
  164.      * @return
  165.      */
  166.  
  167.     public static String publicDecrypt(String data, RSAPublicKey publicKey){
  168.         try{
  169.             Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
  170.             cipher.init(Cipher.DECRYPT_MODE, publicKey);
  171.             return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), publicKey.getModulus().bitLength()), CHARSET);
  172.         }catch(Exception e){
  173.             throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
  174.         }
  175.     }
  176.  
  177.     private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize){
  178.         int maxBlock = 0;
  179.         if(opmode == Cipher.DECRYPT_MODE){
  180.             maxBlock = keySize / 8;
  181.         }else{
  182.             maxBlock = keySize / 8 - 11;
  183.         }
  184.         ByteArrayOutputStream
  185.                 out = new ByteArrayOutputStream();
  186.         int offSet = 0;
  187.         byte[] buff;
  188.         int i = 0;
  189.         try{
  190.             while(datas.length > offSet){
  191.                 if(datas.length-offSet > maxBlock){
  192.                     buff = cipher.doFinal(datas, offSet, maxBlock);
  193.                 }else{
  194.                     buff = cipher.doFinal(datas, offSet, datas.length-offSet);
  195.                 }
  196.                 out.write(buff, 0, buff.length);
  197.                 i++;
  198.                 offSet = i * maxBlock;
  199.             }
  200.         }catch(Exception e){
  201.             throw new RuntimeException("加解密阀值为["+maxBlock+"]的数据时发生异常", e);
  202.         }
  203.         byte[] resultDatas = out.toByteArray();
  204.         IOUtils.closeQuietly(out);
  205.         return resultDatas;
  206.     }
  207.  
  208.     public static void main (String[] args) throws Exception {
  209.     	for (int i = 0; i <= 1; i++) {
  210.             Map<String, String> keyMap = RSAUtils.createKeys();
  211.             String  publicKey = keyMap.get("publicKey");
  212.             String  privateKey = keyMap.get("privateKey");
  213.             System.out.println("公钥: \n\r" + publicKey);
  214.             System.out.println("私钥： \n\r" + privateKey);
  215.  
  216.             System.out.println("公钥加密——私钥解密");
  217.             String str = "code_cayden";
  218.             System.out.println("\r明文：\r\n" + str);
  219.             System.out.println("\r明文大小：\r\n" + str.getBytes().length);
  220.             System.out.println("加密用的公钥：\r\n"+  RSAUtils.getPublicKey(publicKey));
  221.             System.out.println("解密用的私钥：\r\n"+  RSAUtils.getPrivateKey(privateKey));
  222.             String encodedData = RSAUtils.publicEncrypt(str, RSAUtils.getPublicKey(publicKey));
  223.             System.out.println("密文：\r\n" + encodedData);
  224.             String decodedData = RSAUtils.privateDecrypt(encodedData, RSAUtils.getPrivateKey(privateKey));
  225.             System.out.println("解密后文字: \r\n" + decodedData);
  226.     		
  227.     	}
  228.     }
  229. }
  1.     @ApiOperation("获取登录公钥")
  2.     @RequestMapping(value = "/getPublicKey", method = RequestMethod.POST) 
  3.     public Result<String> getPublicKey(){
  4.         Result<String> result = new Result<String>();
  5.         String publicKey = RSAUtils.getPublicKey();
  6.         result.setResult(publicKey);
  7.         result.setSuccess(true);
  8.         result.setCode(CommonConstant.SC_OK_200);
  9.         return result;
  10.     }
  11. 	
  12. 	@ApiOperation("登录接口")
  13. 	@RequestMapping(value = "/login", method = RequestMethod.POST)
  14. 	public Result<JSONObject> login(@RequestBody SysLoginModel sysLoginModel){
  15. 		Result<JSONObject> result = new Result<JSONObject>();
  16. 		String username = sysLoginModel.getUsername();
  17. 		String password = sysLoginModel.getPassword();
  18. 		
  19. 		String privateKey = RSAUtils.getPrivateKey();
  20.         try {
  21.             RSAPrivateKey rsaPrivateKey = RSAUtils.getPrivateKey(privateKey);
  22.             username = RSAUtils.privateDecrypt(username, rsaPrivateKey);
  23.             password = RSAUtils.privateDecrypt(password, rsaPrivateKey);
  24.         } catch (NoSuchAlgorithmException e) {
  25.             // TODO Auto-generated catch block
  26.             e.printStackTrace();
  27.         } catch (InvalidKeySpecException e) {
  28.             // TODO Auto-generated catch block
  29.             e.printStackTrace();
  30.         }
  31.         。。。。。。。。

前端代码

  1. cnpm install jsencrypt --save
  2.  
  3. ---------
  4.   import JsEncrypt from 'jsencrypt'
  5.  
  6. getPublicKey () {
  7.           postAction('/sys/getPublicKey')
  8.               .then(res => {
  9.                   if (res.success === true) {
  10.                       this.publicKey = res.result
  11.                   } else {
  12.                       this.$notification[ 'error' ]({
  13.                           message: '获取公钥失败',
  14.                           description: '获取公钥失败',
  15.                           duration: 4
  16.                       })
  17.                   }
  18.               })
  19.               .catch(err => {
  20.                   this.$notification[ 'error' ]({
  21.                       message: '获取公钥失败',
  22.                       description: '获取公钥失败',
  23.                       duration: 4
  24.                   })
  25.               })
  26.       },
  27. ---
  28. let encrypt = new JsEncrypt()
  29. encrypt.setPublicKey(this.publicKey)
  30. loginParams.username = encrypt.encrypt(values.username)
  31. loginParams.password = encrypt.encrypt(values.password)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/代码探险家/article/detail/948527
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号