teler-sh/teler-wafteler-waf ist eine Go HTTP-Middleware, die lokale Webdienste vor OWASP-Top-10-Bedrohungen, bekannten Schwachstellen, böswilligen Akteuren, Botnetzen, unerwünschten Crawlern und Brute-Force-Angriffen schützt.
teler-waf ist eine umfassende Sicherheitslösung für Go-basierte Webanwendungen. Es fungiert als HTTP-Middleware und bietet eine einfach zu bedienende Schnittstelle, um die IDS-Funktionalität des teler IDS in bestehende Go-Anwendungen zu integrieren. Mit teler-waf können Sie Ihre Anwendung vor einer Vielzahl von webbasierten Angriffen wie Cross-Site-Scripting (XSS) und SQL-Injection schützen.
Das Paket enthält einen standardmäßigen net/http.Handler, der die Integration in das Routing Ihrer Anwendung erleichtert. Wenn ein Client eine Anfrage an eine durch teler-waf geschützte Route stellt, wird die Anfrage zunächst vom teler IDS auf bekannte bösartige Muster überprüft. Werden keine bösartigen Muster erkannt, wird die Anfrage zur weiteren Verarbeitung durchgereicht.
Neben dem Schutz vor webbasierten Angriffen kann teler-waf auch dazu beitragen, die allgemeine Sicherheit und Integrität Ihrer Anwendung zu verbessern. Es ist hoch konfigurierbar, sodass Sie es an die spezifischen Anforderungen Ihrer Anwendung anpassen können.
Siehe auch:
teler-waf bietet eine Reihe leistungsstarker Funktionen, die die Sicherheit Ihrer Go-Webanwendungen verbessern:
Insgesamt bietet teler-waf eine umfassende Sicherheitslösung für Go-basierte Webanwendungen und hilft, vor webbasierten Angriffen zu schützen und die allgemeine Sicherheit und Integrität Ihrer Anwendung zu verbessern.
Abhängigkeiten:
Um teler-waf in Ihre Go-Anwendung zu installieren, führen Sie den folgenden Befehl aus, um das teler-waf-Paket herunterzuladen und zu installieren:```console go get github.com/teler-sh/teler-waf
## Nutzung
> [!WARNING]
> **Hinweis zur Einstellung**: Threat-Ausschlüsse (`Excludes`) werden in der kommenden Version (**v2**) eingestellt. Siehe [#73](https://github.com/teler-sh/teler-waf/discussions/73) & [#64](https://github.com/teler-sh/teler-waf/issues/64).
Hier ist ein Beispiel, wie Sie teler-waf in einer Go-Anwendung verwenden:
1. Importieren Sie das teler-waf-Paket in Ihren Go-Code:```go
import "github.com/teler-sh/teler-waf"
New-Funktion, um eine neue Instanz des Typs Teler zu erstellen. Diese Funktion akzeptiert eine Reihe optionaler Parameter, mit denen sich teler-waf an die spezifischen Anforderungen Ihrer Anwendung anpassen lässt.```go
waf := teler.New()3. Verwenden Sie die `Handler`-Methode der `Teler`-Instanz, um einen `net/http.Handler` zu erstellen. Dieser Handler kann dann in der HTTP-Routing Ihrer Anwendung verwendet werden, um die Sicherheitsmaßnahmen von teler-waf auf bestimmte Routen anzuwenden.```go
handler := waf.Handler(http.HandlerFunc(yourHandlerFunc))
handler in Ihrem HTTP-Routing der Anwendung, um die Sicherheitsmaßnahmen von teler-waf auf bestimmte Routen anzuwenden.```go
http.Handle("/path", handler)Das war's! Sie haben teler-waf in Ihrer Go-Anwendung konfiguriert.
**Optionen:**
Eine Liste der verfügbaren Optionen zum Anpassen von teler-waf finden Sie in der Struktur [`teler.Options`](https://pkg.go.dev/github.com/teler-sh/teler-waf#Options).
### Beispiele
Hier ist ein Beispiel, wie Sie die Optionen und Regeln für teler-waf anpassen können:```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)
}
Weitere Beispiele zur Verwendung von teler-waf oder zur Integration mit einem beliebigen Framework finden Sie im Verzeichnis examples/.
[!TIP] Wenn Sie Konfigurationen erkunden, eigene Regeln erstellen und DSL-Ausdrücke verfassen möchten, können Sie mit diesem teler WAF Playground üben und praktische Erfahrungen sammeln. Hier können Sie auch maßgeschneiderte Anfragen simulieren, um die spezifischen Anforderungen Ihrer Anwendung zu erfüllen.
Um benutzerdefinierte Regeln in die teler-waf Middleware zu integrieren, haben Sie zwei Möglichkeiten: Customs und CustomsFromFile. Diese Optionen bieten Flexibilität, um eigene Sicherheitsprüfungen zu erstellen oder die von teler-waf bereitgestellten Standardprüfungen zu überschreiben.
Customs-OptionSie können benutzerdefinierte Regeln direkt mit der Customs-Option definieren, wie im obigen Beispiel gezeigt.
In der Customs-Option geben Sie ein Array von teler.Rule-Strukturen an. Jede teler.Rule repräsentiert eine benutzerdefinierte Regel mit einem eindeutigen Namen und einer Bedingung, die festlegt, wie die einzelnen Bedingungen innerhalb der Regel ausgewertet werden (or oder and). Die Regel besteht aus einer oder mehreren teler.Condition-Strukturen, die jeweils eine spezifische zu prüfende Bedingung definieren. Bedingungen können auf der HTTP-Methode, dem Element (Header, Body, URI oder beliebig) und einem Regex-Muster oder einem DSL-Ausdruck zum Abgleich basieren.
CustomsFromFile-OptionAlternativ ermöglicht die CustomsFromFile-Option das Laden benutzerdefinierter Regeln aus externen Dateien, was noch mehr Flexibilität und Verwaltbarkeit bietet. Diese Regeln können im YAML-Format definiert werden, wobei jede Datei eine oder mehrere Regeln enthält. Hier ist eine Beispiel-YAML-Struktur, die eine benutzerdefinierte Regel darstellt:```yaml
> [!IMPORTANT]
> Bitte beachten Sie, dass `condition`, `method` und `element` optionale Parameter sind. Die ihnen zugewiesenen Standardwerte lauten wie folgt: `condition` ist auf **or**, `method` auf **ALL** und `element` auf **ANY** gesetzt. Daher können Sie diese Parameter bei Bedarf leer lassen. Der Parameter `pattern` ist obligatorisch, es sei denn, Sie geben einen `dsl`-Ausdruck an. In solchen Fällen ignoriert teler-waf alle Werte, die `method` und `element` zugewiesen wurden, selbst wenn diese definiert sind. Beispiele finden Sie im Verzeichnis [`tests/rules/`](https://github.com/teler-sh/teler-waf/tree/master/tests/rules/valid).
Sie können die Option `CustomsFromFile` mit dem tatsächlichen Dateipfad oder Glob-Muster angeben, das auf den Speicherort Ihrer benutzerdefinierten Regeldateien verweist. Zum Beispiel:```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",
})
Mit CustomsFromFile geben Sie den Dateipfad oder das Glob-Muster an, in dem sich Ihre benutzerdefinierten Regeldateien befinden. Das Muster kann Platzhalter enthalten, um mehrere Dateien oder ein Verzeichnis und seine Unterverzeichnisse abzugleichen. Jede Datei sollte eine oder mehrere benutzerdefinierte Regeln enthalten, die im korrekten YAML-Format definiert sind.
Durch die Verwendung der Optionen Customs, CustomsFromFile oder beider können Sie Ihre benutzerdefinierten Regeln nahtlos in die teler-waf-Middleware integrieren und so deren Sicherheitsfunktionen entsprechend Ihren spezifischen Anforderungen erweitern.
DSL (Domain-Specific Language) Ausdrücke bieten eine leistungsstarke Möglichkeit, Bedingungen zu definieren, die zur Bewertung eingehender Anfragen im Kontext benutzerdefinierter Regeln oder Whitelists verwendet werden. Mit DSL-Ausdrücken können Sie anspruchsvolle und gezielte Bedingungen basierend auf verschiedenen Attributen der eingehenden Anfragen erstellen. Hier sind einige illustrative Beispiele für DSL-Ausdruckscode:
Prüfen, ob die eingehenden Anfrage-Header "curl" enthalten:```sql request.Headers contains "curl"
Überprüfen, ob die eingehende Anfragemethode "GET" ist:```sql
request.Method == "GET"
Überprüfen Sie mit regulären Ausdrücken und dem matches-Operator, ob die eingehende Anforderungsmethode "GET" oder "POST" ist:```sql
request.Method matches "^(POS|GE)T$"
Überprüfen Sie, ob die IP-Adresse der eingehenden Anfrage von localhost stammt:```sql
request.IP in ["127.0.0.1", "::1", "0.0.0.0"]
Überprüfen, ob ein beliebiges Element in der Anfrage die Zeichenfolge "foo" enthält:```console one(request.ALL, # contains "foo")
Überprüfen Sie, ob der eingehende Anforderungstext 'foo' enthält:```sql
request.Body contains "foo"
Überprüfen, ob die aktuell analysierte Bedrohungskategorie böser Crawler oder Directory-Bruteforce ist:```sql threat in [BadCrawler, DirectoryBruteforce]
Diese Beispiele geben einen Einblick in die ausdrucksstarken Fähigkeiten von DSL-Ausdrücken, mit denen Sie komplexe Bedingungen basierend auf verschiedenen Anfrageattributen definieren können. Durch die Nutzung dieser Ausdrücke können Sie effektiv die Kriterien für die Bewertung eingehender Anfragen festlegen und Ihre benutzerdefinierten Regeln oder Whitelists entsprechend anpassen, was eine feingranulare Steuerung des Verhaltens Ihrer Anwendung ermöglicht.
#### Verfügbare Variablen
Bei der Arbeit mit DSL-Ausdrücken haben Sie Zugriff auf verschiedene Variablen, die wertvolle Informationen über die eingehenden Anfragen und die analysierte Bedrohungskategorie liefern. Hier ist eine detaillierte Beschreibung der verfügbaren Variablen:
- **Bedrohungskategorie**
Alle konstanten Identifikatoren des Typs `threat.Threat` können als gültige Variablen verwendet werden. Diese Identifikatoren repräsentieren verschiedene Bedrohungskategorien, die für Ihre Analyse relevant sind.
- **`request`**
Die Variable `request` repräsentiert die eingehende Anfrage und bietet Zugriff auf ihre Felder und die entsprechenden Werte. Die folgenden Untervariablen sind innerhalb der `request`-Variable verfügbar:
- `request.URI`: Stellt den URI der eingehenden Anfrage dar, einschließlich Pfad, Abfragen, Parameter und Fragmente.
- `request.Headers`: Stellt die Header der eingehenden Anfrage dar, dargestellt in mehreren Zeilen.
- `request.Body`: Stellt den Body der eingehenden Anfrage dar.
- `request.Method`: Stellt die Methode der eingehenden Anfrage dar.
- `request.IP`: Stellt die Client-IP-Adresse dar, die mit der eingehenden Anfrage verbunden ist.
- `request.ALL`: Stellt alle Zeichenkettenwerte der oben genannten Anfragefelder in einem Slice dar.
- **`threat`**
Die Variable `threat` repräsentiert die analysierte Bedrohungskategorie. Sie ist vom Typ `threat.Threat` und ermöglicht es Ihnen, basierend auf der spezifischen, mit der Anfrage verbundenen Bedrohungskategorie Bewertungen vorzunehmen und Entscheidungen zu treffen.
Durch die Verwendung dieser Variablen in Ihren DSL-Ausdrücken können Sie effektiv auf die Attribute der eingehenden Anfragen zugreifen und diese manipulieren sowie die relevanten Bedrohungskategorien bewerten. Dies ermöglicht es Ihnen, benutzerdefinierte Regelbedingungen<!-- and whitelists--> zu erstellen, die auf Ihren spezifischen Anwendungsfall zugeschnitten sind.
#### Verfügbare Funktionen
Außerdem haben Sie Zugriff auf eine Vielzahl von Funktionen. Diese Funktionen umfassen sowohl die [eingebauten Funktionen](https://expr.medv.io/docs/Language-Definition#built-in-functions) des expr-Pakets als auch die speziell im DSL-Paket definierten Funktionen. Die Funktionen nutzen die Funktionalitäten des integrierten `strings`-Go-Pakets. Hier ist eine detaillierte Liste der verfügbaren Funktionen:
- `cidr`: Alle IP-Adressen im Bereich mit der angegebenen CIDR abrufen.
- `clone`: Eine Kopie einer Zeichenkette erstellen.
- `containsAny`: Prüfen, ob eine Zeichenkette eine der angegebenen Teilzeichenketten enthält.
- `equalFold`: Zwei Zeichenketten ohne Berücksichtigung der Groß-/Kleinschreibung vergleichen.
- `hasPrefix`: Prüfen, ob eine Zeichenkette ein bestimmtes Präfix hat.
- `hasSuffix`: Prüfen, ob eine Zeichenkette ein bestimmtes Suffix hat.
- `join`: Mehrere Zeichenketten mit einem angegebenen Trennzeichen verketten.
- `repeat`: Eine Zeichenkette eine bestimmte Anzahl von Malen wiederholen.
- `replace`: Vorkommen einer Teilzeichenkette in einer Zeichenkette ersetzen.
- `replaceAll`: Alle Vorkommen einer Teilzeichenkette in einer Zeichenkette ersetzen.
- `request`: Anfragespezifische Informationen innerhalb des DSL-Ausdrucks abrufen.
- `threat`: Informationen zur analysierten Bedrohungskategorie abrufen.
- `title`: Eine Zeichenkette in Titelformat umwandeln.
- `toLower`: Eine Zeichenkette in Kleinbuchstaben umwandeln.
- `toTitle`: Eine Zeichenkette in Titelformat umwandeln.
- `toUpper`: Eine Zeichenkette in Großbuchstaben umwandeln.
- `toValidUTF8`: Eine Zeichenkette in einen gültigen UTF-8-codierten String umwandeln.
- `trim`: Führende und abschließende Leerzeichen aus einer Zeichenkette entfernen.
- `trimLeft`: Führende Leerzeichen aus einer Zeichenkette entfernen.
- `trimPrefix`: Ein bestimmtes Präfix aus einer Zeichenkette entfernen.
- `trimRight`: Abschließende Leerzeichen aus einer Zeichenkette entfernen.
- `trimSpace`: Führende und abschließende Leerzeichen entfernen und aufeinanderfolgende Leerzeichen innerhalb einer Zeichenkette zusammenziehen.
- `trimSuffix`: Ein bestimmtes Suffix aus einer Zeichenkette entfernen.
Für umfassendere Details zu Operatoren und eingebauten Funktionen lesen Sie bitte die [Expr-Dokumentation](https://expr.medv.io/docs/Getting-Started). Sie bietet eine umfassende Anleitung zur Nutzung von Operatoren und zur Erkundung der verfügbaren eingebauten Funktionen in Ihren DSL-Ausdrücken.
### Optimiertes Konfigurationsmanagement
Für eine effektive Konfiguration ist es unerlässlich, eine Reihe von Einstellungen zu definieren, darunter Whitelists, benutzerdefinierte Regeldefinitionen, Protokollierungseinstellungen und andere Parameter. Das Paket [`option`](https://pkg.go.dev/github.com/teler-sh/teler-waf/option) optimiert diesen Konfigurationsworkflow, indem es Ihnen ermöglicht, Konfigurationsdaten effizient aus JSON- und YAML-Formaten zu entpacken oder zu laden, in ein Format, das teler-waf leicht verstehen und umsetzen kann.```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)
Standardmäßig speichert teler-waf alle eingehenden Anfragen für 15 Minuten zwischen und löscht sie alle 20 Minuten, um die Leistung zu verbessern. Wenn Sie jedoch die Einstellungen noch an die Anforderungen Ihrer Anwendung anpassen, können Sie das Caching während der Entwicklung deaktivieren, indem Sie die Entwicklungsmodus-Option auf true setzen. Dadurch wird verhindert, dass eingehende Anfragen zwischengespeichert werden, und dies kann für Debugging-Zwecke hilfreich sein.```go
// Create a new instance of the Teler type using
// the New function & enable development mode option.
telerMiddleware := teler.New(teler.Options{
Development: true,
})
### Protokolle
Hier ist ein Beispiel dafür, wie die Protokollzeilen aussehen würden, wenn teler-waf eine Bedrohung in einer Anfrage erkennt:```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":""}}
Die id ist eine eindeutige Kennung, die generiert wird, wenn eine Anfrage von teler-waf abgelehnt wird. Sie ist in den HTTP-Antwortheadern der Anfrage enthalten (X-Teler-Req-Id) und kann verwendet werden, um Probleme mit Anfragen an die Website zu beheben.
Wenn beispielsweise eine Anfrage an eine Website einen HTTP-Fehlerstatuscode wie 403 Forbidden zurückgibt, kann die Teler-Anfrage-ID verwendet werden, um die spezifische Anfrage zu identifizieren, die den Fehler verursacht hat, und bei der Fehlerbehebung zu helfen.
Teler-Anfrage-IDs werden von teler-waf verwendet, um Anfragen an seine Webanwendung zu verfolgen, und können nützlich sein, um Traffic-Muster auf einer Website zu debuggen und zu analysieren.
Standardmäßig verwendet teler-waf die DefaultHTMLResponse als Standardantwort, wenn eine Anfrage abgelehnt oder blockiert wird. Allerdings bietet teler-waf ein hohes Maß an Anpassungsmöglichkeiten, die es Ihnen ermöglichen, die Antwort an Ihre spezifischen Anforderungen anzupassen. Die Anpassung kann mithilfe der Optionen Status, HTML oder HTMLFile erfolgen, die alle Teil der Response-Schnittstelle sind.
So können Sie diese Optionen in Ihrem Code nutzen:```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", }, })
Mit diesem Maß an Anpassung können Sie personalisierte und informative Antworten erstellen, die angezeigt werden, wenn teler-waf eine Anfrage blockiert oder ablehnt. Die Option `HTML` ermöglicht es Ihnen, den gewünschten HTML-Inhalt direkt als Zeichenfolge anzugeben, während die Option `HTMLFile` es Ihnen ermöglicht, auf eine externe Datei zu verweisen, die die benutzerdefinierte HTML-Antwort enthält.
Darüber hinaus können Sie zur Verbesserung der Benutzererfahrung Platzhalter in Ihrem HTML-Inhalt verwenden, um dynamische Elemente zu generieren. Diese Platzhalter werden zur Laufzeit durch tatsächliche Werte ersetzt, was zu kontextuell relevanteren Antworten führt. Die verfügbaren und unterstützten Platzhalter sind:
* `{{ID}}`: Anfrage-IDs, die eine eindeutige Identifizierung jeder abgelehnten Anfrage ermöglichen.
* `{{message}}`: Abgelehnte Nachrichten, die den Grund für die Blockierung der Anfrage übermitteln.
* `{{threat}}`: Bedrohungskategorien, die Einblicke in die erkannte Sicherheitsbedrohung geben.
Durch die Integration dieser Platzhalter können Sie detaillierte und umfassende Antworten erstellen, die die Gründe für Anfrageablehnungen oder -blockierungen effektiv kommunizieren.
### Falco Sidekick
[Falco Sidekick](https://github.com/falcosecurity/falcosidekick) ist ein Tool, das Ereignisse von Falco, einem Open-Source-Cloud-Native-Runtime-Sicherheitsprojekt, empfängt und an verschiedene Ausgabekanäle sendet. Es ermöglicht Ihnen, Sicherheitswarnungen an verschiedene Drittanbietersysteme wie Slack, Elasticsearch, Loki, Grafana, Datadog und [weitere](https://github.com/falcosecurity/falcosidekick#outputs) weiterzuleiten. Dies ermöglicht Sicherheitsteams eine effiziente Überwachung und Reaktion auf Sicherheitsbedrohungen und Ereignisse in Echtzeit.
Die Integration von Falco Sidekick mit teler-waf ist ebenfalls möglich. Durch die Verwendung der Option `FalcoSidekickURL` können Sie teler-waf so konfigurieren, dass es Ereignisse an Falco Sidekick sendet, der sie dann für Sie empfängt und verarbeitet. Erstellen Sie dazu einfach eine neue Instanz des Typs `Teler` mit der Funktion `New` und geben Sie die Option `FalcoSidekickURL` mit der URL Ihrer Falco-Sidekick-Instanz an. Zum Beispiel:```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",
})
Once you have set up this integration, any threats detected by teler-waf will be sent to Falco Sidekick, which can then take appropriate actions based on the configuration you have set up. For instance, you can set up Falco Sidekick to automatically send alerts to your incident response team.
The event forwarded to Falco Sidekick instance includes the following information:
output: Represents the alert message.priority: The priority is consistently denoted as warning, a nod to the urgency associated with security-related events.rule: Indicates the specific rule (message) that matched the associated request.time: Event's generation timestamp.teler.caller: Identifies the application source that invoked teler-waf.teler.id: Represents a unique identifier for the rejected request.teler.threat: Specifies the category of the threat.teler.listen_addr: Denotes the network address on which teler-waf is listening for incoming requests.
request.body: Contains the body of the associated request.request.headers: Lists the headers from the associated request.Overall, Falco Sidekick is a versatile tool that can help you automate your security response process and improve your overall security posture. By leveraging its capabilities, you can ensure that your cloud-native applications are secure and protected against potential threats.
You can enhance your security monitoring by integrating teler WAF logs into Wazuh. To do this, use custom rules available in the extras/ directory.
Add the localfile element block below inside ossec_config element in the local configuration file:```xml
<ossec_config>
Dadurch kann Wazuh die teler WAF-Protokolle lesen und analysieren, was Ihren Netzwerkschutz verbessert und bessere Einblicke bietet.
Das teler-waf-Paket verwendet einen Datensatz von Bedrohungen, um jede eingehende Anfrage auf potenzielle Sicherheitsbedrohungen zu identifizieren und zu analysieren. Dieser Datensatz wird täglich aktualisiert, sodass Sie immer die neuesten Ressourcen zur Verfügung haben. Der Datensatz wird beim ersten Start zunächst im Cache-Verzeichnis auf Benutzerebene gespeichert (unter Unix-Systemen wird $XDG_CACHE_HOME/teler-waf zurückgegeben, wie in der XDG Base Directory Specification festgelegt, falls nicht leer, ansonsten $HOME/.cache/teler-waf. Unter Darwin wird $HOME/Library/Caches/teler-waf zurückgegeben. Unter Windows wird %LocalAppData%/teler-waf zurückgegeben. Unter Plan 9 wird $home/lib/cache/teler-waf zurückgegeben). Bei späteren Starts wird der zwischengespeicherte Datensatz verwendet, anstatt ihn erneut herunterzuladen.
[!NOTE] Die Bedrohungsdatensätze werden aus dem Repository teler-sh/teler-resources bezogen.
Es kann jedoch Situationen geben, in denen Sie die automatischen Updates des Bedrohungsdatensatzes deaktivieren möchten. Beispielsweise haben Sie möglicherweise eine langsame oder eingeschränkte Internetverbindung oder verwenden einen Computer mit eingeschränktem Dateizugriff. In diesen Fällen können Sie eine Option namens NoUpdateCheck auf true setzen, die verhindert, dass teler-waf den Datensatz automatisch aktualisiert.
[!CAUTION] Das Aktivieren von
InMemoryhat Vorrang und stellt sicher, dass automatische Updates aktiviert bleiben.```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, })
Schließlich kann es Fälle geben, in denen es notwendig ist, den Bedrohungsdatensatz in den Speicher zu laden, anstatt ihn in einem Benutzer-Cache-Verzeichnis zu speichern. Dies kann besonders nützlich sein, wenn Sie die Anwendung oder den Dienst auf einem distroless- oder Runtime-Image ausführen, bei dem der Dateizugriff eingeschränkt oder langsam sein kann. In diesem Szenario können Sie eine Option namens **InMemory** auf `true` setzen, wodurch der Bedrohungsdatensatz für schnelleren Zugriff in den Speicher geladen wird.```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] Dies kann auch mehr Systemressourcen verbrauchen, daher sollte man die Kompromisse abwägen, bevor man diese Entscheidung trifft.
Wenn Sie ein Sicherheitsproblem entdecken, teilen Sie es bitte umgehend mit, wir nehmen Sicherheit ernst!
Wenn Sie Informationen über ein Sicherheitsproblem oder eine Schwachstelle in diesem teler-waf-Paket haben und/oder in der Lage sind, erfolgreich etwas wie Cross-Site-Scripting (XSS) auszuführen und einen Alert in unserer Demo-Seite (siehe Ressourcen) zu öffnen, dann keinen öffentlichen Issue melden — senden Sie Ihren Bericht stattdessen bitte privat über das Schwachstellenmeldeformular.
Hier sind einige Einschränkungen bei der Verwendung von teler-waf:
> [!NOTE]
> Benchmarking-Ergebnisse können variieren und sind möglicherweise nicht konsistent. Der Datensatz [teler-resources](https://github.com/teler-sh/teler-resources) könnte seitdem zugenommen haben, was die Ergebnisse beeinflussen kann.
- **Komplexität der Konfiguration**: Die Konfiguration von teler-waf an die spezifischen Anforderungen Ihrer Anwendung kann komplex sein und ein gewisses Maß an Fachwissen im Bereich Websicherheit erfordern. Dies kann es für Personen, die nicht mit Anwendungsfirewalls und IDS-Systemen vertraut sind, schwierig machen, teler-waf ordnungsgemäß einzurichten und zu verwenden.
- **Eingeschränkter Schutz**: teler-waf ist keine perfekte Sicherheitslösung und kann möglicherweise nicht vor allen möglichen Angriffsarten schützen. Wie bei jedem Sicherheitssystem ist es wichtig, teler-waf regelmäßig zu überwachen und zu warten, um sicherzustellen, dass es das gewünschte Schutzniveau bietet.
#### Bekannte Probleme
Um eine Liste bekannter Probleme mit teler-waf anzuzeigen, filtern Sie die Issues bitte nach dem Label ["known-issue"](https://github.com/teler-sh/teler-waf/issues?q=is%3Aopen+is%3Aissue+label%3Aknown-issue).
## Community
Wir nutzen die Google Groups als unsere dedizierte Mailingliste. Abonnieren Sie [teler-announce](https://groups.google.com/g/teler-announce) über [[email protected]](mailto:[email protected]) für wichtige Ankündigungen, wie die Verfügbarkeit neuer Versionen. Dieses Abonnement hält Sie über bedeutende Entwicklungen im Zusammenhang mit [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) und [teler Resources](https://github.com/teler-sh/teler-resources) auf dem Laufenden.
Für [Anfragen](https://github.com/teler-sh/teler-waf/discussions/categories/q-a), [Diskussionen](https://github.com/teler-sh/teler-waf/discussions) oder [Probleme](https://github.com/teler-sh/teler-waf/issues) werden diese hier auf GitHub verfolgt. Hier verwalten und bearbeiten wir diese Aspekte unseres Community-Engagements aktiv.
## Lizenz
Dieses Paket wird unter einer dualen Lizenz bereitgestellt: der [Apache License 2.0](https://github.com/teler-sh/teler-waf/blob/HEAD/LICENSE-APACHE) und der [Elastic License 2.0 (ELv2)](https://github.com/teler-sh/teler-waf/blob/HEAD/LICENSE-ELASTIC) (für das Hauptpaket **teler**).
Sie können es frei innerhalb Ihrer Organisation nutzen, um Ihre Anwendungen zu schützen. Sie dürfen das Hauptpaket jedoch nicht zur Erstellung eines Cloud-, gehosteten oder verwalteten Dienstes oder für kommerzielle Zwecke verwenden, da Sie dafür eine kommerzielle Lizenz benötigen – diese Option ist derzeit jedoch nicht verfügbar. Wenn Sie an einer solchen kommerziellen Lizenz für Verwendungen interessiert sind, die nicht durch [ELv2](https://github.com/teler-sh/teler-waf/blob/HEAD/LICENSE-ELASTIC) autorisiert sind, wenden Sie sich bitte an **@dwisiswant0**.
teler-waf und alle Beiträge sind urheberrechtlich geschützt © Dwi Siswanto 2022–2024.
request.ip_addr: Discloses the IP address of the associated request.request.method: States the HTTP method employed in the associated request.request.path: Refers to the path of the associated request.