Android中常见的数据加密和编码方式

最新推荐文章于 2024-03-29 22:22:07 发布

NicholasYzd

最新推荐文章于 2024-03-29 22:22:07 发布

阅读量1.6k

点赞数 2

文章标签：加密编码 android md5 rsa加密

本文链接：https://blog.csdn.net/qq_27942511/article/details/53483724

版权

要点1：MD5算法（单向加密）

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

MD5算法具有以下特点：

1、压缩性：任意长度的数据，算出的MD5值长度都是固定的。
2、容易计算：从原数据计算出MD5值很容易。
3、抗修改性：对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值都有
很大区别。
4、强抗碰撞：已知原数据和其MD5值，想找到一个具有相同MD5值的数据（即伪造
数据）是非常困难的。
MD5的作用是让大容量信息在用数字签名软件签署私人密钥前被”压缩”成一种保密的格式（就是把一个任意长度的字节串变换成一定长的十六进制数字串）。

MD5算法的应用场景：

当用户登录的时候，系统把用户输入的密码计算成MD5值，然后再去和保存在文件系统中的MD5值进行比较，进而确定输入的密码是否正确。通过这样的步骤，系统在并不知道用户密码的明码的情况下就可以确定用户登录系统的合法性。这不但可以避免用户的密码被具有系统管理员权限的用户知道，而且还在一定程度上增加了密码被破解的难度。

代码如下：

 public static String msgToMd5(String psw){
           //银行卡，算法：随机生成一个加密的次数10-30次，根据加密的次数不停的进行md5加密
          StringBuilder sb = new StringBuilder();
           try {
               //数据摘要器'
               //algorithm : 设置加密的方式
              MessageDigest messageDigest = MessageDigest.getInstance("MD5");
               //数据摘要,从一个byte数组中摘要出一部分数据，进行加密，得到一个加密过的byte数组
               //将摘要出来的数据二进制的哈希算法
               byte[] digest = messageDigest.digest(psw.getBytes());
               //进行md5加密操作
               for ( int i = 0; i < digest. length; i++) {
                    //byte : -128 -127
                    int reslut = digest[i] & 0xff; //与int 类型的255进行与运行得到一个 int类型的正整数
                    //因为得到int类型的值可能非常大，为了方便显示，需要转化成十六进制的字符串
                    //第一种
                    //String hexString = Integer.toHexString(reslut)+1;//不规则加密，加盐
                   String hexString = Integer.toHexString(reslut);
                    if (hexString.length() < 2) {
                         //System.out.print("0");
                        sb.append( "0");
                   }
                    //System.out.println(hexString);
                   sb.append(hexString);
              }
               return sb.toString();
          } catch (NoSuchAlgorithmException e) {
              e.printStackTrace();
          }
           return psw;
     }

public static String digest(String content){
    StringBuilder builder = new StringBuilder();
    try {
        MessageDigest msgDitest = MessageDigest.getInstance("MD5");
        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();
}

要点2：SHA1算法（单向加密）

sha1也不可逆，比md5长度更长，所以更安全，但是加密的效率比md5要慢一些，如文件的秒传功能，以及相同的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();
}

要点3：DES算法加密(对称加密)

DES算法为密码体制中的对称密码体制，又被成为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。其密钥长度为56位，明文按64位进行分组，将分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

DES算法的入口参数有三个：Key、Data、Mode。其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密或解密，如果Mode为加密，则用Key去把数据Data进行加密，生成Data的密码形式作为DES的输出结果；如Mode为解密，则用Key去把密码形式的数据Data解密，还原为Data的明码形式作为DES的输出结果。

在使用DES时，双方预先约定使用的“密码”，即Key，然后用Key去加密数据；接收方得到密文后使用同样的Key解密得到原数据，这样便实现了安全性较高的数据传输。
特点：
- 密钥可以自己指定，只有一把密钥,如果密钥暴露,文件就会被暴露，
- 特点是加密速度很快，但是缺点是安全性较低，因为只要密钥暴漏，数据就可以被解密了。

