AIEngine (Motor de Inteligencia Artificial)

AIEngine es un motor de sistema de detección de intrusiones en red de nueva generación, interactivo/programable en Python/Ruby/Java/Lua y Go, con capacidades de aprendizaje sin intervención humana, clasificación de dominios DNS, detección de spam, recolector de red, análisis forense de red y muchas otras.

AIEngine también ayuda a los profesionales de redes/seguridad a identificar el tráfico y desarrollar firmas para usarlas en NIDS, cortafuegos, clasificadores de tráfico, etc.

Las principales funcionalidades de AIEngine son:

• Soporte para interactuar/programar con el usuario mientras el motor está en ejecución.
• Soporte para PCRE JIT para la coincidencia de expresiones regulares.
• Soporte para grafos de expresiones regulares (patrones complejos de detección).
• Soporte para seis tipos de NetworkStacks (lan, mobile, lan6, virtual, oflow y mobile6).
• Soporte para conjuntos (Sets) y filtros Bloom para búsquedas de IP.
• Soporta arquitecturas x86_64, ARM y MIPS en sistemas operativos como Linux, FreeBSD y MacOS.
• Soporte para coincidencia de dominios HTTP, DNS y SSL.
• Soporte para dominios y hosts prohibidos para HTTP, DNS, SMTP y SSL.
• Análisis de frecuencias para tráfico desconocido y generación automática de expresiones regulares.
• Generación de firmas Yara.
• Fácil integración con bases de datos (MySQL, Redis, Cassandra, Hadoop, etc...) para correlación de datos.
• Fácil integración con otros motores de paquetes (Netfilter).
• Soporte para limpiar cachés de memoria para actualizar la información almacenada en memoria.
• Soporte para detectar DDoS en la capa de red/aplicación.
• Soporte para rechazar conexiones TCP/UDP.
• Soporte para análisis forense de red en tiempo real.
• Soporte para firmas TLS JA3 en SSL.
• Soporta protocolos como 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.
• Integración de un servidor HTTP para recuperar y configurar el sistema en tiempo real.

Consulta la carpeta docs para más información

Usando AIEngine

Para usar AIEngine (versión reducida) solo ejecuta el binario aiengine o usa el binding de 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.

Tipos de NetworkStack

AIEngine soporta seis tipos de stacks de red dependiendo de la topología de red.

• StackLan (lan) Red de área local basada en IPv4.

• StackLanIPv6 (lan6) Red de área local con soporte IPv6.

• StackMobile (mobile) Red móvil (interfaz Gn) para IPv4.

• StackVirtual (virtual) Stack para entornos virtuales/nube con VxLan y GRE Transparente.

• StackOpenFlow (oflow) Stack para entornos OpenFlow.

• StackMobileIPv6 (mobile6) Red móvil (interfaz Gn) para IPv6.

Integrar/Programar AIEngine con otros sistemas

AIEngine es también un módulo de python/ruby/java/lua que permite ser más flexible en cuanto a la integración con otros sistemas y funcionalidades. Los principales objetos que el módulo python proporciona/exporta son los siguientes.