Android 中 RSA、AES 加密

最新推荐文章于 2024-10-13 12:12:26 发布
最新推荐文章于 2024-10-13 12:12:26 发布
阅读量654 收藏 2
点赞数 2
分类专栏： Android开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreams_deng/article/details/105358513
版权

1. Base64 编码解码

 编码：结果是string
   解码：结果是byte

 String Tag="denganzhi1";
    @RequiresApi(api = Build.VERSION_CODES.O)
    public void base64Show(View view){
        String encode = null;
        try {
            // 编码, 编码的结果是字符串
            encode = java.util.Base64.getEncoder().encodeToString("123456".getBytes("UTF-8"));
            Log.e(Tag, "encode:"+ encode);
            // 解码， 解码的结果是 二进制
            byte[] decode = java.util.Base64.getDecoder().decode(encode);
            Log.e(Tag,"解码："+ new String(decode, "UTF-8"));

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

 2.  RSA : 非对称加密：

   原理： 大质数相乘，对结果进行因式分解困难 
    使用Openssl生成公钥与私钥
Openssl 安装：https://blog.csdn.net/sunhuansheng/article/details/82218678

  OpenSSL:  内部集成了完整算法 rsa/aes
  openssl :  进入 终端 
  genrsa -out rsa_private_key.pem 1024  : 长度1024，生成私钥，私钥长度长于公钥
  rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem ： 基于私钥生成公钥
 
  *重新根据pkcs8的秘钥创建私钥，openssl默认是pkcs1,java使用的是pkcs8转化一下,否则无法解秘
     * pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform pem -nocrypt -out rsa_private_key_pkcs8.pem
     *
     *  根据pkcs8 根据私钥 重新 生成公钥
     *  rsa -in rsa_private_key_pkcs8.pem -pubout -out rsa_public_key_pkcs8.pem
  
-----------------------------------------------------------------------------    
Java Api:  
  Java 通过KeyFactory 获取各种 加密算法 实例 RSA|AES    
  网络传输公钥、私钥使用：
公钥: 发出去
私钥：自己留着
 只有自己才可以解密
 TCP三次握手秘钥传输：
  A -> B   发送公钥
  B -> A   返回私钥
  A -> B   Ack收到

RSA加密核心类：

 //手动 生成 RSA 的 秘钥
// 1. 初始哈参数变量
//2. 获取RSA 的 Cipher
 //3. 执行加密
package mk.denganzhi.com.keymodule;

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

/**
 * Created by denganzhi on 2020/4/3.
 */

public class RSA {


    /****
     *   加密函数,传入明文,公钥返回  密文
     */
    public static byte[] encryptToByte(int data, String publicKey) {
        String message=  String.valueOf(data);
        // base64 编码  返回 byte
        byte[]  decoded= base64Decode(message);
        byte[]  result= null;
        try {
            // 获取RSA 算法    X509EncodedKeySpec 是协议 类型
            RSAPublicKey pubKey= (RSAPublicKey) KeyFactory.getInstance("RSA")
                    .generatePublic(new X509EncodedKeySpec(decoded));
    // 这里指定具体RSA算法,这里的是 PKSC1Padding
            Cipher cipper=Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipper.init(Cipher.ENCRYPT_MODE,pubKey);
            result= cipper.doFinal(message.getBytes("utf-8"));

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }catch (InvalidKeySpecException e){
            e.printStackTrace();
        }catch (InvalidKeyException e){
            e.printStackTrace();
        }
        return result;
    }

    /****
     *   加密函数,传入明文,公钥返回  密文,  返回base64字符串
     */
    public static String encryptToBase64(int data, String publicKey){
        String message=  String.valueOf(data);
        // base64 编码  返回 byte
        byte[]  decoded= base64Decode(publicKey);
        byte[]  result = new byte[]{0};
        try {
            // 获取RSA 算法    X509EncodedKeySpec 是协议 类型
            RSAPublicKey  pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA")
                        .generatePublic(new X509EncodedKeySpec(decoded));

            // 这里指定具体RSA算法,这里的是 PKSC1Padding
            Cipher cipper=Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipper.init(Cipher.ENCRYPT_MODE,pubKey);

            result= cipper.doFinal(message.getBytes("utf-8"));

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }catch (InvalidKeyException e) {
            e.printStackTrace();
        }finally {
            return base64Encord(result);
        }
    }

    /**
     *  解密
     *    密文+ 私钥
     */
    public static String decypt(String encryted,String key){
        byte [] decode =  base64Decode(key);
        byte [] content = base64Decode(encryted);

        byte[] result= new byte[]{0};
        RSAPrivateKey priKey= null;
        try {
            priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").
                    generatePrivate(new PKCS8EncodedKeySpec(decode));

            // 这里指定具体RSA算法,这里的是 PKSC1Padding

            Cipher cipper = Cipher.getInstance("RSA/ECB/PKCS1Padding");

            cipper.init(Cipher.DECRYPT_MODE,priKey);

            result= cipper.doFinal(content);

        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }


        return new String(result);
    }



    // base64 编码

    public static String  base64Encord(byte[] data){
       String encord = null;
        try{
            encord=  android.util.Base64.encodeToString(data,android.util.Base64.NO_WRAP);
        }catch (Exception e){
            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
                encord = Base64.getEncoder().encodeToString(data);
            }
        }
        return encord;
    }


  // base64的解码
    public static byte[]  base64Decode(String data){
        byte[] decode = null;
        try{
            // Java 提供了Base64 (不太好用)
            // Android 中也提供了 base64( 简单好用)

            // android.util.Base64.NO_WRAP  太长了 是否 换行 ， 不换行
            decode=  android.util.Base64.decode(data, android.util.Base64.NO_WRAP);

        }catch (Exception e){
            //  Adroid 中没有 ，用 Java 中的
            //  在 服务端运行 需要
            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
                decode = Base64.getMimeDecoder().decode(data);
            }
        }

       return decode;
    }


}

