Android RSA加密代码

最新推荐文章于 2023-06-21 16:30:07 发布
最新推荐文章于 2023-06-21 16:30:07 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： 加密 文章标签： RSA分段加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24823401/article/details/84658460
版权

       RSA优缺点： RSA的安全性依赖于大数分解，小于1024位的N已经被证明是不安全的，而且由于RSA算法进行的都是大数计算，使得RSA最快的情况也比DES慢上倍，这是RSA最大的缺陷，因此通常只能用于加密少量数据或者加密密钥，但RSA仍然不失为一种高强度的算法。

       加密方法：

       

/**
 * @description:RSA公钥/私钥/签名工具包
 */
public class RSAUtils {

    /**
     * 加密算法RSA
     * /RSA/ECB/PKCS1Padding  RSA
     */
    public static final String KEY_ALGORITHM = "RSA/ECB/PKCS1Padding";

    /**
     * 签名算法
     */
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    /**
     * 获取公钥的key
     */
    //    public static final String PUBLIC_KEY ="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQClOB/q2myynP4c6cJq8tmWOcOw7N4fDhL9QeqWWYOERlnyl4ZAeuUIJpuP0FUHNESvlFIrxiYaYjVVKjMEcwbRUJP8EMWtO4dNRrbxJFKPXpCk2fF82WBxt81dLhgvYPX77EEcqzGNMrTRX6/EuOEVawKgBOUywtCNe2ZijSGccwIDAQAB";
//    public static final String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC7VEIlt7cbOC61b0tLHS1OTx5RixSNewAhUFH10h63H2Xp27SKy039YeTb337TxPuErP0+DBGmXRLyyp64AqUH5aaVHn8geOsoUEjKBv78ics1IU1c5mZxzsgpnCVmkq7uEFauDsjKs5Bbf+RviX4te4WPRoGHX4txdEK+7QMeUQIDAQAB";
    public static final String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC7VEIlt7cbOC61b0tLHS1OTx5RixSNewAhUFH10h63H2Xp27SKy039YeTb337TxPuErP0+DBGmXRLyyp64AqUH5aaVHn8geOsoUEjKBv78ics1IU1c5mZxzsgpnCVmkq7uEFauDsjKs5Bbf+RviX4te4WPRoGHX4txdEK+7QMeUQIDAQAB";
    /**
     * 获取私钥的key
     */
    //    public static final String PRIVATE_KEY = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKU4H+rabLKc/hzpwmry2ZY5w7Ds3h8OEv1B6pZZg4RGWfKXhkB65Qgmm4/QVQc0RK+UUivGJhpiNVUqMwRzBtFQk/wQxa07h01GtvEkUo9ekKTZ8XzZYHG3zV0uGC9g9fvsQRyrMY0ytNFfr8S44RVrAqAE5TLC0I17ZmKNIZxzAgMBAAECgYBlmLmnxWEKBJgOV4CCG4vJYQQBC+ca2aC7s4j5o1nIQSqWjq6zf97OwE7whH+EypNiFKbi3BoaJ0H8eNKebc1Gc6lQz3d7EA/kT4Z+OQnj5PTaAC7CjewFUb2+Gbt0Rppd3Z6rwBWnWX4xXANF1q8FO5s8skyhaJQuafp3XEOAgQJBAN8/xkZfYbHOs+AhOnvYrfCptXmM9hLYrtCuZvV+OS2G5h2nfx53XdcfNN04B4OBz2RmvyRGeEhePHYY2aJBEDECQQC9dQK89MZrvp5vfFgCzk9onLiC0U/wCHCDpiQWpQCHjDoQ/dJOvqkgClL8dFKNfJI2RiUkjnFeIV5SUDG+7RHjAkBht7qD5xAOEhntyt2cg/Vu1/nVIHw9N5cdRJlQb1V7tgZXiI89uKXcmY48HmA7kcBDhC26JRZVJtp0HuB0AuKhAkASebGtqZUb9rfOmWqfw2y8/+OCZlUMTFZkkDQevTKDBWq4M3hp02/8vuT+130hbQ95GXgPy5BEpK5lCor/WnEPAkAUfUhXXUIJ+W2rbabcOc2bv5Hpx6DaALniyL5fQIrFuZSd0MeUdtmzdLi5xezjUNuiXub6s5io9TxrwY5I1osZ";
//    public static final String PRIVATE_KEY = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKU4H+rabLKc/hzpwmry2ZY5w7Ds3h8OEv1B6pZZg4RGWfKXhkB65Qgmm4/QVQc0RK+UUivGJhpiNVUqMwRzBtFQk/wQxa07h01GtvEkUo9ekKTZ8XzZYHG3zV0uGC9g9fvsQRyrMY0ytNFfr8S44RVrAqAE5TLC0I17ZmKNIZxzAgMBAAECgYBlmLmnxWEKBJgOV4CCG4vJYQQBC+ca2aC7s4j5o1nIQSqWjq6zf97OwE7whH+EypNiFKbi3BoaJ0H8eNKebc1Gc6lQz3d7EA/kT4Z+OQnj5PTaAC7CjewFUb2+Gbt0Rppd3Z6rwBWnWX4xXANF1q8FO5s8skyhaJQuafp3XEOAgQJBAN8/xkZfYbHOs+AhOnvYrfCptXmM9hLYrtCuZvV+OS2G5h2nfx53XdcfNN04B4OBz2RmvyRGeEhePHYY2aJBEDECQQC9dQK89MZrvp5vfFgCzk9onLiC0U/wCHCDpiQWpQCHjDoQ/dJOvqkgClL8dFKNfJI2RiUkjnFeIV5SUDG+7RHjAkBht7qD5xAOEhntyt2cg/Vu1/nVIHw9N5cdRJlQb1V7tgZXiI89uKXcmY48HmA7kcBDhC26JRZVJtp0HuB0AuKhAkASebGtqZUb9rfOmWqfw2y8/+OCZlUMTFZkkDQevTKDBWq4M3hp02/8vuT+130hbQ95GXgPy5BEpK5lCor/WnEPAkAUfUhXXUIJ+W2rbabcOc2bv5Hpx6DaALniyL5fQIrFuZSd0MeUdtmzdLi5xezjUNuiXub6s5io9TxrwY5I1osZ";
//    public static final String PRIVATE_KEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAL2Qnu/XXW6cE4T5WH6Ycb1nvEqgBwgeEL7xC7/SIq4rsBQj8XOWv793JCH56UacP0+6Qd65pXgRaXi/MS2bClweB1IgfnRG/a3X7kOMMOBVe7A/JXDq+sH9xXqehg4u6KD4SkQaASARHPeKkTAyaPEt1A/JTJ1N4GKRo5w3df7DAgMBAAECgYB+bjxy/pLkONiT8bHiDU6e4tckdoL6GQNWNnJ9p2tV+vFfHXHmg/6zdoT03DeHzqIzTKiuIeeIoyRTUkE8h5FqJECwP5VFBVKN26SbLJ3prtQVbaABUG4bZiI9b49r9alJIyIOpHFw9VxOl51782uAzf30AeQvjbyxAlA48v/oUQJBAO0JyQoITpACMytOWoNJbhOK6sPWfAHQcSFLmEmdGUH4H1o3zOHkLVs4Gz8l6QRNEzpXXDsaOqmuPUkJkad5t0cCQQDMuqXpye5RXqCsBkg2SayuNdtFRu1pXKlqFWJctMmOOl4NeQ3vShJ/Fyuqi2MxlEr45PO/KIyWj1Kb9cBHkTKlAkB1K/0g5HJRZYT9x0Ge3FF5f5YFMKUkEHGbz857tRijL4/v/N1eXHi/OsDdOlQxOBhlIoIJBTIyZlsNG5nQe65JAkBcbQtIP6zCuXjKEM/7CknWIGRMo1e9UGL/jIXqmofAGSOq63LaC9PL4pcJGIKAuJUcRqiwLUtDEZNW65yR8sAtAkEAgDEoCgYn8jfo+SV5Vk0fGWZMjGfEP5I47G8Be294M56lBGFqpp5xsFOch+guNTcSC9l5Bh8/dzpvoyC172mGcQ==";
    public static final String PRIVATE_KEY = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBALtUQiW3txs4LrVvS0sdLU5PHlGLFI17ACFQUfXSHrcfZenbtIrLTf1h5NvfftPE+4Ss/T4MEaZdEvLKnrgCpQflppUefyB46yhQSMoG/vyJyzUhTVzmZnHOyCmcJWaSru4QVq4OyMqzkFt/5G+Jfi17hY9GgYdfi3F0Qr7tAx5RAgMBAAECgYEAufUFiO2bbgDSlTc61gDLtb3iie33ZA7i7S8PfWetJ/maMJDx4wm4jLw99GojO1OCno0fAxX1+2DPa4bqEh5F9SMjybuhC+RnJwzy0iqFHCbh6IrUSwa36Sh1FZS0GnD2v7751zBWCo5yxNvGZ4d/wig8HfW4sb69tOnunYD/70ECQQDbAwMqC9DXhHn+MSfxyxvkRFjUqzc69Xclrym0qygR18jsxH85L/7QBUVeIuYynrrpamgWgymPO/dCVcIDzwn5AkEA2vdyBUgGHWWk7Wpiznc/ByFtFMvV0QRZhzxmGejscz6D2AxJIqG0qpo4I9guZ9LgZJm71krff4bfMEFVSvWNGQJAMDPBhoeDN2vYzbFT8Uuan+rLAkOMrFVKG+kpbLIe545ukm3M8nE1y+LdGZLkx09YI/dfYVUM2JGCIf9t7BitQQJAPk0/lP8cNksQdTja6jIFreq11b/1k2YwbwkhZ+fdNyEndFZyjLcD57K/nHtLIOFgVV9kkaF2HBvs7xb3xL8/KQJBALNCcIwLEWdYdMu+HaGDWZ4W5Yz9lZI5NHVFA8WD2UNfmmZasNzsl1FuBrjq7ohoZqlOtGdOARdBIakmL/ZY//w=";
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

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

