logback日志脫敏

基於logback實現日志格式規范和脫敏

博客分類：

 
• JAVA

 

    我們在日常開發中，經常會使用logback打印日志，經常會在日志中打印比如手機號、卡號、郵箱等敏感信息，對數據安全而言是有風險的；但是如果業務程序如果處理這些問題，則需要在每個打印日志的地方都需要進行重復的脫敏操作，繁瑣而且影響代碼風格，還會有遺漏情況；此時我們可能需要考慮一個相對統一的解決方案，那就是增強logback底層的特性，在日志message落盤之前統一進行檢測、脫敏。

 

    我們通常的日志處理面臨的通用訴求：

    1）超長日志message截取：程序打印的日志message可能非常大，比如超過1M，這種message極大的影響系統的性能，而且通常數據價值比較低。我們應該對這種message進行截取或者直接拋棄。

    2）日志格式：通常情況下，我們的production環境的業務日志通過會按需采集、分析、存儲，那么日志格式的統一對下游數據處理是非常必要的；為了避免各種原因錯誤配置了日志格式，我們應該將日志格式規范進行默認集成且限制修改。（我司目前支持兩種格式：普通業務日志，通用數據集（監控指標）類日志）

    日志格式中，通常包含一些用於數據分揀的系統信息（項目名、部署集群名、IP、雲平台、rack等），也包含一些運行時的MDC動態參數值，最終格式是一致的。

    3）脫敏：日志中存在特定規則的字符串時，比如手機號，需要對其進行脫敏處理。

 

    設計核心思想：

    1）基於PatternLayoutEncoder來實現日志格式的限定，不再使用默認的pattern參數指定格式，而是固定字段格式 + 自定義字段，最終拼接成格式規范。

    其中局部可控字段，可以是系統變量、也可以MDC字段列表；固定格式部分，通常是message的頭部，統一包含時間、IP、項目名等等。

    2）基於logback提供的MessageConverter特性，在message打印之前允許對“參數格式化之后的message”（formattedMessage）進行轉換，最終logger打印的實際內容是converter返回的整形后的結果。

    那么，我們就可以基於此特性，在convert方法中執行“超長message截取”、“內容脫敏”兩個主要操作。

 

    主要類列表（新增類）：

    1）CommonPatternLayoutEncoder：父類為PatternLayoutEncoder，用於定義日志格式，包括固定字段部分、自定義字段部分，將系統屬性、MDC屬性等，進行拼接，同時基於logback的option特性，將動態參數傳遞給MessageConverter；最終拼接成一個字符串，作為pattern屬性。同時converter所需要的配置參數，比如消息最大長度、正則表達式、替換策略，都需要通過Encoder聲明。

    2）ComplexMessageConverter：message轉換，只會操作logger.info(String message,Throwable ex)傳遞的message部分，其中throwable棧信息不會被操作（其實也無法修改）。

    Converter可以獲取Encoder傳遞的option參數列表，並初始化相關的處理類；內部實現基於正則表達式來匹配敏感信息。

    3）DataSetPatternLayoutEncoder（可選）：主要用於限定數據集類的日志格式，它本身不能對敏感信息進行過濾；數據格式主要為了便於數據分析。

  

    1、CommonPatternLayoutEncoder.java

package ch.qos.logback.classic.encoder;

import ch.qos.logback.classic.PolicyEnum;
import ch.qos.logback.classic.Utils;

import java.text.MessageFormat;

import static ch.qos.logback.classic.Utils.DOMAIN_DELIMITER;
import static ch.qos.logback.classic.Utils.FIELD_DELIMITER;

