En detalle, las etiquetas funcionan de la siguiente manera:

- `<petabi_rules> </petabi_rules>`: Define todas las reglas para este archivo
  de reglas. Solo debe haber un conjunto de estas etiquetas que abran y
  cierren todos los flujos de tráfico designados.
    - `<rule > </rule>`: Designa una sola regla. Una sola regla puede generar
      un número arbitrario de flujos de tráfico o paquetes. Puede tener cualquier
      cantidad de reglas en un solo archivo.
        - Opciones:
            - name: El nombre de esta regla. Principalmente para documentación, sin
              función real.
        - `<traffic_stream> </traffic_stream>`: Un flujo de tráfico define el tráfico
          entre dos puntos finales. Todos los paquetes designados dentro de un mismo
          flujo de tráfico compartirán los mismos puntos finales. Se puede designar
          cualquier número de flujos de tráfico para una regla determinada. Diferentes
          flujos de tráfico dentro de la misma regla pueden tener o no diferentes
          puntos finales dependiendo de la configuración a continuación.
            - Opciones:
                - typets: Especifica qué tipo de flujo de tráfico usaremos para
                  generar paquetes. Actualmente, tenemos Standard, ScanAttack y
                  BackgroundTraffic.
                - scantype: 1==Syn scan (predeterminado) 2 == Connection scan.
                  Se utiliza con ScanAttack.
                - target: Especifica la dirección IP de destino para el ataque de escaneo.
                - targetports: Para un ataque de escaneo. Proporciona una lista
                  separada por comas de puertos posibles, o un único puerto de inicio.
                  De lo contrario, los puertos se escanearán al azar. Si se proporciona
                  un único puerto de inicio, los puertos se escanearán en orden desde
                  ese punto hasta 65535, después de lo cual volverá al punto de inicio.
                  Esta opción se usa junto con typets 'ScanAttack'.
                - srcport: Especifica el puerto de origen para el ataque de escaneo.
                  Aleatorio por defecto.
                - duration: La ventana, o duración, en segundos de un ataque de escaneo
                  si typets es 'ScanAttack'.
                - intensity: Intensidad del ataque de escaneo si typets es 'ScanAttack'.
                - offset: Desplazamiento antes de iniciar un ataque de escaneo.
                  También se usa al insertar múltiples escaneos en el tráfico.
                - replychance: Probabilidad de que un escaneo tenga una respuesta.
                  En otras palabras, probabilidad de que el puerto de destino esté abierto
                  (predeterminado 20%). Se utiliza con ScanAttack.
                - proto: Designa el protocolo de este flujo de tráfico.
                  Debe ser TCP o UDP o ICMP (no probado).
                - src: Dirección IP de origen. Puede ser una dirección en formato
                  xxx.xxx.xxx.xxx, $EXTERNAL_NET (para una dirección externa--asume que
                  se ha designado una red doméstica), $HOME_NET, o any (selecciona
                  aleatoriamente una dirección IP).
                - dst: Dirección IP de destino. Igual que la dirección IP de origen.
                - sport: Puerto de origen (asume TCP o UDP). Puede usar el formato
                  de puerto de Snort que puede ser una lista separada por comas entre
                  corchetes (p. ej., [80,88,89]), un rango (p. ej., [10:1000]), o any
                  (p. ej., selección aleatoria de 0-65535).
                - dport: Puerto de destino según sport.
                - handshake: Generará un handshake TCP al inicio del flujo.
                  Si se omite, no habrá handshake. Los valores válidos son true o false.
                  El valor predeterminado es false.
                - latency: Establece la latencia promedio entre paquetes (en microsegundos).
                - teardown: Cerrará el flujo cuando todo el tráfico haya sido enviado
                  agregando el teardown TCP al final del flujo de tráfico.
                  Los valores válidos son true o false. El valor predeterminado es false.
                - synch: Los flujos de tráfico son síncronos o no. Cuando es true, un
                  flujo de tráfico debe terminar antes de que comience el siguiente.
                  Cuando es false, todos los flujos contiguos que sean false
                  (es decir, asíncronos) se ejecutarán al mismo tiempo.
                - tcp_overlap: El valor predeterminado es false. Cuando es true, a
                  partir del segundo paquete se agregará un contenido extra y el número
                  de secuencia TCP se reducirá en uno para simular la superposición
                  de números de secuencia TCP.
                - ipv: Designa IPv4 o IPv6. Las opciones válidas son 4 o 6.
                  El valor predeterminado es 4.
                - out_of_order: Hace que los paquetes lleguen fuera de orden de
                  manera aleatoria. Nota: esto solo funciona con paquetes que usan
                  la opción 'times'. Además, esta opción debe usarse con ack para
                  que aparezcan los acks duplicados adecuados en el rastro de tráfico.
                  Los valores válidos son true o false. El valor predeterminado es false.
                - out_of_order_prob: Establece la probabilidad de que los paquetes
                  lleguen fuera de orden. Por ejemplo, 10 significaría que hay un 10%
                  de probabilidad de que cada paquete llegue fuera de orden. Los
                  paquetes fuera de orden llegan después de todos los paquetes en orden.
                  Además, se mezclan aleatoriamente. Por lo tanto, si los primeros
                  paquetes 2 y 5 de 10 paquetes se determinan como fuera de orden,
                  llegarán al final de los 10 paquetes (posiciones 9 y 10) y estarán
                  en un orden arbitrario (es decir, el 5 puede llegar antes que el 2
                  o viceversa). El valor debe estar entre 1 y 99. El valor
                  predeterminado es 50.
                - packet_loss: Hace que los paquetes se pierdan aleatoriamente
                  (es decir, que no lleguen). Esto solo funciona con la opción 'times'.
                  Además, esta opción debe usarse con la opción ack establecida en
                  true para que aparezcan acks duplicados en el rastro de tráfico.
                  Los valores válidos son 1 a 99, que representan la probabilidad de
                  que un paquete se pierda. Nota: la pérdida de paquetes solo ocurre
                  en paquetes con datos, no en los acks.
                - ack: Hace que cada paquete de datos en este flujo sea seguido por
                  un ACK del servidor. Los valores válidos son true o false.
                  El valor predeterminado es false.
                - percentage: Esto solo aplica para BackgroundTraffic y debe haber
                  solo una regla de BackgroundTraffic en un archivo o directorio de
                  reglas. El porcentaje indica el porcentaje del flujo de tráfico de
                  fondo que se creará en el flujo de tráfico total.
                - http: Distribución porcentual de protocolos de aplicación http en
                  el flujo de tráfico de fondo.
                - ftp: Distribución porcentual de protocolos de aplicación ftp en
                  el flujo de tráfico de fondo.
                - pop: Distribución porcentual de protocolos de aplicación pop en
                  el flujo de tráfico de fondo.
                - smtp: Distribución porcentual de protocolos de aplicación smtp en
                  el flujo de tráfico de fondo.
                - imap: Distribución porcentual de protocolos de aplicación imap en
                  el flujo de tráfico de fondo.
            - `<pkt > </pkt>`: Esta directiva designa ya sea un paquete individual
              o una serie de paquetes. La función 'times' se puede usar para que una
              sola directiva <pkt> </pkt> genere varios paquetes. De lo contrario, es
              necesario designar explícitamente cada paquete en cada dirección.
                - Opciones:
                    - dir: La dirección del paquete. Los valores válidos son to server
                      o to client. La IP src inicial se considera el cliente, y la
                      IP dst inicial el servidor. Por lo tanto, 'to server' envía un
                      paquete del cliente al servidor y 'to client' envía un paquete
                      del servidor al cliente. El valor predeterminado es to server.
                    - content: Expresión regular que designa el contenido de este
                      paquete. El tamaño del paquete dependerá de la expresión regular.
                    - fragment: Si fragmentar o no este paquete.
                      Solo funciona con ipv4. Debe tener un valor mayor que 2.
                      Creará tantos fragmentos como sean válidos o como se designen
                      (el que sea menor). El valor predeterminado es 0, lo que significa
                      sin fragmentos.
                    - ack: Enviar un ack a este paquete o no. Los valores válidos son
                      true o false. El valor predeterminado es false.
                    - split: Divide el contenido entre el número designado de
                      paquetes. Por defecto, todo el contenido se envía en un solo
                      paquete (los fragmentos son una pequeña excepción a esta regla).
                    - times: Envía este paquete x veces. El valor predeterminado es 1.
                      Un valor positivo enviará exactamente x paquetes (posiblemente
                      con acks si ack es true), mientras que un número negativo enviará
                      un número aleatorio de paquetes entre 1 y abs(-x).
                    - ttl: Establece el valor time to live para el paquete. Por defecto,
                      sniffles generará un valor TTL aleatorio.
                    - ttl_expiry: Simula el ataque de expiración TTL dividiendo los
                      paquetes en múltiples paquetes con un paquete malicioso entre
                      dos paquetes buenos. Por defecto, el valor es 0 (sin paquete
                      malicioso). Si el valor es distinto de cero, insertará un paquete
                      malicioso con este ttl igual al valor de ttl_expiry. Si se
                      establece el valor ttl, el paquete bueno se establecerá con el
                      nuevo valor ttl.

