Android 中数据加密 ---- RSA加密

最新推荐文章于 2021-12-18 17:06:21 发布
最新推荐文章于 2021-12-18 17:06:21 发布
阅读量725 收藏 1
点赞数 1
分类专栏： # android ---- security
本文为博主原创文章，未经博主允许不得转载！
本文链接：https://blog.csdn.net/shift_wwx/article/details/84325007
版权

前言：

对于RSA加密，在博文  RSA 加密 已经有了详细说明，这边博文将其用Android 实现。

 

更多的加密可以看：

数据加密 ---- 总篇

Android 中数据加密 ---- 异或加密

Android 中数据加密 ---- AES加密

Android 中数据加密 ---- DES加密

Android 中数据加密 ---- 3DES加密

Android 中数据加密 ---- MD5加密

Android 中数据加密 ---- SHA加密

 

实例：

实现的详细代码同 AES 加密的实例，这里将抽象的几个接口实现类RSAEncryption 贴出来：

public class RSAEncryption extends BlockEncryption {
    private static final String ALGORITHM = "RSA";
    private static final String PADDING = "/ECB/PKCS1Padding";
    private static final int DEFAULT_KEY_SIZE = 1024;

    private static final int RSA_BLOCK_SIZE = 11;

    public static final int TYPE_ENCRYPTION_WITH_PUBLIC = 0;
    public static final int TYPE_ENCRYPTION_WITH_PRIVATE = 1;

    private int mEncryptionType = TYPE_ENCRYPTION_WITH_PUBLIC;

    private int mKeyLength = DEFAULT_KEY_SIZE;
    private PublicKey mPublicKey;
    private PrivateKey mPrivateKey;

    public RSAEncryption() {
    }

    public void setEncryptionType(int type) {
        mEncryptionType = type;
    }

    public void setKeyLength(int keyLength) {
        mKeyLength = keyLength;
    }

