Java 实现AES全局加密解密

已于 2022-07-15 11:15:29 修改
阅读量849 收藏 8
点赞数 1
文章标签： java servlet 前端
于 2022-07-15 11:13:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FAWFWAFWA/article/details/125800330
版权 
package com.zhxk.ruralbus.config;

import com.zhxk.ruralbus.utils.aes.ParamResultFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * @author ranzhang
 */
@Configuration
public class AesFilterConfig {

    @Bean
    public FilterRegistrationBean registerParamFilter(ParamResultFilter paramResultFilter) {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        registrationBean.setFilter(paramResultFilter);
        registrationBean.setName("paramResultFilter");
        registrationBean.addUrlPatterns("/*");
        registrationBean.setOrder(2);
        return registrationBean;
    }

}

package com.zhxk.ruralbus.utils.aes;

import java.nio.charset.StandardCharsets;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

import com.zhxk.ruralbus.exception.BusinessException;
import org.springframework.stereotype.Component;
import org.springframework.util.Base64Utils;

/**
 * Description AES CBC + BASE64加密
 *
 * @author
 * @date 14:58 2022/3/31
 */
@Component
public final class AesEncryptUtil {

    private AesEncryptUtil() {}


    /**
     *  加密算法
     * @param content 内容
     * @param sKey  密钥
     * @param ivParameter 偏移量
     * @param padding 加密方式
     * @return 加密结果
     */
    public static String encrypt(String content, String sKey, String ivParameter,String padding) {
        try {
            Cipher cipher = Cipher.getInstance(padding);
            byte[] raw = sKey.getBytes();
            SecretKeySpec skySpec = new SecretKeySpec(raw, "AES");
            IvParameterSpec iv = new IvParameterSpec(ivParameter.getBytes());
            cipher.init(Cipher.ENCRYPT_MODE, skySpec, iv);
            byte[] encrypted = cipher.doFinal(content.getBytes(StandardCharsets.UTF_8));

            return  Base64Utils.encodeToString(encrypted);
        } catch (Exception e) {
            throw new BusinessException("加密失败:" + e.getMessage());
        }
    }

    /**
     * 解密算法
     * @param content 内容
     * @param sKey  密钥
     * @param ivParameter 偏移量
     * @param padding 加密方式
     * @return 解密结果
     */
    public static String desEncrypt(String content, String sKey, String ivParameter,String padding) {
        try {
            byte[] raw = sKey.getBytes(StandardCharsets.US_ASCII);
            SecretKeySpec skySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = Cipher.getInstance(padding);
            IvParameterSpec iv = new IvParameterSpec(ivParameter.getBytes());
            cipher.init(Cipher.DECRYPT_MODE, skySpec, iv);

            byte[] encrypted1 = Base64Utils.decodeFromString(content);
            byte[] original = cipher.doFinal(encrypted1);
            return new String(original, StandardCharsets.UTF_8);
        } catch (Exception e) {
            throw  new BusinessException("解密失败:" + e.getMessage());
        }
    }