Notas finales: El nuevo formato de reglas es solo un comienzo y puede contener problemas.
Por favor, avíseme de cualquier inconsistencia o error. Además, la intención es
expandir las opciones para proporcionar cada vez más funcionalidad según sea necesario.
Por favor, contácteme con las funciones deseadas. Finalmente, este producto se
proporciona tal cual. No hay garantía de funcionalidad o precisión.
Siéntase libre de bifurcar este proyecto para satisfacer sus propias necesidades.

Créditos:
--------

Esta aplicación ha sido traída a usted por Petabi, Inc., donde hacemos
soluciones de seguridad confiables, realistas y realmente rápidas.

Autores:

- Victor C. Valgenti
- Min Sik Kim
- Tu Le
- Moosuk Pyun

Nuevas Características:
-----------------------

- 21/11/2014: Versión 1.4.0. Se agregó división de tráfico y traffobot para
   generación de tráfico bidireccional. Se corrigió un error donde se lanzaba
   una excepción cuando la cantidad de tráfico generado cabía en una sola
   llamada de escritura de tráfico. Se reformateó y habilitó el uso. Finalmente,
   se agregaron pruebas unitarias para traffobot y análisis XML.

- 03/02/2015: Versión 2.0. Se reescribió completamente cómo funcionan los flujos para reducir
   los requisitos de memoria al generar grandes flujos usando reglas especiales. Actualmente,
   puede manejar alrededor de 2-3 millones de flujos concurrentes antes de que las cosas se ralenticen.
   He agregado algunas características para ayudar al crear grandes flujos. Primero,
   genere con algo como una concurrencia de 2-3 millones de flujos. Además, no use
   teardown para estos flujos. Una fracción de los flujos durará desde el inicio
   hasta el final de la captura, mientras que el resto se cerrará cada
   período de lote. Trabajaré para hacer esto más eficiente, pero gestionar
   todas las opciones complejas en Sniffles ahora no se puede hacer de manera económica en
   memoria. La única otra solución es obtener una máquina más potente con más RAM.
   Esta versión también contiene una variedad de correcciones.

