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

最新推荐文章于 2024-04-17 17:08:33 发布
最新推荐文章于 2024-04-17 17:08:33 发布
阅读量806 收藏 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>

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

码农-人生
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
logback打印日志字段脱敏加密
Breaking_xu的博客
09-27 2267
logback自定义转换器，不需要修改原来代码，是在日志打印时对其参数进行加密处理，拓展性强。创建自定义转换类MySampleConverter, 继承MessageConverter类,并实现convert方法。}}让我们来看一下event里面是什么这个时候长得帅的小伙伴们都反应过来了，介不就是格式化后的日志吗！长得不那么帅的小伙伴就会问了，接下来呐！怎么办啊！当然是为所欲为了
springmvc log4j2 logback 注解 jackson 日志脱敏实现源码
12-30
几乎是网上 能找到的 日志脱敏的所有实现 1、基于正则表达式的 日志脱敏实现 ，扩展logback 、log4j 2、springmvc 返回报文脱敏。 3、基于注解方式的脱敏。 大家选择使用。
logback日志脱敏
学习笔记
05-30 906
logback日志脱敏。
SpringBoot 控制台打印日志脱敏
最新发布
weixin_62761204的博客
04-17 1868
isWordChar方法用于判断从字符串 msg 中获取的 key 值是否为单词的一部分。该方法主要用于辅助敏感数据处理方法中的逻辑判断。msg：待处理的字符串，即原始消息。key：要判断的关键字。index：key 在 msg 中的索引位置。方法实现首先，定义了一个静态的正则表达式模式 pattern，用于匹配数字和字母字符 [0-9a-zA-Z]。
Spring Boot三步就能完成日志脱敏，简直太哇塞了！
m0_71777195的博客
01-12 178
该组件内置四种匹配规则：手机号、身份证号、邮箱、other(其他匹配不到时用的)，内置一种脱敏方式：password，表示完全脱敏，可用于pattren下的。：定义了对应需要脱敏的关键字，如上诉的email、phone等以及业务对象中的字段、Map中的Key、JSON中的Key。比如说，username字段的值可以是手机号、也可以是邮箱，这个值动态改变的，前面几种方式都没办法解决，可以使用该方式。建议书写日志的时候尽量规范，对于key为中文的是没有办法脱敏的，规范程度可以见脱敏效果演示里的代码。
这个开源组件太强了，仅需三步完成 SpringBoot 日志脱敏
Java知音
07-12 698
点击关注公众号，实用技术文章及时了解前言在我们书写代码的时候，会书写许多日志代码，但是有些敏感数据是需要进行安全脱敏处理的。对于日志脱敏的方式有很多，常见的有①使用conversionRule标签，继承MessageConverter②书写一个脱敏工具类，在打印日志的时候对特定特字段进行脱敏返回。两种方式各有优缺点：第一种方式需要修改代码，不符合开闭原则。第二种方式，需要...
RSA非对称加密+BCryptPasswordEncoder+DES可逆加密+logback日志脱敏
の博客
03-17 101
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 1042
Java，AES加密，Logback，自定义Appender
编码技巧——全局日志开关
娜娜米的博客
04-16 741
开发过程中，业务日志是非常重要且有必要的，往往能帮我们排查问题，如异常原因、入参出参、是否有脏数据、执行到了哪一步等；但是日志也不是越多越好，对于大流量接口，打日志需要慎重，大量的日志会导致频繁的IO、影响机器负载； " 根据经验，4核8G的机器，1个小时日志量不要超过20W "——经历过暴涨日志导致机器负载达到80的某模块SE给出的经验 此外，在中间件出异常时，如ZK连接不上、MQ链接异常等情况发生时，重启机器时也会产生疯长的日志量，可能导致服务依旧无法重启成功；这时候，如果有个全局的日志开关，能..
Spring如何动态自定义logback日志目录详解
08-26
主要给大家介绍了关于Spring如何动态自定义logback日志目录的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
logback日志配置demo
04-15
本文件为logback日志配置demo， 讲解如何配置logback日志及不同的配置方式，示例代码； 本包为maven项目。
自定义日志脱敏组件，简单3 步完成 Spring Boot 的日志脱敏
07-19
对于日志脱敏的方式有很多，常见的有①使用conversionRule标签，继承MessageConverter②书写一个脱敏工具类，在打印日志的时候对特定特字段进行脱敏返回。 两种方式各有优缺点：第一种方式需要修改代码，不符合开闭...
日志脱敏jar包（需要安装到本地仓库）
07-20
随便找个地儿，mvn -v确保maven仓库配置...mvn install:install-file -DgroupId=pers.liuchengyin -DartifactId=logback-desensitization -Dversion=1.0.0 -Dpackaging=jar -Dfile=logback-desensitization-1.0.0.jar
Logback动态修改日志级别的方法
08-26
主要介绍了Logback动态修改日志级别的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
工作备忘-设置Log日志打印开关
jaccty的博客
11-18 1057
在制作SDK时，经常要打印日志调试，但是发布时又不想要打印日志（十分消耗性能），并且将制作好得SDK交给他人使用时，为了给予他人良好的用户体验，设置打印Log日志开关就十分有必要了。首先：// 项目打包发布上线不会打印日志，可放心。 #ifdef DEBUG #define DebugLog(s, ... ) NSLog( @"[%@：in line: %d]-->[message: %@]",
SpringBoot 项目中使用日志及线上日志相关配置
m0_73311735的博客
05-20 1210
其实是方便我们在相同日志接口下的不同日志框架实现自由切换，不需要改动任何代码。
最简单的日志开关
qhexin的专栏
03-21 1023
#if 0 // Set to 1 to enable debug logging #define MWLog(x, ...) NSLog(x, ## __VA_ARGS__); #else #define MWLog(x, ...) #endif
日志、java日志管理--logback、日志脱敏处理
编程日常记录与总结 https://franciswmf.iteye.com
09-27 2622
引用参考： 【splunk】 --Splunk—云计算&大数据时代的超级日志分析和监控利器 [url]https://blog.csdn.net/enweitech/article/details/51330610[/url] 【log4j】 --Log4j日志在java项目中的使用（附工程源码） [url]https://blog.csdn.net/wushiwude/artic...
labview控件图标大全
05-09
LabVIEW控件图标大全是一个重要的资源，它集合了各种常见和自定义的图标，可用于设计界面和自定义控件。这些图标的使用可以极大地提高应用程序的可读性和易用性。在这里，我们将介绍一下常见的LabVIEW控件图标。 1. 文字与数字控件图标：这些控件可用于输入和显示文字或数字，例如文本框、数字输入框和数字显示器。 2. 图像控件图标：这些控件可用于显示包括位图、图像或动画等在内的图像，并提供控制功能，例如图像显示板、屏幕录像仪和视频播放器。 3. 按钮控件图标：这些控件可用于执行操作，例如开关、复位、启动、停止和重启按钮。 4. 图形控件图标：这些控件可用于可视化数据，例如柱状图、曲线图和雷达图。 5. 状态指示器控件图标：这些控件可用于显示设备状态、数据状态或进度，例如灯泡、滚动条和图形指示器。 6. 控件容器图标：这些控件可用于组合其他控件，例如面板、图表和选项卡。 7. LabVIEW系统控件：这些控件可用于调整系统参数、显示输入和输出、记录日志和调试等功能。 除了这些常见的LabVIEW控件图标，用户也可以自定义控件图标以适应其特定的应用程序需求。总的来说，有了这些控件图标，用户可以更轻松地设计和实现各种功能强大的LabVIEW应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值