    /**
     * 私钥
     */
    public static RSAPrivateKey PRIVATE_KEY_RSA;

    /**
     * 公钥
     */
    public static RSAPublicKey PUBLIC_KEY_RSA;

    /**
     * 生成密钥对(公钥和私钥)
     */
    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<>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    /**
     * 用私钥对信息生成数字签名
     */
    public static String sign(String dataStr) throws Exception {
        byte[] data = new BASE64Decoder().decodeBuffer(dataStr);
        RSAUtils.loadPrivateKey(PRIVATE_KEY);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(PRIVATE_KEY_RSA);
        signature.update(data);
        return new BASE64Encoder().encodeBuffer(signature.sign());
    }

    /**
     * 校验数字签名
     *
     * @param sign 数字签名
     */
    public static boolean verify(String dataStr, String sign) throws Exception {
        byte[] data = new BASE64Decoder().decodeBuffer(dataStr);
        RSAUtils.loadPublicKey(PUBLIC_KEY);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(PUBLIC_KEY_RSA);
        signature.update(data);
        return signature.verify(new BASE64Decoder().decodeBuffer(sign));
    }

    /**
     * 私钥解密
     *
     * @param encryptedData 已加密数据
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData) throws Exception {
        if (PRIVATE_KEY_RSA == null) {
            throw new Exception("解密私钥为空，请设置");
        }
        Cipher cipher = null;
        try {
            cipher = Cipher.getInstance(KEY_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, PRIVATE_KEY_RSA);
            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;
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此解密算法");
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
            return null;
        } catch (InvalidKeyException e) {
            throw new Exception("解密私钥非法,请检查");
        } catch (IllegalBlockSizeException e) {
            throw new Exception("密文长度非法");
        } catch (BadPaddingException e) {
            throw new Exception("密文数据已损坏==");
        }
    }

    /**
     * 公钥解密
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData) throws Exception {
        if (PUBLIC_KEY_RSA == null) {
            throw new Exception("解密公钥为空，请设置");
        }
        Cipher cipher = null;
        try {
            cipher = Cipher.getInstance(KEY_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, PUBLIC_KEY_RSA);
            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;
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此解密算法");
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
            return null;
        } catch (InvalidKeyException e) {
            throw new Exception("解密公钥非法,请检查");
        } catch (IllegalBlockSizeException e) {
            throw new Exception("密文长度非法");
        } catch (BadPaddingException e) {
            throw new Exception("密文数据已损坏");
        }
    }

    /**
     * 公钥加密
     *
     * @param data 源数据
     */
    public static byte[] encryptByPublicKey(byte[] data) throws Exception {
        if (PUBLIC_KEY_RSA == null) {
            throw new Exception("加密公钥为空，请设置");
        }
        Cipher cipher = null;
        try {
            cipher = Cipher.getInstance(KEY_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, PUBLIC_KEY_RSA);
            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;
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此加密算法");
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
            return null;
        } catch (InvalidKeyException e) {
            throw new Exception("加密公钥非法,请检查");
        } catch (IllegalBlockSizeException e) {
            throw new Exception("明文长度非法");
        } catch (BadPaddingException e) {
            throw new Exception("明文数据已损坏");
        }
    }

