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 — AIEngine è un NIDS (sistema di rilevamento delle intrusioni di rete) di nuova generazione, interattivo/programmabile, in Python/Ruby/Java/Lua e Go. | Kitploit
Strumenti/BitbucketBitbucket/camp0/aiengine
Strumenti DifensiviNetwork ForensicsSicurezza di ReteThreat IntelligenceMachine LearningRilevamento IntrusioniAnalisi DNSRilevamento di Anomalie
Bitbucketcamp0/aiengine

aiengine

AIEngine è un NIDS (sistema di rilevamento delle intrusioni di rete) di nuova generazione, interattivo/programmabile, in Python/Ruby/Java/Lua e Go.

Vedi Repository
103 anni faNon ancora revisionato

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

Documentation Status codecov coverity CII Best Practices Python 2.7|3.5|3.6|3.7|3.8|3.9 Lua 5.1|5.2|5.4 Go 1.15 License LGTM Grade

LGTM Grade

AIEngine (Motore di Intelligenza Artificiale)

AIEngine è un motore per sistemi di rilevamento delle intrusioni di rete (NIDS) di nuova generazione, interattivo/programmabile in Python/Ruby/Java/Lua e Go, con capacità di apprendimento senza alcun intervento umano, classificazione dei domini DNS, rilevamento dello spam, collettore di rete, network forensics e molte altre.

AIEngine aiuta inoltre i professionisti di rete/sicurezza a identificare il traffico e a 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 a PCRE JIT per il matching delle regex.
  • Supporto per grafi regex (pattern di rilevamento complessi).
  • Supporto di sei tipi di NetworkStacks (lan, mobile, lan6, virtual, oflow e mobile6).
  • Supporto di Set e filtri Bloom per le ricerche IP.
  • Supporto per le architetture x86_64, ARM e MIPS su sistemi operativi come Linux, FreeBSD e MacOS.
  • Supporto per il matching dei 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 di cache di memoria pulite per aggiornare le informazioni memorizzate.
  • Supporto per il rilevamento di DDoS a livello di rete/applicazione.
  • Supporto per il rifiuto di connessioni TCP/UDP.
  • Supporto per la network forensics in tempo reale.
  • Supporto per le firme JA3 TLS su SSL.
  • Supporta protocolli come Bitcoin, CoAP, DHCPv4/DHCPv6, DNS, DTLS, GPRS, GRE, HTTP, ICMPv4/ICMPv6, IMAP, IPv4/v6, Modbus, MPLS, MQTT, Netbios, NTP, OpenFlow, PPPoE, POP, Quic, RTP, SIP, SMB, SMTP, SSDP, SSH, SSL, TCP, UDP, VLAN, VXLAN.
  • Integrazione di un server HTTP per recuperare e configurare il sistema in tempo reale.

Consulta la cartella docs per maggiori informazioni

Uso di AIEngine

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

root@kitploit:~
luis@luis-xps:~/c++/aiengine/src$ ./aiengine -h
aiengine 2.1.0
Mandatory arguments:
  -I [ --input ] arg                Sets the network interface ,pcap file or 
                                    directory with pcap files.

Link Layer optional arguments:
  -q [ --tag ] arg      Selects the tag type of the ethernet layer (vlan,mpls).

TCP optional arguments:
  -t [ --tcp-flows ] arg (=32768) Sets the number of TCP flows on the pool.

UDP optional arguments:
  -u [ --udp-flows ] arg (=16384) Sets the number of UDP flows on the pool.

    Domain optional arguments:
      -D [ --domain-file ] arg             Reads domain names from file.
      -B [ --domain-protocol ] arg (=dns)  Protocol to plug the domain-file (dns, 
                                           ssl, http).
      -S [ --matched-domain ]              Shows only the domains that matches.

Regex optional arguments:
  -R [ --enable-signatures ]     Enables the Signature engine.
  -r [ --regex ] arg (=.*)       Sets the regex for evaluate agains the flows.
  -c [ --flow-class ] arg (=all) Uses tcp, udp or all for matches the signature
				 on the flows.
  -m [ --matched-flows ]         Shows the flows that matchs with the regex.
  -M [ --matched-packet ]        Shows the packet payload that matchs with 
    	                         the regex.
  -C [ --continue ]              Continue evaluating the regex with the 
                                 next packets of the Flow.
  -j [ --reject-flows ]          Rejects the flows that matchs with the 
                                     regex.
  -w [ --evidence ]              Generates a pcap file with the matching 
                                     regex for forensic analysis.

Frequencies optional arguments:
  -F [ --enable-frequencies ]       Enables the Frequency engine.
  -g [ --group-by ] arg (=dst-port) Groups frequencies by src-ip,dst-ip,src-por
				    t and dst-port.
  -f [ --flow-type ] arg (=tcp)     Uses tcp or udp flows.
  -L [ --enable-learner ]           Enables the Learner engine.
  -k [ --key-learner ] arg (=80)    Sets the key for the Learner engine.
  -b [ --buffer-size ] arg (=64)    Sets the size of the internal buffer for 
    	                            generate the regex.
      -Q [ --byte-quality ] arg (=80)   Sets the minimum quality for the bytes of 
                                        the generated regex.
  -y [ --enable-yara ]              Generates a yara signature.

Optional arguments:
  -n [ --stack ] arg (=lan)    Sets the network stack (lan,mobile,lan6,virtual,
			       oflow).
  -d [ --dumpflows ]           Dump the flows to stdout.
  -s [ --statistics ] arg (=0) Show statistics of the network stack (5 levels).
  -T [ --timeout ] arg (=180)  Sets the flows timeout.
  -P [ --protocol ] arg        Show statistics of a specific protocol of the 
                                   network stack.
  -a [ --port ] arg (=0)       Sets the HTTP listenting port.
  -e [ --release ]             Release the caches.
  -l [ --release-cache ] arg   Release a specific cache.
  -p [ --pstatistics ]         Show statistics of the process.
      -o [ --summary ]             Show protocol summmary statistics 
                                   (bytes,packets,% bytes,cache miss,memory).
  -h [ --help ]                Show help.
  -v [ --version ]             Show version string.

