Verbesserung der Datensicherheit durch Überwachung der Dateiintegrität

Einsatz von Watchdog zur Einhaltung von Vorschriften und zur Risikominderung

Unternehmen sind nur dann Gesetzeskonform, wenn sie, unter anderem, den ordnungsgemäßen Umgang mit personenbezogenen Daten (PII) ihrer Kunden nachweisen können. Ein Aspekt dieser Strategie ist die Frage, wie die Integrität von Dateien mit personenbezogenen Daten innerhalb einer Anwendung mit Schnittstelle für den Nutzer verwaltet und sichergestellt wird.

Die Überwachung der Dateiintegrität (File Integrity Monitoring, FIM) ist eine Strategie, die eingeführt wurde, um Warnmechanismen zu aktivieren und zu definieren, die Sicherheitsteams benachrichtigen, wenn der Zustand der Benutzerdaten gefährdet ist und ein Cyberangriff stattfinden könnte.

Dateiintegrität bei Upsun

Upsun (und damit auch Platform.sh) basiert auf einer starken Trennung zwischen Code und Daten. Unsere Plattform basiert auf der Nutzung von Git,. Das schafft für ihr Unternehmen eine Beziehung zwischen dem, was in ein Repository übertragen wird, und der Art und Weise, wie dieser Code in der bereitgestellten Infrastruktur, aktiven Umgebungen und dem was letztendlich ihren Benutzern zur Verfügung gestellt wird.

Wir verknüpfen einzelne Commits, den Zustand ihres Codes und ihrer Konfiguration, mit eindeutigen Build-Images. Diese Images können zwar zwischen Umgebungen verschoben werden, was zu unseren zentralen Funktionen zum Klonen von Umgebungen führt, aber sie können nach der Bereitstellung zur Laufzeit in keiner Weise mehr geändert werden.

Dieses Feature wird durch eine kurze Liste von Regeln ermöglicht, die ihren Projekten auferlegt werden, darunter:

• Änderungen an der Infrastruktur müssen über Commits vorgenommen werden.
• Der Zugriff auf Projekte, Umgebungen, Anwendungen, Dienste oder die Außenwelt muss immer explizit definiert werden.
• Daten und Code sind unterschiedlich. Code, Infrastruktur und Konfiguration sollten committed werden, Daten hingegen nie.
• Der Read-Only-Zugriff auf das Dateisystem bleibt zur Laufzeit bestehen, es sei denn, es wird ausdrücklich anders definiert.
• Daten fließen in untergeordnete Umgebungen

Solange sich ihre Projekte und Teammitglieder an diese Grundsätze halten, sollte alles, was in Git übertragen wird (einschließlich der Infrastruktur), geschützt sein.

Die Angriffsfläche ist jedoch nicht vollständig beseitigt, wenn wir ihre Anwendung selbst und die Dinge, die Sie kontrollieren, in Betracht ziehen. Es ist beispielsweise notwendig, dass benutzerseitige Felder bereinigt werden und Eingaben in ihrer Anwendung validiert werden, um SQL-Injektionen und andere Methoden zu verhindern, die es böswilligen Akteuren ermöglichen würden, beliebigen Code auszuführen, der ein Risiko für personenbezogene Daten darstellt.

Watchdog

Dieser Schutz ist nur die eine Hälfte des FIM-Puzzles, aber selbst mit den besten Praktiken kann nicht vollständig sichergestellt werden, dass personenbezogene Daten niemals offengelegt und/oder verändert werden. Für die Dinge, die wir nicht erwarten können, müssen wir eine Überwachung einrichten, die Benachrichtigungen auslöst, wenn Änderungen an den gespeicherten Dateien vorgenommen werden.

Benachrichtigungen ermöglichen es uns nicht nur, auf laufende Angriffe zu reagieren, sondern auch, bestimmte Meldepflichten zu erfüllen, die im Falle eines Verstoßes gegen die Datenschutzbestimmungen erforderlich sein können.

Obwohl ein solches Benachrichtigungssystem bei Upsun nicht standardmäßig vorhanden ist, können wir mithilfe von Open-Source-Tools, die Änderungen an unseren Verzeichnissen überwachen, eine solche Benachrichtigungsstrategie aufbauen.

