提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  移动开发

当前栏目

Android常用加密方式

Android加密 方式 常用
2023-06-13 09:11:38 时间

大家好，又见面了，我是你们的朋友全栈君。

加密解密简介

加密技术是最常用的安全保密手段，利用技术手段把重要的数据变为乱码（加密）传送，到达目的地后再用相同或不同的手段还原（解密）。加密技术包括两个元素：算法和密钥。算法是将普通的信息或者可以理解的信息与一串数字（密钥）结合，产生不可理解的密文的步骤，密钥是用来对数据进行编码和解密的一种算法。在安全保密中，可通过适当的钥加密技术和管理机制来保证网络的信息通信安全。

加迷解密分类

分为不可逆和可逆，可逆又分为对称密钥体制和非对称密钥体制两种。

秘钥加密技术的密码体制分为对称密钥体制和非对称密钥体制两种。数据加密技术分为两类，即对称加密（私人密钥加密）和非对称加密（公开秘钥加密）。对称加密以数据加密标准（DES，Data Encryption Standard）算法为典型代表，非对称加密通常以RSA（Rivest Shamir Ad1eman）算法为代表。对称加密的加密秘钥和解密密钥相同，而非对称加密的加密密钥和解密密钥不同，加密密钥可以公开而解密密钥需要保密。

不可逆

单项的加密，不能解密。

MD5、SHA、HMAC这三种加密算法，可谓是非可逆加密，就是不可解密的加密方法。

我们通常只把他们作为加密的基础，单纯的以上三种的加密并不可靠。 MD5、SHA 可以通过暴力碰撞算法破解。

对称加密

对称加密指的就是加密和解密使用同一个秘钥，所以叫做对称加密。对称加密只有一个秘钥，作为私钥。

对称加密采用了对称密码编码技术，它的特点是文件加密和解密使用相同的秘钥，即加密密钥也可以用作解密密钥，这种方法在密码学中叫做对称加密算法，对称加密算法使用起来简单快捷，密钥较短，且破译困难，除了数据加密标准（DES），另一个对称密钥加密系统是国际数据加密算法（IDEA），它比DES的加密性好，而且对计算机功能要求也没有那么高。IDEA加密标准由PGP（Pretty Good Privacy）系统使用。

对称性加密算法有：AES、DES、3DES

非对称加密

非对称加密指的是：加密和解密使用不同的秘钥，一把作为公开的公钥，另一把作为私钥。公钥加密的信息，只有私钥才能解密。私钥加密的信息，只有公钥才能解密。

非对称加密指的是：加密和解密使用不同的秘钥，一把作为公开的公钥，另一把作为私钥。公钥加密的信息，只有私钥才能解密。私钥加密的信息，只有公钥才能解密。

1976年，美国学者Dime和Henman为解决信息公开传送和密钥管理问题，提出一种新的密钥交换协议，允许在不安全的媒体上的通讯双方交换信息，安全地达成一致的密钥，这就是“公开密钥系统”。相对于“对称加密算法”这种方法也叫做“非对称加密算法”。与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密 （privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。

非对称性算法有：RSA、DSA、ECC

散列/哈希算法有：MD5、SHA1

其他常用算法：Base64

BASE64

Base64严格地说，属于编码格式，而非加密算法,用于二进制内容转换为可编辑的文本内容。

Base64也会经常用作一个简单的“加密”来保护某些数据，而真正的加密通常都比较繁琐。

编码后的内容，是由64个字符（大小写英文字母 0-9 + / (= 补位符，填充字符)）组成的序列，成为Base64。可逆的编码方式。

常见于邮件、http加密，截取http信息，你就会发现登录操作的用户名、密码字段通过BASE64加密的。

Android中自带的Base64加密算法:

  String s = "xiaoyehai";

        //加密
        String encode = Base64.encodeToString(s.getBytes(), Base64.NO_WRAP);

        //解密
        byte[] decode = Base64.decode(encode.getBytes(), Base64.DEFAULT);
        Log.e("xyh", "encode: " + encode); //eGlhb3llaGFp
        Log.e("xyh", "decode: " +new String(decode,0,decode.length)); //xiaoyehai

在encode的时候，会有一个参数Flags（即上面代码中的Base64.DEFAULT）这个参数有什么用呢？根据Android SDK的描述，这种参数有5个：

