hacktricks/network-services-pentesting/11211-memcache/README.md

# 11211 - Pentesting Memcache

<details>

<summary><strong>Lernen Sie das Hacken von AWS von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories senden.

</details>

## Protokollinformationen

Aus [Wikipedia](https://en.wikipedia.org/wiki/Memcached):

> **Memcached** (Aussprache: mem-cashed, mem-cash-dee) ist ein allgemeines verteiltes [Memory-Caching](https://en.wikipedia.org/wiki/Memory\_caching)-System. Es wird häufig verwendet, um dynamische datenbankgesteuerte Websites zu beschleunigen, indem Daten und Objekte im RAM zwischengespeichert werden, um die Anzahl der Lesevorgänge auf externe Datenquellen (wie eine Datenbank oder API) zu reduzieren.

Obwohl Memcached SASL unterstützt, sind die meisten Instanzen **ohne Authentifizierung zugänglich**.

**Standardport:** 11211
```
PORT      STATE SERVICE
11211/tcp open  unknown
```
## Enumeration

### Manuell

Um alle Informationen aus einer Memcache-Instanz zu exfiltrieren, müssen Sie Folgendes tun:

1. Finden Sie **Slabs** mit **aktiven Elementen**.
2. Holen Sie sich die **Schlüsselnamen** der zuvor erkannten Slabs.
3. Exfiltrieren Sie die **gespeicherten Daten**, indem Sie die Schlüsselnamen abrufen.

Denken Sie daran, dass dieser Dienst nur ein **Cache** ist, daher können **Daten erscheinen und verschwinden**.
```bash
echo "version" | nc -vn -w 1 <IP> 11211      #Get version
echo "stats" | nc -vn -w 1 <IP> 11211        #Get status
echo "stats slabs" | nc -vn -w 1 <IP> 11211  #Get slabs
echo "stats items" | nc -vn -w 1 <IP> 11211  #Get items of slabs with info
echo "stats cachedump <number> 0" | nc -vn -w 1 <IP> 11211  #Get key names (the 0 is for unlimited output size)
echo "get <item_name>" | nc -vn -w 1 <IP> 11211  #Get saved info

#This php will just dump the keys, you need to use "get <item_name> later"
sudo apt-get install php-memcached
php -r '$c = new Memcached(); $c->addServer("localhost", 11211); var_dump( $c->getAllKeys() );'
```
### Handbuch2

Dieses Handbuch enthält Informationen und Anleitungen zum Pentesting von Memcache auf Port 11211.

#### Was ist Memcache?

Memcache ist ein verbreiteter In-Memory-Caching-Dienst, der häufig in Webanwendungen eingesetzt wird, um die Leistung zu verbessern. Es speichert Daten im Arbeitsspeicher, um den Zugriff zu beschleunigen und die Last auf die Datenbank zu verringern.

#### Memcache-Pentesting

Beim Pentesting von Memcache gibt es verschiedene Techniken, die verwendet werden können, um Schwachstellen zu identifizieren und zu exploitieren. Einige dieser Techniken umfassen:

- **Banner-Grabbing**: Durch das Abrufen des Memcache-Banners können Informationen über die Version und Konfiguration des Dienstes erhalten werden.
- **Memcache-Datenbankabfragen**: Durch das Senden von speziell formatierten Befehlen an den Memcache-Server können Informationen über die gespeicherten Daten abgerufen werden.
- **Memcache-Schwachstellen**: Es gibt bekannte Schwachstellen in älteren Versionen von Memcache, die ausgenutzt werden können, um unbefugten Zugriff zu erlangen oder Daten zu manipulieren.
- **Memcache-Exploits**: Es gibt Exploits, die speziell für Memcache entwickelt wurden, um Schwachstellen auszunutzen und Zugriff auf den Server zu erlangen.

#### Empfohlene Tools

Für das Pentesting von Memcache auf Port 11211 können verschiedene Tools verwendet werden, darunter:

- **Memcached-Client**: Ein Client-Tool, mit dem Befehle an den Memcache-Server gesendet werden können.
- **Memcrashed**: Ein Exploit-Tool, das die Schwachstelle "Memcrashed" ausnutzt, um Denial-of-Service-Angriffe durchzuführen.
- **Memcached-Scanner**: Ein Tool, mit dem Memcache-Server im Netzwerk erkannt und gescannt werden können.

#### Sicherheitsmaßnahmen

Um die Sicherheit von Memcache zu verbessern, sollten folgende Maßnahmen ergriffen werden:

- **Firewall-Konfiguration**: Den Zugriff auf den Memcache-Server auf vertrauenswürdige IP-Adressen beschränken.
- **Aktualisierung**: Memcache regelmäßig auf die neueste Version aktualisieren, um bekannte Schwachstellen zu beheben.
- **Authentifizierung**: Die Verwendung von Authentifizierungsmethoden wie SASL kann den unbefugten Zugriff auf den Memcache-Server verhindern.
- **Monitoring**: Überwachung des Memcache-Servers, um verdächtige Aktivitäten zu erkennen und darauf zu reagieren.

#### Fazit

Das Pentesting von Memcache auf Port 11211 ist ein wichtiger Schritt, um die Sicherheit von Webanwendungen zu gewährleisten. Durch die Identifizierung und Behebung von Schwachstellen können potenzielle Angriffsvektoren minimiert und die Integrität der Daten geschützt werden. Es ist wichtig, die empfohlenen Sicherheitsmaßnahmen zu implementieren, um die Sicherheit des Memcache-Servers zu gewährleisten.
```bash
sudo apt install libmemcached-tools
memcstat --servers=127.0.0.1 #Get stats
memcdump --servers=127.0.0.1 #Get all items
memccat  --servers=127.0.0.1 <item1> <item2> <item3> #Get info inside the item(s)
```
### Automatisch

Memcached ist ein weit verbreiteter In-Memory-Datenbank-Cache, der häufig in Webanwendungen eingesetzt wird, um die Leistung zu verbessern. Es speichert Daten im Arbeitsspeicher, um den Zugriff zu beschleunigen.

Memcached verwendet das TCP-Protokoll und lauscht standardmäßig auf Port 11211. Es ermöglicht den Zugriff auf den Cache über verschiedene Befehle wie GET, SET, ADD, DELETE usw.

Um Memcached automatisch zu erkennen, können Sie das Tool `nmap` verwenden. Führen Sie den folgenden Befehl aus:

```
nmap -p 11211 <ziel-ip>
```

Wenn der Port 11211 geöffnet ist, bedeutet dies, dass Memcached auf dem Zielserver läuft.

Um automatisch nach Memcached-Schwachstellen zu suchen, können Sie das Tool `memcrashed.py` verwenden. Führen Sie den folgenden Befehl aus:

```
python memcrashed.py <ziel-ip>
```

Dieses Tool nutzt eine Schwachstelle in Memcached, die es ermöglicht, eine große Anzahl von Anfragen mit gefälschten Absenderadressen zu senden. Dadurch wird der Server dazu gebracht, große Datenmengen an den angegebenen Zieladressen zu senden, was zu einer Überlastung führen kann.

Es ist wichtig zu beachten, dass das Ausnutzen dieser Schwachstelle illegal ist, es sei denn, Sie haben die ausdrückliche Erlaubnis des Eigentümers des Zielservers.
```bash
nmap -n -sV --script memcached-info -p 11211 <IP>   #Just gather info
msf > use auxiliary/gather/memcached_extractor      #Extracts saved data
msf > use auxiliary/scanner/memcached/memcached_amp #Check is UDP DDoS amplification attack is possible
```
## **Dumping Memcache-Schlüssel**

Im Bereich von Memcache, einem Protokoll, das bei der Organisation von Daten durch Slabs hilft, gibt es spezifische Befehle zum Inspektion der gespeicherten Daten, wenn auch mit bemerkenswerten Einschränkungen:

1. Schlüssel können nur nach Slab-Klasse abgerufen werden, wobei Schlüssel ähnlicher Größe gruppiert werden.
2. Es gibt eine Begrenzung von einer Seite pro Slab-Klasse, was 1 MB an Daten entspricht.
3. Diese Funktion ist inoffiziell und kann jederzeit eingestellt werden, wie in den [Community-Foren](https://groups.google.com/forum/?fromgroups=#!topic/memcached/1-T8I-RVGKM) diskutiert.

Die Einschränkung, nur 1 MB aus potenziell Gigabytes an Daten abrufen zu können, ist besonders signifikant. Diese Funktionalität kann jedoch immer noch Einblicke in die Verwendungsmuster von Schlüsseln bieten, abhängig von spezifischen Anforderungen. Für diejenigen, die weniger an der Funktionsweise interessiert sind, bieten die [Tools-Sektion](https://lzone.de/cheat-sheet/memcached#tools) umfassende Dumping-Utilities. Alternativ wird unten der Prozess der direkten Interaktion mit Memcached-Setups über Telnet beschrieben.

### **Wie es funktioniert**

Die Speicherorganisation von Memcache ist entscheidend. Wenn Memcache mit der Option "-vv" gestartet wird, werden die von ihm generierten Slab-Klassen angezeigt, wie unten gezeigt:
```bash
$ memcached -vv
slab class   1: chunk size        96 perslab   10922
[...]
```
Um alle derzeit vorhandenen Slabs anzuzeigen, wird der folgende Befehl verwendet:
```bash
stats slabs
```
Das Hinzufügen eines einzelnen Schlüssels zu Memcached 1.4.13 verdeutlicht, wie Slab-Klassen erstellt und verwaltet werden. Zum Beispiel:
```bash
set mykey 0 60 1
1
STORED
```
Die Ausführung des Befehls "stats slabs" nach dem Hinzufügen des Schlüssels liefert detaillierte Statistiken über die Auslastung der Slabs:
```bash
stats slabs
[...]
```
Diese Ausgabe zeigt die aktiven Slab-Typen, genutzte Chunks und Betriebsstatistiken, die Einblicke in die Effizienz von Lese- und Schreibvorgängen bieten.

Ein weiterer nützlicher Befehl, "stats items", liefert Daten zu Evictionen, Speicherbeschränkungen und Lebenszyklen von Elementen:
```bash
stats items
[...]
```
Diese Statistiken ermöglichen fundierte Annahmen über das Caching-Verhalten der Anwendung, einschließlich der Effizienz des Caches für verschiedene Inhaltsgrößen, der Speicherzuweisung und der Kapazität zum Zwischenspeichern großer Objekte.

### **Schlüssel ausgeben**

Bei Versionen vor 1.4.31 werden Schlüssel nach Slab-Klasse ausgegeben, indem folgender Befehl verwendet wird:
```bash
stats cachedump <slab class> <number of items to dump>
```
Zum Beispiel, um einen Schlüssel in Klasse #1 abzurufen:
```bash
stats cachedump 1 1000
ITEM mykey [1 b; 1350677968 s]
END
```
Diese Methode durchläuft die Slab-Klassen und extrahiert und optional dumpet Schlüsselwerte.

### **DUMPING VON MEMCACHE-SCHLÜSSELN (VER 1.4.31+)**

Mit der Memcache-Version 1.4.31 und höher wird eine neue, sicherere Methode zum Dumpen von Schlüsseln in einer Produktionsumgebung eingeführt, die den nicht blockierenden Modus gemäß den [Release Notes](https://github.com/memcached/memcached/wiki/ReleaseNotes1431) verwendet. Dieser Ansatz erzeugt umfangreiche Ausgaben, daher wird empfohlen, den Befehl 'nc' für Effizienz zu verwenden. Beispiele sind:
```bash
echo 'lru_crawler metadump all' | nc 127.0.0.1 11211 | head -1
echo 'lru_crawler metadump all' | nc 127.0.0.1 11211 | grep ee6ba58566e234ccbbce13f9a24f9a28
```
### **DUMPING-WERKZEUGE**

Tabelle [von hier](https://lzone.de/blog).

| Programmiersprachen | Werkzeuge                                                                                                                           | Funktionalität                                                                                          |                                                                             |         |
| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ------- |
| PHP                 | [einfaches Skript](http://snipt.org/xtP)                                                                                            | Gibt Schlüsselnamen aus.                                                                                |                                                                             |         |
| Perl                | [einfaches Skript](https://wiki.jasig.org/download/attachments/13572172/memcached-clean.pl?version=1\&modificationDate=1229693957401) | Gibt Schlüssel und Werte aus.                                                                           |                                                                             |         |
| Ruby                | [einfaches Skript](https://gist.github.com/1365005)                                                                                 | Gibt Schlüsselnamen aus.                                                                                |                                                                             |         |
| Perl                | [memdump](https://search.cpan.org/\~dmaki/Memcached-libmemcached-0.4202/src/libmemcached/docs/memdump.pod)                         | Werkzeug im CPAN-Modul                                                                                  | [Memcached-libmemcached](https://search.cpan.org/\~dmaki/Memcached-libmemc) | ached/) |
| PHP                 | [memcache.php](http://livebookmark.net/journal/2008/05/21/memcachephp-stats-like-apcphp/)                                          | Memcache Monitoring GUI, das auch das Ausgeben von Schlüsseln ermöglicht                                 |                                                                             |         |
| libmemcached        | [peep](http://blog.evanweaver.com/2009/04/20/peeping-into-memcached/)                                                              | **Friert Ihren Memcached-Prozess ein!!!** Seien Sie vorsichtig bei der Verwendung in der Produktion. Mit diesem Werkzeug können Sie jedoch die 1-MB-Begrenzung umgehen und wirklich **alle** Schlüssel ausgeben. |                                                                             |         |

## Fehlerbehebung <a href="#troubleshooting" id="troubleshooting"></a>

### 1-MB-Datenbegrenzung <a href="#1mb-data-limit" id="1mb-data-limit"></a>

Beachten Sie, dass Sie vor memcached 1.4 keine Objekte größer als 1 MB speichern können, aufgrund der standardmäßigen maximalen Slab-Größe.

### Timeout niemals auf > 30 Tage setzen! <a href="#never-set-a-timeout--30-days" id="never-set-a-timeout--30-days"></a>

Wenn Sie versuchen, einen Schlüssel mit einem Timeout größer als dem erlaubten Maximum zu "setzen" oder "hinzuzufügen", erhalten Sie möglicherweise nicht das erwartete Ergebnis, da memcached den Wert dann als Unix-Zeitstempel behandelt. Wenn der Zeitstempel auch in der Vergangenheit liegt, wird überhaupt nichts passieren. Ihr Befehl wird stillschweigend fehlschlagen.

Wenn Sie also die maximale Lebensdauer verwenden möchten, geben Sie 2592000 an. Beispiel:
```
set my_key 0 2592000 1
1
```
### Verschwindende Schlüssel bei Überlauf <a href="#verschwindende-schlüssel-bei-überlauf" id="verschwindende-schlüssel-bei-überlauf"></a>

Obwohl die Dokumentation besagt, dass ein Überlauf eines 64-Bit-Werts mit "incr" dazu führt, dass der Wert verschwindet, muss er mit "add"/"set" erneut erstellt werden.

### Replikation <a href="#replikation" id="replikation"></a>

memcached selbst unterstützt keine Replikation. Wenn Sie es wirklich benötigen, müssen Sie Drittanbieterlösungen verwenden:

* [repcached](http://repcached.lab.klab.org/): Multi-Master-Asynchrone Replikation (memcached 1.2 Patch-Set)
* [Couchbase memcached interface](http://www.couchbase.com/memcached): Verwenden Sie CouchBase als Ersatz für memcached
* [yrmcds](https://cybozu.github.io/yrmcds/): memcached-kompatibler Master-Slave-Schlüssel-Wert-Speicher
* [twemproxy](https://github.com/twitter/twemproxy) (auch bekannt als nutcracker): Proxy mit memcached-Unterstützung

### Befehls-Spickzettel

{% content-ref url="memcache-commands.md" %}
[memcache-commands.md](memcache-commands.md)
{% endcontent-ref %}

### **Shodan**

* `port:11211 "STAT pid"`
* `"STAT pid"`

## Referenzen

* [https://lzone.de/cheat-sheet/memcached](https://lzone.de/cheat-sheet/memcached)

<details>

<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) **bei oder folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) **und** [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) **GitHub-Repositories senden.**

</details>