Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Striker — Framework C2 multi-operatore con agenti nativi in C e Python, canali HTTP(S), tasking asincrono e un'interfaccia web reattiva per operazioni di red team. | Kitploit
Strumenti/GitHubGitHub/4g3nt47/striker
Generazione di PayloadCommand and ControlRed TeamingStrumento di Accesso Remoto
GitHub4g3nt47/striker

Striker

Framework C2 multi-operatore con agenti nativi in C e Python, canali HTTP(S), tasking asincrono e un'interfaccia web reattiva per operazioni di red team.

Vedi Repository
3004123 anni faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

Striker C2

Striker è un semplice programma di Command and Control (C2).

Pasted image 20221022194999

Dichiarazione di non responsabilità

image

Questo progetto è in fase di sviluppo attivo. La maggior parte delle funzionalità sono sperimentali, con altre in arrivo. Aspettati modifiche sostanziali.

Caratteristiche

A) Agenti

  • Agenti nativi per host Linux e Windows.
  • Agente Python minimale e autonomo, nel caso ne avessi bisogno.
  • Canali HTTP(s).
  • Esecuzione asincrona dei compiti.
  • Supporto per più redirector, e possibilità di ripiegare su altri quando quello attivo non è disponibile.

B) Backend / Teamserver

  • Supporta più operatori.
  • La maggior parte delle funzionalità sono esposte tramite API REST, facilitando l'automazione.
  • Utilizza web socket per comunicazioni più veloci.

