In der heutigen datengesteuerten Welt ist Datensicherheit am wichtigsten. Protokollierungs-Frameworks spielen eine entscheidende Rolle bei der Anwendungsüberwachung und beim Debuggen, können jedoch versehentlich vertrauliche Informationen preisgeben, die nicht hätten offengelegt werden dürfen. Bei der Protokollmaskierung handelt es sich um eine Technik, die vertrauliche Daten in Protokollnachrichten wirksam verschleiert und so vertrauliche Informationen schützt.
Logback ist ein leistungsstarkes und am häufigsten verwendetes Protokollierungsframework in Java-Anwendungen. Es bietet flexible Konfigurationsoptionen, einschließlich der Möglichkeit, Protokollereignisse als JSON-Objekte zu formatieren. Es ist ein Nachfolger des Log4j-Frameworks und hat aufgrund seiner Funktionen und Benutzerfreundlichkeit schnell an Popularität gewonnen. Es besteht aus Logger, Encodern, Layout, Appender und Encoder.
Logger:Logger ist ein Kontext für Protokollnachrichten. Anwendungen interagieren mit dieser Klasse, um Protokollnachrichten zu erstellen.
Encoder:Encoder werden in Logback 0.9.91 eingeführt und sind für die Umwandlung eines Ereignisses in ein Byte-Array sowie für das Schreiben dieses Byte-Arrays in einen OutputStream verantwortlich. Als Layouts eingeführte Encoder können ein Ereignis nur in einen String umwandeln, was ihren Umfang auf nicht-binäre Ausgaben beschränkt.
Layout: Das Layout ist für die Formatierung der Protokollierungsanfrage gemäß den Wünschen des Benutzers verantwortlich, während ein Appender dafür sorgt, dass die formatierte Ausgabe an ihr Ziel gesendet wird.
Appender: In der Logback-Sprache wird ein Ausgabeziel als Appender bezeichnet. Dadurch werden Protokollnachrichten an ihren endgültigen Zielorten abgelegt. Ein Logger kann mehr als einen Appender haben. Derzeit gibt es Appender für die Konsole, Dateien, Remote-Socket-Server, MySQL, PostgreSQL, Oracle und andere Datenbanken, JMS und Remote-UNIX-Syslog-Daemons.
Die logstash-logback-encoder-Bibliothek ist ein wertvolles Tool zur Verbesserung der Protokollierungsfunktionen Ihrer Spring Boot-Anwendungen. Es bietet eine bequeme Möglichkeit, Protokollnachrichten in einem strukturierten JSON-Format zu formatieren, sodass sie problemlos von Protokollaggregations- und Analysetools wie Logstash verwendet werden können. Das JSON-Format bietet eine strukturierte und maschinenlesbare Möglichkeit zum Protokollieren von Informationen und eignet sich daher ideal für erweiterte Protokollanalysen und Sicherheitsmaßnahmen. Vorteile von Logstash
JSON-Anpassungslogstash ermöglicht es Ihnen, die JSON-Ausgabe so anzupassen, dass sie bestimmte Felder und Metadaten enthält.
Dynamische Felder Es ermöglicht auch das dynamische Hinzufügen von Feldern zum Protokollieren von Ereignissen basierend auf dem Anwendungskontext.
Verbesserte Lesbarkeit Das JSON-Format bietet eine klare und für Menschen lesbare Struktur für Protokollereignisse.
Erweiterte Such- und Analyseprotokoll-Aggregationstools können JSON-Protokolle einfach analysieren und abfragen.
Machine Parsing JSON-Protokolle sind ideal für automatisierte Analyse- und Warnsysteme.
Das Hauptziel besteht darin, eine Lösung zum Maskieren der Daten bereitzustellen, die zur Laufzeit anpassbar und konfigurierbar ist.
Hier ist unsere einfache Anforderung an
Schritt 1
Erstellen Sie eine Spring-Boot-Anwendung. Diese Lösung funktioniert mit jeder Java-basierten Anwendung mit wenig Anpassung.
Schritt 2
Konfigurieren Sie alle regulären Ausdrücke, um die Daten zu maskieren. Bitte beachten Sie, dass reguläre Ausdrücke im Hinblick auf die Ressourcennutzung kostspielig sind. Stellen Sie sicher, dass Sie Ihren regulären Ausdruck optimieren. Mit Regex-Gruppen können wir den erforderlichen Teilstring aus dem String auswählen.
Schritt 3
Erstellen Sie eine Klasse und implementieren Sie MessageJsonProvider. Diese Schnittstelle stammt von logstash und ermöglicht es uns, die Nachricht anzupassen, bevor wir sie an den Appender senden. Die writeTo-Methode in dieser Schnittstelle wird für jede Protokollnachricht aufgerufen.
in der start()-Methode alle regulären Ausdrücke lesen und LogMasker vorbereiten, der alle MaskingRule enthält. Diese Methode stammt von AbstractJsonProvider und markiert einfach den gestarteten Prozess als wahr.
MaskingRule enthält ein Regex-Muster und eine Funktion. Diese Funktion ersetzt die identifizierte Zeichenfolge aus dem Protokoll.
@Data
public class MaskingMessagingProvider extends MessageJsonProvider {
public static final String DEFAULT_RULES_DELIMITER = ",";
private LogMasker logMasker;
private String rules;
public MaskingMessagingProvider() {
super();
}
@Override
public void start() {
super.start();
this.logMasker = LogMasker.create(StringUtils.tokenizeToStringArray(rules, DEFAULT_RULES_DELIMITER));
}
@Override
public void writeTo(JsonGenerator generator, ILoggingEvent event) throws IOException {
if (isStarted()) {
JsonWritingUtils.writeStringField(generator, getFieldName(), logMasker.mask(event.getFormattedMessage()));
}
}
}
class LogMasker {
private MaskingRule[] masks;
public LogMasker(MaskingRule[] masks) {
super();
this.masks = masks.clone();
}
public static LogMasker create(String[] rules) {
return new LogMasker(Arrays.stream(rules).map(rule -> MaskingRule.create(rule)).toArray(MaskingRule[]::new));
}
public String mask(String input) {
String transformed = input;
for (MaskingRule m : masks) {
transformed = m.mask(transformed);
}
return transformed;
}
}
class MaskingRule {
public static final int REG_EX_DEFAULT_GROUP_SELECTOR = 2;
public static final String DEFAULT_REPLACEMENT = "*";
private Pattern pattern;
private UnaryOperator<String> replacement;
public MaskingRule(Pattern maskPattern, UnaryOperator<String> replacement) {
super();
this.pattern = maskPattern;
this.replacement = replacement;
}
public static MaskingRule create(String rule) {
return new MaskingRule(Pattern.compile(rule), (in) -> MaskingRule.maskDataWithReplacement(in, DEFAULT_REPLACEMENT));
}
public String mask(String transformed) {
Matcher matcher = pattern.matcher(transformed);
StringBuffer sb = new StringBuffer();
while (matcher.find()) {
matcher.appendReplacement(sb, replacement.apply(getDataToBeMasked(matcher)));
}
matcher.appendTail(sb);
return sb.toString();
}
private static String maskDataWithReplacement(String input, String replacement) {
int repetition = !StringUtils.hasLength(input) ? 0 : input.length();
return String.join("", Collections.nCopies(repetition, replacement));
}
private static String getDataToBeMasked(Matcher matcher) {
if (matcher.groupCount() > 1) {
return matcher.group(REG_EX_DEFAULT_GROUP_SELECTOR);
}
return matcher.groupCount() > 0 ? matcher.group(1) : "";
}
}
Schritt 4
Konfigurieren Sie die Klasse in der Datei logback-spring.xml.
<configuration>
<springProperty scope="context" name="rules" source="app.logging.masking.rules"
defaultValue=""/>
<appender name="CONSOLE">
<p><strong>Steps 5</strong><br>
Run the application. For simplicity, i have taken a string which is holding data and printing it at application start up.<br>
</p>
<pre class="brush:php;toolbar:false">@SpringBootApplication
@Slf4j
public class LogDataMaskingApplication {
public static void main(String[] args) {
SpringApplication.run(LogDataMaskingApplication.class, args);
LogDataMaskingApplication.maskingTest();
}
public static void maskingTest() {
String data = "{\"loginName\":\"maskingtest\",\"phoneNumber\":\"9898981212\",\"password\":\"Masking@123\"}";
log.info(data);
}
}
Dies ist eine sehr einfache Lösung und bietet viel Spielraum für Verbesserungen je nach Anforderung, z. B. Message Digest usw.
Code finden Sie bei GitHub.
Bitte hinterlassen Sie einen Kommentar, wenn Sie Fragen haben.
Das obige ist der detaillierte Inhalt vonMaskieren Sie Protokolle mit Logstash-Logback in Java mithilfe von Regex. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
