TEMA 1 - COMANDOS BÁSICOS DE LINUX

whoami--> Saber usuario.

id --> Grupo al que perteneces.
sudo presenta un riesgo de escala de privilegios. Porque sudo puede llegar a ser root.
sudo su --> Entras como root.
Tooken privileg --> Para que no vuelvas a poner contraseña de sudo su a root.
sudo + comando --> Lo ejecutas como root.
Los grupos los vemos en /etc/group ( esto es un directorio/archivo).
cat --> Lista los contenidos de un file.
cat /etc/group --> Vemos listados los grupos.
wich cat ( nos dice bin/batcat/ ) --> Vemos la ruta absoluta del binario.
user/bin/whoiam --> Sale igual el comando.
echo hola --> Te sale el hola.
echo + $PATH --> Rutas separadas por dos puntos. Eso es que busca donde está el
comando. Orden de prioridad de búsqueda de izquierda a derecha. Se puede cambiar este
PATH.
id --> Veo los grupos y donde estoy. Veo 25floppy.
/bin/cat --> ruta absoluta más cuca.
control + l --> Limpia la pantalla.
Para filtrar --> | ( pipear) grep "floppy"
El usa batcat con /bin/batcat --> Nos da la línea y así no hay que buscar por las líneas.
Para ver si el comando existe --> wich
Cuando wich no existe --> command -v ( reporta ruta absoluta).
pwd --> Para ver donde estoy.
ls --> Lista donde estoy.
lsd ( comando más profesional).
Permisos o listar con más detalles -> Ls -l
Se puede listar con ruta --> ls + ruta
cd --> Migramos de directorio.
cd .. --> Vamos para atrás.
Para ir a la raiz --> cd ./
Si le das a cd vas a tu directorio personal.
cat /etc/passwd --> Identificamos usuarios + id de usuario + id de grupo. Y vemos el
directorio personal al final y la shell.
$SHELL --> El tipo de shell que usamos. zsh es la que tiene el.
Los tipos de shells se ven en cat /etc/shells.
Para listar las shells --> cat /etc/shells
Para migrar --> echo $SHELL y si pongo bash cambia a bash. Esto cuando tienes otro
instalado a parte de bash.

TEMA 2 - CONTROLES DE FLUJO STDERR-STDOUT, OPERADORES Y

PROCESOS EN SEGUNDO PLANO

Podemos listar comandos con ; entre ellos --> whoami ; ls

Podemos usar && --> El segundo operando se ejecuta si el primer comando es exitoso.
Para ver el código de estado del comando --> echo $?
Si es 0 el comando ha tenido éxito. Si da otro número, es erróneo.
stdr --> Errores
whoam 2>/dev/null --> Envía el error a un agujero negro. Recursos existente donde se
desvanece lo que metamos. Si el comando está bien, sale por pantalla, si no, lo manda a
ese recurso.
Para que no se vea el stdout y se redirija al dev/null y que los errores sean stdout --> cat
/etc/host > /dev/null 2>&1
Hay una mejor manera --> cat /etc/host &>/dev/null
Esto se suele hacer para programas como el wireshark para cuando creas scrips y no
quieres que se vea la salida del programa.
Para poner un programa en segundo plano --> wireshark &> /dev/null &
Y sale un pid que identifica el programa/proceso.
El proceso si es hijo, y cerramos el padre que es la consola, se cierra y lo pierdes. Si
quieres independizarlo: disown al final del comando.

DESCRIPTORES DE ARCHIVO:
exec 3 <> file --> Creamos un archivo.
file file --> Nos dice lo que hay.
Menor solo lectura, mayor escritura.
Para almacenar --> whoami >&3 y lo mete dentro del archivo.
exec 3 >&- --> Cierras el descriptor de archivo. No lo pierde, solo que de cara a un futuro
output ya no se guarda.
exec 5<> data
ls
data
whoami >&5
cat data
Lo veo el archivo ahora.
exec 8>&5 --> Lo que hay en el 5, se copie en el 8. Loque guardas en uno, se guarda en
el otro.
Podemos crear uno y cerrar otro con exec 6>&5-

PERMISOS
Con touch podemos crear un archivo.
Para meter contenido:
echo "Hola" > [Link]
cat [Link]
Si luego ponemos otra cosa, se borra lo anterior.
Doble redirector para que no sobre escriba. >>
Para borrar el archivo rm [Link]
nano [Link]
Le metes el contenido --> Para guardar CONTROL+S o CONTROL+X
vi es otro editor. Si ponemos I, modo inserción. W es para guardar. Y Q para salir.
Si listamos con ls -l :
.rw-r--r--
Si llevan una d es directorio.
r w - ( permisos de propietarios)--> Puedo leer y escribir.
r-- ( grupo)--> Pueden leer solo.
r-- (otros) --> Pueden leer solo.
rwx --> read, write, x ( se puede ejecutar el archivo según grupo/usuario).
Hay que ver el usuario y grupo, por ejemplo en ls -l /etc/passwd
Vemos que pone usuario root y grupo root. Yo como parrot, sería otros y solo podría leer.
Para ver contraseñas:
cat /etc/[Link] | grep "ENCRYPT_METHOD"
Y te dice en que formato está cifrada la contraseña.

ASIGNAR PERMISOS
Con touch creas archivos y con mkdir directorios.
Para tener permisos de escritura --> Tengo que ser el propietario.
chmod cambio privilegios.
chmod o+w prueba
La recursividad borra lo que contenga ( todo).
El * lo puede borrar todo.
Para que los grupos puedan crear contenido:
chgrp --> cambia grupos
chgrp parrot pruba --> Le da permisos de grupo al archivo/directorio.
chmod g+w prueba --> El grupo puede leer y escribir.
Ejemplo:
rw- -w- rw- Con esto adecuamos:
chmod u-x, g-rx, o-x prueba
[Link]
[Link]
acceso-con-chmod/

CREACIÓN DE USUARIOS:
useradd pepe -s ( tipo de shell) /bin/bash -d ( directorio) /home/pepe
Contraseña --> passwd pepe
Y pones contraseña.
Ponerlo en un grupo
chgrp pepe pepe o chgrp Alumnos pruba --> chgrp + grupo + archivo.
chown pepe pepe --> Propietario
chown parrot:root pepe --> De golpe todo.
Aquí está el significado de cada parte del comando:

• "chown": Es el comando abreviado de "change owner", que significa cambiar

propietario.
• "parrot": Es el nuevo propietario que se asignará al archivo o directorio. En este
caso, el nuevo propietario será un usuario llamado "parrot".
 • "root": Es el nuevo grupo al que se asignará el archivo o directorio. En este caso,
el nuevo grupo será "root".
• "pepe": Es el nombre del archivo o directorio al que se cambiará el propietario y
el grupo.

su pepe ( entro en pepe)

whoami
cd ( home/pepe) sale
Creamos un nuevo grupo: grupadd alumnos
usermod -a -G Alumno pepe ( añadimos usuario)
id --> Vemos nuestro grupo.
[Link]
[Link]

NOTACIÓN OCTAL DE PERMISOS

Creo directorio llamado testing con root y lo listo con ls -l.

rwx r-xr-x
tendríamos 111-101-101
Porque separamos en rwx / r-x / r-x
Donde hay letra, ponemos un 1 y si hay -, ponemos 0.
Por tanto: 111-101-101
El 101 es 5 ( 210) y el 111 sería (210) 7. Por tanto, 755. Este permiso sería 755.
chmod 755 testing.
Si queremos hacer el siguiente permiso:
r-xr---w-
Separamos en r-x / r--/-w- y tendremos 101/100/010. Contamos las posiciones en 210, el
010 sería 2, el 100 sería, 4, el 101 sería 5. Este permiso sería 542.
Si se lo añadimos, sería chmod 542 testing. Si comparamos, vemos que los permisos han
cambiado.
Truco: rwx rwx rwx --> Este permiso es el 251. Recordando que rwx es 421, si le
quitamos los 0. Sale rápida la cuenta.
[Link]
PERMISOS ESPECIALES - STICKY BIT

Abrimos consola y vamos al Escritorio y nos convertimos en root. Creamos un directorio

pruebas pepito y vemos los permisos.
chown pepepepe
Para cambiarlo.
Queremos cambiar los grupos para que puedan escribir:
chmod g+w nombre del fichero.
chmod 777 pruebapepito
Migramos al usuario pepe y creamos un archivo llamado holaprobando y lo metemos en
[Link]
Si salimos y nos convertimos en parrot. Estamos en el escritorio y vemos pruebaspepito.
Miramos que hay dentro y hay un [Link] y que no podemos alterar el archivo, solo leerlo.
Si ponemos rm [Link] y permite borrar el archivo! Porque otros pueden alterar el
contenido ( eso incluye borrar).
Es mejor ver los permisos de la carpete.
Si volvemos a entrar como pepito y entramos en pruebaspepito y creamos un archivo con
echo hola probando > [Link], ten el propio directorio de pruebaspepito.
chmod +t pruebaspepito --> Ya no puedes borrar.
Aquí entra el Sticky Bit.
Se suele ejecutar sobre /tmp Y/var/tmp. En octal es el número 1000.
Se activa -->
chmod 1775 test o bien, chmod +t /test
Se desactiva --> chmod -t /test o en octal chmod 0777 /tmp
Ejemplo:
$ ls -ld /tmp
drwxrwxrwt 17 root root 4096 may 18 14:28 /tmp
Para establecerlo podemos ejecutar:
chmod 1xxx directorio
o bien
chmod o+t directorio
De forma análoga a los permisos anteriores, para desactivarlo:
chmod o-t directorio
CONTROL DE ATRIBUTOS DE FICHEROS EN LINUX - CHATTR Y LSATTR

-f hace que no pregunte si si o si no.

Nos convertimos en root. Si podemos borrar ahora el directorio.
Creamos un archivo --> cp /ect/hosts prueba
Te crea una copia de un archivo. Así no alteramos el fichero original.
rm /etc/hosts --> Puedo borrarlo. Pero te peta el equipo.
cat /etc/passwd - --> Es una copia.
Ponemos charttr +i -V ( el verbose hace que veamos que pasa por detrás) prueba.
Le metemos flags.
ls -l
Lo veríamos todo normal e intentamos borrar y no podremos!
lsattr listamos lo que es inmutable.
Tienen flag de inmutable. Se le puede quitar esta flag.
[Link]
linux/#:~:text=El%20primer%20comando%2C%20lsattr%20permite,chmod%2C%20ch
own%2Csetfacl%E2%80%A6)

[Link]

PERMISOS ESPECIALES - SUID y SGID

Si abrimos la consola, nos convertimos en root. Consideramos un binario, por ejemplo,

python3.9
wich python3.9 y vemos donde está
Se puede concatenar un comando:
wich python3.9 | xargs ls-l
Paraleliza comandos y secuencias.
Tiene privilegio 775 ( suelen tener todos los binarios).
Le damos privilegios SUID
chmod u+s /usr/bin/python3.9
Vemos ls -l
Aparece una S.
Trae consigo "problemas". Puedo entrar, ver que hay binarios con SUID.
Descubrir binarios:
find /. -type f -perm -4000 (SUID) 2>/dev/null ( quito los errores)
Esta es una forma rápida de ver SUID.
Si es SUID voy a poder ejecutar de forma temporar el binario como si fuera el propietario.
Desde python3.9, entrando así puedo entrar y convertirme en usuario:
import os
[Link](0)
[Link] ("whoami")
root
0 ( 0 es exitoso).
Puedo aprovecharme de esto para escalar privilegios e inyectar.
Puedes pedir una bash también o una zsh.
SGUID es lo mismo pero en grupos.
Pero en vez de -4000, es -2000.
La asignación es chmod g+s python3.9
2755 en octal.
[Link]
linux/#:~:text=Permiso%20SGID,-
El%20permiso%20SGID&text=Si%20se%20establece%20en%20un,perteneciente%2C
%20el%20grupo%20del%20directorio.

CAPABILITIES