/**
 * @author liuguanqing
 * created 2018/6/22 下午8:01
 * 適用於基於File的Appender
 * <p>
 * 限定我司日志規范，增加有關敏感信息的過濾。
 * 可以通過regex指定需要匹配和過濾的表達式，對於符合表達式的字符串，則采用policy進行處理。
 * 1）replace：替換，將字符串替換為facade，比如：18611001100 > 186****1100
 * 2) drop：拋棄整條日志
 * 3）erase：擦除字符串，全部替換成等長度的"****"，18611001100 > ***********
 * <p>
 * depth：正則匹配深度，默認為12，即匹配成功次數達到此值以后終止匹配，主要考慮是性能。如果一個超長的日志，我們不應該全部替換，否則可能引入性能問題。
 * maxLength：單條message的最大長度（不計算throwable），超長則截取，並在message尾部追加終止符。
 * <p>
 * 考慮到擴展性，用戶仍然可以直接配置pattern，此時regex、policy、depth等option則不生效。但是maxLength會一致生效。
 * 格式樣例：
 * %d{yyyy-MM-dd/HH:mm:ss.SSS}|IP_OR_HOSTNAME|REQUEST_ID|REQUEST_SEQ|^_^|
 * SYS_K1:%property{SYS_K1}|SYS_K2:%property{SYS_K2}|MDC_K1:%X{MDC_K1:--}|MDC_K2:%X{MDC_K2:--}|^_^|
 * [%t] %-5level %logger{50} %line - %m{o1,o2,o3,o4}%n
 * 格式中domain1是必選，而且限定無法擴展
 * domain2根據配置文件指定的system properties和mdcKeys動態拼接，K-V結構，便於解析；可以為空。
 * domain3是常規message部分，其中%m攜帶options，此后Converter可以獲取這些參數。
 **/
public class CommonPatternLayoutEncoder extends PatternLayoutEncoder {


    protected static final String PATTERN_D1 = "%d'{'yyyy-MM-dd/HH:mm:ss.SSS'}'|{0}|%X'{'requestId:--'}'|%X'{'requestSeq:--'}'";
    protected static final String PATTERN_D2_S1 = "{0}:%property'{'{1}'}'";
    protected static final String PATTERN_D2_S2 = "{0}:%X'{'{1}:--'}'";
    protected static final String PATTERN_D3_S1 = "[%t] %-5level %logger{50} %line - ";
    //0:message最大長度（超出則截取），1:正則表達式，2:policy，3:查找深度（超過深度后停止正則匹配）
    protected static final String PATTERN_D3_S2 = "%m'{'{0},{1},{2},{3}'}'%n";

    protected String mdcKeys;//來自MDC的key,多個key用逗號分隔。

    protected String regex = "-";//匹配的正則表達式，如果此值為null或者"-",那么policy、deep參數都將無效

    protected int maxLength = 2048;//單條消息的最大長度，主要是message

    protected String policy = "replace";//如果匹配成功，字符串的策略。

    protected int depth = 128;

    protected boolean useDefaultRegex = true;

    protected static final String DEFAULT_REGEX = "'((?<\\d)1[3-9]\\d{9}(?!\\d))'";//手機號，11位數字，並且前后位不再是數字。
    //系統參數，如果未指定，則使用default;
    protected String systemProperties;

    protected static final String DEFAULT_SYSTEM_PROPERTIES = "project,profiles,cloudPlatform,clusterName";

    @Override
    public void start() {
        if (getPattern() == null) {
            StringBuilder sb = new StringBuilder();
            String d1 = MessageFormat.format(PATTERN_D1, Utils.getHostName());
            sb.append(d1);
            sb.append(FIELD_DELIMITER)
                    .append(DOMAIN_DELIMITER)
                    .append(FIELD_DELIMITER);
            //拼裝系統參數，如果當前數據視圖不存在，則先set一個默認值
            if (systemProperties == null || systemProperties.isEmpty()) {
                systemProperties = DEFAULT_SYSTEM_PROPERTIES;
            }
            //系統參數
            String[] properties = systemProperties.split(",");
            for (String property : properties) {
                String value = Utils.getSystemProperty(property);
                if (value == null) {
                    System.setProperty(property, "-");//初始化
                }
                sb.append(MessageFormat.format(PATTERN_D2_S1, property, property))
                        .append(FIELD_DELIMITER);
            }

            //拼接MDC參數
            if (mdcKeys != null) {
                String[] keys = mdcKeys.split(",");
                for (String key : keys) {
                    sb.append(MessageFormat.format(PATTERN_D2_S2, key, key));
                    sb.append(FIELD_DELIMITER);
                }
                sb.append(DOMAIN_DELIMITER)
                        .append(FIELD_DELIMITER);
            }
            sb.append(PATTERN_D3_S1);

            if (PolicyEnum.codeOf(policy) == null) {
                policy = "-";
            }

            if (maxLength < 0 || maxLength > 10240) {
                maxLength = 2048;
            }

            //如果設定了自定義regex，則優先生效；否則使用默認
            if (!regex.equalsIgnoreCase("-")) {
                useDefaultRegex = false;
            }
            if (useDefaultRegex) {
                regex = DEFAULT_REGEX;
            }

            sb.append(MessageFormat.format(PATTERN_D3_S2, String.valueOf(maxLength), regex, policy, String.valueOf(depth)));
            setPattern(sb.toString());
        }
        super.start();
    }