String data = "小鸡炖蘑菇";
String desKey = "青龙偃月刀";// 密钥，口号
boolean isDesEncrypt = false;
private void useDes() {
    try {
        if(isDesEncrypt){
            //解密
            text.setText(Des.decrypt(text.getText().toString(), desKey));
        }else {
            //加密
            text.setText(Des.encrypt(data, desKey));
        }
        isDesEncrypt = !isDesEncrypt;

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

要点4：AES加密（对称加密）

AES即高级加密标准（Advanced Encryption Standard）。随着对称密码的发展,DES数据加密标准算法由于密钥长度较小(56位),已经不适应当今分布式开放网络对数据加密安全性的要求，因此1997年NIST公开征集新的数据加密标准,即AES。AES作为新一代的数据加密标准汇聚了强安全性、高性能、高效率、易用和灵活等优点。
AES算法主要包括三个方面：轮变化、圈数和密钥扩展。AES 是一个迭代的、对称密钥分组的密码，AES加密数据块分组长度必须为128比特，密钥长度可以是128比特、192比特、256比特中的任意一个（如果数据块及密钥长度不足时，会补齐）。与公共密钥密码使用密钥对不同，对称密钥密码使用相同的密钥加密和解密数据。AES 算法是基于置换和代替的。置换是数据的重新排列，而代替是用一个单元数据替换另一个。AES 使用了几种不同的技术来实现置换和替换，加密过程中会进行很多轮的重复和变换。

 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;

public class AESUtils {
    public static final String TAG = "AESUtils";

    public static String encrypt(String seed, String clearText) {
        // Log.d(TAG, "加密前的seed=" + seed + ",内容为:" + clearText);
        byte[] result = null;
        try {
            byte[] rawkey = getRawKey(seed.getBytes());
            result = encrypt(rawkey, clearText.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }
        String content = toHex(result);
        // Log.d(TAG, "加密后的内容为:" + content);
        return content;
    }

    public static String decrypt(String seed, String encrypted) {
        // Log.d(TAG, "解密前的seed=" + seed + ",内容为:" + encrypted);
        byte[] rawKey;
        try {
            rawKey = getRawKey(seed.getBytes());
            byte[] enc = toByte(encrypted);
            byte[] result = decrypt(rawKey, enc);
            String coentn = new String(result);
            // Log.d(TAG, "解密后的内容为:" + coentn);
            return coentn;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    private static byte[] getRawKey(byte[] seed) throws Exception {
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
        sr.setSeed(seed);
        kgen.init(128, sr);
        SecretKey sKey = kgen.generateKey();
        byte[] raw = sKey.getEncoded();
        return raw;
    }

    private static byte[] encrypt(byte[] raw, byte[] clear) throws Exception {
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
         Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec, new IvParameterSpec(
                new byte[cipher.getBlockSize()]));
        byte[] encrypted = cipher.doFinal(clear);
        return encrypted;
    }

    private static byte[] decrypt(byte[] raw, byte[] encrypted)
            throws Exception {
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
         Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, skeySpec, new IvParameterSpec(
                new byte[cipher.getBlockSize()]));
        byte[] decrypted = cipher.doFinal(encrypted);
        return decrypted;
    }

    public static String toHex(String txt) {
        return toHex(txt.getBytes());
    }

    public static String fromHex(String hex) {
        return new String(toByte(hex));
    }

    public static byte[] toByte(String hexString) {
        int len = hexString.length() / 2;
        byte[] result = new byte[len];
        for (int i = 0; i < len; i++)
            result[i] = Integer.valueOf(hexString.substring(2 * i, 2 * i + 2),
                    16).byteValue();
        return result;
    }

    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) {
        final String HEX = "0123456789ABCDEF";
        sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));
    }
}

要点5：RSA加密与解密（非对称加密）

