0
0

Java加密总结：常见哈希算法总结、对称式加密与非对称式加密的对比

哈希算法

** 概述**

    哈希算法又称摘要算法，将任意一组数据利用指定算法得到一个固定长度的字节数组(输出摘要)，目的是为了验证原始数据是否被篡改；

特点

       当原始数据相同时，经过哈希算法所得到的结果一定相同

       当原始数据不同时，经过哈希算法所得到的结果可能相同（哈希碰撞）

哈希碰撞：输入两个不同数据得到相同的输出结果；当然哈希碰撞是不可避免的，原因是输出字节的长度是固定的，而输入的数据长度却是不固定的，将一个无限的输入集合映射到一个有限的输出集合，必然会产生碰撞

一个安全的哈希算法必须满足：碰撞概率低、输出结果无规律

输出结果无规律：输入任意一个bit所造成的输出结果完全不同，很难从输出结果反推出输入数据（只能依赖暴力穷举）

用途

** 校验下载文件**

    判断下载到本地的软件是否是未经篡改的文件？我们只需要自己计算一下本地文件的哈希值，再与官网公开的哈希值对比，如果相同，说明文件下载正确，否则，说明文件已被篡改。

** 储存用户密码**

    如果将用户的原始口令直接存放到数据库中，数据库数据一旦泄漏，黑客会直接获取用户明文口令。那么我们就应该存储用户口令的哈希，例如在用户输入原始口令后，系统计算用户输入的原始口令的MD5并与数据库存储的MD5对比，如果一致，说明口令正确，否则，口令错误。即使数据库泄漏，黑客也无法拿到用户的原始口令。想要拿到用户的原始口令，必须用暴力穷举的方法逐个尝试直到某个口令计算的MD5恰好等于指定值。
     使用哈希口令时，还要注意防止彩虹表攻击。彩虹表是一个预先计算好的常用口令，用彩虹表和它们的MD5表对照，如果用户使用了常用口令，黑客从MD5一下就能反查到原始口令； 这就是为什么不要使用常用密码，以及不要使用生日作为密码的原因。

常用哈希算法

算法输出长度（位）输出字节长度MD5128 bits16 bytesSHA-1160 bits20 bytesRipeMD-160160 bits20 bytesSHA-256256 bits32 bytesSHA-512512 bits****64 bytes

SHA-1

    Java标准库提供了常用的算法，并且不同算法的代码形式相同，我们以SHA-1为例，观察如何利用哈希算法得到加密字节数组:

public class Hash01 {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        //获取基于SHA-1加密算法的工具对象
        MessageDigest mds=MessageDigest.getInstance("SHA-1");
        
        //更新原始数据
        mds.update("hello".getBytes());
        mds.update("would".getBytes());
        
        //获取加密后的结果
        byte[] resultByteArray=mds.digest();
        System.out.println("加密后字节数组结果："+Arrays.toString(resultByteArray));
        
        //只要内容相同，加密结果就相同
        MessageDigest tempMds=MessageDigest.getInstance("SHA-1");
        tempMds.update("hellowould".getBytes());
        byte[] tempresultByteArray=tempMds.digest();
        System.out.println("相同数据加密后字节数组结果："+Arrays.toString(tempresultByteArray));
    }
}

代码输出结果：

加密后字节数组结果：[-123, -47, -11, -94, -101, -78, -6, -76, 41, -73, 26, 14, -124, 5, -17, -28, 29, 79, -104, -108]
相同数据加密后字节数组结果：[-123, -47, -11, -94, -101, -78, -6, -76, 41, -73, 26, 14, -124, 5, -17, -28, 29, 79, -104, -108]

我们可以将字节数组处理成一段编码：

        StringBuilder resultStr=new StringBuilder();
        for(byte bit:resultByteArray) {
            resultStr.append(String.format("%02x", bit));
        }
        System.out.println("处理后密文："+resultStr);
        System.out.println("处理后密文长度："+resultStr.length());

编码结果：

处理后密文：85d1f5a29bb2fab429b71a0e8405efe41d4f9894
处理后密文长度：40

    类似的，计算MD5、SHA-256、SHA-512只要传入相应的哈希算法名称，Java标准库支持的哈希算法都可以使用此代码形式得到密文；

