使用logback屏蔽日志中的敏感数据

问题描述 投票：12回答：5

我需要能够搜索事件中的任何一个模式，并用模板值替换模式中的文本。这是我们的应用程序中的一项功能，旨在防止敏感信息落入日志。由于信息可能来自各种各样的来源，因此在所有输入上应用过滤器是不切实际的。除了日志记录之外还有toString（）的用法，我不希望toString（）统一屏蔽所有调用（仅记录日志）。

我尝试在logback.xml中使用％replace方法：

<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %replace(%msg){'f k\="pin">(.*?)&lt;/f','f k\="pin">**********&lt;/f'}%n</pattern>

这是成功的（在用字符实体替换尖括号后），但它只能替换单个模式。我也想表现相当于

<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %replace(%msg){'pin=(.*?),','pin=**********,'}%n</pattern>

同时，但不能。无法在一个％替换中屏蔽两个模式。

在interblags上松散讨论的另一种方法是在appender / encoder / layout层次结构上进行扩展，但每次拦截ILoggingEvent的尝试都会导致整个系统崩溃，通常是通过实例化错误或UnsupportedOperationException。

例如，我尝试扩展PatternLayout：

@Component("maskingPatternLayout")
public class MaskingPatternLayout extends PatternLayout {

    @Autowired
    private Environment env;

    @Override
    public String doLayout(ILoggingEvent event) {
        String message=super.doLayout(event);

        String patternsProperty = env.getProperty("bowdleriser.patterns");

        if( patternsProperty != null ) {
            String[] patterns = patternsProperty.split("|");
            for (int i = 0; i < patterns.length; i++ ) {
                Pattern pattern = Pattern.compile(patterns[i]);
                Matcher matcher = pattern.matcher(event.getMessage());
                matcher.replaceAll("*");
            }
        } else {
            System.out.println("Bowdleriser not cleaning! Naughty strings are getting through!");
        }

        return message;
    }
}

然后调整logback.xml

<configuration>
  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
        <layout class="com.touchcorp.touchpoint.utils.MaskingPatternLayout">
      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </layout>
    </encoder>
  </appender>

    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
      <file>logs/touchpoint.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
            <fileNamePattern>logs/touchpoint.%i.log.zip</fileNamePattern>
            <minIndex>1</minIndex>
            <maxIndex>3</maxIndex>
        </rollingPolicy>

        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <maxFileSize>10MB</maxFileSize>
        </triggeringPolicy>
      <encoder>
          <layout class="com.touchcorp.touchpoint.utils.MaskingPatternLayout">
            <pattern>%date{YYYY-MM-dd HH:mm:ss} %level [%thread] %logger{10} [%file:%line] %msg%n</pattern>
          </layout>
      </encoder>
    </appender>


  <logger name="com.touchcorp.touchpoint" level="DEBUG" />
  <logger name="org.springframework.web.servlet.mvc" level="TRACE" />

  <root level="INFO">
    <appender-ref ref="FILE" />
    <appender-ref ref="STDOUT" />
  </root>
</configuration>

我已经尝试了很多其他的插入，所以我想知道是否有人实际上已经实现了我正在尝试的东西，以及他们是否可以提供任何线索或解决方案。

logback data-masking
5个回答
12
投票

你需要使用LayoutWrappingEncoder包装布局。而且我相信你不能在这里使用spring，因为logback不是由spring管理的。

这是更新的课程。

public class MaskingPatternLayout extends PatternLayout {

    private String patternsProperty;

    public String getPatternsProperty() {
        return patternsProperty;
    }

    public void setPatternsProperty(String patternsProperty) {
        this.patternsProperty = patternsProperty;
    }

    @Override
    public String doLayout(ILoggingEvent event) {
        String message = super.doLayout(event);

        if (patternsProperty != null) {
            String[] patterns = patternsProperty.split("\\|");
            for (int i = 0; i < patterns.length; i++) {
                Pattern pattern = Pattern.compile(patterns[i]);

                Matcher matcher = pattern.matcher(event.getMessage());
                if (matcher.find()) {
                    message = matcher.replaceAll("*");
                }
            }
        } else {

        }

        return message;
    }

}

并示例logback.xml

<appender name="fileAppender1" class="ch.qos.logback.core.FileAppender">
    <file>c:/logs/kp-ws.log</file>
    <append>true</append>
    <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
        <layout class="com.kp.MaskingPatternLayout">
            <patternsProperty>.*password.*|.*karthik.*</patternsProperty>
            <pattern>%d [%thread] %-5level %logger{35} - %msg%n</pattern>
        </layout>
    </encoder>