DEFAULT 这个参数是默认，使用默认的方法来加密 CRLF 这个参数看起来比较眼熟，它就是Win风格的换行符，意思就是使用CRLF 这一对作为一行的结尾而不是Unix风格的LF NO_PADDING 这个参数是略去加密字符串最后的”=” NO_WRAP 这个参数意思是略去所有的换行符（设置后CRLF就没用了） URL_SAFE 这个参数意思是加密时不使用对URL和文件名有特殊意义的字符来作为加密字符，具体就是以-和 _ 取代+和/

MD5

MD5即Message-Digest Algorithm 5（信息-摘要算法5），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD5实现。将数据（如汉字）运算为另一固定长度值，是杂凑算法的基础原理，MD5的前身有MD2、MD3和MD4。

MD5本质是一种散列函数，用以提供消息的完整性保护。

单项的加密，不能解密，长度固定（32位）。

通过对任意长度的信息逐位进行计算，产生一个二进制长度为128位（十六进制长度就是32位）的 hash 值, 不同的文件产生相同的hash的可能性是非常小。

特点：

1.压缩性：任意长度的数据，算出的MD5值长度都是固定的；

2.容易计算：从原数据计算出MD5值很容易；

3.抗修改性：对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值都有很大的区别；

4.强抗碰撞：已知原数据和其MD5值，想找到一个具有相同MD5值的数据（及伪造数据）是非常困难的；

5.不可逆：MD5理论上是不可逆的（但是现在已经可以暴力破解了）。

但实际上MD5不是一种加密算法，只是一种算法，因为它是一个不可逆的过程，即 MD5 生成消息摘要后是不能通过结果解析得到原来的内容。

使用场景：

1.验证密码：只要算法不变，就能和服务器上的MD5匹配；在用户注册时，会将密码进行md5加密，存到数据库中。这样可以防止那些可以看到数据库数据的人，恶意操作了。

2.文件完整性的校验：当下载一个文件时，服务器返回的信息包括这个文件的md5,在本地下载完毕时进行md5加密，将两个md5值进行比较，如果一致则说明文件完整没有丢包现象。

MessageDigest 通过其getInstance系列静态函数来进行实例化和初始化。MessageDigest 对象通过使用 update 方法处理数据。任何时候都可以调用 reset 方法重置摘要。一旦所有需要更新的数据都已经被更新了，应该调用 digest 方法之一完成哈希计算并返回结果。

对于给定数量的更新数据，digest 方法只能被调用一次。digest 方法被调用后，MessageDigest 对象被重新设置成其初始状态。

MD5加密工具类

/** * Created by : Administrator * Create date : 2019/5/16 22:34 * description : md5加密工具类 */
public class MD5Utils { 
   

      public static String md5(String s) { 
   
        if (s == null) { 
   
            return "";
        }
        try { 
   
            //初始化MessageDigest对象
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");

            //（可选）调用reset方法重置要传入进行加密的数据
            messageDigest.reset();

            //调用update方法传入要进行加密的byte数据
            messageDigest.update(s.getBytes("UTF-8"));

            //调用digest方法对传入的数据进行加密
            byte[] byteArray = messageDigest.digest();
            // java中一个byte为8个二进制位,16*8=128
            //Log.e("xyh", "md5: " + byteArray.length); //16
            StringBuffer md5StrBuff = new StringBuffer();
            for (int i = 0; i < byteArray.length; ++i) { 
   
                //转换为16进制,0xFF也可以写成255
                String hexString = Integer.toHexString(0xFF & byteArray[i]);
                Log.e("xyh", "md5: " +hexString);
                if (hexString.length() == 1) { 
   
                    md5StrBuff.append("0").append(hexString);
                } else { 
   
                    md5StrBuff.append(hexString);
                }
            }

            return md5StrBuff.toString();

        } catch (Exception e) { 
   
            e.printStackTrace();
        }
        return "";
    }

    public static String md5(byte[] target, int len) { 
   
        try { 
   
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            messageDigest.reset();
            messageDigest.update(target, 0, len);
            byte[] byteArray = messageDigest.digest();
            StringBuffer md5StrBuff = new StringBuffer();
            for (int i = 0; i < byteArray.length; ++i) { 
   
                if (Integer.toHexString(255 & byteArray[i]).length() == 1) { 
   
                    md5StrBuff.append("0").append(Integer.toHexString(255 & byteArray[i]));
                } else { 
   
                    md5StrBuff.append(Integer.toHexString(255 & byteArray[i]));
                }
            }

            return md5StrBuff.toString();
        } catch (Exception e) { 
   
            e.printStackTrace();
        }
        return "";
    }