RipeMD-160

    不过虽然Java标准库中提供了一系列常用的标准算法，仍然有一些我们想用的某种算法没有在标准库里；

    解决的方式有两种：一是自己写，二是找一个现成的第三方库直接使用

    在这里我们就不得不提到一个第三方开源库：**BouncyCastle **，​​​​​​​它提供了一些Java标准库没有的一些算法，例如：RipeMD160算法；

RipeMD160是基于Merkle-Damgård结构的加密哈希算法，它是比特币的标准之一。RipeMD160是RIPEMD的增强版本，RipeMD160算法可以产生160位哈希摘要；

**用法 **

    在使用RipeMD160算法之前，我们必须要把BouncyCastle ​​​​​​​提供的**bcprov-jdk5on-1.70.jar**添加至classpath，添加成功jar包后，就可以使用java.security包下提供的一种标准机制，允许第三方库无缝接入；

    要使用BouncyCastle ​​​​​​​提供的RipeMD160算法需要先注册BouncyCastle，在这里我们就要提到security类提供的addProvider(Provider provider)方法，他的作用就是：注册bouncycastle类提供的通知类对象BouncyCastleProvider

    public static int addProvider(Provider provider) {
        /*
         * We can't assign a position here because the statically
         * registered providers may not have been installed yet.
         * insertProviderAt() will fix that value after it has
         * loaded the static providers.
         */
        return insertProviderAt(provider, 0);
    }

代码如下：

