面試官：說一下你經常使用的加密算法

時間  2020-12-06
標籤 java 算法 安全 網絡 dom 函數 網站 加密 spa 設計 欄目 快樂工作 简体版
原文   原文鏈接

加密算法咱們總體能夠分爲：可逆加密和不可逆加密，可逆加密又能夠分爲：對稱加密和非對稱加密。java

1、不可逆加密

常見的不可逆加密算法有MD5，HMAC，SHA1、SHA-224、SHA-256、SHA-384，和SHA-512，其中SHA-224、SHA-256、SHA-384，和SHA-512咱們能夠統稱爲SHA2加密算法，SHA加密算法的安全性要比MD5更高，而SHA2加密算法比SHA1的要高。其中SHA後面的數字表示的是加密後的字符串長度，SHA1默認會產生一個160位的信息摘要。算法

不可逆加密算法最大的特色就是密鑰，可是HMAC是須要密鑰的【手動狗頭】。安全

因爲這些加密都是不可逆的，所以比較經常使用的場景就是用戶密碼加密，其驗證過程就是經過比較兩個加密後的字符串是否同樣來確認身份的。網上也有不少自稱是能夠破解MD5密碼的網站，其原理也是同樣，就是有一個巨大的資源庫，存放了許多字符串及對應的MD5加密後的字符串，經過你輸入的MD5加密串來進行比較，若是過你的密碼複雜度比較低，仍是有很大機率驗證出來的。網絡

1.1 MD5

MD5信息摘要算法（英語：MD5 Message-Digest Algorithm），一種被普遍使用的密碼散列函數，能夠產生出一個128位（16字節）的散列值（hash value），用於確保信息傳輸完整一致。

MD5算法有如下特色：dom

一、壓縮性：不管數據長度是多少，計算出來的MD5值長度相同函數

二、容易計算性：由原數據容易計算出MD5值網站

三、抗修改性：即使修改一個字節，計算出來的MD5值也會巨大差別加密

四、抗碰撞性：知道數據和MD5值，很小几率找到相同MD5值相同的原數據。spa

