* Anweisungen befolgen, Nachrichten lesen, auf mögliche Portkonflikte prüfen und neu starten

<!-- TOC -->
- [T-Pot - Die All-in-One Multi-Honeypot-Plattform](#t-pot---die-all-in-one-multi-honeypot-plattform)
- [TL;DR](#tldr)
- [Haftungsausschluss](#haftungsausschluss)
- [Technisches Konzept](#technisches-konzept)
  - [Honeypots und Werkzeuge](#honeypots-und-werkzeuge)
  - [Technische Architektur](#technische-architektur)
  - [Dienste](#dienste)
  - [Benutzertypen](#benutzertypen)
- [Systemanforderungen](#systemanforderungen)
  - [Ausführung in einer VM](#ausführung-in-einer-vm)
  - [Ausführung auf Hardware](#ausführung-auf-hardware)
  - [Ausführung in der Cloud](#ausführung-in-der-cloud)
  - [Erforderliche Ports](#erforderliche-ports)
  - [LLM-basierte Honeypots](#llm-basierte-honeypots)
    - [Ollama](#ollama)
    - [ChatGPT](#chatgpt)
- [Systemplatzierung](#systemplatzierung)
- [Installation](#installation)
  - [Wählen Sie Ihre Distribution](#wählen-sie-ihre-distribution)
  - [Raspberry Pi 4 (8 GB) Unterstützung](#raspberry-pi-4-8-gb-unterstützung)
  - [T-Pot herunterladen und installieren](#t-pot-herunterladen-und-installieren)
  - [macOS & Windows](#macos--windows)
  - [Red Hat Enterprise Linux](#red-hat-enterprise-linux)
  - [Installationstypen](#installationstypen)
    - [Standard / Hive](#standard--hive)
    - [Verteilt](#verteilt)
  - [T-Pot deinstallieren](#t-pot-deinstallieren)
- [Erster Start](#erster-start)
  - [Standalone Erster Start](#standalone-erster-start)
  - [Verteilte Bereitstellung](#verteilte-bereitstellung)
    - [Planung und Zertifikate](#planung-und-zertifikate)
    - [Sensoren bereitstellen](#sensoren-bereitstellen)
    - [Sensoren entfernen](#sensoren-entfernen)
  - [Community-Datenübermittlung](#community-datenübermittlung)
  - [Opt-In HPFEEDS-Datenübermittlung](#opt-in-hpfeeds-datenübermittlung)
- [Remote-Zugriff und Werkzeuge](#remote-zugriff-und-werkzeuge)
  - [SSH](#ssh)
  - [T-Pot Startseite](#t-pot-startseite)
  - [Kibana Dashboard](#kibana-dashboard)
  - [Angriffskarte](#angriffskarte)
  - [Cyberchef](#cyberchef)
  - [Elasticvue](#elasticvue)
  - [Spiderfoot](#spiderfoot)
- [Konfiguration](#konfiguration)
  - [T-Pot Konfigurationsdatei](#t-pot-konfigurationsdatei)
  - [T-Pot Honeypots und Dienste anpassen](#t-pot-honeypots-und-dienste-anpassen)
- [Wartung](#wartung)
  - [Allgemeine Updates](#allgemeine-updates)
  - [Update-Skript](#update-skript)
  - [Täglicher Neustart](#täglicher-neustart)
  - [Bekannte Probleme](#bekannte-probleme)
    - [Docker-Images können nicht heruntergeladen werden](#docker-images-können-nicht-heruntergeladen-werden)
    - [T-Pot Netzwerk funktioniert nicht](#t-pot-netzwerk-funktioniert-nicht)
  - [T-Pot starten](#t-pot-starten)
  - [T-Pot stoppen](#t-pot-stoppen)
  - [T-Pot Datenordner](#t-pot-datenordner)
  - [Log-Persistenz](#log-persistenz)
  - [Factory Reset](#factory-reset)
  - [Container und Images anzeigen](#container-und-images-anzeigen)
  - [Blackhole](#blackhole)
  - [Benutzer zu Nginx hinzufügen (T-Pot WebUI)](#benutzer-zu-nginx-hinzufügen-t-pot-webui)
  - [Kibana-Objekte importieren und exportieren](#kibana-objekte-importieren-und-exportieren)
    - [Exportieren](#exportieren)
    - [Importieren](#importieren)
- [Fehlerbehebung](#fehlerbehebung)
  - [Logs](#logs)
  - [RAM und Speicher](#ram-und-speicher)
- [Kontakt](#kontakt)
  - [Probleme](#probleme)
  - [Diskussionen](#diskussionen)
- [Lizenzen](#lizenzen)
- [Danksagungen](#danksagungen)
  - [Die Entwickler und Entwicklungsgemeinschaften von](#die-entwickler-und-entwicklungsgemeinschaften-von)
  - [**Die folgenden Unternehmen und Organisationen**](#die-folgenden-unternehmen-und-organisationen)
  - [**Und natürlich ***DU*** für die Teilnahme an der Community!**](#und-natürlich-du-für-die-teilnahme-an-der-community)
- [Erfahrungsberichte](#erfahrungsberichte)
- [Vielen Dank 💖](#vielen-dank-)
<!-- TOC -->
<br><br>

# Haftungsausschluss
- Sie installieren und betreiben T-Pot in eigener Verantwortung. Wählen Sie Ihre Bereitstellung weise, da eine Systemkompromittierung nie ausgeschlossen werden kann.
- Für schnelle Hilfe recherchieren Sie in den [Issues](https://github.com/telekom-security/tpotce/issues) und [Diskussionen](https://github.com/telekom-security/tpotce/discussions).
- Die Software wird nach bestem Wissen und Gewissen entwickelt und angeboten. Als Community- und Open-Source-Projekt verwendet sie viele andere Open-Source-Software und kann Fehler und Probleme enthalten. Melden Sie verantwortungsbewusst.
- Honeypots sollten - von Natur aus - keine sensiblen Daten enthalten. Stellen Sie sicher, dass Sie keine hinzufügen.
- Standardmäßig werden Ihre Daten an [Sicherheitstacho](https://www.sicherheitstacho.eu/start/main) übermittelt. Sie können dies in der Konfiguration (`~/tpotce/docker-compose.yml`) deaktivieren, indem Sie den Abschnitt `ewsposter` [entfernen](#community-datenübermittlung). Aber in diesem Fall ist Teilen wirklich Fürsorge!
<br><br>

# Technisches Konzept
Die Hauptkomponenten von T-Pot wurden in das Docker-Image `tpotinit` verschoben, sodass T-Pot jetzt mehrere Linux-Distributionen unterstützt, sogar macOS und Windows (beide jedoch auf den Funktionsumfang von Docker Desktop beschränkt). T-Pot verwendet [docker](https://www.docker.com/) und [docker compose](https://docs.docker.com/compose/), um sein Ziel zu erreichen, so viele Honeypots und Tools wie möglich gleichzeitig auszuführen und so die Hardware des Hosts maximal auszunutzen.
<br><br>

## Honeypots und Werkzeuge
- T-Pot bietet Docker-Images für die folgenden Honeypots an:<br>
[adbhoney](https://github.com/huuck/ADBHoney),
[beelzebub](https://github.com/beelzebub-labs/beelzebub),
[ciscoasa](https://github.com/Cymmetria/ciscoasa_honeypot),
[citrixhoneypot](https://github.com/MalwareTech/CitrixHoneypot),
[conpot](http://conpot.org/),
[cowrie](https://github.com/cowrie/cowrie),
[ddospot](https://github.com/aelth/ddospot),
[dicompot](https://github.com/nsmfoo/dicompot),
[dionaea](https://github.com/DinoTools/dionaea),
[elasticpot](https://gitlab.com/bontchev/elasticpot),
[endlessh](https://github.com/skeeto/endlessh),
[galah](https://github.com/0x4D31/galah),
[go-pot](https://github.com/ryanolee/go-pot),
[glutton](https://github.com/mushorg/glutton),
[h0neytr4p](https://github.com/pbssubhash/h0neytr4p),
[hellpot](https://github.com/yunginnanet/HellPot),
[heralding](https://github.com/johnnykv/heralding),
[honeyaml](https://github.com/mmta/honeyaml),
[honeypots](https://github.com/qeeqbox/honeypots),
[honeytrap](https://github.com/armedpot/honeytrap/),
[ipphoney](https://gitlab.com/bontchev/ipphoney),
[log4pot](https://github.com/thomaspatzke/Log4Pot),
[mailoney](https://github.com/phin3has/mailoney),
[medpot](https://github.com/schmalle/medpot),
[miniprint](https://github.com/sa7mon/miniprint),
[redishoneypot](https://github.com/cypwnpwnsocute/RedisHoneyPot),
[rdphoneypot](https://gitlab.com/bontchev/rdphoneypot),
[sentrypeer](https://github.com/SentryPeer/SentryPeer),
[snare](http://mushmush.org/),
[tanner](http://mushmush.org/),
[wordpot](https://github.com/gbrindisi/wordpot)

Zusammen mit den folgenden Werkzeugen:
* [Autoheal](https://github.com/willfarrell/docker-autoheal) ein Werkzeug zum automatischen Neustarten von Containern mit fehlgeschlagenen Healthchecks.
* [Cyberchef](https://gchq.github.io/CyberChef/) eine Web-App für Verschlüsselung, Kodierung, Komprimierung und Datenanalyse.
* [Elastic Stack](https://www.elastic.co/videos) zur ansprechenden Visualisierung aller von T-Pot erfassten Ereignisse.
* [Elasticvue](https://github.com/cars10/elasticvue/) ein Web-Frontend zum Durchsuchen und Interagieren mit einem Elasticsearch-Cluster.
* [Fatt](https://github.com/0x4D31/fatt) ein auf pyshark basierendes Skript zum Extrahieren von Netzwerkmetadaten und Fingerabdrücken aus pcap-Dateien und live Netzwerkverkehr.
* [T-Pot-Attack-Map](https://github.com/telekom-security/t-pot-attack-map) eine animierte Angriffskarte für T-Pot.
* [P0f](https://lcamtuf.coredump.cx/p0f3/) ein Werkzeug für rein passives Traffic-Fingerprinting.
* [Spiderfoot](https://github.com/smicallef/spiderfoot) ein Open-Source-Intelligence-Automatisierungswerkzeug.
* [Suricata](https://suricata.io/) eine Network Security Monitoring Engine.

... um Ihnen das bestmögliche Out-of-the-Box-Erlebnis und ein einfach zu bedienendes Multi-Honeypot-System zu bieten.
<br><br>

## Technische Architektur
![Architektur](https://assets.kitploit.com/production/public/readmes/4462/3fe1e953817d210102d0a4c79a55bebd32d23014d6ddefa058719411cfc9d178.png)

Der Quellcode und die Konfigurationsdateien sind vollständig im T-Pot GitHub-Repository gespeichert. Die Docker-Images werden erstellt und für die T-Pot-Umgebung vorkonfiguriert.

Die einzelnen Dockerfiles und Konfigurationen befinden sich im [docker-Ordner](https://github.com/telekom-security/tpotce/tree/master/docker).
<br><br>

## Dienste
T-Pot bietet eine Reihe von Diensten, die grundsätzlich in fünf Gruppen unterteilt sind:
1. Systemdienste des Betriebssystems
    * SSH für sicheren Fernzugriff.
2. Elastic Stack
    * Elasticsearch zum Speichern von Ereignissen.
    * Logstash zum Aufnehmen, Empfangen und Senden von Ereignissen an Elasticsearch.
    * Kibana zur Anzeige von Ereignissen in schön gestalteten Dashboards.
3. Werkzeuge
    * NGINX bietet sicheren Fernzugriff (Reverse Proxy) auf Kibana, CyberChef, Elasticvue, GeoIP-Angriffskarte, Spiderfoot und ermöglicht es T-Pot-Sensoren, Ereignisdaten sicher an den T-Pot-Hive zu senden.
    * CyberChef eine Web-App für Verschlüsselung, Kodierung, Komprimierung und Datenanalyse.
    * Elasticvue ein Web-Frontend zum Durchsuchen und Interagieren mit einem Elasticsearch-Cluster.
    * T-Pot-Angriffskarte eine animierte Angriffskarte für T-Pot.
    * Spiderfoot ein Open-Source-Intelligence-Automatisierungswerkzeug.
4. Honeypots
    * Eine Auswahl der 23 verfügbaren Honeypots basierend auf der ausgewählten `docker-compose.yml`.
5. Network Security Monitoring (NSM)
    * Fatt ein auf pyshark basierendes Skript zum Extrahieren von Netzwerkmetadaten und Fingerabdrücken aus pcap-Dateien und live Netzwerkverkehr.
    * P0f ein Werkzeug für rein passives Traffic-Fingerprinting.
    * Suricata eine Network Security Monitoring Engine.
<br><br>

## Benutzertypen
Während der Installation und der Nutzung von T-Pot gibt es zwei verschiedene Arten von Konten, mit denen Sie arbeiten werden. Stellen Sie sicher, dass Sie die Unterschiede der verschiedenen Kontotypen kennen, da dies **bei weitem** der häufigste Grund für Authentifizierungsfehler ist.

| Dienst           | Kontotyp      | Benutzername / Gruppe | Beschreibung                                                        |
|:-----------------|:--------------|:----------------------|:--------------------------------------------------------------------|
| SSH              | OS            | `<OS_USERNAME>`      | Der Benutzer, den Sie während der Installation des Betriebssystems gewählt haben. |
| Nginx            | BasicAuth     | `<WEB_USER>`         | Der `<web_user>`, den Sie während der Installation von T-Pot gewählt haben. |
| CyberChef        | BasicAuth     | `<WEB_USER>`         | Der `<web_user>`, den Sie während der Installation von T-Pot gewählt haben. |
| Elasticvue       | BasicAuth     | `<WEB_USER>`         | Der `<web_user>`, den Sie während der Installation von T-Pot gewählt haben. |
| Geoip-Angriffskarte | BasicAuth  | `<WEB_USER>`         | Der `<web_user>`, den Sie während der Installation von T-Pot gewählt haben. |
| Spiderfoot       | BasicAuth     | `<WEB_USER>`         | Der `<web_user>`, den Sie während der Installation von T-Pot gewählt haben. |
| T-Pot            | OS            | `tpot`               | `tpot` Dieser Benutzer / diese Gruppe ist immer von den T-Pot-Diensten reserviert. |
| T-Pot-Logs       | BasicAuth     | `<LS_WEB_USER>`      | `LS_WEB_USER` werden automatisch verwaltet.                         |

<br><br>

# Systemanforderungen

Abhängig von den [unterstützten Linux-Distributions-Images](#wählen-sie-ihre-distribution), Hive/Sensor, Installation auf [echter Hardware](#ausführung-auf-hardware), in einer [virtuellen Maschine](#ausführung-in-einer-vm) oder anderen Umgebungen gibt es unterschiedliche Anforderungen an Betriebssystem, RAM, Speicher und Netzwerk für eine erfolgreiche Installation von T-Pot (Sie können jederzeit `~/tpotce/docker-compose.yml` und `~/tpotce/.env` an Ihre Bedürfnisse anpassen, um diese Anforderungen zu umgehen).
<br><br>

| T-Pot Typ | RAM  | Speicher    | Beschreibung                                                                                       |
|:----------|:-----|:------------|:---------------------------------------------------------------------------------------------------|
| Hive      | 16GB | 256GB SSD   | Als Faustregel gilt: Je mehr Honeypots, Sensoren und Daten, desto mehr RAM und Speicher werden benötigt. |
| Sensor    | 8GB  | 128GB SSD   | Da Honeypot-Logs 30 Tage lang gespeichert werden (~/tpotce/data), hängt der Speicherbedarf vom Angriffsvolumen ab. |

T-Pot benötigt ...
- eine IPv4-Adresse per DHCP oder statisch zugewiesen
- eine funktionierende, nicht-proxierte Internetverbindung
... für eine erfolgreiche Installation und den Betrieb.
<br><br>
*Wenn Sie Proxy-Unterstützung oder andere nicht standardmäßige Funktionen benötigen, sollten Sie die Dokumentation der [unterstützten Linux-Distributions-Images](#wählen-sie-ihre-distribution) und/oder die [Docker-Dokumentation](https://docs.docker.com/) lesen.*
<br><br>

## Ausführung in einer VM
Alle [unterstützten Linux-Distributions-Images](#wählen-sie-ihre-distribution) laufen in einer VM, was bedeutet, dass T-Pot problemlos funktioniert. Folgende wurden getestet / als funktionierend gemeldet:
* [UTM (Intel & Apple Silicon)](https://mac.getutm.app/)
* [VirtualBox](https://www.virtualbox.org/)
* [VMWare Fusion](https://www.vmware.com/products/desktop-hypervisor/workstation-and-fusion) und [VMWare Workstation](https://www.vmware.com/products/desktop-hypervisor/workstation-and-fusion)
* KVM wird ebenfalls als funktionierend gemeldet.

***Einige Hinweise zur Konfiguration / Einrichtung:***
- Während Intel-Versionen stabil laufen, hat die Unterstützung für Apple Silicon (arm64) bekannte Probleme, die in UTM möglicherweise erfordern, während der anfänglichen Installation des Betriebssystems die `Anzeige` auf `Nur Konsole` umzustellen und danach wieder auf `Vollgrafiken`.
- Während der Konfiguration müssen Sie möglicherweise den Promiscuous-Modus für die Netzwerkschnittstelle aktivieren, damit fatt, suricata und p0f ordnungsgemäß funktionieren.
- Wenn Sie eine WLAN-Karte als primäre Netzwerkschnittstelle für T-Pot verwenden möchten, beachten Sie bitte, dass nicht alle Netzwerkschnittstellentreiber alle drahtlosen Karten unterstützen. In VirtualBox müssen Sie z. B. das Modell *"MT SERVER"* der Netzwerkkarte auswählen.
<br><br>

## Ausführung auf Hardware
T-Pot wird nur durch die Hardwareunterstützung der [unterstützten Linux-Distributions-Images](#wählen-sie-ihre-distribution) eingeschränkt. Es wird empfohlen, die HCL (Hardware-Kompatibilitätsliste) zu überprüfen und die unterstützten Distributionen mit T-Pot zu testen, bevor Sie in dedizierte Hardware investieren.
<br><br>

## Ausführung in der Cloud
T-Pot wurde getestet und läuft bekanntermaßen auf ...
* Telekom OTC mit der Post-Install-Methode
... andere mögen funktionieren, bleiben aber ungetestet.

Einige Benutzer berichten von funktionierenden Installationen auf anderen Clouds und Hostern, z. B. Azure und GCP. Die Hardwareanforderungen können unterschiedlich sein. Wenn Sie unsicher sind, sollten Sie [Issues](https://github.com/telekom-security/tpotce/issues) und [Diskussionen](https://github.com/telekom-security/tpotce/discussions) recherchieren und einige Funktionstests durchführen. Mit T-Pot 24.04.0 und später haben wir sichergestellt, dass Einstellungen entfernt wurden, die bekanntermaßen Cloud-basierte Installationen beeinträchtigen.
<br><br>

## Erforderliche Ports
Neben den Ports, die allgemein vom Betriebssystem benötigt werden, z. B. für die DHCP-Lease, DNS usw., benötigt T-Pot die folgenden Ports für eingehende/ausgehende Verbindungen. Lesen Sie die [T-Pot-Architektur](#technisches-konzept) für eine visuelle Darstellung. Einige Ports werden als Duplikate angezeigt, was in Ordnung ist, da sie in verschiedenen Editionen verwendet werden.| Port                                                                                                                                  | Protokoll | Richtung | Beschreibung                                                                                         |
|:--------------------------------------------------------------------------------------------------------------------------------------|:----------|:---------|:-----------------------------------------------------------------------------------------------------|
| 80, 443                                                                                                                               | tcp       | ausgehend | T-Pot-Management: Installation, Updates, Logs (z.B. OS, GitHub, DockerHub, Sicherheitstacho, usw.)  |
| 11434                                                                                                                                 | tcp       | ausgehend | LLM-basierte Honeypots: Zugriff auf Ihre Ollama-Installation                                         |
| 64294                                                                                                                                 | tcp       | eingehend | T-Pot-Management: Sensordatenübertragung an die Hive (über NGINX-Reverse-Proxy) an 127.0.0.1:64305  |
| 64295                                                                                                                                 | tcp       | eingehend | T-Pot-Management: Zugriff auf SSH                                                                   |
| 64297                                                                                                                                 | tcp       | eingehend | T-Pot-Management: Zugriff auf NGINX-Reverse-Proxy                                                   |
| 5555                                                                                                                                  | tcp       | eingehend | Honeypot: ADBHoney                                                                                  |
| 22                                                                                                                                    | tcp       | eingehend | Honeypot: Beelzebub (LLM erforderlich)                                                              |
| 5000                                                                                                                                  | udp       | eingehend | Honeypot: CiscoASA                                                                                  |
| 8443                                                                                                                                  | tcp       | eingehend | Honeypot: CiscoASA                                                                                  |
| 443                                                                                                                                   | tcp       | eingehend | Honeypot: CitrixHoneypot                                                                             |
| 80, 102, 502, 1025, 2404, 10001, 44818, 47808, 50100                                                                                 | tcp       | eingehend | Honeypot: Conpot                                                                                    |
| 161, 623                                                                                                                              | udp       | eingehend | Honeypot: Conpot                                                                                    |
| 22, 23                                                                                                                                | tcp       | eingehend | Honeypot: Cowrie                                                                                    |
| 19, 53, 123, 1900                                                                                                                     | udp       | eingehend | Honeypot: Ddospot                                                                                   |
| 11112                                                                                                                                 | tcp       | eingehend | Honeypot: Dicompot                                                                                  |
| 21, 42, 135, 443, 445, 1433, 1723, 1883, 3306, 8081                                                                                  | tcp       | eingehend | Honeypot: Dionaea                                                                                   |
| 69                                                                                                                                    | udp       | eingehend | Honeypot: Dionaea                                                                                   |
| 9200                                                                                                                                  | tcp       | eingehend | Honeypot: Elasticpot                                                                                |
| 22                                                                                                                                    | tcp       | eingehend | Honeypot: Endlessh                                                                                  |
| 80, 443, 8080, 8443                                                                                                                   | tcp       | eingehend | Honeypot: Galah (LLM erforderlich)                                                                  |
| 8080                                                                                                                                  | tcp       | eingehend | Honeypot: Go-pot                                                                                    |
| 80, 443                                                                                                                               | tcp       | eingehend | Honeypot: H0neytr4p                                                                                 |
| 21, 22, 23, 25, 80, 110, 143, 443, 993, 995, 1080, 5432, 5900                                                                        | tcp       | eingehend | Honeypot: Heralding                                                                                 |
| 3000                                                                                                                                  | tcp       | eingehend | Honeypot: Honeyaml                                                                                  |
| 21, 22, 23, 25, 80, 110, 143, 389, 443, 445, 631, 1080, 1433, 1521, 3306, 3389, 5060, 5432, 5900, 6379, 6667, 8080, 9100, 9200, 11211 | tcp       | eingehend | Honeypot: qHoneypots                                                                                |
| 53, 123, 161, 5060                                                                                                                    | udp       | eingehend | Honeypot: qHoneypots                                                                                |
| 631                                                                                                                                   | tcp       | eingehend | Honeypot: IPPHoney                                                                                  |
| 80, 443, 8080, 9200, 25565                                                                                                            | tcp       | eingehend | Honeypot: Log4Pot                                                                                   |
| 25                                                                                                                                    | tcp       | eingehend | Honeypot: Mailoney                                                                                  |
| 2575                                                                                                                                  | tcp       | eingehend | Honeypot: Medpot                                                                                    |
| 9100                                                                                                                                  | tcp       | eingehend | Honeypot: Miniprint                                                                                 |
| 6379                                                                                                                                  | tcp       | eingehend | Honeypot: Redishoneypot                                                                             |
| 3389                                                                                                                                  | tcp       | eingehend | Honeypot: RDPHoneypot                                                                               |
| 5060                                                                                                                                  | tcp/udp   | eingehend | Honeypot: SentryPeer                                                                                |
| 80                                                                                                                                    | tcp       | eingehend | Honeypot: Snare (Tanner)                                                                             |
| 8090                                                                                                                                  | tcp       | eingehend | Honeypot: Wordpot                                                                                   |

Die Verfügbarkeit von Ports und SaaS-Diensten kann je nach geografischem Standort variieren.

Bei einigen Honeypots sind für die volle Funktionalität (z.B. Cowrie oder Log4Pot) auch ausgehende Verbindungen erforderlich, um die Malware des Angreifers herunterzuladen. Weitere Informationen finden Sie in der Dokumentation des jeweiligen Honeypots, indem Sie den [Links](#technical-concept) zu deren Repositorys folgen.

## LLM-basierte Honeypots
Wir glauben, dass LLM-basierte Honeypots den **Beginn** einer grundlegenden Veränderung im Bereich der Täuschung / Honeypots markieren. Mit der Veröffentlichung von **T-Pot 24.04.1** wurden daher zwei LLM-basierte Honeypots, **Beelzebub** und **Galah**, eingeführt. Diese Honeypots erfordern eine Installation von **Ollama**, die in der [T-Pot-Konfigurationsdatei](#t-pot-config-file) konfiguriert werden muss. Sie können die Einstellungen in dieser Datei auch für die **ChatGPT**-Unterstützung anpassen; beachten Sie jedoch, dass dazu auch Änderungen in der Docker-Compose-Datei (`~/tpotce/compose/llm.yml`) erforderlich sind, um diese Anpassungen zu berücksichtigen.<br><br>
Folgen Sie den Links im Abschnitt [Honeypots und Tools](#honeypots-and-tools), um mehr über **Beelzebub** und **Galah** zu erfahren.

### Ollama
🚨 **Die Nutzung auf CPU-Basis wird nicht empfohlen**, nicht einmal zu Testzwecken.<br><br>
Informationen zur Einrichtung und Ausführung von **Ollama** finden Sie im [Ollama GitHub-Repository](https://github.com/ollama/ollama). Für den Einstieg oder zu Testzwecken können Sie mit einer **Nvidia RTX 4060 Ti 16 GB** oder einem gleichwertigen Modell (AMDs ROCm wird ebenfalls von Ollama unterstützt) Ergebnisse erzielen, z. B. mit Modellen wie **openchat** und **Llama3**. Als allgemeine Regel gilt bei LLM-basierten Systemen: Je besser und mehr Hardware Sie verwenden, desto schneller und genauer werden die Ergebnisse sein, insbesondere wenn Aufgaben auf mehrere GPUs und größere Modelle ausgelagert werden.

### ChatGPT
Die ChatGPT-Unterstützung für diese Honeypots wird in Bezug auf T-Pot ungetestet bleiben.
<br><br>

# Systemplatzierung
Es wird empfohlen, sich mit der Funktionsweise von T-Pot und den Honeypots vertraut zu machen, bevor Sie diese dem Internet aussetzen. Für einen Schnellstart führen Sie eine T-Pot-Installation in einer virtuellen Maschine durch.
<br><br>
Sobald Sie verstanden haben, wie die Dinge funktionieren, sollten Sie ein Netzwerk wählen, in dem Sie Eindringlinge vermuten (z. B. das Internet). Andernfalls wird T-Pot höchstwahrscheinlich keine Angriffe erfassen (es sei denn, Sie möchten einen Punkt beweisen)! Für den Anfang empfiehlt es sich, T-Pot in einer ungefilterten Zone zu platzieren, in der der gesamte TCP- und UDP-Verkehr an die Netzwerkschnittstelle von T-Pot weitergeleitet wird. Um das Abtasten der T-Pot-Verwaltungsports zu vermeiden, sollten Sie T-Pot hinter einer Firewall platzieren und den gesamten TCP/UDP-Verkehr im Portbereich 1-64000 an T-Pot weiterleiten, während Sie den Zugriff auf Ports > 64000 nur von vertrauenswürdigen IPs aus erlauben und/oder nur die für Ihren Anwendungsfall relevanten [Ports](#required-ports) freigeben. Wenn Sie Malware-Verkehr auf unbekannten Ports erfassen möchten, sollten Sie die weitergeleiteten Ports nicht einschränken, da glutton und honeytrap dynamisch jeden TCP-Port binden, der nicht von anderen Honeypot-Daemons belegt ist, und Ihnen so eine bessere Repräsentation der Risiken bieten, denen Ihr Setup ausgesetzt ist.
<br><br>

# Installation
[Laden Sie](#choose-your-distro) eines der [unterstützten Linux-Distro-Images](#choose-your-distro) herunter, folgen Sie der [TL;DR](#tldr)-Anleitung oder `git clone` das T-Pot-Repository und führen Sie das Installationsprogramm `~/tpotce/install.sh` aus. Die Ausführung von T-Pot auf einem laufenden und unterstützten Linux-System ist möglich, dennoch wird eine saubere Installation empfohlen, um Portkonflikte mit laufenden Diensten zu vermeiden. Das T-Pot-Installationsprogramm benötigt direkten Internetzugang, wie [hier](#required-ports) beschrieben.
<br><br>

## Wählen Sie Ihre Distribution
**Schritte:**

1. Laden Sie eine unterstützte Linux-Distribution aus der Liste unten herunter. (HINWEIS: Red Hat Enterprise Linux >= 8 wird unterstützt, ist aber aufgrund seines abonnementbasierten Modells in der nachfolgenden Liste nicht aufgeführt. Weitere Informationen finden Sie unter [Red Hat Enterprise Linux](#red-hat-enterprise-linux)).
2. Wählen Sie während der Installation eine **minimale**, **Netinstall**- oder **Server**-Version, die nur die wichtigsten Pakete installiert.
3. **Installieren Sie niemals** eine grafische Desktop-Umgebung wie Gnome oder KDE. T-Pot wird damit aufgrund von Portkonflikten nicht funktionieren.
4. Stellen Sie sicher, dass Sie SSH installieren, damit Sie eine Remote-Verbindung zum Rechner herstellen können.

| Name der Distribution                                                                  | x64                                                                                                                                   | arm64                                                                                                                                   |
|:---------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------|
| [Alma Linux OS 9.x Minimal ISO](https://almalinux.org)                                    | [download](https://repo.almalinux.org/almalinux/9/isos/x86_64/AlmaLinux-9.8-x86_64-minimal.iso)                                        | [download](https://repo.almalinux.org/almalinux/9/isos/aarch64/AlmaLinux-9.8-aarch64-minimal.iso)                                        |
| [Debian 13 Network Install](https://www.debian.org/CD/netinst/index.en.html)           | [download](https://cdimage.debian.org/debian-cd/current/amd64/iso-cd/debian-13.5.0-amd64-netinst.iso)                                 | [download](https://cdimage.debian.org/debian-cd/current/arm64/iso-cd/debian-13.5.0-arm64-netinst.iso)                                   |
| [Fedora Server 42 Network Install](https://fedoraproject.org/server/download)          | [download](https://download.fedoraproject.org/pub/fedora/linux/releases/42/Server/x86_64/iso/Fedora-Server-netinst-x86_64-42-1.1.iso) | [download](https://download.fedoraproject.org/pub/fedora/linux/releases/42/Server/aarch64/iso/Fedora-Server-netinst-aarch64-42-1.1.iso) |
| [OpenSuse Tumbleweed Network Image](https://get.opensuse.org/tumbleweed/#download)     | [download](https://download.opensuse.org/tumbleweed/iso/openSUSE-Tumbleweed-NET-x86_64-Current.iso)                                   | [download](https://download.opensuse.org/ports/aarch64/tumbleweed/iso/openSUSE-Tumbleweed-NET-aarch64-Current.iso)                      |
| [Rocky Linux OS 9.x Minimal ISO](https://rockylinux.org/download)                         | [download](https://download.rockylinux.org/pub/rocky/9/isos/x86_64/Rocky-9.8-x86_64-minimal.iso)                                      | [download](https://download.rockylinux.org/pub/rocky/9/isos/aarch64/Rocky-9.8-aarch64-minimal.iso)                                      |
| [Ubuntu 24.04.x Live Server](https://ubuntu.com/download/server)                       | [download](https://releases.ubuntu.com/24.04/ubuntu-24.04.3-live-server-amd64.iso)                                                    | [download](https://cdimage.ubuntu.com/releases/24.04/release/ubuntu-24.04.3-live-server-arm64.iso)                                      |

<br>

## Raspberry Pi 4 (8 GB) Support
| Name der Distribution                                                      | arm64                                                                                                                                               |
|:---------------------------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------|
| [Raspberry Pi OS (**64Bit, Lite**)](https://www.raspberrypi.com)           | [download](https://downloads.raspberrypi.com/raspios_lite_arm64/images/raspios_lite_arm64-2024-03-15/2024-03-15-raspios-bookworm-arm64-lite.img.xz) |

<br><br> 
## T-Pot herunterladen und installieren
1. Klonen Sie das GitHub-Repository: `$ git clone https://github.com/telekom-security/tpotce` oder folgen Sie der [TL;DR](#tldr)-Anleitung und überspringen Sie diesen Abschnitt.
2. Wechseln Sie in den Ordner **tpotce/**: `$ cd tpotce`
3. Führen Sie das Installationsprogramm als Nicht-Root-Benutzer aus: `$ ./install.sh`:
   * ⚠️ ***Abhängig von Ihrer gewählten Linux-Distribution wird das Installationsprogramm:***
     * Den SSH-Port auf `tcp/64295` ändern
     * Den DNS-Stub-Listener deaktivieren, um Portkonflikte mit Honeypots zu vermeiden
     * SELinux in den Überwachungsmodus setzen
     * Das Firewall-Ziel für die öffentliche Zone auf ACCEPT setzen
     * Das Docker-Repository hinzufügen und Docker installieren
     * Empfohlene Pakete installieren
     * Pakete entfernen, die bekanntermaßen Probleme verursachen
     * Den aktuellen Benutzer zur Docker-Gruppe hinzufügen (Docker-Interaktion ohne `sudo` ermöglichen)
     * Aliase `dps`, `dpsw` und `dim` für formatierte Container- und Image-Übersichten hinzufügen
     * Aliase `la`, `ll` und `ls` hinzufügen (für `exa`, einen verbesserten `ls`-Befehl)
     * Alias `mi` hinzufügen (für `micro`, eine großartige Alternative zu `vi` und/oder `nano`)
     * Offene Ports auf dem Host anzeigen (mit den [erforderlichen](https://github.com/telekom-security/tpotce#required-ports) T-Pot-Ports vergleichen)
     * `tpot.service` zu `/etc/systemd/system` hinzufügen und aktivieren, damit T-Pot automatisch starten und stoppen kann
4. Folgen Sie den Anweisungen des Installationsprogramms; Sie müssen mindestens einmal Ihr Benutzerpasswort (`sudo` oder `root`) eingeben
5. Überprüfen Sie die Installationsmeldungen auf Fehler und offene Ports, die Portkonflikte verursachen könnten
6. Starten Sie neu: `$ sudo reboot`
<br><br>## macOS und Windows
Manchmal ist es einfach schön, eine T-Pot-Instanz unter macOS oder Windows hochfahren zu können, z. B. für Entwicklung, Tests oder einfach aus Spaß. Da Docker Desktop recht eingeschränkt ist, werden nicht alle Honeypot-Typen oder T-Pot-Funktionen unterstützt. Denken Sie auch daran, dass die macOS- und Windows-Firewall standardmäßig den Zugriff von außen blockieren, sodass Tests auf den Host beschränkt sind. Für die Produktion wird empfohlen, T-Pot unter [Linux](#choose-your-distro) auszuführen.<br>
Um alles zum Laufen zu bringen, folgen Sie einfach diesen Schritten:
1. Installieren Sie Docker Desktop für [macOS](https://docs.docker.com/desktop/setup/install/mac-install/) oder [Windows](https://docs.docker.com/desktop/setup/install/windows-install/).
2. Klonen Sie das GitHub-Repository: `git clone https://github.com/telekom-security/tpotce` (stellen Sie unter Windows sicher, dass der Code mit `LF` statt `CRLF` ausgecheckt wird!)
3. Wechseln Sie zu: `cd ~/tpotce`
4. Kopieren Sie `cp compose/mac_win.yml ./docker-compose.yml`
5. Erstellen Sie einen `WEB_USER`, indem Sie `~/tpotce/genuser.sh` (macOS) oder `~/tpotce/genuserwin.ps1` (Windows) ausführen
6. Passen Sie die `.env`-Datei an, indem Sie `TPOT_OSTYPE=linux` entweder auf `mac` oder `win` ändern:   ```
   # OSType (linux, mac, win)
   #  Most docker features are available on linux
   TPOT_OSTYPE=mac

Die T-Pot-Konfigurationsdatei (`.env`) ermöglicht es, die SSL-Überprüfung für Logstash-Verbindungen von **Sensor** zum **Hive** zu deaktivieren, indem `LS_SSL_VERIFICATION=none` gesetzt wird. Aus Sicherheitsgründen wird dies nur für Labor- oder Testumgebungen empfohlen.<br><br>
Wenn du dich entscheidest, ein gültiges Zertifikat für den **Hive** zu verwenden, das von einer CA signiert wurde (z.B. Let's Encrypt), sollte Logstash und damit der **Sensor** keine Probleme haben, sich zu verbinden und seine Logs an den **Hive** zu übertragen.

### Bereitstellung von Sensoren
Sobald du den **Sensor** wie vom Installationsprogramm angewiesen neu gestartet hast, kannst du mit der verteilten Bereitstellung fortfahren, indem du dich beim **Hive** anmeldest und in das Verzeichnis `cd ~/tpotce` wechselst. Stelle sicher, dass du die [Planung und Zertifikate](#planning-and-certificates) verstanden hast, bevor du mit der eigentlichen Bereitstellung fortfährst.

Falls du noch nicht geschehen, generiere einen SSH-Schlüssel, um dich sicher beim **Sensor** anzumelden und damit `Ansible` ein Playbook auf dem Sensor ausführen kann:
1. Führe `ssh-keygen` aus, befolge die Anweisungen und lasse die Passphrase leer:   ```
   Generating public/private rsa key pair.
   Enter file in which to save the key (/home/<your_user>/.ssh/id_rsa):
   Enter passphrase (empty for no passphrase):
   Enter same passphrase again:
   Your identification has been saved in /home/<your_user>/.ssh/id_rsa
   Your public key has been saved in /home/<your_user>/.ssh/id_rsa.pub

4. Start T-Pot services: `systemctl start tpot`

Es wird empfohlen, die Datenübermittlung nicht zu deaktivieren, da dies der Hauptzweck des Community-Ansatzes ist – wie ihr alle wisst **Teilen ist Fürsorge** 😍
<br><br>

## Opt-In HPFEEDS-Datenübermittlung
Als Opt-In ist es möglich, T-Pot-Daten mit Drittanbieter-HPFEEDS-Brokern zu teilen.
1. Befolgen Sie die Anweisungen [hier](#community-data-submission), um die T-Pot-Dienste zu stoppen und `~/tpotce/docker-compose.yml` zu öffnen.
2. Scrollen Sie nach unten zum Abschnitt `ewsposter` und passen Sie die HPFEEDS-Einstellungen nach Ihren Bedürfnissen an.
3. Wenn Sie ein CA-Zertifikat hinzufügen müssen, fügen Sie es zu `~/tpotce/data/ews/conf` hinzu und setzen Sie `EWS_HPFEEDS_TLSCERT=/data/ews/conf/<your_ca.crt>`.
4. Starten Sie die T-Pot-Dienste: `systemctl start tpot`.
<br><br>

# Fernzugriff und Werkzeuge
Der Fernzugriff auf Ihren Host / T-Pot ist mit SSH (auf **`tcp/64295`**) möglich, und einige Dienste und Werkzeuge werden mit T-Pot mitgeliefert, um Ihre Forschungsaufgaben erheblich zu erleichtern.
<br><br>

## SSH
Entsprechend den [Benutzertypen](#user-types) können Sie sich per SSH anmelden, um auf die Befehlszeile zuzugreifen: `ssh -l <OS_USERNAME> -p 64295 <your.ip>`:

- Benutzer: **[`<OS_USERNAME>`]**
- Passwort: **[password]**
<br><br>

## T-Pot-Landingpage
Entsprechend den [Benutzertypen](#user-types) können Sie die T-Pot-Landingpage über Ihren Browser unter `https://<your.ip>:64297` öffnen:

- Benutzer: **[`<WEB_USER>`]**
- Passwort: **[password]**

![T-Pot-WebUI](https://assets.kitploit.com/production/public/readmes/4462/7e70eb82c25026577169f745794728206ca655c2fac5155262c645bf0290158e.png)
<br><br>

## Kibana-Dashboard
Klicken Sie auf der T-Pot-Landingpage einfach auf `Kibana`, und Sie werden zu Kibana weitergeleitet. Sie können aus einer großen Auswahl an Dashboards und Visualisierungen wählen, die alle auf die von T-Pot unterstützten Honeypots zugeschnitten sind.

![Dashbaord](https://assets.kitploit.com/production/public/readmes/4462/d363122f1d233abb0f1818c0e69ed6ac1f4a2f139d5d924bcf7d6fc2b0b7f8bc.png)
<br><br>

## Attack Map
Klicken Sie auf der T-Pot-Landingpage einfach auf `Attack Map`, und Sie werden zur Attack Map weitergeleitet. Da die Attack Map WebSockets verwendet, müssen Sie möglicherweise die Anmeldedaten des `<WEB_USER>` erneut eingeben.

![AttackMap](https://assets.kitploit.com/production/public/readmes/4462/a9a8e7024bebe87b98b754ee1fcaf877dee35b0b35404525cfc7b4bcf63778b5.png)
<br><br>

## Cyberchef
Klicken Sie auf der T-Pot-Landingpage einfach auf `Cyberchef`, und Sie werden zu Cyberchef weitergeleitet.

![Cyberchef](https://assets.kitploit.com/production/public/readmes/4462/4e8c0b3e528dad69e932ee8fefc6c0367c93b144fc22b5cbfdfc21401a212540.png)
<br><br>

## Elasticvue
Klicken Sie auf der T-Pot-Landingpage einfach auf `Elasticvue`, und Sie werden zu Elasticvue weitergeleitet.

![Elasticvue](https://assets.kitploit.com/production/public/readmes/4462/0a40257ee96c7713158d952dd3eaeaaa65ef587883f3545592072793819d4a22.png)
<br><br>

## Spiderfoot
Klicken Sie auf der T-Pot-Landingpage einfach auf `Spiderfoot`, und Sie werden zu Spiderfoot weitergeleitet.

![Spiderfoot](https://assets.kitploit.com/production/public/readmes/4462/018e445ac80bc3a63e3504e5f46335b67870f5afe102fe59b308f5b64886e79e.png)
<br><br>

# Konfiguration

## T-Pot-Konfigurationsdatei
T-Pot bietet eine Konfigurationsdatei, die Variablen nicht nur für die Docker-Dienste (d. h. Honeypots und Werkzeuge), sondern auch für die Docker-Compose-Umgebung bereitstellt. Die Konfigurationsdatei ist unter `~/tpotce/.env` versteckt. Es gibt auch eine Beispieldatei (`env.example`), die die Standardkonfiguration enthält.<br>
Führen Sie vor dem ersten Start `~/tpotce/genuser.sh` aus oder richten Sie den `WEB_USER` manuell ein, wie [hier](#add-users-to-nginx-t-pot-webui) beschrieben.

## T-Pot-Honeypots und -Dienste anpassen

In `~/tpotce/compose` finden Sie alles, was Sie benötigen, um die T-Pot Standard / Hive Installation anzupassen:```
customizer.py
llm.yml
mac_win.yml
mini.yml
mobile.yml
sensor.yml
standard.yml
tarpit.yml
tpot_services.yml

## Bekannte Probleme
Die folgenden Probleme sind bekannt, befolgen Sie einfach die beschriebenen Schritte, um sie zu lösen.
<br><br>

### Docker-Images können nicht heruntergeladen werden
Vor einiger Zeit führte Docker Download-[Ratenbegrenzungen](https://docs.docker.com/docker-hub/download-rate-limit/#:~:text=Docker%20Hub%20limits%20the%20number,pulls%20per%206%20hour%20period.) ein. Wenn Sie häufig Docker-Images über eine einzelne oder gemeinsame IP herunterladen, könnte die IP-Adresse das Docker-Download-Ratenlimit ausgeschöpft haben. Melden Sie sich bei Ihrem Docker-Konto an, um das Ratenlimit zu erweitern.```
sudo su -
docker login

5. Jetzt können Sie `~/tpotce/install.sh` ausführen.
<br><br>

## Container und Images anzeigen
Sie können alle T-Pot-relevanten Container durch Ausführen von `dps` oder `dpsw [Intervall]` anzeigen. Das `Intervall (s)` führt `dps` periodisch erneut aus. Verwenden Sie `dim`, um lokal verfügbare Docker-Images einschließlich der Spalte `CREATED` anzuzeigen.
<br><br>

## Blackhole
Blackhole lässt T-Pot in einer Art Stealth-Modus laufen, ohne permanente Besuche von öffentlich bekannten Scannern, und verringert so die Möglichkeit der Entdeckung. Während dies natürlich immer ein Katz-und-Maus-Spiel ist, leitet die Blackhole-Funktion alle Anfragen von [bekannten Massenscannern](https://raw.githubusercontent.com/stamparm/maltrail/master/trails/static/mass_scanner.txt) ins Leere, während die Ereignisse dennoch durch Suricata erfasst werden.
<br>
Die Funktion wird aktiviert, indem in `~/tpotce/.env` `TPOT_BLACKHOLE=DISABLED` gesetzt wird. Führen Sie dann `systemctl stop tpot` und `systemctl start tpot` oder `sudo reboot` aus.
<br>
Das Aktivieren dieser Funktion wird die Sichtbarkeit von Angreifern drastisch reduzieren und folglich zu weniger Aktivität führen. Wie bereits erwähnt, ist es jedoch weder eine Garantie für vollständige Tarnung noch verhindert es das Fingerprinting einiger Honeypot-Dienste.
<br><br>

## Benutzer zu Nginx hinzufügen (T-Pot WebUI)
Nginx (T-Pot WebUI) ermöglicht es Ihnen, beliebig viele `<WEB_USER>`-Konten hinzuzufügen (gemäß den [Benutzertypen](#user-types)).<br>
Um einen neuen Benutzer **hinzuzufügen**, führen Sie `~/tpotce/genuser.sh` aus.<br>
Um Benutzer zu **entfernen**, öffnen Sie `~/tpotce/.env`, finden Sie `WEB_USER` und entfernen Sie den entsprechenden Base64-String (zum Dekodieren: `echo <base64_string> | base64 -d` oder öffnen Sie CyberChef und laden Sie das Rezept "From Base64").<br>
Damit die Änderungen wirksam werden, müssen Sie T-Pot mit `systemctl stop tpot` und `systemctl start tpot` oder `sudo reboot` neu starten.
<br><br>

## Kibana-Objekte importieren und exportieren
Einige T-Pot-Updates erfordern, dass Sie die Kibana-Objekte aktualisieren. Entweder um neue Honeypots zu unterstützen oder um bestehende Dashboards oder Visualisierungen zu verbessern. Stellen Sie sicher, dass Sie zuerst ***exportieren***, damit Sie keine Ihrer Anpassungen verlieren.

### Exportieren
1. Gehen Sie zu Kibana
2. Klicken Sie auf "Stack Management"
3. Klicken Sie auf "Saved Objects"
4. Klicken Sie auf "Export <Anzahl> Objekte"
5. Klicken Sie auf "Alle exportieren"
Dadurch wird eine NDJSON-Datei mit allen Ihren Objekten exportiert. Führen Sie immer einen vollständigen Export durch, um sicherzustellen, dass alle Referenzen enthalten sind.

### Importieren
1. [Laden Sie die NDJSON-Datei herunter](https://raw.githubusercontent.com/telekom-security/tpotce/refs/heads/master/docker/tpotinit/dist/etc/objects/kibana_export.ndjson.zip) und entpacken Sie sie.
2. Gehen Sie zu Kibana
3. Klicken Sie auf "Stack Management"
4. Klicken Sie auf "Saved Objects"
5. Klicken Sie auf "Import" und belassen Sie die Standardeinstellungen (nach vorhandenen Objekten suchen und Konflikte automatisch überschreiben), wenn Sie keine persönlichen Änderungen an den Kibana-Objekten vorgenommen haben.
6. Wählen Sie die NDJSON-Datei aus
Wenn gefragt wird: "If any of the objects already exist, do you want to automatically overwrite them?" antworten Sie mit "Yes, overwrite all".
<br><br>

# Fehlerbehebung
Im Allgemeinen wird T-Pot ***wie besehen*** angeboten, ohne Verpflichtung zur Unterstützung. Es können Issues und Diskussionen eröffnet werden, aber seien Sie bereit, grundlegende notwendige Informationen bereitzustellen, damit die Community helfen kann.
<br><br>

## Logs
* Überprüfen Sie, ob Ihre Container korrekt laufen: `dps`
* Überprüfen Sie lokal verfügbare Docker-Images und ihr Alter: `dim`
* Überprüfen Sie, ob Ihre Systemressourcen nicht erschöpft sind: `htop`, `docker stats`
* Überprüfen Sie, ob ein Portkonflikt vorliegt:```
systemctl stop tpot
grc netstat -tulpen
mi ~/tpotce/docker-compose.yml
docker-compose -f ~/tpotce/docker-compose.yml up
CTRL+C
docker-compose -f ~/tpotce/docker-compose.yml down -v