//使用第三方类库bouncycastle提供RipeMD160算法加密
public class Bouncy01 {
    public static void main(String[] args) {
        try {
            //注册bouncycastle类提供的通知类对象BouncyCastleProvider
            Security.addProvider(new BouncyCastleProvider());
            
            //获取RipeMD160算法的摘要对象（加密信息）
            MessageDigest digest=MessageDigest.getInstance("RipeMD160");
            
            //更新原始数据
            digest.update("helloWould".getBytes());
            
            //获取信息摘要（加密）
            byte[] resultByteArray=digest.digest();
            
            //信息摘要的字节长度和内容
            System.out.println(Arrays.toString(resultByteArray));
            System.out.println(resultByteArray.length);
            
            //十六进制内容字符串
            String hex=new BigInteger(1, resultByteArray).toString(16);
            System.out.println(hex);
            System.out.println(hex.length());
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

对称式加密

概述

     对称加密算法就是传统的用一个密码进行加密和解密；

常用对称算法

*算法密钥长度工作模式填充模式DES56/64ECB/CBC/PCBC/CTR/...*NoPadding/PKCS5Padding/...AES128/192/256*ECB/CBC/PCBC/CTR/...*NoPadding/PKCS5Padding/PKCS7Padding/...IDEA128*ECB*PKCS5Padding/PKCS7Padding/...

注：由于DES密钥过短，可以在短时间内被暴力破解，并不推荐使用

** **密钥长度直接决定加密强度，而工作模式和填充模式相当于是对称算法的参数和格式选择，Java标准库并不包括所有的工作模式和填充模式，一般情况选择常用的就可以了；

AES算法

** **AES算法目前是应用最广泛的加密运算，常见工作模式：ECB、CBC;

ECB模式

** **​​​​​​​ECB模式是最简单的AES加密模式，它只需要一个固定长度的密钥，固定的明文会生成固定的密文，这种一对一的加密方式会导致安全性降低；

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class Aes01 {
    public static void main(String[] args) {
        try {
            //原文
            String password="hello,world";
            
            //128位密钥==16 bytes key
            byte[] key="1234567890abcdef".getBytes();
            
            //加密
            byte[] data=password.getBytes();
            byte[] encrypted=encrypt(key, data);
            System.out.println("加密："+Base64.getEncoder().encodeToString(encrypted));
            
            //解密
            System.out.println("解密："+new String(decrypt(key, encrypted)));
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
    }
    
    //加密
    public static byte[] encrypt(byte[] key,byte[] data) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
        
        //创建密码对象，需要传入算法/工作模式/填充模式
        Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
        
        //根据key的字节内容，回复密钥对象
        SecretKey keySpec=new SecretKeySpec(key, "AES");
        
        //初始化密钥：设置加密模式
        cipher.init(Cipher.ENCRYPT_MODE, keySpec);
        
        //根据原始内容（字节），进行加密
        return cipher.doFinal(data);
                
    }
    
    //解密
    public static byte[] decrypt(byte[] key,byte[] data) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
        
        //创建密码对象，需要传入算法/工作模式/填充模式
        Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
        
        //根据key的字节内容，回复密钥对象
        SecretKey keySpec=new SecretKeySpec(key, "AES");
        
        //初始化密钥：设置解密模式
        cipher.init(Cipher.DECRYPT_MODE, keySpec);
        
        //根据原始内容（字节），进行解密
        return cipher.doFinal(data);
        
    }
}

CBC模式

** **在CBC模式下，需要一个随机生成的16字节IV参数，必须使用SecureRandom生成。因为多了一个IvParameterSpec实例，因此，初始化方法需要调用Cipher的一个重载方法并传入IvParameterSpec。观察输出，可以发现每次生成的IV不同，密文也不同；

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Base64;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class Cbc01 {
    public static void main(String[] args) {
        try {
            //原文
            String password="hello,world";
            
            //128位密钥==16 bytes key
            byte[] key="1234567890abcdef1234567890abcdef".getBytes();
            
            //加密
            byte[] data=password.getBytes();
            byte[] encrypted=encrypt(key, data);
            System.out.println("加密数组："+Arrays.toString(encrypted));
            System.out.println("加密："+Base64.getEncoder().encodeToString(encrypted));
            
            //解密
            System.out.println("解密："+new String(decrypt(key, encrypted)));
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        }
    }
    
    //加密
    public static byte[] encrypt(byte[] key,byte[] data) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException {
        
        //创建密码对象，需要传入算法/工作模式/填充模式
        Cipher cipher=Cipher.getInstance("AES/CBC/PKCS5Padding");
        
        //根据key的字节内容，回复密钥对象
        SecretKey keySpec=new SecretKeySpec(key, "AES");
        
        //CBC模式需要生成一个16bytes的initialization vector(iv)
        SecureRandom random=SecureRandom.getInstanceStrong();
        byte[] iv=random.generateSeed(16);//生成16个字节的随机数
        System.out.println(Arrays.toString(iv));
        IvParameterSpec ivps=new IvParameterSpec(iv);//随机数封装为IvParameterSpec参数
        
        //初始化密钥：设置加密模式，密钥，iv参数
        cipher.init(Cipher.ENCRYPT_MODE, keySpec,ivps);
        
        //加密
        byte[] encry=cipher.doFinal(data);
        
        //iv不需要保密，把iv和密文一起返回
        return join(iv,encry);
                
    }
    
    //解密
    public static byte[] decrypt(byte[] key,byte[] data) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException {
        //把data分割成IV和密文
        byte[] iv=new byte[16];
        byte[] encry=new byte[data.length-16];
        
        System.arraycopy(data, 0, iv, 0, iv.length);//iv
        System.arraycopy(data, iv.length, encry, 0, encry.length);//密文
//        System.out.println(Arrays.toString(iv));
//        System.out.println(Arrays.toString(encry));
        
        
        //解密：
        //创建密码对象，需要传入算法/工作模式/填充模式
        Cipher cipher=Cipher.getInstance("AES/CBC/PKCS5Padding");
        
        //根据key的字节内容，回复密钥对象
        SecretKey keySpec=new SecretKeySpec(key, "AES");
        IvParameterSpec ivps=new IvParameterSpec(iv);
        
        //初始化密钥：设置解密模式
        cipher.init(Cipher.DECRYPT_MODE, keySpec,ivps);
        
        //根据原始内容（字节），进行解密
        return cipher.doFinal(encry);
        
    }
    
    public static byte[] join(byte[] iv,byte[] encry) {
        byte[] r=new byte[iv.length+encry.length];
        System.arraycopy(iv, 0, r, 0, iv.length);
        System.arraycopy(encry, 0, r, iv.length, encry.length);
        System.out.println("iv："+Arrays.toString(iv));
        System.out.println("密文："+Arrays.toString(encry));
        return r;
    }
}

非对称式加密

概述

    非对称加密是指加密和解密使用的不是相同的密钥，只有同一个公钥-私钥对才能正常加解密。典型的非对称式加密算法就是RSA算法；

import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;

import javax.crypto.Cipher;

//RSA
public class KeyPairRSA {
    public static void main(String[] args) throws Exception {
         // 明文:
         byte[] plain = "Hello, encrypt use RSA".getBytes("UTF-8");
         
         // 创建公钥／私钥对:
         Human alice = new Human("Alice");
         
         // 用Alice的公钥加密:
         // 获取Alice的公钥，并输出
         byte[] pk = alice.getPublicKey();
         System.out.println(String.format("publickey(公钥)：%x", new BigInteger(1, pk)));
         
         // 使用公钥加密
         byte[] encrypted = alice.encrypt(plain);
         System.out.println(String.format("encrypted: %x", new BigInteger(1, encrypted)));
        
         // 用Alice的私钥解密:
         // 获取Alice的私钥，并输出
         byte[] sk = alice.getPrivateKey();
         System.out.println(String.format("privatekey(私钥)：%x", new BigInteger(1, sk)));
         
         // 使用私钥解密
         byte[] decrypted = alice.decrypt(encrypted);
         System.out.println(new String(decrypted, "UTF-8"));
     }
}

//用户类
class Human {
        // 姓名
     String name;
     
     // 私钥:
     PrivateKey sk;
     
     // 公钥:
     PublicKey pk;
    
     // 构造方法
      public Human(String name) throws GeneralSecurityException {
         // 初始化姓名
         this.name = name;
         
         // 生成公钥／私钥对:
         KeyPairGenerator kpGen = KeyPairGenerator.getInstance("RSA");
         kpGen.initialize(1024);
         KeyPair kp = kpGen.generateKeyPair();
         
         this.sk = kp.getPrivate();
         this.pk = kp.getPublic();
     }
    
     // 把私钥导出为字节
     public byte[] getPrivateKey() {
         return this.sk.getEncoded();
     }
    
     // 把公钥导出为字节
     public byte[] getPublicKey() {
         return this.pk.getEncoded();
     }
    
     // 用公钥加密:
     public byte[] encrypt(byte[] message) throws GeneralSecurityException {
         Cipher cipher = Cipher.getInstance("RSA");
         cipher.init(Cipher.ENCRYPT_MODE, this.pk); // 使用公钥进行初始化
         return cipher.doFinal(message);
     }
    
     // 用私钥解密:
     public byte[] decrypt(byte[] input) throws GeneralSecurityException {
         Cipher cipher = Cipher.getInstance("RSA");
         cipher.init(Cipher.DECRYPT_MODE, this.sk); // 使用私钥进行初始化
         return cipher.doFinal(input);
     }
}
、

总结

    哈希算法可用于验证数据完整性，具有防篡改检测的功能；常用的哈希算法有MD5、SHA-1等；用哈希存储口令时要考虑彩虹表攻击。

    对称加密算法使用同一个密钥进行加密和解密，常用算法有DES、AES和IDEA等； 密钥长度由算法设计决定，AES的密钥长度是128/192/256位；使用对称加密算法需要指定算法名称、工作模式和填充模式。

    非对称加密就是加密和解密使用的不是相同的密钥，只有同一个公钥-私钥对才能正常加解密；
标签： java 哈希算法 开发语言
本文转载自: https://blog.csdn.net/w259149/article/details/125919051
版权归原作者 雾远望 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Java加密总结：常见哈希算法总结、对称式加密与非对称式加密的对比”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

机器人技术在安全领域的重要作用

安全学习记录——网络篇（一）

图腾柱PFC：HP1010为您的电动两轮车之旅提供绿色，高效，安全的动力

单元测试数据库回滚问题

这才是单元测试，之前我们都错了

【C语言基础】：字符函数和字符串函数

ChatGPT-Next-Web SSRF漏洞+XSS漏洞复现(CVE-2023-49785)

文章导航