Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
Ferramentas/GitHubGitHub/4g3nt47/striker
Geração de PayloadsComando e ControleRed TeamingFerramenta de Acesso Remoto
GitHub4g3nt47/striker

Striker

Framework C2 multioperador com agentes nativos em C e Python, canais HTTP(S), tarefas assíncronas e uma interface web reativa para operações de red team.

Ver Repositório
300412há 3 anosRevisado pelo Kitploit

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

Striker C2

Striker é um simples programa de Comando e Controle (C2).

Pasted image 20221022194999

Aviso Legal

image

Este projeto está em desenvolvimento ativo. A maioria das funcionalidades é experimental, com mais por vir. Espere mudanças que quebram a compatibilidade.

Funcionalidades

A) Agentes

  • Agentes nativos para hosts linux e windows.
  • Agente python autossuficiente e mínimo, caso você precise.
  • Canais HTTP(s).
  • Execução assíncrona de tarefas.
  • Suporte para múltiplos redirecionadores, e pode usar outros como fallback quando o ativo cair.

B) Backend / Servidor de Equipe

  • Suporta múltiplos operadores.
  • A maioria das funcionalidades expostas através da API REST, facilitando a automação.
  • Usa web sockets para comunicações mais rápidas.

C) Interface do Usuário

  • UI suave e reativa graças a Svelte e SocketIO.
  • Fácil de configurar, pois compila em arquivos HTML, JavaScript e CSS estáticos, que podem ser hospedados com o servidor web mais básico que você encontrar.
  • Funcionalidade de chat de equipe para se comunicar com outros operadores por texto.

Instalando o Striker

Clone o repositório;

root@kitploit:~
$ git clone https://github.com/4g3nt47/Striker.git
$ cd Striker

A base de código está dividida em 4 seções independentes;

1. O Servidor C2 / Backend

Isso lida com toda a lógica do lado do servidor para operadores e agentes. É uma aplicação NodeJS feita com;

  • express - Para a API REST.
  • socket.io - Para comunicação Web Socket.
  • mongoose - Para conectar ao MongoDB.
  • multer - Para lidar com uploads de arquivos.
  • bcrypt - Para hash de senhas de usuários.

O código fonte está no diretório backend/. Para configurar o servidor;

  1. Configure um banco de dados MongoDB;

O Striker usa MongoDB como banco de dados backend para armazenar todos os dados importantes. Você pode instalá-lo localmente na sua máquina usando este guia para distribuições baseadas em Debian, ou criar um gratuito com MongoDB Atlas (uma plataforma de banco de dados como serviço).

  1. Entre no diretório fonte;
root@kitploit:~
$ cd backend
  1. Instale as dependências;
root@kitploit:~
$ npm install
  1. Crie um diretório para arquivos estáticos;
root@kitploit:~
$ mkdir static

Você pode usar esta pasta para hospedar arquivos estáticos no servidor. Este também deve ser o local onde a UPLOAD_LOCATION está definida no arquivo .env (mais sobre isso depois), mas não é obrigatório. Os arquivos neste diretório estarão acessíveis publicamente sob o caminho /static/.

  1. Crie um arquivo .env;

NOTA: Os valores entre < e > são espaços reservados. Substitua-os pelos valores apropriados (incluindo os <>). Para campos que exigem strings aleatórias, você pode gerá-las facilmente usando;

root@kitploit:~
$ head -c 100 /dev/urandom | sha256sum
root@kitploit:~
DB_URL=<your MongoDB connection URL>
HOST=<host to listen on (default: 127.0.0.1)>
PORT=<port to listen on (default: 3000)>
SECRET=<random string to use for signing session cookies and encrypting session data>
ORIGIN_URL=<full URL of the server you will be hosting the frontend at. Used to setup CORS>
REGISTRATION_KEY=<random string to use for authentication during signup>
MAX_UPLOAD_SIZE=<max file upload size, in bytes>
UPLOAD_LOCATION=<directory to store uploaded files to (default: static)>
SSL_KEY=<your SSL key file (optional)>
SSL_CERT=<your SSL cert file (optional)>

Observe que SSL_KEY e SSL_CERT são opcionais. Se algum não for definido, um servidor HTTP simples será criado. Isso ajuda a evitar sobrecarga desnecessária ao executar o servidor atrás de um proxy reverso com SSL no mesmo host.

  1. Inicie o servidor;