Watchdog ist eine Open-Source-Python-Bibliothek und ein Shell-Tool zur Überwachung von Dateisystemereignissen. Wir können Watchdog zusätzlich zu unseren bewährten Verfahren zur Zugriffskontrolle verwenden, um ein Benachrichtigungssystem zur Überwachung von Dateisystemänderungen einzurichten.

Nachfolgend finden Sie eine einfache Anwendung, die im Grunde keinen Code enthält, außer dem, was für die Konfiguration der Infrastruktur zur Einrichtung eines Watchdog-Workers zur Überwachung von Dateisystemänderungen an einer einzelnen Einhängung relevant ist.

applications:
  notify:
    # Dieses Beispiel nutzt einfach das Composable image für Python
    # `type:'python:3.12'` hätte auch funktioniert
    stack:
      - python@3.12
      - python312Packages.pip
    hooks:
      build: |
        set -e
        pip install -r requirements.txt
    #Best Practices für Referenzen
    access:
      ssh: admin
    web:
      commands:
        start: sleep infinity
    # EIn Mount mit den sensiblen Daten
    mounts:
      user_pii:
        source: storage

Aktualisieren Sie die Upsun-Konfiguration für den Worker:

applications: notify: # Dieses Beispiel verwendet das Composable-Image für Python, dachte aber, dass einfach # `type:'python:3.12'` genauso gut funktionieren würde stack: - python@3.12 - python312Packages.pip hooks: build: | set -e pip install -r requirements.txt # Einige Best Practices für den Referenzzugang: ssh: admin web: commands: start: sleep infinity # Unser Mount mit sensiblen Daten. mounts: user_pii: source: storage

Diese Konfiguration richtet einen einzelnen Python 3.12-Container mit einem einzigen beschreibbaren Verzeichnis ein, das unsere sensiblen Benutzerdaten(user_pii) enthält. Als nächstes installieren wir Watchdog über eine virtuelle Umgebung

python3 -m venv env
env/bin/activate
(env) pip install watchdog requests
(env) pip freeze > requirements.txt
(env) deactivate
echo "env" > .gitignore

Erstellen Sie dann das Notifizierungsskript, das von unserem Worker-Container aus ausgeführt werden soll:

# https://github.com/gorakhargosh/watchdog
# https://pypi.org/project/requests/
# https://philipkiely.com/code/python_watchdog.html

import os
import sys
import time
import datetime
import requests
import logging
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class Watcher:

    def __init__(self, directory=".", handler=FileSystemEventHandler()):
        self.observer = Observer()
        self.handler = handler
        self.directory = directory

    def run(self):
        self.observer.schedule(
            self.handler, self.directory, recursive=True)
        self.observer.start()
        print("\nWatcher läuft in {}/\n".format(self.directory))
        try:
            while True:
                time.sleep(1)
        except:
            self.observer.stop()
        self.observer.join()
        print("\nWatcher beendet\n")

class MyHandler(FileSystemEventHandler):

    webhook_url = "https://webhook.site/3cbc9b0d-d2c1-4b95-8576-1e3070f704cd"

    if os.environ.get("WATCH_WEBHOOK_URL") is not None:
        webhook_url = os.environ["WATCH_WEBHOOK_URL"]

    logging.basicConfig(level=logging.INFO,
                    format='%(asctime)s - %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S')

    def on_any_event(self, event):
        if not event.is_directory:
            event_data = {
                "src_path": event.src_path,
                "dest_path": event.dest_path,
                "event_type": event.event_type,
                "is_directory": event.is_directory,
                "is_synthetic": event.is_synthetic,
                "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S%z")
            }
            logging.info(f'{event.event_type.upper()!r}: {event_data!r}')
            resp = requests.post(self.webhook_url, json = event_data)
            alert_data = {
                "status_code": resp.status_code,
                "url": resp.url
            }
            logging.info(f'{"WEITERGELEITET".upper()!r}: {alert_data!r}')

if __name__=="__main__":
    watchpath = sys.argv[1] if len(sys.argv) > 1 else '.'
    w = Watcher(watchpath, MyHandler())
    w.run()

Zu beachten im obigen Skript ist, dass:

