Java加密解密算法世界（java实现加密解密）

一、概述

实际工作中遇到的加密解密算法和算法之间的区别以及如何选择，包括：BASE64、DES、3DES、AES、RSA、MD5、SHA。

区别与选择：

1. 加密算法可逆，用来保证数据安全，散列算法不可逆，用来验证身份。
2. 对称加密算法，速度快，适合给大量数据加密，交互双方使用同一个密钥，存在被抓包破解的风险。
3. 非对称加密算法使用公钥加密，私钥解密，私钥签名，公钥验签，安全性较高，但速度较慢。非对称加密使用两个密钥，服务端和客户端密匙不一样，私钥放在服务端，安全性高。4、在实际的操作过程中，我们通常采用的方式是：采用非对称加密算法管理对称算法的密钥，然后用对称加密算法加密数据，这样我们就集成了两类加密算法的优点，既实现了加密速度快的优点，又实现了安全方便管理密钥的优点。

二、编码加解密

1、Base64：

说明：严格意义来说Base64并不是一种加密/解密算法，而是一种编码的方式。Base64不生成密钥，通过Base64编码后的密文就可以直接“翻译”为明文。在网络上传输数据时，往往要经过多个路由设备，由于不同的设备对字符的处理方式有一些不同，这样那些不可见字符就有可能被处理错误，这是不利于传输的。所以就先把数据先做一个Base64编码，统统变成可见字符，这样出错的可能性就大降低，Base64转换后的字符串理论上将要比原来的长1/3。

例子：

package com.yx.encryption;

import java.util.Base64;

/**
 * Base64使用例子
 * 加密和解密
 *
 * @author yx
 */
public class Base64Demo {
    public static void main(String[] args) {
        // 加密文字
        String data = "EasyJava";

        // 加密
        byte[] encode = Base64.getEncoder().encode(data.getBytes());
        String enCodeResult = new String(encode);
        System.out.println("加密结果：" + enCodeResult);

        // 解密
        byte[] decode = Base64.getDecoder().decode(enCodeResult);
        String decodeResult = new String(decode);
        System.out.println("解密结果：" + decodeResult);
    }
}


执行结果：

加密结果：RWFzeUphdmE=
解密结果：EasyJava

三、对称加解密

1、DES：

说明：DES是一种基于56位密钥的对称算法，1976年被美国联邦政府的国家标准局确定为联邦资料处理标准(FIPS)，随后在国际上广泛流传开来。现在DES已经不是一种安全的加密算法，已被公开破解，现在DES已经被高级加密标准(AES)所代替。新项目不建议选择DES，这种加密方式只存在历史项目中。

例子：

package com.yx.encryption;

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import java.security.Key;

/**
 * DES使用例子
 * 加密和解密
 *
 * @author yx
 */
public class DESDemo {
    /**
     * 密钥
     */
    private static String SECRET_KEY = "12345678";

    private static final char[] HEXES = {
            '0', '1', '2', '3',
            '4', '5', '6', '7',
            '8', '9', 'a', 'b',
            'c', 'd', 'e', 'f'
    };

    /**
     * byte数组 转换成 16进制小写字符串
     */
    public static String bytes2Hex(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return null;
        }
        StringBuilder hex = new StringBuilder();
        for (byte b : bytes) {
            hex.append(HEXES[(b >> 4) & 0x0F]);
            hex.append(HEXES[b & 0x0F]);
        }
        return hex.toString();
    }

    public static void main(String[] args) throws Exception {
        // 加密字符串
        String src = "EasyJava";
        //KEY转换
        DESKeySpec desKeySpec = new DESKeySpec(SECRET_KEY.getBytes("utf-8"));
        SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
        Key convertSecretKey = factory.generateSecret(desKeySpec);
        //加密
        Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
        byte[] result = cipher.doFinal(src.getBytes());
        System.out.println("加密结果: " + bytes2Hex(result));
        //解密
        cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
        result = cipher.doFinal(result);
        System.out.println("解密结果: " + new String(result));
    }
}

执行结果：