Tipi di NetworkStack

AIEngine supporta sei tipi di Network stack 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.

  • StackMobileIPv6 (mobile6) rete mobile (interfaccia Gn) per IPv6.

Integrare/Programmare AIEngine con altri sistemi

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

root@kitploit:~
    BitcoinInfo
    Cache
    CoAPInfo
    DCERCPInfo
    DHCPInfo
    DHCPv6Info
    DNSInfo
    DTLSInfo
    DatabaseAdaptor
    DomainName
    DomainNameManager
    Flow
    FlowManager
    Frequencies
    FrequencyGroup
    HTTPInfo
    HTTPUriSet
    IMAPInfo
    IPAbstractSet
        IPRadixTree
        IPSet
    IPSetManager
    LearnerEngine
    MQTTInfo
    NetbiosInfo
    NetworkStack
        StackLan
        StackLanIPv6
        StackMobile
        StackMobileIPv6
        StackOpenFlow
        StackVirtual
    POPInfo
    PacketDispatcher
    PacketFrequencies
    QuicInfo
    Regex
    RegexManager
    SIPInfo
    SMBInfo
    SMTPInfo
    SSDPInfo
    SSHInfo
    SSLInfo
    TCPInfo

Per una descrizione completa dei metodi delle classi in Python

root@kitploit:~
import pyaiengine
help(pyaiengine)

Controlla la cartella examples per trovare casi d'uso utili e consulta /docs per la documentazione.

Compilare il binario di AIEngine

È necessario avere installato pcre-devel, libpcap-devel e boost-devel nel proprio sistema come minimo.

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

Funzionalità opzionali

Il sistema fornisce le seguenti funzionalità abilitabili/disabilitabili a seconda delle proprie esigenze.

  • --enable-tcpqos Abilita il supporto alle metriche TCP QoS per misurare la QoS delle connessioni.
  • --enable-bloomfilter Abilita il supporto al bloom filter per le ricerche IP. Questa opzione richiede le librerie corrette.
  • --enable-reject Abilita il supporto al rifiuto di connessioni TCP/UDP per interrompere le connessioni stabilite sugli oggetti StackLans e StackLanIPv6.
  • --enable-pythongil Abilita il supporto al Gil di Python per applicazioni multithreading.
  • --enable-static-memory Abilita il supporto alla memoria statica/fissa per sistemi con bassi requisiti di memoria (slot da 256 byte).
  • --enable-code-coverage Abilita il supporto alla code coverage (sviluppo).
  • --enable-sanatizer Abilita il supporto ai test sanatizer (sviluppo).
  • --enable-ja3 Abilita la generazione di impronte TLS nel formato JA3.
  • --enable-pcaptimers Abilita i timer pcap nei binding.
  • --enable-alerts Abilita il supporto agli alert sulle code IPCS.

Queste opzioni possono essere abilitate/disabilitate solo al momento della compilazione nello script configure.

Compilare la libreria Python di AIEngine

Per compilare la libreria Python sono consigliati anche boost-python3-devel o boost-python-devel e python-devel.

La prima opzione per compilare la libreria è usare l'ottimizzazione di compilazione O3; questo genererà una libreria di piccole dimensioni

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 libreria di dimensioni maggiori 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
$ python3.6 setup.py build_ext -i 
$ python3.6 pyai_test.py

La libreria Python contiene tutte le funzionalità fornite dal motore.

Compilare la libreria Ruby di AIEngine

Per compilare in Ruby sono necessari swig e ruby-devel.

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

La libreria Ruby non fornisce tutte le funzionalità del motore.

Compilare la libreria Java di AIEngine

Per compilare in Java è necessario il pacchetto java devel.

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

La libreria Java fornisce alcune delle funzionalità del motore, con alcune eccezioni.

Compilare la libreria Lua di AIEngine

Per compilare in Lua con swig è necessario il pacchetto lua-devel.

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

La libreria Lua fornisce la maggior parte delle funzionalità del motore.

Compilare la libreria Go di AIEngine

Per compilare in Go è necessario swig.

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

La libreria Go ha alcune restrizioni funzionali dovute alla natura del linguaggio.

Confronto con altri sistemi

Puoi trovare una descrizione completa dei diversi casi d'uso con i NIDS più comuni su http://aiengine.readthedocs.io/en/latest/aiengine.html#performance-with-other-engines

Contribuire ad AIEngine

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

Scarica il codice sorgente di AIEngine con

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

Se sei interessato a una funzionalità specifica, vuoi promuovere il progetto o hai semplicemente bisogno di aiuto, scrivimi un'email. I contributi sono sempre utili.

Sviluppare nuove funzionalità

AIEngine è stato sviluppato usando lo sviluppo test-driven. Quindi, per mantenere lo stesso ciclo di vita, la nuova funzionalità dovrebbe avere unit test nella directory creata per la nuova funzionalità e, per integrarsi con l'intero sistema, successivamente integrarsi con il file principale tests.cc nella directory /src

Se hai un caso d'uso che non è coperto dagli esempi forniti, non esitare a contattarmi.

Donazioni

Se il progetto ti piace, puoi offrirmi delle birre con bitcoin :)

root@kitploit:~
3DG7FhkFUuKq7VhfXdP9QpsUzfWPXu49ng
Scarica lo strumento