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位;使用对称加密算法需要指定算法名称、工作模式和填充模式。

    非对称加密就是加密和解密使用的不是相同的密钥,只有同一个公钥-私钥对才能正常加解密;

本文转载自: https://blog.csdn.net/w259149/article/details/125919051
版权归原作者 雾远望 所有, 如有侵权,请联系我们删除。

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

还没有评论