加密、解密功能调用：

  /***
     *重新根据pkcs8的秘钥创建私钥
     * pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform pem -nocrypt -out rsa_private_key_pkcs8.pem
     *
     *  根据pkcs8 根据私钥 重新 生成公钥
     *  rsa -in rsa_private_key_pkcs8.pem -pubout -out rsa_public_key_pkcs8.pem
     * @param view
     */

    public void rsaShow(View view){

        // openssl 生成的是 base64编码的 字符串
        String pubKey="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDZFFN1SzejUOylCihG4tzbOOJJ\n" +
                "vzyQvj8d+eWAm5D1LdQZcKGIa7eb30Ue/ULvXIiVVTZdFXolejWmZVUN88oONsF3\n" +
                "cgWa9h1hRioQMfKypfSo8KwjhxAUJjtLBHv+q+bSX8lG2QEMTChTzA6S7BnNaRsv\n" +
                "rfpD7ow29pl3oGR3awIDAQAB";


        String priKey="MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBANkUU3VLN6NQ7KUK\n" +
                "KEbi3Ns44km/PJC+Px355YCbkPUt1BlwoYhrt5vfRR79Qu9ciJVVNl0VeiV6NaZl\n" +
                "VQ3zyg42wXdyBZr2HWFGKhAx8rKl9KjwrCOHEBQmO0sEe/6r5tJfyUbZAQxMKFPM\n" +
                "DpLsGc1pGy+t+kPujDb2mXegZHdrAgMBAAECgYEAkWTqzTn25v0RsyzNc0UJtg8w\n" +
                "iUJ8F1pFPhedXvlTKtRqJivpFU1Iai8txabNyTJKDPNI+SmkaSukeXGPeUva/VOP\n" +
                "GvIsCgp6I9dJWsRtVTRV2t4Ydc85f8hJojQtYdOtpTOQwN5C5MV3wy4x3ZvCLzaf\n" +
                "P53n7zqlF17LZ+JdxHkCQQD9pOAUEhe/rJy/gsBVydzxZQxjbILMZt8MrEFkDe0N\n" +
                "GLypp67oUe8P4QHT0d/hMR0E+DhofmIHNbP03LCqfgR3AkEA2xiBgDcDFBOjjH8G\n" +
                "A+YbJmo1hytqEpJ9yVpw3J0iQ8lZj5TQ1opFy6zV9MdFbjUc7vkMmTfNtaWGYl1s\n" +
                "muvlrQJBAI2rkpEDTgp8Ig0BveXs2yBlfVbnG+OJLdpJODjnYlknUPE9vH78jJeE\n" +
                "6N1j4zVHllrZPcB3ns9CGqKQxYhk3J8CQBUI4UYCAhWnXQhcGaO+L9UcVU9I58Io\n" +
                "tlLij/teSq/fYO3cB8DRPao0ScZaa1wNVV3MI12CcgmCfshq18Z353ECQQCuHhE9\n" +
                "HnVU9nj+v6Hyj/4gz9EZtdnCOF5N5qMiayDmTC/sWup9ffEQTyBRMbg06kuvbIUX\n" +
                "dnMSxAn7z32a2Mem";


          int  context= 123;
          // 加密
          String enctryed = RSA.encryptToBase64(context,pubKey);
          // 解密
          String result= RSA.decypt(enctryed,priKey);

          Log.e(Tag,"RSA解密：result:  "+result);

    }