getcap
Lista capabilitis del sistema.
getcap -r /. 2>/dev/null
Podemos manipular el identificador de usuario con las capabilities.
getcap cap_setuid+ep /usr/bin/python3.9
getcap !$
getcap /usr/bin/python3.9
Para quitarla -r
Recurso muy bueno --> GTFOBins
Salen los binarios principales que si tienen capabilities se puede trastear.
RESUMEN:
Las capabilities nos permiten gestionar que permisos tiene un proceso para acceder a las
partes del kernel. Independientemente del usuario que lo lance.
Existen una serie de capabilities que se pueden habilitar a los programa para que tengan
acceso a dichas partes que gestionan.
Estos cuentan con Flags para poder determinar que acciones están disponibles:
Efectivas (e): las capacidades usadas por el núcleo para llevar a cabo comprobaciones de
permisos para el proceso.
Permitidas (p): la capacidades que el proceso puede asumir (esto es, un superconjunto
limitante para los conjuntos de efectivas y heredadas). Si un proceso elimina una
capacidad de su conjunto de permitidas, no puede volver nunca a adquirir esa capacidad
(a menos que ejecute un programa set-UID-root).
Heredadas (i): las capacidades que se conservan tras llamadas a execve(2).
[Link]

ESTRUCTURA DEL DIRECTORIO DEL SISTEMA

A modo de sumario, te dejamos por aquí unos apuntes con la descripción de cada ruta del
sistema:

Directorio Raíz

El directorio raíz, simbolizado por el símbolo (/), es el directorio principal a partir del
cual se ramifican todo el resto de directorios.

Directorio /bin

El directorio /bin es un directorio estático y compartible en el que se almacenan

archivos binarios/ejecutables necesarios para el funcionamiento del sistema. Estos
archivos binarios los pueden usar la totalidad de usuarios del sistema operativo.

Directorio /boot

Es un directorio estático no compartible que contiene la totalidad de archivos

necesarios para el arranque del ordenador excepto los archivos de configuración.
Algunos de los archivos indispensables para el arranque del sistema que acostumbra a
almacenar el directorio /boot son el kernel y el gestor de arranque Grub.

Directorio /dev

El sistema operativo Gnu-Linux trata los dispositivos de hardware como si fueran un

archivo. Estos archivos que representan nuestros dispositivos de hardware se hallan
almacenados en el directorio /dev.
Algunos de los archivos básicos que podemos encontrar en este directorio son:

• cdrom que representa nuestro dispositivo de CDROM.

• sda que representa nuestro disco duro sata.
• audio que representa nuestra tarjeta de sonido.
• psaux que representa el puerto PS/2.
• lpx que representa nuestra impresora.
• fd0 que representa nuestra disquetera.

Directorio /etc

El directorio /etc es un directorio estático que contiene los archivos de configuración

del sistema operativo. Este directorio también contiene archivos de configuración para
controlar el funcionamiento de diversos programas.
Algunos de los archivos de configuración de la carpeta /etc pueden ser sustituidos o
complementados por archivos de configuración ubicados en nuestra carpeta personal
/home.

Directorio /home

El directorio /home se trata de un directorio variable y compartible. Este directorio

está destinado a alojar la totalidad de archivos personales de los distintos usuarios
del sistema operativo a excepción del usuario root. Algunos de los archivos personales
almacenados en la carpeta /home son fotografías, documentos de ofimática, vídeos, etc.

Directorio /lib
El directorio /lib es un directorio estático y que puede ser compartible. Este
directorio contiene bibliotecas compartidas que son necesarias para arrancar los
ejecutables que se almacenan en los directorios /bin y /sbin.

Directorio /mnt

El directorio /mnt tiene la finalidad de albergar los puntos de montaje de los distintos
dispositivos de almacenamiento como por ejemplo discos duros externos, particiones
de unidades externas, etc.

Directorio /media

La función del directorio /media es similar a la del directorio /mnt. Este

directorio contiene los puntos de montaje de los medios extraíbles de
almacenamiento como por ejemplo memorias USB, lectores de CD-ROM, unidades de
disquete, etc.

Directorio /opt

El contenido almacenado en el directorio /opt es estático y compartible. La función de

este directorio es almacenar programas que no vienen con nuestro sistema
operativo como por ejemplo Spotify, Google-earth, Google Chrome, Teamviewer, etc.

Directorio /proc

El directorio /proc se trata de un sistema de archivos virtual. Este sistema de archivos

virtual nos proporciona información acerca de los distintos procesos y aplicaciones
que se están ejecutando en nuestro sistema operativo.

Directorio /root

El directorio /root se trata de un directorio variable no compartible. El directorio

/root es el directorio /home del administrador del sistema (usuario root).

Directorio /sbin
El directorio /sbin se trata de un directorio estático y compartible. Su función es similar
al directorio /bin, pero a diferencia del directorio /bin, el directorio /sbin almacena
archivos binarios/ejecutables que solo puede ejecutar el usuario root o administrador
del sistema.

Directorio /srv

El directorio /srv se usa para almacenar directorios y datos que usan ciertos
servidores que podamos tener instalados en nuestro ordenador.

Directorio /tmp

El directorio /tmp es donde se crean y se almacenan los archivos temporales y las

variables para que los programas puedan funcionar de forma adecuada.

Directorio /usr

El directorio /usr es un directorio compartido y estático. Este directorio es el

que contiene la gran mayoría de programas instalados en nuestro sistema operativo.
Todo el contenido almacenado en la carpeta /usr es accesible para todos los usuarios y su
contenido es solo de lectura.

Directorio /var

El directorio /var contiene archivos de datos variables y temporales como por ejemplo
los registros del sistema (logs), los registros de programas que tenemos instalados en
el sistema operativo, archivos spool, etc.
La principal función del directorio /var es la detectar problemas y solucionarlos. Se
recomienda ubicar el directorio /var en una partición propia, y en caso de no ser posible
es recomendable ubicarlo fuera de la partición raíz.

Directorio /sys

Directorio que contiene información similar a la del directorio /proc. Dentro de esta
carpeta podemos encontrar información estructurada y jerárquica acerca del kernel
de nuestro equipo, de nuestras particiones y sistemas de archivo, de nuestros drivers,
etc.

Directorio /lost-found

Directorio que se crea en las particiones de disco con un sistema de archivos ext después
ejecutar herramientas para restaurar y recuperar el sistema operativo como por ejemplo
fsch.
Si nuestro sistema no ha presentado problemas este directorio estará completamente
vacío. En el caso que hayan habido problemas este directorio contendrá ficheros y
directorios que han sido recuperados tras la caída del sistema operativo.

USO DE BASHRC Y ZSHRC

