teler-sh/teler-wafteler-waf est un middleware HTTP en Go qui protège les services web locaux contre les menaces du Top 10 OWASP, les vulnérabilités connues, les acteurs malveillants, les botnets, les crawlers indésirables et les attaques par force brute.
teler-waf est une solution de sécurité complète pour les applications web basées sur Go. Il agit comme un middleware HTTP, offrant une interface facile à utiliser pour intégrer les fonctionnalités de l'IDS avec teler IDS dans des applications Go existantes. En utilisant teler-waf, vous pouvez aider à vous protéger contre une variété d'attaques web, telles que le cross-site scripting (XSS) et l'injection SQL.
Le paquet est fourni avec un net/http.Handler standard, ce qui facilite son intégration dans le routage de votre application. Lorsqu'un client effectue une requête vers une route protégée par teler-waf, la requête est d'abord vérifiée par rapport à l'IDS teler pour détecter les modèles malveillants connus. Si aucun modèle malveillant n'est détecté, la requête est ensuite transmise pour un traitement ultérieur.
En plus de fournir une protection contre les attaques web, teler-waf peut également contribuer à améliorer la sécurité globale et l'intégrité de votre application. Il est hautement configurable, vous permettant de l'adapter aux besoins spécifiques de votre application.
Voir aussi :
teler-waf offre une gamme de fonctionnalités puissantes conçues pour renforcer la sécurité de vos applications web Go :
Dans l'ensemble, teler-waf fournit une solution de sécurité complète pour les applications web basées sur Go, aidant à se protéger contre les attaques web et à améliorer la sécurité globale et l'intégrité de votre application.
Dépendances :
Pour installer teler-waf dans votre application Go, exécutez la commande suivante pour télécharger et installer le paquet teler-waf :```console go get github.com/teler-sh/teler-waf
## Utilisation
> [!WARNING]
> **Avis de dépréciation** : Les exclusions de menace (`Excludes`) seront dépréciées dans la prochaine version (**v2**). Voir [#73](https://github.com/teler-sh/teler-waf/discussions/73) et [#64](https://github.com/teler-sh/teler-waf/issues/64).
Voici un exemple d'utilisation de teler-waf dans une application Go :
1. Importez le package teler-waf dans votre code Go :```go
import "github.com/teler-sh/teler-waf"
New pour créer une nouvelle instance du type Teler. Cette fonction accepte une variété de paramètres optionnels qui peuvent être utilisés pour configurer teler-waf afin de répondre aux besoins spécifiques de votre application.```go
waf := teler.New()3. Utilisez la méthode `Handler` de l'instance `Teler` pour créer un `net/http.Handler`. Ce handler peut ensuite être utilisé dans le routage HTTP de votre application pour appliquer les mesures de sécurité de teler-waf à des routes spécifiques.```go
handler := waf.Handler(http.HandlerFunc(yourHandlerFunc))
handler dans le routage HTTP de votre application pour appliquer les mesures de sécurité de teler-waf à des routes spécifiques.```go
http.Handle("/path", handler)C'est tout ! Vous avez configuré teler-waf dans votre application Go.
**Options :**
Pour une liste des options disponibles pour personnaliser teler-waf, voir la structure [`teler.Options`](https://pkg.go.dev/github.com/teler-sh/teler-waf#Options).
### Exemples
Voici un exemple de la façon de personnaliser les options et les règles pour teler-waf :```go
// main.go
package main
import (
"net/http"
"github.com/teler-sh/teler-waf"
"github.com/teler-sh/teler-waf/request"
"github.com/teler-sh/teler-waf/threat"
)
var myHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// This is the handler function for the route that we want to protect
// with teler-waf's security measures.
w.Write([]byte("hello world"))
})
var rejectHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// This is the handler function for the route that we want to be rejected
// if the teler-waf's security measures are triggered.
http.Error(w, "Sorry, your request has been denied for security reasons.", http.StatusForbidden)
})
func main() {
// Create a new instance of the Teler type using the New function
// and configure it using the Options struct.
telerMiddleware := teler.New(teler.Options{
// Exclude specific threats from being checked by the teler-waf.
Excludes: []threat.Threat{
threat.BadReferrer,
threat.BadCrawler,
},
// Specify whitelisted URIs (path & query parameters), headers,
// or IP addresses that will always be allowed by the teler-waf
// with DSL expressions.
Whitelists: []string{
`request.Headers matches "(curl|Go-http-client|okhttp)/*" && threat == BadCrawler`,
`request.URI startsWith "/wp-login.php"`,
`request.IP in ["127.0.0.1", "::1", "0.0.0.0"]`,
`request.Headers contains "authorization" && request.Method == "POST"`
},
// Specify file path or glob pattern of custom rule files.
CustomsFromRule: "/path/to/custom/rules/**/*.yaml",
// Specify custom rules for the teler-waf to follow.
Customs: []teler.Rule{
{
// Give the rule a name for easy identification.
Name: "Log4j Attack",
// Specify the logical operator to use when evaluating the rule's conditions.
Condition: "or",
// Specify the conditions that must be met for the rule to trigger.
Rules: []teler.Condition{
{
// Specify the HTTP method that the rule applies to.
Method: request.GET,
// Specify the element of the request that the rule applies to
// (e.g. URI, headers, body).
Element: request.URI,
// Specify the pattern to match against the element of the request.
Pattern: `\$\{.*:\/\/.*\/?\w+?\}`,
},
},
},
{
// Give the rule a name for easy identification.
Name: `Headers Contains "curl" String`,
// Specify the conditions that must be met for the rule to trigger.
Rules: []teler.Condition{
{
// Specify the DSL expression that the rule applies to.
DSL: `request.Headers contains "curl"`,
},
},
},
},
// Specify the file path to use for logging.
LogFile: "/tmp/teler.log",
})
// Set the rejectHandler as the handler for the telerMiddleware.
telerMiddleware.SetHandler(rejectHandler)
// Create a new handler using the handler method of the Teler instance
// and pass in the myHandler function for the route we want to protect.
app := telerMiddleware.Handler(myHandler)
// Use the app handler as the handler for the route.
http.ListenAndServe("127.0.0.1:3000", app)
}
Pour plus d'exemples d'utilisation de teler-waf ou d'intégration avec n'importe quel framework, jetez un œil au répertoire examples/.
[!TIP] Si vous souhaitez explorer les configurations, vous plonger dans la création de règles personnalisées et la composition d'expressions DSL, vous pouvez vous entraîner et acquérir une expérience pratique en utilisant ce terrain de jeu teler WAF. Ici, vous pouvez également simuler des requêtes personnalisées pour répondre aux besoins spécifiques de votre application.
Pour intégrer des règles personnalisées dans le middleware teler-waf, vous avez deux choix : Customs et CustomsFromFile. Ces options offrent une flexibilité pour créer vos propres contrôles de sécurité ou remplacer les contrôles par défaut fournis par teler-waf.
Customs optionVous pouvez définir des règles personnalisées directement en utilisant l'option Customs, comme illustré dans l'exemple ci-dessus.
Dans l'option Customs, vous fournissez un tableau de structures teler.Rule. Chaque teler.Rule représente une règle personnalisée avec un nom unique et une condition qui spécifie comment les conditions individuelles au sein de la règle sont évaluées (or ou and). La règle se compose d'une ou plusieurs structures teler.Condition, chacune définissant une condition spécifique à vérifier. Les conditions peuvent être basées sur la méthode HTTP, l'élément (en-têtes, corps, URI ou tout), et un motif regex ou une expression DSL à faire correspondre.
CustomsFromFile optionAlternativement, l'option CustomsFromFile vous permet de charger des règles personnalisées à partir de fichiers externes, offrant une flexibilité et une gestion encore plus grandes. Ces règles peuvent être définies au format YAML, chaque fichier contenant une ou plusieurs règles. Voici un exemple de structure YAML représentant une règle personnalisée :```yaml
> [!IMPORTANT]
> Veuillez noter que les paramètres `condition`, `method` et `element` sont optionnels. Les valeurs par défaut leur sont attribuées comme suit : `condition` est défini sur **or**, `method` sur **ALL** et `element` sur **ANY**. Par conséquent, si vous le souhaitez, vous pouvez laisser ces paramètres vides. Le paramètre `pattern` est obligatoire, sauf si vous spécifiez une expression `dsl`. Dans ce cas, lorsqu'une expression `dsl` est fournie, teler-waf ignorera toutes les valeurs attribuées à `method` et `element`, même si elles sont définies. Pour voir quelques exemples, vous pouvez vous référer au répertoire [`tests/rules/`](https://github.com/teler-sh/teler-waf/tree/master/tests/rules/valid).
Vous pouvez spécifier l'option `CustomsFromFile` avec le chemin de fichier réel ou le motif glob pointant vers l'emplacement de vos fichiers de règles personnalisées. Par exemple :```go
// Create a new instance of the Teler middleware and
// specify custom rules with the CustomsFromFile option.
telerMiddleware := teler.New(teler.Options{
CustomsFromFile: "/path/to/custom/rules/**/*.yaml",
})
Avec CustomsFromFile, vous fournissez le chemin du fichier ou le motif glob où se trouvent vos fichiers de règles personnalisées. Le motif peut inclure des caractères génériques pour correspondre à plusieurs fichiers ou à un répertoire et ses sous-répertoires. Chaque fichier doit contenir une ou plusieurs règles personnalisées définies dans le format YAML approprié.
En utilisant l'option Customs, CustomsFromFile, ou les deux, vous pouvez intégrer de manière transparente vos règles personnalisées dans le middleware teler-waf, améliorant ainsi ses capacités de sécurité pour répondre à vos besoins spécifiques.
Les expressions DSL (Domain-Specific Language) offrent un moyen puissant de définir des conditions utilisées pour évaluer les requêtes entrantes dans le contexte de règles personnalisées ou de listes blanches. Avec les expressions DSL, vous pouvez créer des conditions sophistiquées et ciblées basées sur différents attributs des requêtes entrantes. Voici quelques exemples illustratifs de code d'expression DSL :
Vérifiez si les en-têtes de la requête entrante contiennent "curl" :```sql request.Headers contains "curl"
Vérifiez si la méthode de requête entrante est "GET" :```sql
request.Method == "GET"
Vérifiez si la méthode de requête entrante est "GET" ou "POST" en utilisant l'expression régulière, l'opérateur matches :```sql
request.Method matches "^(POS|GE)T$"
Vérifiez si l'adresse IP de la demande entrante provient de localhost :```sql
request.IP in ["127.0.0.1", "::1", "0.0.0.0"]
Vérifier si un élément de la requête contient la chaîne "foo":```console one(request.ALL, # contains "foo")
Vérifier si le corps de la requête entrante contient "foo" :```sql
request.Body contains "foo"
Vérifiez si la catégorie de menace actuelle analysée est un mauvais crawler ou un bruteforce de répertoires :```sql threat in [BadCrawler, DirectoryBruteforce]
Ces exemples donnent un aperçu des capacités expressives des expressions DSL, vous permettant de définir des conditions complexes basées sur divers attributs de requête. En exploitant ces expressions, vous pouvez définir efficacement les critères d'évaluation des requêtes entrantes et adapter vos règles personnalisées ou listes blanches en conséquence, offrant un contrôle granulaire sur le comportement de votre application.
#### Variables disponibles
- **Catégorie de menace**
Tous les identifiants constants du type `threat.Threat` peuvent être utilisés comme variables valides. Ces identifiants représentent différentes catégories de menaces pertinentes pour votre analyse.
- **`request`**
La variable `request` représente la requête entrante et donne accès à ses champs et valeurs correspondantes. Les sous-variables suivantes sont disponibles dans la variable `request` :
- `request.URI` : Représente l'URI de la requête entrante, incluant le chemin, les requêtes, les paramètres et les fragments.
- `request.Headers` : Représente les en-têtes de la requête entrante, présentés sur plusieurs lignes.
- `request.Body` : Représente le corps de la requête entrante.
- `request.Method` : Représente la méthode de la requête entrante.
- `request.IP` : Représente l'adresse IP du client associée à la requête entrante.
- `request.ALL` : Représente toutes les valeurs de chaîne des champs de requête mentionnés ci-dessus dans une slice.
- **`threat`**
La variable `threat` représente la catégorie de menace en cours d'analyse. Elle est de type `threat.Threat` et vous permet d'évaluer et de prendre des décisions en fonction de la catégorie de menace spécifique associée à la requête.
En utilisant ces variables dans vos expressions DSL, vous pouvez accéder efficacement et manipuler les attributs des requêtes entrantes et évaluer les catégories de menaces pertinentes. Cela vous permet de créer des conditions de règles personnalisées<!-- and whitelists--> adaptées à votre cas d'utilisation spécifique.
#### Fonctions disponibles
De plus, vous avez accès à une variété de fonctions. Ces fonctions incluent à la fois les [fonctions intégrées](https://expr.medv.io/docs/Language-Definition#built-in-functions) fournies par le paquet expr et celles définies spécifiquement dans le paquet DSL. Les fonctions utilisent les fonctionnalités offertes par le paquet Go `strings` intégré. Voici une liste détaillée des fonctions disponibles :
- `cidr` : Obtenir toutes les adresses IP dans la plage avec le CIDR donné.
- `clone` : Créer une copie d'une chaîne de caractères.
- `containsAny` : Vérifier si une chaîne contient l'une des sous-chaînes spécifiées.
- `equalFold` : Comparer deux chaînes de manière insensible à la casse.
- `hasPrefix` : Vérifier si une chaîne a un préfixe spécifié.
- `hasSuffix` : Vérifier si une chaîne a un suffixe spécifié.
- `join` : Concaténer plusieurs chaînes en utilisant un séparateur spécifié.
- `repeat` : Répéter une chaîne un nombre de fois spécifié.
- `replace` : Remplacer les occurrences d'une sous-chaîne dans une chaîne.
- `replaceAll` : Remplacer toutes les occurrences d'une sous-chaîne dans une chaîne.
- `request` : Accéder aux informations spécifiques à la requête dans l'expression DSL.
- `threat` : Accéder aux informations relatives à la catégorie de menace en cours d'analyse.
- `title` : Convertir une chaîne en casse de titre.
- `toLower` : Convertir une chaîne en minuscules.
- `toTitle` : Convertir une chaîne en casse de titre.
- `toUpper` : Convertir une chaîne en majuscules.
- `toValidUTF8` : Convertir une chaîne en une chaîne encodée UTF-8 valide.
- `trim` : Supprimer les espaces blancs au début et à la fin d'une chaîne.
- `trimLeft` : Supprimer les espaces blancs au début d'une chaîne.
- `trimPrefix` : Supprimer un préfixe spécifié d'une chaîne.
- `trimRight` : Supprimer les espaces blancs à la fin d'une chaîne.
- `trimSpace` : Supprimer les espaces blancs au début et à la fin et réduire les espaces blancs consécutifs dans une chaîne.
- `trimSuffix` : Supprimer un suffixe spécifié d'une chaîne.
Pour plus de détails complets sur les opérateurs et les fonctions intégrées, veuillez vous référer à la [documentation Expr](https://expr.medv.io/docs/Getting-Started). Elle fournit un guide complet pour utiliser les opérateurs et explorer les fonctions intégrées disponibles dans vos expressions DSL.
### Gestion simplifiée de la configuration
Pour une configuration efficace, il est essentiel de définir une série de paramètres, notamment les listes blanches, les définitions de règles personnalisées, les préférences de journalisation et d'autres paramètres. Le paquet [`option`](https://pkg.go.dev/github.com/teler-sh/teler-waf/option) simplifie ce flux de travail de configuration en vous permettant de démarshaler ou de charger efficacement les données de configuration depuis les formats JSON et YAML dans un format que teler-waf peut facilement comprendre et mettre en œuvre.```go
// Load configuration from a YAML file.
opt, err := option.LoadFromYAMLFile("/path/to/teler-waf.conf.yaml")
if err != nil {
panic(err)
}
// Create a new instance of the Teler type with
// the loaded options.
telerMiddleware := teler.New(opt)
Par défaut, teler-waf met en cache toutes les requêtes entrantes pendant 15 minutes et les vide toutes les 20 minutes pour améliorer les performances. Cependant, si vous personnalisez encore les paramètres pour qu'ils correspondent aux exigences de votre application, vous pouvez désactiver la mise en cache pendant le développement en définissant l'option du mode développement sur true. Cela empêchera la mise en cache des requêtes entrantes et peut être utile à des fins de débogage.```go
// Create a new instance of the Teler type using
// the New function & enable development mode option.
telerMiddleware := teler.New(teler.Options{
Development: true,
})
### Logs
Voici un exemple de ce à quoi ressembleraient les lignes de log si teler-waf détectait une menace sur une requête :```json
{"level":"warn","ts":1672261174.5995026,"msg":"bad crawler","id":"654b85325e1b2911258a","category":"BadCrawler","caller":"teler-waf","listen_addr":"127.0.0.1:36267","request":{"method":"GET","path":"/","ip_addr":"127.0.0.1:37702","headers":{"Accept":["*/*"],"User-Agent":["curl/7.81.0"]},"body":""}}
{"level":"warn","ts":1672261175.9567692,"msg":"directory bruteforce","id":"b29546945276ed6b1fba","category":"DirectoryBruteforce","caller":"teler-waf","listen_addr":"127.0.0.1:36267","request":{"method":"GET","path":"/.git","ip_addr":"127.0.0.1:37716","headers":{"Accept":["*/*"],"User-Agent":["X"]},"body":""}}
{"level":"warn","ts":1672261177.1487508,"msg":"Detects common comment types","id":"75412f2cc0ec1cf79efd","category":"CommonWebAttack","caller":"teler-waf","listen_addr":"127.0.0.1:36267","request":{"method":"GET","path":"/?id=1%27%20or%201%3D1%23","ip_addr":"127.0.0.1:37728","headers":{"Accept":["*/*"],"User-Agent":["X"]},"body":""}}
L'id est un identifiant unique généré lorsqu'une requête est rejetée par teler-waf. Il est inclus dans les en-têtes de réponse HTTP de la requête (X-Teler-Req-Id), et peut être utilisé pour résoudre les problèmes liés aux requêtes effectuées vers le site web.
Par exemple, si une requête vers un site web renvoie un code d'état HTTP d'erreur, comme un 403 Forbidden, l'ID de requête teler peut être utilisé pour identifier la requête spécifique qui a causé l'erreur et aider à résoudre le problème.
Les IDs de requête teler sont utilisés par teler-waf pour suivre les requêtes faites à son application web et peuvent être utiles pour déboguer et analyser les modèles de trafic sur un site web.
Par défaut, teler-waf utilise DefaultHTMLResponse comme réponse standard lorsqu'une requête est rejetée ou bloquée. Cependant, teler-waf offre un haut degré de personnalisation, vous permettant d'adapter la réponse à vos besoins spécifiques. La personnalisation peut être réalisée à l'aide des options Status, HTML ou HTMLFile, qui font toutes partie de l'interface Response.
Voici comment vous pouvez utiliser ces options dans votre code :```go // Create a new instance of the Teler middleware telerMiddleware := teler.New(teler.Options{ // Customize the response for rejected requests Response: teler.Response{ Status: 403, HTML: "Your request has been denied for security reasons. Ref ID: {{ID}}.", // Alternatively, you can use HTMLFile to point to a custom HTML file HTMLFile: "/path/to/custom-403.html", }, })
Avec ce niveau de personnalisation, vous pouvez construire des réponses personnalisées et informatives à afficher lorsque teler-waf bloque ou rejette une requête. L'option `HTML` vous permet de spécifier directement le contenu HTML souhaité sous forme de chaîne de caractères, tandis que l'option `HTMLFile` vous permet de référencer un fichier externe contenant la réponse HTML personnalisée.
De plus, pour améliorer l'expérience utilisateur, vous pouvez utiliser des espaces réservés dans votre contenu HTML pour générer des éléments dynamiques. Pendant l'exécution, ces espaces réservés seront remplacés par des valeurs réelles, ce qui produira des réponses plus pertinentes contextuellement. Les espaces réservés disponibles et pris en charge incluent :
* `{{ID}}` : Identifiants de requête, permettant l'identification unique de chaque requête rejetée.
* `{{message}}` : Messages de rejet indiquant la raison du blocage de la requête.
* `{{threat}}` : Catégories de menace, fournissant des informations sur la menace de sécurité détectée.
En intégrant ces espaces réservés, vous pouvez créer des réponses détaillées et complètes qui communiquent efficacement la justification derrière les rejets ou les blocages de requêtes.
### Falco Sidekick
[Falco Sidekick](https://github.com/falcosecurity/falcosidekick) est un outil qui reçoit des événements de Falco, un projet de sécurité open-source natif du cloud pour l'exécution, et les envoie vers différents canaux de sortie. Il vous permet de transmettre des alertes de sécurité vers divers systèmes tiers tels que Slack, Elasticsearch, Loki, Grafana, Datadog et [plus](https://github.com/falcosecurity/falcosidekick#outputs). Cela permet aux équipes de sécurité de surveiller et de répondre efficacement aux menaces et événements de sécurité en temps réel.
L'intégration de Falco Sidekick avec teler-waf est également possible. En utilisant l'option `FalcoSidekickURL`, vous pouvez configurer teler-waf pour envoyer des événements à Falco Sidekick, qui les recevra et les traitera pour vous. Pour ce faire, créez simplement une nouvelle instance du type `Teler` en utilisant la fonction `New` et fournissez l'option `FalcoSidekickURL` avec l'URL de votre instance Falco Sidekick. Par exemple :```go
// Create a new instance of the Teler type using
// the New function & integrate Falco Sidekick.
telerMiddleware := teler.New(teler.Options{
FalcoSidekickURL: "http://localhost:2801",
})
Une fois que vous avez configuré cette intégration, toutes les menaces détectées par teler-waf seront envoyées à Falco Sidekick, qui pourra alors prendre les mesures appropriées en fonction de la configuration que vous avez définie. Par exemple, vous pouvez configurer Falco Sidekick pour envoyer automatiquement des alertes à votre équipe de réponse aux incidents.
L'événement transmis à l'instance Falco Sidekick comprend les informations suivantes :
output : Représente le message d'alerte.priority : La priorité est systématiquement indiquée comme warning, en référence à l'urgence associée aux événements de sécurité.rule : Indique la règle spécifique (message) qui correspond à la requête associée.time : Horodatage de génération de l'événement.teler.caller : Identifie la source applicative qui a invoqué teler-waf.teler.id : Représente un identifiant unique pour la requête rejetée.teler.threat : Spécifie la catégorie de la menace.teler.listen_addr : Indique l'adresse réseau sur laquelle teler-waf écoute les requêtes entrantes.
request.body : Contient le corps de la requête associée.request.headers : Liste les en-têtes de la requête associée.Dans l'ensemble, Falco Sidekick est un outil polyvalent qui peut vous aider à automatiser votre processus de réponse aux incidents et à améliorer votre posture de sécurité globale. En exploitant ses capacités, vous pouvez garantir que vos applications cloud-native sont sécurisées et protégées contre les menaces potentielles.
Vous pouvez améliorer votre surveillance de sécurité en intégrant les logs de teler WAF dans Wazuh. Pour ce faire, utilisez les règles personnalisées disponibles dans le répertoire extras/.
Ajoutez le bloc d'élément localfile ci-dessous à l'intérieur de l'élément ossec_config dans le fichier de configuration locale :```xml
<ossec_config>
En procédant ainsi, Wazuh pourra lire et analyser les journaux du WAF teler, améliorant ainsi la protection de votre réseau et fournissant de meilleures informations.
Le paquet teler-waf utilise un jeu de données de menaces pour identifier et analyser chaque requête entrante afin de détecter d'éventuelles menaces de sécurité. Ce jeu de données est mis à jour quotidiennement, ce qui signifie que vous disposerez toujours de la ressource la plus récente. Le jeu de données est initialement stocké dans le répertoire de cache au niveau de l'utilisateur (sur les systèmes Unix, il retourne $XDG_CACHE_HOME/teler-waf comme spécifié par la XDG Base Directory Specification
s'il n'est pas vide, sinon $HOME/.cache/teler-waf. Sur Darwin, il retourne $HOME/Library/Caches/teler-waf. Sur Windows, il retourne %LocalAppData%/teler-waf. Sur Plan 9, il retourne $home/lib/cache/teler-waf) lors de votre premier lancement. Les lancements ultérieurs utiliseront le jeu de données en cache, plutôt que de le télécharger à nouveau.
[!NOTE] Les jeux de données de menaces sont obtenus à partir du dépôt teler-sh/teler-resources.
Cependant, il peut y avoir des situations où vous souhaitez désactiver les mises à jour automatiques du jeu de données de menaces. Par exemple, vous pouvez avoir une connexion Internet lente ou limitée, ou vous pouvez utiliser une machine avec un accès aux fichiers restreint. Dans ces cas, vous pouvez définir une option appelée NoUpdateCheck sur true, ce qui empêchera le teler-waf de mettre à jour automatiquement le jeu de données.
[!CAUTION] Activer l'option
InMemorya priorité et garantit que les mises à jour automatiques restent activées.```go // Create a new instance of the Teler type using the New // function & disable automatic updates to the threat dataset. telerMiddleware := teler.New(teler.Options{ NoUpdateCheck: true, })
Enfin, il peut y avoir des cas où il est nécessaire de charger l'ensemble de données de menaces en mémoire plutôt que de le sauvegarder dans un répertoire de cache au niveau utilisateur. Cela peut être particulièrement utile si vous exécutez l'application ou le service sur une image distroless ou runtime, où l'accès aux fichiers peut être limité ou lent. Dans ce scénario, vous pouvez définir une option appelée **InMemory** sur `true`, ce qui chargera l'ensemble de données de menaces en mémoire pour un accès plus rapide.```go
// Create a new instance of the Teler type using the
// New function & enable in-memory threat datasets store.
telerMiddleware := teler.New(teler.Options{
InMemory: true,
})
[!CAUTION] Cela peut également consommer davantage de ressources système, il est donc judicieux de peser les compromis avant de prendre cette décision.
Si vous découvrez un problème de sécurité, veuillez le signaler immédiatement à leur attention, nous prenons la sécurité au sérieux !
Si vous avez des informations sur un problème de sécurité ou une vulnérabilité dans ce package teler-waf, et/ou si vous êtes en mesure d'exécuter avec succès une attaque telle que du cross-site scripting (XSS) et d'afficher une alerte sur notre site de démonstration (voir ressources), veuillez NE PAS créer de problème public — veuillez plutôt envoyer votre rapport en privé via le formulaire de signalement de vulnérabilité.
Voici quelques limitations liées à l'utilisation de teler-waf :
> [!NOTE]
> Les résultats de benchmarking peuvent varier et ne sont pas nécessairement cohérents. Le jeu de données [teler-resources](https://github.com/teler-sh/teler-resources) peut avoir augmenté depuis, ce qui peut impacter les résultats.
- **Complexité de la configuration** : Configurer teler-waf pour répondre aux besoins spécifiques de votre application peut être complexe et peut nécessiter un certain niveau d'expertise en sécurité web. Cela peut rendre difficile pour ceux qui ne sont pas familiers avec les pare-feu applicatifs et les systèmes IDS de configurer et d'utiliser correctement teler-waf.
- **Protection limitée** : teler-waf n'est pas une solution de sécurité parfaite et peut ne pas être en mesure de protéger contre tous les types d'attaques possibles. Comme tout système de sécurité, il est important de surveiller et maintenir régulièrement teler-waf pour garantir qu'il offre le niveau de protection souhaité.
#### Problèmes connus
Pour voir une liste des problèmes connus avec teler-waf, veuillez filtrer les issues par le label ["known-issue"](https://github.com/teler-sh/teler-waf/issues?q=is%3Aopen+is%3Aissue+label%3Aknown-issue).
## Communauté
Nous utilisons Google Groups comme liste de diffusion dédiée. Abonnez-vous à [teler-announce](https://groups.google.com/g/teler-announce) via [[email protected]](mailto:[email protected]) pour les annonces importantes, comme la disponibilité de nouvelles versions. Cet abonnement vous tiendra informé des développements significatifs liés à [teler IDS](https://github.com/teler-sh/teler), [teler WAF](https://github.com/teler-sh/teler-waf), [teler Proxy](https://github.com/teler-sh/teler-proxy), [teler Caddy](https://github.com/teler-sh/teler-caddy) et [teler Resources](https://github.com/teler-sh/teler-resources).
Pour toute [demande](https://github.com/teler-sh/teler-waf/discussions/categories/q-a), [discussion](https://github.com/teler-sh/teler-waf/discussions) ou [problème](https://github.com/teler-sh/teler-waf/issues), ils sont suivis ici sur GitHub. C'est là que nous gérons et traitons activement ces aspects de notre engagement communautaire.
## Licence
Ce package est mis à disposition sous une double licence : la [Apache License 2.0](https://github.com/teler-sh/teler-waf/blob/HEAD/LICENSE-APACHE) et la [Elastic License 2.0 (ELv2)](https://github.com/teler-sh/teler-waf/blob/HEAD/LICENSE-ELASTIC) (pour le package principal, **teler**).
Vous pouvez l'utiliser librement au sein de votre organisation pour protéger vos applications. Cependant, vous ne pouvez pas utiliser le package principal pour créer un service cloud, hébergé ou géré, ou à des fins commerciales, car vous auriez besoin d'une licence commerciale pour cela – bien que cette option ne soit pas actuellement disponible. Si vous êtes intéressé par l'obtention de cette licence commerciale pour des utilisations non autorisées par [ELv2](https://github.com/teler-sh/teler-waf/blob/HEAD/LICENSE-ELASTIC), veuillez contacter **@dwisiswant0**.
teler-waf et toutes les contributions sont copyright © par Dwi Siswanto 2022-2024.
request.ip_addr : Révèle l'adresse IP de la requête associée.request.method : Indique la méthode HTTP utilisée dans la requête associée.request.path : Fait référence au chemin de la requête associée.