java常见加密算法比较总结

  SHA是一种数据加密算法， 该算法经过加密专家多年来的发展和改进已日益完善，现在已成为公认的最安全的散列算法之一，并被广泛使用。该算法的思想是接收一段明文，然后以一种不可逆 的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也 称为信息摘要或信息认证代码）的过程。散列函数值可以说是对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。
  安全散列算法SHA（Secure Hash Algorithm，SHA)是美国国家标准技术研究所发布的国家标准FIPS PUB 180，最新的标准已经于2008年更新到FIPS PUB 180-3。其中规定了SHA-1，SHA-224，SHA-256，SHA-384，和SHA-512这几种单向散列算法。SHA-1，SHA-224和SHA-256适用于长度不超过2^{64二进制位的消息。SHA-384和SHA-512适用于长度不超过2}128二进制位的消息。
  BASE64编码算法不算是真正的加密算法。
  MD5、SHA、HMAC这三种加密算法，可谓是非可逆加密，就是不可解密的加密方法，我们称之为单向加密算法。我们通常只把他们作为加密的基础。单纯的以上三种的加密并不可靠。

AES：对称算法适合大数据量的加解密处理，就是快，密匙不易管理。
测试

package com.zyu.webmoudle.EncryptionTest;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.UUID;



/*
* 高级加密标准（英语：Advanced Encryption Standard，缩写：AES）是一种对称加密算法，
* 加密时需要使用密钥，密钥长度则可以是128，192或256比特，高级加密标准已然成为对称密钥加密中最流行的算法之一。
* AES是DES的代替品，用于传输敏感敏感的铭文，如常见的密码不能明文传输
* */
public class AESUtil {

    /**
     * @param key 密钥
     *
     * @param content 需要加密的字符串
     * @return 密文字节数组
     */
    public static byte[] encrypt(String key, String content) {
        byte[] rawKey = genKey(key.getBytes());
        try {
            SecretKeySpec secretKeySpec = new SecretKeySpec(rawKey, "AES");
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
            byte[] encypted = cipher.doFinal(content.getBytes());
            return encypted;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * @param encrypted 密文字节数组
     * @param key 密钥
     * @return 解密后的字符串
     */
    public static String decrypt(byte[] encrypted, String key) {
        byte[] rawKey = genKey(key.getBytes());
        try {
            SecretKeySpec secretKeySpec = new SecretKeySpec(rawKey, "AES");
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
            byte[] decrypted = cipher.doFinal(encrypted);
            return new String(decrypted);
        } catch (Exception e) {
            return "";
        }
    }

    /**
     * @param seed 种子数据
     * @return 密钥数据
     */
    private static byte[] genKey(byte[] seed) {
        byte[] rawKey = null;
        try {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
            secureRandom.setSeed(seed);
            // AES加密数据块分组长度必须为128比特，密钥长度可以是128比特、192比特、256比特中的任意一个
            kgen.init(128, secureRandom);
            SecretKey secretKey = kgen.generateKey();
            rawKey = secretKey.getEncoded();
        } catch (NoSuchAlgorithmException e) {
        }
        return rawKey;
    }


    public static void main(String[] args) {
        // 密钥的种子，可以是任何形式，本质是字节数组
        String key = UUID.randomUUID().toString();

        // 密码的明文
        String clearPwd = "123456";

        // 密码加密后的密文
        byte[] encryptedByteArr = encrypt(key, clearPwd);
        String encryptedPwd = new String(encryptedByteArr);
        System.out.println(encryptedPwd);

        // 解密后的字符串
        String decryptedPwd = decrypt(encryptedByteArr, key);
        System.out.println(decryptedPwd);
    }

}

RSA：非对称加密，慢，适合小数据量的加解密、数据签名等，密匙比较容易管理，安全性目前来说是非常高的。
测试

package com.zyu.webmoudle.EncryptionTest;

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;


/*
*非对称加密算法
* */
public class RSA {
    /**
     * 生成密钥对
     * @return
     * @throws Exception
     */
    public static KeyPair genKeyPair() throws Exception{
        KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("RSA");
        // 一般为1024，为了更安全最好采用2048
        keyPairGenerator.initialize(1024);
        return keyPairGenerator.generateKeyPair();
    }

    /**
     * 公钥加密
     * @param content
     * @param publicKey
     * @return
     * @throws Exception
     */
    public static byte[] encrypt(byte[] content, PublicKey publicKey) throws Exception{
        // java默认"RSA"="RSA/ECB/PKCS1Padding"
        Cipher cipher=Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(content);
    }

    /**
     * 私钥解密
     * @param content
     * @param privateKey
     * @return
     * @throws Exception
     */
    public static byte[] decrypt(byte[] content, PrivateKey privateKey) throws Exception{
        Cipher cipher=Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(content);
    }

    public static void main(String[] args) throws Exception {
        String data = "123456";

        KeyPair keyPair= genKeyPair();

        //获取公钥，并以base64格式打印出来
        PublicKey publicKey=keyPair.getPublic();
        //System.out.println("公钥："+new String(Base64.getEncoder().encode(publicKey.getEncoded())));
        System.out.println("公钥："+publicKey);


        //获取私钥，并以base64格式打印出来
        PrivateKey privateKey=keyPair.getPrivate();
        //System.out.println("私钥："+new String(Base64.getEncoder().encode(privateKey.getEncoded())));
        System.out.println("私钥："+privateKey);

        //公钥加密
        byte[] encryptedBytes=encrypt(data.getBytes(), publicKey);
        //System.out.println("加密后："+new String(encryptedBytes));
        System.out.println("加密后："+encryptedBytes);


        //私钥解密
        byte[] decryptedBytes=decrypt(encryptedBytes, privateKey);
        System.out.println("解密后："+new String(decryptedBytes));
    }
}