在信息技术迅猛发展的今天，工程项目的实施和交付正在经历一场深刻的变革。传统的工程项目管理方式，往往依赖于纸质文档和人工操作，不仅效率低下，还容易出错。而数字化交付作为一种全新的管理模式，正以其高效、准确、协同的特点，逐步成为工程项目管理的新标准。本文将深入探讨工程项目数字化交付的核心、交付标准以及交付内容，为工程项目管理者提供一份详尽的指南。

一、什么是DES算法

DES算法是一种对称加密算法，它使用相同的密钥进行加密和解密。DES算法是一种分组密码，即将明文分成固定长度的块，并对每个块进行加密。DES算法将每个64位的明文块分成两个32位的半块，然后进行一系列的加密和解密操作，最终得到一个64位的密文块。

二、CBC模式的实现

作为后台产品经理，常常需要进行外部系统的对接，在设计开放平台接口过程中，往往会涉及接口传输安全性相关的问题，笔者在详细的查阅大量资料后，结合自身的过往经验，对于接口加密及签名的相关知识做了一个系统性的总结，在方便自己查阅的同时也分享给大家做一些参考，说明不当之处欢迎指正。

接口安全性问题主要来源于几方面考虑：

在使用Spring Boot进行Web应用程序开发的时候，经常会将数据库的连接配置到application.yml中，而数据库链接中通常包含了一些敏感信息，那么为了保护这些敏感的数据信息，我们需要对相关的用户名和密码进行加密操作，防止出现安全相关的问题。下面我们就来详细介绍一下Spring Boot中如何对这些配置文件中的数据库敏感信息进行加密来保证应用的安全性。

加密算法要解决的主要是信息传输中的加密和解密问题。要假设数据传输过程是不安全的，所有信息都在被窃听的，所以发送端要把信息加密，接收方收到信息之后，要知道如何解密。

一、对称性加密

对称性密码，也叫共享密钥密码，顾名思义，这种加密方式用相同的密钥进行加密和解密。比如用一种最简单的对称加密的方法。都知道信息都可以表示成 0/1 比特序列，也知道相同的两个比特序列做异或运算的结果为 0。那么就可以生成一个长度和原始信息一样的随机比特序列作为密钥，然后用它对原始信息做异或运算，就生成了密文。反之用该密钥对密文做一次异或运算，就可以恢复原始信息。如密钥的长度和原始信息完全一致，如果原始信息很大，密钥也会一样大，而且生成大量真随机比特序列的计算开销也比较大。

我写的代码：

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.SecureRandom;

public class AesCmdTool {

    private static final String AES = "AES";
    private static final String SHA1PRNG = "SHA1PRNG";
    public static final String PRE_KEY = "DES@";

    /**
     * 将二进制转换成16进制
     */
    public static String parseByte2HexStr(byte[] buf) {
        StringBuilder sb = new StringBuilder();
        String hex = null;
        for (byte each : buf) {
            hex = Integer.toHexString(each & 0xFF);
            if (hex.length() == 1) {
                sb.append("0");
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 将16进制转换为二进制
     */
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr == null) {
            return null;
        }

        int hexStrLen = hexStr.length();
        if (hexStrLen < 1) {
            return null;
        }

        int iLen = hexStrLen / 2;

        byte[] result = new byte[iLen];
        for (int i = 0; i < iLen; ++i) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }

    public static String encode(String secret, String strPwd) {
        byte[] encryptResult = encrypt(secret, strPwd);
        if (encryptResult == null) {
            return "";
        }
        return parseByte2HexStr(encryptResult);
    }


    public static String decode(String secret, String strPwd) {
        // 解密
        byte[] decryptFrom = parseHexStr2Byte(secret);
        byte[] decryptResult = decrypt(decryptFrom, strPwd);
        if (decryptResult == null) {
            return "";
        }
        return new String(decryptResult);
    }


    /**
     * 加密
     *
     * @param content  需要加密的内容
     * @param password 加密密码
     */
    private static byte[] encrypt(String content, String password) {
        try {
            KeyGenerator keyGen = KeyGenerator.getInstance(AES);
            SecureRandom secureRandom = SecureRandom.getInstance(SHA1PRNG);
            secureRandom.setSeed(password.getBytes());
            keyGen.init(128, secureRandom);
            SecretKey secretKey = keyGen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, AES);
            Cipher cipher = Cipher.getInstance(AES);
            byte[] byteContent = content.getBytes(StandardCharsets.UTF_8);
            cipher.init(Cipher.ENCRYPT_MODE, key);
            return cipher.doFinal(byteContent);
        } catch (Exception e) {
            return null;
        }
    }

    private static byte[] decrypt(byte[] content, String password) {
        try {
            KeyGenerator keyGen = KeyGenerator.getInstance(AES);
            //防止linux下 随机生成key
            SecureRandom secureRandom = SecureRandom.getInstance(SHA1PRNG);
            secureRandom.setSeed(password.getBytes());
            keyGen.init(128, secureRandom);
            SecretKey secretKey = keyGen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, AES);
            Cipher cipher = Cipher.getInstance(AES);
            cipher.init(Cipher.DECRYPT_MODE, key);
            return cipher.doFinal(content);
        } catch (Exception e) {
            return null;
        }
    }

    public static String textDecodeForPreText(String data, String password) {
        if (data == null) {
            return "";
        }

        if (data.startsWith(PRE_KEY)) {
            return decode(data.substring(PRE_KEY.length()), password);
        }

        return data;
    }

    public static void main(String[] args) {

        String one = "看代码网";
        String pwd = "workForLife";
        String enText = encode(one,pwd);
        String deText = decode(enText,pwd);
        System.out.println("en："+enText);
        System.out.println("de："+deText);
    }
}