C) Interfaccia Utente

  • UI fluida e reattiva grazie a Svelte e SocketIO.
  • Facile da configurare poiché si compila in file HTML, JavaScript e CSS statici, che possono essere ospitati anche con il server web più semplice che puoi trovare.
  • Funzione di chat di squadra per comunicare con altri operatori tramite testo.
  • Installazione di Striker

    Clona il repository;

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

    Il codice è suddiviso in 4 sezioni indipendenti;

    1. Il Server C2 / Backend

    Gestisce tutta la logica lato server sia per gli operatori che per gli agenti. È un'applicazione NodeJS realizzata con;

    • express - Per l'API REST.
    • socket.io - Per la comunicazione Web Socket.
    • mongoose - Per connettersi a MongoDB.
    • multer - Per gestire il caricamento dei file.
    • bcrypt - Per l'hash delle password degli utenti.

    Il codice sorgente si trova nella directory backend/. Per configurare il server;

    1. Configura un database MongoDB;

    Striker utilizza MongoDB come database di backend per memorizzare tutti i dati importanti. Puoi installarlo localmente sulla tua macchina usando questa guida per distribuzioni basate su Debian, o crearne uno gratuito con MongoDB Atlas (una piattaforma database-as-a-service).

    1. Spostati nella directory sorgente;
    root@kitploit:~
    $ cd backend
    
    1. Installa le dipendenze;
    root@kitploit:~
    $ npm install
    
    1. Crea una directory per i file statici;
    root@kitploit:~
    $ mkdir static
    

    Puoi usare questa cartella per ospitare file statici sul server. Dovrebbe anche essere dove il tuo UPLOAD_LOCATION è impostato nel file .env (maggiori dettagli in seguito), ma non è necessario. I file in questa directory saranno accessibili pubblicamente sotto il percorso /static/.

    1. Crea un file .env;

    NOTA: I valori tra < e > sono segnaposto. Sostituiscili con i valori appropriati (inclusi i <>). Per i campi che richiedono stringhe casuali, puoi generarli 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)>
    

    Nota che SSL_KEY e SSL_CERT sono opzionali. Se qualcuno non è definito, verrà creato un server HTTP semplice. Questo aiuta a evitare overhead inutili quando si esegue il server dietro un proxy inverso con SSL abilitato sullo stesso host.

    1. Avvia il server;
    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. Il Frontend

    Questa è l'interfaccia web utilizzata dagli operatori. È un'applicazione web a pagina singola scritta in Svelte, e il codice sorgente si trova nella directory frontend/.

    Per configurare il frontend;

    1. Spostati nella directory sorgente;
    root@kitploit:~
    $ cd frontend
    
    1. Installa le dipendenze;
    root@kitploit:~
    $ npm install
    
    1. Crea un file .env con la variabile VITE_STRIKER_API impostata sull'URL completo del server C2 come configurato sopra;
    root@kitploit:~
    VITE_STRIKER_API=https://c2.striker.local
    
    1. Compila;
    root@kitploit:~
    $ npm run build
    

    Il comando sopra compilerà tutto in un'applicazione web statica nella directory dist/. Puoi spostare tutti i file al suo interno nella root web del tuo server web, o addirittura ospitarlo con un server HTTP di base come quello di Python;

    root@kitploit:~
    $ cd dist
    $ python3 -m http.server 8000
    
    1. Registrazione;
    • Apri il sito in un browser web. Dovresti vedere una pagina di login.
    • Clicca sul pulsante Register.
    • Inserisci un nome utente, una password e la chiave di registrazione in uso (vedi REGISTRATION_KEY in backend/.env)

    Questo creerà un account utente standard. Avrai bisogno di un account amministratore per accedere ad alcune funzionalità. Il tuo primo account amministratore deve essere creato manualmente, dopodiché potrai aggiornare e declassare altri account nella scheda Utenti dell'interfaccia web.

    Per creare il tuo primo account amministratore;

    • Connettiti al database MongoDB utilizzato dal backend.
    • Aggiorna la collezione users e imposta il campo admin dell'utente target a true;

    Ci sono diversi modi per farlo. Se hai mongo disponibile nella tua CLI, puoi farlo usando;

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

    Dovresti ottenere la seguente risposta se funziona;

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

    Ora puoi fare login :)

    3. Il Redirector C2

    A) Reindirizzamento a Tubo Semplice

    Un redirector a tubo semplice scritto per Striker è disponibile in redirector/redirector.py. Ovviamente funzionerà solo per traffico HTTP semplice, o per HTTPS quando la verifica SSL è disabilitata (puoi farlo abilitando la macro INSECURE_SSL nell'agente C).

    Il seguente esempio ascolta sulla porta 443 su tutte le interfacce e inoltra a c2.example.org sulla 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 Inverso Nginx come Redirector

    1. Installa Nginx;
    root@kitploit:~
    $ sudo apt install nginx
    
    1. Crea un file di configurazione vhost (es: /etc/nginx/sites-available/striker);

    Segnaposto;

    • <domain-name> - Questo è il FQDN del tuo server e dovrebbe corrispondere a quello nel tuo certificato SSL.
    • <ssl-cert> - Il file del certificato SSL da utilizzare.
    • <ssl-key> - Il file della chiave SSL da utilizzare.
    • <c2-server> - L'URL completo del server C2 a cui inoltrare le richieste.

    ATTENZIONE: client_max_body_size dovrebbe essere grande quanto la dimensione definita da MAX_UPLOAD_SIZE nel tuo file backend/.env, altrimenti i caricamenti di file grandi falliranno.

    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. Abilitalo;
    root@kitploit:~
    $ sudo ln -s /etc/nginx/sites-available/striker /etc/nginx/sites-enabled/striker
    
    1. Riavvia Nginx;
    root@kitploit:~
    $ sudo service nginx restart
    

    Il tuo redirector dovrebbe ora essere attivo sulla porta 443, e può essere testato usando (supponendo che il tuo FQDN sia striker.local);

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

    Se funziona, dovresti ottenere la risposta 404 usata dal backend, come;

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

    4. Gli Agenti (Impianti)

    A) L'Agente C

    Questi sono gli impianti utilizzati da Striker. L'agente principale è scritto in C e si trova in agent/C/. Supporta sia host Linux che Windows. L'agente Linux dipende esternamente da libcurl, che troverai installato nella maggior parte dei sistemi.

    L'agente Windows non ha dipendenze esterne. Utilizza wininet per le comunicazioni, che credo sia disponibile su tutti gli host Windows.

    1. Compilazione per Linux

    Supponendo che tu sia su un host a 64 bit, il seguente comando compilerà per host a 64 bit;

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

    Per compilare per 32 bit su 64;

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

    Il comando sopra compila tutto nella directory bin/. Avrai bisogno solo di due file per generare impianti funzionanti;

    • bin/stub - Questo è lo stub dell'agente che verrà usato come modello per generare impianti funzionanti.
    • bin/builder - Questo è ciò che userai per patchare lo stub dell'agente e generare impianti funzionanti.

    Il builder accetta i seguenti argomenti;

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

    Dove;

    • <url> - Il server a cui riferire. Idealmente dovrebbe essere un redirector, ma anche un URL diretto al server funzionerà.
    • <auth_key> - La chiave di autenticazione da utilizzare per connettersi al C2. Puoi crearla nella scheda chiavi di autenticazione dell'interfaccia web.
    • <delay> - Ritardo tra ogni callback, in secondi. Dovrebbe essere almeno 2, a seconda di quanto rumoroso vuoi che sia.
    • <stub> - Il file stub da leggere, in questo caso bin/stub.
    • <outfile> - Il nome del file di output del nuovo impianto.

    Esempio;

    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. Compilazione per Windows

    Avrai bisogno di MinGW per questo. Il seguente comando installerà l'ambiente di sviluppo Windows a 32 e 64 bit;

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

    Compila per 64 bit;

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

    Per compilare per 32 bit;

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

    Questo compilerà tutto nella directory bin/, e avrai il builder e lo stub rispettivamente come bin\stub.exe e bin\builder.exe.

    B) L'Agente Python

    Striker include anche un agente Python autonomo (testato su Python 2.7.16 e 3.7.3). Si trova in agent/python/. Solo le funzionalità più basilari sono implementate in questo agente. Utile per host che non possono eseguire l'agente C ma hanno Python installato.

    Ci sono 2 file in questa directory;

    • stub.py - Questo è lo stub del payload da passare al builder.
    • builder.py - Questo è ciò che userai per generare un impianto.

    Esempio di utilizzo:

    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
    

    Per Iniziare

    Dopo aver seguito le istruzioni sopra, Striker dovrebbe essere pronto per l'uso. Ti invitiamo a consultare la guida all'uso. Divertiti e buon hacking!

    Supporto

    Se ti piace il progetto, considera di aiutarmi a trasformare caffè in codice!

    Scarica lo strumento