使用RAS进行前端传输数据加密码

今天接到一个任务就是前端面传密码过来时，会先对密码进分加密，然后后端再对密码进行解密 ，我这里使用Rsa对密码进行加密，原理：通过Rsa获取公钥和私钥，公钥是给前端用来对密码进行加密，然后对加密后的密码伟给后台，后台使用Rsa使用私钥对加密后的密码进行解密，不多说上代码

得到公钥和私钥

@RequestMapping(value = "/getPublicKey")
public ReturnInfo getPublicKey(){
    try {
        // 获取公钥和私钥
        String key = "rasKey_"+System.currentTimeMillis()+Math.random();
        Map<String, String> keys = RSAUtils.getKeys();
        String publicKey  =  keys.get("publicKey");
        String privateKey =  keys.get("privateKey");
        //保存私钥到 redis
        redisObject.set(PUBLIC_KEY_PREFIX+key, privateKey,5L,TimeUnit.MINUTES);
        Map map = new HashMap();
        map.put("key",key);
        map.put("publicKey",publicKey);
        return ReturnDate.success(map);
    }catch (Exception e){
        e.printStackTrace();
        return ReturnDate.error(-1, "网络异常");
    }
}

这里私钥我使用redis保存

登录接口对之前密码进行解密

passWord = RSAUtils.decryptByPrivateKey(passWord, ObjectUtils.toString(privateKeyObj));
loginCode = RSAUtils.decryptByPrivateKey(loginCode, ObjectUtils.toString(privateKeyObj));
redisObject.delete(PUBLIC_KEY_PREFIX+key);

ras工具类

package com.jpay.secure;


import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import javax.crypto.Cipher;

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

public class RSAUtils {

   /** RSA最大加密明文大小 */
   private static final int MAX_ENCRYPT_BLOCK = 117;

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

   /** 加密算法RSA */
   private static final String KEY_ALGORITHM = "RSA";
   
   final static Base64 base64 = new Base64();

   /**
    * 生成公钥和私钥
    * 
    * @throws Exception
    * 
    */
   public static Map<String, String>  getKeys() 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();

      String publicKeyStr = getPublicKeyStr(publicKey);
      String privateKeyStr = getPrivateKeyStr(privateKey);

      Map<String, String> map = new HashMap<String, String>();
      map.put("publicKey", publicKeyStr);
      map.put("privateKey", privateKeyStr);
      