En mi caso yo opero con una ZSH, por tanto mi archivo de configuración corresponde al
‘~/.zshrc‘. Recuerda que en caso de usar una BASH tu archivo de configuración debería
estar situado en ‘~/.bashrc‘
ls -l -a --> La a detecta archivos ocultos ( empiezan por un . )
Archivo de configuración --> .bashrc
Si se modifica, se pueden crear funciones de ayuda.
hostname -i ( vemos la IP) o infconfig
Creamos una función que nos diga la IP privada nuestra y diga: Tu IP priva es:
[Link]
Se utiliza bash scripting.
auk o cut --> Delimitan y printan argumentos. aunk '{print $3}'
El archivo se puede referenciar: nano ~/.zshrc
ACTUALIZACIÓN Y UPGRADEO DEL SISTEMA
sudo su primero de todo
apt update --> Vemos los paquetes a actualizar.
Parrot tiene parrot-upgrade --> Actualiza el sistema.
sudo pacman -Syu --> Otra opción

USO Y MANEJO CON TMUX --> He pasado de esto.

BÚSQUEDAS A NIVEL DE SISTEMAS
Comando find.
find /. -name passwd 2>/dev/null |
xargs ls -l ( se lo podemos poner para unir comandos).
find / -perm -4000 2>/dev/null --> Para ver los privilegios en los binarios y podemos ver
para inyectar comandos.
find /. -group savitar -type f -d 2>/dev/null
find /. -user root -writable 2>/dev/null
find /. -name dex\* 2>/dev/null --> Busca algo con dex.
\*exdum\* --> Algo que contiene esto.
dex\*.sh
man find --> Ver el manual
find con ls te filtra con los permisos.
[Link]

CREACIÓN DE SCRIPTS EN BASH

touch [Link]
Vemos que no tiene permisos de ejecución.
chmod +x --> Le asigna permisos de ejecución a todos.
vin [Link]
/bin/bash
Empieza el programa
echo "hola esto es una prueba"
Guardamos.
./[Link]
Si le damos ip a
ip a | grep ens33
Nos quedamos en la tercera línea y ponemos tail -n 1
Vemos la IP y awk {print $1}
cut -d '/' (limitador de campo).
Usaremos finalmente el siguiente comando :
ip a | grep ens33 | tail -n 1 | awk '{print $2}' | awk '{print $3}' FS="/"
Abrimos [Link]
echo "[+] Esta es tu dirección IP privada--> $ (ip a | grep ens33 | tail -n 1 | awk '{print
$2}' | awk '{print $3}' FS="/" )"
Si al echo le metemos -e coge carácteres especiales como /n
Se pueden poner colores.
KITTY
[Link]
VIM
[Link]
SSH
sshpass -p 'HASH' ssh + resto
Estamos jugando en Bandit.
Para abrir un archivo llamado "-", usamos cat ./-
Otra opción es --> cat /home/bandit1/-
Se podría usar grep para filtrar por alguna letra.
grep -r "\w" 2>dev/null | tail -n 1 | awk '{print $2}' FS="/"
Y para aprender:
echo -e "\n[+] La contraseña es $(grep -r "\w" 2>dev/null | tail -n 1 | tr ':' ' ' | rev | awk
{print $1} | rev)\n"

1. echo: Es un comando utilizado para imprimir (mostrar) un mensaje en la terminal.

2. -e: Esta opción habilita la interpretación de secuencias de escape en el texto
proporcionado para el comando echo. En este caso, la secuencia de escape "\n"
representa una nueva línea, lo que significa que el texto que sigue después de esta
secuencia será impreso en una nueva línea.
3. "...": Las comillas dobles se utilizan para agrupar el texto que se imprimirá y
asegurarse de que las secuencias de escape y las variables sean interpretadas
correctamente.
4. \n: Representa una nueva línea.
5. [+] La contraseña es ...: Es parte del mensaje que se mostrará en la terminal.
Aquí es donde se insertará la contraseña que se extrae más adelante en el comando.
6. $(...): Esto indica una subshell, lo que significa que el contenido dentro de los
paréntesis será evaluado antes de que se ejecute el comando echo. En este caso,
el contenido dentro de los paréntesis es el comando completo que extraerá la
contraseña.
 7. grep -r "\w" 2>dev/null: El comando grep se utiliza para buscar patrones en
texto. En este caso, -r indica que la búsqueda será recursiva en todos los archivos
dentro del directorio actual y sus subdirectorios. La expresión "\w" buscará
cualquier palabra en el archivo, lo que incluye letras, números y guiones bajos. El
2>dev/null redirecciona los mensajes de error a la "nada" (es decir, se descartan),

lo que evita que aparezcan mensajes de error en la terminal si no se encuentran

coincidencias.
8. |: El símbolo de tubería se utiliza para redirigir la salida del comando anterior
como entrada al siguiente comando.
9. tail -n 1: tail muestra las últimas líneas de un archivo o entrada. -n 1 aquí
indica que solo queremos la última línea de la salida del comando anterior (grep).
10. tr ':' ' ': tr es un comando utilizado para reemplazar caracteres. Aquí, se
reemplaza el carácter ":" con un espacio en blanco. Esto probablemente se utiliza
para formatear la salida.
11. rev: rev es un comando que invierte el orden de los caracteres en cada línea. En
este caso, se utilizará para invertir el orden de los caracteres en la última línea que
se obtuvo después del comando tail.
12. awk {print $1}: awk es un potente comando para procesar y manipular texto.
En este caso, awk se usa para imprimir el primer campo de la línea (campo
separado por espacios en blanco) que fue invertida anteriormente con rev.
13. rev: Se usa nuevamente el comando rev para revertir el orden de los caracteres
del resultado obtenido por awk. Esto devolverá la contraseña a su orden original.

ARCHIVOS CON ESPACIOS

