masquer les journaux avec la connexion logstash en Java en utilisant regex

Dans le monde actuel axé sur les données, la sécurité des données est la plus importante. Les infrastructures de journalisation jouent un rôle crucial dans la surveillance et le débogage des applications, mais elles peuvent exposer par inadvertance des informations sensibles qui n'auraient pas dû l'être. Le masquage des journaux est une technique qui masque efficacement les données sensibles dans les messages de journal, protégeant ainsi les informations confidentielles.

Comprendre la reconnexion

Logback est un framework de journalisation puissant et principalement utilisé dans les applications Java. Il offre des options de configuration flexibles, notamment la possibilité de formater les événements de journal en tant qu'objets JSON. C'est un successeur du framework Log4j, qui a rapidement gagné en popularité en raison de ses fonctionnalités et de sa facilité d'utilisation. Il comprend un enregistreur, des encodeurs, une mise en page, un appender et un encodeur.

Logger : Logger est un contexte pour les messages de journal. Les applications interagiront avec cette classe pour créer des messages de journal.

Encodeurs : Les encodeurs sont introduits dans la version 0.9.91 et sont responsables de la transformation d'un événement en un tableau d'octets ainsi que de l'écriture de ce tableau d'octets dans un OutputStream. Les encodeurs présentés en tant que Layouts sont uniquement capables de transformer un événement en chaîne, ce qui limite leur portée à une sortie non binaire.

Mise en page : La mise en page est responsable du formatage de la demande de journalisation selon les souhaits de l'utilisateur, tandis qu'un appender se charge d'envoyer la sortie formatée à sa destination.

Appenders : En langage de connexion, une destination de sortie est appelée un appender. Cela place les messages du journal dans leurs destinations finales. Un Logger peut avoir plusieurs Appender. Actuellement, des appenders existent pour la console, les fichiers, les serveurs de socket distants, vers MySQL, PostgreSQL, Oracle et d'autres bases de données, JMS et les démons Syslog UNIX distants.

À propos de l'encodeur de journalisation Logstash

La bibliothèque logstash-logback-encoder est un outil précieux pour améliorer les capacités de journalisation de vos applications Spring Boot. Il fournit un moyen pratique de formater les messages de journaux dans un format JSON structuré, les rendant facilement utilisables par des outils d'agrégation et d'analyse de journaux tels que Logstash. Le format JSON offre un moyen structuré et lisible par machine de consigner les informations, ce qui le rend idéal pour l'analyse avancée des journaux et les mesures de sécurité. Avantages du logstash

• JSON Customization Logstash vous permet de personnaliser la sortie JSON pour inclure des champs et des métadonnées spécifiques.

• Champs dynamiques Il permet également d'ajouter dynamiquement des champs pour enregistrer les événements en fonction du contexte de l'application.

• Lisibilité améliorée Le format JSON offre une structure claire et lisible par l'homme pour les événements de journal.

• Les outils améliorés d'agrégation de journaux de recherche et d'analyse peuvent facilement analyser et interroger les journaux JSON.

• Les journaux JSON d'analyse automatique sont idéaux pour les systèmes d'analyse et d'alerte automatisés.

Solution pour masquer les données dans les logs

L'objectif principal ici est de fournir une solution pour masquer les données qui soit personnalisable et configurable au moment de l'exécution.

Voici notre simple exigence de

1. masquer complètement le mot de passe dans le journal.
2. masquer le numéro de téléphone et le nom de connexion, sauf les 5 derniers enregistrements du journal.

Étape 1
Créez une application Spring Boot. Cette solution fonctionnera avec n'importe quelle application basée sur Java avec peu de personnalisation.

Étape 2
Configurez toutes les expressions régulières pour masquer les données. N'oubliez pas que les regex sont coûteuses en termes d'utilisation des ressources. Assurez-vous d'ajuster votre regex. Les groupes Regex nous permettront de sélectionner la sous-chaîne requise à partir de la chaîne.

Étape 3
Créez une classe et implémentez MessageJsonProvider. Cette interface provient de logstash et nous permet de personnaliser le message avant de l'imprimer sur l'appender. La méthode writeTo dans cette interface sera appelée pour chaque message de journal.

• dans la méthode start(), lisez toutes les expressions régulières et préparez LogMasker qui contient toutes les MaskingRule. Cette méthode provient de AbstractJsonProvider et marque simplement le processus démarré comme vrai.

• MaskingRule contiendra un modèle d'expression régulière et une fonction. Cette fonction remplace la chaîne identifiée dans le journal.
  

@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) : "";
    }
}

Étape 4
Configurez la classe dans le fichier 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);
    }

}

Il s'agit d'une solution très basique et ayant de nombreuses possibilités d'amélioration selon les exigences, comme le résumé du message, etc...

Vous pouvez trouver du code sur GitHub.

Veuillez laisser un commentaire si vous avez des questions.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!