Android常見的加密和算法

　　1.不可逆的算法

　　主要為MD5和SHA-1算法。(二者都不屬於加密只能算作一種算法)

　　相同點：都是使用目前比較廣泛的散列(Hash)函數，就是把任意長度的輸入，變換成固定長度的輸出，該輸出就是散列值。計算的時候所有的數據都參與了運算，其中任何一個數據變化了都會導致計算出來的Hash值完全不同。（理論上來講產生的密文都有可能產生碰撞）

　　不同點：MD5輸出是128位的，SHA-1輸出是160位的，MD5比SHA1運行速度快，SHA1比MD5強度高。MD5一般用於文件的校驗，SHA-1主要使用於數字簽名標准。

　　MD5使用：

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++){
            // TODO: 2019/11/10 需要再了解一下 
            builder.append(Integer.toHexString(digests[i] & 0xff +8));//+8為加鹽操作
        }
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    return  builder.toString();
}

　　SHA-1使用：

public static String sha1Digest(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++){
           // TODO: 2019/11/10 再了解一下 
           builder.append(Integer.toHexString(digests[i] & 0xff +8));//+8為加鹽操作
       }
   } catch (NoSuchAlgorithmException e) {
       e.printStackTrace();
   }
   return  builder.toString();
}

　　2.可逆算法

　　其中可逆算法按照密鑰的數量和加密規則又分為對稱加密和非對稱加密。

　　(1)對稱加密

　　密鑰可以自己指定，只有一把密鑰。常用的對稱加密算法有DES和AES兩種。對稱加密的速度快，但是缺點是安全性低，因為只要密鑰暴漏，數據就可以被解密。

　　AES加密解密使用：

package com.cn;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Scanner;

public class SymmetricEncoder {
    /*
     * 加密
     * 1.構造密鑰生成器
     * 2.根據ecnodeRules規則初始化密鑰生成器
     * 3.產生密鑰
     * 4.創建和初始化密碼器
     * 5.內容加密
     * 6.返回字符串
     */
    public static String AESEncode(String encodeRules,String content){
        try {
            //1.構造密鑰生成器，指定為AES算法,不區分大小寫
            KeyGenerator keygen=KeyGenerator.getInstance("AES");
            //2.根據ecnodeRules規則初始化密鑰生成器
            //生成一個128位的隨機源,根據傳入的字節數組
            keygen.init(128, new SecureRandom(encodeRules.getBytes()));
            //3.產生原始對稱密鑰
            SecretKey original_key=keygen.generateKey();
            //4.獲得原始對稱密鑰的字節數組
            byte [] raw=original_key.getEncoded();
            //5.根據字節數組生成AES密鑰
            SecretKey key=new SecretKeySpec(raw, "AES");
            //6.根據指定算法AES自成密碼器
            Cipher cipher=Cipher.getInstance("AES");
            //7.初始化密碼器，第一個參數為加密(Encrypt_mode)或者解密解密(Decrypt_mode)操作，第二個參數為使用的KEY
            cipher.init(Cipher.ENCRYPT_MODE, key);
            //8.獲取加密內容的字節數組(這里要設置為utf-8)不然內容中如果有中文和英文混合中文就會解密為亂碼
            byte [] byte_encode=content.getBytes("utf-8");
            //9.根據密碼器的初始化方式--加密：將數據加密
            byte [] byte_AES=cipher.doFinal(byte_encode);
            //10.將加密后的數據轉換為字符串
            //這里用Base64Encoder中會找不到包
            //解決辦法：
            //在項目的Build path中先移除JRE System Library，再添加庫JRE System Library，重新編譯后就一切正常了。
            String AES_encode=new String(new BASE64Encoder().encode(byte_AES));
            //11.將字符串返回
            return AES_encode;
        } 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();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        //如果有錯就返加null
        return null;
    }
    /*
     * 解密
     * 解密過程：
     * 1.同加密1-4步
     * 2.將加密后的字符串反紡成byte[]數組
     * 3.將加密內容解密
     */
    public static String AESDncode(String encodeRules,String content){
        try {
            //1.構造密鑰生成器，指定為AES算法,不區分大小寫
            KeyGenerator keygen=KeyGenerator.getInstance("AES");
            //2.根據ecnodeRules規則初始化密鑰生成器
            //生成一個128位的隨機源,根據傳入的字節數組
            keygen.init(128, new SecureRandom(encodeRules.getBytes()));
            //3.產生原始對稱密鑰
            SecretKey original_key=keygen.generateKey();
            //4.獲得原始對稱密鑰的字節數組
            byte [] raw=original_key.getEncoded();
            //5.根據字節數組生成AES密鑰
            SecretKey key=new SecretKeySpec(raw, "AES");
            //6.根據指定算法AES自成密碼器
            Cipher cipher=Cipher.getInstance("AES");
            //7.初始化密碼器，第一個參數為加密(Encrypt_mode)或者解密(Decrypt_mode)操作，第二個參數為使用的KEY
            cipher.init(Cipher.DECRYPT_MODE, key);
            //8.將加密並編碼后的內容解碼成字節數組
            byte [] byte_content= new BASE64Decoder().decodeBuffer(content);
            /*
             * 解密
             */
            byte [] byte_decode=cipher.doFinal(byte_content);
            String AES_decode=new String(byte_decode,"utf-8");
            return AES_decode;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }

        //如果有錯就返加null
        return null;
    }

