logback自定义日志脱敏规则及脱敏开关（动态控制日志加密方式以及加密开关）

最新推荐文章于 2024-05-24 10:26:13 发布
最新推荐文章于 2024-05-24 10:26:13 发布
阅读量1.2k 收藏 4
点赞数 1
文章标签： logback java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39189120/article/details/132396926
版权

背景：公司日志数据不能暴露账号密码登个人关键信息

常见脱密方式：（推荐使用第二种方式）

1.xml配置对应的key然后对其value进行相应规则的脱敏（此种方式对于没有key的值无法脱敏并且系统重也不好穷尽所有需要脱敏的key）
2.采用正则表达式匹配对应的关键信息进行脱敏（满足正则表达是即可正确的脱敏相应的内容）

下面就对第二种方式详细说明：

1.定义一个SensitiveLogDataConverter

import ch.qos.logback.classic.pattern.MessageConverter;
import ch.qos.logback.classic.spi.ILoggingEvent;
import cn.hutool.core.util.StrUtil;

import java.util.HashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SensitiveLogDataConverter extends MessageConverter {

    // 脱敏符号 *
    public static final String SYMBOL_STAR = "*";

    /**
     * 0 加密前三位
     * 1 加密中间四位
     * 2 加密后面四位
     */
    public static Integer logMode = 1;

    /**
     * 是否开启加密规则 默认为false
     */
    public static boolean logSensitive = false;
    /**
     * 手机号
     */
    private static final Pattern PHONE_PATTERN = Pattern.compile("(?<!\\d)(1\\d{10})(?!\\d)");

    private static final Pattern LANDLINE_AREA = Pattern.compile("[0][1-9]{2,3}-[0-9]{5,10}"); // 验证带区号的

    private static final Pattern LANDLINE = Pattern.compile("[1-9]{1}[0-9]{5,8}"); // 验证没有区号的

    /**
     * 证件号码
     */
    private static final Pattern ID_NUMBER = Pattern.compile("((1[1-5])|(2[1-3])|(3[1-7])|(4[1-6])|(5[0-4])|(6[1-5])|71|81|82|91)[0-9]{4}(18|19|20)[0-9]{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)[0-9]{3}[0-9Xx]");


    /**
     * 银行卡
     */
    //private static final Pattern BANK_CARD_NUMBER = Pattern.compile("^(?:62|88|99|19\\d{2}|4\\d{3}|5[1-5]\\d{2}|6\\d{3}|81\\d{2})\\d{10}|^62\\d{12,17}|^[0-9]{16,19}$");


    private static final Pattern BANK_CARD_NUMBER = Pattern.compile("[0-9]{16,19}");
    /**
     * 邮箱符号
     */
    private static final Pattern EMAIL = Pattern.compile("\\w[-\\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+\\.)+[A-Za-z]{2,14}");

    //private static final Pattern ADDRESS = Pattern.compile("/^([\\u4e00-\\u9fa5]+(?:省|市|自治区)){0,1}([\\u4e00-\\u9fa5]+(?:市|区|县|州|盟)){0,1}([\\u4e00-\\u9fa5]+(?:街道|镇|乡)){0,1}([\\u4e00-\\u9fa5]+(?:号|村|社)){0,1}([\\u4e00-\\u9fa5]+(?:路|街|巷)){0,1}([\\u4e00-\\u9fa5]+(?:弄|号楼|栋|单元)){0,1}([0-9A-Za-z]{5,}){0,1}$/");

    //
    private static final Pattern ADDRESS = Pattern.compile("([^区]+区)|([^镇]+镇)|([^路]+路)|([^街]+街)|([^单元]+单元)|([^公司]+公司)|([^室]+室)|([^户]+户)");


    @Override
    public String convert(ILoggingEvent event) {
        String logMsg = event.getFormattedMessage();
        if (logSensitive) {
            try {

                final Set<String> email = validateEmail(logMsg);
                if (!email.isEmpty()) {
                    for (String param : email) {
                        logMsg = logMsg.replaceAll(param, emailEncrypt(param));
                    }
                }

                final Set<String> phoneNumber = validatePhoneNumber(logMsg);
                //电话号码加密
                if (!phoneNumber.isEmpty()) {
                    for (String param : phoneNumber) {
                        logMsg = logMsg.replaceAll(param, mobileEncrypt(param));
                    }
                }

                final Set<String> landlineArea = validateLandlineArea(logMsg);
                if (!phoneNumber.isEmpty()) {
                    for (String param : landlineArea) {
                        logMsg = logMsg.replaceAll(param, idNumberEncrypt(param));
                    }
                }

                final Set<String> IDNumber = validateIDNumber(logMsg);
                if (!IDNumber.isEmpty()) {
                    for (String param : IDNumber) {
                        logMsg = logMsg.replaceAll(param, idNumberEncrypt(param));
                    }
                }
                final Set<String> cardNumber = validateCardNumber(logMsg);
                if (!cardNumber.isEmpty()) {
                    for (String param : cardNumber) {
                        logMsg = logMsg.replaceAll(param, idNumberEncrypt(param));
                    }
                }
                final Set<String> bankCardNumber = validateBankCardNumber(logMsg);
                if (!bankCardNumber.isEmpty()) {
                    for (String param : bankCardNumber) {
                        logMsg = logMsg.replaceAll(param, idNumberEncrypt(param));
                    }
                }

                logMsg = dealAddress(logMsg);
                return logMsg;
            } catch (Exception e) {
                e.printStackTrace();
                return super.convert(event);
            }
        } else {
            return logMsg;
        }
    }

    private static String dealAddress(String logMsg) {
        char[] charArray = logMsg.toCharArray();
        if (logMsg.contains("市")) {
            while (logMsg.contains("市")) {
                for (int i = logMsg.indexOf("市"); i < logMsg.length() - 1; i++) {
                    if (checkAddressEnd(charArray[i])) {
                        break;
                    }
                    charArray[i] = SYMBOL_STAR.charAt(0);
                }
                logMsg = String.valueOf(charArray);
            }
        } else {
            if (logMsg.contains("省")) {
                while (logMsg.contains("省")) {
                    for (int i = logMsg.indexOf("省"); i < logMsg.length() - 1; i++) {
                        if (checkAddressEnd(charArray[i])) {
                            break;
                        }
                        charArray[i] = SYMBOL_STAR.charAt(0);

                    }
                    logMsg = String.valueOf(charArray);
                }
            }
        }
        return String.valueOf(charArray);
    }

    private static boolean checkAddressEnd(char c) {
        return String.valueOf(c).equals(" ") || String.valueOf(c).equals(":") || String.valueOf(c).equals("；") ||
            String.valueOf(c).equals("：") || String.valueOf(c).equals(";") || String.valueOf(c).equals(",")
            || String.valueOf(c).equals("，") || String.valueOf(c).equals("“") || String.valueOf(c).equals("\"");
    }

    /**
     * 获取日志字符串内容中符合手机号
     */
    private static Set<String> validatePhoneNumber(String param) {
        Set<String> set = new HashSet<>();
        // 匹配手机号
        Matcher phoneMatcher = PHONE_PATTERN.matcher(param);
        while (phoneMatcher.find()) {
            set.add(phoneMatcher.group());
        }
        return set;
    }

    private static Set<String> validateLandline(String param) {
        Set<String> set = new HashSet<>();
        // 匹配手机号
        Matcher phoneMatcher = LANDLINE.matcher(param);
        while (phoneMatcher.find()) {
            set.add(phoneMatcher.group());
        }
        return set;
    }


    private static Set<String> validateLandlineArea(String param) {
        Set<String> set = new HashSet<>();
        // 匹配手机号
        Matcher phoneMatcher = LANDLINE_AREA.matcher(param);
        while (phoneMatcher.find()) {
            set.add(phoneMatcher.group());
        }
        return set;
    }


    private static Set<String> validateIDNumber(String param) {
        Set<String> set = new HashSet<>();
        Matcher phoneMatcher = ID_NUMBER.matcher(param);
        while (phoneMatcher.find()) {
            set.add(phoneMatcher.group());
        }
        return set;
    }

    private static Set<String> validateCardNumber(String param) {
        Set<String> set = new HashSet<>();
        Matcher phoneMatcher = CARD_NUMBER.matcher(param);
        while (phoneMatcher.find()) {
            set.add(phoneMatcher.group());
        }
        return set;
    }

    private static Set<String> validateBankCardNumber(String param) {
        Set<String> set = new HashSet<>();
        Matcher phoneMatcher = BANK_CARD_NUMBER.matcher(param);
        while (phoneMatcher.find()) {
            set.add(phoneMatcher.group());
        }
        return set;
    }

    private static Set<String> validateEmail(String param) {
        Set<String> set = new HashSet<>();
        Matcher phoneMatcher = EMAIL.matcher(param);
        while (phoneMatcher.find()) {
            set.add(phoneMatcher.group());
        }
        return set;
    }

    private static Set<String> validateAddress(String param) {
        Set<String> set = new HashSet<>();
        Matcher phoneMatcher = ADDRESS.matcher(param);
        while (phoneMatcher.find()) {
            set.add(phoneMatcher.group());
        }
        return set;
    }

    /**
     * 手机号脱敏
     *
     * @param mobile
     * @return
     */
    public static String mobileEncrypt(String mobile) {
        if (StrUtil.isEmpty(mobile) || (mobile.length() != 11)) {
            return mobile;
        }
        switch (logMode) {
            case 0:
                return mobile.replaceAll("(\\d{3})(\\d{4})(\\d{4})", "***$2$3");
            case 1:
                return mobile.replaceAll("(\\d{3})(\\d{4})(\\d{4})", "$1****$3");
            case 2:
                return mobile.replaceAll("(\\d{3})(\\d{4})(\\d{4})", "$1$2****");
            default:
                return mobile;
        }
    }

    public static String idNumberEncrypt(String idNumber) {
        if (StrUtil.isEmpty(idNumber)) {
            return idNumber;
        }
        return filterString(idNumber, SYMBOL_STAR);
    }

    public static String emailEncrypt(String email) {
        if (StrUtil.isEmpty(email)) {
            return email;
        }
        return filterEmail(email, SYMBOL_STAR);
    }

    public static String addressEncrypt(String address) {
        if (StrUtil.isEmpty(address)) {
            return address;
        }
        return filterAddress(address, SYMBOL_STAR);
    }


    public static String filterAddress(String address, String symbol) {
        if (StrUtil.isNotBlank(address) && !address.contains("省") && !address.contains("市")) {
            return buildSymbol(symbol, address.length());
        }
        return address;
    }

    public static String filterEmail(String email, String symbol) {
        if (email.contains("@")) {
            int i = email.lastIndexOf("@");
            String front = email.substring(0, i);
            String rear = email.substring(i).replace("@", "#");
            return filterString(front, symbol).concat(rear);
        }
        return email;
    }

    public static String filterString(String s, String symbol) {
        if (StrUtil.isNotBlank(s)) {
            char[] charArray = s.toCharArray();
            switch (logMode) {
                //隐藏前三位
                case 0:
                    for (int i = 0; i < Math.min(3, charArray.length); i++) {
                        charArray[i] = symbol.charAt(0);
                    }
                    return String.valueOf(charArray);
                //隐藏中间4位
                case 1:
                    for (int i = Math.max((charArray.length / 2 - 2), 0); i < (Math.min((charArray.length / 2 + 2), charArray.length)); i++) {
                        charArray[i] = symbol.charAt(0);
                    }
                    return String.valueOf(charArray);
                case 2:
                    for (int i = Math.max((charArray.length - 1), 0); i >= (Math.max((charArray.length - 4), 0)); i--) {
                        charArray[i] = symbol.charAt(0);
                    }
                    return String.valueOf(charArray);
                default:
                    break;
            }
        }
        return s;
    }


    /**
     * @param symbol 符号
     * @param num    数量
     * @return 创建一定数量的相同符号字符串
     */
    public static String buildSymbol(String symbol, int num) {
        if (num < 0) {
            throw new IndexOutOfBoundsException("-1");
        }
        StringBuilder value = new StringBuilder();
        while (--num >= 0) {
            value.append(symbol);
        }
        return value.toString();
    }
}