public static String md5(String text) {
    MessageDigest messageDigest = null;
    try {
        messageDigest = MessageDigest.getInstance("MD5");
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    byte[] bytes = messageDigest.digest(text.getBytes());
    return Hex.encodeHexString(bytes); 
}

1.2 SHA系列

安全散列算法（英語：Secure Hash Algorithm，縮寫爲SHA）是一個密碼散列函數家族，是FIPS所認證的安全散列算法。能計算出一個數字消息所對應到的，長度固定的字符串（又稱消息摘要）的算法。且若輸入的消息不一樣，它們對應到不一樣字符串的機率很高。

2005年8月17日的CRYPTO會議尾聲中王小云、姚期智、姚儲楓再度發表更有效率的SHA-1攻擊法，能在2的63次方個計算複雜度內找到碰撞。設計

也就是說SHA-1加密算法有碰撞的可能性，雖然很小。

public static String sha256(String text) {
    MessageDigest messageDigest = null;
    try {
        messageDigest = MessageDigest.getInstance("SHA-256");
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    byte[] bytes = messageDigest.digest(text.getBytes()); 
    return Hex.encodeHexString(bytes); 
}

1.3 HMAC系列

HMAC是密鑰相關的哈希運算消息認證碼（Hash-based Message Authentication Code）的縮寫，由H.Krawezyk，M.Bellare，R.Canetti於1996年提出的一種基於Hash函數和密鑰進行消息認證的方法，並於1997年做爲RFC2104被公佈，並在 IPSec和其餘網絡協議（如 SSL）中得以普遍應用，如今已經成爲事實上的Internet安全標準。它能夠與任何迭代散列函數捆綁使用。

HMAC算法更像是一種加密算法，它引入了密鑰，其安全性已經不徹底依賴於所使用的Hash算法

public static String hmacSha256(String text, SecretKeySpec sk) {
    Mac mac = null;
    try {
        mac = Mac.getInstance("HmacSHA256");
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    try {
        mac.init(sk);
    } catch (InvalidKeyException e) {
        e.printStackTrace();
    }
    byte[] rawHmac = mac.doFinal(text.getBytes());
    return new String(Base64.encodeBase64(rawHmac));
}

若是要使用不可逆加密，推薦使用SHA25六、SHA38四、SHA512以及HMAC-SHA25六、HMAC-SHA38四、HMAC-SHA512這幾種算法。

2、對稱加密算法

對稱加密算法是應用比較早的算法，在數據加密和解密的時用的都是同一個密鑰，這就形成了密鑰管理困難的問題。常見的對稱加密算法有DES、3DES、AES128、AES192、AES256 (默認安裝的 JDK 尚不支持 AES256，須要安裝對應的 jce 補丁進行升級 jce1.7，jce1.8)。其中AES後面的數字表明的是密鑰長度。對稱加密算法的安全性相對較低，比較適用的場景就是內網環境中的加解密。

2.1 DES

DES是對稱加密算法領域中的典型算法，其密鑰默認長度爲56位。

// 加密
public static String encrypt(byte[] dataSource, String password){
     try {
         SecureRandom random = new SecureRandom();
         DESKeySpec desKeySpec = new DESKeySpec(password.getBytes());
         //建立一個密匙工廠，而後用它把DESKeySpec轉換成 
         SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES"); 
         SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec); 
         //Cipher對象實際完成加密操做 
         Cipher cipher = Cipher.getInstance("DES"); 
         //用密匙初始化Cipher對象 
         cipher.init(Cipher.ENCRYPT_MODE, secretKey, random); 
         //正式執行加密操做 
         return Base64.encodeBase64String(cipher.doFinal(dataSource)); 
     } catch (Throwable e) { 
         e.printStackTrace(); 
     } return null; 
 } 
// 解密
public static String decrypt(String src, String password) throws Exception{ 
    // DES算法要求有一個可信任的隨機數源 
    SecureRandom random = new SecureRandom(); 
    // 建立一個DESKeySpec對象 
    DESKeySpec desKeySpec = new DESKeySpec(password.getBytes()); 
    // 建立一個密匙工廠 
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); 
    // 將DESKeySpec對象轉換成SecretKey對象 
    SecretKey secretKey = keyFactory.generateSecret(desKeySpec); 
    // Cipher對象實際完成解密操做 
    Cipher cipher = Cipher.getInstance("DES"); 
    // 用密匙初始化Cipher對象 
    cipher.init(Cipher.DECRYPT_MODE, secretKey, random); 
    // 真正開始解密操做 
    return new String(cipher.doFinal(Base64.decodeBase64(src))); 
}

2.2 3DES

3DES（即Triple DES）是DES向AES過渡的加密算法，它使用3條56位的密鑰對數據進行三次加密。是DES的一個更安全的變形。它以DES爲基本模塊，經過組合分組方法設計出分組加密算法。比起最初的DES，3DES更爲安全。密鑰長度默認爲168位，還能夠選擇128位。

public static String encryptThreeDESECB(String src, String key) {
    try{
        DESedeKeySpec dks = new DESedeKeySpec(key.getBytes("UTF-8"));
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede");
        SecretKey securekey = keyFactory.generateSecret(dks);

        Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, securekey);
        byte[] b = cipher.doFinal(src.getBytes("UTF-8"));

        String ss = new String(Base64.encodeBase64(b));
        ss = ss.replaceAll("\\+", "-");
        ss = ss.replaceAll("/", "_");
        return ss;
    } catch(Exception ex){
        ex.printStackTrace();
        return src;
    }
}

public static String decryptThreeDESECB(String src, String key) {
    try{
        src = src.replaceAll("-", "+");
        src = src.replaceAll("_", "/");
        byte[] bytesrc = Base64.decodeBase64(src.getBytes("UTF-8"));
        // --解密的key
        DESedeKeySpec dks = new DESedeKeySpec(key.getBytes("UTF-8"));
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede");
        SecretKey securekey = keyFactory.generateSecret(dks);

        // --Chipher對象解密
        Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, securekey);
        byte[] retByte = cipher.doFinal(bytesrc);

        return new String(retByte, "UTF-8");
    } catch(Exception ex){
        ex.printStackTrace();
        return src;
    }
}

2.3 AES

AES 高級數據加密標準，可以有效抵禦已知的針對DES算法的全部攻擊，默認密鑰長度爲128位，還能夠供選擇192位，256位。這裏順便提一句這個位指的是bit。

private static final String defaultCharset = "UTF-8";
private static final String KEY_AES = "AES";
private static final String KEY_MD5 = "MD5";
private static MessageDigest md5Digest;
static {
    try {
        md5Digest = MessageDigest.getInstance(KEY_MD5);
    } catch (NoSuchAlgorithmException e) {

    }
}
/**
  * 加密
  */
public static String encrypt(String data, String key) {
    return doAES(data, key, Cipher.ENCRYPT_MODE);
}
/**
  * 解密
  */
public static String decrypt(String data, String key) {
    return doAES(data, key, Cipher.DECRYPT_MODE);
}


/**
  * 加解密
  */