    /** * 获取文件的MD5 * * @param file * @return */
    public static String getFileMD5(File file) { 
   
        if (!file.isFile()) { 
   
            return null;
        } else { 
   
            MessageDigest digest = null;
            FileInputStream in = null;
            byte[] buffer = new byte[1024];

            try { 
   
                digest = MessageDigest.getInstance("MD5");
                in = new FileInputStream(file);

                while (true) { 
   
                    int len;
                    if ((len = in.read(buffer, 0, 1024)) == -1) { 
   
                        in.close();
                        break;
                    }

                    digest.update(buffer, 0, len);
                }
            } catch (Exception var6) { 
   
                var6.printStackTrace();
                return null;
            }

            BigInteger bigInt = new BigInteger(1, digest.digest());
            return bigInt.toString(16);
        }
    }

    /** * 获取文件夹的MD5 * * @param file * @param listChild * @return */
    public static Map<String, String> getDirMD5(File file, boolean listChild) { 
   
        if (!file.isDirectory()) { 
   
            return null;
        } else { 
   
            Map<String, String> map = new HashMap();
            File[] files = file.listFiles();

            for (int i = 0; i < files.length; ++i) { 
   
                File f = files[i];
                if (f.isDirectory() && listChild) { 
   
                    map.putAll(getDirMD5(f, listChild));
                } else { 
   
                    String md5 = getFileMD5(f);
                    if (md5 != null) { 
   
                        map.put(f.getPath(), md5);
                    }
                }
            }
            return map;
        }
    }
}

SHA

安全散列算法，数字签名工具 , 长度比MD5要长，所以更安全，但是加密的效率要比MD5慢一些.

安全散列算法SHA (Secure Hash Algorithm)，用于确保信息传输完整一致。SHA基于MD5实现。

是美国国家标准技术研究所发布的国家标准FIPS PUB 180，最新的标准已经于2008年更新到FIPS PUB 180-3。其中规定了SHA-1，SHA-224，SHA-256，SHA-384，和SHA-512这几种单向散列算法。SHA-1，SHA-224和SHA-256适用于长度不超过264二进制位的消息。SHA-384和SHA-512适用于长度不超过2128二进制位的消息。

SHA1有如下特性：

不可以从消息摘要中复原信息； 两个不同的消息不会产生同样的消息摘要。

著名的图片加载框架Glide在缓存key时就采用的此加密 文件的秒传功能，以及相同的v4包冲突都是可以根据sha1值进行比对的

/** * 使用sha-1方式进行加密 * @return */
       public static String digest(String content){ 
   
        StringBuilder builder = new StringBuilder();
        try { 
   
            MessageDigest msgDitest = MessageDigest.getInstance("SHA-1");
            msgDitest.update(content.getBytes());
            byte[] digests = msgDitest.digest();
            //将每个字节转为16进制
            for (int i=0;i<digests.length;i++){ 
   
                builder.append(Integer.toHexString(digests[i] & 0xff +8));//+8为加盐操作
            }
        } catch (NoSuchAlgorithmException e) { 
   
            e.printStackTrace();
        }
        return  builder.toString();
       }

AES加密

AES加密是一种高级加密标准，是一种区块加密标准。它是一个对称密码，就是说加密和解密用相同的密钥。WPA/WPA2经常用的加密方式就是AES加密算法。

高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。 这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用，Android 中的AES 加密 秘钥 key 必须为16/24/32位字节，否则抛异常。

package com.xiaoyehai.sdwydc.utils;

import android.text.TextUtils;
import android.util.Base64;
import android.util.Log;

import com.xiaoyehai.sdwydc.constant.AppConstant;

import java.security.Provider;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/** * AES加密解密 * Created by xiaoyehai on 2018/12/28 0028. */

public class AESUtils { 
   

    private final static String HEX = "0123456789ABCDEF";
    private static final String CBC_PKCS5_PADDING = "AES/CBC/PKCS5Padding";//AES是加密方式 CBC是工作模式 PKCS5Padding是填充模式
    private static final String AES = "AES";//AES 加密
    private static final String SHA1PRNG = "SHA1PRNG";// SHA1PRNG 强随机种子算法, 要区别4.2以上版本的调用方法

    /** * 生成随机数，可以当做动态的密钥 加密和解密的密钥必须一致，不然将不能解密 */
    public static String generateKey() { 
   
        try { 
   
            SecureRandom localSecureRandom = SecureRandom.getInstance(SHA1PRNG);
            byte[] bytes_key = new byte[20];
            localSecureRandom.nextBytes(bytes_key);
            String str_key = toHex(bytes_key);
            return str_key;
        } catch (Exception e) { 
   
            e.printStackTrace();
        }
        return null;
    }