    /**
     * 将二进制转换成16进制
     *
     * @param buf 参数
     * @return 返回值
     */
    public static String parseByte2HexStr(byte[] buf) {
        StringBuilder sb = new StringBuilder();
        for (byte b : buf) {
            String hex = Integer.toHexString(b & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 将16进制转换为二进制
     *
     * @param hexStr 参数
     * @return 返回值
     */
    public static byte[] parseHexStr2Byte(String hexStr) {

        if (hexStr.length() < 1) {
            return new byte[0];
        }
        byte[] result = new byte[hexStr.length() / 2];
        for (int i = 0; i < hexStr.length() / 2; 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;
    }
}

package com.zhxk.ruralbus.utils.aes;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.alibaba.fastjson.JSONArray;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;

/***
 * Description 请求参数加密过滤器
 *
 * @date 16:34 2022/3/29
 */
@Component
@Slf4j
public class ParamResultFilter implements Filter {

    /**
     * 参数是否加密
     */
    @Value("${aesencrypt.paramEncryptAble:false}")
    private Boolean paramEncryptAble;

    /**
     * 结果是否加密
     */
    @Value("${aesencrypt.resultEncryptAble:false}")
    private Boolean resultEncryptAble;

    /**
     * 排除加密解密的接口
     */
    @Value("${aesencrypt.excludeUrl:}")
    private String[] excludeUrls;

    /**
     * 使用AES-128-CBC加密模式，key需要为16位,key和iv可以相同！
     */
    @Value("${aesencrypt.key:}")
    private String key;

    @Value("${aesencrypt.iv:}")
    private String iv;

    @Value("${aesencrypt.padding:}")
    private String padding;

    private List<String> excludes;

    /**
     * GET 请求方式
     */
    private static final String GET_REQUEST = "GET";

    /**
     * GET 请求方式
     */
    private static final String OPTIONS = "OPTIONS";

    /**
     * DELETE 请求方式
     */
    private static final String DELETE_REQUEST = "DELETE";

    private static final String POST_REQUEST = "POST";


    /**
     * 前端加密的请求,swagger 传输的时候没有这个请求头
     */
    private static final String ADVANCED = "Advanced";

    @SneakyThrows
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
        HttpServletRequest req = (HttpServletRequest)request;
        String method = req.getMethod();
        String requestUri = req.getRequestURI();
        // 这里处理swagger 的过滤
        boolean swaggerFlag = !StringUtils.isEmpty(requestUri) && requestUri.contains("/doc.html")
                || requestUri.contains("/wn-web/doc.html") || requestUri.contains("/swagger")
                || requestUri.contains("/v2/") ||requestUri.contains("/websocket");

        if (DELETE_REQUEST.equals(method) || OPTIONS.equals(method) || swaggerFlag) {
            // 这里是过滤器注册转发
            chain.doFilter(request, response);
            return;
        }

        // 允许跳过的接口
        if (handleExcludeUrl(req)) {
            // 这里是过滤器注册转发
            chain.doFilter(request, response);
            return;
        }
        // 是否参数加密
        RequestWrapper requestWrapper = new RequestWrapper((HttpServletRequest)request);
        // 前端加密之后的请求头
        String product = req.getHeader("Product");
        // 处理智搜的GET加密请求
        if (ADVANCED.equals(product) && GET_REQUEST.equals(method) && paramEncryptAble) {
            this.dealGetRequestDecode(requestWrapper);
        }
        // 如果可以json化一般都是swagger请求就直接请求
        boolean jsonFlag = false;
        // 处理post请求
        if (POST_REQUEST.equals(method)) {
            StringBuilder str = new StringBuilder();
            String line;
            BufferedReader reader;
            reader = requestWrapper.getReader();
            while ((line = reader.readLine()) != null) {
                str.append(line);
            }
            String json;
            if (StringUtils.isNotEmpty(str.toString())) {
                try {
                    JSONObject object = JSON.parseObject(str.toString());
                    json = object.toJSONString();
                    requestWrapper.setBody(json.getBytes(StandardCharsets.UTF_8));
                    // 能json 话说明是swagger的
                    jsonFlag = true;
                } catch (Exception e) {
                    try {
                        JSONArray object = JSON.parseArray(str.toString());
                        json = object.toJSONString();
                        requestWrapper.setBody(json.getBytes(StandardCharsets.UTF_8));
                        // 能json 话说明是swagger的
                        jsonFlag = true;
                    } catch (Exception exception) {
                        log.warn("不是常规的json字符串解密异常字符串:{},异常内容：{}", str, e.getMessage());
                    }
                }
            }
            // 如果不是swagger传过来的数据否则就对post进行解密且对返回的数据加密
            if (!jsonFlag) {
                // post请求内容需要解密
                json = AesEncryptUtil.desEncrypt(str.toString(), key, iv, padding);
                log.info("解密之后的字符串:{}", json);
                requestWrapper.setBody(json.getBytes(StandardCharsets.UTF_8));
            }
        }
        // 结果是否加密
        if (resultEncryptAble && !jsonFlag) {
            // 且对返回数据进行加密 ,此地方代码过于冗余后续可能需要对整个方法进行优化
            this.encryptResultData(chain, response, requestWrapper);
        } else {
            chain.doFilter(requestWrapper, response);
        }

    }

    /**
     * @description: 加密返回数据
     * @param: [chain,
     *             response, requestWrapper]
     * @return: void
     * @date: 2022/4/12 18:16
     */
    public void encryptResultData(FilterChain chain, ServletResponse response, RequestWrapper requestWrapper) {
        // 且对返回数据进行加密 ,此地方代码过于冗余后续可能需要对整个方法进行优化
        try {
            // 请注意响应处理 包装响应对象 res 并缓存响应数据,只有需要加密数据才使用这个 ResponseWrapper
            ResponseWrapper responseWrapper = new ResponseWrapper((HttpServletResponse)response);
            // 执行业务逻辑 交给下一个过滤器或servlet处理
            // 设置响应内容格式，防止解析响应内容时出错
           // responseWrapper.setContentType("text/plain;charset=UTF-8");
            // 这里是过滤器注册转发
            chain.doFilter(requestWrapper, responseWrapper);
            // 是否结果加密
            byte[] resData = responseWrapper.getResponseData();
            // 加密响应报文并响应
            String resultEncrypt = AesEncryptUtil.encrypt(new String(resData), key, iv, padding);
            // 这里得用原始的流去处理返回 切记
            PrintWriter out = response.getWriter();
            out.print(resultEncrypt);
            out.flush();
            out.close();

        } catch (Exception e) {
            log.error("返回数据加密失败：{}", e.getMessage());
            try {
                getFailResponse((HttpServletResponse)response);
            } catch (IOException ioException) {
                log.error("io异常：{}", ioException.getMessage());
            }

        }
    }

    /**
     * 前端get请求 加密之后需要解码请求参数
     *
     */
    private void dealGetRequestDecode(RequestWrapper requestWrapper) {
        Map<String, String[]> parameterMap = requestWrapper.getParameterMap();
        Map<String, Object> paras = new HashMap<>();
        // 这里get 请求加密的value
        parameterMap.forEach((paramKey, encryptValue) -> {
            for (String s : encryptValue) {
                try {
                    // 解密请求的
                    String params = AesEncryptUtil.desEncrypt(s, key, iv, padding);
                    JSONObject jsonObject = JSON.parseObject(params);
                    jsonObject.forEach((name, value) -> {
                        String[] vs = {value + ""};
                        paras.put(name, vs);
                    });
                } catch (Exception e) {
                    log.info("get请求解密异常：{}", e.getMessage());
                }
            }

        });
        requestWrapper.addAllParameters(paras);
        log.info("paramsMap:{}", parameterMap);
    }

    private void getFailResponse(HttpServletResponse response) throws IOException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        PrintWriter out = null;
        out = response.getWriter();
        // out.write("{\n" +
        // " \"status\":"+ Constant.ENCRYPT_FAIL +",\n" +
        // " \"message\": null,\n" +
        // " \"data\": []\n" +
        // "}");
        // 加密后的错误消息
        out.write("服务端加密异常");
        out.flush();
        out.close();
    }

    @Override
    public void destroy() {}

    @Override
    public void init(FilterConfig filterConfig) {
        excludes = Lists.newArrayList(Arrays.asList(excludeUrls));
        /*String excludesTemp = filterConfig.getInitParameter("excludes");
        if (!StrUtil.isEmpty(excludesTemp)) {
            String[] url = excludesTemp.split(",");
            excludes.addAll(Arrays.asList(url));
        }*/
    }

    private boolean handleExcludeUrl(HttpServletRequest request) {
        if (CollectionUtils.isEmpty(excludes)) {
            return false;
        }
        String url = request.getServletPath();
        for (String pattern : excludes) {
            Pattern p = Pattern.compile("^" + pattern);
            Matcher m = p.matcher(url);
            if (m.find()) {
                return true;
            }
        }
        return false;
    }


}


package com.zhxk.ruralbus.utils.aes;

import lombok.extern.slf4j.Slf4j;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

/**
 * @version 1.0
 * @date 2021/12/16 14:42
 */
@Slf4j
public class RequestWrapper extends HttpServletRequestWrapper {
    private Map<String, String[]> params = new HashMap<>();

    private byte[] body;

    public RequestWrapper(HttpServletRequest request) {
        super(request);
        body = getBodyString(request).getBytes(StandardCharsets.UTF_8);
        //将参数表，赋予给当前的Map以便于持有request中的参数
        this.params.putAll(request.getParameterMap());

    }

    /**
     * 在获取所有的参数名,必须重写此方法，否则对象中参数值映射不上
     *
     * @return
     */
    @Override
    public Enumeration<String> getParameterNames() {
        return new Vector<>(params.keySet()).elements();
    }

    /**
     * 重写getParameter方法
     *
     * @param name 参数名
     * @return 返回参数值
     */
    @Override
    public String getParameter(String name) {
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }

    @Override
    public String[] getParameterValues(String name) {
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return new String[]{};
        }
        return values;
    }

    /**
     * 增加多个参数
     *
     * @param otherParams 增加的多个参数
     */
    public void addAllParameters(Map<String, Object> otherParams) {
        for (Map.Entry<String, Object> entry : otherParams.entrySet()) {
            addParameter(entry.getKey(), entry.getValue());
        }
    }

    /**
     * 增加参数
     *
     * @param name  参数名
     * @param value 参数值
     */
    public void addParameter(String name, Object value) {
        if (value != null) {
            if (value instanceof String[]) {
                params.put(name, (String[]) value);
            } else if (value instanceof String) {
                params.put(name, new String[]{(String) value});
            } else {
                params.put(name, new String[]{String.valueOf(value)});
            }
        }
    }


    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    /**
     * 重写获取 输入流的方法，保证流可写可读多次
     *
     * @return ServletInputStream
     * @throws IOException IO异常
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream bs = new ByteArrayInputStream(body);
        return new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {
                log.info(readListener.toString());
            }

            @Override
            public int read() throws IOException {
                return bs.read();
            }
        };
    }

    public byte[] getBody() {
        return body;
    }

    public void setBody(byte[] body) {
        this.body = body;
    }

    public static String getBodyString(ServletRequest request) {
        StringBuilder sb = new StringBuilder();
        try (
                InputStream inputStream = request.getInputStream();
                BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
        ) {
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            log.error("getBodyString IOException", e);
        }
        return sb.toString();
    }

}

package com.zhxk.ruralbus.utils.aes;

import lombok.extern.slf4j.Slf4j;

import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.*;

/**
 * @ClassName: ResponseWrapper
 * @Description:
 * @Date: 2022-04-11 10:41
 */
@Slf4j
public class ResponseWrapper extends HttpServletResponseWrapper {
    /**
     * @Description: 响应包装类
     * @Date: 2020/5/26 16:29
     */


    private ByteArrayOutputStream buffer = null;
    private ServletOutputStream out = null;
    private PrintWriter writer = null;

    public ResponseWrapper(HttpServletResponse response) throws IOException {
        super(response);
        buffer = new ByteArrayOutputStream();// 真正存储数据的流
        out = new WapperedOutputStream(buffer);
        writer = new PrintWriter(new OutputStreamWriter(buffer, this.getCharacterEncoding()));
    }

    /**
     * 重载父类获取outputstream的方法
     */
    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        return out;
    }

    /**
     * 重载父类获取writer的方法
     */
    @Override
    public PrintWriter getWriter() throws UnsupportedEncodingException {
        return writer;
    }

    /**
     * 重载父类获取flushBuffer的方法
     */
    @Override
    public void flushBuffer() throws IOException {
        if (out != null) {
            out.flush();
        }
        if (writer != null) {
            writer.flush();
        }
    }

    @Override
    public void reset() {
        buffer.reset();
    }

    /**
     * 将out、writer中的数据强制输出到WapperedResponse的buffer里面，否则取不到数据
     */
    public byte[] getResponseData() throws IOException {
        flushBuffer();
        return buffer.toByteArray();
    }

    /**
     * 内部类，对ServletOutputStream进行包装
     */
    private class WapperedOutputStream extends ServletOutputStream {
        private ByteArrayOutputStream bos = null;

        public WapperedOutputStream(ByteArrayOutputStream stream) {
            bos = stream;
        }

        @Override
        public void write(int b) throws IOException {
            bos.write(b);
        }

        @Override
        public void write(byte[] b) throws IOException {
            bos.write(b, 0, b.length);
        }

        @Override
        public boolean isReady() {
            return false;
        }

        @Override
        public void setWriteListener(WriteListener writeListener) {
            log.info("writeListener");
        }
    }


}

需要配置小程序appid和密钥，我是写在配置文件中的，需要获取配置文件参数的工具类看获取配置文件参数工具类

在这里插入图片描述

老王爱绿色
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AES加密解密工具类
WoddenFish的博客
11-15 1452
最近项目使用到了aes的加解密算法，但是在使用过程中出现了诸多问题，比如bc库版本冲突、并发下bc对象占用解密失败，重复new bc库导致加解密速度太慢等。。。最后经过一番分析，现在分享一下彻底解决这些问题的版本； 1、依赖版本（最好使用这个，支持jdk1.5及以上，算是比较新的） <dependency> <groupId>org.bo...
aes对称加密vue版本demo
01-16
这个DEMO项目为开发者提供了一个完整的端到端加密示例，涵盖了前后端的加密解密流程，对于理解AES加密以及如何在实际项目中应用具有很高的参考价值。通过学习和实践这个DEMO，开发者能够更好地掌握AES加密技术，并将...
java：AES加密和解密
a232884c的博客
12-17 6667
对称加密，即单秘钥加密，指加密和解密的过程中，使用相同的秘钥，相比于非对称加密，因仅有一把钥匙，故而速度更快，更适合解密大文件（常见于如视频文件的加密解密中）。AES算法就属于对称加密中的一种。
Java加密与解密
热门推荐
ThinkStu的博客
08-15 5万+
加密方式主要有3种，摘要加密、对称加密与非对称加密。
AES加密解密（java、web、app）
shaoyujian的博客
12-15 1776
AES加密解密（java、web、app）AES加密解密（java、web、app）java端Web端ios端 AES加密解密（java、web、app） 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 java端 package com.unicomSmartCity.common.core.utils; import com.unicomSmartCity.common.cor
QT AES 加密和解密 能实现ECB 和 CBC
dai410257573的博客
08-25 1432
最近因为业务需要，需要对数据进行AES的加解密。参考了论坛大佬的例程，稍作修改，便于我的使用。记录下来，感谢共享的大佬。 QT5.6.3 编译 ，可用 修改地方，增加初始化的参数，增加加密模式的参数，和CBC模式CFB模式的初始偏移量，但是未对该偏移量进行长度校验和补齐，请确保是16个字节的偏移量。 AESTools::AESTools(QString *keyqs,QString *cbcIv,EncryptMode eEncryptMode) { QByteArray key = keyqs->t
uniapp AES加密解密
清音的博客
09-02 7072
2.在项目根目录，创建一个utils文件夹，并创建一个aes_endecrypt.js文件。1.在dcloud插件市场中搜索-传输加密，AES对称加密 （作者。3. 在App.vue中，在methods中创建加密、解密方法。3.在main.js文件中，引入方法，并注册为全局方法。uniapp里我知道的有两种aes加密解密方式。2.项目main.js文件中，注册全局组件。4.在页面中使用aes加密解密方式。4.在页面中使用aes加密，解密。二、第二种方式：直接引入插件。一、引入crypto-js。
Java实现3DES加解密算法
Ws_zqw的博客
01-27 9970
【信息安全课程实验报告】3DES加解密算法
Java 数据加密解密及脱敏处理
qq_41867674的博客
02-28 1248
在开发中会遇到一些敏感信息 需要做加密和脱敏处理,以下是加密解密实战
AES加密、解密工具类
Wang_WY的博客
03-20 3744
一、AES介绍 AES（Advanced Encryption Standard），中文名称高级加密标准。 AES是开发中常用的加密算法之一。然而由于前后端开发使用的语言不统一，导致经常出现前端加密而后端不能解密的情况出现。然而无论什么语言系统，AES 的算法总是相同的， 因此导致结果不一致的原因在于 加密设置的参数不一致 。于是先来看看在两个平台使用AES加密时需要统一的几个参数。 密钥长...
php实现URL加密解密的方法
12-19
本文实例将介绍一种基于特定算法的PHP URL加密解密方法。 首先，我们要理解URL加密的目的。URL（统一资源定位符）通常会暴露在浏览器地址栏中，如果其中包含敏感信息，比如用户ID、密码或查询参数，那么这些信息...
Spring MVC请求参数与响应结果全局加密和解密详解
08-27
在总结一下，Spring MVC请求参数与响应结果全局加密和解密可以通过使用AES对称秘钥和SHA-256签名算法来实现。我们需要考虑到第三方的提交方式，兼容不同的ContentType提交方式，并使用EncryptUtils工具类来进行加密...
小程序aes加密解密.zip
09-07
通过这些步骤，开发者可以在小程序中实现AES加密解密，确保用户数据在传输和存储过程中的安全性。AES加密的引入，不仅可以防止数据被非法获取，还可以满足微信小程序平台对数据隐私的合规要求。在实际应用中，还需要...
AES.zip_AES_AES加解密_AES解密_aes 加解密
09-14
1. Crypt_Aes.cpp、Crypt_Aes.h：这是AES加密和解密的具体实现，可能包含了AES的密钥扩展、加密和解密函数等核心逻辑。 2. Crypt_Common.cpp、Crypt_Common.h：这些文件可能包含了加密算法共通的部分，比如错误处理...
枚举工具类
qq_43049583的博客
08-04 311
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 353
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 682
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
windows DNS对称加密
05-23
Windows DNS对称加密是一种安全保护措施，用于保护域名系统(DNS)查询过程中的数据传输。它使用Advanced Encryption Standard (AES)对称加密算法来加密DNS查询和响应消息，从而防止黑客窃听和篡改。在Windows Server 2008和更高版本的操作系统中，DNS对称加密是默认启用的。 DNS对称加密通过使用预共享密钥，使DNS客户端和DNS服务器之间的通信实现加密。它使用一个固定密钥来进行加密和解密，因此被称为对称加密。此外，DNS对称加密还提供了一个可选的完整性验证功能，可以确保接收到的DNS响应消息没有被篡改。 在Windows Server中，可以使用组策略来配置DNS对称加密选项。可以设置一个全局的预共享密钥或针对每个DNS区域分别设置不同的密钥。可以通过使用PowerShell命令行工具或者通过GUI配置工具来进行配置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值