Android RSA加解密

最新推荐文章于 2024-07-21 11:25:24 发布
最新推荐文章于 2024-07-21 11:25:24 发布
阅读量2k 收藏 3
点赞数 2
分类专栏： 胖虎的逆向之路 文章标签： android rsa 加解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a_Chaon/article/details/71271494
版权

如下代码: 

ublic class RSAUtils {


        private static String RSA = "RSA";

        /**
         * 随机生成RSA密钥对(默认密钥长度为1024)
         *
         * @return
         */
    public static KeyPair generateRSAKeyPair()
    {
        return generateRSAKeyPair(1024);
    }

    /**
     * 随机生成RSA密钥对
     *
     * @param keyLength
     *            密钥长度，范围：512～2048<br>
     *            一般1024
     * @return
     */
    public static KeyPair generateRSAKeyPair(int keyLength)
    {
        try
        {
            KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);
            kpg.initialize(keyLength);
            return kpg.genKeyPair();
        } catch (NoSuchAlgorithmException e)
        {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 用公钥加密 <br>
     * 每次加密的字节数，不能超过密钥的长度值减去11
     *
     * @param data 需加密数据的byte数据
     * @param PublicKey  公钥
     * @return 加密后的byte型数据
     */
    public static byte[] encryptData(byte[] data, PublicKey publicKey)
    {
        try
        {
            Cipher cipher = Cipher.getInstance(RSA);
            // 编码前设定编码方式及密钥
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            // 传入编码数据并返回编码结果
            return cipher.doFinal(data);
        } catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 用私钥解密
     *
     * @param encryptedData
     *            经过encryptedData()加密返回的byte数据
     * @param privateKey
     *            私钥
     * @return
     */
    public static byte[] decryptData(byte[] encryptedData, PrivateKey privateKey)
    {
        try
        {
            Cipher cipher = Cipher.getInstance(RSA);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return cipher.doFinal(encryptedData);
        } catch (Exception e)
        {
            return null;
        }
    }

    /**
     * 通过公钥byte[](publicKey.getEncoded())将公钥还原，适用于RSA算法
     *
     * @param keyBytes
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    public static PublicKey getPublicKey(byte[] keyBytes) throws Exception {
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }

    /**
     * 通过私钥byte[]将公钥还原，适用于RSA算法
     *
     * @param keyBytes
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    public static PrivateKey getPrivateKey(byte[] keyBytes) throws NoSuchAlgorithmException,
            InvalidKeySpecException
    {
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }

    /**
     * 使用N、e值还原公钥
     *
     * @param modulus
     * @param publicExponent
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    public static PublicKey getPublicKey(String modulus, String publicExponent)
            throws NoSuchAlgorithmException, InvalidKeySpecException
    {
        BigInteger bigIntModulus = new BigInteger(modulus);
        BigInteger bigIntPrivateExponent = new BigInteger(publicExponent);
        RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }

    /**
     * 使用N、d值还原私钥
     *
     * @param modulus
     * @param privateExponent
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    public static PrivateKey getPrivateKey(String modulus, String privateExponent)
            throws NoSuchAlgorithmException, InvalidKeySpecException
    {
        BigInteger bigIntModulus = new BigInteger(modulus);
        BigInteger bigIntPrivateExponent = new BigInteger(privateExponent);
        RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }

    /**
     * 从字符串中加载公钥
     *
     * @param publicKeyStr
     *            公钥数据字符串
     * @throws Exception
     *             加载公钥时产生的异常
     */
    public static PublicKey loadPublicKey(String publicKeyStr) throws Exception
    {
        try
        {
            byte[] buffer = Base64Utils.decode(publicKeyStr);
            KeyFactory keyFactory = KeyFactory.getInstance(RSA);
            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 = Base64Utils.decode(privateKeyStr);
            // X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
            KeyFactory keyFactory = KeyFactory.getInstance(RSA);
            return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
        } catch (NoSuchAlgorithmException e)
        {
            throw new Exception("无此算法");
        } catch (InvalidKeySpecException e)
        {
            throw new Exception("私钥非法");
        } catch (NullPointerException e)
        {
            throw new Exception("私钥数据为空");
        }
    }

    /**
     * 从文件中输入流中加载公钥
     *
     * @param in
     *            公钥输入流
     * @throws Exception
     *             加载公钥时产生的异常
     */
    public static PublicKey loadPublicKey(InputStream in) throws Exception
    {
        try
        {
            return loadPublicKey(readKey(in));
        } catch (IOException e)
        {
            throw new Exception("公钥数据流读取错误");
        } catch (NullPointerException e)
        {
            throw new Exception("公钥输入流为空");
        }
    }

    /**
     * 从文件中加载私钥
     *
     * @return 是否成功
     * @throws Exception
     */
    public static PrivateKey loadPrivateKey(InputStream in) throws Exception
    {
        try
        {
            return loadPrivateKey(readKey(in));
        } catch (IOException e)
        {
            throw new Exception("私钥数据读取错误");
        } catch (NullPointerException e)
        {
            throw new Exception("私钥输入流为空");
        }
    }

    /**
     * 读取密钥信息
     *
     * @param in
     * @return
     * @throws IOException
     */
    private static String readKey(InputStream in) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(in));
        String readLine = null;
        StringBuilder sb = new StringBuilder();
        while ((readLine = br.readLine()) != null)
        {
            if (readLine.charAt(0) == '-')
            {
                continue;
            } else
            {
                sb.append(readLine);
                sb.append('\r');
            }
        }

        return sb.toString();
    }

    /**
     * 打印公钥信息
     *
     * @param publicKey
     */
    public static void printPublicKeyInfo(PublicKey publicKey)
    {
        RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;
        System.out.println("----------RSAPublicKey----------");
        System.out.println("Modulus.length=" + rsaPublicKey.getModulus().bitLength());
        System.out.println("Modulus=" + rsaPublicKey.getModulus().toString());
        System.out.println("PublicExponent.length=" + rsaPublicKey.getPublicExponent().bitLength());
        System.out.println("PublicExponent=" + rsaPublicKey.getPublicExponent().toString());
    }

    public static void printPrivateKeyInfo(PrivateKey privateKey)
    {
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) privateKey;
        System.out.println("----------RSAPrivateKey ----------");
        System.out.println("Modulus.length=" + rsaPrivateKey.getModulus().bitLength());
        System.out.println("Modulus=" + rsaPrivateKey.getModulus().toString());
        System.out.println("PrivateExponent.length=" + rsaPrivateKey.getPrivateExponent().bitLength());
        System.out.println("PrivatecExponent=" + rsaPrivateKey.getPrivateExponent().toString());

    }

    /**
     *  TODO rsa解密
     * @param mContext
     * @param encryptContent 需要解密的字符
     * @return 解密完成的字符
     */

    public static String decodeInfo(Context mContext,String encryptContent){

        String decodeStr;
        try
        {
            // 从字符串中得到私钥
            // PrivateKey privateKey = RSAUtils.loadPrivateKey(PRIVATE_KEY);
            // 从文件中得到私钥
            InputStream inPrivate = mContext.getResources().getAssets().open("pkcs8_rsa_private_key.pem");
            PrivateKey privateKey = RSAUtils.loadPrivateKey(inPrivate);
            // 因为RSA加密后的内容经Base64再加密转换了一下，所以先Base64解密回来再给RSA解密
            byte[] decryptByte = RSAUtils.decryptData(Base64Utils.decode(encryptContent), privateKey);
            decodeStr  = new String(decryptByte);


        } catch (Exception e) {
            decodeStr="";
        }

        return  decodeStr;
    }


    public static String encodeInfo(Context mContext,String source){

        String encodeStr;
        try
        {
            // 从字符串中得到公钥
            // PublicKey publicKey = RSAUtils.loadPublicKey(PUCLIC_KEY);
            // 从文件中得到公钥
            InputStream inPublic = mContext.getResources().getAssets().open("rsa_public_key.pem");
            PublicKey publicKey = RSAUtils.loadPublicKey(inPublic);
            // 加密
            byte[] encryptByte = RSAUtils.encryptData(source.getBytes(), publicKey);
            // 为了方便观察吧加密后的数据用base64加密转一下，要不然看起来是乱码,所以解密是也是要用Base64先转换
            encodeStr = Base64Utils.encode(encryptByte);
        } catch (Exception e) {
            encodeStr="";
        }
        return encodeStr;
    }



}

