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

# 11211 - Pentesting Memcache

{% hint style="success" %}
Lernen & üben Sie AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
Lernen & üben Sie GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)

<details>

<summary>Support HackTricks</summary>

* Überprüfen Sie die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)!
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos senden.

</details>
{% endhint %}

## Protokollinformationen

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

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

Obwohl Memcached SASL unterstützt, sind die meisten Instanzen **ohne Authentifizierung exponiert**.

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

### Manual

Um alle Informationen, die in einer Memcache-Instanz gespeichert sind, zu exfiltrieren, müssen Sie:

1. **Slabs** mit **aktiven Elementen** finden
2. Die **Schlüsselnamen** der zuvor erkannten Slabs abrufen
3. Die **gespeicherten Daten** durch **Abrufen der Schlüsselnamen** exfiltrieren

Denken Sie daran, dass dieser Dienst nur ein **Cache** ist, sodass **Daten erscheinen und verschwinden können**.
```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() );'
```
### Manual2
```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
```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 Keys**

Im Bereich von memcache, einem Protokoll, das bei der Organisation von Daten durch Slabs hilft, gibt es spezifische Befehle zur Inspektion der gespeicherten Daten, jedoch mit bemerkenswerten Einschränkungen:

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

Die Einschränkung, nur 1 MB aus potenziell Gigabytes an Daten ausgeben zu können, ist besonders signifikant. Diese Funktionalität kann jedoch dennoch Einblicke in die Nutzungsmuster der Schlüssel bieten, abhängig von den spezifischen Bedürfnissen. Für diejenigen, die weniger an den Mechaniken interessiert sind, zeigt ein Besuch im [Tools-Bereich](https://lzone.de/cheat-sheet/memcached#tools) Hilfsmittel für umfassende Dumps. Alternativ wird der Prozess der Verwendung von telnet für die direkte Interaktion mit memcached-Setups im Folgenden beschrieben.

### **How it Works**

Die Speicherorganisation von Memcache ist entscheidend. Das Starten von memcache mit der Option "-vv" zeigt die Slab-Klassen, die es generiert, wie unten dargestellt:
```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
```
Hinzufügen eines einzelnen Schlüssels zu memcached 1.4.13 veranschaulicht, wie Slab-Klassen befüllt und verwaltet werden. Zum Beispiel:
```bash
set mykey 0 60 1
1
STORED
```
Die Ausführung des Befehls "stats slabs" nach der Schlüsseladdition liefert detaillierte Statistiken über die Slab-Nutzung:
```bash
stats slabs
[...]
```
Dieser Output zeigt die aktiven Slab-Typen, genutzten Chunks und Betriebsstatistiken und bietet Einblicke in die Effizienz von Lese- und Schreiboperationen.

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

### **Dumping Keys**

Für Versionen vor 1.4.31 werden die Schlüssel nach Slab-Klasse mit folgendem Befehl ausgegeben:
```bash
stats cachedump <slab class> <number of items to dump>
```
Zum Beispiel, um einen Schlüssel in Klasse #1 zu dumpen:
```bash
stats cachedump 1 1000
ITEM mykey [1 b; 1350677968 s]
END
```
Diese Methode iteriert über Slab-Klassen, extrahiert und optional Schlüsselwerte.

### **DUMPING MEMCACHE KEYS (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 nutzt, wie in den [Release-Notizen](https://github.com/memcached/memcached/wiki/ReleaseNotes1431) beschrieben. Dieser Ansatz erzeugt umfangreiche Ausgaben, daher wird empfohlen, den Befehl 'nc' zur 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 TOOLS**

Table [from here](https://lzone.de/blog).

| Programmier­sprachen | 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)                         | Tool 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 Überwachungs-GUI, die auch das Dumpen 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, wenn Sie dies in der Produktion verwenden. Dennoch können Sie damit die 1MB-Beschränkung umgehen und wirklich **alle** Schlüssel dumpen. |                                                                             |         |

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

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

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

### Setzen Sie niemals ein Timeout > 30 Tage! <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 das erlaubte Maximum zu „setzen“ oder „hinzuzufügen“, erhalten Sie möglicherweise nicht das, was Sie erwarten, da memcached den Wert dann als Unix-Zeitstempel behandelt. Wenn der Zeitstempel auch in der Vergangenheit liegt, wird überhaupt nichts getan. Ihr Befehl schlägt stillschweigend fehl.

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

Trotz der Dokumentation, die etwas über das Überlaufen eines Wertes mit 64 Bit sagt, führt die Verwendung von „incr“ dazu, dass der Wert verschwindet. Er muss erneut mit „add“/„set“ erstellt werden.

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

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

* [repcached](http://repcached.lab.klab.org/): Multi-Master asynchrone Replikation (memcached 1.2 Patch-Set)
* [Couchbase memcached-Schnittstelle](http://www.couchbase.com/memcached): Verwenden Sie CouchBase als memcached Drop-in
* [yrmcds](https://cybozu.github.io/yrmcds/): memcached-kompatibler Master-Slave Key-Value-Speicher
* [twemproxy](https://github.com/twitter/twemproxy) (auch bekannt als nutcracker): Proxy mit memcached-Unterstützung

### Befehle Cheat-Sheet

{% 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)

{% hint style="success" %}
Lernen & üben Sie AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
Lernen & üben Sie GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)

<details>

<summary>Unterstützen Sie HackTricks</summary>

* Überprüfen Sie die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)!
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos senden.

</details>
{% endhint %}