    /** * 对密钥进行处理 * * @param seed * @return * @throws Exception */
    private static byte[] getRawKey(byte[] seed) throws Exception { 
   
        KeyGenerator kgen = KeyGenerator.getInstance(AES);
        //for android
        SecureRandom sr = null;
        // 在4.2以上版本中，SecureRandom获取方式发生了改变
        int sdk_version = android.os.Build.VERSION.SDK_INT;
        if (sdk_version > 23) { 
     // Android 6.0 以上
            sr = SecureRandom.getInstance(SHA1PRNG, new CryptoProvider());
        } else if (android.os.Build.VERSION.SDK_INT >= 17) { 
      //4.2及以上
            sr = SecureRandom.getInstance(SHA1PRNG, "Crypto");
        } else { 
   
            sr = SecureRandom.getInstance(SHA1PRNG);
        }


        // for Java
        // secureRandom = SecureRandom.getInstance(SHA1PRNG);
        sr.setSeed(seed);
        kgen.init(128, sr); //256 bits or 128 bits,192bits
        //AES中128位密钥版本有10个加密循环，192比特密钥版本有12个加密循环，256比特密钥版本则有14个加密循环。
        SecretKey skey = kgen.generateKey();
        byte[] raw = skey.getEncoded();
        return raw;
    }

    /** * 加密 */
    public static String encrypt(String key, String cleartext) { 
   
        if (TextUtils.isEmpty(cleartext)) { 
   
            return cleartext;
        }
        try { 
   
            byte[] result = encrypt(key, cleartext.getBytes());
            // return Base64Encoder.encode(result);
            return new String(Base64.encode(result, Base64.DEFAULT));
        } catch (Exception e) { 
   
            e.printStackTrace();
        }
        return null;
    }

    /** * 加密 */
    private static byte[] encrypt(String key, byte[] clear) throws Exception { 
   
        byte[] raw = getRawKey(key.getBytes());
        SecretKeySpec skeySpec = new SecretKeySpec(raw, AES);
        Cipher cipher = Cipher.getInstance(CBC_PKCS5_PADDING);
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec, new IvParameterSpec(new byte[cipher.getBlockSize()]));
        byte[] encrypted = cipher.doFinal(clear);
        return encrypted;
    }

    /** * 解密 */
    public static String decrypt(String key, String encrypted) { 
   
        if (TextUtils.isEmpty(encrypted)) { 
   
            return encrypted;
        }
        try { 
   
            // byte[] enc = Base64Decoder.decodeToBytes(encrypted);
            byte[] enc = Base64.decode(encrypted, Base64.DEFAULT);
            byte[] result = decrypt(key, enc);
            return new String(result);
        } catch (Exception e) { 
   
            e.printStackTrace();
        }
        return null;
    }

    /** * 解密 */
    private static byte[] decrypt(String key, byte[] encrypted) throws Exception { 
   
        byte[] raw = getRawKey(key.getBytes());
        SecretKeySpec skeySpec = new SecretKeySpec(raw, AES);
        Cipher cipher = Cipher.getInstance(CBC_PKCS5_PADDING);
        cipher.init(Cipher.DECRYPT_MODE, skeySpec, new IvParameterSpec(new byte[cipher.getBlockSize()]));
        byte[] decrypted = cipher.doFinal(encrypted);
        return decrypted;
    }

    //二进制转字符
    public static String toHex(byte[] buf) { 
   
        if (buf == null)
            return "";
        StringBuffer result = new StringBuffer(2 * buf.length);
        for (int i = 0; i < buf.length; i++) { 
   
            appendHex(result, buf[i]);
        }
        return result.toString();
    }

    private static void appendHex(StringBuffer sb, byte b) { 
   
        sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));
    }


    // 增加 CryptoProvider 类

    public static class CryptoProvider extends Provider { 
   
        /** * Creates a Provider and puts parameters */
        public CryptoProvider() { 
   
            super("Crypto", 1.0, "HARMONY (SHA1 digest; SecureRandom; SHA1withDSA signature)");
            put("SecureRandom.SHA1PRNG",
                    "org.apache.harmony.security.provider.crypto.SHA1PRNG_SecureRandomImpl");
            put("SecureRandom.SHA1PRNG ImplementedIn", "Software");
        }
    }
}