其中,从字符串中得到公钥, 或者是秘钥只是一个字符串, 可以给变量添加字符就好了!

@芥末君
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Android RSA加密解密
Rocko's blog - http://rocko.xyz
08-23 2万+
RSA是目前最有影响力的公钥加密算法。在项目开发中对于一些比较敏感的信息需要对其进行加密处理，我们就可以使用RSA这种非对称加密算法来对数据进行加密处理，保证数据的安全。
Android RSA加密解密
打字打不快的屌丝
09-17 1545
转载自： http://blog.csdn.net/bbld_/article/details/38777491
Android RSA加密，解密
xiyangyang8110的博客
10-10 653
在前后端数据传输的过程中，数据被网截工具拦截容易泄露，此时我们可以把数据用RSA进行加密，使得数据安全。RSA非对称加密，加密解密规则不一样，数据更安全！ 使用公钥进行加密：cipher.init(Cipher.ENCRYPT_MODE, publicKey);// 1024 KeyPairGenerator kg=KeyPairGenerator.getInstance("RSA
android RSA加解密
Fly_o0o的专栏
01-04 1177
废话不多说，使用RSA加解密时遇到很多问题，大概三点： 1.公钥或私钥构造失败，原因大概两点，一是公钥串或是密钥串不对，应该用openssl生成密钥，“-----BEGIN PUBLIC KEY-----”和“-----END PUBLIC KEY-----”中间的串即为密钥。二是没有用Base64类转换，成字节数组，用本文的例子中的Base64工具类即可。 2.加解密失败，确认使用的公钥和私
Android RSA加密解密demo
08-23
本示例"Android RSA加密解密demo"提供了一个完整的实现过程，帮助开发者理解如何在Android平台上使用RSA进行数据的加密和解密操作。 RSA算法基于数论，它的核心思想是利用两个大素数的乘积作为公钥，这两个大素数的...
android RSA2加密解密
09-24
android RSA2加密解密，里边提供两个方法，一个是生成公有私有秘钥加密解密，另一个是加密解密
Android RSA加解密签名
06-19
本文将深入探讨如何在Android平台上实现RSA加解密和签名操作，同时也会涉及从字符串和PEM文件读取公钥和私钥的方法，并使用Android自带的Base64库进行编码和解码。 首先，我们需要理解RSA算法的基本原理。RSA是基于...
RSADemo:Android RSA加密解密
05-09
公钥是可发布的供任何人使用，私钥则为自己所有，供解密之用。关于RSA其它需要了解的知识，参考维基百科: #####在项目开发中对于一些比较敏感的信息需要对其进行加密处理，我们就可以使用RSA这种非对称加密算法来对...
C#Android互通RSA加密解密
06-13
"C# Android互通RSA加密解密"这一主题就聚焦于如何在C#和Android之间安全地进行数据传输，通过RSA加密算法确保数据的安全性。 RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，它基于大数因子分解的困难性，为...
Android RSA 加密解密Demo
08-27
这个demo能帮助正在写RSA加密的朋友，一定能帮助你的 从生成密钥对到publicKey加密，privateKey解密得到数据，完整的过程
Android之RSA加密解密签名验签（亲测可用）
05-11
Android之RSA加密解密签名验签，亲测可用，不能用退分！
【Android】RSA加密、解密
jifenglie的博客
01-23 341
RSAUtils import java.io.BufferedReader; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.math.BigInteger; ...
Android RSA 加解密
最新发布
xingfuyisheng的专栏
07-21 842
RSA是一种常用的非对称加密算法，所谓非对称加密是指使用一对密钥（公钥和私钥）进行加密和解密，公钥人人都可以获得，用于加密数据，私钥保存在服务器中，用于解密数据。加密解密过程如下：使用RSA进行加密解密，其优点是非常不容易破解，缺点是和对称加密（如AES）相比，加密速度较慢。因此，实际使用中，常常将对称加密和非对称加密结合使用，即使用非对称加密协商对称加密的密钥，使用对称加密密钥加密传输内容。
java android rsa加密解密_Android中的RSA加密解密
weixin_35367645的博客
02-21 519
我正在爲Android中的RSA加密和解密實施演示。我可以很好地執行加密，但在解密中，我得到一個例外：>>java.security.InvalidKeyException: unknown key type passed to RSA。Android中的RSA加密解密KeyPairGenerator kpg;KeyPair kp;PublicKey publicKey;Private...
Android 中 RSA接口加密以及解密
u010227042的博客
11-14 851
1.RSA简介 RSA是一种非对称加密算法，加密和解密使用不同的密钥。通信双方各握有一对密钥（称为公钥和私钥）中的一把，己方密钥加密的数据，只有对方密钥能够解密。RSA基于一个数论事实：将两个大素数相乘十分容易，但想要对其乘积进行因式分解却极其困 难，因此可以将乘积公开作为加密密钥，即公钥，而两个大素数组合成私钥。公钥是可提供给任何人使用，私钥则为自己所有，供解密之用。 一般在Android中使...
Android--RSA加密解密
超宇的博客
12-07 5194
RSA算法原理如下： 1.随机选择两个大质数p和q，p不等于q，计算N=pq；  2.选择一个大于1小于N的自然数e，e必须与(p-1)(q-1)互素。  3.用公式计算出d：d×e = 1 (mod (p-1)(q-1)) 。 4.销毁p和q。 最终得到的N和e就是“公钥”，d就是“私钥”，发送方使用N去加密数据，接收方只有使用d才能解开数据内容。 RSAUtils工具类：
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值