    public String getMdcKeys() {
        return mdcKeys;
    }

    public void setMdcKeys(String mdcKeys) {
        this.mdcKeys = mdcKeys;
    }

    public String getRegex() {
        return regex;
    }

    public void setRegex(String regex) {
        this.regex = regex;
    }

    public int getMaxLength() {
        return maxLength;
    }

    public void setMaxLength(int maxLength) {
        this.maxLength = maxLength;
    }

    public String getPolicy() {
        return policy;
    }

    public void setPolicy(String policy) {
        this.policy = policy;
    }

    public int getDepth() {
        return depth;
    }

    public void setDepth(int depth) {
        this.depth = depth;
    }

    public Boolean getUseDefaultRegex() {
        return useDefaultRegex;
    }

    public boolean isUseDefaultRegex() {
        return useDefaultRegex;
    }

    public void setUseDefaultRegex(boolean useDefaultRegex) {
        this.useDefaultRegex = useDefaultRegex;
    }

    @Override
    public String getPattern() {
        return super.getPattern();
    }

    @Override
    public void setPattern(String pattern) {
        super.setPattern(pattern);
    }

    public String getSystemProperties() {
        return systemProperties;
    }

    public void setSystemProperties(String systemProperties) {
        this.systemProperties = systemProperties;
    }


}

 

    1）日志格式部分，僅供參考。

 

    2）MDC參數聲明格式為：%X{key}，如果上下文中key不存在，則打印""；我們通過使用“:-”來聲明其默認值，比如%X{key:--}表示如果key不存在則將打印“-”。

 

    3）根據logback的規定，option參數列表需要聲明在某個字段中，並配合<conversionRule>才能生效，以本文為例，我們主要對message進行整形，所以option參數聲明在%m上，其格式為：

    “%m{o1,o2...}”，多個option之間以“,”分割。然后o1,o2的字面值，將可以在Converter中獲取。簡單來說，你需要將參數傳遞給Converter時，這些參數必須以option方式聲明在某個字段上，否則沒法做。

    特別注意，如果option參數中如果包含“{”、“}”時，必須將option參數使用''包括。比如%m{2048,'\\d{11}','replace','128'}，為了便於理解，建議所有的option參數都使用''逐個包含。

 

    此外，如果你對日志格式中，還需要使用系統參數（System Property），可以使用“%property{key}”來聲明，有個問題，就是如果這些系統參數不是通過“java -jar -Dkey=value”設置的，而是在運行時通過System.setProperty(key,value)設置的，這些系統參數在logback初始化時是無法獲得的，因為logback初始化結束后才會執行application程序；你可以在Encoder的start方法中先設定為這些系統參數設定一個默認值，以免日志打印是出現大量null。

 

    4）MessageFormat格式化字符串時，字符串中如果包含“{”、“}”特殊字符,也需要將這兩個字符使用''包含，比如：

     MessageFormat.format("展示一下'{'{0}'}'格式化的效果。","hello") 

        輸出>>

    "展示一下{hello}格式化效果。"

 

    5）useDefaultRegex：是否使用默認表達式，即手機號數字（連續11位數字，且后位不再跟進數字）。

 

    6）regex：我們也允許用戶自定義表達式。此時需要將useDefaultRegex設定為false才能生效。

    7）maxLength：默認值為2048，即message的最大長度超過此值后將會被截取，可配置。

    8）policy：對於regex匹配成功的字符串，如何處理。（處理規則，參見下文ComplexMessageConverter）

        A）drop：直接拋棄，將message重置為一個“終止符號”。比如：

        “我的手機號為18611001100”

            將會被整形為：

        “><”。

        B）replace：替換，將敏感信息除去前三、后四位字符之外的其他字符用“*”替換，也是默認策略。比如：

        “我的手機號為18611001100”

            將會被整形為：

        “我的手機號為186****1100”。

        C）erase：參數，將匹配成功的字符串，全部替換為等長度的“*”，比如：

        “我的手機號為18611001100”

            將會被整形為：

        “我的手機號為***********”。

 

    9）depth：匹配深度，即message中，最多匹配成功的次數，超過之后將會終止匹配，主要考慮性能，默認值為128。假如message中有200個手機號，那么匹配和替換到128個之后，將會終止操作，剩余的手機號將不會再替換。

 

    10）mdcKeys：指定pattern拼接時，需要植入的mdc參數列表，比如mdcKeys="name,address"，那么在pattern中將會包含：

    “name:%X{name:--}|address:%X{address:--}”

 

    其實大家主要關注的是option部分，Encoder的主要作用就是拼接一個pattern大概樣例：