Para abrir archivos con cat que tienen espacios en medio tipo space in this file --> cat
"space in this file"
Control + K --> Quitas la cadena escrita.
cat spaces\ in\ filename
cat s*
cat /home/bandit2/s*
cat /home/bandit2/* ( asterisco lista todo, como solo está este archivo...apañado).

ARCHIVOS OCULTOS:
Los archivos ocultos se ven como un .
Para verlos ls -la
find .
salen :D
./hiden
cat .hidden
find . -type -f | xarg cat
find .-type -f | xarg get "hiden" | xarg cat
find . -type f | grep -vE "bashrc|profile"
En resumen, el comando find . -type f | grep -vE "bashrc|profile" busca todos
los archivos en el directorio actual y sus subdirectorios, pero excluye aquellos cuyos
nombres contengan "bashrc" o "profile" en su nombre. Los resultados serán una lista de
archivos que no coinciden con esos patrones.
Y luego se le puede añadir | cat
Y se obtiene también el resultado.

BUSCAR ARCHIVOS
[Link]
[Link]

[Link]

find . -type f | xarg file ( buscamos lo que tienen ASCII)

cat ruta del archivo que tiene ASCII
Ahora buscamos lo siguiente:
The password for the next level is stored in a file somewhere under the inhere directory
and has all of the following properties:

• human-readable
• 1033 bytes in size
• not executable

Comando --> find . -type f -redeable -size 1033c ! -executable | xargs cat | xargs ( porque
se veía mal)
Siguiente ejercicio:
The password for the next level is stored somewhere on the server and has all of the
following properties:

• owned by user bandit7

• owned by group bandit6
• 33 bytes in size

find . -type f -user bandit7 -group bandit6 -size 33c 2>/dev/null

The password for the next level is stored in the file [Link] next to the word millionth
cat [Link] | grep "millionth"
Ahora hace un comando "programado" para saber donde hay datos en un texto con
muchos espacios:

Juega también mucho con el awks

Le pedimos cat [Link] | grep "millionth" | awk NF '${print $1}' y printa el primer
argumento.
O cat [Link] | grep "millionth" | xargs --> Te lo compacta
Podríamos usar con este comando, el cut:
cat [Link] | grep "millionth" | xargs | cut -d ' ' -f 2 ( tomando como delimitador el espacio,
dame el segundo argumento).
Otro: Con tr le digo que los espacios sean saltos de línea:
cat [Link] | grep "millionth" | xargs |tr ' ' '\n' | tail -n 1 ( Me quedo con la última línea)
Sed cambia palabras sed '/prueba/probando/' --> Para que lo haga en todos lados --> le
metemos una g al fina. --> sed '/prueba/probando/g'
Siguiente:
The password for the next level is stored in the file [Link] and is the only line of text
that occurs only once
[Link]
[Link]
[Link]
Entonces si vemos que un archivo tiene mucho texto y buscamos el único, hacemos:
Comando: sort [Link] | uniq -u
Siguiente:
The password for the next level is stored in the file [Link] in one of the few human-
readable strings, preceded by several ‘=’ characters.
Comando: strings [Link] | grep "===" | tail -n 1 | awk "NF{ print $NF}

Supongamos que tienes un archivo llamado "[Link]" con texto dentro y quieres realizar
una serie de operaciones para extraer cierta información de él.

1. strings [Link]: El comando strings extrae las secuencias de caracteres

imprimibles (strings) de un archivo binario. En este caso, se usa para extraer las
cadenas imprimibles del archivo "[Link]".
2. grep "===": El comando grep se utiliza para buscar patrones en el texto. Aquí,
se busca la cadena "===" en la salida de strings [Link]. Si "===" aparece
en el archivo, grep filtrará y mostrará solo las líneas que contengan esta cadena.
3. tail -n 1: El comando tail muestra las últimas líneas de un archivo o entrada.
Con la opción -n 1, se muestra solo la última línea de la salida de grep. Esto se
hace asumiendo que solo hay una línea que contiene "===".
4. awk "NF{ print $NF}: awk es una herramienta de procesamiento de texto muy
potente. Aquí, se utiliza para imprimir el último campo (palabra) de la última línea
obtenida en el paso anterior (la línea que contiene "==="). NF en awk representa el
número total de campos en la línea, y $NF representa el valor del último campo.

En resumen, el comando completo busca en el archivo "[Link]" las cadenas que

contienen "===" y luego muestra el último campo de la última línea que contiene esa
cadena.

Siguiente: BASE64 - CODIFICACIÓN Y DESCODIFICACIÓN

Para pasar un archivo a base64:
echo "hola" | base64
Para volverlo a pasar a decodificado:
echo "hola" | base64 -d
Por tanto, cat [Link] | base64 -d
SIGUIENTE: ROTACIÓN DE CARÁCTERES
Hay una web que es rot13 y te rota la cadena.
En terminal: 1
cat [Link] | tr '[G-ZA-Fg-az-f]' '[T-ZA-St-za-s]' ( englobamos todas las letras).
Lo vemos ordenando las letras.
Otra forma más sencilla es:
cat [Link] | tr '[A-Za-z]' '[N-ZA-Mn-za-m]' Hemos contado 13 del alfabeto ( la M es la
13, por tanto, N es la siguiente y ordenamos desde ahí).
Comando final: cat [Link] | tr '[A-Za-z]' '[N-ZA-Mn-za-m]' | awk 'NF{print $NF}'
Pero al final, lo he hecho con : [Link]

SIGUIENTE: DESCOMPRESOR RECURSIVO AUTOMÁTICO

xxd --> lo pasa a hexadecimal
Para pasarlo a data normal --> xxd -ps -r
echo "hola" | tee prueba --> Lo enseña y lo guarda
Mejor usar sponge --> cat test | spnge test
Entonces:
- Copiamos el archivo data de bandit a un nvim de nuestra máquina.
- Lo guardamos y le hacemos: cat data | xxd -r | sponge data
- Descargamos ghex y lo abrimos --> ghex data
- Sale 1f8b --> archivo gzip.
- Vale entonces comandos hasta cansarnos:
7z l + archivo --> Vemos que hay dentro
7z x + archivo --> Lo sacamos
Así hasta el [Link] --> Que miramos file [Link] y vemos que tiene texto ASCCI.
- Podemos cat [Link] o bien cat !$ (último argumento)
wbWdlBxEir4CaE8LaPhauuOo6pwRmrDw

SSH Y MANEJO DE CLAVE DE PARES

Los pares de claves SSH son dos claves criptográficamente seguras que pueden usarse
para autenticar a un cliente a un servidor SSH. Cada par de claves está compuesto por
una clave pública y una clave privada.
El cliente mantiene la clave privada y debe mantenerla en absoluto secreto. Poner en
riesgo la clave privada puede permitir a un atacante no autorizado iniciar sesión en los
servidores que están configurados con la clave pública asociada sin autenticación
adicional. Como medida de precaución adicional, es recomendable cifrar la clave en el
disco con una frase de contraseña.
La clave pública asociada puede compartirse libremente sin ninguna consecuencia
negativa. La clave pública puede usarse para cifrar mensajes que sólo la clave privada
puede descifrar. Esta propiedad se emplea como forma de autenticación mediante el uso
del par de claves.
Ejercicio : The password for the next level is stored in /etc/bandit_pass/bandit14 and
can only be read by user bandit14. For this level, you don’t get the next password, but
you get a private SSH key that can be used to log into the next level. Note: localhost is a
hostname that refers to the machine you are working on
Tenemos la id_rsa ( la clave privada), si la cogemos y la usamos para autentificarnos en
el ssh como bandit14, entramos.
Otra opción es cp id_rsa.pub authentication_key ---> La convertimos en clave de
autentificación, la copiamos en la máquina atacada y entramos.
Comando: ssh -i nombre de la id_rsa ( ssh_keyprivate) bandit14@localhost.
fGrHPx402xGC7U7rXKDaxiWFTOiF0ENq

SIGUIENTE - NETCAT
Tenemos que entrar en el puerto 30000.
Netcat es una herramienta de línea de comandos que sirve para escribir y leer datos en la
red. Para la transmisión de datos, Netcat usa los protocolos de red TCP/IP y UDP. La
herramienta proviene originalmente del mundo de Unix; desde entonces, se ha expandido
a todas las plataformas.
Gracias a su universalidad, a Netcat se la llama “la navaja suiza del TCP/IP”. Puede
utilizarse, por ejemplo, para diagnosticar errores y problemas que afecten a la
funcionalidad y la seguridad de una red. Netcat también puede escanear puertos, hacer
streaming de datos o simplemente transferirlos. Además, permite configurar servidores
de chat y de web e iniciar consultas por correo. Este software minimalista, desarrollado a
mediados de los 90, puede operar en modo servidor y cliente.
Le pegamos la contraseña anterior cuando se quede como "pensando". Y nos da otra.
jN2kgmIXJ6fShzhT2avhotn4Zcka6tnt
CONCEPTOS:
Para ver connexiones --> ss -ntlp
Para ver los puertos que corren en cada uno --> lsof -i:22
Script hecho en clase:

Para listar procesos del sistema -> ps -faux

ENCRIPTAR CON SSL

ncat --ssl IP PUERTO
JQttfApK4SeyHwDlI9SXGR50qclOAil1

DESCUBRIR PUERTOS
Contraseña bandit17 -
VwOSWtCA7lRKkTfbr2IDh6awj9RNZM5eVwOSWtCA7lRKkTfbr2IDh6awj9RNZM
5e
El ejercicio nos pedía lo siguiente : Las credenciales para el siguiente nivel se pueden
obtener al enviar la contraseña del nivel actual a un puerto en localhost en el rango de
31000 a 32000. Primero, averigua qué puertos de esta gama tienen un servidor
escuchando en ellos. Luego, descubre cuáles de esos puertos utilizan SSL y cuáles no.
Solo hay 1 servidor que proporcionará las credenciales siguientes; los demás simplemente
te devolverán lo que les envíes.

Para ello:
- Hemos creado un script llamado [Link]. Que es el siguiente:
#!/bin/bash
function ctrl_c(){
echo -e "\n\n[!] Saliendo...\n" --> Función para salir cuando se toca CONTROL+C
tput cnorm; exit 1 --> El cursor aparece.
}
# Ctrl+C
trap ctrl_c INT
tput civis # Ocultar el cursor
for port in $(seq 1 65535); do
(echo '' > /dev/tcp/[Link]/$port) 2>/dev/null && echo "[+] $port - OPEN" &
done; wait --> Este bucle for busca los puertos abiertos en una secuencia del puerto 1 al
65535. Cuando encuentra uno abierto, imprime un mensaje de abierto, si no, nada. El wait
hace que vaya más rápido el script.
# Recuperamos el cursor
tput cnorm
- Entonces desde bandit16, vamos al /tmp/ y creamos un directorio temporal con -->
mktemp -d
- Nos dará una ruta, la copiamos, y dentro de esa ruta creamos el archivo con --> touch
[Link]
- Le damos privilegios con --> chmod +x [Link]
- Lo editamos con --> nano [Link]
- Lo ejecutamos con --> ./[Link]
- Vemos los puertos abiertos y empezamos a probar con ssl con el comando --> ncat --ssl
IP PUERTO
- Ponemos la contraseña anterior a ver qué pasa. Si no pasa nada, seguimos probando con
otro puerto.
- Se nos abre uno con la ID_RSA.
- La copiamos en el directorio donde tenemos [Link] con nano.
- Intentamos entrar en bandit17 con la id_rsa mediante --> ssh -i id_rsa
bandit17@localhost -p 2220
- LISTO!
Otra manera:
- nmap --open -T5 -v -n -p 31000-32000 IP

DETECCIÓN DE DIFERENCIAS DE ARCHIVOS:

El ejercicio es el siguiente -->

Hay 2 archivos en el directorio principal (homedirectory): [Link] y
[Link]. La contraseña para el próximo nivel está en [Link] y es la única
línea que ha cambiado entre [Link] y [Link].
NOTA: si has resuelto este nivel y ves "Byebye!" al intentar iniciar sesión en bandit18,
esto está relacionado con el próximo nivel, bandit19.

Resolución:
- Miramos con ls -la lo que hay en bandit17.
- Hay dos archivos, para ver que hay dentro usamos el comando: wc -l *
- Para ver que hay diferente entre ambos --> diff [Link] [Link]
- Salen dos cadenas:
hga5tuuCLF6fFzUpnagiMN8ssu9LFrdg --> Esta es la buena.
[Link]

COMANDOS DE SSH :
A través del archivo de configuración ‘.bashrc‘ o ‘.zshrc‘, es posible definir una serie de
acciones a llevar a cabo a la hora de obtener una consola interactiva, en este caso tras
ingresar por SSH.
Es por ello que tras ingresar, somos expulsados de forma inmediata, dado que así ha sido
definido en el archivo de configuración ‘.bashrc‘ para el caso que estamos tratando. Si
colamos un comando al final de nuestra línea al aplicar una autenticación por SSH,
lograremos que ese comando sea introducido a nivel de sistema antes de que se interprete
el archivo de configuración pertinente.
PROCESO--> SSH se le pueden poner comandos detrás, este caso, le ponemos ssh
bandit18@localhost -p 2220 bash
Y entramos dentro.
Una vez dentro, buscamos el archivo readme y está la siguiente contraseña.
Lo tenemos --> awhqfNnAbc1naukrpqDYcF95h7HoMTrC

SUID Y SGUID
SUID es un permiso de archivo especial para archivos ejecutables que permite a otros
usuarios ejecutar el archivo con los permisos efectivos del propietario del archivo. SGID,
por el contrario, es un permiso de archivo especial que también se aplica a los archivos
ejecutables y permite a otros usuarios heredar el GID efectivo del propietario del grupo
de archivos.
SUID significa “establecer ID de usuario” (Set owner User ID) y SGID significa
“establecer ID de grupo” (Set Group ID up on execution).
PROCESO:
- Entramos a ver qué hay con ls -l y vemos un archivo llamado bandit20-do ( por tanto
podemos usarlo como si fuéramos usuarios).
- ./ bandit20-do whoami
- ./bandit20-do id
- ./bandit20-do bash -p
Y entramos en bandit20.
- Hacemos ls y pwd.
- Nos dice que el archivo está en /etc/bandit_pass/bandit20 --> cat a esto y obtenemos la
contraseña.
VxCazJaVykI6W36BkBU0mJTCM8rR95XT
JUGANDO CON CONEXIONES

Bandit21 --> NvEJF7oVjkddltPSrdKEFOllh9V1IBcq

Nos dice el enunciado lo siguiente --> Hay un archivo binario con el atributo "setuid" en
el directorio principal (homedirectory) que hace lo siguiente: establece una conexión con
localhost en el puerto que especificas como argumento en la línea de comandos. Luego,

lee una línea de texto de la conexión y la compara con la contraseña del nivel anterior
(bandit20). Si la contraseña es correcta, transmitirá la contraseña para el siguiente nivel
(bandit21).
PROCEDIMIENTO:
- Para establecer una connexión usamos nc -nlvp 4646 ( puerto cualquiera) en una
terminal con bandit20 abierto.
- En otra terminal abrimos bandit20 y ejecutamos ./suconnect
- En la que está en escucha, ponemos la contraseña de bandit20 y nos devuelve la de
bandit21.

[Link]

CRON
Cron es un administrador de tareas de Linux que permite ejecutar comandos en un
momento determinado, por ejemplo, cada minuto, día, semana o mes. Si queremos
trabajar con cron, podemos hacerlo a través del comando crontab.
El formato de configuración de cron es el siguiente: Minuto Hora Dia-del-Mes Mes
Dia-de-la-Semana Comando-a-Ejecutar
El intervalo de tiempo se especifica mediante 5 campos que representan, de izquierda a
derecha:

• Minutos: de 0 a 59.
 • Horas: de 0 a 23.
• Día del mes: de 1 a 31.
• Mes: de 1 a 12.
• Día de la semana: de 1 a 6 lunes a sábado (1=lunes, 2=martes, etc.) y 0 o 7 el
domingo.

Si quisiéramos especificar todos los valores posibles de un parámetro (minutos, horas,

etc.) podemos hacer uso del asterisco (*). Esto implica que si en lugar de un número
utilizamos un asterisco, el comando indicado se ejecutará cada minuto, hora, día de mes,
mes o día de la semana, como en el siguiente ejemplo:
* * * * * /home/user/[Link]
Contraseña --> WdDozAdTM2z9DiFEQ2mGlwngMfj4EZff
PROCEDIMIENTO:
- Entramos en la carpeta /etc/cron.d
- Vemos los cronjob. Y hacemos cat en cronjob_bandit22. Y vemos que se está ejecutando
un script llamado [Link]. Lo miramos con cat y vemos que pone chmod 664 y que
pasa la contraseña de un directorio a un tmp. Intentamos entrar en el directorio pero nos
dice que no podemos. Sin embargo, en el tmp tenemos permisos de read. Por tanto,
entramos y hacemos cat al /tmp. Y listo.
Más información: [Link]
Segunda parte del ejercicio --> Un programa se está ejecutando automáticamente en
intervalos regulares desde cron, el programador de tareas basado en el tiempo. Busca en
/etc/cron.d/ la configuración y verifica qué comando se está ejecutando.
NOTA: Mirar scripts de shell escritos por otras personas es una habilidad muy útil. El
script de este nivel está intencionalmente diseñado para ser fácil de leer. Si tienes
problemas para entender lo que hace, intenta ejecutarlo para ver la información de
depuración que imprime.
Contraseña: QYw0Y2aiA672PsMmh9puTQuhoz8SyR2G
- Nos dice que hay una tarea realizandose. La buscamos en /etc/cron.d y vamos a cat
cronjob_bandit23 y vemos que se está ejecutando un script de bash.
- La miramos con cat /usr/bin/cronjob_bandit23.sh y vemos que hay un script que se
ejecuta de forma automática y es de autentificación.
- Vamos a ejecutar el script poniendo echo y sustituyendo whoami por bandit23 y el tarjet
será lo que nos de el md5sum.
- El md5sum lo usaremos como parte del /tmp/tarjet.
- cat /tmp/tarjet --> Y obtenemos la contraseña.

Siguiente y última de CRON :

Contraseña: VAfGXJ1PBSsPSnvsjI8p759leLZ9GGar
En este, teníamos un scrip que borraba archivos y hemos tenido que crear un script propio
en un mktemp. Y darle permisos a otros y al propio archivo. El scrip era el siguiente:
cat /etc/bandit_pass/bandit24 ( donde estan las contraseñas) > /tmp/carpeta nuestra
temporal/bandit24_password.log ( archivo creado)
chmod o+r al archivo con la ruta entera /tmp/carpeta nuestra/bandit24_password.log
Salimos y le damos permisos a otros para que vean la ruta de /tmp con chmod o+wx /tmp/
Luego copiamos cp [Link] /var/..... ( ruta de bandit24)
Ejecutamos watch -n 1 ls -l
Y luego vemos que cambia de 0 a 33 el [Link] y hacemos cat y vemos la
contraseña.

CRON Y SUS EXPRESIONES

[Link]

FUERZA BRUTA

En este ejercicio nos pedía la contraseña + un pin de 4 dígitos. Para ello, hemos creado
un script de bash de la siguiente manera:
for pin in {0000..9999} ; do echo " contraseña $pin" ; done > [Link]
Para que se almacenara allí.
Una vez almacenado --> cat [Link] | nc localhost 30002 | grep -vE
"Wrong|Please enter" ( para quitar texto).
Al cabo de un rato, debería salir la contraseña.
El archivo [Link] lo creamos en un temporal con el comando:
dir_name=$(mktemp -d)
Así luego podemos hacer cd $dir_name e ir directamente.

MORE
En esta parte, no nos deja conectarnos de bandit 25 a bandit 26, nos explusa. Pero tenemos
una id_rsa. La intentamos usar con el comando:
ssh -i [Link] bandit26@localhost -p 2220
Nos vuelve a echar cuando se conecta y vemos que no tiene bash.
Indagamos y vemos que tiene un archivo llamado /usr/bin/showtext.
Lo miramos con more y vemos que es el intento de abrir el banner gigantesco. Lo bueno
de more es que usando el modo v ( visual) podemos escribir comandos e insertar
variables. Para ello, le damos a ESCP + SHIFT + : y ya podemos escribir.
Creamos la variable set shell =/bin/bash y ya tenemos bash dentro de bandit26.
Lo usamos para hacer cat [Link]
cat /etc/bandit_pass/bandit26 --> Pero nos manda al showtext de antes. Pero vemos que
hay un binario con permisos SGUID. Por tanto, podemos ejecutarlo con en la clase
anterior:
./bandit27-do cat /etc/bandit_pass/bandit27 y copiamos la contraseña y ya podemos
loggearnos como bandit27.

GITHUB
Compramos la contraseña de bandit27 para usarla como contraseña en la descarga de
GitHub.
Clonamos el proyecto con --> git clone ( la dirección que nos han dado).
Hay que hacer root en casos que queremos clonar en nuestra sesión.
Creamos un dir_name=$(mktemp -d) y en él almacenamos el repositorio descargado.
Lo miramos con cat repo y cat readme.
Vemos que está la contraseña de bandit28.
Para el siguiente ejercicio utilizamos dos comandos nuevos:
git log y git show:
Con el comando ‘git log‘ podremos siempre listar todos los Commits existentes en un
proyecto. Lo que obtendremos es un listado de identificadores los cuales podremos
aprovechar para, por ejemplo, mediante el uso del comando ‘git show‘ seguido del
identificador del Commit cuyas propiedades queramos visualizar, ser capaces de ver
todos los cambios que se hayan aplicado para un punto dado del proyecto.
En caso de querer volver a un estado del proyecto pasado, podremos hacer uso del
comando ‘git checkout‘ seguido del identificador del Commit deseado, pudiendo así
volver a ese punto de la historia con todos los archivos existentes para ese entonces
restaurados.
Volvemos a repetir lo mismo, git clone, ponemos la contraseña y vemos que en cat repo
está el user y el password. Para ver las modificaciones:
git log
Para ver lo que se modificó con el Commit que tiene --> git show "número de Commit"
y ya vemos la contraseña.
El comando ‘git branch‘ nos permite crear, enumerar y eliminar ramas, así como cambiar
sus nombres. Es importante recalcar que no nos permite cambiar entre ramas o volver a
unir un historial bifurcado. Por este motivo, ‘git branch‘ está estrechamente integrado
con los comandos ‘git checkout‘ y ‘git merge‘.
Hacemos lo mismo que antes:
- mktemp -d
- git clone
- cd repo
- cat README.
Vemos que el passw no está.
- git log
- git show de ambos commits
Y nada tampoco. Pues usamos los comandos branch y checkout. El branch es el de rama.
- git branch -a --> Vemos cambios, pues intentamos volver atrás.
- git checkout dev --> La rama de desarrollo donde puede estar la contraseña modificada.
ls
cat [Link] --> Contraseña!
En Git, una etiqueta o tag sirve básicamente como una rama firmada que no permuta, es
decir, siempre se mantiene inalterable. Sencillamente es una cadena arbitraria que apunta
a un Commit específico. Puede decirse que un tag es un nombre que puedes usar para
marcar un punto específico en la historia de un repositorio.
En el siguiente volvemos a lo mismo:
- mktemp -d
- git clone repositorio
- cd repo
- cat readme
- git log
- git branch -a --> No vemos nada.
Usamos el tag:
- git tag --> Vemos un archivo secret
- git show secret --> Contraseña encontrada.

Los commits son la base principal del trabajo de Git, ya que es el comando más usado
para guardar cualquier cambio en esta herramienta. Si te preguntas qué es un commit, te
puedes hacer una idea al entenderlo como una captura de pantalla del trabajo que
haces cada segundo en Git, creando en consecuencia una versión del proyecto en el
repositorio local.

Repetimos los pasos anteriores:

- mktemp -d
- Vemos el readme con cd repo + cat readme.
No hay nada.
- git log
- git branch -a
- git tag --> tampoco.
Nos pide el archivo que creemos un nuevo documento ( Commit). Lo creamos pues:
- nano [Link] --> Nos pide que se llame así.
- git add -f [Link]
- git commit -m "Creamos un nuevo archivo"
- git push -u origin-master --> Donde nos dice que debe estar - YES - Contraseña anterior
- Sale la nueva!

ARGUMENTOS POSICIONALES EN BASH

En Bash se pueden usar argumentos desde la línea de comandos, los cuales son enviados
a los scripts como variables. Estos quedarían representados de la siguiente forma:
[$0]: Representa el nombre del script que se invocó desde la terminal.
[$1]: Es el primer argumento desde la línea de comandos.
[$2]: Es el segundo argumento desde la línea de comandos y así sucesivamente.
[$#]: Contiene el número de argumentos que son recibidos desde la línea de comandos.
[$*]: Contiene todos los argumentos que son recibidos desde la línea de comandos,
guardados todos en la misma variable.
En este ejercicio, hemos entrado en un shell que no es bash y no nos deja poner comandos.
Visto lo anterior, usaremos $0 para que nos de el scrip anterior que se invocó y es un sh.
Por tanto, al hacer $0, nos deja entrar como una bash. Y ya podemos indagar en cd
/home/bandit33 y ver la contraseña.