加密结果: dcf185f57bb08208feb959b7d4642fcb
解密结果: EasyJava

2、3DES

说明：相当于是对每个数据块应用三次DES加密算法。由于计算机运算能力的增强，原版DES密码的密钥长度变得容易被暴力破解，3DES即是设计用来提供一种相对简单的方法，即通过增加DES的密钥长度来避免类似的攻击，而不是设计一种全新密码算法。

例子：

package com.yx.encryption;

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.nio.charset.StandardCharsets;
import java.security.Key;

/**
 * DES3使用例子
 * 加密和解密
 *
 * @author yx
 */
public class DES3Demo {
    /**
     * 密钥（24位）
     */
    private static String SECRET_KEY = "123456781234567812345678";

    private static final String KEY_ALGORITHM = "DESede";
    private static final String CIPHER_ALGORITHM = "DESede/CBC/PKCS5Padding";

    /**
     * 3DES 加密
     *
     * @param key  密钥（24位）
     * @param iv   偏移量
     * @param data 需要加密的字符串
     * @return 返回加密的字符串
     */
    public static String encrypt(String key, String iv, String data) {
        try {
            DESedeKeySpec spec = new DESedeKeySpec(key.getBytes(StandardCharsets.UTF_8));
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(KEY_ALGORITHM);
            Key desKey = keyFactory.generateSecret(spec);
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            IvParameterSpec ips = new IvParameterSpec(iv.getBytes(StandardCharsets.UTF_8));
            cipher.init(Cipher.ENCRYPT_MODE, desKey, ips);
            byte[] bOut = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
            return Base64.encodeBase64String(bOut);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("3DES 解密错误");
            throw new RuntimeException("3DES 解密错误");
        }
    }

    /**
     * 3DES 解密
     *
     * @param key  密钥（24位）
     * @param iv   偏移量
     * @param data 需要解密的密文
     * @return 返回加密的字符串
     */
    public static String decrypt(String key, String iv, String data) {
        try {
            DESedeKeySpec spec = new DESedeKeySpec(key.getBytes(StandardCharsets.UTF_8));
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(KEY_ALGORITHM);
            Key desKey = keyFactory.generateSecret(spec);
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            IvParameterSpec ips = new IvParameterSpec(iv.getBytes(StandardCharsets.UTF_8));
            cipher.init(Cipher.DECRYPT_MODE, desKey, ips);
            byte[] bOut = cipher.doFinal(Base64.decodeBase64(data.getBytes(StandardCharsets.UTF_8)));
            return new String(bOut, StandardCharsets.UTF_8);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("3DES 解密错误");
            throw new RuntimeException("3DES 解密错误");
        }
    }

    public static void main(String[] args) {
        String data = "EasyJava";

        String des3EncodeCBC = encrypt(SECRET_KEY, "53152654", data);
        System.out.println("加密结果：" + des3EncodeCBC);

        String des3DecodeCBC = decrypt(SECRET_KEY, "53152654", des3EncodeCBC);
        System.out.println("解密结果：" + des3DecodeCBC);
    }

}

执行结果：

加密结果：5gBjg/fcZ45YrGKm8nxHvQ==
解密结果：EasyJava

3、AES

说明：是目前对称加密算法中最流行的算法之一，是DES的替代者，未被破解，性能更优。

例子：

package com.yx.encryption;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.util.Base64;

/**
 * AES使用例子
 * 加密和解密
 *
 * @author yx
 */
public class AESDemo {
    /**
     * 密钥（24）
     */
    private static String SECRET_KEY = "xxxxxxxxxxxxxxxxxxxxxxxx";

    public static void main(String[] args) throws Exception {
        // 加密字符串
        String src = "EasyJava";
        // Key转换
        Key key = new SecretKeySpec(SECRET_KEY.getBytes("utf-8"), "AES");

        // 加密
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] encryptBytes = cipher.doFinal(src.getBytes("utf-8"));
        System.out.println("加密结果：" + Base64.getEncoder().encodeToString(encryptBytes));

