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
aiengine — Motore di ispezione dei pacchetti programmabile con NIDS, classificazione DNS, analisi di frequenza e generazione automatica di regex. Supporta binding Python/Ruby/Java/Lua per l'integrazione con database e altri strumenti di sicurezza. | Kitploit
Strumenti/GitHubGitHub/camp0/aiengine
Sniffing e Analisi dei PacchettiAnalisi delle VulnerabilitàInformatica ForenseSicurezza di ReteMachine LearningRilevamento IntrusioniAnalisi DNSRilevamento di Anomalie
GitHubcamp0/aiengine

aiengine

Motore di ispezione dei pacchetti programmabile con NIDS, classificazione DNS, analisi di frequenza e generazione automatica di regex. Supporta binding Python/Ruby/Java/Lua per l'integrazione con database e altri strumenti di sicurezza.

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

AIEngine (Motore di Intelligenza Artificiale)

AIEngine è un motore di ispezione dei pacchetti interattivo/programmabile di nuova generazione per Python/Ruby/Java/Lua con capacità di apprendimento senza alcun intervento umano, funzionalità NIDS (Sistema di Rilevamento Intrusioni di Rete), classificazione dei domini DNS, collettore di rete, analisi forense di rete e molte altre.

Il vero progetto è su https://bitbucket.org/camp0/aiengine

AIEngine aiuta anche i professionisti della rete/sicurezza a identificare il traffico e sviluppare firme per utilizzarle su NIDS, Firewall, Classificatori di Traffico e così via.

Le principali funzionalità di AIEngine sono:

  • Supporto per interagire/programmare con l'utente mentre il motore è in esecuzione.
  • Supporto per PCRE JIT per il matching delle regex.
  • Supporto per grafi di regex (pattern di rilevamento complessi).
  • Supporto per cinque tipi di NetworkStack (lan, mobile, lan6, virtual e oflow).
  • Supporto per Set e Filtri Bloom per ricerche IP.
  • Supporto per sistemi operativi Linux, FreeBSD e MacOS.
  • Supporto per il matching di domini HTTP, DNS e SSL.
  • Supporto per domini e host bloccati per HTTP, DNS, SMTP e SSL.
  • Analisi delle frequenze per traffico sconosciuto e generazione automatica di regex.
  • Generazione di firme Yara.
  • Facile integrazione con database (MySQL, Redis, Cassandra, Hadoop, ecc...) per la correlazione dei dati.
  • Facile integrazione con altri motori di pacchetti (Netfilter).
  • Supporto per cache pulite in memoria per aggiornare le informazioni memorizzate.
  • Supporto per rilevare DDoS a livello di rete/applicazione.
  • Supporto per il rifiuto di connessioni TCP/UDP.
  • Supporto per analisi forense di rete in tempo reale.
  • Supporto per protocolli come Bitcoin, CoAP, DHCP, DNS, GPRS, GRE, HTTP, ICMPv4/ICMPv6, IMAP, IPv4/v6, Modbus, MPLS, MQTT, NTP, OpenFlow, POP, RTP, SIP, SMTP, SSDP, SSL, TCP, UDP, VLAN, VXLAN.

Usare AIEngine

Per usare AIEngine (versione ridotta) basta eseguire il binario aiengine o usare il binding python/ruby/java/lua.

root@kitploit:~
luis@luis-xps:~/c++/aiengine/src$ ./aiengine -h
aiengine 1.5
Argomenti obbligatori:
  -I [ --input ] arg                Imposta l'interfaccia di rete, il file pcap o
                                    la directory con file pcap.

Argomenti opzionali del livello di collegamento:
  -q [ --tag ] arg      Seleziona il tipo di tag del livello ethernet (vlan, mpls).

Argomenti opzionali TCP:
  -t [ --tcp-flows ] arg (=32768) Imposta il numero di flussi TCP nel pool.

Argomenti opzionali UDP:
  -u [ --udp-flows ] arg (=16384) Imposta il numero di flussi UDP nel pool.

Argomenti opzionali Regex:
  -R [ --enable-signatures ]     Abilita il motore delle firme.
  -r [ --regex ] arg (=.*)       Imposta la regex per valutare sui flussi.
  -c [ --flow-class ] arg (=all) Usa tcp, udp o all per abbinare la firma
				 sui flussi.
  -m [ --matched-flows ]         Mostra i flussi che corrispondono alla regex.
  -j [ --reject-flows ]          Rifiuta i flussi che corrispondono alla
                                     regex.
  -w [ --evidence ]              Genera un file pcap con la regex corrispondente
                                     per l'analisi forense.

Argomenti opzionali Frequenze:
  -F [ --enable-frequencies ]       Abilita il motore delle frequenze.
  -g [ --group-by ] arg (=dst-port) Raggruppa le frequenze per src-ip, dst-ip, src-port
				    e dst-port.
  -f [ --flow-type ] arg (=tcp)     Usa flussi tcp o udp.
  -L [ --enable-learner ]           Abilita il motore di apprendimento.
  -k [ --key-learner ] arg (=80)    Imposta la chiave per il motore di apprendimento.
  -b [ --buffer-size ] arg (=64)    Imposta la dimensione del buffer interno per
    	                            generare la regex.
  -y [ --enable-yara ]              Genera una firma yara.