- 11/02/2015: Se agregó probabilidad a los paquetes fuera de orden para permitir ajustar
   la frecuencia de los paquetes fuera de orden.

- 05/03/2015: Se cambió el teardown TCP a la secuencia de teardown estándar.
   Ahora se permite que el contenido se distribuya en múltiples paquetes sin usar fragmentos.

- 09/04/2015: Se corrigió el tráfico de escaneo, que estaba parcialmente roto durante uno de los
   cambios anteriores. La marca de tiempo de inicio de pcap ahora por defecto es la hora actual y se
   puede establecer con la opción -g. Finalmente, el tercer paquete en el handshake TCP de 3 vías
   ahora contendrá datos si el cliente debe enviar datos primero.

- 22/05/2015: Se reescribió el análisis de reglas para simplificar la capacidad de extender el
   analizador de reglas para admitir más formatos. Se incorporó la navegación nfa y
   pcre directamente en sniffles. Se limpió el código y se preparó para el
   público.

- 27/05/2015: Se actualizó la documentación, se fusionaron las bibliotecas pcre y
   la construcción nfa para hacer de sniffles un paquete autónomo.
   Se agregaron el Generador de Expresiones Regulares y el Generador de Reglas Aleatorias como
   parte del paquete Sniffles. Se actualizó la versión a 3.0.0
   y se publicó en github.

- 12/08/2015: Se implementaron una gran cantidad de correcciones de errores y nuevas
   características. Se cambió fundamentalmente cómo se manejan los flujos y las corrientes
   para permitir una mejor extensibilidad. Se agregó latencia por
   flujo. Se actualizó la documentación.

Generador de Expresiones Regulares
==================================