DES加密

DES(Data Encryption Standard，数据加密算法) 是IBM公司于1975年研究成功并公开发表的，是一种堆成加密算法. 

 	private final static String HEX = "0123456789ABCDEF";
    private final static String TRANSFORMATION = "DES/CBC/PKCS5Padding";//DES是加密方式 CBC是工作模式 PKCS5Padding是填充模式
    private final static String IVPARAMETERSPEC = "01020304";初始化向量参数，AES 为16bytes. DES 为8bytes.
    private final static String ALGORITHM = "DES";//DES是加密方式
    private static final String SHA1PRNG = "SHA1PRNG"; SHA1PRNG 强随机种子算法, 要区别4.2以上版本的调用方法

/* * 生成随机数，可以当做动态的密钥 加密和解密的密钥必须一致，不然将不能解密 */
    public static String generateKey() { 
   
        try { 
   
            SecureRandom localSecureRandom = SecureRandom.getInstance(SHA1PRNG);
            byte[] bytes_key = new byte[20];
            localSecureRandom.nextBytes(bytes_key);
            String str_key = toHex(bytes_key);
            return str_key;
        } catch (Exception e) { 
   
            e.printStackTrace();
        }
        return null;
    }

    //二进制转字符
    public static String toHex(byte[] buf) { 
   
        if (buf == null)
            return "";
        StringBuffer result = new StringBuffer(2 * buf.length);
        for (int i = 0; i < buf.length; i++) { 
   
            appendHex(result, buf[i]);
        }
        return result.toString();
    }

    private static void appendHex(StringBuffer sb, byte b) { 
   
        sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));
    }
  // 对密钥进行处理
    private static Key getRawKey(String key) throws Exception { 
   
        KeyGenerator kgen = KeyGenerator.getInstance(ALGORITHM);
        //for android
        SecureRandom sr = null;
        // 在4.2以上版本中，SecureRandom获取方式发生了改变
        if (android.os.Build.VERSION.SDK_INT >= 17) { 
   
            sr = SecureRandom.getInstance(SHA1PRNG, "Crypto");
        } else { 
   
            sr = SecureRandom.getInstance(SHA1PRNG);
        }
        // for Java
        // secureRandom = SecureRandom.getInstance(SHA1PRNG);
        sr.setSeed(key.getBytes());
        kgen.init(64, sr); //DES固定格式为64bits，即8bytes。
        SecretKey skey = kgen.generateKey();
        byte[] raw = skey.getEncoded();
        return new SecretKeySpec(raw, ALGORITHM);
    }
/** * DES算法，加密 * * @param data 待加密字符串 * @param key 加密私钥，长度不能够小于8位 * @return 加密后的字节数组，一般结合Base64编码使用 */
    public static String encode(String key, String data) { 
   
        return encode(key, data.getBytes());
    }


    /** * DES算法，加密 * * @param data 待加密字符串 * @param key 加密私钥，长度不能够小于8位 * @return 加密后的字节数组，一般结合Base64编码使用 */
    public static String encode(String key, byte[] data) { 
   
        try { 
   
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            IvParameterSpec iv = new IvParameterSpec(IVPARAMETERSPEC.getBytes());
            cipher.init(Cipher.ENCRYPT_MODE, getRawKey(key), iv);
            byte[] bytes = cipher.doFinal(data);
            return Base64.encodeToString(bytes, Base64.DEFAULT);
        } catch (Exception e) { 
   
            return null;
        }
    }
  /** * 获取编码后的值 * * @param key * @param data * @return */
    public static String decode(String key, String data) { 
   
        return decode(key, Base64.decode(data, Base64.DEFAULT));
    }

    /** * DES算法，解密 * * @param data 待解密字符串 * @param key 解密私钥，长度不能够小于8位 * @return 解密后的字节数组 */
    public static String decode(String key, byte[] data) { 
   
        try { 
   
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            IvParameterSpec iv = new IvParameterSpec(IVPARAMETERSPEC.getBytes());
            cipher.init(Cipher.DECRYPT_MODE, getRawKey(key), iv);
            byte[] original = cipher.doFinal(data);
            String originalString = new String(original);
            return originalString;
        } catch (Exception e) { 
   
            return null;
        }
    }

DES知识扩展：3DES

3DES是DES加密算法的一种模式，它使用3条64位的密钥对数据进行三次加密。数据加密标准（DES）是美国的一种由来已久的加密标准，它使用对称密钥加密法。3DES（即Triple DES）是DES向AES过渡的加密算法（1999年，NIST将3-DES指定为过渡的加密标准），是DES的一个更安全的变形。它以DES为基本模块，通过组合分组方法设计出分组加密算法。