    public static void main(String[] args) {
        SymmetricEncoder se=new SymmetricEncoder();
        Scanner scanner=new Scanner(System.in);
        /*
         * 加密
         */
        System.out.println("使用AES對稱加密，請輸入加密的規則");
        String encodeRules=scanner.next();
        System.out.println("請輸入要加密的內容:");
        String content = scanner.next();
        System.out.println("根據輸入的規則"+encodeRules+"加密后的密文是:"+se.AESEncode(encodeRules, content));

        /*
         * 解密
         */
        System.out.println("使用AES對稱解密，請輸入加密的規則：(須與加密相同)");
        encodeRules=scanner.next();
        System.out.println("請輸入要解密的內容（密文）:");
        content = scanner.next();
        System.out.println("根據輸入的規則"+encodeRules+"解密后的明文是:"+se.AESDncode(encodeRules, content));
    }
}

 　　DES加密解密使用：

package com.cn;

import javax.crypto.*;
import javax.crypto.spec.DESKeySpec;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;

public class DESUtil {
    public static byte[] encode(String mes) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException, InvalidKeySpecException, InvalidAlgorithmParameterException {
        SecureRandom random = new SecureRandom();
        // TODO: 2019/11/10 密鑰長度應該是要大於8
        DESKeySpec desKey = new DESKeySpec("123abc123".getBytes());
        //創建一個密匙工廠，然后用它把DESKeySpec轉換成
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey securekey = keyFactory.generateSecret(desKey);
        //Cipher對象實際完成加密操作
        Cipher cipher = Cipher.getInstance("DES");
        //用密匙初始化Cipher對象
        cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
        return cipher.doFinal(mes.getBytes());
    }

    public static byte[] decode(byte[] encodeBytes) throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, BadPaddingException, IllegalBlockSizeException {
        // DES算法要求有一個可信任的隨機數源
        SecureRandom random = new SecureRandom();
        // 創建一個DESKeySpec對象
        DESKeySpec desKey = new DESKeySpec("123abc123".getBytes());
        // 創建一個密匙工廠
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        // 將DESKeySpec對象轉換成SecretKey對象
        SecretKey securekey = keyFactory.generateSecret(desKey);
        // Cipher對象實際完成解密操作
        Cipher cipher = Cipher.getInstance("DES");
        // 用密匙初始化Cipher對象
        cipher.init(Cipher.DECRYPT_MODE, securekey, random);
        // 真正開始解密操作
        return cipher.doFinal(encodeBytes);
    }
}