    /**
     * 私钥加密
     *
     * @param data 源数据
     */
    public static byte[] encryptByPrivateKey(byte[] data) throws Exception {
        if (PRIVATE_KEY_RSA == null) {
            throw new Exception("加密私钥为空，请设置");
        }
        Cipher cipher = null;
        try {
            cipher = Cipher.getInstance(KEY_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, PRIVATE_KEY_RSA);
            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;
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此加密算法");
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
            return null;
        } catch (InvalidKeyException e) {
            throw new Exception("加密私钥非法,请检查");
        } catch (IllegalBlockSizeException e) {
            throw new Exception("明文长度非法");
        } catch (BadPaddingException e) {
            throw new Exception("明文数据已损坏");
        }
    }

    /**
     * 获取私钥
     *
     * @param keyMap 密钥对
     */
    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return new BASE64Encoder().encodeBuffer(key.getEncoded());
    }

    /**
     * 获取公钥
     *
     * @param keyMap 密钥对
     */
    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return new BASE64Encoder().encodeBuffer(key.getEncoded());
    }

    /**
     * 从字符串中加载公钥
     *
     * @param publicKeyStr 公钥数据字符串
     * @throws Exception 加载公钥时产生的异常
     */
    public static void loadPublicKey(String publicKeyStr) throws Exception {
        try {
            BASE64Decoder base64Decoder = new BASE64Decoder();
            byte[] buffer = base64Decoder.decodeBuffer(publicKeyStr);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
            RSAUtils.PUBLIC_KEY_RSA = (RSAPublicKey) keyFactory.generatePublic(keySpec);
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此算法");
        } catch (InvalidKeySpecException e) {
            throw new Exception("公钥非法");
        } catch (NullPointerException e) {
            throw new Exception("公钥数据为空");
        } catch (Exception e) {
            throw new Exception("所有---" + e.getLocalizedMessage());
        }
    }

    /**
     * 从字符串中加载私钥
     *
     * @throws Exception 加载私钥时产生的异常
     */
    public static void loadPrivateKey(String privateKeyStr) throws Exception {
        try {
            BASE64Decoder base64Decoder = new BASE64Decoder();
            byte[] buffer = base64Decoder.decodeBuffer(privateKeyStr);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            RSAUtils.PRIVATE_KEY_RSA = (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此算法");
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
            throw new Exception("私钥非法");
        } catch (NullPointerException e) {
            throw new Exception("私钥数据为空");
        } catch (Exception e) {
            throw new Exception("所有-----" + e.getLocalizedMessage());
        }
    }

    /**
     * 私钥解密后的字符串
     */
    public static String decryptPrivateWithBase64(String base64String) throws Exception {
        RSAUtils.loadPrivateKey(PRIVATE_KEY);
        byte[] binaryData = decryptByPrivateKey(new BASE64Decoder().decodeBuffer(base64String));
        String string = new String(binaryData);
        return string;
    }

    /**
     * 公钥加密后的字符串
     */
    public static String encryptPublicWithBase64(String string) throws Exception {
        //获取公钥
        RSAUtils.loadPublicKey(PUBLIC_KEY);
        //字符串进行加密
        byte[] binaryData = encryptByPublicKey(string.getBytes());
        //        LogUtil.e("RSA:" + new String(binaryData));
        //结果进行base64转换
        String base64String = new BASE64Encoder().encodeBuffer(binaryData);
        return base64String;
    }

    /**
     * 公钥解密后的字符串
     */
    public static String decryptPublicWithBase64(String base64String) throws Exception {
        RSAUtils.loadPublicKey(PUBLIC_KEY);
        byte[] binaryData = decryptByPublicKey(new BASE64Decoder().decodeBuffer(base64String));
        String string = new String(binaryData);
        return string;
    }

    /**
     * 私钥加密后的字符串
     */
    public static String encryptPrivateWithBase64(String string) throws Exception {
        RSAUtils.loadPrivateKey(PRIVATE_KEY);
        byte[] binaryData = encryptByPrivateKey(string.getBytes());
        String base64String = new BASE64Encoder().encodeBuffer(binaryData);
        return base64String;
    }

    public static void main(String args[]) throws Exception {
        String v = "{\"id\":\"0dd2242adf9d47eeb8194a887812c48e\"}";
//        mbBlfQRjg03Hv0OW5RmD4kyLjHfzNjbuxW1NYlwSR/vA8d7tYl6cLP88Jfaj595OXJuToqBNrJ9uO8Ey54kfZEDPMcjt++3NVHGSix8aJoPGqDgKwuGqmhmnYUx5o0RTRUq6nGQT2QlxMN/BSgm86yDMZ5C2aqMAETox/lJqe1E=
        String str1 = RSAUtils.encryptPublicWithBase64(v);
//        String str1 = "oaI7FMlh1ExJSC0WQmOTcArbA2Vk4sRxH7TmXWY/lbI9LCAXdFWY91f9tuJq0BwDlGm1dZZDrZOacZVfhqPGwnRumlzrW8H8i2EGXPiyyn8lpWhdZzmDMrWcCkqEdoyvRCHz8jk2wWTV58SvoQjFIvH2XpdvCmCcT8ZcwBiEGfY=";
        String str2 = RSAUtils.decryptPrivateWithBase64(str1);
    }
}

 

        RSA分段加密资源压缩包地址：https://download.csdn.net/my