        // 解密
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] decodeBytes = cipher.doFinal(encryptBytes);
        System.out.println("解密结果：" + new String(decodeBytes));
    }
}

执行结果：

加密结果：ESuCYW2piOpf4Expba6IuA==
解密结果：EasyJava

四、非对称加解密

1、RSA

说明：广泛接受且实现，多用于数据加密和数字签名领域，支持公钥加密私钥解密，私钥加密公钥解密方式。

例子：

package com.yx.encryption;

import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

/**
 * RSA使用例子
 * 私钥加密，公钥解密
 * 公钥加密，私钥解密
 *
 * @author yx
 */
public class RSADemo {

    private static void encode1(String src, RSAPublicKey rsaPublicKey, RSAPrivateKey rsaPrivateKey) throws Exception {
        // 加密
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        byte[] encodeResult = cipher.doFinal(src.getBytes("utf-8"));
        System.out.println("【私钥加密、公钥解密】加密结果：" + Base64.getEncoder().encodeToString(encodeResult));

        // 解密
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
        keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        byte[] decodeResult = cipher.doFinal(encodeResult);
        System.out.println("【私钥加密、公钥解密】解密结果：" + new String(decodeResult, "utf-8"));
    }

    private static void encode2(String src, RSAPublicKey rsaPublicKey, RSAPrivateKey rsaPrivateKey) throws Exception {
        // 加密
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encodeResult = cipher.doFinal(src.getBytes("utf-8"));
        System.out.println("【公钥加密、私钥解密】加密结果：" + Base64.getEncoder().encodeToString(encodeResult));

        // 解密
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
        keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decodeResult = cipher.doFinal(encodeResult);
        System.out.println("【公钥加密、私钥解密】解密结果：" + new String(decodeResult, "utf-8"));
    }

    public static void main(String[] args) throws Exception {
        // 加密字符串
        String src = "EasyJava";

        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(512);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        // 公钥 & 私钥
        RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
        System.out.println("公钥：" + Base64.getEncoder().encodeToString(rsaPublicKey.getEncoded()));
        System.out.println("私钥：" + Base64.getEncoder().encodeToString(rsaPrivateKey.getEncoded()));

        // 【私钥加密、公钥解密】
        encode1(src, rsaPublicKey, rsaPrivateKey);

        // 【公钥加密、私钥解密】
        encode2(src, rsaPublicKey, rsaPrivateKey);
    }
}

执行结果：

公钥：MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJ68MgEMZD7X+5e9kYwLZfcXeCzlXlB3me/v214mON3ONbDjX++a3b7EqW+rVf49H9AmiY5bWuj335X/18/qyV8CAwEAAQ==
私钥：MIIBUwIBADANBgkqhkiG9w0BAQEFAASCAT0wggE5AgEAAkEAnrwyAQxkPtf7l72RjAtl9xd4LOVeUHeZ7+/bXiY43c41sONf75rdvsSpb6tV/j0f0CaJjlta6Pfflf/Xz+rJXwIDAQABAkAnJACwgX22gUtofzYEcksSQpc/es9myBcNMvfEn2gmSO8wYDxTnyctYGC0slOjFXDSuTp5WoK/bRcAOWnDI/UBAiEA0uQJeMGpl5c8Qmbxs5NWJvXOntJE/S/Ka/1UgX/MJXUCIQDAsDf9rUDxzjF+hqY9Mv79STO3PYd5MZN/C3uHCGzVAwIgDf6d9kp7s5iQoiNstKr5U5qKPJXdiCOsvh/QhMtzQ6UCIFkiKwRh3KT+aM7KoqO0r1ejQRUGlWBumngua5nvP8jZAiBcdQ1czDuqBPQrua0DylFeP/3way2pKrQFg4xmNcM8Uw==
【私钥加密、公钥解密】加密结果：KjQIb91tWcau+FAwPF6AX6jw3QzYhXyaQQPG6roNWZ5wT1nMhanX2G1O2ZNPqVS2s3Ar4Cl1ROKYF6JmlEeYBw==
【私钥加密、公钥解密】解密结果：EasyJava
【公钥加密、私钥解密】加密结果：gw3PUe2zrCsZ+SyIgGBPX2ZnzQVnTZal7pvP4TZRGUzQho2IK91YjdbV8ec9Tp9HUHKVHMf96aNu2tRc7ZDMBg==
【公钥加密、私钥解密】解密结果：EasyJava

