Java Web项目RSA加密

最近做的一个项目，服务器为Java，采用SSH框架，客户端为Android和IOS。当用户登录时，从客户端向服务器提交用户名和密码。这就存在一个问题，如果数据包在网络上被其他人截取了，密码就有可能泄露。

可以采用Base64对密码编码，但是Base64要进行解码是很容易的事。

另一种方法是对密码进行MD5加密，MD5是不可逆的，只能加密不能解密。但是其他人截取了密码的MD5字符串以后，可以原封不动的将MD5加密后的字符串提交给服务器，服务器肯定会判断这是正确的密码，这样还是可以登录进去。

解决的方法就只能采用加密算法了。加密算法分为对称加密和非对称加密。对称加密算法，加密和解密使用相同的密钥，密钥在网络传输的过程中有可能被截取，所以不是很安全。非对称加密，使用公钥加密，只能使用私钥解密，公钥是公开的，私钥是不公开的。即使在传递的过程中，公钥被其他人获取了也无所谓，因为公钥是用来加密的，只有私钥才能解密，而私钥是不会传递的，也就不可能被其他人获取。

非对称加密最常用的就是RSA算法，RSA算法是由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的，取了他们姓的第一个字母来命名。RSA算法的原理就不讲了。密钥长度为768的RSA算法有可能被破解，密钥长度为1024的RSA算法还没有被破解，所以可以认为密钥长度为1024的RSA算法是比较安全的。但是RSA算法的计算量大，一般只用于关键信息的加密，如密码、对称加密算法的密钥等。在我们的项目中，就使用RSA算法对用户密码进行加密。具体的步骤如下：

1. 客户端向服务器申请密钥；

2. 服务器接收到客户端的申请以后，生成一对密钥，将公钥发给客户端，私钥自己保存；

3. 客户端接收到公钥以后，使用公钥对密码加密，然后将密文发给服务器；

4. 服务器接收到密文以后，使用私钥解密，判断是否是正确的密码。

下面是关键代码。

生成密钥和加密、解密的代码：

/**
     * 生成公钥和私钥
     * @throws NoSuchAlgorithmException
     *
     */
    public static HashMap<String, Object> getKeys() throws NoSuchAlgorithmException{
        HashMap<String, Object> map = new HashMap<String, Object>();
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        map.put("public", publicKey);
        map.put("private", privateKey);
        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("RSA");
            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("RSA");
            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, RSAPublicKey publicKey)
            throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        // 模长
        int key_len = publicKey.getModulus().bitLength() / 8;
        // 加密数据长度 <= 模长-11
        String[] datas = splitString(data, key_len - 11);
        String mi = "";
        //如果明文长度大于模长-11则要分组加密
        for (String s : datas) {
            mi += bcd2Str(cipher.doFinal(s.getBytes()));
        }
        return mi;
    }  

    /**
     * 私钥解密
     *
     * @param data
     * @param privateKey
     * @return
     * @throws Exception
     */
    public static String decryptByPrivateKey(String data, RSAPrivateKey privateKey)
            throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/NoPadding");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        //模长
        int key_len = privateKey.getModulus().bitLength() / 8;
        byte[] bytes = data.getBytes();
        byte[] bcd = ASCII_To_BCD(bytes, bytes.length);
        System.err.println(bcd.length);
        //如果密文长度大于模长则要分组解密
        String ming = "";
        byte[][] arrays = splitArray(bcd, key_len);
        for(byte[] arr : arrays){
            ming += new String(cipher.doFinal(arr));
        }
        return ming;
    } 

服务器收到客户端的请求时，生成一对密钥：

                HashMap<String, Object> mymap = RSAUtils.getKeys();
                // 生成公钥和私钥
                RSAPublicKey publicKey = (RSAPublicKey) mymap.get("public");
                RSAPrivateKey privateKey = (RSAPrivateKey) mymap.get("private");
                // 模
                String modulus = publicKey.getModulus().toString();
                // 公钥指数
                String public_exponent = publicKey.getPublicExponent().toString();
                // 私钥指数
                String private_exponent = privateKey.getPrivateExponent().toString();
                // 使用模和指数生成公钥和私钥
                RSAPublicKey pubKey = RSAUtils.getPublicKey(modulus, public_exponent);
                RSAPrivateKey priKey = RSAUtils.getPrivateKey(modulus, private_exponent);

将其中的模和私钥指数发给客户端，客户端收到以后，使用getPublicKey(String modulus, String exponent)生成公钥，使用公钥对密码加密，然后发给服务器。服务器收到密文以后，使用decryptByPrivateKey(String data, RSAPrivateKey privateKey)解密，获得密码明文，然后就可以判断密码是否正确。