      System.out.println("公钥\r\n" + publicKeyStr);
      System.out.println("私钥\r\n" + privateKeyStr);
      return map;
   }

   /**
    * 使用模和指数生成RSA公钥
    * 注意：【此代码用了默认补位方式，为RSA/None/PKCS1Padding，不同JDK默认的补位方式可能不同，如Android默认是RSA
    * /None/NoPadding】
    * 
    * @param modulus
    *            模
    * @param exponent
    *            公钥指数
    * @return
    */
   public static RSAPublicKey getPublicKey(String modulus, String exponent) {
      try {
         BigInteger b1 = new BigInteger(modulus);
         BigInteger b2 = new BigInteger(exponent);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);
         return (RSAPublicKey) keyFactory.generatePublic(keySpec);
      } catch (Exception e) {
         e.printStackTrace();
         return null;
      }
   }

   /**
    * 使用模和指数生成RSA私钥
    * 注意：【此代码用了默认补位方式，为RSA/None/PKCS1Padding，不同JDK默认的补位方式可能不同，如Android默认是RSA
    * /None/NoPadding】
    * 
    * @param modulus
    *            模
    * @param exponent
    *            指数
    * @return
    */
   public static RSAPrivateKey getPrivateKey(String modulus, String exponent) {
      try {
         BigInteger b1 = new BigInteger(modulus);
         BigInteger b2 = new BigInteger(exponent);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);
         return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
      } catch (Exception e) {
         e.printStackTrace();
         return null;
      }
   }

   /**
    * 公钥加密
    * @param data
    * @param publicKey
    * @return
    * @throws Exception
    */
   public static String encryptByPublicKey(String data,String publicKey) throws Exception {
      return encryptByPublicKey(data, publicKey, "RSA/ECB/PKCS1Padding");
   }
   
   public static String encryptByPublicKeyByWx(String data,String publicKey) throws Exception {
      return encryptByPublicKey(data, publicKey, "RSA/ECB/OAEPWITHSHA-1ANDMGF1PADDING");
   }
   
   /**
    * 公钥加密
    * @param data
    * @param publicKey
    * @param fillMode 填充模式
    * @return
    * @throws Exception
    */
   public static String encryptByPublicKey(String data,String publicKey,String fillMode) throws Exception {
      byte[] dataByte = data.getBytes();
      byte[] keyBytes = base64.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 cipher = Cipher.getInstance(fillMode);
      cipher.init(Cipher.ENCRYPT_MODE, publicK);
      int inputLen = dataByte.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(dataByte, offSet, MAX_ENCRYPT_BLOCK);
         } else {
            cache = cipher.doFinal(dataByte, offSet, inputLen - offSet);
         }
         out.write(cache, 0, cache.length);
         i++;
         offSet = i * MAX_ENCRYPT_BLOCK;
      }
      byte[] encryptedData = out.toByteArray();
      out.close();
      return base64.encodeToString(encryptedData);
   }

   /**
    * 私钥解密
    * @param data
    * @param privateKey
    * @return
    * @throws Exception
    */
   public static String decryptByPrivateKey(String data,String privateKey) throws Exception {
      return decryptByPrivateKey(data, privateKey, "RSA/ECB/PKCS1Padding");
   }
   public static String decryptByPrivateKeyByWx(String data,String privateKey) throws Exception {
      return decryptByPrivateKey(data, privateKey, "RSA/ECB/OAEPWITHSHA-1ANDMGF1PADDING");
   }
   
   /**
    * 私钥解密
    * @param data
    * @param privateKey
    * @param fillMode 填充模式
    * @return
    * @throws Exception
    */
   public static String decryptByPrivateKey(String data,String privateKey,String fillMode) throws Exception {
      byte[] encryptedData = base64.decode(data);
      byte[] keyBytes = base64.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 cipher = Cipher.getInstance(fillMode);

      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 new String(decryptedData);
   }

   /**
    * 获取模数和密钥
    * @return
    */
   public static Map<String, String> getModulusAndKeys() {

      Map<String, String> map = new HashMap<String, String>();

      try {
         InputStream in = RSAUtils.class
               .getResourceAsStream("/rsa.properties");
         Properties prop = new Properties();
         prop.load(in);

         String modulus = prop.getProperty("modulus");
         String publicKey = prop.getProperty("publicKey");
         String privateKey = prop.getProperty("privateKey");

         in.close();

         map.put("modulus", modulus);
         map.put("publicKey", publicKey);
         map.put("privateKey", privateKey);

      } catch (IOException e) {
         e.printStackTrace();
      }

      return map;
   }

   /**
    * 从字符串中加载公钥
    * @param publicKeyStr
    *            公钥数据字符串
    * @throws Exception
    *             加载公钥时产生的异常
    */
   public static PublicKey loadPublicKey(String publicKeyStr) throws Exception {
      try {
         byte[] buffer = base64.decode(publicKeyStr);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
         return (RSAPublicKey) keyFactory.generatePublic(keySpec);
      } catch (NoSuchAlgorithmException e) {
         throw new Exception("无此算法");
      } catch (InvalidKeySpecException e) {
         throw new Exception("公钥非法");
      } catch (NullPointerException e) {
         throw new Exception("公钥数据为空");
      }
   }

   /**
    * 从字符串中加载私钥<br>
    * 加载时使用的是PKCS8EncodedKeySpec（PKCS#8编码的Key指令）。
    * @param privateKeyStr
    * @return
    * @throws Exception
    */
   public static PrivateKey loadPrivateKey(String privateKeyStr)
         throws Exception {
      try {
         byte[] buffer = base64.decode(privateKeyStr);
         // X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
      } catch (NoSuchAlgorithmException e) {
         throw new Exception("无此算法");
      } catch (InvalidKeySpecException e) {
         throw new Exception("私钥非法");
      } catch (NullPointerException e) {
         throw new Exception("私钥数据为空");
      }
   }

   public static String getPrivateKeyStr(PrivateKey privateKey)
         throws Exception {
      return new String(base64.encode(privateKey.getEncoded()));
   }

   public static String getPublicKeyStr(PublicKey publicKey) throws Exception {
      return new String(base64.encode(publicKey.getEncoded()));
   }

  
}