备注： logMode 与 logSensitive 参数 可配置在启动参数上，然后springboot项目启动时读取入参并赋值给对应的静态变量以达到日志规则与日志开关的动态控制。
启动参数配置
在这里插入图片描述

2.xml中配置

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
    <property name="APP_NAME" value="data"/>
    <property name="LOG_HOME" value="./data/logs/${APP_NAME}"/>

    <conversionRule conversionWord="m" converterClass="....SensitiveLogDataConverter"/>
    ......
</configuration>

补充：正则表达式不会的小伙伴可以去网上找，案例很多。

码农-人生
关注
springmvc log4j2 logback 注解 jackson 日志脱敏实现源码
12-30
几乎是网上 能找到的 日志脱敏的所有实现 1、基于正则表达式的 日志脱敏实现 ，扩展logback 、log4j 2、springmvc 返回报文脱敏。 3、基于注解方式的脱敏。 大家选择使用。
秒懂Springboot之如何使用logback做日志脱敏和截取
ShuSheng007的程序人生
04-06 1805
日志的重要性无需多言，而数据的安全性亦不用赘述，但不幸的是它两常常产生矛盾。要便利就会牺牲安全，要安全就会牺牲便利，所以需要找到一个折中的方案：既满足日志方便审计以及查找问题的需求又兼顾安全。这就是我们今天要谈论的日志脱敏的问题。清楚logback的日志处理流程，确定要对下手清楚如何给Converter传参和如何解析参数清楚如何应用自定义的Converter会写各种正则表达式。
logback打印日志字段脱敏加密
Breaking_xu的博客
09-27 2509
logback自定义转换器，不需要修改原来代码，是在日志打印时对其参数进行加密处理，拓展性强。创建自定义转换类MySampleConverter, 继承MessageConverter类,并实现convert方法。}}让我们来看一下event里面是什么这个时候长得帅的小伙伴们都反应过来了，介不就是格式化后的日志吗！长得不那么帅的小伙伴就会问了，接下来呐！怎么办啊！当然是为所欲为了
这个开源组件太强了，仅需三步完成 SpringBoot 日志脱敏
Java知音
07-12 798
点击关注公众号，实用技术文章及时了解前言在我们书写代码的时候，会书写许多日志代码，但是有些敏感数据是需要进行安全脱敏处理的。对于日志脱敏的方式有很多，常见的有①使用conversionRule标签，继承MessageConverter②书写一个脱敏工具类，在打印日志的时候对特定特字段进行脱敏返回。两种方式各有优缺点：第一种方式需要修改代码，不符合开闭原则。第二种方式，需要...
logback日志脱敏
学习笔记
05-30 1250
logback日志脱敏。
【logback日志掩盖敏感信息】
u012632105的博客
09-24 256
logback日志掩盖敏感信息
java 日志的数据脱敏的实现方法
08-26
因此，数据脱敏是一种必要的安全措施，它通过对敏感数据进行部分替换或加密，以保护原始数据的完整性，同时确保日志仍然具有一定的可读性和分析价值。 以下是一个简单的实现策略： 1. **在Model层处理**： 一种...
安卓日志分析崩溃拦截相关-Android控制整个项目Log的打印和关闭.zip
07-29
2. **自定义日志类**：创建一个自定义的日志类（如`MyLog`），可以统一管理所有日志打印，实现动态开关，以及添加额外的信息，如线程名、时间戳、类名和方法名等，便于追踪和分析。 3. **日志拦截**：在自定义的...
data-mask:数据脱敏平台后端项目
05-14
7. **日志和监控**：使用Logback或Log4j记录系统日志，配合ELK（Elasticsearch、Logstash、Kibana）或Prometheus+Grafana进行性能监控和报警。 8. **持续集成/持续部署(CI/CD)**：使用Jenkins、GitLab CI/CD或...
日志错误报告
02-17
这些框架提供了丰富的功能，包括日志级别的控制、日志格式的定制、日志输出的目标（控制台、文件、数据库等）以及性能优化等。 Log4j是广泛使用的日志框架之一，它提供了灵活的日志配置和强大的功能。例如，通过...
(RSA+DES接口加密交互) (logback日志分级) (异常统一处理) (多数据源主主+redis集群).zip
08-18
(RSA+DES接口加密交互) (logback日志分级) (异常统一处理) (多数据源主主+redis集群) SpringSecurity权限控制 带图形验证码自定义认证器 SpringSecurity过滤器 登陆 + JWT + SpringSecurity权限控制
记录日志启用有限的线程进行记录相关内容
05-24
10. **安全性与隐私**：在记录敏感信息时，应遵循数据保护原则，可能需要对日志进行加密或脱敏处理，以保护用户隐私和企业信息安全。 在"如何调用.txt"和"threadPool"这两个文件中，很可能是介绍了如何在实际项目中...
logback实现日志信息脱敏
lh87270202的博客
11-12 7379
文章目录一、一些敏感信息比如 手机号、身份证号，不在明文在日志中打印，自定义logback转换器，将这些字段脱敏后输出1、定义一个ESensitiveDataConverter 类如下：2、logback.xml中添加如下配置： 一、一些敏感信息比如 手机号、身份证号，不在明文在日志中打印，自定义logback转换器，将这些字段脱敏后输出 1、定义一个ESensitiveDataConverter 类如下： import ch.qos.logback.classic.pattern.MessageConve
RSA非对称加密+BCryptPasswordEncoder+DES可逆加密+logback日志脱敏
の博客
03-17 260
Hash算法没有固定的公式，只要符合散列思想的算法都可以被称为Hash算法(SHA1，SHA2，MD5)。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相。2、得到解密后的明文后用A的公钥（PUB_A）解签A用A自己的私钥（PRI_A）的签名。1、用自己的私钥（PRI_B）解密A用B的公钥（PUB_B）加密的内容；1、A先用自己的私钥（PRI_A）对信息（一般是信息的摘要）进行签名。
Java对日志文件进行加密
CROSSFIT的博客
07-19 1413
Java，AES加密，Logback，自定义Appender
Logback+SM2+正则实现敏感日志数据加密/脱敏处理
最新发布
随笔
05-24 444
Logback+SM2+正则实现敏感日志数据加密/脱敏处理
一次性解决打日志时的4个重复低效场景（日志脱敏、日期格式化、json序列化)...
JiuQianWan的博客
03-22 1104
本篇文章是对之前的两篇文章的一个总结、补充。《日志里打出来的都是时间戳？教你一行代码搞定它》《日志里的敏感信息还在打明文？3 种日志脱敏方案任你选》之前的解决方案是基于 fastjson + logback，本次补充了 fastjson + log4j。至于其他的 json 序列化框架、日志框架，大家可以继续深究，重点是解决问题的思路。背景我们在打日志的过程有 4 个重复低效的场景1、对象都是 j...
日志里的敏感信息还在打明文？3 种日志脱敏方案任你选
热门推荐
JiuQianWan的博客
09-23 1万+
背景我们打的日志中经常包含姓名、手机号、银行卡号等敏感信息，如果不做任何处理，就会以明文的形式展示在日志中，存在安全风险。像下面这样：我们需要一种能自动帮我们脱敏的工具，效果如下：方案1 - 基于 logback我们得先搞清楚消息内容是在哪里处理的，也就是配置文件中这个占位符的内容：对应到源码是这里 ch.qos.logback.classic.PatternLayout ：这里可以看出来都是通...
本地安装日志脱敏jar包教程
资源摘要信息:"该资源是一个日志脱敏jar包，需要安装到本地Maven仓库。日志脱敏是指在处理日志时对敏感信息进行处理，以保护用户隐私或避免敏感信息泄露。本资源的jar包使用Logback框架作为日志管理工具，其版本为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值