teler-sh/teler-wafteler-waf è un middleware HTTP Go che protegge i servizi web locali da minacce OWASP Top 10, vulnerabilità note, attori malintenzionati, botnet, crawler indesiderati e attacchi di forza bruta.
teler-waf è una soluzione di sicurezza completa per applicazioni web basate su Go. Funge da middleware HTTP, fornendo un'interfaccia semplice per integrare le funzionalità IDS con teler IDS nelle applicazioni Go esistenti. Utilizzando teler-waf, puoi contribuire a proteggerti da una varietà di attacchi basati sul web, come cross-site scripting (XSS) e SQL injection.
Il pacchetto include un net/http.Handler standard, che ne facilita l'integrazione nel routing della tua applicazione. Quando un client effettua una richiesta a una rotta protetta da teler-waf, la richiesta viene prima controllata rispetto a teler IDS per rilevare pattern dannosi noti. Se non vengono rilevati pattern dannosi, la richiesta viene quindi passata per ulteriori elaborazioni.
Oltre a fornire protezione contro gli attacchi basati sul web, teler-waf può anche contribuire a migliorare la sicurezza e l'integrità complessiva della tua applicazione. È altamente configurabile, consentendoti di adattarlo alle esigenze specifiche della tua applicazione.
Vedi anche:
teler-waf offre una gamma di potenti funzionalità progettate per migliorare la sicurezza delle tue applicazioni web Go:
In sintesi, teler-waf fornisce una soluzione di sicurezza completa per applicazioni web basate su Go, aiutando a proteggere dagli attacchi basati sul web e migliorando la sicurezza e l'integrità complessiva della tua applicazione.
Dipendenze:
Per installare teler-waf nella tua applicazione Go, esegui il seguente comando per scaricare e installare il pacchetto teler-waf:```console go get github.com/teler-sh/teler-waf
## Utilizzo
> [!WARNING]
> **Avviso di deprecazione**: Le esclusioni di minacce (`Excludes`) saranno deprecate nella prossima release (**v2**). Vedi [#73](https://github.com/teler-sh/teler-waf/discussions/73) e [#64](https://github.com/teler-sh/teler-waf/issues/64).
Ecco un esempio di come utilizzare teler-waf in un'applicazione Go:
1. Importa il pacchetto teler-waf nel tuo codice Go:```go
import "github.com/teler-sh/teler-waf"
New per creare una nuova istanza del tipo Teler. Questa funzione accetta una varietà di parametri opzionali che possono essere utilizzati per configurare teler-waf in base alle esigenze specifiche della tua applicazione.```go
waf := teler.New()3. Utilizza il metodo `Handler` dell'istanza `Teler` per creare un `net/http.Handler`. Questo handler può quindi essere utilizzato nel routing HTTP della tua applicazione per applicare le misure di sicurezza di teler-waf a rotte specifiche.```go
handler := waf.Handler(http.HandlerFunc(yourHandlerFunc))
handler nel routing HTTP della tua applicazione per applicare le misure di sicurezza di teler-waf a rotte specifiche.```go
http.Handle("/path", handler)Ecco fatto! Hai configurato teler-waf nella tua applicazione Go.
**Opzioni:**
Per un elenco delle opzioni disponibili per personalizzare teler-waf, consulta la struttura [`teler.Options`](https://pkg.go.dev/github.com/teler-sh/teler-waf#Options).
### Esempi
Ecco un esempio di come personalizzare le opzioni e le regole per 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)
}
Per maggiori esempi sull'uso di teler-waf o su come integrarlo con qualsiasi framework, dai un'occhiata alla directory examples/.
[!SUGGERIMENTO] Se desideri esplorare le configurazioni, approfondire la creazione di regole personalizzate e comporre espressioni DSL, puoi fare pratica e acquisire esperienza pratica utilizzando questo playground di teler WAF. Qui puoi anche simulare richieste personalizzate per soddisfare le esigenze specifiche della tua applicazione.
Per integrare regole personalizzate nel middleware teler-waf, hai due scelte: Customs e CustomsFromFile. Queste opzioni offrono flessibilità per creare i tuoi controlli di sicurezza o sovrascrivere i controlli predefiniti forniti da teler-waf.
CustomsPuoi definire regole personalizzate direttamente utilizzando l'opzione Customs, come mostrato nell'esempio sopra.
Nell'opzione Customs, fornisci un array di strutture teler.Rule. Ogni teler.Rule rappresenta una regola personalizzata con un nome univoco e una condizione che specifica come vengono valutate le singole condizioni all'interno della regola (or o and). La regola consiste in una o più strutture teler.Condition, ciascuna delle quali definisce una condizione specifica da verificare. Le condizioni possono basarsi sul metodo HTTP, elemento (intestazioni, corpo, URI o qualsiasi), un pattern regex o un'espressione DSL da confrontare.
CustomsFromFileIn alternativa, l'opzione CustomsFromFile consente di caricare regole personalizzate da file esterni, offrendo ancora maggiore flessibilità e gestibilità. Queste regole possono essere definite in formato YAML, con ogni file contenente una o più regole. Ecco un esempio di struttura YAML che rappresenta una regola personalizzata:```yaml
> [!IMPORTANT]
> Si noti che i parametri `condition`, `method` ed `element` sono opzionali. I valori predefiniti assegnati sono: `condition` è impostato su **or**, `method` su **ALL** ed `element` su **ANY**. Pertanto, se desiderato, è possibile lasciare vuoti tali parametri. Il parametro `pattern` è obbligatorio, a meno che non si specifichi un'espressione `dsl`. In tali casi, quando viene fornita un'espressione `dsl`, teler-waf ignorerà qualsiasi valore assegnato a `method` ed `element`, anche se definiti. Per vedere alcuni esempi, è possibile fare riferimento alla directory [`tests/rules/`](https://github.com/teler-sh/teler-waf/tree/master/tests/rules/valid).
È possibile specificare l'opzione `CustomsFromFile` con il percorso effettivo del file o un pattern glob che indica la posizione dei file di regole personalizzate. Ad esempio:```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",
})
Con CustomsFromFile, fornisci il percorso del file o il pattern glob in cui si trovano i tuoi file di regole personalizzate. Il pattern può includere wildcard per corrispondere a più file o a una directory e le sue sottodirectory. Ogni file dovrebbe contenere una o più regole personalizzate definite nel formato YAML appropriato.
Utilizzando l'opzione Customs, CustomsFromFile o entrambe, puoi integrare perfettamente le tue regole personalizzate nel middleware teler-waf, migliorando le sue capacità di sicurezza per soddisfare i tuoi requisiti specifici.
Le espressioni DSL (Domain-Specific Language) forniscono un potente mezzo per definire condizioni utilizzate per valutare le richieste in arrivo nel contesto di regole personalizzate o whitelist. Con le espressioni DSL, puoi creare condizioni sofisticate e mirate basate su diversi attributi delle richieste in arrivo. Ecco alcuni esempi illustrativi di codice di espressioni DSL:
Controlla se gli header della richiesta in arrivo contengono "curl":```sql request.Headers contains "curl"
Controlla se il metodo della richiesta in arrivo è "GET":```sql
request.Method == "GET"
Controlla se il metodo della richiesta in ingresso è "GET" o "POST" utilizzando l'espressione regolare, operatore matches:```sql
request.Method matches "^(POS|GE)T$"
Verifica se l'indirizzo IP della richiesta in arrivo proviene da localhost:```sql
request.IP in ["127.0.0.1", "::1", "0.0.0.0"]
Controlla se un qualsiasi elemento nella richiesta contiene la stringa "foo":```console one(request.ALL, # contains "foo")
Verifica se il corpo della richiesta in arrivo contiene "foo":```sql
request.Body contains "foo"
Verifica se la categoria di minaccia attualmente analizzata è bad crawler o directory bruteforce:```sql threat in [BadCrawler, DirectoryBruteforce]
Questi esempi offrono uno sguardo sulle capacità espressive delle espressioni DSL, permettendoti di definire condizioni complesse basate su vari attributi delle richieste. Sfruttando queste espressioni, puoi definire efficacemente i criteri per valutare le richieste in arrivo e personalizzare di conseguenza le tue regole personalizzate o le whitelist, consentendo un controllo granulare sul comportamento della tua applicazione.
#### Variabili disponibili
Quando lavori con le espressioni DSL, hai accesso a varie variabili che forniscono informazioni preziose sulle richieste in arrivo e sulla categoria di minaccia in analisi. Ecco una descrizione dettagliata delle variabili disponibili:
- **Categoria di minaccia**
Tutti gli identificatori costanti del tipo `threat.Threat` possono essere usati come variabili valide. Questi identificatori rappresentano diverse categorie di minaccia rilevanti per la tua analisi.
- **`request`**
La variabile `request` rappresenta la richiesta in arrivo e fornisce accesso ai suoi campi e ai corrispondenti valori. Le seguenti sotto-variabili sono disponibili all'interno della variabile `request`:
- `request.URI`: Rappresenta l'URI della richiesta in arrivo, inclusi percorso, query, parametri e frammenti.
- `request.Headers`: Rappresenta gli header della richiesta in arrivo, presentati su più righe.
- `request.Body`: Rappresenta il corpo della richiesta in arrivo.
- `request.Method`: Rappresenta il metodo della richiesta in arrivo.
- `request.IP`: Rappresenta l'indirizzo IP del client associato alla richiesta in arrivo.
- `request.ALL`: Rappresenta tutti i valori stringa dei campi della richiesta menzionati sopra in una slice.
- **`threat`**
La variabile `threat` rappresenta la categoria di minaccia in analisi. È del tipo `threat.Threat` e ti permette di valutare e prendere decisioni basate sulla specifica categoria di minaccia associata alla richiesta.
Utilizzando queste variabili all'interno delle tue espressioni DSL, puoi accedere e manipolare efficacemente gli attributi delle richieste in arrivo e valutare le categorie di minaccia rilevanti. Questo ti permette di creare condizioni di regole personalizzate<!-- and whitelists--> che sono adattate al tuo caso d'uso specifico.
#### Funzioni disponibili
Inoltre, hai accesso a una varietà di funzioni. Queste funzioni comprendono sia le [funzioni incorporate](https://expr.medv.io/docs/Language-Definition#built-in-functions) fornite dal pacchetto expr sia quelle definite specificamente all'interno del pacchetto DSL. Le funzioni utilizzano le funzionalità offerte dal pacchetto integrato `strings` di Go. Ecco un elenco dettagliato delle funzioni disponibili:
- `cidr`: Ottieni tutti gli indirizzi IP nell'intervallo con un dato CIDR.
- `clone`: Crea una copia di una stringa.
- `containsAny`: Verifica se una stringa contiene una qualsiasi delle sottostringhe specificate.
- `equalFold`: Confronta due stringhe in modo case-insensitive.
- `hasPrefix`: Verifica se una stringa ha un prefisso specificato.
- `hasSuffix`: Verifica se una stringa ha un suffisso specificato.
- `join`: Concatena più stringhe usando un separatore specificato.
- `repeat`: Ripete una stringa un numero specificato di volte.
- `replace`: Sostituisce occorrenze di una sottostringa all'interno di una stringa.
- `replaceAll`: Sostituisce tutte le occorrenze di una sottostringa all'interno di una stringa.
- `request`: Accede alle informazioni specifiche della richiesta all'interno dell'espressione DSL.
- `threat`: Accede alle informazioni relative alla categoria di minaccia in analisi.
- `title`: Converte una stringa in formato titolo.
- `toLower`: Converte una stringa in minuscolo.
- `toTitle`: Converte una stringa in formato titolo.
- `toUpper`: Converte una stringa in maiuscolo.
- `toValidUTF8`: Converte una stringa in una stringa codificata UTF-8 valida.
- `trim`: Rimuove spazi bianchi iniziali e finali da una stringa.
- `trimLeft`: Rimuove spazi bianchi iniziali da una stringa.
- `trimPrefix`: Rimuove un prefisso specificato da una stringa.
- `trimRight`: Rimuove spazi bianchi finali da una stringa.
- `trimSpace`: Rimuove spazi bianchi iniziali e finali e compatta spazi bianchi consecutivi all'interno di una stringa.
- `trimSuffix`: Rimuove un suffisso specificato da una stringa.
Per dettagli più completi su operatori e funzioni integrate, consulta la [documentazione di Expr](https://expr.medv.io/docs/Getting-Started). Fornisce una guida completa all'utilizzo degli operatori e all'esplorazione delle funzioni integrate disponibili nelle tue espressioni DSL.
### Gestione Semplificata della Configurazione
Per una configurazione efficace, è essenziale definire una serie di impostazioni, incluse whitelist, definizioni di regole personalizzate, preferenze di logging e altri parametri. Il pacchetto [`option`](https://pkg.go.dev/github.com/teler-sh/teler-waf/option) semplifica questo flusso di lavoro di configurazione permettendoti di unmarshalizzare o caricare efficientemente i dati di configurazione dai formati JSON e YAML in un formato che teler-waf può comprendere e implementare prontamente.```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)
Per impostazione predefinita, teler-waf memorizza nella cache tutte le richieste in arrivo per 15 minuti & le cancella ogni 20 minuti per migliorare le prestazioni. Tuttavia, se stai ancora personalizzando le impostazioni per soddisfare i requisiti della tua applicazione, puoi disabilitare la memorizzazione nella cache durante lo sviluppo impostando l'opzione della modalità di sviluppo su true. Questo impedirà la memorizzazione nella cache delle richieste in arrivo e può essere utile per scopi di debug.```go
// Create a new instance of the Teler type using
// the New function & enable development mode option.
telerMiddleware := teler.New(teler.Options{
Development: true,
})
### Log
Ecco un esempio di come apparirebbero le righe di log se teler-waf rileva una minaccia su una richiesta:```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 è un identificatore univoco generato quando una richiesta viene respinta da teler-waf. Viene incluso nelle intestazioni di risposta HTTP della richiesta (X-Teler-Req-Id) e può essere utilizzato per risolvere problemi relativi alle richieste effettuate al sito web.
Ad esempio, se una richiesta a un sito web restituisce un codice di stato di errore HTTP, come un 403 Forbidden, l'ID della richiesta teler può essere utilizzato per identificare la richiesta specifica che ha causato l'errore e aiutare a risolvere il problema.
Gli ID delle richieste teler sono utilizzati da teler-waf per tracciare le richieste effettuate alla sua applicazione web e possono essere utili per il debug e l'analisi dei pattern di traffico su un sito web.
Per impostazione predefinita, teler-waf utilizza DefaultHTMLResponse come risposta standard quando una richiesta viene respinta o bloccata. Tuttavia, teler-waf offre un alto grado di personalizzazione, dandoti la possibilità di adattare la risposta alle tue esigenze specifiche. La personalizzazione può essere ottenuta utilizzando le opzioni Status, HTML o HTMLFile, tutte parte dell'interfaccia Response.
Ecco come puoi utilizzare queste opzioni nel tuo codice:```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", }, })
Con questo livello di personalizzazione, puoi costruire risposte personalizzate e informative da mostrare quando teler-waf blocca o rifiuta una richiesta. L'opzione `HTML` ti consente di specificare direttamente il contenuto HTML desiderato come stringa, mentre l'opzione `HTMLFile` ti permette di fare riferimento a un file esterno contenente la risposta HTML personalizzata.
Inoltre, per migliorare l'esperienza utente, puoi sfruttare i segnaposto nel tuo contenuto HTML per generare elementi dinamici. Durante l'esecuzione, questi segnaposto verranno sostituiti con valori reali, producendo risposte più pertinenti al contesto. I segnaposto disponibili e supportati includono:
* `{{ID}}`: ID della richiesta, che consente l'identificazione univoca di ogni richiesta rifiutata.
* `{{message}}`: Messaggi di rifiuto che indicano il motivo del blocco della richiesta.
* `{{threat}}`: Categorie di minaccia, che forniscono informazioni sulla minaccia di sicurezza rilevata.
Incorporando questi segnaposto, puoi creare risposte dettagliate e complete che comunicano efficacemente le motivazioni alla base dei rifiuti o dei blocchi delle richieste.
### Falco Sidekick
[Falco Sidekick](https://github.com/falcosecurity/falcosidekick) è uno strumento che riceve eventi da Falco, un progetto open-source di runtime security cloud-native, e li invia a diversi canali di output. Ti permette di inoltrare gli avvisi di sicurezza a vari sistemi di terze parti come Slack, Elasticsearch, Loki, Grafana, Datadog e [altri](https://github.com/falcosecurity/falcosidekick#outputs). Questo consente ai team di sicurezza di monitorare e rispondere in modo efficiente alle minacce e agli eventi di sicurezza in tempo reale.
È possibile anche integrare Falco Sidekick con teler-waf. Utilizzando l'opzione `FalcoSidekickURL`, puoi configurare teler-waf per inviare eventi a Falco Sidekick, che li riceverà e li elaborerà per te. Per farlo, crea semplicemente una nuova istanza del tipo `Teler` usando la funzione `New` e fornisci l'opzione `FalcoSidekickURL` con l'URL della tua istanza di Falco Sidekick. Per esempio:```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",
})
Una volta configurata questa integrazione, tutte le minacce rilevate da teler-waf verranno inviate a Falco Sidekick, che potrà quindi intraprendere le azioni appropriate in base alla configurazione impostata. Ad esempio, è possibile configurare Falco Sidekick per inviare automaticamente avvisi al team di risposta agli incidenti.
L'evento inoltrato all'istanza di Falco Sidekick include le seguenti informazioni:
output: Rappresenta il messaggio di avviso.priority: La priorità è costantemente indicata come warning, un cenno all'urgenza associata agli eventi di sicurezza.rule: Indica la regola specifica (messaggio) che ha corrisposto alla richiesta associata.time: Timestamp di generazione dell'evento.teler.caller: Identifica la sorgente dell'applicazione che ha invocato teler-waf.teler.id: Rappresenta un identificatore univoco per la richiesta respinta.teler.threat: Specifica la categoria della minaccia.teler.listen_addr: Denota l'indirizzo di rete su cui teler-waf è in ascolto per le richieste in arrivo.
request.body: Contiene il corpo della richiesta associata.request.headers: Elenca le intestazioni della richiesta associata.In generale, Falco Sidekick è uno strumento versatile che può aiutarti ad automatizzare il processo di risposta agli incidenti di sicurezza e migliorare la tua postura di sicurezza complessiva. Sfruttando le sue capacità, puoi garantire che le tue applicazioni cloud-native siano sicure e protette contro potenziali minacce.
Puoi migliorare il tuo monitoraggio della sicurezza integrando i log di teler WAF in Wazuh. Per farlo, utilizza le regole personalizzate disponibili nella directory extras/.
Aggiungi il blocco dell'elemento localfile qui sotto all'interno dell'elemento ossec_config nel file di configurazione locale:```xml
<ossec_config>
In questo modo, Wazuh sarà in grado di leggere e analizzare i log di teler WAF, migliorando la protezione della rete e fornendo migliori informazioni.
Il pacchetto teler-waf utilizza un dataset di minacce per identificare e analizzare ogni richiesta in arrivo alla ricerca di potenziali minacce alla sicurezza. Questo dataset viene aggiornato quotidianamente, il che significa che avrai sempre la risorsa più recente. Il dataset viene inizialmente archiviato nella directory cache a livello utente (nei sistemi Unix, restituisce $XDG_CACHE_HOME/teler-waf come specificato dalla XDG Base Directory Specification
se non vuota, altrimenti $HOME/.cache/teler-waf. Su Darwin, restituisce $HOME/Library/Caches/teler-waf. Su Windows, restituisce %LocalAppData%/teler-waf. Su Plan 9, restituisce $home/lib/cache/teler-waf) al primo avvio. I successivi avvii utilizzeranno il dataset memorizzato nella cache, invece di scaricarlo nuovamente.
[!NOTE] I dataset delle minacce sono ottenuti dal repository teler-sh/teler-resources.
Tuttavia, potrebbero esserci situazioni in cui si desidera disabilitare gli aggiornamenti automatici del dataset delle minacce. Ad esempio, potresti avere una connessione internet lenta o limitata, oppure potresti utilizzare una macchina con accesso limitato ai file. In questi casi, puoi impostare un'opzione chiamata NoUpdateCheck su true, che impedirà a teler-waf di aggiornare automaticamente il dataset.
[!CAUTION] Abilitare
InMemoryha la precedenza e garantisce che gli aggiornamenti automatici rimangano abilitati.```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, })
Finalmente, possono esserci casi in cui è necessario caricare il dataset di minacce in memoria anziché salvarlo in una directory di cache a livello utente. Ciò può essere particolarmente utile se si esegue l'applicazione o il servizio su un'immagine distroless o runtime, dove l'accesso ai file potrebbe essere limitato o lento. In questo scenario, è possibile impostare un'opzione chiamata **InMemory** su `true`, che caricherà il dataset di minacce in memoria per un accesso più veloce.```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] Questo potrebbe anche consumare più risorse di sistema, quindi vale la pena considerare i compromessi prima di prendere questa decisione.
Se scopri un problema di sicurezza, segnalalo immediatamente alla loro attenzione, prendiamo sul serio la sicurezza!
Se hai informazioni su un problema di sicurezza o una vulnerabilità in questo pacchetto teler-waf, e/o sei in grado di eseguire con successo, ad esempio, cross-site scripting (XSS) e far apparire un avviso nel nostro sito demo (vedi risorse), per favore NON aprire un issue pubblico — invece, invia gentilmente il tuo report privatamente tramite il modulo di segnalazione delle vulnerabilità.
Ecco alcune limitazioni nell'uso di teler-waf:
> [!NOTE]
> I risultati dei benchmark possono variare e potrebbero non essere coerenti. Il dataset di [teler-resources](https://github.com/teler-sh/teler-resources) potrebbe essere aumentato da allora, e questo potrebbe influire sui risultati.
- **Complessità di configurazione**: Configurare teler-waf per soddisfare le esigenze specifiche della tua applicazione può essere complesso e potrebbe richiedere un certo livello di competenza in sicurezza web. Questo può rendere difficile per chi non ha familiarità con firewall applicativi e sistemi IDS impostare e utilizzare correttamente teler-waf.
- **Protezione limitata**: teler-waf non è una soluzione di sicurezza perfetta e potrebbe non essere in grado di proteggere da tutti i possibili tipi di attacchi. Come per qualsiasi sistema di sicurezza, è importante monitorare e mantenere regolarmente teler-waf per assicurarsi che fornisca il livello di protezione desiderato.
#### Problemi noti
Per visualizzare un elenco di problemi noti con teler-waf, filtra le issues tramite l'etichetta ["known-issue"](https://github.com/teler-sh/teler-waf/issues?q=is%3Aopen+is%3Aissue+label%3Aknown-issue).
## Comunità
Utilizziamo Google Groups come nostra mailing list dedicata. Iscriviti a [teler-announce](https://groups.google.com/g/teler-announce) tramite [[email protected]](mailto:[email protected]) per annunci importanti, come la disponibilità di nuove versioni. Questa iscrizione ti terrà informato sugli sviluppi significativi relativi a [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) e [teler Resources](https://github.com/teler-sh/teler-resources).
Per qualsiasi [richiesta](https://github.com/teler-sh/teler-waf/discussions/categories/q-a), [discussione](https://github.com/teler-sh/teler-waf/discussions) o [problema](https://github.com/teler-sh/teler-waf/issues) vengono tracciati qui su GitHub. È qui che gestiamo e affrontiamo attivamente questi aspetti del nostro coinvolgimento nella comunità.
## Licenza
Questo pacchetto è reso disponibile con una doppia licenza: [Apache License 2.0](https://github.com/teler-sh/teler-waf/blob/HEAD/LICENSE-APACHE) e [Elastic License 2.0 (ELv2)](https://github.com/teler-sh/teler-waf/blob/HEAD/LICENSE-ELASTIC) (per il pacchetto principale, **teler**).
Puoi usarlo liberamente all'interno della tua organizzazione per proteggere le tue applicazioni. Tuttavia, non puoi utilizzare il pacchetto principale per creare un servizio cloud, ospitato o gestito, o per scopi commerciali, poiché avresti bisogno di una licenza commerciale per farlo – anche se questa opzione non è attualmente disponibile. Se sei interessato a ottenere questa licenza commerciale per usi non autorizzati da [ELv2](https://github.com/teler-sh/teler-waf/blob/HEAD/LICENSE-ELASTIC), contatta **@dwisiswant0**.
teler-waf e qualsiasi contributo sono protetti da copyright © di Dwi Siswanto 2022-2024.
request.ip_addr: Rivela l'indirizzo IP della richiesta associata.request.method: Indica il metodo HTTP utilizzato nella richiesta associata.request.path: Si riferisce al percorso della richiesta associata.