-有两把秘钥，公钥和私钥
-把密钥通常是通过程序生成，不能自己指定
-特点是加密速度慢些，但是安全系数很高
-加密和解密的规则是：公钥加密只能私钥解密，私钥加密只能公钥解密
-应用场景举例：在集成支付宝支付sdk时，需要生成私钥和公钥，公钥-需要设置到支付宝网站的管理后台，在程序中调用支付接口的时候，使用我们自己的私钥进行加密，这样支付宝由于有公钥可以解密，其他人即时劫持了数据，但是没有公钥，也无法解密。

RSA工具类

public class RSACrypt {

    /**
     * 文件读取缓冲区大小
     */
    private static final int CACHE_SIZE = 1024;

    /**
     * <p>
     * BASE64字符串解码为二进制数据
     * </p>
     * 
     * @param base64
     * @return
     * @throws Exception
     */
    public static byte[] decode(String base64) throws Exception {
        return new BASE64Decoder().decodeBuffer(base64);
    }

    /**
     * <p>
     * 二进制数据编码为BASE64字符串
     * </p>
     * 
     * @param bytes
     * @return
     * @throws Exception
     */
    public static String encode(byte[] bytes) throws Exception {
        return new BASE64Encoder().encode(bytes);
    }

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

    public static final String KEY_ALGORITHM = "RSA";

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

    /**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";

    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

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

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

    /**
     * <p>
     * 生成密钥对(公钥和私钥)
     * </p>
     * 
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair(String seed) throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        // SecureRandom secrand = new SecureRandom();
        // secrand.setSeed(seed.getBytes()); // 初始化随机产生器
        // keyPairGen.initialize(1024, secrand);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    /**
     * <p>
     * 用私钥对信息生成数字签名
     * </p>
     * 
     * @param data
     *            已加密数据
     * @param privateKey
     *            私钥(BASE64编码)
     * 
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        return encode(signature.sign());
    }

    /**
     * <p>
     * 校验数字签名
     * </p>
     * 
     * @param data
     *            已加密数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @param sign
     *            数字签名
     * 
     * @return
     * @throws Exception
     * 
     */
    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
        byte[] keyBytes = decode(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(decode(sign));
    }