Argomenti opzionali:
  -n [ --stack ] arg (=lan)    Imposta lo stack di rete (lan, mobile, lan6, virtual,
			       oflow).
  -d [ --dumpflows ]           Scarica i flussi su stdout.
  -s [ --statistics ] arg (=0) Mostra le statistiche dello stack di rete (5 livelli).
  -T [ --timeout ] arg (=180)  Imposta il timeout dei flussi.
  -P [ --protocol ] arg        Mostra le statistiche di un protocollo specifico dello
                                   stack di rete.
  -e [ --release ]             Rilascia le cache.
  -l [ --release-cache ] arg   Rilascia una cache specifica.
  -p [ --pstatistics ]         Mostra le statistiche del processo.
  -h [ --help ]                Mostra l'aiuto.
  -v [ --version ]             Mostra la stringa della versione.

Tipi di NetworkStack

AIEngine supporta cinque tipi di stack di rete a seconda della topologia di rete.

  • StackLan (lan) Rete locale basata su IPv4.

  • StackLanIPv6 (lan6) Rete locale con supporto IPv6.

  • StackMobile (mobile) Rete Mobile (interfaccia Gn) per IPv4.

  • StackVirtual (virtual) Stack per ambienti virtuali/cloud con VxLan e GRE Trasparente.

  • StackOpenFlow (oflow) Stack per ambienti openflow.

Integrare/Programmare AIEngine con altri sistemi

AIEngine è anche un modulo python/ruby/java/lua che permette una maggiore flessibilità in termini di integrazione con altri sistemi e funzionalità. I principali oggetti forniti dal modulo python sono i seguenti.

root@kitploit:~
    DNSInfo
    BitcoinInfo
    DatabaseAdaptor (classe astratta)
    DomainName
    DomainNameManager
    Flow
    FlowManager
    Frequencies
    FrequencyGroup
    HTTPInfo
    HTTPUriSet
    IMAPInfo
    IPAbstractSet (classe astratta)
        IPSet
    IPSetManager
    LearnerEngine
    NetworkStack (classe astratta)
        StackLan
        StackLanIPv6
        StackMobile
        StackOpenFlow
        StackVirtual
    POPInfo
    PacketDispatcher
    PacketFrequencies
    Regex
    RegexManager
    SIPInfo
    SMTPInfo
    SSLInfo
    MQTTInfo
    CoAPInfo

Per una descrizione completa dei metodi della classe

root@kitploit:~
import pyaiengine
help(pyaiengine)

Consulta le pagine wiki di configurazione o la directory degli esempi per trovare esempi più interessanti. [https://bitbucket.org/camp0/aiengine/wiki/Configurations]

Compilare il binario AIEngine

root@kitploit:~
$ git clone https://bitbucket.com/camp0/aiengine
$ ./autogen.sh
$ ./configure
$ make

Compilare la libreria Python di AIEngine

La prima opzione per compilare la libreria è usare l'ottimizzazione di compilazione O3, questo genererà una libreria piccola

root@kitploit:~
$ git clone https://bitbucket.com/camp0/aiengine
$ ./autogen.sh
$ ./configure
$ cd src
$ make python
$ python pyai_test.py

La seconda opzione compilerà la libreria usando il metodo pythonico standard tramite setup.py, questo genererà una dimensione della libreria maggiore rispetto alla precedente.

root@kitploit:~
$ git clone https://bitbucket.com/camp0/aiengine
$ ./autogen.sh
$ ./configure
$ cd src
$ python setup.py build_ext -i
$ python pyai_test.py

Compilare la libreria Ruby di AIEngine

root@kitploit:~
$ git clone https://bitbucket.com/camp0/aiengine
$ ./autogen.sh
$ ./configure
$ cd src
$ make ruby
$ ruby ruai_tests.rb

Compilare la libreria Java di AIEngine

root@kitploit:~
$ git clone https://bitbucket.com/camp0/aiengine
$ ./autogen.sh
$ ./configure
$ cd src
$ make java
$ java -cp ".:/usr/share/java/junit.jar:/usr/share/java/hamcrest/core.jar:./buildjava" org.junit.runner.JUnitCore JunitTestSuite

Compilare la libreria Lua di AIEngine

root@kitploit:~
$ git clone https://bitbucket.com/camp0/aiengine
$ ./autogen.sh
$ ./configure
$ cd src
$ make lua
$ lua luai_tests.lua

Contribuire a AIEngine

AIEngine è sviluppato con lo standard c++11/14 ed è sotto i termini della GPLv2.

Preleva il codice sorgente di AIEngine con

root@kitploit:~
$ git clone https://bitbucket.com/camp0/aiengine

Se sei interessato a qualche funzionalità o hai bisogno di aiuto, mandami un'email. I contributi sono sempre benvenuti.

Sviluppare nuove funzionalità

AIEngine è stato sviluppato utilizzando lo sviluppo guidato dai test. Quindi, per mantenere lo stesso ciclo di vita, la nuova funzionalità dovrebbe avere test unitari nella directory creata per la nuova funzionalità e, per integrarsi con tutto il sistema, successivamente integrarsi con il file principale tests.cc nella directory /src.

Scarica lo strumento