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.

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: