精华内容
下载资源
问答
  • 常用的加密算法有哪些

    千次阅读 2016-12-08 14:47:57
    常见的对称加密算法有DES、3DES、和AES等; 对称加密 指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解性。假设两个用户需要使用对称加密方法加密然后交换...

    常见的加密算法可以分成三类,对称加密算法,非对称加密算法和Hash算法。

    指加密和解密使用相同密钥的加密算法。

    常见的对称加密算法有DES、3DES、和AES等;


    对称加密
    指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解性。假设两个用户需要使用对称加密方法加密然后交换数据,则用户最少需要2个密钥并交换使用,如果企业内用户有n个,则整个企业共需要n×(n-1) 个密钥,密钥的生成和分发将成为企业信息部门的恶梦。对称加密算法的安全性取决于加密密钥的保存情况,但要求企业中每一个持有密钥的人都保守秘密是不可能的,他们通常会有意无意的把密钥泄漏出去——如果一个用户使用的密钥被入侵者所获得,入侵者便可以读取该用户密钥加密的所有文档,如果整个企业共用一个加密密钥,那整个企业文档的保密性便无从谈起。
    常见的对称加密算法有DES、3DES、Blowfish、IDEA、RC4、RC5、RC6和AES

    非对称加密
    指加密和解密使用不同密钥的加密算法,也称为公私钥加密。假设两个用户要加密交换数据,双方交换公钥,使用时一方用对方的公钥加密,另一方即可用自己的私钥解密。如果企业中有n个用户,企业需要生成n对密钥,并分发n个公钥。由于公钥是可以公开的,用户只要保管好自己的私钥即可,因此加密密钥的分发将变得十分简单。同时,由于每个用户的私钥是唯一的,其他用户除了可以可以通过信息发送者的公钥来验证信息的来源是否真实,还可以确保发送者无法否认曾发送过该信息。非对称加密的缺点是加解密速度要远远慢于对称加密,在某些极端情况下,甚至能比非对称加密慢上1000倍。
    常见的非对称加密算法有:RSA、ECC(移动设备用)、Diffie-Hellman、El Gamal、DSA(数字签名用)
    Hash算法
    Hash算法特别的地方在于它是一种单向算法,用户可以通过Hash算法对目标信息生成一段特定长度的唯一的Hash值,却不能通过这个Hash值重新获得目标信息。因此Hash算法常用在不可还原的密码存储、信息完整性校验等。
    常见的Hash算法有MD2、MD4、MD5、HAVAL、SHA
    加密算法的效能通常可以按照算法本身的复杂程度、密钥长度(密钥越长越安全)、加解密速度等来衡量。上述的算法中,除了DES密钥长度不够、MD2速度较慢已逐渐被淘汰外,其他算法仍在目前的加密系统产品中使用。

    展开全文
  • 常见不可逆加密算法有MD5,HMAC,SHA1、SHA-224、SHA-256、SHA-384,和SHA-512,其中SHA-224、SHA-256、SHA-384,和SHA-512我们可以统称为SHA2加密算法,SHA加密算法安全性要比MD5更高,而SHA2加密算法比SHA1...

    加密算法我们整体可以分为:可逆加密和不可逆加密,可逆加密又可以分为:对称加密和非对称加密。

    一、不可逆加密

    常见的不可逆加密算法有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算法有以下特点:

    1、压缩性:无论数据长度是多少,计算出来的MD5值长度相同

    2、容易计算性:由原数据容易计算出MD5值

    3、抗修改性:即便修改一个字节,计算出来的MD5值也会巨大差异

    4、抗碰撞性:知道数据和MD5值,很小概率找到相同MD5值相同的原数据。

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

    如果要使用不可逆加密,推荐使用SHA256、SHA384、SHA512以及HMAC-SHA256、HMAC-SHA384、HMAC-SHA512这几种算法。

    二、对称加密算法

    对称加密算法是应用比较早的算法,在数据加密和解密的时用的都是同一个密钥,这就造成了密钥管理困难的问题。常见的对称加密算法有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。

    三、非对称加密算法

    非对称加密算法有两个密钥,这两个密钥完全不同但又完全匹配。只有使用匹配的一对公钥和私钥,才能完成对明文的加密和解密过程。常见的非对称加密有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();
    }
    

    四、加密盐

    加密盐也是比较常听到的一个概念,盐就是一个随机字符串用来和我们的加密串拼接后进行加密。加盐主要是为了提供加密字符串的安全性。假如有一个加盐后的加密串,黑客通过一定手段这个加密串,他拿到的明文,并不是我们加密前的字符串,而是加密前的字符串和盐组合的字符串,这样相对来说又增加了字符串的安全性。

    比较推荐的几个加密算法有:

    • 不可逆加密:SHA256、SHA384、SHA512以及HMAC-SHA256、HMAC-SHA384、HMAC-SHA512
    • 对称加密算法:AES、3DES
    • 非对称加密算法:RSA

    感谢你看到这里,我是程序员麦冬,一个java开发从业者,深耕行业六年了,每天都会分享java相关技术文章或行业资讯

    欢迎大家关注和转发文章,后期还有福利赠送!

    展开全文
  • 常见加密算法有哪些?是否对称

    千次阅读 2020-01-06 09:28:04
    常用的对称加密算法:DES、AES、3DES、RC2、RC4 常用的非对称加密算法:RSA、DSA、ECC 单向散列函数的加密算法:MD5、SHA 【Java面试题与答案】整理推荐 基础与语法 集合 网络编程 并发编程 Web 安全 ...
    • 常用的对称加密算法:DES、AES、3DES、RC2、RC4
    • 常用的非对称加密算法:RSA、DSA、ECC
    • 单向散列函数的加密算法:MD5、SHA

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • 常见不可逆加密算法有MD5,HMAC,SHA1、SHA-224、SHA-256、SHA-384,和SHA-512,其中SHA-224、SHA-256、SHA-384,和SHA-512我们可以统称为SHA2加密算法,SHA加密算法安全性要比MD5更高,而SHA2加密算法比SHA1...

    加密算法我们整体可以分为:可逆加密和不可逆加密,可逆加密又可以分为:对称加密和非对称加密。

    一、不可逆加密

    常见的不可逆加密算法有MD5HMACSHA1SHA-224SHA-256SHA-384,和SHA-512,其中SHA-224SHA-256SHA-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算法有以下特点:

    1、压缩性:无论数据长度是多少,计算出来的MD5值长度相同

    2、容易计算性:由原数据容易计算出MD5

    3、抗修改性:即便修改一个字节,计算出来的MD5值也会巨大差异

    4、抗碰撞性:知道数据和MD5值,很小概率找到相同MD5值相同的原数据。

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

    如果要使用不可逆加密,推荐使用SHA256、SHA384、SHA512以及HMAC-SHA256、HMAC-SHA384、HMAC-SHA512这几种算法。

    二、对称加密算法

    对称加密算法是应用比较早的算法,在数据加密和解密的时用的都是同一个密钥,这就造成了密钥管理困难的问题。常见的对称加密算法有DES3DESAES128AES192AES256(默认安装的JDK尚不支持AES256,需要安装对应的jce补丁进行升级jce1.7jce1.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)是DESAES过渡的加密算法,它使用3条56位的密钥对数据进行三次加密。是DES的一个更安全的变形。它以DES为基本模块,通过组合分组方法设计出分组加密算法。比起最初的DES3DES更为安全。密钥长度默认为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;
    }

    推荐使用对称加密算法有:AES128AES192AES256

    三、非对称加密算法

    非对称加密算法有两个密钥,这两个密钥完全不同但又完全匹配。只有使用匹配的一对公钥和私钥,才能完成对明文的加密和解密过程。常见的非对称加密有RSASM2等。

    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();
    }

    四、加密盐

    加密盐也是比较常听到的一个概念,盐就是一个随机字符串用来和我们的加密串拼接后进行加密。加盐主要是为了提供加密字符串的安全性。假如有一个加盐后的加密串,黑客通过一定手段这个加密串,他拿到的明文,并不是我们加密前的字符串,而是加密前的字符串和盐组合的字符串,这样相对来说又增加了字符串的安全性。

    文中的一些算法来源于网络,可直接复制使用

    比较推荐的几个加密算法有:

    • 不可逆加密:SHA256SHA384SHA512以及HMAC-SHA256HMAC-SHA384HMAC-SHA512

    • 对称加密算法:AES3DES

    • 非对称加密算法:RSA

    展开全文
  • 为什么需要使用配置中心常用的配置管理解决方案有哪些缺点?答:配置管理解决方案的缺点:硬编码(缺点:需要修改代码、繁琐、风险大)写在properties文件里面(缺点:在集群环境下,需要替换和重启)写在xml配置...
  • 常见加密算法可以分成三类,对称加密算法,非对称加密算法和Hash算法。 对称加密 指加密和解密使用相同密钥加密算法。对称加密算法的优点在于加解密高速度和使用长密钥时难破解性。假设两个用户需要...
  • 加密,解密话,分为,对称加密,和非对称加密。 像 des,aes 就是对称加密 非对称 RSA,DSA,等。 对称和非对称是指,加密和解密时候,是不是需要同一个秘钥。非对称加密,使用私钥和公钥两种秘钥。 支付宝...
  • 加密算法简介

    2018-12-13 17:20:36
    加密算法有哪些类别? 1.对称加密算法 如:DES,3DES,DESX,Blowfish,IDEA,RC4,RC5,RC6,AES 2.非对称加密算法 如:RSA,ECC,Diffie-hellman,EI Gamal,DSA 3.Hash算法 如:MD2,MD4,MD5,H...
  • 要经过数个节点才能到达目的地,在这个过程中难免会被别有用心的人监听(现在常用的网络数据监听软件就charles,具体可以查看相关使用教程,通过这个软件可以监听到某个页面用到了哪些接口,发送以及返回的参数...
  • 常用的加密有哪些对称加密(加密解密密钥相同):DES、DES3、AES非对称加密(分公钥私钥):RSA信息摘要算法/签名算法:MD5、HMAC、SHA学习资源推荐冷月大佬的博客 : https://lengyue.me/突破前端反调试--阻...
  • (1)、常用的对称加解密有哪些? (2)、加解密的模式 【ecb】这种模式是将整个明文分成若干段相同的小段,然后对每一小段进行加密 【cbc】这种模式是先将明文切分成若干小段,然后每一小段与初始块或者上一段的...
  • [817]JS加密--基础总结

    2020-05-25 23:38:20
    常用的加密有哪些对称加密(加密解密密钥相同):DES、DES3、AES 非对称加密(分公钥私钥):RSA 信息摘要算法/签名算法:MD5、HMAC、SHA 学习资源推荐 冷月大佬的博客 : https://lengyue.me/ 突破前端反调试–...
  • 中和农信 Java一面

    2020-11-25 11:37:59
    这次面试给我感觉就是很底层,被吊打一次...四次挥手过程,osi七层协议,tcp是那一层,数据链路层有哪些协议,https和http区别, 非对称加密算法有哪些,我就说了一个MD5算法, 接着问,那MD5怎么加密解密, 非对
  • 阿里巴巴面经

    2018-09-21 21:38:15
    阿里巴巴电话面试: 1快速排序算法,归并排序算法的怎么实现,以及他们复杂度?...常用加密的方法有哪些? 5.get与post区别? SSL是什么,以及他实现机制? 总结get和post区别—面试用 • get参数通过url...
  • 2.7 生成非对称加密的公钥和私钥 35 2.8 使用RSA算法进行加密和解密 37 2.8.1使用RSA公钥进行加密 37 2.8.2使用RSA私钥进行解密 40 2.9 使用密钥协定创建共享密钥 42 2.9.1创建DH公钥和私钥 43 2.9.2创建共享密钥 46...
  • 网络安全:非对称加密、数字签名、数字证书 网络攻击:DDOS、XSS、CSRF 跨域攻击 怎么学? 计算机网络面试一道非常经典面试题:说说你从URL输入到最终页面展现过程。这一题可以覆盖大部分计网知识点,可以...
  • C#编程经验技巧宝典

    热门讨论 2008-06-01 08:59:33
    58 <br>0081 文本中首字母改为大写 59 <br>0082 C#随机数产生 59 <br>0083 身份证从15位升至18位算法 60 <br>0084 十进制数转二进制数的算法 60 <br>0085 十进制数转八进制数的算法 61...

空空如也

空空如也

1 2
收藏数 21
精华内容 8
关键字:

常用的对称加密算法有哪些