TOC

So überwachen Sie Ihre Systemsicherheit mit osquery unter Ubuntu 16.04

Einführung

osquery ist ein Open-Source-Sicherheitstool, das ein Betriebssystem in eine riesige Datenbank mit Tabellen verwandelt, die Sie mit SQL-ähnlichen Anweisungen abfragen können. Mit diesen Abfragen können Sie die Dateiintegrität überwachen, den Status und die Konfiguration der Firewall überprüfen, Sicherheitsüberprüfungen des Zielservers durchführen und vieles mehr.

Es ist eine plattformübergreifende Anwendung mit Unterstützung für die neuesten Versionen von macOS, Windows 10, CentOS und Ubuntu. Es wird offiziell als Framework für die Instrumentierung, Überwachung und Analyse von SQL-basierten Betriebssystemen bezeichnet und stammt von Facebook.

Mit osquery können Sie Befehle wie "+ select * from logical_in_users; +" für Ihren Server ausführen und ein Ergebnis wie das folgende erhalten:

Output+-----------+----------+-------+------------------+------------+------+
| type      | user     | tty   | host             | time       | pid  |
+-----------+----------+-------+------------------+------------+------+
| login     | LOGIN    | ttyS0 |                  | 1483580429 | 1546 |
| login     | LOGIN    | tty1  |                  | 1483580429 | 1549 |
| user      | root     | pts/0 | 24.27.68.82      | 1483580584 | 1752 |
| user      | sammy    | pts/1 | 11.11.11.11      | 1483580770 | 4057 |
| boot_time | reboot   | ~     | 4.4.0-57-generic | 1483580419 | 0    |
| runlevel  | runlevel | ~     | 4.4.0-57-generic | 1483580426 | 53   |
+-----------+----------+-------+------------------+------------+------+

Wenn Sie dies möchten, werden Sie osquery gerne als Tool zur Überwachung der Systemsicherheit und zur Erkennung von Eindringlingen für Ihren Server verwenden.

Durch das Installieren von osquery erhalten Sie Zugriff auf die folgenden Komponenten:

  • + osqueryi +: Die interaktive osquery-Shell zum Ausführen von Ad-hoc-Abfragen.

  • + osqueryd +: Ein Daemon zum Planen und Ausführen von Abfragen im Hintergrund.

  • + osqueryctl +: Ein Hilfsskript zum Testen einer Bereitstellung oder Konfiguration von osquery. Es kann auch anstelle des Service Managers des Betriebssystems zum Starten / Stoppen / Neustarten von + osqueryd + verwendet werden.

