Android中常見的數據加密和編碼方式

要點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));
}

NicholasYzd

發佈了28 篇原創文章 · 獲贊 27 · 訪問量 4萬+

私信關注

Android中常見的數據加密和編碼方式

要點1：MD5算法（單向加密）

要點2：SHA1算法（單向加密）

要點3：DES算法加密(對稱加密)

要點4：AES加密（對稱加密）

要點5：RSA加密與解密（非對稱加密）

要點6：URL編碼

要點7：BASE64編碼

MySQL 核心模塊揭祕 | 18 期 | 鎖在內存里長什麼樣*

使用perf工具生成火焰圖

HttpSecurity 是如何組裝過濾器鏈的

數說海南——近6年海南各市縣人口簡單看

長序列中Transformers的高級注意力機制總結

大齡程序員思考

響應式界面控件DevExtreme * 更強的數據分析和可視化功能

Frament的使用教程-回退棧

Fragment的使用教程

動態加載案例

Android DrawerLayout+ToolBar+NavigationView實現側滑菜單效果,沉浸式狀態欄

淺談EventBus框架的使用

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結