root@kitploit:~
$ node index.js
[12:45:30 PM]  Connecting to backend database...
[12:45:31 PM]  Starting HTTP server...
[12:45:31 PM]  Server started on port: 3000

2. O Frontend

Esta é a interface web usada pelos operadores. É uma aplicação web de página única escrita em Svelte, e o código fonte está no diretório frontend/.

Para configurar o frontend;

  1. Entre no diretório fonte;
root@kitploit:~
$ cd frontend
  1. Instale as dependências;
root@kitploit:~
$ npm install
  1. Crie um arquivo .env com a variável VITE_STRIKER_API definida para a URL completa do servidor C2 conforme configurado acima;
root@kitploit:~
VITE_STRIKER_API=https://c2.striker.local
  1. Compile;
root@kitploit:~
$ npm run build

O comando acima compilará tudo em uma aplicação web estática no diretório dist/. Você pode mover todos os arquivos para a raiz web do seu servidor web, ou até mesmo hospedá-lo com um servidor HTTP básico como o do python;

root@kitploit:~
$ cd dist
$ python3 -m http.server 8000
  1. Cadastre-se;
  • Abra o site em um navegador. Você deve ver uma página de login.
  • Clique no botão Registrar.
  • Digite um nome de usuário, senha e a chave de registro em uso (veja REGISTRATION_KEY em backend/.env)

Isso criará uma conta de usuário padrão. Você precisará de uma conta de administrador para acessar alguns recursos. Sua primeira conta de administrador deve ser criada manualmente, depois você pode promover e rebaixar outras contas na aba Usuários da interface web.

Para criar sua primeira conta de administrador;

  • Conecte-se ao banco de dados MongoDB usado pelo backend.
  • Atualize a coleção users e defina o campo admin do usuário alvo como true;

Existem diferentes maneiras de fazer isso. Se você tiver mongo disponível na sua linha de comando, pode fazer usando;

root@kitploit:~
$ mongo <your MongoDB connection URL>
> db.users.updateOne({username: "<your username>"}, {$set: {admin: true}})

Você deve obter a seguinte resposta se funcionar;

root@kitploit:~
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

Agora você pode fazer login :)

3. O Redirecionador C2

A) Redirecionamento Dumb Pipe

Um redirecionador dumb pipe escrito para o Striker está disponível em redirector/redirector.py. Obviamente, isso só funcionará para tráfego HTTP simples, ou para HTTPS quando a verificação SSL estiver desabilitada (você pode fazer isso ativando a macro INSECURE_SSL no agente C).

O exemplo a seguir escuta na porta 443 em todas as interfaces e encaminha para c2.example.org na porta 443;

root@kitploit:~
$ cd redirector
$ ./redirector.py 0.0.0.0:443 c2.example.org:443
[*] Starting redirector on 0.0.0.0:443...
[+] Listening for connections...

B) Proxy Reverso Nginx como Redirecionador

  1. Instale o Nginx;
root@kitploit:~
$ sudo apt install nginx
  1. Crie um config de vhost (ex: /etc/nginx/sites-available/striker);

Espaços reservados;

  • <domain-name> - Este é o FQDN do seu servidor, e deve corresponder ao do seu certificado SSL.
  • <ssl-cert> - O arquivo de certificado SSL a ser usado.
  • <ssl-key> - O arquivo de chave SSL a ser usado.
  • <c2-server> - A URL completa do servidor C2 para o qual encaminhar as requisições.

AVISO: client_max_body_size deve ser tão grande quanto o tamanho definido por MAX_UPLOAD_SIZE no seu arquivo backend/.env, caso contrário, uploads de arquivos grandes falharão.

root@kitploit:~
server {
    listen 443 ssl;
    server_name             <domain-name>;
    ssl_certificate         <ssl-cert>;
    ssl_certificate_key     <ssl-key>;
    client_max_body_size    100M;
    access_log              /var/log/nginx/striker.log;

    location / {
      proxy_pass              <c2-server>;
      proxy_redirect          off;
      proxy_ssl_verify        off;
      proxy_read_timeout      90;
      proxy_http_version      1.0;
      proxy_set_header        Upgrade $http_upgrade;
      proxy_set_header        Connection "upgrade";
      proxy_set_header        Host $host;
      proxy_set_header        X-Real-IP $remote_addr;
      proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}
  1. Ative-o;
root@kitploit:~
$ sudo ln -s /etc/nginx/sites-available/striker /etc/nginx/sites-enabled/striker
  1. Reinicie o Nginx;
root@kitploit:~
$ sudo service nginx restart

Seu redirecionador agora deve estar funcionando na porta 443, e pode ser testado usando (assumindo que seu FQDN é striker.local);

root@kitploit:~
$ curl https://striker.local

Se funcionar, você deve obter a resposta 404 usada pelo backend, como;

root@kitploit:~
{"error":"Invalid route!"}

4. Os Agentes (Implantes)

A) O Agente C