直到世界尽头szk
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
android RSA2加密解密
09-24
android RSA2加密解密，里边提供两个方法，一个是生成公有私有秘钥加密解密，另一个是加密解密
android RSA 使用公钥加密里的坑
zhuawalibai的博客
12-01 5483
RAS算法使用公钥加密代码： /** * 公钥加密 */ public static String encryptByPublicKey(String data, String key) throws GeneralSecurityException { byte[] keyBytes = Base64.decode(key, NO_WRAP); X509
Android RSA加密解密
qq_43685172的博客
02-19 2346
Android RSA加密解密
Android RSA和AES对称加密工具
最新发布
吕氏春秋i
06-21 1137
最近开发 用到数据加密 研究后要用RSA和AES对称加密工具以前没搞过 记录一下心酸过程。
RSA加密及在Android中的使用
tlaqcxb的博客
08-19 3969
1. RSA简介 RSA是一种常用的非对称加密算法，所谓非对称加密是指使用一对密钥（公钥和私钥）进行加密和解密，公钥人人都可以获得，用于加密数据，私钥保存在服务器中，用于解密数据。加密解密过程如下： 使用RSA进行加密解密，其优点是非常不容易破解，缺点是和对称加密（如AES）相比，加密速度较慢。因此，实际使用中，常常将对称加密和非对称加密结合使用，即使用非对称加密协商对称加密的密钥，使用对称加密密钥加密传输内容。 2. 在Android中使用RSA Java中已内置RSA支持，示例代码如下： 2.1 生成
关于非对称加密算法在不同系统间对接时的使用要点
孙雪峰
06-15 658
对方密钥的使用 不同加密算法的库生成的密钥的格式不同，拿到别人的密钥的时候，需要去掉格式，只保留密钥字符串，然后按照自己的格式拼接起来，再使用。 加密结果的网络传输 加密后的结果可能非法字符，在网络传输中可能造成数据丢失，这是可以使用可逆的编码方式处理加密后的字符串，例如base64编码。需要注意的是，解密的时候不要忘了通知对方使用同样的编码方式解码，再解密 ...
java cfb加密_漫谈Java加密技术(四)
weixin_35223524的博客
03-06 378
公钥:MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCYU/+I0+z1aBl5X6DUUOHQ7FZpmBSDbKTtx89JEcB64jFCkunELT8qiKly7fzEqD03g8ALlu5XvX+bBqHFy7YPJJP0ekE2X3wjUnh2NxlqpH3/B/xm1ZdSlCwDIkbijhBVDjA/bu5BObhZqQmDwIxlQInL9oVz+...
常用的RSA+BASE64 加密解密
m0_67069473的博客
06-13 1563
@Slf4j public class RSAUtil { private static String publicKey="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCJ6AEtEdfDt9/2CnHc8JZsnMUBM2rkuNpA0jV++1A8bZgfXliS4HK2hJbeWWH1CW3xMnQQqq57/Nuqdt7swNiSgToSCz9SX+S2Lsj6eRPXH33l+MBjvTRRSJDRx1ydHTS5219YoDVDqJLAD
RSA 公钥解密后置处理器
Radioman-lhq的博客
08-12 1105
一.RSA 公钥解密后置处理器截图： 二.RSA 公钥解密后置处理器使用说明： 公钥：RSA解密公钥； 填充算法：目前支持PKCS1 OAEP PADDING、PKCS1 PADDING、NO PADDING三种填充算法； 目标变量名：如上图RSA公钥解密结果存放到rsaPublic变量中，使用时，以${rsaPublic}这种形式引用即可。 三.示例 场景1：密文存储在JMeter变量rsaP...
openssl RSA公钥问题
走在路上
07-07 309
嵌入式openssl公钥获取模式和指数
Android RSA加密jar包
11-01
Android RSA加密jar包，提供RSA加密与解密的java类，便于开发使用。
Android，java实现RSA加密
07-23
RSA加密算法，是一种“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息...本资源是通过Android、java实现的RSA加密的例子，可供大家参考学习。
Android使用RSA加密和解密的示例代码
08-29
本篇文章主要介绍了Android使用RSA加密和解密的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
RSADemo:Android RSA加密解密
05-09
RSA是目前最有影响力的公钥加密算法，该算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困 难，因此可以将乘积公开作为加密密钥，即公钥，而两个大素数组合成私钥...
Android数据加密之Rsa加密
01-05
 •Android数据加密之Rsa加密  •Android数据加密之Aes加密  •Android数据加密之Des加密  •Android数据加密之MD5加密  •Android数据加密之Base64编码算法  •Android数据加密之SHA安全散列算法  什么是Rsa...
android rsa 私钥加密解密,Android网络数据传输安全——实现RSA公钥加密私钥解密...
weixin_29233333的博客
06-03 1200
一，整体流程后台生成一个RSA秘钥对，包括公钥和私钥后台将公钥字符串下发给客户端，然后客户端用此公钥生成一个RSAPublicKey对象，再将手机号密码等数据用此对象加密，客户端将加密的数据发送给后台，后台将加密的数据用私钥解密。image.png二，公私钥你可以利用工具一键生成密钥对访问支付宝官网，进入如下页面，该页面的URL：https://docs.open.alipay.com/291/1...
Android数据加密之Rsa/MD5/Aes/Des加密算法归纳总结
心情舒畅
01-25 2061
加密算法 1.加密算法通常分为对称性加密算法和非对称性加密算法：对于对称性加密算法，信息接收双方都需事先知道密匙和加解密算法且其密匙是相同的，之后便是对数据进行 加解密了。非对称算法与之不同，发送双方A,B事先均生成一堆密匙，然后A将自己的公有密匙发送给B，B将自己的公有密匙发送给A，如果A要给B发送消息，则先需要用B的公有密匙进行消息加密，然后发送给B端，此时B端再用自己的私有密匙进行消息解密...
android -------- RSA加密解密算法
weixin_30423977的博客
08-12 93
RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用 RSA公开密钥密码体制。所谓的公开密钥密码体制就是使用不同的加密密钥与解密密钥，是一种“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制 网上写法也有很多种，分享一种参考 import java.math.BigInteger; import java.security.KeyFactor...
Android RSA加密解密
打字打不快的屌丝
09-17 1506
转载自： http://blog.csdn.net/bbld_/article/details/38777491
写出android中进行rsa加密的代码
02-22
以下是实现RSA加密的Android代码：// Generate an RSA keyKeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); kpg.initialize(2048); KeyPair kp = kpg.genKeyPair();// Get the public and private ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

直到世界尽头szk

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值