DES与AES比较：

当时被问起采用DES加密内心深处我是拒绝的。单纯从名字上看AES(Advanced Encryption Standard)高级加密标准，安全性要高于DES，其实AES的出现本身就是为了取代DES的，AES具有比DES更好的安全性、效率、灵活性，所以对称加密优先采用AES。

RSA加密

RSA加密算法是一种非对称加密算法，非对称加密算法需要两个密钥：公共密钥和私有密钥。公钥和私钥是配对的，用公钥加密的数据只有配对的私钥才能解密。

RSA对加密数据的长度有限制，一般为密钥的长度值-11，要加密较长的数据，可以采用数据截取的方法，分段加密。

特点是加密速度比较慢，但是安全性比较高；

使用场景：

文件或数据在本地使用公钥或私钥加密，加密后的数据传送到服务器，服务器使用同一套密钥中的私钥或者公钥进行解密。

public class RSAUtils { 
   
    //构建Cipher实例时所传入的的字符串，默认为"RSA/NONE/PKCS1Padding"
    private static String sTransform = "RSA/NONE/PKCS1Padding";

    //进行Base64转码时的flag设置，默认为Base64.DEFAULT
    private static int sBase64Mode = Base64.DEFAULT;
    //初始化方法，设置参数
    public static void init(String transform,int base64Mode){ 
   
        sTransform = transform;
        sBase64Mode = base64Mode;
    }
    //产生密钥对
    public static KeyPair generateRSAKeyPair(int keyLength){ 
   
        KeyPair keyPair=null;
        try { 
   
            KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("RSA");
            //设置密钥长度
            keyPairGenerator.initialize(keyLength);
            //产生密钥对
            keyPair=keyPairGenerator.generateKeyPair();
        } catch (NoSuchAlgorithmException e) { 
   
            e.printStackTrace();
        }
        return keyPair;
    }

    /** * 加密或解密数据的通用的方法,srcData:待处理的数据；key:公钥或者私钥，mode指 * 加密还是解密，值为Cipher.ENCRYPT_MODE或者Cipher.DECRYPT_MODE */
    public static byte[]processDAta(byte[]srcData, Key key,int mode){ 
   
        //用来保存处理的结果
        byte[]resultBytes=null;
        //构建Cipher对象，需要传入一个字符串，格式必须为"algorithm/mode/padding"或者"algorithm/",意为"算法/加密模式/填充方式"
        try { 
   
            Cipher cipher=Cipher.getInstance("RSA/NONE/PKCS1Padding");
            //初始化Cipher,mode指定是加密还是解密，key为公钥或密钥
            cipher.init(mode,key);
            //处理数据
            resultBytes=cipher.doFinal(srcData);
        } catch (Exception e) { 
   
            e.printStackTrace();
        }
        return resultBytes;
    }
    //使用公钥加密数据，结果用Base64转码
    public static String encryptDataByPublicKey(byte[]srcData, PublicKey publicKey){ 
   
        byte[]resultBytes=processDAta(srcData,publicKey,Cipher.ENCRYPT_MODE);
        return Base64.encodeToString(resultBytes,sBase64Mode);
    }
    //使用私钥解密，结果用Base64转码
    public static byte[]decryptDataByPrivate(String encryptedData, PrivateKey privateKey){ 
   
        byte[]bytes=Base64.decode(encryptedData,sBase64Mode);
        return processDAta(bytes,privateKey,Cipher.DECRYPT_MODE);
    }

    //使用私钥解密，返回解码数据
    public static String decryptToStrByPrivate(String encryptedData,PrivateKey privateKey){ 
   
        return new String(decryptDataByPrivate(encryptedData,privateKey));
    }

}

总结

（1） 对称加密加密与解密使用的是同样的密钥，所以速度快，但由于需要将密钥在网络传输，所以安全性不高。

（2） 非对称加密使用了一对密钥，公钥与私钥，所以安全性高，但加密与解密速度慢。

（3） 解决的办法是将对称加密的密钥使用非对称加密的公钥进行加密，然后发送出去，接收方使用私钥进行解密得到对称加密的密钥，然后双方可以使用对称加密来进行沟通。

使用

在Android开发中，一般只用到Base64，MD5，RSA，DES。

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/145359.html原文链接：https://javaforall.cn

相关文章