2、MD5

说明：严格意义上不属于加密算法，属于信息摘要算法。

例子：

package com.yx.encryption;

import java.security.MessageDigest;

/**
 * MD5使用例子
 * 生成消息摘要
 *
 * @author yx
 */
public class MD5Demo {

    private static final char[] HEXES = {
            '0', '1', '2', '3',
            '4', '5', '6', '7',
            '8', '9', 'a', 'b',
            'c', 'd', 'e', 'f'
    };

    /**
     * byte数组 转换成 16进制小写字符串
     */
    public static String bytes2Hex(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return null;
        }
        StringBuilder hex = new StringBuilder();
        for (byte b : bytes) {
            hex.append(HEXES[(b >> 4) & 0x0F]);
            hex.append(HEXES[b & 0x0F]);
        }
        return hex.toString();
    }

    public static void main(String[] args) throws Exception {
        // 加密字符
        String src = "EasyJava";

        // 获取摘要
        MessageDigest messageDigest = MessageDigest.getInstance("MD5");
        byte[] md5Result = messageDigest.digest(src.getBytes("utf-8"));
        System.out.println("摘要信息：" + bytes2Hex(md5Result));
    }
}

执行结果：

摘要信息：0d50d2ea5aece0b7bc10643a3f72159c

3、SHA

说明：SHA家族的五个算法，分别是SHA-1、SHA-224、SHA-256、SHA-384，和 SHA-512，后四者有时并称为SHA-2。SHA-1在许多安全协定中广为使用。 MD5与SHA1都是Hash算法，MD5输出是128位的(转换为16进制则为32个字符)，SHA1输出是160位的(转换为16进制则为40个字符)，MD5比SHA1快，SHA1比MD5强度高。

例子：

package com.yx.encryption;

import java.security.MessageDigest;

/**
 * SHA使用例子
 * 生成消息摘要
 *
 * @author yx
 */
public class SHADemo {

    private static final char[] HEXES = {
            '0', '1', '2', '3',
            '4', '5', '6', '7',
            '8', '9', 'a', 'b',
            'c', 'd', 'e', 'f'
    };

    /**
     * byte数组 转换成 16进制小写字符串
     */
    public static String bytes2Hex(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return null;
        }
        StringBuilder hex = new StringBuilder();
        for (byte b : bytes) {
            hex.append(HEXES[(b >> 4) & 0x0F]);
            hex.append(HEXES[b & 0x0F]);
        }
        return hex.toString();
    }

    public static void main(String[] args) throws Exception {
        // 加密字符
        String src = "EasyJava";

        // 获取摘要
        MessageDigest messageDigest = MessageDigest.getInstance("SHA");
        messageDigest.update(src.getBytes("utf-8"));
        byte[] md5Result = messageDigest.digest();
        System.out.println("摘要信息：" + bytes2Hex(md5Result));
    }
}

执行结果：

摘要信息：a59bcc9c6c15610a8fc0dc75a1551903f5583a90

相关推荐

取消回复欢迎你发表评论:

Google 黑客常用搜索语句一览原力计划

npx简介（npxvip是哪国的）

在 Android 模拟器上运行 ARM 应用（android模拟器原理）

GB28181,B接口协议之SIPRTSPRTPRTMP协议从入门到精通

手机实时提取SIM卡打电话的信令和声音-辅助外设与商用通话方案

安装使用Hoppscotch构建API请求访问与测试

Python自动化办公——后台截图（python 自动截图）

轻松转换!AppleNumbers到Excel的快捷教程

电脑端腾讯文档如何导出excel

网络流媒体经典开源软件宝典webRTC, FFMpeg, SIP_流媒体开发教程