    private KeyPair generateRSAKeyPair(int keyLength) {
        try {
            KeyPairGenerator kpg = KeyPairGenerator.getInstance(ALGORITHM);
            kpg.initialize(keyLength);
            return kpg.genKeyPair();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
    }

    public void generateKeys() {
        KeyPair keyPair = generateRSAKeyPair(mKeyLength);

        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        try {
            // get public key
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey.getEncoded());
            KeyFactory kf = KeyFactory.getInstance(ALGORITHM);
            mPublicKey = kf.generatePublic(keySpec);

            // get private key
            PKCS8EncodedKeySpec keySpec1 = new PKCS8EncodedKeySpec(privateKey.getEncoded());
            mPrivateKey = kf.generatePrivate(keySpec1);
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    private Key getKey(int mode) {
        if (mEncryptionType == TYPE_ENCRYPTION_WITH_PRIVATE) {
            return mode == Cipher.ENCRYPT_MODE ? mPrivateKey : mPublicKey;
        }
        return mode == Cipher.ENCRYPT_MODE ? mPublicKey : mPrivateKey;
    }

    @Override
    public Cipher getCipher(int mode) {
        if (mode != Cipher.ENCRYPT_MODE && mode != Cipher.DECRYPT_MODE)
            return null;

        try {
            Cipher cipher = Cipher.getInstance(ALGORITHM + PADDING);
            cipher.init(mode, getKey(mode));
            return cipher;
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return null;
    }

    @Override
    public String getAlgorithm() {
        return ALGORITHM;
    }

    @Override
    protected int getBlockSize() {
        return RSA_BLOCK_SIZE;
    }

    @Override
    protected int getBufferSize() {
        return (mKeyLength / 8) - RSA_BLOCK_SIZE;
    }

}

需要注意的是，这里的buffer size 为key length/8，block size 是11。

另外，因为RSA 需要public key 和private key，所以gitCipher() 不再使用BlockEncryptionHelper 中的方法。

 

Activity 中设置button 进行点击：

    private void testEncryptionRSA() {
        Button ersa = (Button) findViewById(R.id.encrypt_rsa);
        ersa.setOnClickListener(this);

        Button drsa = (Button) findViewById(R.id.decrypt_rsa);
        drsa.setOnClickListener(this);
    }

    private void rsaEncryption() {
        {
            mOperationTitle.setText(getString(R.string.encrypt_rsa));
            String strSource = "hliuhiufhliuhsd;jfijso;goshgosjogijsgo;j";
            mBeforeOperation.setText(getString(R.string.before_operation, strSource));

            if (mRSAEncryption == null) {
                mRSAEncryption = new RSAEncryption();
                mRSAEncryption.generateKeys();
            }

            mStrEncrypted = mRSAEncryption.strEncryption(strSource);
            Log.d(TAG, "==== mStrEncrypted = " + mStrEncrypted);
            mAfterOperation.setText(getString(R.string.after_operation, mStrEncrypted));
        }

//        if (mFileEncryption != null) {
//            Log.d(TAG, "==== test file, encryption with rsa ...");
//            String filePath = "/storage/emulated/0/hehe.png";
//            String destPath = "/storage/emulated/0/2.png";
//            mFileEncryption.setAlgorithm(FileEncryption.ALG_MODE_RSA);
//            mFileEncryption.start(FileEncryption.MODE_ENCRYPT, filePath, destPath);
//            Log.d(TAG, "==== test file, encryption end");
//        }
    }

    private void rsaDecryption() {
        {
            mOperationTitle.setText(getString(R.string.decrypt_rsa));
            mBeforeOperation.setText(getString(R.string.before_operation, mStrEncrypted));

            if (mRSAEncryption == null) {
                mRSAEncryption = new RSAEncryption();
                mRSAEncryption.generateKeys();
            }

            String strDecrypted = mRSAEncryption.strDecryption(mStrEncrypted);
            Log.d(TAG, "==== strDecrypted = " + strDecrypted);
            mAfterOperation.setText(getString(R.string.after_operation, strDecrypted));
        }

//        if (mFileEncryption != null) {
//            Log.d(TAG, "==== test file, decryption with rsa ...");
//            String filePath = "/storage/emulated/0/hehe.png";
//            String destPath = "/storage/emulated/0/2.png";
//            mFileEncryption.setAlgorithm(FileEncryption.ALG_MODE_RSA);
//            mFileEncryption.start(FileEncryption.MODE_DECRYPT, destPath, filePath);
//            Log.d(TAG, "==== test file, decryption end");
//        }
    }

注释掉的是对于文件的加密、解密，同样是实用的。

 

结果：

12-19 05:04:19.186  1958  1958 D TestEncryptionActivity: ==== mStrEncrypted = kPSmTWshnnFvHxOgxgp/qL7cJ2jHwx7sz+DE4cjrmskgeHOc1BKdBJGmKPTMN2JvY5NwI7Od5s/1
12-19 05:04:19.186  1958  1958 D TestEncryptionActivity: gNJX4Bzad/gvUgskpWklFOTHtfQL9hS1aG67fPhG8YXrbyOiHDYFSRxNdEFxRla4CkNRx+DDUWq7
12-19 05:04:19.186  1958  1958 D TestEncryptionActivity: /zDqAkA92myhgMUCLKk=
12-19 05:04:24.587  1958  1958 D TestEncryptionActivity: ==== strDecrypted = hliuhiufhliuhsd;jfijso;goshgosjogijsgo;j
12-19 05:04:32.139  1958  1958 D TestEncryptionActivity: ==== mStrEncrypted = PgZyrAPsJNIwa1sXSpeRFe5z8XsNHMJ0sPsNmLycdHKO4kZhiOWAvfXjMgaN2r6exhWLMbkzY+Kw
12-19 05:04:32.139  1958  1958 D TestEncryptionActivity: dGV8KHdVYWdy6GVUXGa85lPYkuEtGKyDXdAX8erXYhKdwGGKPcZtqFK074K0R7p1inFy2g24LEkl
12-19 05:04:32.139  1958  1958 D TestEncryptionActivity: RyMAZwuRCjgPiDJTqw4=
12-19 05:04:34.194  1958  1958 D TestEncryptionActivity: ==== strDecrypted = hliuhiufhliuhsd;jfijso;goshgosjogijsgo;j
12-19 05:04:35.797  1958  1958 D TestEncryptionActivity: ==== mStrEncrypted = EaFez+qztG8VP1WmgUaAdeQp7ZbuC0p+JwKiHYpo3VymgZ6fV4Yc4+Wfm64D4AQKPONzSVm7q8fc
12-19 05:04:35.797  1958  1958 D TestEncryptionActivity: fd4nnAfk+wqDYYyStvg+4D4LGvEXe6UZaKXw9leqfR9bLiSazbUgVzD60TwDE8Sgbx/igeoSX40G
12-19 05:04:35.797  1958  1958 D TestEncryptionActivity: 30MbOgVbjfQN3gRR86Q=
12-19 05:04:37.150  1958  1958 D TestEncryptionActivity: ==== strDecrypted = hliuhiufhliuhsd;jfijso;goshgosjogijsgo;j

每一次加密的结果都不一样，这个是因为加密的key 是public key，所以填充都会随机变化，导致了最后结果的不同。

如果加密的时候为private key，那么加密后的值是相同的。

 

 

私房菜
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
android RSA加密
谢岩的博客
03-01 419
这个RSA加密其实自己也没有完全弄清楚，只是在网上自己找了一些资料，也是为了记录自己的代码。 概述 RSA是目前最有影响力的公钥加密算法，该算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困 难，因此可以将乘积公开作为加密密钥，即公钥，而两个大素数组合成私钥。公钥是可发布的供任何人使用，私钥则为自己所有，供解密之用。关于RSA其它需
Android-请求参数通过RSA加密
08-13
本文将深入探讨如何在Android中实现请求参数的RSA加密。 首先，RSA是一种非对称加密算法，它基于两个密钥：公钥和私钥。公钥可以公开，用于加密数据；而私钥必须保密，用于解密数据。这种特性使得只有持有私钥的...
Android数据加密之Des加密
06-13 111
前言： 端午节前有个同事咨询我有关Android DES加密的相关实现，简单的实现了一下，今天来总结一下。 其他几种加密方式： Android数据加密之Rsa加密 Android数据加密之Aes加密 Android数据加密之Des加密 Android数据加密之MD5加密 Android数据加密之Base64编码算法...
Android中数据加密
殇神马的博客
09-19 828
在一个Android应用中，客户端与服务器之间数据通信安全是非常重要的。这就涉及到了数据的加密。Android中客户端与服务器端数据的加密主要有两种情况:1.只有创建者才能够知道的数据 比如用户密码数据,这类数据加密后必须是不可逆的， 也就是说数据加密后传到服务器，服务器端无需解密，也不能解密，直接存进数据库。2.也是比较重要的数据，但是服务器端可能也需要知道的，也就是说数据加密后必须是可
Android数据传输加密(三)：RSA加密
热门推荐
Android Engineer.
05-22 1万+
RSA是一种非对称加密算法，加密和解密使用不同的密钥。通信双方各握有一对密钥（称为公钥和私钥）中的一把，己方密钥加密的数据，只有对方密钥能够解密。RSA基于一个数论事实：将两个大素数相乘十分容易，但想要对其乘积进行因式分解却极其困 难，因此可以将乘积公开作为加密密钥，即公钥，而两个大素数组合成私钥。公钥是可提供给任何人使用，私钥则为自己所有，供解密之用。
Android RSA 加密
朱豪凯的博客
12-18 8046
没想到被Android里的RSA加密折腾了几个小时，主要还是自己对RSA加密的原理不了解，然后网上相关的资料也少。 使用AndroidUtilCode工具类中的`EncryptUtils.encryptRSA()`加密后的数据怎么也不对，后来自己找了段加密代码，才总算是可以了，这里记录一下。 首先我们需要先 生成一个RSA的公钥和私钥。
Android数据加密之Rsa加密
09-01
总之，RSA加密在Android中提供了强大的数据安全保障，尤其是在需要非对称加密的场景下，如安全通信和数字签名。然而，由于RSA的运算速度较慢，通常用于加密较小的数据块或者加密用于交换的对称密钥。在实际应用中，...
Android数据加密之Rsa加密的简单实现
09-01
在Android开发中，数据安全是至关重要的，尤其是涉及到用户敏感信息时。...总的来说，Rsa加密在Android应用中提供了一种强大的数据保护手段，通过合理的使用和组合，可以构建安全的数据通信和存储系统。
RSA加密解密的使用，含jsencrypt.js文件（uni-app也可用）
07-20
总之，RSA加密是前端开发中保障数据安全的重要手段，尤其在uni-app这样的多端开发框架中，通过jsencrypt.js库，开发者可以在不牺牲用户体验的前提下，实现高效且安全的数据传输。合理利用这些工具和方法，可以有效地...
Android-Android加密工具集合
08-13
"Android-Android加密工具集合"是一个专注于Android平台上的加密工具库，它为开发者提供了多种加密算法和实用工具，旨在增强应用的安全性。在这个资源中，我们主要关注的是UOpenCryption-master，它可能是一个包含...
androidRSA加密
10-30
RSA封装类 ，完整的RSA加密和解密 public class RSAUtilEncrypt { public static final String KEY_ALGORTHM = "RSA";// public static final String KEY_ALGORTHM_RSA_ECB_PKCS1PADDING = "RSA/ECB/PKCS1Padding"; public static String RSA_PUBLIC_KEY = "rsa_public_key"; public static String RSA_PRIVATE_KEY = "rsa_private_key"; private int KeySize = 1024; private Map keyMap; private static String RSA = "RSA"; private static PublicKey publickey; public RSAUtilEncrypt(int KeySize,String publickey) { this.KeySize = KeySize; try { this.publickey=generatePublicKeyByString(publickey); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } private RSAPublicKey generatePublicKeyByString(String publicKeyStr) throws Exception { try { BASE64Decoder base64Decoder = new BASE64Decoder(); byte[] buffer = base64Decoder.decodeBuffer(publicKeyStr); X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); return (RSAPublicKey) keyFactory.generatePublic(keySpec); } catch (NoSuchAlgorithmException e) { throw new Exception("No Algorthm,Checked by cemung!"); } catch (InvalidKeySpecException e) { throw new Exception("InvalidKeySpec!"); } catch (IOException e) { throw new Exception("Io exception!"); } catch (NullPointerException e) { throw new Exception("Illegle pointer reference!"); } } // Encypt public byte[] RSAEncrypt(byte[] data, RSAPublicKey publickey) throws Exception { Cipher cipher = Cipher.getInstance(KEY_ALGORTHM_RSA_ECB_PKCS1PADDING); cipher.init(Cipher.ENCRYPT_MODE, this.publickey); byte[] cipherbytes = cipher.doFinal(data); return cipherbytes; } // Encypt public byte[] RSAEncrypt(byte[] data) throws Exception { Cipher cipher = Cipher.getInstance(KEY_ALGORTHM_RSA_ECB_PKCS1PADDING); cipher.init(Cipher.ENCRYPT_MODE, this.publickey); byte[] cipherbytes = cipher.doFinal(data); return cipherbytes; } // Get Public key with format byte[] public byte[] getPublicKeyByte() { RSAPublicKey pubkey = (RSAPublicKey) keyMap.get(RSA_PUBLIC_KEY); return pubkey.getEncoded(); } public static byte[] decryptBASE64(String key) throws Exception { return (new BASE64Decoder()).decodeBuffer(key); } public static String encryptBASE64(byte[] key) throws Exception { return (new BASE64Encoder()).encodeBuffer(key); } public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception { byte[] keyBytes = decryptBASE64(key); PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec( keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM); Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec); Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); cipher.init(Cipher.DECRYPT_MODE, privateKey); return cipher.doFinal(data); } public static byte[] encryptByPublicKey(byte[] data, String key) throws Exception { byte[] keyBytes = decryptBASE64(key); X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM); Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec); Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); cipher.init(Cipher.ENCRYPT_MODE, publicKey); return cipher.doFinal(data); } public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception { byte[] keyBytes = decryptBASE64(key); X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM); Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec); Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); cipher.init(Cipher.DECRYPT_MODE, publicKey); return cipher.doFinal(data); } 使用方法 private RSAUtilEncrypt rsa = new RSAUtilEncrypt(1024, publikey); /* * 给信息加密,获取密文 */ public String getCiphertext(String str_encrode) { try { byte[] estr = rsa.RSAEncrypt(str_encrode.getBytes()); // 密文 String ciphertext = Base64.encodeToString(estr, Base64.DEFAULT); return ciphertext; } catch (Exception e) { e.printStackTrace(); } return null; } 有疑问的留言
Android中RSA加密
水月洞天
03-22 1515
上次我们说了一个MD5加密，我们来复习一下。这是一种单向加密方式。我们只能让拦截我们数据的人不知道我们真实的内容是什么，但是我们不能反向解密。一般用于信息验证的场合。今天说的就是一个可以加密也可以解密的东东，那就是RSA加密。 RSA加密后的内容是一个byte数组，解密需要的内容也是byte数组。但加密后的byte数组如果你尝试转为字符串你会发现是乱码。所以我们传输或者保存的时候需要直接对byte数组进行传输处理，不要尝试转为字符串，否则会有意想不到的错误。 代码如下，大家参考。依赖包我已经上传到资源了
Android RSA密码加密
ku_fupeng的博客
08-29 328
public static String passEncipher(String password) throws Exception { String pKey = "xxxxxxxx"; byte[] keyByte = Base64.decode(pKey.getBytes("UTF-8"), Base64.NO_WRAP); KeyFactory keyFactory = KeyFactory.getInstance("RSA");// KEY_ALGORITHM 指定的加密算法 .
android rsa数据加密,Android中的RSA加密
weixin_39716703的博客
05-31 241
Frank..5这里有一个如何做到的例子,但在实践中,您不能仅使用RSA加密和解密整个文件.RSA算法只能加密单个块,并且执行整个文件的速度相当慢.您可以使用3DES或AES加密文件,然后使用预期收件人的RSA公钥加密AES密钥.一些代码:public static void main(String[] args) throws Exception {KeyPairGenerator kpg = ...
Android RSA加密
Fover android开发笔记
11-16 221
和小段讨论之后，我觉得现在APP加密还是比较严峻的，一个是APP本身被破击打包，还有一个是接口被利用。本文主要是想通过加密的方式来防止接口被直接抓包抓到，虽然依旧可破解，但是能让破解者费点力气。生成密钥 RSA加密的密钥有两种，一种是公钥，另一种是私钥，公钥是用来加密的，密钥用于解密。在实际应用中，将公钥给Android客户端，Android客户端提交数据通过这个公钥加密后上传到服务器，服务器用
Android 数据加密
小白新人
07-27 279
通过网络传输数据，需要保证数据的完整性、保密性，以及能够对数据的发送者进行身份验证。这些都需要通过一些加密算法实现。对称加密： 加密和解密使用同一个密钥，特点：保证了数据的保密性。局限性：无法解决密钥交换问题。常用的算法有：DES,3DES,AES;公钥加密： 生成一个密钥对（私钥和公钥），加密时用私钥加密，解密时用公钥解密，特点：解决了密钥交换问题。局限性：对大的数据加密速度慢。 单向加密： 提...
写出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 keysPublicKey publicKey = kp.getPublic(); PrivateKey privateKey = kp.getPrivate();// Encrypt a messageCipher cipher = Cipher.getInstance("RSA"); cipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] encryptedBytes = cipher.doFinal("Hello world".getBytes());// Decrypt the messagecipher.init(Cipher.DECRYPT_MODE, privateKey); byte[] decryptedBytes = cipher.doFinal(encryptedBytes); String decryptedString = new String(decryptedBytes);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

私房菜

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

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

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

打赏作者

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

抵扣说明：

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

余额充值