3. AES对称加密：

  需要使用代码自己手动生成秘钥

 //手动 生成 AES的 秘钥
// 1. 初始哈参数变量
//2. 获取AES的 Cipher
 //3. 执行加密

AES 功能： 

package mk.denganzhi.com.keymodule;

import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;

public class AES {

    private SecretKey mKey;


    public AES(){
        try {

            //  获取AES 算法
            KeyGenerator keyGenerator=KeyGenerator.getInstance("AES");
            //
            SecureRandom secureRandom=new SecureRandom();
            secureRandom.setSeed(System.currentTimeMillis());

            keyGenerator.init(128,secureRandom);

            mKey= keyGenerator.generateKey();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }

      // 加密
    public byte[] entrypt(String context){

        byte result[]=new byte[]{-1};

        if(mKey==null){
            return result;
        }

        try {
            Cipher cipher=Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE,mKey);
            result= cipher.doFinal(context.getBytes());

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }finally {
            return  result;
        }
    }

    public byte[] decrypt(byte[] conent){

        byte result[]=new byte[]{-1};
        if(mKey==null){
            return result;
        }

        Cipher cipher= null;
        try {
            cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE,mKey);
            result = cipher.doFinal(conent);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }finally {
            return result;
        }


    }

}

函数调用：

 public void aesClick(View view) {
        AES aes=new AES();
        String context="thi is  age";
        byte[] entrypted=  aes.entrypt(context);
     //   Log.e(Tag,"加密："+new String(entrypted));
        byte[] dectrypted= aes.decrypt(entrypted);
        Log.e(Tag,"解密:"+ new String(dectrypted));
    }

 