• Eine FileSystemEventHandler-Klasse wird verwendet, um MyHandler zu definieren, die in den primären Watcher geleitet wird, wenn das Skript ausgeführt wird
• Der Watcher überwacht Dateisystemänderungen rekursiv, sofern ein Ziel als Befehlszeilenargument(sys.argv) übergeben wird.
• MyHandler hört auf Dateisystemänderungen on_an_event und leitet ein event_data JSON-Objekt entweder an eine Standard-Webhook-URL (in diesem Fall an eine temporäre Webhook-URL auf Webhook.site) oder an eine vom Benutzer bereitgestellte URL über die Umgebungsvariable WEBHOOK_URL weiter.

Wenn das Skript bereitist, können wir es parallel zur man-Anwendung über einen Worker ausführen :

    workers:
      watchdog:
        commands:
          start: |
            python watch.py $PLATFORM_APP_DIR/user_pii

Bevor wir den Push ausführen, können wir einige Laufzeitoperationen (nur für Administratoren!) einfügen , um unsere Änderungen zu testen:

    operations:
      init-secret:
        role: admin
        commands:
          start: |
            echo "Oceanic 815 SYD -> LAX, 13C; Status: DEPARTED" > \
              $PLATFORM_APP_DIR/user_pii/austen_kate.txt
      read-secret:
        role: admin
        commands:
          start: cat $PLATFORM_APP_DIR/user_pii/austen_kate.txt
      rewrite-secret:
        role: admin
        commands:
          start: >
            echo "Oceanic 815 SYD -> LAX, 13C; Status: LOST" > \
              $PLATFORM_APP_DIR/user_pii/austen_kate.txt
      destroy-secret:
        role: admin
        commands:
          start: rm $PLATFORM_APP_DIR/user_pii/austen_kate.txt

Zum Schluss werden alle Änderungen übertragen und gepusht:

git add . && git commit -m "Create a simple notifier app."
git push upsun main

Sobald die Anwendung bereitgestellt wurde, können wir unsere Laufzeitoperationen nutzen, um sicherzustellen, dass Dateisystemereignisse, die sensible Daten in einem Mount ändern, zu Benachrichtigungen an unsere gewünschte Webhook-URL führen.

1. Erstellen Sie eine Datei

upsun operation:run init-secret -y

Tatsächlich löst die Operation (Erstellen der Datei austen_kate.txt) vier Benachrichtigungen aus (open, created, modified, closed):

2. Datei aktualisieren

upsun operation:run rewrite-secret -y

Auch hier führt die Aktion (Aktualisierung der Datei austen_kate.txt) zu drei Ereignissen (öffnen, ändern, schließen), auf die wir aufmerksam gemacht werden können.

3. Eine Datei lesen

upsun operation:run read-secret -y

Wir können uns ebenfalls über die beiden Ereignisse (open, close_no_write) benachrichtigen lassen, die beim Lesen einer Datei mit sensiblen Daten auftreten(cat austen_kate.txt),

4. Löschen einer Datei

upsun operation:run destroy-secret -y

Schließlich kann das vollständige Entfernen der Datei aus dem Dateisystem eine eigene Benachrichtigung für das Ereignis "Single deleted filesystem" auslösen.

Dies ist ein sehr einfaches Beispiel dafür, wie Open-Source-Tools verwendet werden können, um ein benutzerdefiniertes Benachrichtigungssystem für FIM auf Upsun zu erstellen. Sie könnten die Umgebungsvariable WEBHOOK_URL aktualisieren, um eine Slack-Webhook-URL im Sicherheitsbenachrichtigungskanal ihrer Organisation zu verwenden , aber so wie es ist, würde dieser Kanal mit False Positives überflutet werden.

Hoffentlich können Sie jedoch erkennen, wie diese grundlegenden Werkzeuge angepasst werden können, um auf Folgendes zu hören:

• eine Teilmenge von Dateisystemereignissen
• nur die Dateisystemereignisse, die von anderen Agenten als den bekannten Administratoren oder ihrer Anwendung selbst ausgeführt werden
• Details darüber, was genau geändert wurde, um sie in die weitergeleitete Nachricht aufzunehmen
• Links zu den neuesten Sicherungen im Speicher, um die Zeit bis zur Wiederherstellung zu verkürzen

Passen Sie dieses Beispiel an ihre Bedürfnisse an, und unterschätzen Sie nie, was auf einer Anwendungsplattform mit so wenigen Regeln möglich ist. Viel Erfolg!