格式樣例：
%d{yyyy-MM-dd/HH:mm:ss.SSS}|IP_OR_HOSTNAME|REQUEST_ID|REQUEST_SEQ|^_^|
    SYS_K1:%property{SYS_K1}|SYS_K2:%property{SYS_K2}|MDC_K1:%X{MDC_K1:--}|MDC_K2:%X{MDC_K2:--}|^_^|
    [%t] %-5level %logger{50} %line - %m{2048,'(\\d{11})','replace',128}

格式中domain1是必選，而且限定無法擴展
domain2根據配置文件指定的system properties和mdcKeys動態拼接，K-V結構，便於解析；可以為空。
domain3是常規message部分，其中%m攜帶options，此后Converter可以獲取這些參數。

   

 

    2、ComplexMessageConverter.java

package ch.qos.logback.classic.pattern;

import ch.qos.logback.classic.PolicyEnum;
import ch.qos.logback.classic.spi.ILoggingEvent;

import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author liuguanqing
 * created 2018/6/22 下午8:01
 * <p>
 * 日志格式轉換器，會為每個appender創建一個實例，所以在配置層面需要考慮兼容。
 * 主要目的是，根據配置的regex來匹配message，對於匹配成功的字符串進行替換操作，並返回修正后的message。
 **/
public class ComplexMessageConverter extends MessageConverter {

    protected String regex = "-";
    protected int depth = 0;
    protected String policy = "-";
    protected int maxLength = 2048;
    private ReplaceMatcher replaceMatcher = null;

    @Override
    public void start() {
        List<String> options = getOptionList();
        //如果存在參數選項，則提取
        if (options != null && options.size() == 4) {
            maxLength = Integer.valueOf(options.get(0));
            regex = options.get(1);
            policy = options.get(2);
            depth = Integer.valueOf(options.get(3));

            if ((regex != null && !regex.equals("-"))
                    && (PolicyEnum.codeOf(policy) != null)
                    && depth > 0) {
                replaceMatcher = new ReplaceMatcher();
            }
        }
        super.start();
    }

    @Override
    public String convert(ILoggingEvent event) {
        String source = event.getFormattedMessage();
        if (source == null || source.isEmpty()) {
            return source;
        }
        //復雜處理的原因：盡量少的字符串轉換、空間重建、字符移動。共享一個builder
        if (source.length() > maxLength || replaceMatcher != null) {
            StringBuilder sb = null;
            //如果超長截取
            if (source.length() > maxLength) {
                sb = new StringBuilder(maxLength + 6);
                sb.append(source.substring(0, maxLength))
                        .append("❮❮❮");//后面增加三個終止符
            }
            //如果啟動了matcher
            if (replaceMatcher != null) {
                //如果沒有超過maxLength
                if (sb == null) {
                    sb = new StringBuilder(source);
                }
                return replaceMatcher.execute(sb, policy);
            }

            return sb.toString();
        }

        return source;
    }