Este es un generador simple de expresiones regulares.
Crea expresiones regulares completamente al azar, o
basado en una serie de distribuciones.
Los controles que se pueden aplicar sobre cómo se generan las expresiones
regulares son estructurales más que contextuales. En otras palabras,
no hay esfuerzo para que ciertos tokens de cadena aparezcan en
las expresiones regulares generadas. Sin embargo, las distribuciones
de probabilidad se pueden ajustar para afectar los tipos de características
que se encuentran en las reglas, como clases de caracteres, alternancia, repetición, etc.

Instalación
-----------

Se instalará automáticamente con el resto de Sniffles.

Opciones
--------

regexgen--Generador aleatorio de expresiones regulares.

    uso: regexgen [-C distribución de caracteres] [-c número de regex]
    [-D distribución de clases] [-f archivo de salida re]
    [-l lambda para generación de longitud] [-M longitud máxima de regex]
    [-m longitud mínima de regex] [-n probabilidad de negación]
    [-o probabilidad de opciones] [-R probabilidad de repetición] [-r distribución de repetición]
    [-t distribución de tipo estructural re] [-?] [-g]

-    -C Distribución de caracteres: Establece la posibilidad de ver
    caracteres o tipos de caracteres particulares. Vea una breve explicación de
    distribuciones a continuación para ejemplos de cómo usar esto. Por defecto
    esta distribución es una distribución igual. Esta distribución
    tiene cinco ranuras: Caracteres ASCII, Caracteres binarios en formato \x00,
    Letras alfabéticas (mayúsculas o minúsculas), Dígitos y clases
    de sustitución (como \w). Un ejemplo de entrada sería "10,20,10,40,20"
    lo que significaría 10% de probabilidad de que cualquier carácter generado provenga de 10% ASCII,
    20% binario, 10% letras, etc. Una advertencia es que los caracteres ASCII que
    podrían causar problemas con expresiones regulares (como `[' o '{')
    se convierten a representación hexadecimal (\x3b por ejemplo).
-    -c Número de expresiones regulares a generar. El valor predeterminado es uno.
-    -D Distribución de clases: Solo hay dos ranuras en la distribución
    de clases. La primera ranura es la probabilidad de que la clase esté
    compuesta por un número de caracteres generados aleatoriamente. La
    segunda ranura es la probabilidad de que la clase esté compuesta por
    rangos (como a-z).
-    -f Nombre del archivo de salida. Establece el nombre del archivo donde se
    almacenan las expresiones regulares. El valor predeterminado es un archivo
    llamado rand.re en el directorio de trabajo actual.
-    -g Grupos: Todas las expresiones regulares tendrán un prefijo común con
    al menos una o más expresiones regulares (siempre que haya más de una
    regex). Un prefijo común es simplemente una expresión regular que es la
    misma para algún conjunto de expresiones regulares. El número total de
    prefijos comunes posibles es de 1 a la mitad del tamaño total de las
    expresiones regulares a generar. El valor predeterminado para esta opción
    es false. Esta opción no toma parámetros.
-    -l Lambda para longitud: Esta es la longitud media para una distribución
    exponencial de longitudes de expresiones regulares. El valor predeterminado es 10.
-    -M Longitud máxima de regex: hacer que las expresiones regulares tengan como máximo esta
    longitud estructural o más corta. Por defecto, la longitud máxima no está limitada.
-    -m Longitud mínima de regex: hacer que las expresiones regulares tengan al menos esta
    longitud o más larga. El valor predeterminado es 3, y automáticamente usará un valor de 1
    si la entrada es cero o menos.
-    -n Probabilidad de negación: La probabilidad de que una clase de caracteres sea
    una clase de negación ([^xyz]) en lugar de una clase de caracteres normal ([xyz]).
    La probabilidad predeterminada es 50%.
-    -o Probabilidad de opción: Esta es la probabilidad de que se agregue una opción
    a la expresión regular. Las opciones actuales son 'i', 'm' y 's'.
    Se agrega un número aleatorio de opciones a la lista con esas opciones
    elegidas mediante una distribución uniforme.
-    -R Probabilidad de repetición: La probabilidad de que ocurra una repetición
    después de que se haya agregado cualquier componente estructural a la expresión regular.
-    -r Distribución de repetición: La distribución de estructuras de repetición.
    Las ranuras son: Cero a uno (?), Cero a muchos (*), uno a muchos (+), y
    conteo ({x,y}).
-    -t Distribución de tipo estructural Re: La distribución para los
    componentes estructurales principales de la expresión regular. Estos
    comprenden tres ranuras o categorías: caracteres, clases y alternancia.
    Nota: la alternancia simplemente generará una expresión regular más pequeña
    hasta el tamaño de la longitud restante de la re. En otras palabras,
    la alternancia dará como resultado que varias expresiones regulares más pequeñas
    se unan en la expresión regular general. La alternancia utiliza la misma
    metodología exacta para crear esas expresiones regulares más pequeñas.
-   -? Imprime esta ayuda.

    Este generador creará expresiones regulares aleatorias. Es posible
    ajustar las estructuras dentro de las expresiones regulares a una distribución
    de probabilidad, pero actualmente no el contenido. Esto es deseable para
    explorar la máxima diversidad en expresiones regulares posibles
    (aunque no necesariamente expresiones regulares realistas).
    Las distribuciones se manejan creando una lista de probabilidades para
    las diversas posibilidades, o ranuras, para una distribución particular.
    Estas se agregan como argumentos de línea de comandos usando una lista de
    cadenas simple como: "10,30,40,20". La lista debe tener tantos valores
    como ranuras tenga. El total de todos los valores en la lista debe ser
    100 y no debe haber fracciones. El valor en cada ranura es la probabilidad
    de que esa ranura sea elegida. Por ejemplo, la distribución de tipo
    estructural RE base tiene tres ranuras. La primera ranura es la probabilidad
    de que el siguiente tipo de estructura sea un carácter (donde un carácter
    puede ser una letra, dígito, binario, ASCII o clase de sustitución (como \w)).
    La segunda ranura es para clases de caracteres como [ab@%], [^123] o [a-z].
    La ranura final es la probabilidad de que ocurra alternancia como (ab|cd).
    Con estas tres ranuras puede ajustar con qué frecuencia desea que aparezcan
    las estructuras en sus expresiones regulares. Por ejemplo, regexgen -c 10
    -t "80,10,10" crearía 10 expresiones regulares donde el 80% de las estructuras
    utilizadas serían caracteres, el 10 por ciento serían clases de caracteres y
    el 10% alternancia.

Generador de Reglas Aleatorias
==============================

El Generador de Reglas Aleatorias proporciona un medio para crear una cantidad de reglas
generadas aleatoriamente con las cuales probar una plataforma particular. Actualmente,
las reglas generadas cumplen con el formato de reglas de Snort o son solo líneas
de texto. Para que el Generador de Reglas Aleatorias funcione, debe tener
un conjunto de características definidas. Se pueden encontrar características de
ejemplo en la carpeta example_features y se describen más a continuación.

Instalación
-----------

Se instala automáticamente con Sniffles

Nota: El Generador de Reglas Aleatorias hace uso del
Generador de Expresiones Regulares Aleatorias para crear contenido de cualquier tipo.Opciones
-------

Generador de Reglas Aleatorias

usage: rulegen -c [número de reglas] -f [conjunto de características]
        -o [archivo de salida] [-s]

- -c  Número de reglas: La cantidad de reglas a generar.
      El valor predeterminado es uno.
- -f  Conjunto de características: El archivo que contiene la descripción del conjunto de características.
      Consulte la documentación para obtener una explicación más detallada de
      los conjuntos de características y cómo describirlos.
- -o  Archivo de salida: archivo de salida en el que se escriben las reglas.
      El valor predeterminado es rules.txt
- -s  Formato de regla Snort: escribe las reglas en un formato de regla Snort.
      Sin parámetros, por defecto está desactivado. Cuando está desactivado, las reglas se
      convierten a un formato de cadena, cualquiera que sea según el
      analizador de características.

Conjunto de Características
-----------

Las características se utilizan para describir aspectos potenciales de las reglas utilizadas en
IDS. Por ejemplo, un filtro de paquetes podría utilizar reglas que tengan como objetivo
la dirección IP de origen y destino. En ese caso, sería posible
crear un conjunto de características que describa cómo se deben generar esas direcciones IP de origen y destino. Más específicamente, hacemos la
distinción entre reglas simples y reglas complejas. La diferencia
entre estas dos es la presencia de notaciones ambiguas. Por
ejemplo, si tuviéramos una notación ambigua de * para significar cualquier
dirección IP, entonces podríamos decir que * representa una notación ambigua.
Además, sabemos que una regla también puede usar una notación no ambigua,
como 192.168.1.1. Eso representaría una dirección IP simple, ya que
es una única dirección IP fija sin ninguna notación ambigua posible.
Luego definimos además el rango de las características particulares
(es decir, direcciones IP en los más de 4 mil millones de
posibles direcciones IPv4, o solo un subconjunto de eso).

Las características definen, en última instancia, todos los aspectos de una
regla arbitraria. Dado un conjunto de características y un formato de regla válido,
es posible generar aleatoriamente un número arbitrario
de reglas que utilicen esas características. De esta manera, es posible
generar conjuntos de reglas de prueba que examinarán el IDS a lo largo de un
vector que a menudo se pasa por alto.

Las características se definen en una lista separada por punto y coma, una característica por línea:
type=feature; lista de argumentos en pares key=value, listas usando formato de Python
(es decir, [a, ..., z]). Las características definen porciones específicas de un
formato de regla objetivo. Las características se pueden extender para agregar más funcionalidad.
Opcionalmente, se puede extender la capacidad de las características creando un nuevo
formato de regla.

Tipos de características actuales:

1. Feature — característica genérica
2. Content — Característica de contenido
3. IP — Característica de IP
4. Protocol — Característica de protocolo

Las listas ambiguas deben escribirse como listas como [x:y]
para un rango, [x,y] para una lista, {x1,x2,x3} para un conjunto
o simplemente * para un comodín o una opción única similar.

Ejemplo sobre lista ambigua:```
ambiguity_list=[[2:9]]
it will generate [3:4], [5:6], etc (any [x:y] such that
x <= y and x >= 2 and y > x and y <= 9).

ambiguity_list=[[3,20]]
it will generate [3,9,10], [3,4,8,12], etc (any list [x1,x2,x3,..]
such that all values falling between 3 and 20.

ambiguity_list=[{5,6,10}]
it will generate a subset of {5,6,10} such as {5,10}, {5}.

ambiguity_list=[[2:9],[3,20],{5,6,11}]
it will pick one of [2:9], [3,20], and {5,6,11} and
generate a corresponding instance (see above)

lo anterior define dos características: una característica de protocolo y una característica de IP de origen. El protocolo se llama proto, que es importante solo para el formateador de reglas, y los protocolos válidos son: IP, TCP, UDP e ICMP. La característica IP se define como IPv4 y todas las reglas serán complejas. La complejidad de IP ya es parte de la clase y no es necesario agregarla en la definición de la característica. Esto creará direcciones IP usando notación CIDR.

Atributos genéricos de característica:

- Feature_name: Atributo informativo, potencialmente valioso para el formateador de reglas.
- lower_bound: El límite inferior de valores posibles. Asume que la característica es un número.
- upper_bound: Opuesto a lower_bound.
- complexity_prob: La probabilidad de usar características complejas para una regla. De 0 a 100. Por defecto 0. Cuando se usan características complejas, se selecciona aleatoriamente una notación ambigua de la lista de ambigüedad, o si la característica define una ambigüedad específica (como direcciones IP), entonces se usa esa. Cuando no se usan características complejas, se genera un valor usando los límites, o, en el caso de Content, usando un conjunto de valores de distribución que restringirán la cadena generada a una serie de caracteres ASCII.
- ambiguity_list: Una lista de posibles notaciones ambiguas. Lista separada por comas usando formato de Python (es decir, [a, b, c]).
- toString(): Imprime una instancia de una regla dado este conjunto de características particular.

Content Feature — Hereda de Feature:
- regex: Verdadero o Falso. Si es Verdadero, usará formato PCRE para expresiones regulares y también posiblemente agregará las opciones i, s o m a la expresión regular.
- length: Define la longitud promedio del contenido generado.
- min_regex_length: Define la longitud mínima de la expresión regular.

Protocol Feature — Hereda de Feature:
- proto_list: Define la lista de protocolos posibles, como una lista separada por comas (es decir, [TCP, UDP]).

IP Feature — Hereda de Feature:
- version: 4 para IP versión 4, 6 para IP versión 6. Por defecto versión 4.

Notación ambigua para rangos, listas, conjuntos:

Notación de rango:
  [x:y] significa de x a y (inclusive).

Notación de lista:
  [x,y] significa una lista de un número determinado aleatoriamente de valores donde cada valor es mayor o igual que x y menor o igual que y.

Notación de conjunto:
  {x1,x2,x3,x4} significa un conjunto de valores x1, x2, x3, x4. Generará un subconjunto del conjunto original.

Consulte los conjuntos de características de ejemplo en la carpeta example_features para más ejemplos. Más detalles, así como la teoría académica detrás de esto, están programados para agregarse más adelante.