加密与解密

对称加密与非对称加密

对称加密：加密和解密使用同一个秘钥，被黑客拦截不安全。DES，AES，3DES等等

非对称加密：加密和解密使用不同的秘钥，一把作为公开的公钥，另一把作为私钥。公钥加密的信息，只有私钥才能解密。私钥加密的信息，只有公钥才能解密。非常安全，黑客拦截也没用，因为私钥未公开。RSA，ECC等。

两者在C/S模型的用法通常是：

1. 服务端计算出一对秘钥pub/pri。将私钥保密，将公钥公开。

2. 客户端请求服务端时，拿到服务端的公钥pub。

3. 客户端通过AES计算出一个对称加密的秘钥X（更安全的是用非对称加密的公钥）。 然后使用pub将X进行加密。

4. 客户端将加密后的密文发送给服务端。服务端通过pri解密获得X。

5. 然后两边的通讯内容就通过对称密钥X以对称加密算法来加解密。

RSA生成秘钥对

public static Map<String, String> genKeyPair() {
        // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
        KeyPairGenerator keyPairGen;
        try {
            keyPairGen = KeyPairGenerator.getInstance(RSA_ALGORITHM);
            // 初始化密钥对生成器，密钥大小为96-1024位
            keyPairGen.initialize(1024, new SecureRandom());
            // 生成一个密钥对，保存在keyPair中
            KeyPair keyPair = keyPairGen.generateKeyPair();
            // 得到私钥
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            // 得到公钥
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            String publicKeyString = new String(Base64.encodeBase64(publicKey.getEncoded()));
            // 得到私钥字符串
            String privateKeyString = new String(Base64.encodeBase64((privateKey.getEncoded())));
            // 将公钥和私钥保存到Map
            Map<String, String> keyMap = new HashMap<>();
            keyMap.put("public", publicKeyString);
            keyMap.put("private", privateKeyString);
            return keyMap;
        } catch (NoSuchAlgorithmException e) {
            logger.error("无此算法", e);
            throw new PcAuthException(ExceptionEnum.ENCRYPTION_EXCEPTION);
        }
    }

RSA加密和解密

public static String encrypt(String str, String publicKey) throws Exception {
        // base64编码的公钥
        byte[] decoded = Base64.decodeBase64(publicKey);
        RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance(“RSA”)
                .generatePublic(new X509EncodedKeySpec(decoded));
        // RSA加密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        return Base64.encodeBase64String(cipher.doFinal(str.getBytes(CHARSET)));
    }

public static String decrypt(String str, String privateKey) {
        // 64位解码加密后的字符串
        byte[] inputByte = new byte[0];
        try {
            inputByte = Base64.decodeBase64(str.getBytes(CHARSET));
        } catch (UnsupportedEncodingException e) {
            logger.error(e.getMessage());
            throw new PcAuthException(ExceptionEnum.ENCRYPTION_EXCEPTION);
        }
        // base64编码的私钥
        byte[] decoded = Base64.decodeBase64(privateKey);
        RSAPrivateKey priKey = null;
        try {
            priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA")
                    .generatePrivate(new PKCS8EncodedKeySpec(decoded));
        } catch (InvalidKeySpecException | NoSuchAlgorithmException e) {
            logger.error(e.getMessage());
            throw new PcAuthException(ExceptionEnum.ENCRYPTION_EXCEPTION);
        }
        // RSA解密
        Cipher cipher = null;
        try {
            cipher = Cipher.getInstance(“RSA");
        } catch (NoSuchAlgorithmException | NoSuchPaddingException e) {
            logger.error(e.getMessage());
            throw new PcAuthException(ExceptionEnum.ENCRYPTION_EXCEPTION);
        }
        try {
            cipher.init(Cipher.DECRYPT_MODE, priKey);
        } catch (InvalidKeyException e) {
            logger.error(e.getMessage());
            throw new PcAuthException(ExceptionEnum.ENCRYPTION_EXCEPTION);
        }
        try {
            return new String(cipher.doFinal(inputByte));
        } catch (IllegalBlockSizeException | BadPaddingException e) {
            logger.error(e.getMessage());
            throw new PcAuthException(ExceptionEnum.ENCRYPTION_EXCEPTION);
        }
    }