龙德施泰.冯.置
关注
专栏目录
Android 加密 AES
jacksinrow的博客
05-05 863
AES 加密又称对称性加密，在开发中常用于对流数据对加密，尤其是流数据在网络传输过程中，担心被泄露，AES 加密被常用于这块的校验中。下面是 AES 加密的百度百科说明解释： AES加密标准又称为高级加密标准 Rijndael 加密法，是美国国家标准技术研究所NIST旨在取代 DES 的 21 世纪的加密标准。AES 的基本要求是，采用对称分组密码体制，密钥长度可以为 128、192 或 256...
android 加密rsa aes,移动端数据的加密,采用RSA和AES方式
weixin_28835583的博客
06-02 594
移动端和WEB端的混合加密(RSA和AES)流程是先由服务器创建RSA密钥对，RSA公钥保存在安卓的so文件里面，服务器保存RSA私钥。而安卓创建AES密钥(这个密钥也是在so文件里面)，并用该AES密钥加密待传送的明文数据，同时用接受的RSA公钥加密AES密钥，最后把用RSA公钥加密后的AES密钥同密文一起通过Internet传输发送到服务器。当服务器收到这个被加密的AES密钥和密文后，首先调用...
Android数据加密之RSA+AES混合加密
殇神马的博客
09-19 4726
在上一篇Android数据加密 中已经介绍了Android中数据加密的情况，并且在总结中给出了RSA+AES混合加密的方案，下面就来介绍一下RSA+AES混合加密。该篇博客转载自:http://blog.csdn.net/aa464971/article/details/510344621.RSA+AES混合加密过程Android端的数据加密过程： -首先生成一对RSA秘钥(公钥和私钥)
Android经典实战之常见的移动端加密算法和用kotlin进行AES-256加密和解密
AntDream的程序世界
08-28 1016
本文首发于公众号“AntDream”，欢迎微信搜索“AntDream”或扫描文章底部二维码关注，和我一起每天进步一点点在移动端开发中，数据加密是确保数据传输和存储安全的重要手段。常见的加密算法包括对称加密算法（如 AES）、非对称加密算法（如 RSA）、散列算法（如 SHA-256），以及消息认证码（如 HMAC）。
android中采用AES进行加密
kanwoerzi
08-24 124
对称密码体制的发展趋势将以分组密码为重点。分组密码算法通常由密钥扩展算法和加密（解密）算法两部分组成。密钥扩展算法将b字节用户主密钥扩展成r个子密钥。加密算法由一个密码学上的弱函数f与r个子密钥迭代r次组成。混乱和密钥扩散是分组密码算法设计的基本原则。抵御已知明文的差分和线性攻击，可变长密钥和分组是该体制的设计要点。　　AES是美国国家标准技术研究所NIST旨在取代DES的21世纪的加密标准。 ...
Android数据传输加密(二)：AES加密
Android Engineer.
05-15 5326
前言：不关心原理的小伙伴们可直接阅读第4部分。 1.AES加密简介 AES是一种对称加密算法，即加密解密使用同一把秘钥。非对称加密则是加密解密使用不同的秘钥（如RSA加密，下一篇文章会介绍）。 AES通常是这样使用的： 客户端每次随机生成一个秘钥，对待传输的数据加密，然后再用其他加密手段（如RSA），对秘钥本身进行加密，最后将加密后的数据和AES秘钥一同发送给服务端。 服
安卓AES加密
09-30 409
一：什么是AES加密 AES高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。 这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。 AES 是一个迭代的、对称密钥分组的密码,AES算法加密强度大，执行效率高，使用简单，实际开发中建议选择AES 算法。...
Android RSA AES 加密库
06-02
在Android RSA AES加密库中，可能使用JNI来实现以下功能： - 使用C/C++编写高效的加密库，因为这些语言在处理加密算法时通常比Java更快。 - 在本地代码中执行加密和解密操作，减少Java层的性能开销。 - 利用JNI...
android AES rsa 混合加密
10-18
在Android中，可以使用Java的`javax.crypto.Cipher`类来实现AES加密。首先，生成一个随机的AES密钥，然后使用这个密钥对数据进行加密。 2. **RSA公钥加密AES密钥**: AES加密后的密文相对安全，但AES密钥本身仍然...
Android中RSA加密博客的对应依赖资源
03-22
在Android开发中，RSA加密是一种常见的安全性技术，用于保护数据的隐私和安全。RSA是一种非对称加密算法，它的特点是有一对密钥：公钥和私钥。公钥可以公开给任何人，而私钥必须保密。这个算法的核心原理是两个大...
android开发RSA-AES-混合加密Demo
03-21
总之，"android开发RSA-AES-混合加密Demo"是一个实用的教学实例，它展示了如何在Android应用中结合使用RSA和AES加密技术来保障用户数据的安全。通过学习和理解这个Demo，开发者能够更好地理解非对称加密和对称加密的...
安卓 AES加密
zhenxili的博客
11-16 393
AES指高级加密标准（Advanced Encryption Standard）,是当前最流行的一种密码算法，下面是我自己整理的安卓针对AES加密的代码。 public class CryptAES { private static final String AESTYPE ="AES/ECB/pkcs5padding"; //加密模式和填充，可根据后台的加密模式和填充进行修改
Android中的AES加密
锋1024的专栏
06-23 529
AES 高级加密标准（英语：Advanced Encryption Standard，缩写：AES） AES加密是现在在对称加密中比较常用的一种加密算法。AES加密采用对称密钥体制，加密密钥与解密密钥是相同，密钥长度支持128、192、256。AES在安全方面DES更安全、灵活、高效率； 代码： /** * * 说明 :AES加密 * * @param stringT
Android上的AES加密
最新发布
github_35581409的博客
10-13 600
虽然这个视频讲的非常详细，但是涉及到具体底层算法，大致流程1. 将数据转成HEX或者byte array2.将数据分层一块块等大小的数据3.将数据和key 进行一次混合，加密之后的输出，在生成新的key4.将新的key和下一个数据，进行加密计算，继续重复生成的KEY长度有128,192,256，不同的的长度对算法的速度有影响当然key的长度越长，可能越安全这样具体的算法是什么呢。
Android实现AES加密
weixin_42602900的博客
02-27 856
Android实现AES加密
Android数据安全之AES加密
liugec的博客
05-02 761
背景AES(Advanced Encryption Standard)高级加密标准，安全性要高于DES，其实AES的出现本身就是为了取代DES的，AES具有比DES更好的安全性、效率、灵活性，所以对称加密优先采用AES。
Android AES加密算法工具类
jys1115的专栏
11-01 1182
1、AES加密工具类
Android AES 加密、解密
2401_85955090的博客
08-19 1030
给大家分享一份移动架构大纲，包含了移动架构师需要掌握的所有的技术体系，大家可以对比一下自己不足或者欠缺的地方有方向的去学习提升；参考docs.qq.com/doc/DSkNLaERkbnFoS0ZF同，还没看具体实现。有知道的小伙伴还请先指点一二。给大家分享一份移动架构大纲，包含了移动架构师需要掌握的所有的技术体系，大家可以对比一下自己不足或者欠缺的地方有方向的去学习提升；[外链图片转存中…(img-1lwPmuf9-1724066138540)]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值