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
Manati — Uno strumento basato sul web per assistere il lavoro degli analisti delle minacce intuitivi. | Kitploit
Strumenti/GitHubGitHub/stratosphereips/manati
Raccolta InformazioniThreat IntelligenceMachine Learning
GitHubstratosphereips/manati

Manati

Uno strumento basato sul web per assistere il lavoro degli analisti delle minacce intuitivi.

Vedi Repository
1142727 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

Progetto ManaTI

Build Status contributions welcome GPLv3 license

Machine Learning per l'Analisi Intuitiva delle Minacce

L'obiettivo del progetto ManaTI è sviluppare tecniche di machine learning per assistere un analista di minacce intuitivo ad accelerare la scoperta di nuovi problemi di sicurezza. Il machine learning contribuirà all'analisi trovando nuove relazioni e inferenze. Il progetto includerà lo sviluppo di un'interfaccia web per consentire all'analista di interagire con i dati e l'output del machine learning.

Questo progetto è parzialmente supportato da Cisco Systems. Per maggiori informazioni sul progetto, visita la pagina del Stratosphere Lab

Versioni stabili

  • Mon Sep 3 12:24:26 CEST 2018: Versione 0.12.0a
  • Sun Aug 12 16:21:19 CEST 2018: Versione 0.11.0a
  • Mon Jan 29 00:07:15 CEST 2018: Versione 0.9.0a
  • Fri Nov 10 19:16:52 CEST 2017: Versione 0.8.0.537a
  • Fri Mar 31 12:19:00 CEST 2017: Versione 0.7.1
  • Sun Mar 5 00:04:41 CEST 2017: Versione 0.7
  • Thu Nov 10 12:30:45 CEST 2016: Versione 0.6.2.1
  • Wed Oct 12 21:19:21 CEST 2016: Versione 0.5.1
  • Wed Sep 21 17:56:40 CEST 2016: Versione 0.41
  • Tue Sep 13 10:52:36 CEST 2016: Versione 0.4
  • Thu Aug 18 15:44:31 CEST 2016: Versione 0.3
  • Wed Jun 29 10:44:15 CEST 2016: Versione 0.2
  • Autori

    • Raúl B. Netto (@Piuliss, [email protected], [email protected])
    • Sebastian García (@eldracote, [email protected], [email protected])

    Screenshot dell'app

    manati_screenshot

    Installazione

    ManaTI è un progetto Django con database Postgres e funziona in Linux e MacOS. Raccomandiamo l'uso di un ambiente virtualenv per configurarlo. I passaggi di installazione per Linux sono:

    root@kitploit:~
        sudo apt-get update ; sudo apt-get upgrade -y
    
    1. Clonare il repository
    2. root@kitploit:~
          git clone [email protected]:stratosphereips/Manati.git; cd Manati
        
      

      oppure se non vuoi usare SSH, usa HTTPS

      root@kitploit:~
          git clone https://github.com/stratosphereips/Manati.git; cd Manati
      
    3. Installare Virtualenv per isolare le librerie Python richieste da ManaTI, verranno installate anche le librerie Python per lo sviluppo
    4. root@kitploit:~
          sudo apt-get install virtualenv python-pip python-dev libpq-dev build-essential libssl-dev libffi-dev
          
      
    5. Creare la cartella virtualenv
    6. root@kitploit:~
          virtualenv .vmanati
          
      
    7. Attivare Virtualenv
    8. root@kitploit:~
          source .vmanati/bin/activate
          
      
    9. Installare il motore database PostgreSQL
    10. root@kitploit:~
          sudo apt-get install postgresql-server-dev-all postgresql-9.5 postgresql-client-9.5
          
      
    11. Creare i file delle variabili d'ambiente. Copiare e rinominare i file .env.example in .env, e .env-docker.example in .env-docker
    12. root@kitploit:~
          cp .env.example .env
          cp .env-docker.example .env-docker
      

      OPZIONALE

      Puoi modificare la password e il nome del database, se lo desideri. Ricorda di applicare le modifiche nelle impostazioni del database Postgres di seguito.

    13. Installare le librerie Python richieste
    14. root@kitploit:~
          pip install -r requirements/local.txt
          
      

      Potresti avere qualche problema di permessi nella cartella ~/.cache; esegui il comando seguente e il problema sarà risolto:

             sudo chmod 777 ~/.cache

      Se deployi su Amazon AWS EC2 e hai un errore di memoria, prova:

      root@kitploit:~
          pip install -r requirements/local.txt --no-cache-dir
          
      
    15. Avviare postgresql
    16. root@kitploit:~
          sudo /etc/init.d/postgresql start
      

      Configurare il database

    17. Come root: (Dovrebbe esserci un utente postgres dopo l'installazione del database)
    18. root@kitploit:~
          su - postgres
           
      
    19. Creare il database:
    20. root@kitploit:~
          psql
      
          create user manati_db_user with password 'password';
      
          create database manati_db;
      
          grant all privileges on database manati_db to manati_db_user;
      
          alter role manati_db_user createrole createdb;
          
          CTRL-D (per uscire dalla shell del database postgres)
          
      

      OPZIONALE

      Per cambiare la password predefinita dell'utente postgres (puoi impostare la stessa password se vuoi), particolarmente utile se vuoi usare pgAdmin3-4 come client postgres. Ricorda di non uscire da "sudo - postgres"

      root@kitploit:~
          psql
          
          \password;
      
          CTRL-D (per uscire dalla shell del database postgres)
      

      Verificare che il db sia stato creato con successo

    21. Come utente postgres
    22. root@kitploit:~
          psql -h localhost -d manati_db -U manati_db_user
      
          (e inserisci la password)
      

      Dopo aver inserito la password dovresti aver effettuato l'accesso a postgres.

    23. Installare redis-server
    24. root@kitploit:~
          sudo apt-get install redis-server
          
      

      OPZIONALE

      Se vuoi configurare Redis. Ad esempio, se sei interessato a cambiare la password, puoi:

      root@kitploit:~
          sudo vi /etc/redis/redis.conf
          
      

      e trova la riga requirepass e scrivi accanto la password che desideri.

      root@kitploit:~
          requirepass passwodUser
      

      Ricorda solo di aggiornare la variabile d'ambiente REDIS_PASSWORD nel file .env nella radice del progetto.

    25. Eseguire i file di migrate
    26. root@kitploit:~
          python ./manage.py makemigrations guardian
          python ./manage.py migrate
          
      
    27. Registrazione dei moduli esterni. Devi eseguire questo comando ogni volta che aggiungi o rimuovi un Modulo Esterno
    28. root@kitploit:~
           python ./manage.py check_external_modules
      
    29. Eseguire il file redis_worker.sh (in background '&' o in un'altra console).
    30. root@kitploit:~
          ./utility/redis_worker.sh
          
      
    31. Creare un super utente per l'accesso al sistema web se necessario
    32. root@kitploit:~
          python manage.py createsuperuser
      

      Come eseguirlo

      Non è consigliato eseguire il server come root, ma poiché solo root può aprire porte con numeri inferiori a 1024, sta a te quale utente usare. Di default apre la porta 8000, quindi puoi eseguirlo come root:

      root@kitploit:~
      python ./manage.py runserver
      

      Successivamente, apri il tuo browser su http://localhost:8000/manati_project/manati_ui

      Se vuoi aprire il server sulla rete, puoi farlo con:

      root@kitploit:~
      python ./manage.py runserver <indirizzo-ip>:8000
      

    Se vuoi vedere i job in esecuzione o in coda, vai su http://localhost:8000/manati_project/django-rq/

    Impostazioni: Aggiornamento della versione dal master

    1. Aprire la directory del progetto
    2. root@kitploit:~
      cd path/to/project_directory
          
      
    3. Scaricare le ultime modifiche dal master
    4. root@kitploit:~
      git pull origin master
      
    5. Installare le ultime librerie installate
    6. root@kitploit:~
      pip install -r requirements/local.txt
          
      
    7. Installare redis-server ed eseguire il file redis_worker.sh (in background '&' o in un'altra console)
    8. root@kitploit:~
      ./utility/redis_worker.sh
          
      
    9. Preparare i file di migration per la libreria guardian (se già esistono, non succede nulla)
    10. root@kitploit:~
      python ./manage.py makemigrations guardian --noinput
          
      
    11. Eseguire i file di migration
    12. root@kitploit:~
      python ./manage.py migrate --noinput
      
    13. Registrazione dei moduli esterni. Devi eseguire questo comando ogni volta che aggiungi o rimuovi un Modulo Esterno
    14. root@kitploit:~
      python ./manage.py check_external_modules
          
      
    15. Eseguire il server
    16. root@kitploit:~
      python ./manage.py runserver
      

    Esecuzione in produzione.

    Usando supervisor, gunicorn come server con RQ worker (con server redis) per gestire le attività in background. In futuro abbiamo in programma di preparare le impostazioni per nginx

    root@kitploit:~
    cd path/to/project_directory 
    python manage.py collectstatic --noinput --clear
    sudo supervisord -c supervisor-manati.conf -n
    

    Immagine Docker

    Se hai docker installato, potrebbe essere una buona idea installare l'immagine docker di ManaTI. Il Dockerfile e i file di configurazione del server sono qui. Questa immagine docker di ManaTI viene eseguita su un server NGINX e uWSGI. Questa immagine è mantenuta da @Piuliss

    root@kitploit:~
    docker pull honeyjack/manati:latest
    docker run --name manati -p 8888:8888 -dti honeyjack/manati:latest bash
    

    Quindi, attendere 5 o 10 secondi e andare su http://localhost:8888

    Docker Compose

    Se non vuoi perdere tempo a installare ManaTI e hai docker installato, puoi semplicemente eseguire docker-compose. Prima clona il repository e vai nella directory del progetto.

    root@kitploit:~
    cd Manati
    cp .env.example .env
    cp .env-docker.example .env-docker
    docker-compose build
    docker-compose run web bash -c "python manage.py makemigrations --noinput; python manage.py migrate; python manage.py check_external_modules"
    docker-compose run web bash -c "python manage.py createsuperuser2 --username admin --password Password123 --noinput --email '[email protected]'"
    docker-compose up # oppure 'docker-compose up -d' se non vuoi vedere i log nella console.
    

    Successivamente, apri il tuo browser su http://localhost:8000/manati_project/manati_ui/new

    Backup del DB

    root@kitploit:~
    pg_dump -U manati_db_user -W -F p manati_db > backup.sql # plain text
    

    Ripristino del DB

    root@kitploit:~
    psql manati_db -f backup.sql -U manati_db_user
    

    Browser supportati

    IE / Edge
    IE / Edge
    Firefox
    Firefox
    Chrome
    Chrome
    Safari
    Safari
    Opera
    Opera
    Vivaldi
    Vivaldi
    N/D55+60+N/DN/DN/D

    Licenza

    Licenza GPLv3 (GPLv3). Vedi il file docs/LICENSE per maggiori dettagli.

    Copyright (c) 2016-2018 Stratosphere Laboratory

    Scarica lo strumento