    /**
     * <P>
     * 私钥解密
     * </p>
     * 
     * @param encryptedData
     *            已加密数据
     * @param privateKey
     *            私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
        byte[] keyBytes = decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
//       Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING");

        cipher.init(Cipher.DECRYPT_MODE, privateK);
        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;
    }

    /**
     * <p>
     * 公钥解密
     * </p>
     * 
     * @param encryptedData
     *            已加密数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
        byte[] keyBytes = decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING");
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        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;
    }

    /**
     * <p>
     * 公钥加密
     * </p>
     * 
     * @param data
     *            源数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
        byte[] keyBytes = decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        // Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING");

        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        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;
    }

    /**
     * <p>
     * 私钥加密
     * </p>
     * 
     * @param data
     *            源数据
     * @param privateKey
     *            私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        // Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING");
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        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;
    }

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

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

}

Demo

try {
            String privateKey = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAKB8GunT65dDzvV4" + "VD6UA9+lGEjIgEtyEVtrp3rEhBRmvOZ1sromkybrAF4ByodHh1BmgBLdImMqMzH2"
                    + "vgwc3ioOqiaODqHNPpqa/jeSrdNE/hJSKQqPXi+qVaIg6tOi84GnirHOrwkVxR45" + "kQgj4lH7qnIaMhooaIModIsDTGs7AgMBAAECgYEAg/Jlwlhtu9mRgDslsKnLoYZA"
                    + "uB65dM5dPPf/JC4MliV+LFEa2Hg8xmOy0pfQZ3dE5rLPnDLaQgQBQZQn3xehBE/N" + "2YdzLEH1Dpw1eOJY30Qf/Rp6jUaTwY5gQCxSDt24CXpDjzo09dvaR4uHhRNZX1KB"
                    + "XNco+PiM7ujFaSrhuBkCQQDQC3d2OhQB4vAaxaPzwqQv6lAFWCR8Osy5jyY/KlVF" + "kd/VzXp2uWACgFm6UXmUwyLfrSpFl013E5SjOsdgpXYNAkEAxXoqed1TYAHHS63N"
                    + "oIQlMz/ygHiMtkFeoD8HgKYw5TzYCpqlM++2O1VcbTLjQtnwctIe3B3xF7eOZ1Si" + "53KcZwJAdPaNYhWC3BCnJpYI9+ls/1c/R9HnKUSxhn05Zne5WxSJAB22hPrxRFa+"
                    + "m2Zk8ULH33LuehN3RMPoY+CO6QH9HQJBAK9+JrtP7iU2z2a42TEZ3nlSDe8PsnTR" + "WQdtm/w/NNqznIan8cJa+AZ4kH/WplIlneJcSuJwlW3vSNUZSQAIQWcCQHBsB41q"
                    + "WyyPcRBjMCR6YO4Iih/07kZJDAqHrdnhea+aNF+MPuShqIGlcDEbdeS1XxUp8gSm" + "diXEh5aJvpTfSEY=";

            String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCgfBrp0+uXQ871eFQ+lAPfpRhI" + "yIBLchFba6d6xIQUZrzmdbK6JpMm6wBeAcqHR4dQZoAS3SJjKjMx9r4MHN4qDqom"
                    + "jg6hzT6amv43kq3TRP4SUikKj14vqlWiIOrTovOBp4qxzq8JFcUeOZEII+JR+6py" + "GjIaKGiDKHSLA0xrOwIDAQAB";

            System.out.println("privateKey=" + privateKey);
            System.err.println("私钥加密——公钥解密");
            String source = "hyx_912_74571852356eb1dd4902f66c9c7ad103e8285d010d27488b";
            System.out.println("原文字：\r\n" + source);
            byte[] data = source.getBytes();
            // byte[] encodedData = RSACrypt.encryptByPrivateKey(data, privateKey);
            byte[] encodedData = RSACrypt.encryptByPublicKey(data, publicKey);
            String enBaseDate = RSACrypt.encode(encodedData);
            System.out.println("加密后：\r\n" + enBaseDate);
            // byte[] decryptByPublicKey = RSACrypt.decryptByPublicKey(encodedData, publicKey);
            byte[] decryptByPublicKey = RSACrypt.decryptByPrivateKey(encodedData, privateKey);
            System.out.println("解密后：\r\n" + new String(decryptByPublicKey));
        } catch (Exception e) {
            e.printStackTrace();
        }

要点6：URL编码

URL编码：http协议中请求的url不支持中文和特殊字符(如&?)，所以需要对url进行编码和解码，编码使用的是URLEncoder，解码使用的是URLDecoder；
//进行url编码
URLEncoder.encode(url)
//进行url解码
URLDecoder.decode(encodeUrl)

要点7：BASE64编码

Base64：可以将二进制数据对象转为字符串，主要用于在http传输中将一些比较大的比如二进制数据，编码为字符串，适合放入url进行传递，而且具有非明文行。应用场景如下：
-将图片等文件进行base64编码为字符串后再上传，代码如下：

private void base64Image() {
    Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.ic_launcher);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    bitmap.compress(CompressFormat.PNG, 100, baos);

    byte[] encode = Base64.encode(baos.toByteArray(), Base64.DEFAULT);
    tv_result.setText(new String(encode));
}

将对象进行base64编码为字符串后，可以进行本地缓存，代码如下：

private void base64Object() {
    Object obj = new Object();
    ByteArrayOutputStream bo = new ByteArrayOutputStream();
    ObjectOutputStream oo;
    try {
        oo = new ObjectOutputStream(bo);
        oo.writeObject(obj);
    } catch (IOException e) {
        e.printStackTrace();
    }

    byte[] encode = Base64.encode(bo.toByteArray(), Base64.DEFAULT);
    tv_result.setText(new String(encode));
}