private static String doAES(String data, String key, int mode) {
    try {
        boolean encrypt = mode == Cipher.ENCRYPT_MODE;
        byte[] content;
        if (encrypt) {
            content = data.getBytes(defaultCharset);
        } else {
            content = Base64.decodeBase64(data.getBytes());
        }
        SecretKeySpec keySpec = new SecretKeySpec(md5Digest.digest(key.getBytes(defaultCharset))
                                                  , KEY_AES);
        Cipher cipher = Cipher.getInstance(KEY_AES);// 建立密碼器
        cipher.init(mode, keySpec);// 初始化
        byte[] result = cipher.doFinal(content);
        if (encrypt) {
            return new String(Base64.encodeBase64(result));
        } else {
            return new String(result, defaultCharset);
        }
    } catch (Exception e) {
    }
    return null;
}

推薦使用對稱加密算法有：AES128、AES192、AES256。

3、非對稱加密算法

非對稱加密算法有兩個密鑰，這兩個密鑰徹底不一樣但又徹底匹配。只有使用匹配的一對公鑰和私鑰，才能完成對明文的加密和解密過程。常見的非對稱加密有RSA、SM2等。

3.1 RSA

RSA密鑰至少爲500位長，通常推薦使用1024位。

//非對稱密鑰算法
public static final String KEY_ALGORITHM = "RSA";

/**
  * 密鑰長度，DH算法的默認密鑰長度是1024
  * 密鑰長度必須是64的倍數，在512到65536位之間
  */
private static final int KEY_SIZE = 1024;
//公鑰
private static final String PUBLIC_KEY = "RSAPublicKey";
//私鑰
private static final String PRIVATE_KEY = "RSAPrivateKey";
/**
  * 初始化密鑰對
  *
  * @return Map 甲方密鑰的Map
  */
public static Map<String, Object> initKey() throws Exception {
    //實例化密鑰生成器
    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    //初始化密鑰生成器
    keyPairGenerator.initialize(KEY_SIZE);
    //生成密鑰對
    KeyPair keyPair = keyPairGenerator.generateKeyPair();
    //甲方公鑰
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    //甲方私鑰
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    //將密鑰存儲在map中
    Map<String, Object> keyMap = new HashMap<String, Object>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);
    return keyMap;
}
/**
  * 私鑰加密
  *
  * @param data 待加密數據
  * @param key  密鑰
  * @return byte[] 加密數據
  */
public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception {

    //取得私鑰
    PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    //生成私鑰
    PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
    //數據加密
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, privateKey);
    return cipher.doFinal(data);
}

/**
  * 公鑰加密
  *
  * @param data 待加密數據
  * @param key  密鑰
  * @return byte[] 加密數據
  */
public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {

    //實例化密鑰工廠
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    //初始化公鑰
    //密鑰材料轉換
    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
    //產生公鑰
    PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
    //數據加密
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, pubKey);
    return cipher.doFinal(data);
}

/**
  * 私鑰解密
  *
  * @param data 待解密數據
  * @param key  密鑰
  * @return byte[] 解密數據
  */
public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception {
    //取得私鑰
    PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    //生成私鑰
    PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
    //數據解密
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, privateKey);
    return cipher.doFinal(data);
}

/**
  * 公鑰解密
  *
  * @param data 待解密數據
  * @param key  密鑰
  * @return byte[] 解密數據
  */
public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception {

    //實例化密鑰工廠
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    //初始化公鑰
    //密鑰材料轉換
    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
    //產生公鑰
    PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
    //數據解密
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, pubKey);
    return cipher.doFinal(data);
}

/**
  * 取得私鑰
  *
  * @param keyMap 密鑰map
  * @return byte[] 私鑰
  */
public static byte[] getPrivateKey(Map<String, Object> keyMap) {
    Key key = (Key) keyMap.get(PRIVATE_KEY);
    return key.getEncoded();
}

/**
  * 取得公鑰
  *
  * @param keyMap 密鑰map
  * @return byte[] 公鑰
  */
public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
    Key key = (Key) keyMap.get(PUBLIC_KEY);
    return key.getEncoded();
}

4、加密鹽

加密鹽也是比較常聽到的一個概念，鹽就是一個隨機字符串用來和咱們的加密串拼接後進行加密。加鹽主要是爲了提供加密字符串的安全性。假若有一個加鹽後的加密串，黑客經過必定手段這個加密串，他拿到的明文，並非咱們加密前的字符串，而是加密前的字符串和鹽組合的字符串，這樣相對來講又增長了字符串的安全性。

文中的一些算法來源於網絡，可直接複製使用。

比較推薦的幾個加密算法有：

  • 不可逆加密：SHA256、SHA384、SHA512以及HMAC-SHA256、HMAC-SHA384、HMAC-SHA512
  • 對稱加密算法：AES、3DES
  • 非對稱加密算法：RSA

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程