　　(2)非對稱加密

　　常見的非對稱加密算法是RSA；他有兩把密鑰，且是由程序生成的，不能自己指定；特點是加密速度比較慢，但是安全性比較高；加密和解密的規則是：公鑰加密只能私鑰解密，私鑰加密只能公鑰解密。

package com.cn;

import android.util.Base64;

import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

public class RSAUtil {
    private static Map<Integer, String> keyMap = new HashMap<Integer, String>();  //用於封裝隨機產生的公鑰與私鑰
    public static void main(String[] args) throws Exception {
        //生成公鑰和私鑰
        genKeyPair();
        //加密字符串
        String message = "abc12301230";
        System.out.println("隨機生成的公鑰為:" + keyMap.get(0));
        System.out.println("隨機生成的私鑰為:" + keyMap.get(1));
        String messageEn = encrypt(message,keyMap.get(0));
        System.out.println(message + "\t加密后的字符串為:" + messageEn);
        String messageDe = decrypt(messageEn,keyMap.get(1));
        System.out.println("還原后的字符串為:" + messageDe);
    }

    /**
     * 隨機生成密鑰對
     * @throws NoSuchAlgorithmException
     */
    public static void genKeyPair() throws NoSuchAlgorithmException {
        // KeyPairGenerator類用於生成公鑰和私鑰對，基於RSA算法生成對象
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
        // 初始化密鑰對生成器，密鑰大小為96-1024位
        keyPairGen.initialize(1024,new SecureRandom());
        // 生成一個密鑰對，保存在keyPair中
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();   // 得到私鑰
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  // 得到公鑰
        String publicKeyString = new String(Base64.encode(publicKey.getEncoded(), 0));
        // 得到私鑰字符串
        String privateKeyString = new String(Base64.encode(privateKey.getEncoded(), 0));
        // 將公鑰和私鑰保存到Map
        keyMap.put(0,publicKeyString);  //0表示公鑰
        keyMap.put(1,privateKeyString);  //1表示私鑰
    }
    /**
     * RSA公鑰加密
     *
     * @param str
     *            加密字符串
     * @param publicKey
     *            公鑰
     * @return 密文
     * @throws Exception
     *             加密過程中的異常信息
     */
    public static String encrypt(String str, String publicKey) throws Exception{
        //base64編碼的公鑰
        byte[] decoded = Base64.decode(publicKey, 0);
        RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
        //RSA加密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        String outStr = new String(Base64.encode(cipher.doFinal(str.getBytes("UTF-8")), 0));
        return outStr;
    }

    /**
     * RSA私鑰解密
     *
     * @param str
     *            加密字符串
     * @param privateKey
     *            私鑰
     * @return 銘文
     * @throws Exception
     *             解密過程中的異常信息
     */
    public static String decrypt(String str, String privateKey) throws Exception{
        //64位解碼加密后的字符串
        byte[] inputByte = Base64.decode(str.getBytes(), 0);
        //base64編碼的私鑰
        byte[] decoded = Base64.decode(privateKey, 0);
        RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));
        //RSA解密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, priKey);
        String outStr = new String(cipher.doFinal(inputByte));
        return outStr;
    }
}

　　// TODO   AES加密模式， padding填充模式？？

 

　　參考資料：https://www.cnblogs.com/yegong0214/p/6498409.html

　　　　　　   https://blog.csdn.net/u011897782/article/details/81163387

　　　　　　   https://blog.csdn.net/joshho/article/details/88716314

　　　　　　　 https://www.cnblogs.com/jying/p/9511247.html

　　　　　　    https://blog.csdn.net/qy20115549/article/details/83105736

　　　　　　　// TODO

　　　　　　  https://www.cnblogs.com/think-in-java/p/5527389.html