    class ReplaceMatcher {
        Pattern pattern;

        ReplaceMatcher() {
            pattern = Pattern.compile(regex);
        }

        String execute(StringBuilder source, String policy) {

            Matcher matcher = pattern.matcher(source);

            int i = 0;
            while (matcher.find() && (i < depth)) {
                i++;
                int start = matcher.start();
                int end = matcher.end();
                if (start < 0 || end < 0) {
                    break;
                }
                String group = matcher.group();
                switch (policy) {
                    case "drop":
                        return "❯❮";//只要匹配，立即返回
                    case "replace":
                        source.replace(start, end, facade(group, true));
                        break;
                    case "erase":
                    default:
                        source.replace(start, end, facade(group, false));
                        break;

                }
            }
            return source.toString();
        }

    }

    /**
     * 混淆，但是不能改變字符串的長度
     *
     * @param source
     * @param included
     * @return
     */
    public static String facade(String source, boolean included) {
        int length = source.length();
        StringBuilder sb = new StringBuilder();
        //長度超過11的，保留前三、后四，中間全部*替換
        //低於11位或者included=false，全部*替換
        if (length >= 11) {
            if (included) {
                sb.append(source.substring(0, 3));
            } else {
                sb.append("***");
            }
            sb.append(repeat('*', length - 7));
            if (included) {
                sb.append(source.substring(length - 4));
            } else {
                sb.append(repeat('*', 4));
            }
        } else {
            sb.append(repeat('*', length));
        }

        return sb.toString();
    }

    private static String repeat(char t, int times) {
        char[] r = new char[times];
        for (int i = 0; i < times; i++) {
            r[i] = t;
        }
        return new String(r);
    }
}

 

   此類主要是從CommonPatternLayoutEncoder聲明的options（即regix、maxLength、policy、depth）並初始化一個Matcher，針對message進行匹配和替換。正則比較消耗CPU，此外還要認真設計，避免在message處理過程中，新建太多的字符串，否則會大量消耗內存；我們在處理時，盡可能確保主message只有一個，replace時不改變message的長度，可以避免因為重建String導致一些空間浪費。

 

    自所以Converter能夠發揮作用，離不開<conversionRule>，參看下文的配置樣例。不過還需要注意，每個Appender都會根據<conversionRule>創建一個Converter實例，所以Converter設計時注意代碼兼容。

 

    3、logback.xml配置樣例

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    ...

    <conversionRule conversionWord="m" converterClass="ch.qos.logback.classic.pattern.ComplexMessageConverter"/>

    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
        <file>你的日志文件名</file>
        <Append>true</Append>
        <prudent>false</prudent>
        <encoder class="ch.qos.logback.classic.encoder.CommonPatternLayoutEncoder">
            <useDefaultRegex>true</useDefaultRegex>
            <policy>replace</policy>
            <maxLength>2048</maxLength>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <FileNamePattern>你的日志名.%d{yyyy-MM-dd}.%i</FileNamePattern>
            <maxFileSize>64MB</maxFileSize>
            <maxHistory>7</maxHistory>
            <totalSizeCap>6GB</totalSizeCap>
        </rollingPolicy>
    </appender>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.ConsolePatternLayoutEncoder"/>
    </appender>

    ...
</configuration>

    

    <conversionRule>節點中的“conversionWord='m'”，其中m就是對應pattern中的“%m”，可以從“%m”獲取options列表。

    因為CommonPatternLayoutEncoder中已經限定了pattern的格式，所以我們再logback.xml中也不需要再顯示的聲明pattern參數，基於此可以限定業務日志的格式保持統一。當然如果有特殊情況需要自定義，仍然可以使用<pattern>來聲明以覆蓋默認格式。