Estes são os implantes usados pelo Striker. O agente principal é escrito em C e está localizado em agent/C/. Ele suporta hosts linux e windows. O agente linux depende externamente de libcurl, que você encontrará instalado na maioria dos sistemas.

O agente windows não tem dependência externa. Ele usa wininet para comunicações, que acredito estar disponível em todos os hosts windows.

  1. Compilando para linux

Supondo que você esteja em um host de 64 bits, o seguinte compilará para host de 64;

root@kitploit:~
$ cd agent/C
$ mkdir bin
$ make

Para compilar para 32 bits em 64;

root@kitploit:~
$ sudo apt install gcc-multilib
$ make arch=32

O comando acima compila tudo no diretório bin/. Você precisará apenas de dois arquivos para gerar implantes funcionais;

  • bin/stub - Este é o stub do agente que será usado como modelo para gerar implantes funcionais.
  • bin/builder - É o que você usará para modificar o stub do agente para gerar implantes funcionais.

O builder aceita os seguintes argumentos;

root@kitploit:~
$ ./bin/builder 
[-] Usage: ./bin/builder <url> <auth_key> <delay> <stub> <outfile>

Onde;

  • <url> - O servidor para o qual reportar. Idealmente deve ser um redirecionador, mas uma URL direta para o servidor também funcionará.
  • <auth_key> - A chave de autenticação a ser usada ao conectar ao C2. Você pode criar isso na aba chaves de autenticação da interface web.
  • <delay> - Atraso entre cada callback, em segundos. Deve ser pelo menos 2, dependendo de quão "ruidoso" você quer que seja.
  • <stub> - O arquivo stub a ser lido, bin/stub neste caso.
  • <outfile> - O nome do arquivo de saída do novo implante.

Exemplo;

root@kitploit:~
$ ./bin/builder https://localhost:3000 979a9d5ace15653f8ffa9704611612fc 5 bin/stub bin/striker
[*] Obfuscating strings...
[+] 69 strings obfuscated :)
[*] Finding offsets of our markers...
[+] Offsets:
            URL: 0x0000a2e0
       OBFS Key: 0x0000a280
       Auth Key: 0x0000a2a0
          Delay: 0x0000a260
[*] Patching...
[+] Operation completed!
  1. Compilando para windows

Você precisará do MinGW para isso. O seguinte instalará o ambiente de desenvolvimento windows de 32 e 64 bits;

root@kitploit:~
$ sudo apt install mingw-w64

Compile para 64 bits;

root@kitploit:~
$ cd agent/C
$ mdkir bin
$ make target=win

Para compilar para 32 bits;

root@kitploit:~
$ make target=win arch=32

Isso compilará tudo no diretório bin/, e você terá o builder e o stub como bin\stub.exe e bin\builder.exe, respectivamente.

B) O Agente Python

O Striker também vem com um agente python autossuficiente (testado no python 2.7.16 e 3.7.3). Ele está localizado em agent/python/. Apenas as funcionalidades mais básicas são implementadas neste agente. Útil para hosts que não podem executar o agente C, mas têm python instalado.

Há 2 arquivos neste diretório;

  • stub.py - Este é o stub de payload a ser passado para o builder.
  • builder.py - É o que você usará para gerar um implante.

Exemplo de uso:

root@kitploit:~
$ ./builder.py
[-] Usage: builder.py <url> <auth_key> <delay> <stub> <outfile>
# The following will generate a working payload as `output.py`
$ ./builder.py http://localhost:3000 979a9d5ace15653f8ffa9704611612fc 2 stub.py output.py
[*] Loading agent stub...
[*] Writing configs...
[+] Agent built successfully: output.py
# Run it
$ python3 output.py

Primeiros Passos

Após seguir as instruções acima, o Striker agora deve estar pronto para uso. Por favor, leia o guia de uso. Divirta-se e boas invasões!

Suporte

Se você gosta do projeto, considere me ajudar a transformar café em código!

Baixar ferramenta