</appender>
<root level="DEBUG">
    <appender-ref ref="fileAppender1" />
</root>

UPDATE

这是更好的方法，在init期间设置Pattern。这样我们就可以避免一次又一次地重新创建Pattern，这种实现接近于实际的用例。

公共类MaskingPatternLayout扩展PatternLayout {

private String patternsProperty;
private Optional<Pattern> pattern;

public String getPatternsProperty() {
    return patternsProperty;
}

public void setPatternsProperty(String patternsProperty) {
    this.patternsProperty = patternsProperty;
    if (this.patternsProperty != null) {
        this.pattern = Optional.of(Pattern.compile(patternsProperty, Pattern.MULTILINE));
    } else {
        this.pattern = Optional.empty();
    }
}

    @Override
    public String doLayout(ILoggingEvent event) {
        final StringBuilder message = new StringBuilder(super.doLayout(event));

        if (pattern.isPresent()) {
            Matcher matcher = pattern.get().matcher(message);
            while (matcher.find()) {

                int group = 1;
                while (group <= matcher.groupCount()) {
                    if (matcher.group(group) != null) {
                        for (int i = matcher.start(group); i < matcher.end(group); i++) {
                            message.setCharAt(i, '*');
                        }
                    }
                    group++;
                }
            }
        }
        return message.toString();
    }

}

和更新的配置文件。

<appender name="fileAppender1" class="ch.qos.logback.core.FileAppender">
    <file>c:/logs/kp-ws.log</file>
    <append>true</append>
    <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
        <layout class="com.kp.MaskingPatternLayout">
            <patternsProperty>(password)|(karthik)</patternsProperty>
            <pattern>%d [%thread] %-5level %logger{35} - %msg%n</pattern>
        </layout>
    </encoder>
</appender>
<root level="DEBUG">
    <appender-ref ref="fileAppender1" />
</root>

产量

My username=test and password=*******
5
投票

从文档：

replace(p){r, t}

模式p可以是任意复杂的，特别是可以包含多个转换关键字。

面对同样的问题不得不在消息中替换2个模式，我只是尝试chain所以p只是一个替换的调用，在我的情况下：

%replace(  %replace(%msg){'regex1', 'replacement1'}  ){'regex2', 'replacement2'}

工作得很好，虽然我不知道我是否会推动它，而且p确实可以是任意复杂的。

1
投票

我在https://github.com/tersesystems/terse-logback有审查，允许你在一个地方定义一个审查员，然后在多个appender中引用它。

0
投票

一种非常相似但略有不同的方法围绕定制CompositeConverter并在引用自定义转换器的logback中定义<conversionRule ...>。

在我的一个技术演示项目中，我定义了一个MaskingConverter类，它定义了一系列模式，分析了日志记录事件，并更新了一个在我的logback configuration中使用的匹配。

由于链接专用答案在这里并不是我所钟爱的，所以我会在这里发布代码的重要部分并解释它的作用以及为什么这样设置。从基于Java的自定义转换器类开始：

public class MaskingConverter<E extends ILoggingEvent> extends CompositeConverter<E> {

  public static final String CONFIDENTIAL = "CONFIDENTIAL";
  public static final Marker CONFIDENTIAL_MARKER = MarkerFactory.getMarker(CONFIDENTIAL);

  private Pattern keyValPattern;
  private Pattern basicAuthPattern;
  private Pattern urlAuthorizationPattern;

  @Override
  public void start() {
    keyValPattern = Pattern.compile("(pw|pwd|password)=.*?(&|$)");
    basicAuthPattern = Pattern.compile("(B|b)asic ([a-zA-Z0-9+/=]{3})[a-zA-Z0-9+/=]*([a-zA-Z0-9+/=]{3})");
    urlAuthorizationPattern = Pattern.compile("//(.*?):.*?@");
    super.start();
  }

  @Override
  protected String transform(E event, String in) {
    if (!started) {
      return in;
    }
    Marker marker = event.getMarker();
    if (null != marker && CONFIDENTIAL.equals(marker.getName())) {
      // key=value[&...] matching
      Matcher keyValMatcher = keyValPattern.matcher(in);
      // Authorization: Basic dXNlcjpwYXNzd29yZA==
      Matcher basicAuthMatcher = basicAuthPattern.matcher(in);
      // sftp://user:password@host:port/path/to/resource
      Matcher urlAuthMatcher = urlAuthorizationPattern.matcher(in);

      if (keyValMatcher.find()) {
        String replacement = "$1=XXX$2";
        return keyValMatcher.replaceAll(replacement);
      } else if (basicAuthMatcher.find()) {
        return basicAuthMatcher.replaceAll("$1asic $2XXX$3");
      } else if (urlAuthMatcher.find()) {
        return urlAuthMatcher.replaceAll("//$1:XXX@");
      }
    }
    return in;
  }
}

