En détail, les balises fonctionnent comme suit :

- `<petabi_rules> </petabi_rules>` : Cela définit toutes les règles pour ce fichier de règles. Il ne devrait y avoir qu'un seul jeu de ces balises ouvrant et fermant tous les flux de trafic désignés.
    - `<rule > </rule>` : Désigne une règle unique. Une règle unique peut générer un nombre arbitraire de flux de trafic ou de paquets. Peut avoir n'importe quel nombre de règles dans un même fichier.
        - Options :
            - name : Le nom de cette règle. Principalement pour la documentation, aucune fonction réelle.
        - `<traffic_stream> </traffic_stream>` : Un flux de trafic définit le trafic entre deux points d'extrémité. Tous les paquets désignés au sein d'un même flux de trafic partageront les mêmes points d'extrémité. Un nombre quelconque de flux de trafic peut être désigné pour une règle donnée. Différents flux de trafic au sein de la même règle peuvent avoir des points d'extrémité différents ou non selon les paramètres ci-dessous.
            - Options :
                - typets : Spécifie le type de flux de trafic que nous utiliserons pour générer des paquets. Actuellement, nous avons Standard, ScanAttack et BackgroundTraffic.
                - scantype : 1 == scan SYN (par défaut) 2 == scan de connexion. Utilisé avec ScanAttack.
                - target : Spécifie l'adresse IP cible pour une attaque de scan.
                - targetports : Pour une attaque de scan. Fournit une liste de ports séparés par des virgules, ou un seul port de départ. Sinon, les ports seront scannés aléatoirement. Si un seul port de départ est fourni, les ports seront scannés dans l'ordre à partir de ce point jusqu'à 65535, après quoi il reviendra au point de départ. Cette option est utilisée conjointement avec typets étant 'ScanAttack'.
                - srcport : Spécifie le port source pour une attaque de scan. Aléatoire par défaut.
                - duration : La fenêtre, ou durée, en secondes d'une attaque de scan si typets est 'ScanAttack'.
                - intensity : Intensité de l'attaque de scan si typets est 'ScanAttack'.
                - offset : Décalage avant de démarrer une attaque de scan. Également utilisé lors de l'insertion de plusieurs scans dans le trafic.
                - replychance : Probabilité qu'un scan ait une réponse. En d'autres termes, probabilité que le port cible soit ouvert (par défaut 20 %). Utilisé avec ScanAttack.
                - proto : Désigne le protocole de ce flux de trafic. Doit être TCP ou UDP ou ICMP (non testé).
                - src : Adresse IP source. Peut être une adresse au format xxx.xxx.xxx.xxx, $EXTERNAL_NET (pour une adresse externe – suppose qu'un réseau domestique a été désigné), $HOME_NET, ou any (sélectionne aléatoirement une adresse IP).
                - dst : Adresse IP de destination. Identique à l'adresse IP source.
                - sport : Port source (suppose TCP ou UDP). Peut utiliser le formatage de port Snort qui peut être une liste séparée par des virgules entre crochets (par exemple [80,88,89]), une plage (par exemple [10:1000]), ou any (c'est-à-dire choix aléatoire entre 0 et 65535).
                - dport : Port de destination comme pour sport.
                - handshake : Génère un handshake TCP au début du flux. Si exclu, il n'y aura pas de handshake. Les valeurs valides sont true ou false. Par défaut false.
                - latency : Définit la latence moyenne entre les paquets (en microsecondes).
                - teardown : Ferme le flux lorsque tout le trafic a été envoyé en ajoutant la déconnexion TCP à la fin du flux de trafic. Les valeurs valides sont true ou false. Par défaut false.
                - synch : Les flux de trafic sont synchrones ou non. Lorsque true, un flux de trafic doit se terminer avant que le suivant ne commence. Lorsque false, tous les flux contigus qui sont false (c'est-à-dire asynchrones) s'exécuteront en même temps.
                - tcp_overlap : La valeur par défaut est false. Lorsque true, à partir du deuxième paquet, un contenu supplémentaire sera ajouté et le numéro de séquence TCP sera réduit de un pour simuler un numéro de séquence TCP se chevauchant.
                - ipv : Désigne IPv4 ou IPv6. Les options valides sont 4 ou 6. Par défaut 4.
                - out_of_order : Faire arriver les paquets dans le désordre de manière aléatoire. Notez que cela ne fonctionne qu'avec les paquets utilisant l'option 'times'. De plus, cette option doit également être utilisée avec ack afin que les bons accusés de réception en double apparaissent dans la trace de trafic. Les valeurs valides sont true ou false. Par défaut false.
                - out_of_order_prob : Définit la probabilité que des paquets arrivent dans le désordre. Par exemple, 10 signifierait qu'il y a 10 % de chances que chaque paquet arrive dans le désordre. Les paquets en désordre arrivent après tous les paquets en ordre. De plus, ils sont également mélangés aléatoirement. Ainsi, si les premiers paquets 2 et 5 de 10 paquets sont déterminés comme étant en désordre, ils arriveront en dernier parmi les 10 paquets (emplacements 9 et 10) et seront dans un ordre arbitraire (c'est-à-dire que 5 peut arriver avant 2 ou vice versa). La valeur doit être comprise entre 1 et 99. Par défaut 50.
                - packet_loss : Faire perdre des paquets de manière aléatoire (c'est-à-dire qu'ils n'arrivent pas). Cela ne fonctionne qu'avec l'option 'times'. De plus, cette option doit également être utilisée avec l'option ack définie à true afin que des accusés de réception en double apparaissent dans la trace de trafic. Les valeurs valides sont de 1 à 99 représentant la probabilité qu'un paquet soit perdu. Notez que la perte de paquet ne se produit que sur les paquets contenant des données, pas sur les accusés de réception.
                - ack : Faire en sorte que chaque paquet de données de ce flux soit suivi d'un ACK du serveur. Les valeurs valides sont true ou false. Par défaut false.
                - percentage : Cela s'applique uniquement à BackgroundTraffic et il ne doit y avoir qu'une seule règle de BackgroundTraffic dans un fichier de règles ou un répertoire. Le pourcentage indique le pourcentage de flux de trafic de fond à créer dans le flux de trafic total.
                - http : Distribution en pourcentage des protocoles d'application http dans le flux de trafic de fond.
                - ftp : Distribution en pourcentage des protocoles d'application ftp dans le flux de trafic de fond.
                - pop : Distribution en pourcentage des protocoles d'application pop dans le flux de trafic de fond.
                - smtp : Distribution en pourcentage des protocoles d'application smtp dans le flux de trafic de fond.
                - imap : Distribution en pourcentage des protocoles d'application imap dans le flux de trafic de fond.
            - `<pkt > </pkt>` : Cette directive désigne soit un paquet individuel, soit une série de paquets. La fonctionnalité times peut être utilisée pour qu'une directive `<pkt> </pkt>` génère plusieurs paquets. Sinon, il est nécessaire de désigner explicitement chaque paquet dans chaque direction.
                - Options :
                    - dir : La direction du paquet. Les valeurs valides sont to server ou to client. L'IP source initiale est considérée comme le client et l'IP de destination initiale comme le serveur. Ainsi, 'to server' envoie un paquet du client au serveur et 'to client' envoie un paquet du serveur au client. Par défaut to server.
                    - content : Expression régulière désignant le contenu de ce paquet. La taille du paquet dépendra de l'expression régulière.
                    - fragment : Fragmenter ou non ce paquet. Ne fonctionne qu'avec IPv4. Doit avoir une valeur supérieure à 2. Créera autant de fragments que valides ou que désignés (le plus petit des deux). La valeur par défaut est 0, ce qui signifie aucun fragment.
                    - ack : Envoyer un accusé de réception à ce paquet ou non. Les valeurs valides sont true ou false. Par défaut false.
                    - split : Diviser le contenu entre le nombre désigné de paquets. Par défaut, tout le contenu est envoyé dans un seul paquet (les fragments sont une petite exception à cette règle).
                    - times : Envoyer ce paquet x fois. La valeur par défaut est 1, une valeur positive enverra exactement x paquets (éventuellement avec des accusés de réception si ack est true), tandis qu'un nombre négatif enverra un nombre aléatoire de paquets entre 1 et abs(-x).
                    - ttl : Définir la valeur time to live pour le paquet. Par défaut, sniffles générera une valeur TTL aléatoire.
                    - ttl_expiry : Simuler l'attaque d'expiration TTL en divisant les paquets en plusieurs paquets avec un paquet malveillant entre deux bons paquets. Par défaut, la valeur est 0 (aucun paquet malveillant). Si la valeur est non nulle, elle insérera un paquet malveillant avec ce ttl égal à la valeur ttl_expiry. Si la valeur ttl est définie, le bon paquet sera défini avec la nouvelle valeur ttl.

Notes finales : Le nouveau format de règle n'est qu'un début et peut contenir des problèmes. Veuillez me signaler toute incohérence ou erreur. De plus, l'intention est d'étendre les options pour offrir de plus en plus de fonctionnalités selon les besoins. Veuillez me contacter pour les fonctionnalités souhaitées. Enfin, ce produit est fourni tel quel. Il n'y a aucune garantie de fonctionnalité ou d'exactitude. N'hésitez pas à forker ce projet pour répondre à vos propres besoins.

Crédits :
--------

Cette application vous a été apportée par Petabi, Inc. où nous proposons des solutions de sécurité fiables, réalistes et extrêmement rapides.

Auteurs :

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

Nouvelles fonctionnalités :
-------------

- 21/11/2014 : Version 1.4.0 Ajout de la division du trafic et de traffobot pour la génération de trafic bidirectionnel. Correction d'un bug où une exception était levée lorsque la quantité de trafic générée pouvait tenir dans un seul appel d'écriture de trafic. Reformattage et activation de l'utilisation. Enfin, ajout de tests unitaires pour traffobot et l'analyse XML.

- 03/02/2015 : Version 2.0. Réécriture complète du fonctionnement des flux afin de réduire les besoins en mémoire lors de la génération de grands flux à l'aide de règles spéciales. Actuellement, peut gérer environ 2 à 3 millions de flux simultanés avant que les choses ne ralentissent. J'ai ajouté quelques fonctionnalités pour aider lors de la création de grands flux. Premièrement, générez avec une simultanéité d'environ 2 à 3 millions de flux. De plus, n'utilisez pas la déconnexion pour ces flux. Une fraction des flux durera du début à la fin de la capture tandis que le reste sera fermé à chaque période de lot. Je travaillerai à rendre cela plus efficace, mais la gestion de toutes les options complexes dans Sniffles ne peut désormais plus être effectuée à moindre coût en mémoire. La seule autre solution est d'opter pour une machine plus puissante avec plus de RAM. Cette version contient également diverses corrections.

- 11/02/2015 : Ajout d'une probabilité pour les paquets en désordre afin de permettre le réglage de la fréquence des paquets en désordre.

- 05/03/2015 : Modification de la déconnexion TCP en séquence de déconnexion standard. Permet désormais de répartir le contenu sur plusieurs paquets sans utiliser de fragments.

- 09/04/2015 : Correction du trafic de scan, partiellement cassé lors de l'un des changements précédents. L'horodatage de début du pcap est désormais par défaut l'heure actuelle et peut être défini avec l'option -g. Enfin, le 3ème paquet du handshake TCP à 3 voies portera désormais des données si le client doit envoyer des données en premier.

- 22/05/2015 : Réécriture de l'analyse syntaxique des règles pour simplifier la capacité d'étendre l'analyseur de règles afin de prendre en charge davantage de formats. Intégration directe de la traversée NFA et de PCRE dans sniffles. Nettoyage du code et préparation pour le public.

- 27/05/2015 : Mise à jour de la documentation, fusion des bibliothèques PCRE et de la construction NFA pour faire de sniffles un package autonome. Ajout du générateur d'expressions régulières et du générateur de règles aléatoires dans le cadre du package Sniffles. Mise à jour de la version à 3.0.0 et publication sur GitHub.

- 12/08/2015 : Implémentation d'un grand nombre de corrections de bugs et de nouvelles fonctionnalités. Modification fondamentale de la gestion des flux et des flots pour permettre une meilleure extensibilité. Ajout de la latence par flux. Mise à jour de la documentation.

Générateur d'expressions régulières
====================================

Ceci est un simple générateur d'expressions régulières.
Il crée des expressions régulières soit complètement aléatoires, soit basées sur une série de distributions.
Les contrôles qui peuvent être appliqués sur la façon dont les expressions régulières sont générées sont structurels plutôt que contextuels. En d'autres termes, aucun effort n'est fait pour que certains jetons de chaîne apparaissent dans les expressions régulières générées. Cependant, les distributions de probabilité peuvent être ajustées pour affecter les types de fonctionnalités trouvées dans les règles comme les classes de caractères, l'alternance, la répétition, etc.

Installation
-------

Sera installé automatiquement avec le reste de Sniffles.

Options
-------

regexgen—Générateur d'expressions régulières aléatoires.

    usage : regexgen [-C distribution de caractères] [-c nombre d'expressions régulières]
    [-D distribution de classes] [-f fichier de sortie des RE]
    [-l lambda pour la génération de longueur] [-M longueur maximale d'expression régulière]
    [-m longueur minimale d'expression régulière] [-n probabilité de négation]
    [-o probabilité d'options] [-R probabilité de répétition] [-r distribution de répétition]
    [-t distribution de type structurel d'expression régulière] [-?] [-g]

- -C Distribution de caractères : Définit la possibilité de voir des caractères ou types de caractères particuliers. Voir une brève explication des distributions ci-dessous pour des exemples d'utilisation. Par défaut, cette distribution est une distribution égale. Cette distribution comporte cinq emplacements : caractères ASCII, caractères binaires au format \x00, lettres alphabétiques (majuscules ou minuscules), chiffres et classes de substitution (comme \w). Un exemple d'entrée serait « 10,20,10,40,20 », ce qui signifierait 10 % de chances que tout caractère généré provienne de 10 % d'ASCII, 20 % de binaire, 10 % de lettres, etc. Une mise en garde : les caractères ASCII qui pourraient poser problème avec les expressions régulières (comme « [ » ou « { ») sont convertis en représentation hexadécimale (\x3b par exemple).
- -c Nombre d'expressions régulières à générer. Par défaut une.
- -D Distribution de classes : Il n'y a que deux emplacements dans la distribution de classes. Le premier emplacement est la probabilité que la classe soit composée d'un certain nombre de caractères générés aléatoirement. Le second emplacement est la probabilité que la classe soit composée de plages (comme a-z).
- -f Nom du fichier de sortie. Définit le nom du fichier où les expressions régulières sont stockées. Par défaut, un fichier nommé rand.re dans le répertoire de travail courant.
- -g Groupes : Toutes les expressions régulières auront un préfixe commun avec au moins une ou plusieurs autres expressions régulières (tant qu'il y a plus d'une expression). Un préfixe commun est simplement une expression régulière identique pour un certain ensemble d'expressions régulières. Le nombre total de préfixes communs possibles est de 1 à la moitié de la taille totale des expressions régulières à générer. La valeur par défaut de cette option est false. Cette option ne prend pas de paramètres.
- -l Lambda pour la longueur : C'est la longueur moyenne pour une distribution exponentielle des longueurs d'expressions régulières. La valeur par défaut est 10.
- -M Longueur maximale d'expression régulière : les expressions régulières font au maximum cette longueur structurelle ou moins. Par défaut, la longueur maximale n'est pas limitée.
- -m Longueur minimale d'expression régulière : les expressions régulières font au moins cette longueur ou plus. Par défaut 3, et utilisera automatiquement une valeur de 1 si l'entrée est nulle ou inférieure.
- -n Probabilité de négation : probabilité qu'une classe de caractères soit une classe de négation ([^xyz]) plutôt qu'une classe de caractères normale ([xyz]). Probabilité par défaut de 50 %.
- -o Probabilité d'option : probabilité qu'une option soit ajoutée à l'expression régulière. Les options actuelles sont « i », « m » et « s ». Un nombre aléatoire d'options est ajouté à la liste, ces options étant choisies via une distribution uniforme.
- -R Probabilité de répétition : probabilité qu'une répétition se produise après l'ajout d'un composant structurel à l'expression régulière.
- -r Distribution de répétition : distribution des structures de répétition. Les emplacements sont : zéro à un (?), zéro à plusieurs (*), un à plusieurs (+), et comptage ({x,y}).
- -t Distribution de type structurel d'expression régulière : distribution pour les composants structurels principaux de l'expression régulière. Ceux-ci sont composés de trois emplacements, ou catégories : caractères, classes et alternance. Notez que l'alternance générera simplement une expression régulière plus petite jusqu'à la taille restante de l'expression. En d'autres termes, l'alternance entraînera la jonction de plusieurs expressions régulières plus petites dans l'expression régulière globale. L'alternance utilise exactement la même méthodologie pour créer ces expressions régulières plus petites.
- -? Affiche cette aide.

    Ce générateur créera des expressions régulières aléatoires. Il est possible d'ajuster les structures au sein des expressions régulières selon une distribution de probabilité, mais pas actuellement le contenu. Cela est souhaitable afin d'explorer la diversité maximale des expressions régulières possibles (bien que pas nécessairement réalistes). Les distributions sont gérées en créant une liste de probabilités pour les diverses possibilités, ou emplacements, d'une distribution particulière. Celles-ci sont ajoutées comme arguments de ligne de commande en utilisant une simple liste de chaînes comme : « 10,30,40,20 ». La liste doit avoir autant de valeurs qu'il y a d'emplacements. Le total de toutes les valeurs dans la liste doit être 100 et il ne doit pas y avoir de fractions. La valeur de chaque emplacement est la probabilité que cet emplacement soit choisi. Par exemple, la distribution de type structurel de base des RE a trois emplacements. Le premier emplacement est la probabilité que le prochain type de structure soit un caractère (où un caractère peut être une lettre, un chiffre, un binaire, un ASCII ou une classe de substitution (comme \w)). Le second emplacement est pour les classes de caractères comme [ab@%], [^123] ou [a-z]. Le dernier emplacement est la probabilité d'alternance comme (ab|cd). Avec ces trois emplacements, vous pouvez ajuster la fréquence à laquelle vous souhaitez que les structures apparaissent dans vos expressions régulières. Par exemple, regexgen -c 10 -t « 80,10,10 » créerait 10 expressions régulières où 80 % des structures utilisées seraient des caractères, 10 % des classes de caractères et 10 % d'alternance.

Générateur de règles aléatoires
=====================================

Le générateur de règles aléatoires offre un moyen de créer un certain nombre de règles générées aléatoirement pour tester une plateforme particulière. Actuellement, les règles générées respectent soit le format de règle Snort, soit sont simplement des lignes de texte. Pour que le générateur de règles aléatoires fonctionne, vous devez disposer d'un ensemble de fonctionnalités définies. Des exemples de fonctionnalités se trouvent dans le dossier example_features et sont décrits plus en détail ci-dessous.

Installation
-------

Installé automatiquement avec Sniffles.

Remarque : Le générateur de règles aléatoires utilise le générateur d'expressions régulières aléatoires pour créer du contenu de toute nature.Options
-------

Générateur de règles aléatoires

usage: rulegen -c [number of rules] -f [feature set]
        -o [outfile] [-s]

- -c  Nombre de règles : Le nombre de règles à générer.
      Par défaut, une.
- -f  Ensemble de fonctionnalités : Le fichier contenant la description de l'ensemble de fonctionnalités.
      Veuillez consulter la documentation pour plus d'explications sur
      les ensembles de fonctionnalités et la façon de les décrire.
- -o  Fichier de sortie : fichier de sortie dans lequel les règles sont écrites.
      Par défaut, rules.txt
- -s  Format de règle Snort : écrire les règles au format de règle Snort.
      Aucun paramètre, par défaut désactivé. Lorsqu'il est désactivé, les règles sont simplement
      converties en un format de chaîne, quel qu'il soit, basé sur
      l'analyseur de fonctionnalités.

Ensemble de fonctionnalités
-----------

Les fonctionnalités sont utilisées pour décrire les aspects potentiels des règles utilisées dans les IDS. Par exemple, un filtre de paquets pourrait utiliser des règles qui ciblent l'adresse IP source et destination. Dans ce cas, il serait possible de créer un ensemble de fonctionnalités décrivant comment ces adresses IP source et destination devraient être générées. Plus précisément, nous faisons la distinction entre les règles simples et les règles complexes. La différence entre les deux est la présence de notations ambiguës. Par exemple, si nous possédions une notation ambiguë de * pour signifier n'importe quelle adresse IP, alors nous pourrions dire que * représente une notation ambiguë. De plus, nous savons qu'une règle peut également utiliser une notation non ambiguë, comme 192.168.1.1. Cela représenterait une adresse IP simple car c'est une adresse IP fixe unique sans aucune notation ambiguë possible. Nous définissons ensuite plus en détail la plage des fonctionnalités particulières (c'est-à-dire les adresses IP sur l'ensemble des plus de 4 milliards d'adresses IPv4 possibles, ou simplement un sous-ensemble de celles-ci).

Les fonctionnalités définissent finalement tous les aspects d'une règle arbitraire. Étant donné un ensemble de fonctionnalités et un format de règle valide, il devient possible de générer aléatoirement un nombre arbitraire de règles qui utilisent ces fonctionnalités. De cette manière, il est possible de générer des ensembles de règles de test qui examineront l'IDS sur un vecteur souvent négligé.

Les fonctionnalités sont définies dans une liste séparée par des points-virgules, une fonctionnalité par ligne
type=feature; liste d'arguments sous forme de paires clé=valeur, listes utilisant le formatage Python (c'est-à-dire [a, ..., z]). Les fonctionnalités définissent des portions spécifiques d'un format de règle cible. Les fonctionnalités peuvent être étendues pour ajouter plus de fonctionnalités. Optionnellement, on peut étendre la capacité des fonctionnalités en créant un nouveau format de règle.

Types de fonctionnalités actuels :

1. Feature -- fonctionnalité générique
2. Content -- fonctionnalité de contenu
3. IP -- fonctionnalité IP
4. Protocol -- fonctionnalité de protocole

Les listes ambiguës doivent être écrites sous forme de listes comme [x:y] pour une plage, [x,y] pour une liste, {x1,x2,x3} pour un ensemble ou simplement * pour un joker ou une option unique similaire.

Exemple de liste ambiguë :```
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)

ce qui précède définit deux caractéristiques, une caractéristique de protocole et une caractéristique d'adresse IP source.  Le protocole est nommé proto, ce qui est important
uniquement pour le formatteur de règles, et les protocoles valides sont :
IP, TCP, UDP et ICMP.  La caractéristique IP est définie comme IPv4
et toutes les règles seront complexes.  La complexité IP fait déjà
partie de la classe et n'a pas besoin d'être ajoutée dans la définition de la caractéristique.
Cela créera des adresses IP en utilisant la notation CIDR.

Attributs génériques des caractéristiques :

- Feature_name : Attribut informatif, potentiellement précieux pour
                le formatteur de règles.
- lower_bound : La borne inférieure des valeurs possibles.  Suppose
               que la caractéristique est un nombre.
- upper_bound : Opposé de lower_bound.
- complexity_prob : La probabilité d'utiliser des caractéristiques complexes pour une
                   règle.  De 0 à 100.  Par défaut 0.
                   Lorsque des caractéristiques complexes sont utilisées, une notation ambiguë
                   est sélectionnée au hasard dans la liste d'ambiguïté, ou
                   si la caractéristique définit une ambiguïté spécifique (comme
                   les adresses IP), alors celle-ci est utilisée.  Lorsque des
                   caractéristiques complexes ne sont pas utilisées, une valeur est générée en
                   utilisant les bornes, ou, dans le cas de Content,
                   en utilisant un ensemble de valeurs de distribution qui
                   restreindront la chaîne générée à une série
                   de caractères ASCII.
- ambiguity_list : Une liste de notations ambiguës possibles.
                  Liste séparée par des virgules utilisant le formatage python
                  (c'est-à-dire [a, b, c]).
- toString() : Affiche une instance d'une règle étant donné cet ensemble
              de caractéristiques particulier.

Content Feature -- Héritée de Feature :
- regex : Vrai ou Faux.  Si Vrai, utilisera le formatage pcre pour
         l'expression régulière ainsi que l'ajout éventuel des options i, s ou
         m à l'expression régulière.
- length : Définit la longueur moyenne du contenu généré.
- min_regex_length : Définit la longueur minimale de l'expression régulière.

Protocol Feature -- Héritée de Feature :
- proto_list : Définit la liste des protocoles possibles,
                 sous forme de liste séparée par des virgules (c'est-à-dire [TCP,
                 UDP]).

IP Feature -- Héritée de Feature :
- version : 4 pour la version 4 d'IP, 6 pour la version 6 d'IP.
           Par défaut version 4.

Notation ambiguë pour les plages, listes, ensembles :

Notation de plage :
  [x:y]  signifie de x à y (inclus).

Notation de liste :
  [x,y] signifie une liste d'un nombre de valeurs déterminé aléatoirement,
  où chaque valeur est supérieure ou égale à x
  et inférieure ou égale à y.

Notation d'ensemble :
  {x1,x2,x3,x4} signifie un ensemble de valeurs x1, x2, x3, x4.  Il
  générera un sous-ensemble de l'ensemble original.

Veuillez consulter les exemples d'ensembles de caractéristiques dans le
dossier example_features pour plus d'exemples.
Plus de détails ainsi que la théorie académique derrière cela sont prévus pour être ajoutés ultérieurement.