+ osqueryi + und + osqueryd + sind unabhängige Werkzeuge. Sie kommunizieren nicht miteinander und Sie können eins ohne das andere verwenden. Die meisten Flags und Optionen, die für die Ausführung benötigt werden, sind gleich. Sie können + osqueryi + mit der Konfigurationsdatei von + osqueryd + `starten, um die Umgebung anzupassen, ohne viele Befehlszeilenoptionen zu verwenden.

In diesem Tutorial werden Sie:

  • Installieren Sie osquery.

  • Konfigurieren Sie Aspekte des Betriebssystems, wie z. B. Rsyslog, die osquery benötigt, um ordnungsgemäß zu funktionieren.

  • Richten Sie eine Konfigurationsdatei ein, die von "+ osqueryi " und " osqueryd +" verwendet werden kann.

  • Arbeiten Sie mit osquery packs, einer Gruppe vordefinierter Abfragen, die Sie einem Zeitplan hinzufügen können.

  • Führen Sie Ad-hoc-Abfragen mit "+ osqueryi +" durch, um nach Sicherheitsproblemen zu suchen.

  • Starten Sie den Dämon, damit Abfragen automatisch ausgeführt werden können.

Mit dem Dämon "+ osqueryd +" erstellte Protokolle sollen an externe Protokollierungsendpunkte gesendet werden, die zusätzliche Kenntnisse für die Einrichtung und ordnungsgemäße Verwendung erfordern. In diesem Lernprogramm wird diese Konfiguration nicht behandelt. Sie erfahren jedoch, wie Sie den Daemon konfigurieren, ausführen und die Ergebnisse lokal speichern.

Voraussetzungen

Um dieses Lernprogramm abzuschließen, muss Folgendes vorhanden sein:

  • Ein Ubuntu 16.04-Server, der mit einem Nicht-Root-Benutzer mit Sudo-Berechtigungen und einer Firewall konfiguriert ist. Befolgen Sie die Initial Setup Guide for Ubuntu 16.04, um dies einzurichten.

Sie sollten auch ein grundlegendes Verständnis von SQL und eine https://www.digitalocean.com/community/tutorials/an-einführung-zum-Sichern-Ihres-Linux-VPS haben.

Schritt 1 - osquery auf dem Server installieren

Sie können osquery installieren, indem Sie es aus dem Quellcode kompilieren oder den Paketmanager verwenden. Da das offizielle Ubuntu-Repository kein installierbares Paket enthält, müssen Sie das offizielle Ubuntu-Repository des Projekts zum System hinzufügen.

Fügen Sie zunächst den öffentlichen Schlüssel des Repositorys hinzu:

sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 1484120AC4E9F8A1A577AEEE97A80C63C9D8B80B

Fügen Sie dann das Repository hinzu:

sudo add-apt-repository "deb [arch=amd64] https://osquery-packages.s3.amazonaws.com/xenial xenial main"

Aktualisieren Sie die Paketdatenbank:

sudo apt-get update

Zum Schluss installiere osquery:

sudo apt-get install osquery

Out of the Box ist osquery nicht unglaublich nützlich; Es ist keine Plug-and-Play-Anwendung. Unabhängig davon, ob Sie die interaktive Shell oder den Daemon verwenden möchten, müssen Sie einige Flags und Optionen entweder über die Befehlszeile oder über eine Konfigurationsdatei übergeben. Geben Sie Folgendes ein, um die für den Dämon verfügbaren Flags und Optionen anzuzeigen:

osqueryd --help

Die Ausgabe enthält Dutzende von Befehlszeilen-Flags und Konfigurationsoptionen. Unten ist eine Teilausgabe des für diesen Artikel verwendeten Testservers dargestellt.

Outputosquery 2.1.2, your OS as a high-performance relational database
Usage: osqueryd [OPTION]...

osquery command line flags:

   --flagfile PATH                           Line-delimited file of additional flags
   --config_check                            Check the format of an osquery config and exit
   --config_dump                             Dump the contents of the configuration
   --config_path VALUE                       Path to JSON config file
   --config_plugin VALUE                     Config plugin name
   --config_tls_endpoint VALUE               TLS/HTTPS endpoint for config retrieval
   --config_tls_max_attempts VALUE           Number of attempts to retry a TLS config/enroll request
   --config_tls_refresh VALUE                Optional interval in seconds to re-read configuration
   --daemonize                               Run as daemon (osqueryd only)

...

...

osquery configuration options (set by config or CLI flags):

   --audit_allow_config                      Allow the audit publisher to change auditing configuration
   --audit_allow_sockets                     Allow the audit publisher to install socket-related rules
   --audit_persist                           Attempt to retain control of audit
   --aws_access_key_id VALUE                 AWS access key ID
   --aws_firehose_period VALUE               Seconds between flushing logs to Firehose (default 10)
   --aws_firehose_stream VALUE               Name of Firehose stream for logging
   --aws_kinesis_period VALUE                Seconds between flushing logs to Kinesis (default 10)
   --aws_kinesis_random_partition_key        Enable random kinesis partition keys
   --aws_kinesis_stream VALUE                Name of Kinesis stream for logging
   --aws_profile_name VALUE                  AWS profile for authentication and region configuration
   --aws_region VALUE                        AWS region

Geben Sie Folgendes ein, um zusätzliche Befehlszeilenflags anzuzeigen, die nur für die interaktive Shell verfügbar sind:

osqueryi --help

Das Ausführen von + osqueryi + ist die einfachste Methode zum Auflisten und Abfragen der sofort verfügbaren osquery-Tabellen. Starten Sie es beispielsweise mit dem folgenden Befehl:

osqueryi --verbose

Dies versetzt Sie in eine interaktive Shell und Sie sehen eine Ausgabe ähnlich der folgenden:

OutputI0105 01:52:54.987584  4761 init.cpp:364] osquery initialized [version=2.1.2]
I0105 01:52:54.987808  4761 extensions.cpp:351] Could not autoload extensions: Failed reading: /etc/osquery/extensions.load
I0105 01:52:54.987944  4761 extensions.cpp:364] Could not autoload modules: Failed reading: /etc/osquery/modules.load
I0105 01:52:54.988209  4761 init.cpp:606] Error reading config: config file does not exist: /etc/osquery/osquery.conf
I0105 01:52:54.988334  4761 events.cpp:886] Error registering subscriber: socket_events: Subscriber disabled via configuration
I0105 01:52:54.993973  4763 interface.cpp:307] Extension manager service starting: /home/sammy/.osquery/shell.em
Using a virtual database. Need help, type '.help'
osquery>

Aufgrund der Fehler- und Informationsmeldungen in der Ausgabe ist es offensichtlich, dass alle Teile von osquery nicht richtig funktionieren. Bestimmte Abfragen, wie "+ select * from yara; +" geben nichts zurück, was zeigt, dass die Tabelle nicht mit Daten gefüllt wurde.

Andere Abfragen, wie "+ Zeit, Schweregrad, Nachricht von Syslog auswählen; +", geben eine Nachricht wie die folgende zurück, die angibt, dass noch mehr Arbeit zu erledigen ist:

OutputW1202 15:44:48.600539  1720 virtual_table.cpp:492] Table syslog is event-based but events are disabled
W1202 15:44:48.600587  1720 virtual_table.cpp:499] Please see the table documentation: https://osquery.io/docs/#syslog

Wir werden einige Änderungen an der Serverkonfiguration vornehmen, um dieses Problem zu beheben.

Beenden Sie die Konsole, indem Sie Folgendes eingeben:

.exit

Im nächsten Abschnitt werden wir Aspekte des Betriebssystems ändern, die osquery benötigt, um ordnungsgemäß zu funktionieren.

Schritt 2 - Zulassen, dass osquery auf das Systemprotokoll zugreift

In diesem Schritt ändern wir die Syslog-Anwendung des Betriebssystems, damit osquery das Systemprotokoll verwenden und abfragen kann. Unter Ubuntu 16.04 bedeutet dies, die Rsyslog-Konfigurationsdatei zu ändern. Die einzige Änderung, die Sie vornehmen müssen, besteht darin, ein paar Codezeilen an die Konfigurationsdatei anzuhängen.

Öffnen Sie zunächst die Datei "+ / etc / rsyslog.conf +":

sudo nano /etc/rsyslog.conf

Wir müssen einige Konfigurationszeilen hinzufügen, die Rsyslog mitteilen, in welche Pipe geschrieben werden soll und welche Syslog-Parameter in diese Pipe geschrieben werden sollen. Standardmäßig lautet die Pipe "+ / var / osquery / syslog_pipe ". osquery füllt dann seine " syslog +" - Tabelle mit Informationen, die in diese Pipe geschrieben wurden.

Fügen Sie die folgenden Zeilen an die Datei an:

/etc/rsyslog.conftemplate(
 name="OsqueryCsvFormat"
 type="string"
 string="%timestamp:::date-rfc3339,csv%,%hostname:::csv%,%syslogseverity:::csv%,%syslogfacility-text:::csv%,%syslogtag:::csv%,%msg:::csv%\n"
)
*.* action(type="ompipe" Pipe="/var/osquery/syslog_pipe" template="OsqueryCsvFormat")

Speichern und schließen Sie die Datei. Starten Sie den Syslog-Daemon neu, um die Änderungen zu übernehmen:

sudo systemctl restart rsyslog

Jetzt erstellen wir eine Konfigurationsdatei, in der einige Standardoptionen festgelegt und einige Abfragen geplant werden.

Schritt 3 - Erstellen einer osquery-Konfigurationsdatei

Das Erstellen einer Konfigurationsdatei erleichtert das Ausführen von + osqueryi +. Anstatt viele Befehlszeilenoptionen übergeben zu müssen, kann "+ osqueryi " diese Optionen aus einer Konfigurationsdatei in " /etc/osquery/osquery.conf +" lesen. Natürlich steht die Konfigurationsdatei auch dem Dämon zur Verfügung.

Die Konfigurationsdatei enthält auch Abfragen, die termingerecht ausgeführt werden müssen. Die meisten Abfragen, die Sie termingerecht ausführen können, werden jedoch als so genannte packs ausgeliefert. Packs sind Dateien, die sich im Verzeichnis + / usr / share / osquery / packs + befinden.

Zum Lieferumfang von osquery gehört keine Konfigurationsdatei, es gibt jedoch eine Beispielkonfigurationsdatei, die Sie nach + / etc / osquery + kopieren und ändern können. Diese Datei verfügt jedoch nicht über alle Optionen, die Sie zum Ausführen auf einer Linux-Distribution wie Ubuntu benötigen. Daher erstellen wir unsere eigene.

Die Konfigurationsdatei besteht aus drei Abschnitten:

  • Eine Liste der Dämonoptionen und Funktionseinstellungen. Diese können auch von "+ osqueryi +" gelesen werden.

  • Eine Liste der geplanten Abfragen, die ausgeführt werden sollen und wann sie ausgeführt werden sollen.

  • Eine Liste von Paketen, mit denen spezifischere geplante Abfragen durchgeführt werden können.

Im Folgenden finden Sie eine Liste der Optionen, die wir für unsere Konfigurationsdatei verwenden, deren Bedeutung und die Werte, auf die wir sie einstellen werden. Diese Liste von Optionen reicht aus, um + osquery und` + osquery` unter Ubuntu 16.04 und anderen Linux-Distributionen auszuführen.

  • * config_plugin *: Wo soll osquery seine Konfigurationen lesen? Standardmäßig werden sie von einer Datei auf der Festplatte gelesen, daher lautet der Wert für diese Datei "+ Dateisystem +".

  • * logger_plugin *: Gibt an, wo osquery Ergebnisse geplanter Abfragen schreiben soll. Wieder verwenden wir "+ Dateisystem +".

  • * logger_path *: Dies ist der Pfad zum Protokollverzeichnis, in dem Sie Dateien mit Informationen, Warnungen, Fehlern und Ergebnissen geplanter Abfragen finden. Standardmäßig ist dies "+ / var / log / osquery +".

  • * disable_logging *: Durch Setzen des Wertes auf "+ false +" aktivieren wir die Protokollierung.

  • * log_result_events *: Wenn Sie dies auf "+ true +" setzen, stellt jede Zeile in den Ergebnisprotokollen eine Statusänderung dar.

  • * schedule_splay_percent *: Hiermit wird osquery mitgeteilt, dass bei einer großen Anzahl von Abfragen, die in demselben Intervall geplant wurden, diese verteilt ausgeführt werden sollen, um die Auswirkungen auf die Leistung auf dem Server zu begrenzen. Der Standardwert ist "+ 10 +", was einem Prozentsatz entspricht.

  • * pidfile *: Wo soll die Prozess-ID des osquery-Daemons geschrieben werden? Die Standardeinstellung ist "+ / var / osquery / osquery.pidfile +".

  • * events_expiry *: In Sekunden, wie lange der Abonnent gehalten werden soll, wird der osquery-Sicherungsspeicher erstellt. Im Auslieferungszustand ist dies auf "+ 3600 +" eingestellt.

  • * database_path *: Der Pfad zur Datenbank von osquery. Wir verwenden die Standardeinstellung "+ / var / osquery / osquery.db +".

  • * verbose *: Wenn die Protokollierung aktiviert ist, wird diese verwendet, um ausführliche Informationsnachrichten zu aktivieren oder zu deaktivieren. Wir setzen dies auf "+ false".

  • * worker_threads *: Anzahl der Arbeitsthreads, die zum Verarbeiten von Abfragen verwendet werden. Dies ist standardmäßig auf "+ 2 +" eingestellt, daher belassen wir es dabei.

  • * enable_monitor *: Dient zum Aktivieren oder Deaktivieren des Zeitplanmonitors. Wir werden es aktivieren, daher lautet der Wert "+ true +".

  • * disable_events *: Wird zur Regulierung des Publish / Subscribe-Systems von osquery verwendet. Wir müssen dies aktivieren, damit der Wert hier "+ false +" ist.

  • * disable_audit *: Dient zum Deaktivieren des Empfangs von Ereignissen vom Überwachungssubsystem des Betriebssystems. Wir müssen es aktivieren, damit der hier verwendete Wert "+ false +" ist.

  • * audit_allow_config *: Ermöglicht dem Überwachungsverleger, die Überwachungskonfiguration zu ändern. Standard ist + true +.

  • * audit_allow_sockets *: Hiermit kann der Prüfverleger Socket-bezogene Regeln installieren. Der Wert wird "+ true +" sein.

  • * host_identifier *: Hiermit wird der Host identifiziert, auf dem osquery ausgeführt wird. Wenn Sie Ergebnisse von mehreren Servern zusammenfassen, können Sie auf einfache Weise ermitteln, von welchem ​​Server ein bestimmter Protokolleintrag stammt. Der Wert ist entweder "+ hostname " oder " uuid ". Im Auslieferungszustand ist " Hostname +" eingestellt, daher verwenden wir diesen Wert.

  • * enable_syslog *: Damit osquery Syslog-Informationen verarbeiten kann, muss dies auf "+ true +" gesetzt sein.

  • * schedule_default_interval *: Wenn das Intervall einer geplanten Abfrage nicht festgelegt ist, verwenden Sie diesen Wert. Es ist in Sekunden und wir stellen es auf "+ 3600 +".

Sie haben bereits gesehen, wie Sie alle Befehlszeilen-Flags und Konfigurationsoptionen anzeigen, die für "+ osqueryi " und " osqueryd +" verfügbar sind. Die oben genannten Optionen reichen jedoch aus, um osquery auf diesem Server auszuführen.

Erstellen und öffnen Sie die Konfigurationsdatei mit dem folgenden Befehl:

sudo nano /etc/osquery/osquery.conf

Die Konfigurationsdatei verwendet das Format JSON. Kopieren Sie den folgenden Inhalt in die Datei:

/etc/osquery/osquery.conf

{
 "options": {
   "config_plugin": "filesystem",
   "logger_plugin": "filesystem",
   "logger_path": "/var/log/osquery",
   "disable_logging": "false",
   "log_result_events": "true",
   "schedule_splay_percent": "10",
   "pidfile": "/var/osquery/osquery.pidfile",
   "events_expiry": "3600",
   "database_path": "/var/osquery/osquery.db",
   "verbose": "false",
   "worker_threads": "2",
   "enable_monitor": "true",
   "disable_events": "false",
   "disable_audit": "false",
   "audit_allow_config": "true",
   "host_identifier": "hostname",
   "enable_syslog": "true",
   "audit_allow_sockets": "true",
   "schedule_default_interval": "3600"
 },

Der nächste Teil der Konfigurationsdatei ist der Planungsabschnitt. Jede Abfrage wird durch einen Schlüssel oder Namen identifiziert, der in der Datei eindeutig sein muss, gefolgt von der auszuführenden Abfrage und dem Intervall in Sekunden, in dem die Abfrage ausgeführt werden soll. Wir fügen eine geplante Abfrage hinzu, die alle 300 Sekunden in der Tabelle "+ crontab +" nachschaut.

Fügen Sie der Konfigurationsdatei folgende Zeilen hinzu:

/etc/osquery/osquery.conf

 "schedule": {
   "crontab": {
     "query": "SELECT * FROM crontab;",
     "interval": 300
   }
 },

Sie können beliebig viele Abfragen schreiben. Behalten Sie einfach das richtige Format. Wenn Sie dies nicht tun, schlägt die Überprüfung der Datei fehl. Fügen Sie beispielsweise die folgenden Zeilen hinzu, um ein paar weitere Abfragen hinzuzufügen:

/etc/osquery/osquery.conf

 "schedule": {
   "crontab": {
     "query": "SELECT * FROM crontab;",
     "interval": 300
   }







 },

Nach den geplanten Abfragen können Sie spezielle Abfragen hinzufügen, die als * Dekoratoren * bezeichnet werden. Hierbei handelt es sich um Abfragen, die Daten anderen geplanten Abfragen voranstellen. Bei den hier gezeigten Decorator-Abfragen werden die UUID des Hosts, auf dem osquery ausgeführt wird, und der Benutzername des Benutzers jeder geplanten Abfrage vorangestellt.

Hänge diese Zeilen an die Datei an:

/etc/osquery/osquery.conf

 "decorators": {
   "load": [
     "SELECT uuid AS host_uuid FROM system_info;",
     "SELECT user AS username FROM logged_in_users ORDER BY time DESC LIMIT 1;"
   ]
 },

Schließlich können wir osquery auf eine Liste von Paketen verweisen, die spezifischere Abfragen enthalten. Jede Installation von osquery wird mit einem Standardsatz von Paketen geliefert, die sich im Verzeichnis + / usr / share / osquery / packs + befinden. Eines der Pakete ist für macOS, der Rest für Linux-Systeme. Obwohl Sie die Pakete von ihrem Standardspeicherort aus verwenden können, können Sie sie auch in das Verzeichnis "+ / etc / osquery +" kopieren.

Fügen Sie diese Zeilen zur Datei hinzu, um die Datei zu vervollständigen.

/etc/osquery/osquery.conf

 "packs": {
    "osquery-monitoring": "/usr/share/osquery/packs/osquery-monitoring.conf",
    "incident-response": "/usr/share/osquery/packs/incident-response.conf",
    "it-compliance": "/usr/share/osquery/packs/it-compliance.conf",
    "vuln-management": "/usr/share/osquery/packs/vuln-management.conf"
 }
}

Beachten Sie die schließende geschweifte Klammer am Ende, die der öffnenden geschweiften Klammer in der ersten Zeile der Datei entspricht. Ihre fertige Konfigurationsdatei sollte folgendermaßen aussehen:

/etc/osquery/osquery.conf

{
 "options": {
   "config_plugin": "filesystem",
   "logger_plugin": "filesystem",
   "logger_path": "/var/log/osquery",
   "disable_logging": "false",
   "log_result_events": "true",
   "schedule_splay_percent": "10",
   "pidfile": "/var/osquery/osquery.pidfile",
   "events_expiry": "3600",
   "database_path": "/var/osquery/osquery.db",
   "verbose": "false",
   "worker_threads": "2",
   "enable_monitor": "true",
   "disable_events": "false",
   "disable_audit": "false",
   "audit_allow_config": "true",
   "host_identifier": "hostname",
   "enable_syslog": "true",
   "audit_allow_sockets": "true",
   "schedule_default_interval": "3600"
 },
 "schedule": {
   "crontab": {
     "query": "SELECT * FROM crontab;",
     "interval": 300
   },
   "system_profile": {
     "query": "SELECT * FROM osquery_schedule;"
   },
   "system_info": {
     "query": "SELECT hostname, cpu_brand, physical_memory FROM system_info;",
     "interval": 3600
   }
 },
 "decorators": {
   "load": [
     "SELECT uuid AS host_uuid FROM system_info;",
     "SELECT user AS username FROM logged_in_users ORDER BY time DESC LIMIT 1;"
   ]
 },
 "packs": {
    "osquery-monitoring": "/usr/share/osquery/packs/osquery-monitoring.conf",
    "incident-response": "/usr/share/osquery/packs/incident-response.conf",
    "it-compliance": "/usr/share/osquery/packs/it-compliance.conf",
    "vuln-management": "/usr/share/osquery/packs/vuln-management.conf"
 }
}

Speichern und schließen Sie die Datei und validieren Sie sie mit dem folgenden Befehl:

sudo osqueryctl config-check

Die Ausgabe sollte folgendermaßen aussehen:

OutputI0104 11:11:46.022858 24501 rocksdb.cpp:187] Opening RocksDB handle: /var/osquery/osquery.db

Wenn ein Fehler vorliegt, zeigt die Ausgabe den Ort des Fehlers an, damit Sie ihn beheben können.

Sobald Sie eine gültige Konfigurationsdatei haben, können Sie mit der Konfiguration des für die Überwachung der Dateiintegrität erforderlichen Osquery Packs fortfahren.

Schritt 4 - Einrichten des osquery File Integrity Monitoring Pack

Ein kritischer Aspekt bei der Überwachung der Systemsicherheit ist die Überwachung der Integrität der Dateien auf Ihrem Server. Zu diesem Zweck bietet osquery eine fertige Lösung.

Die Packs, die Sie der Konfiguration im vorherigen Abschnitt hinzugefügt haben, sind sofort einsatzbereit. In diesem Abschnitt fügen wir der Liste ein weiteres Paket hinzu, das die Abfrage und Anweisungen enthält, die für die Überwachung der Dateiintegrität verwendet werden. In dieser Übung rufen wir die Datei "+ fim.conf +" auf.

Erstellen Sie diese Datei und öffnen Sie sie in Ihrem Editor:

sudo nano /usr/share/osquery/packs/fim.conf

Wir erstellen ein Paket, das alle 300 Sekunden nach Dateiereignissen in den Verzeichnissen "+ / home", "+ / etc" und "+ / tmp" sucht. Das vollständige Setup für die Packdatei ist in der folgenden Dateiliste aufgeführt. Kopieren Sie es in die Datei.

/usr/share/osquery/packs/fim.conf{
 "queries": {
   "file_events": {
     "query": "select * from file_events;",
     "removed": false,
     "interval": 300
   }
 },
 "file_paths": {
   "homes": [
     "/root/.ssh/%%",
     "/home/%/.ssh/%%"
   ],
     "etc": [
     "/etc/%%"
   ],
     "home": [
     "/home/%%"
   ],
     "tmp": [
     "/tmp/%%"
   ]
 }
}

Speichern und schließen Sie die Datei.

Um die neue Datei und ihre Regeln für osquery verfügbar zu machen, referenzieren Sie sie in der Packliste am Ende von "+ /etc/osquery/osquery.conf +". Öffnen Sie die Datei zum Bearbeiten:

sudo nano /etc/osquery/osquery.conf

Ändern Sie dann den Abschnitt packs, um die neue Datei einzuschließen:

/etc/osquery/osquery.conf
...

"packs": {

    "osquery-monitoring": "/usr/share/osquery/packs/osquery-monitoring.conf",
    "incident-response": "/usr/share/osquery/packs/incident-response.conf",
    "it-compliance": "/usr/share/osquery/packs/it-compliance.conf",
    "vuln-management": "/usr/share/osquery/packs/vuln-management.conf"
 }

Speichern und schließen Sie die Datei. Und um sicherzugehen, dass Sie keinen Fehler in der Datei gemacht haben, überprüfen Sie sie erneut:

sudo osqueryctl config-check

Beginnen wir nun mit der Verwendung von "+ osqueryi +", um das System abzufragen.

Schritt 5 - Verwenden von osqueryi zur Durchführung von Ad-hoc-Sicherheitsprüfungen

Es gibt viele Orte, an denen die Suche nützlich ist. In diesem Abschnitt führen Sie verschiedene Sicherheitsüberprüfungen Ihres Systems mit der interaktiven Shell "+ osqueryi " durch. Beachten Sie, dass der osquery-Daemon zu diesem Zeitpunkt noch nicht gestartet wurde. Und das ist das Schöne an osquery: Sie können Abfragen mit " osqueryi +" ausführen, auch wenn der Dämon nicht aktiv ist, und dabei die Konfigurationsdatei verwenden, die wir zur Konfiguration der Umgebung erstellt haben.

Um "+ osquery +" mit einer Konfigurationsdatei zu starten, geben Sie Folgendes ein:

sudo osqueryi --config_path /etc/osquery/osquery.conf --verbose

Beginnen wir mit den grundlegenden Sicherheitsüberprüfungen und arbeiten uns von dort nach oben vor. Zum Beispiel, wer außer Ihnen ist jetzt im System angemeldet? Finden Sie es mit dieser Abfrage heraus:

select * from logged_in_users ;

Die Ausgabe sollte folgendermaßen aussehen:

Output+-----------+----------+-------+------------------+------------+------+
| type      | user     | tty   | host             | time       | pid  |
+-----------+----------+-------+------------------+------------+------+
| boot_time | reboot   | ~     | 4.4.0-57-generic | 1483580419 | 0    |
| runlevel  | runlevel | ~     | 4.4.0-57-generic | 1483580426 | 53   |
| login     | LOGIN    | ttyS0 |                  | 1483580429 | 1546 |
| login     | LOGIN    | tty1  |                  | 1483580429 | 1549 |
| user      |      | pts/0 |       | 1483580584 | 1752 |
| user      |     | pts/1 |       | 1483580770 | 4057 |
+-----------+----------+-------+------------------+------------+------+

In dieser Ausgabe sind zwei echte Benutzerkonten am Computer angemeldet, und beide haben dieselbe IP-Adresse. Diese IP-Adresse sollte eine bekannte IP-Adresse sein. Wenn dies nicht der Fall ist, sollten Sie untersuchen, woher diese Anmeldung stammt.

In der vorherigen Abfrage sehen Sie, wer sich jetzt angemeldet hat, aber was ist mit früheren Anmeldungen? Sie können dies herausfinden, indem Sie die * letzte * Tabelle wie folgt abfragen:

select * from last ;

Die Ausgabe zeigte nichts Ungewöhnliches an, sodass sich in letzter Zeit keine andere Person bei der Maschine angemeldet hat:

Output+----------+-------+------+------+------------+------------------+
| username | tty   | pid  | type | time       | host             |
+----------+-------+------+------+------------+------------------+
| reboot   | ~     | 0    | 2    | 1483580419 | 4.4.0-57-generic |
| runlevel | ~     | 53   | 1    | 1483580426 | 4.4.0-57-generic |
|          | ttyS0 | 1546 | 5    | 1483580429 |                  |
| LOGIN    | ttyS0 | 1546 | 6    | 1483580429 |                  |
|          | tty1  | 1549 | 5    | 1483580429 |                  |
| LOGIN    | tty1  | 1549 | 6    | 1483580429 |                  |
|      | pts/0 | 1752 | 7    | 1483580584 |       |
|     | pts/1 | 4057 | 7    | 1483580770 |       |
+----------+-------+------+------+------------+------------------+

Ist die Firewall konfiguriert und aktiviert? Läuft die Firewall noch? Führen Sie im Zweifelsfall diese Abfrage aus, um Folgendes herauszufinden:

select * from iptables ;

Wenn keine Ausgabe erfolgt, wurde die IPTables-Firewall nicht konfiguriert. Für einen mit dem Internet verbundenen Server ist dies keine gute Sache. Konfigurieren Sie die Firewall daher besser.

Sie können den vorherigen Befehl ausführen, der so geändert wurde, dass er nach bestimmten Spalten filtert:

select chain, policy, src_ip, dst_ip from iptables ;

Diese Abfrage sollte eine Ausgabe wie die folgende ergeben. Suchen Sie nach ungewöhnlichen Quell- und Ziel-IP-Adressen, die Sie nicht konfiguriert haben:

Output+---------+--------+---------+-----------+
| chain   | policy | src_ip  | dst_ip    |
+---------+--------+---------+-----------+
| INPUT   | ACCEPT | 0.0.0.0 | 0.0.0.0   |
| INPUT   | ACCEPT | 0.0.0.0 | 127.0.0.0 |
| INPUT   | ACCEPT | 0.0.0.0 | 0.0.0.0   |
| INPUT   | ACCEPT | 0.0.0.0 | 0.0.0.0   |
| INPUT   | ACCEPT | 0.0.0.0 | 0.0.0.0   |
| INPUT   | ACCEPT | 0.0.0.0 | 0.0.0.0   |
| INPUT   | ACCEPT | 0.0.0.0 | 0.0.0.0   |
| INPUT   | ACCEPT | 0.0.0.0 | 0.0.0.0   |
| INPUT   | ACCEPT | 0.0.0.0 | 0.0.0.0   |
| INPUT   | ACCEPT | 0.0.0.0 | 0.0.0.0   |
| FORWARD | ACCEPT | 0.0.0.0 | 0.0.0.0   |
| FORWARD | ACCEPT | 0.0.0.0 | 0.0.0.0   |
| OUTPUT  | ACCEPT | 0.0.0.0 | 0.0.0.0   |
| OUTPUT  | ACCEPT | 0.0.0.0 | 0.0.0.0   |
+---------+--------+---------+-----------+

Welche Art von Jobs sind in crontab geplant? Hast du sie eingeplant? Mithilfe dieser Abfrage können Sie nach Malware suchen, deren Ausführung in bestimmten Intervallen geplant ist:

select command, path from crontab ;

Und die Ausgabe sollte diese Form annehmen. Jeder Befehl, der verdächtig aussieht, erfordert weitere Nachforschungen:

Output+----------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+
| command                                                                                                                                | path                           |
+----------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+
| root cd / && run-parts --report /etc/cron.hourly                                                                                       | /etc/crontab                   |
| root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily )                                                       | /etc/crontab                   |
| root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.weekly )                                                      | /etc/crontab                   |
| root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.monthly )                                                     | /etc/crontab                   |
| root if [ -x /usr/share/mdadm/checkarray ] && [ $(date +\%d) -le 7 ]; then /usr/share/mdadm/checkarray --cron --all --idle --quiet; fi | /etc/cron.d/mdadm              |
| root test -x /etc/cron.daily/popularity-contest && /etc/cron.daily/popularity-contest --crond                                          | /etc/cron.d/popularity-contest |
+----------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+

Befinden sich Dateien auf dem System, die setuid-fähig sind? Auf jedem Ubuntu 16.04-Server gibt es einige, aber welche sind es und welche sollten nicht auf dem System sein? Antworten auf diese Fragen helfen Ihnen dabei, Binärdateien mit Hintertüren zu erkennen. Führen Sie diese Abfrage regelmäßig aus und vergleichen Sie ihre Ergebnisse mit älteren Ergebnissen, damit Sie eventuelle Ergänzungen im Auge behalten können. Diese Abfrage lautet:

select * from suid_bin ;

Eine Teilausgabe dieser Abfrage könnte folgendermaßen aussehen:

Output+-------------------------------+----------+-----------+-------------+
| path                          | username | groupname | permissions |
+-------------------------------+----------+-----------+-------------+
| /bin/ping6                    | root     | root      | S           |
| /bin/su                       | root     | root      | S           |
| /bin/mount                    | root     | root      | S           |
| /bin/umount                   | root     | root      | S           |
| /bin/fusermount               | root     | root      | S           |
| /bin/ntfs-3g                  | root     | root      | S           |
| /bin/ping                     | root     | root      | S           |
| /sbin/mount.ntfs-3g           | root     | root      | S           |
| /sbin/mount.ntfs              | root     | root      | S           |
| /sbin/unix_chkpwd             | root     | shadow    | G           |
| /sbin/pam_extrausers_chkpwd   | root     | shadow    | G           |
| /usr/bin/chage                | root     | shadow    | G           |
| /usr/bin/locate               | root     | mlocate   | G           |
| /usr/bin/chfn                 | root     | root      | S           |
| /usr/bin/chsh                 | root     | root      | S           |
| /usr/bin/newuidmap            | root     | root      | S           |
| /usr/bin/write                | root     | tty       | G           |
| /usr/bin/mlocate              | root     | mlocate   | G           |
| /usr/bin/at                   | daemon   | daemon    | SG          |
| /usr/bin/sg                   | root     | root      | S           |

Führen Sie die folgende Abfrage aus, um eine Liste der geladenen Kernelmodule anzuzeigen:

select name, used_by, status from kernel_modules where status="Live" ;

Dies ist eine weitere Abfrage, die Sie regelmäßig ausführen und ihre Ausgabe mit älteren Ergebnissen vergleichen möchten, um festzustellen, ob sich etwas geändert hat.

Eine weitere Methode zum Auffinden von Hintertüren auf dem Server besteht darin, eine Abfrage auszuführen, in der alle empfangsbereiten Ports aufgelistet sind. Führen Sie dazu diese Abfrage aus:

select * from listening_ports ;

Auf einem neuen Server, auf dem nur SSH auf Port "+ 22 +" ausgeführt wird, sieht die Ausgabe folgendermaßen aus:

Output+-------+------+----------+--------+---------+
| pid   | port | protocol | family | address |
+-------+------+----------+--------+---------+
| 1686  | 22   | 6        | 2      | 0.0.0.0 |
| 1686  | 22   | 6        | 10     | ::      |
| 25356 | 0    | 0        | 0      |         |
+-------+------+----------+--------+---------+

Wenn die Ausgabe auf Ihrem Server nur Ports enthält, von denen Sie wissen, dass sie vom Server abgehört werden sollen, müssen Sie sich keine Sorgen machen. Wenn jedoch andere Ports offen wären, möchten Sie untersuchen, um welche Ports es sich handelt.

Führen Sie die folgende Abfrage aus, um die Dateiaktivität auf dem Server anzuzeigen:

select target_path, action, uid from file_events ;

In der Ausgabe werden alle aktuellen Dateiaktivitäten auf dem Server zusammen mit der für die Aktivität verantwortlichen Benutzer-ID angezeigt.

Output+---------------------------+---------+------+
| target_path               | action  | uid  |
+---------------------------+---------+------+
| /home/sammy/..bashrc.swp  | CREATED | 1000 |
| /home/sammy/..bashrc.swp  | UPDATED | 1000 |
| /home/sammy/..bashrc.swp  | UPDATED | 1000 |
| /home/sammy/.bashrc       | UPDATED | 1000 |
| /home/sammy/..bashrc.swp  | DELETED | 1000 |
| /home/sammy/..bashrc.swp  | CREATED | 1000 |
| /home/sammy/..bashrc.swp  | UPDATED | 1000 |
| /home/sammy/..bashrc.swp  | UPDATED | 1000 |
| /home/sammy/.bashrc       | UPDATED | 1000 |
| /home/sammy/.bashrc       | UPDATED | 1000 |
| /home/sammy/.bashrc       | UPDATED | 1000 |
| /home/sammy/..bashrc.swp  | DELETED |      |
| /etc/test_file.txt        | DELETED |      |
| /home/sammy/.bash_history | UPDATED | 1000 |
| /home/sammy/.bash_history | UPDATED | 1000 |
| /etc/secret_file.md       | CREATED | 0    |
| /etc/secret_file.md       | UPDATED | 0    |
| /etc/secret_file.md       | UPDATED | 0    |
+---------------------------+---------+------+

Es gibt viele ähnliche Abfragen, die Sie auf Ihrem Server ausführen können, um einen Überblick über mögliche Sicherheitsprobleme zu erhalten.

Wenn Sie sich bezüglich des Schemas einer Tabelle nicht sicher sind, verwenden Sie den folgenden Befehl, um dies herauszufinden:

.schema

Und Sie können die verfügbaren Tabellen auflisten mit:

.tables

Es gibt viele weitere Beispiele in den Paketen, die mit osquery ausgeliefert werden, und viele sind so konzipiert, dass sie regelmäßig von "+ osqueryd +" ausgeführt werden. Im nächsten Abschnitt erfahren Sie, wie Sie den Daemon starten, um diese Abfragen auszuführen.

Schritt 6 - Ausführen von osqueryd

+ osqueryd +, der Daemon, erlaubt es osquery, Abfragen in festgelegten Intervallen auszuführen. Zu diesen Abfragen gehören die Abfragen, die Sie in Schritt 4 konfiguriert haben, die Abfragen in den Paketen, die wir in diesem Schritt angegeben haben, und die Abfragen in dem FIM-Paket, das wir in Schritt 5 konfiguriert haben. Wenn Sie sie noch nicht studiert haben, ist jetzt ein guter Zeitpunkt, sich den Inhalt von "+ / usr / share / osquery / packs +" anzusehen.

Die von "+ osqueryd " generierten Ergebnisse werden in eine Datei mit dem Namen " osqueryd.results.log " im Verzeichnis " / var / log / osquery +" geschrieben. Standardmäßig ist diese Datei nicht vorhanden. Es wird erst erstellt, wenn der Dämon gestartet wird und Ergebnisse generiert.

Sie können + osqueryd + entweder mit + systemctl + oder + osqueryctl + starten. Beide erreichen dasselbe, sodass es keine Rolle spielt, welchen Sie verwenden. + osqueryd + prüft beim Start, ob eine Konfigurationsdatei vorhanden ist, und benachrichtigt Sie, wenn keine gefunden wird. Es wird weiterhin ohne Konfigurationsdatei ausgeführt, obwohl es nichts Nützliches bringt.

Da Sie jedoch bereits eine Konfigurationsdatei eingerichtet haben, müssen Sie hier nur den Dämon starten:

sudo systemctl start osqueryd

Oder Sie können Folgendes eingeben:

sudo osqueryctl start

Wenige Minuten nach dem Start des Daemons sollte die Größe von "+ / var / log / osquery / osqueryd.results.log +" zunehmen. Sie können dies sehen, indem Sie den folgenden Befehl eingeben und wiederholen:

ls -lh /var/log/osquery/osqueryd.results.log

Die zunehmende Größe der Datei zeigt an, dass die Ergebnisse der geplanten Abfragen auf die Festplatte geschrieben werden. Leider verfügt osquery nicht über eine Warnfunktion wie OSSEC, sodass Sie die Ergebnisse geplanter Abfragen nur anzeigen können, wenn Sie die Ergebnisdatei anzeigen. Sie können dies mit dem Befehl + tail + tun, der die letzten 10 Zeilen dieser Datei kontinuierlich auf Ihren Bildschirm überträgt:

sudo tail -f /var/log/osquery/osqueryd.results.log

Drücken Sie die Tastenkombination "+ STRG + C +", um das Protokoll zu beenden.

Längerfristig möchten Sie das Abfrageergebnisprotokoll an eine externe Analyseplattform senden, mit der Sie arbeiten können. Zu den möglichen Open Source-Optionen gehören Doorman, Zentral und https://www.elastic.co/products/ elasticsearch [ElasticSearch].

Fazit

osquery ist ein leistungsstarkes Tool, mit dem Sie einmalige und geplante Abfragen mit einer vertrauten SQL-Syntax ausführen können. + osqueryi + ist die osquery-Komponente zum Schreiben einmaliger Abfragen, während + osqueryd + zum Planen von Abfragen dient. Um die Ergebnisse geplanter Abfragen zu verstehen, müssen Sie sie an eine externe Protokollanalyseplattform senden. Weitere Informationen zu osquery finden Sie unter https://osquery.io [https://osquery.io/].

Related