Android MD5,3DES,AES,RSA,Base64加解密

導言:
由於數據的安全性,所以需要進行數據加密和解密處理,所以本文只是記錄一點

名詞:
對稱加密算法:加密和解密使用相同密鑰的算法
異或加密算法:簡單加密算法的一種,通過異或算法處理
RSA:公鑰和私鑰,非對稱密碼算法
Des:密鑰加載,對稱加密算法
Des3:DES加密算法的擴展，它使用3條64位的密鑰對數據進行三次加密,DES向AES過渡的加密算法
Aes:區塊,對稱加密算法,用來替代Des
Md5:單向不可逆加密算法,但是也是可以編譯的,用跑字典,解決方式多次加密和加鹽
SHA:單向不可逆加密算法,Md5後繼者,有SHA-1，SHA-2(SHA-224、SHA-384,SHA-512),如Google將使用SHA-2
Base64:對數據內容進行編碼轉換適合網絡傳輸,由於傳輸過程中那些不可見ascii碼被處理錯誤

步驟:
1:MD5加密,很簡單,直接將需要加密的字符串傳入即可.


public static String MD5Tool(String str) {
        if (TextUtils.isEmpty(str)) {
            return "";
        }
        try {
            MessageDigest mDigest = MessageDigest.getInstance("MD5");
            byte[] bytes = mDigest.digest(str.getBytes());
            String result = "";
            for (byte bt : bytes) {
                String temp = Integer.toHexString(bt & 0xff);
                if (temp.length() == 1) {
                    temp = "0" + temp;
                }
                result += temp;
            }
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

2:3DES重要加密解密類


public class DES3Util {
    private static final String TYPE = "DESede";

    //加密
    public static byte[] encryptMode(byte[] keybyte, byte[] src) {
        try {
            SecretKey deskey = new SecretKeySpec(keybyte, TYPE);
            Cipher c1 = Cipher.getInstance(TYPE);
            c1.init(Cipher.ENCRYPT_MODE, deskey);
            return c1.doFinal(src);
        } catch (java.security.NoSuchAlgorithmException e1) {
            e1.printStackTrace();
        } catch (javax.crypto.NoSuchPaddingException e2) {
            e2.printStackTrace();
        } catch (java.lang.Exception e3) {
            e3.printStackTrace();
        }
        return null;
    }

    //解密
    public static byte[] decryptMode(byte[] keybyte, byte[] src) {
        try {
            SecretKey deskey = new SecretKeySpec(keybyte, TYPE);
            Cipher c1 = Cipher.getInstance(TYPE);
            c1.init(Cipher.DECRYPT_MODE, deskey);
            return c1.doFinal(src);
        } catch (java.security.NoSuchAlgorithmException e1) {
            e1.printStackTrace();
        } catch (javax.crypto.NoSuchPaddingException e2) {
            e2.printStackTrace();
        } catch (java.lang.Exception e3) {
            e3.printStackTrace();
        }
        return null;
    }

    //byte->hexString
    public static String byte2hex(byte[] b) {
        String hs = "";
        String stmp = "";
        for (int n = 0; n < b.length; n++) {
            stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
            if (stmp.length() == 1) hs = hs + "0" + stmp;
            else hs = hs + stmp;
            if (n < b.length - 1) hs = hs + "";
        }
        return hs.toUpperCase();
    }

    //hexString->byte
    public static byte[] hexStringToBytes(String hexString) {
        if (hexString == null || hexString.equals("")) {
            return null;
        }
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }

    private static byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }
}

3:使用3DES加密解密樣例

//三個不同祕鑰
String key = "B1B2B3B4B5B6B7B8" + "A1A2A3A4A5A6A7A8" + "A1B2A3A4A5A6A7F8";
Sting src="[email protected]";
//加密
String encryResult = byte2hex(encryptMode(hexStringToBytes(key), src.getBytes("UTF-8")));
//解密
String decryptResult = new String(decryptMode(hexStringToBytes(key), hexStringToBytes(encryResult)), "UTF-8");

4:RSA,AES,Base64混合保證數據傳遞的安全性
釋義:
RSA公鑰和私鑰通過Alipay_RSA簽名工具生成,不要用代碼生成,AES每次在客戶端自動隨機生成.

流程:android<—>服務器後臺是雙向的
android:
1:RSA公鑰a–加密–>AES祕鑰b---->加密的AES祕鑰c
2:AES祕鑰b–加密–>原數據d---->加密數據e

服務器後臺:
1:RSA私鑰f–解密–>加密的AES祕鑰c---->AES祕鑰b
2:AES祕鑰b–解密–>加密數據e---->原數據d

public class RSAESUtils {
    private static String sTransform = "RSA/NONE/PKCS1Padding";
    private static int sBase64Mode = Base64.DEFAULT;

    //RSA產生密鑰對,經常通過第三方工具支付寶生成,而不是用代碼生成,所以這個方法忽略
    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;
    }

    //RSA加密或解密數據的通用方法
    private static byte[] processData(byte[] srcData, Key key, int mode) {
        //用來保存處理結果
        byte[] resultBytes = null;
        try {
            //獲取Cipher實例
            Cipher cipher = Cipher.getInstance(sTransform);
            //初始化Cipher，mode指定是加密還是解密，key爲公鑰或私鑰
            cipher.init(mode, key);
            //處理數據
            resultBytes = cipher.doFinal(srcData);
        } 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();
        }
        return resultBytes;
    }

    //RSA使用公鑰加密數據，結果用Base64轉碼
    public static String encryptDataByPublicKey(byte[] srcData, PublicKey publicKey) {
        byte[] resultBytes = processData(srcData, publicKey, Cipher.ENCRYPT_MODE);
        return Base64.encodeToString(resultBytes, sBase64Mode);
    }

    //RSA使用私鑰解密，返回解碼數據
    public static byte[] decryptDataByPrivate(String encryptedData, PrivateKey privateKey) {
        byte[] bytes = Base64.decode(encryptedData, sBase64Mode);
        return processData(bytes, privateKey, Cipher.DECRYPT_MODE);
    }

    //RSA使用私鑰進行解密，解密數據轉換爲字符串，使用utf-8編碼格式
    public static String decryptedToStrByPrivate(String encryptedData, PrivateKey privateKey) {
        return new String(decryptDataByPrivate(encryptedData, privateKey));
    }

    //RSA使用私鑰解密，解密數據轉換爲字符串，並指定字符集
    public static String decryptedToStrByPrivate(String encryptedData, PrivateKey privateKey, String charset) {
        try {
            return new String(decryptDataByPrivate(encryptedData, privateKey), charset);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    //RSA使用私鑰加密，結果用Base64轉碼
    public static String encryptDataByPrivateKey(byte[] srcData, PrivateKey privateKey) {
        byte[] resultBytes = processData(srcData, privateKey, Cipher.ENCRYPT_MODE);
        return Base64.encodeToString(resultBytes, sBase64Mode);
    }

    //RSA使用公鑰解密，返回解密數據
    public static byte[] decryptDataByPublicKey(String encryptedData, PublicKey publicKey) {
        byte[] bytes = Base64.decode(encryptedData, sBase64Mode);
        return processData(bytes, publicKey, Cipher.DECRYPT_MODE);
    }

    //RSA使用公鑰解密，結果轉換爲字符串，使用默認字符集utf-8
    public static String decryptedToStrByPublicKey(String encryptedData, PublicKey publicKey) {
        return new String(decryptDataByPublicKey(encryptedData, publicKey));
    }

    //RSA使用公鑰解密，結果轉換爲字符串，使用指定字符集
    public static String decryptedToStrByPublicKey(String encryptedData, PublicKey publicKey, String charset) {
        try {
            return new String(decryptDataByPublicKey(encryptedData, publicKey), charset);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    //RSA將字符串形式的公鑰轉換爲公鑰對象
    public static PublicKey keyStrToPublicKey(String publicKeyStr) {
        PublicKey publicKey = null;
        byte[] keyBytes = Base64.decode(publicKeyStr, sBase64Mode);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        try {
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            publicKey = keyFactory.generatePublic(keySpec);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return publicKey;
    }

    //RSA將字符串形式的私鑰，轉換爲私鑰對象
    public static PrivateKey keyStrToPrivate(String privateKeyStr) {
        PrivateKey privateKey = null;
        byte[] keyBytes = Base64.decode(privateKeyStr, sBase64Mode);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        try {
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            privateKey = keyFactory.generatePrivate(keySpec);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return privateKey;
    }

    //生成AES祕鑰
    public static byte[] generateAESKey(int keySize) {
        //保存AES密鑰的字節數組
        byte[] keyBytes = null;
        try {
            //獲取密鑰生成器
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            //設置密鑰長度，如果不調用該方法，默認生成256位的密鑰
            keyGenerator.init(keySize);
            //獲得密鑰對象
            SecretKey secretKey = keyGenerator.generateKey();
            //轉成字節數組
            keyBytes = secretKey.getEncoded();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return keyBytes;
    }

    //AES初始化向量IV
    private static byte[] generatorIvBytes(int blockSize) {
        Random random = new Random();
        byte[] ivParam = new byte[blockSize];
        for (int index = 0; index < blockSize; index++) {
            ivParam[index] = (byte) random.nextInt(256);
        }
        return ivParam;
    }

    //AES ECB模式加密
    public static String encryptDataByECB(String srcData) {
        String finalResult = null;
        //產生密鑰
        byte[] keyBytes = generateAESKey(256);
        //構建SecretKeySpec，初始化Cipher對象時需要該參數
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "AES");
        try {
            //構建Cipher對象，需要傳入一個字符串，格式必須爲"algorithm/mode/padding"或者"algorithm/"
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            //初始化Cipher對象
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
            //加密數據
            byte[] resultBytes = cipher.doFinal(srcData.getBytes());
            //結果用Base64轉碼
            finalResult = Base64.encodeToString(resultBytes, Base64.DEFAULT);
        } 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();
        }
        return finalResult;
    }

    //AES ECB模式解密
    public static String decryptDataByECB(String srcData, byte[] keyBytes, String transform) {
        byte[] clearData = null;
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "AES");
        try {
            //根據格式獲取Cipher實例，需與加密時一致
            Cipher cipher = Cipher.getInstance(transform);
            //初始化Cipher，注意這裏變爲解密模式
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
            //先Base64解碼
            byte[] temp = Base64.decode(srcData, Base64.DEFAULT);
            //解密數據
            clearData = cipher.doFinal(temp);
        } 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();
        }
        return new String(clearData);
    }

    //AES CBC模式加密
    public static String encryptDataByCBC(String srcData) {
        String finalResult = null;
        //產生密鑰
        byte[] keyBytes = generateAESKey(256);
        //構建SecretKeySpec，初始化Cipher對象時需要該參數
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "AES");
        try {
            //構建Cipher對象，需要傳入一個字符串，格式必須爲"algorithm/mode/padding"或者"algorithm/"
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            //初始化Cipher對象
            byte[] ivBytes = generatorIvBytes(keyBytes.length);
            IvParameterSpec ivParameterSpec = new IvParameterSpec(ivBytes);
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
            //加密數據
            byte[] resultBytes = cipher.doFinal(srcData.getBytes());
            //結果用Base64轉碼
            finalResult = Base64.encodeToString(resultBytes, Base64.DEFAULT);
        } 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();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        }
        return finalResult;
    }

    //AES CBC模式解密
    public static String decryptDataByCBC(String srcData, byte[] keyBytes, byte[] ivBytes, String transform) {
        byte[] clearData = null;
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "AES");
        try {
            //根據格式獲取Cipher實例，需與加密時一致
            Cipher cipher = Cipher.getInstance(transform);
            //初始化Cipher，注意這裏變爲解密模式
            IvParameterSpec ivParameterSpec = new IvParameterSpec(ivBytes);
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);
            //先Base64解碼
            byte[] temp = Base64.decode(srcData, Base64.DEFAULT);
            //解密數據
            clearData = cipher.doFinal(temp);
        } 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();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        }
        return new String(clearData);
    }
}

結束

Android MD5,3DES,AES,RSA,Base64加解密

一鍵自動化博客發佈工具,用過的人都說好(頭條篇)

美團一面：項目中有 10000 個 if else 如何優化？想了半天，被問懵了！

01 穩定性（一）如何應對事故並做好覆盤？

線程池那些坑爹的參數-核心線程數&最大線程數&工作隊列

Stream流常用方法總結

Android MD5,3DES,AES,RSA,Base64加解密

Android接口回調實例

Android Framework學習筆記

GitHub搜索

AGPBI kind error text Android resource linking failed

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

linux以太網驅動總結