此类定义了许多RegEx模式，相应的日志行应与比较相对应，并通过屏蔽密码来更新事件。

请注意，此代码示例假定日志行仅包含一种密码。当然，如果您想探测多个模式匹配的每一行，您当然可以自由地调整bahvior以满足您的需求。

要应用此转换器，只需将以下行添加到logback配置：

<conversionRule conversionWord="mask" converterClass="at.rovo.awsxray.utils.MaskingConverter"/>

它定义了一个新函数mask，它可以在模式中使用，以便屏蔽与自定义转换器中定义的任何模式匹配的任何日志事件。此函数现在可以在模式中使用，以告知Logback在每个日志事件上执行逻辑。各自的模式可能如下所示：

<property name="patternValue"
          value="%date{yyyy-MM-dd HH:mm:ss} [%-5level] - %X{FILE_ID} - %mask(%msg) [%thread] [%logger{5}] %n"/>

<!-- Appender definitions-->

<appender class="ch.qos.logback.core.ConsoleAppender" name="console">
    <encoder>
        <pattern>${patternValue}</pattern>
    </encoder>
</appender>

其中%mask(%msg)将原始日志行作为输入，并对传递给该函数的每一行执行密码屏蔽。

由于探测一个或多个模式匹配的每一行可能是昂贵的，上面的Java代码包括可以在日志语句中使用的Markers，以将日志语句本身的某些元信息发送到Logback / SLF4J。基于这些标记，可以实现不同的行为。在提供的场景中，可以使用标记接口告诉Logback相应的日志行包含机密信息，因此如果匹配则需要屏蔽。此转换器将忽略未标记为机密的任何日志行，这有助于更快地抽出行，因为不需要对这些行执行模式匹配。

在Java中，这样的标记可以添加到日志语句中，如下所示：

LOG.debug(MaskingConverter.CONFIDENTIAL_MARKER, "Received basic auth header: {}",
      connection.getBasicAuthentication());

对于上面提到的自定义转换器，它可能产生类似于Received basic auth header: Basic QlRXXXlQ=的日志行，它留下了第一个和最后几个字符，但是用XXX混淆了中间位。

0
投票

我使用了基于RegexCensor的censor来自库https://github.com/tersesystems/terse-logback。在logback.xml中

<!--censoring information-->
<newRule pattern="*/censor" actionClass="com.tersesystems.logback.censor.CensorAction"/>
<conversionRule conversionWord="censor" converterClass="com.tersesystems.logback.censor.CensorConverter" />
<!--impl inspired by com.tersesystems.logback.censor.RegexCensor -->
<censor name="censor-sensitive" class="com.mycompaqny.config.logging.SensitiveDataCensor"></censor>

我把列表正则表达式替换。

@Getter@Setter    
public class SensitiveDataCensor extends ContextAwareBase implements Censor, LifeCycle {
    protected volatile boolean started = false;
    protected String name;
    private List<Pair<Pattern, String>> replacementPhrases = new ArrayList<>();

    public void start() {

        String ssnJsonPattern = "\"(ssn|socialSecurityNumber)(\"\\W*:\\W*\".*?)-(.*?)\"";
        replacementPhrases.add(Pair.of(Pattern.compile(ssnJsonPattern), "\"$1$2-****\""));

        String ssnXmlPattern = "<(ssn|socialSecurityNumber)>(\\W*.*?)-(.*?)</";
        replacementPhrases.add(Pair.of(Pattern.compile(ssnXmlPattern), "<$1>$2-****</"));

        started = true;
    }

    public void stop() {
        replacementPhrases.clear();
        started = false;
    }

    public CharSequence censorText(CharSequence original) {
        CharSequence outcome = original;
        for (Pair<Pattern, String> replacementPhrase : replacementPhrases) {
            outcome = replacementPhrase.getLeft().matcher(outcome).replaceAll(replacementPhrase.getRight());
        } 
        return outcome;
    }
}

并在像这样的logback.xml中使用它

<message>[ignore]</message> <---- IMPORTANT to disable original message field so you get only censored message
...
<pattern>
    {"message": "%censor(%msg){censor-sensitive}"}
</pattern>

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.