Questa pagina è stata tradotta dall'API Cloud Translation.

Configurazione degli attributi del linguaggio delle regole personalizzate

Ogni regola dei criteri di sicurezza di Google Cloud Armor ha una priorità, una condizione di corrispondenza e un'azione. Google Cloud Armor esegue l'azione della regola con la priorità più alta che corrisponde a una richiesta. Le regole con una priorità inferiore a quella della regola di corrispondenza con la priorità più alta non vengono valutate, anche se hanno le stesse condizioni di corrispondenza.

Ogni regola dei criteri di sicurezza supporta due tipi di condizioni di corrispondenza:

Una condizione di corrispondenza di base contiene elenchi di indirizzi IP o elenchi di intervalli di indirizzi IP. Le condizioni di corrispondenza di base vengono definite utilizzando il flag --src-ip-ranges durante la creazione di una regola utilizzando Google Cloud CLI.
Una condizione di corrispondenza avanzata contiene un'espressione con un massimo di cinque sottoespressioni che possono corrispondere a una serie di attributi di una richiesta in entrata. Le condizioni di corrispondenza avanzate vengono definite utilizzando il flag --expression quando si crea una regola utilizzando Google Cloud CLI.

Questa pagina descrive le condizioni di corrispondenza avanzate e il linguaggio delle regole personalizzate di Google Cloud Armor che utilizzi per scrivere espressioni nelle condizioni di corrispondenza avanzate delle regole dei criteri di sicurezza. Il linguaggio delle regole personalizzate di Google Cloud Armor è un sottoinsieme del Common Expression Language (CEL). Le espressioni scritte nel linguaggio delle regole personalizzate di Google Cloud Armor richiedono due componenti:

L'attributo: i dati da esaminare
L'operazione: come utilizzare i dati

Ad esempio, la seguente espressione utilizza gli attributi origin.ip e 9.9.9.0/24 nell'operazione inIpRange(). In questo caso, l'espressione restituisce true se origin.ip è compreso nell'intervallo di indirizzi IP 9.9.9.0/24.

inIpRange(origin.ip, '9.9.9.0/24')

Anche se l'espressione dell'esempio precedente corrisponde solo all'indirizzo IP di origine, quando utilizzi l'espressione di esempio in una regola dei criteri di sicurezza di Google Cloud Armor, la regola è considerata una regola con condizioni di corrispondenza avanzate dal punto di vista della quota. Per ulteriori informazioni, consulta Quote e limiti di Google Cloud Armor.

Operazioni

Il seguente riferimento descrive gli operatori che puoi utilizzare con gli attributi (rappresentati da x, y e k) per definire le espressioni delle regole.

Operazioni	Espressioni	Descrizione
Equality	`x == y`	Restituisce true se x è uguale a y.
Uguaglianza, valore letterale di stringa	`x == "foo"`	Restituisce true se x è uguale al valore letterale stringa costante specificato.
Uguaglianza, valore letterale di stringa non elaborata	`x == R"fo'o"`	Restituisce true se x è uguale al valore letterale della stringa non elaborata specificata che non interpreta le sequenze di escape. I valori letterali stringa non elaborata sono utili per esprimere stringhe che devono utilizzare caratteri di sequenza di escape.
NOT logico	`!x`	Restituisce true se il valore booleano x è false oppure restituisce false se il valore booleano x è true.
Disuguaglianza	`x != y`	Restituisce true se x è diverso da y.
Concatenazione	`x + y`	Restituisce la stringa concatenata xy.
AND logico	`x && y`	Restituisce true se sia x che y sono true.
OR logico	`x \|\| y`	Restituisce true se x, y o entrambi sono true.
Contiene sottostringa	`x.contains(y)`	Restituisce true se la stringa x contiene la sottostringa y.
Inizia con la sottostringa	`x.startsWith(y)`	Restituisce true se la stringa x inizia con la sottostringa y.
Termina con sottostringa	`x.endsWith(y)`	Restituisce true se la stringa x termina con la sottostringa y.
Corrispondenza mediante espressione regolare	`x.matches(y)`	Restituisce true se la stringa x corrisponde parzialmente al pattern y RE2 specificato. Il pattern RE2 viene compilato utilizzando l'opzione RE2::Latin1 che disabilita le funzionalità Unicode.
Indirizzo IP compreso nell'intervallo	`inIpRange(x, y)`	Restituisce true se l'indirizzo IP x è contenuto nell'intervallo IP y.
Minuscolo	`x.lower()`	Restituisce il valore in minuscolo della stringa x.
Maiuscole	`x.upper()`	Restituisce il valore in maiuscolo della stringa x.
Valore decodificato Base64	`x.base64Decode()`	Restituisce il valore decodificato in Base64 di x; i caratteri `_ -` vengono prima sostituiti rispettivamente con `/ +`. Restituisce `""` (stringa vuota) se x non è un valore base64 valido.
Valore della mappa chiavi	`m['k']`	Restituisce il valore della chiave k nella mappa da stringa a stringa m se k è disponibile; in caso contrario, restituisce un errore. L'approccio consigliato è verificare prima la disponibilità utilizzando `"has(m['k'])==true"`.
Controllare la disponibilità delle chiavi in una mappa	`has(m['k'])`	Restituisce true se la chiave k è disponibile nella mappa m.
Converti in numero intero	`int(x)`	Converte il risultato della stringa di x in un tipo `int`. Può quindi essere utilizzato per eseguire un confronto tra numeri interi utilizzando operatori aritmetici standard come > e <=. Questa operazione funziona solo per i valori che devono essere numeri interi.
Lunghezza	`size(x)`	Restituisce la lunghezza della stringa x.
Decodifica URL	`x.urlDecode()`	Restituisce il valore decodificato dall'URL di x; le sequenze di caratteri nel formato `%##` vengono sostituite con gli equivalenti non ASCII e `+` viene sostituito con uno spazio. Le codifiche non valide vengono restituite così come sono.
Decodifica URL (Unicode)	`x.urlDecodeUni()`	Restituisce il valore decodificato dall'URL di x; oltre a `urlDecode()`, gestisce anche le sequenze di caratteri Unicode nel formato `%u###`. Le codifiche non valide vengono restituite così come sono.
Converti utf8 in Unicode	`x.utf8ToUnicode()`	Restituisce la rappresentazione Unicode in minuscolo di un valore x codificato in UTF-8.

Attributi

Gli attributi rappresentano le informazioni di una richiesta in entrata, ad esempio l'indirizzo IP di origine o il percorso URL richiesto.

Campo	Tipo	Descrizione del campo
`origin.ip`	string	L'indirizzo IP di origine della richiesta.
`origin.user_ip`	string	L'indirizzo IP del client di origine, incluso in `HTTP-HEADER` da un proxy upstream. Prima di utilizzare questo attributo, devi configurare l'opzione `userIpRequestHeaders[]` nel campo `advancedOptionsConfig` del criterio di sicurezza in modo che corrisponda a un'origine come `True-Client-IP`, `X-Forwarded-For` o `X-Real-IP`. Se non configuri l'opzione `userIpRequestHeaders[]`, se l'intestazione configurata contiene valori di indirizzo IP non validi o se l'intestazione configurata non è presente, `origin.user_ip` viene impostato per impostazione predefinita su `origin.ip`. Per ulteriori informazioni, consulta il riferimento alla risorsa securityPolicy.
`origin.tls_ja4_fingerprint`	string	Impronta TLS/SSL JA4 se il client si connette utilizzando `HTTPS`, `HTTP/2` o `HTTP/3`. Se non disponibile, viene restituita una stringa vuota.
`origin.tls_ja3_fingerprint`	string	Impronta JA3 TLS/SSL se il client si connette utilizzando `HTTPS`, `HTTP/2` o `HTTP/3`. Se non disponibile, viene restituita una stringa vuota.
`request.headers`	mappa	Una mappa stringa-stringa delle intestazioni delle richieste HTTP. Se un'intestazione contiene più valori, il valore in questa mappa è una stringa separata da virgole di tutti i valori dell'intestazione. Le chiavi in questa mappa contengono solo lettere minuscole. Tutte le intestazioni accettate dai bilanciatori del carico delle applicazioni esterni vengono ispezionate e si applicano le stesse limitazioni delle intestazioni. L'approccio consigliato è verificare prima la disponibilità utilizzando `has()`, ad esempio `has(request.headers['header-key']) && request.headers['header-key'] != 'header-value'`.
`request.method`	string	Il metodo di richiesta HTTP, ad esempio `GET` o `POST`.
`request.path`	string	Il percorso URL HTTP richiesto.
`request.scheme`	string	Lo schema URL HTTP, ad esempio `http` o `https`. I valori di questo attributo sono tutti in minuscolo.
`request.query`	string	La query URL HTTP nel formato `name1=value&name2=value2`, come appare nella prima riga della richiesta HTTP. Non viene eseguita alcuna decodifica.
`origin.region_code`	string	Il codice paese Unicode associato all'IP di origine, ad esempio `US`. Se crei una regola o un'espressione che utilizza i codici paese o regione ISO 3166-1 alpha 2, Google Cloud Armor tratta ogni codice in modo indipendente. Le regole e le espressioni di Google Cloud Armor utilizzano esplicitamente questi codici regione per consentire o negare le richieste.
`origin.asn`	integer	Il numero di sistema autonomo (ASN) associato all'indirizzo IP di origine. L'ASN univoco a livello globale viene determinato in base all'operatore di rete che supporta i prefissi IP che contengono l'indirizzo IP di origine.

Attributi reCAPTCHA

Questa sezione elenca gli attributi applicabili solo ai token reCAPTCHA o ai cookie di esenzione. Un'espressione secondaria basata su questi attributi restituisce false se il token reCAPTCHA o il cookie di esenzione da valutare non è disponibile o non è valido per uno dei seguenti motivi:

Il token non è in un formato corretto e non può essere decodificato.
Il token contiene attributi non validi. Ad esempio, il token è stato generato utilizzando una chiave reCAPTCHA che non corrisponde alle chiavi reCAPTCHA associate alla regola.
Il token è scaduto.

Attributi dei cookie di esenzione

Campo	Tipo	Descrizione del campo
`token.recaptcha_exemption.valid`	`bool`	La presenza di un cookie di esenzione reCAPTCHA valido.

Attributi token di azione

Campo	Tipo	Descrizione del campo
`token.recaptcha_action.score`	`float`	Il punteggio di un token di azione reCAPTCHA. Un punteggio valido va da `0.0` a `1.0`, dove `0.0` indica un utente illegittimo e `1.0` indica un utente legittimo.
`token.recaptcha_action.captcha_status`	`string`	Lo stato del captcha di un token di azione reCAPTCHA. Uno stato valido è `NONE`, `PASS` o `FAIL`, dove `NONE` si riferisce a quando non sono coinvolte sfide durante test reCAPTCHA, in modo che il campo captcha non sia presente nel token di azione.
`token.recaptcha_action.action`	`string`	Il nome dell'azione (fino a 100 caratteri) di un token di azione reCAPTCHA. Vedi Nomi delle azioni.
`token.recaptcha_action.valid`	`bool`	La presenza di un token di azione reCAPTCHA valido.

Attributi del token di sessione

Campo	Tipo	Descrizione del campo
`token.recaptcha_session.score`	`float`	Il punteggio di un token di sessione reCAPTCHA. Un punteggio valido va da `0.0` a `1.0`, dove `0.0` indica un utente illegittimo e `1.0` indica un utente legittimo.
`token.recaptcha_session.valid`	`bool`	La presenza di un token di sessione reCAPTCHA valido.

Espressioni di esempio

Per ciascuna di queste espressioni, l'azione intrapresa dipende dal fatto che l'espressione sia inclusa in una regola Nega o in una regola Consenti.

Consenti o nega l'accesso in base a un intervallo di indirizzi IP in IPv4 o IPv6

La seguente espressione corrisponde alle richieste provenienti dall'intervallo di indirizzi IP 198.51.100.0/24:
```
inIpRange(origin.ip, '198.51.100.0/24')
```
La seguente espressione corrisponde alle richieste provenienti dall'intervallo di indirizzi IP 2001:db8::/32:
```
inIpRange(origin.ip, '2001:db8::/32')
```

Consenti o nega l'accesso in base a un intervallo di indirizzi IP client personalizzato dietro un proxy upstream

Se hai configurato l'operatore origin.user_ip, puoi eseguire la corrispondenza in base ai valori dell'intestazione specificati nel campo advancedOptionsConfig.userIpRequestHeaders[].

La seguente espressione corrisponde alle richieste provenienti dall'intervallo di indirizzi IP 192.0.2.0/24:
```
inIpRange(origin.user_ip, '192.0.2.0/24')
```
La seguente espressione corrisponde alle richieste provenienti dall'intervallo di indirizzi IP 2001:db8::/32:
```
inIpRange(origin.user_ip, '2001:db8::/32')
```

Consentire o negare il traffico con un cookie specifico

La seguente espressione corrisponde alle richieste che hanno un cookie contenente 80=BLAH:
```
has(request.headers['cookie']) && request.headers['cookie'].contains('80=BLAH')
```

Consenti o nega il traffico con un'intestazione `referer` non vuota

La seguente espressione corrisponde alle richieste con un'intestazione referer non vuota:
```
has(request.headers['referer']) && request.headers['referer'] != ""
```

Consentire o negare il traffico in base all'URL host nell'intestazione

La seguente espressione corrisponde alle richieste a un URL specifico:
```
request.headers['host'].lower().contains('test.example.com')
```

Consentire o negare il traffico da una regione specifica

Se la tua applicazione web non è disponibile nella regione AU, tutte le richieste provenienti da quella regione devono essere bloccate.

In una regola di negazione, utilizza la seguente espressione, che corrisponde alle richieste provenienti dalla regione AU:
```
origin.region_code == 'AU'
```

In alternativa, se la tua applicazione web è disponibile solo nella regione AU, le richieste provenienti da tutte le altre regioni devono essere bloccate.

In una regola di negazione, utilizza la seguente espressione, che corrisponde alle richieste provenienti da tutte le regioni diverse dalla regione AU:
```
origin.region_code != 'AU'
```

I codici regione si basano sui codici ISO 3166-1 alpha 2. In alcuni casi, una regione corrisponde a un paese, ma non è sempre così. Ad esempio, il codice US include tutti gli stati degli Stati Uniti, un distretto e sei aree periferiche.

Consentire o negare il traffico da un ASN specifico

Se la tua applicazione web deve essere bloccata per i clienti serviti da un operatore di rete specifico, puoi utilizzare il numero ASN dell'operatore di rete per il blocco.

In una regola di negazione, utilizza la seguente espressione, che corrisponde alle richieste provenienti da un ASN specifico:
```
origin.asn == 123
```

In alternativa, se la tua applicazione web deve essere disponibile solo per i clienti di un operatore di rete specifico, le richieste di tutti gli altri operatori di rete devono essere bloccate.

In una regola di negazione, utilizza la seguente espressione, che corrisponde a tutti gli altri operatori di rete diversi da quello che ti interessa consentire:
```
origin.asn != 123
```

Più espressioni

Per includere più condizioni in una singola regola, combina più sottoespressioni.

Nel seguente esempio, le richieste provenienti da 1.2.3.0/24 (ad esempio i tuoi alpha tester) nella regione AU corrispondono alla seguente espressione:
```
origin.region_code == "AU" && inIpRange(origin.ip, '1.2.3.0/24')
```

La seguente espressione corrisponde alle richieste provenienti da 1.2.3.4 in cui uno user agent contiene la stringa WordPress:

inIpRange(origin.ip, '1.2.3.4/32') &&
has(request.headers['user-agent']) && request.headers['user-agent'].contains('WordPress')

Consenti o nega il traffico per un URI della richiesta che corrisponde a un'espressione regolare

La seguente espressione corrisponde alle richieste che contengono la stringa /example_path/ nell'URI:
```
request.path.matches('/example_path/')
```
La seguente espressione corrisponde alle richieste che contengono Chrome nel campo dell'intestazione User-Agent:
```
request.headers['user-agent'].matches('Chrome')
```
La seguente espressione mostra la corrispondenza senza distinzione tra maiuscole e minuscole per l'intestazione User-Agent contenente wordpress; corrisponde a User-Agent:WordPress/605.1.15, User-Agent:wordPress e altre varianti di wordpress:
```
request.headers['user-agent'].matches('(?i:wordpress)')
```

Consentire o negare il traffico che contiene un valore decodificato in base64 specifico

La seguente espressione corrisponde alle richieste con un valore decodificato in base64 di myValue per l'intestazione user-id:
```
has(request.headers['user-id']) && request.headers['user-id'].base64Decode().contains('myValue')
```

Consentire o negare il traffico che contiene un valore stringa di una lunghezza specifica

La seguente espressione corrisponde alle richieste con una lunghezza dell'URL superiore a 10 caratteri:
```
size(request.path) > 10
```
La seguente espressione corrisponde alle richieste con un'intestazione x-data di lunghezza maggiore o uguale a 1024 caratteri:
```
size(request.headers['x-data']) >= 1024
```

Consenti o nega il traffico con `content-length` zero nel corpo HTTP

La seguente espressione corrisponde alle richieste che hanno uno zero content-length nel corpo HTTP:
```
int(request.headers["content-length"]) == 0
```

Consentire o negare il traffico che contiene un valore codificato come URL specifico

La seguente espressione corrisponde alle richieste con un valore del cookie contenente %3c:
```
has(request.headers['cookie']) && request.headers['cookie'].urlDecode().contains('<')
```

Consenti o nega il traffico che contiene un valore codificato di un URL specifico di una stringa Unicode

La seguente espressione corrisponde alle richieste con un valore del cookie uguale a Match%2BValue o Match%u002BValue:
```
has(request.headers['cookie']) && request.headers['cookie'].urlDecodeUni() == 'Match+Value'
```

Consenti o nega il traffico che contiene una stringa Unicode specifica di un testo UTF-8

La seguente espressione corrisponde alle richieste con un valore del cookie uguale a ¬:

has(request.headers['cookie']) && request.headers['cookie'].utf8ToUnicode() == '%u00ac'

Consenti o nega il traffico in base a un'impronta JA4 nota

La seguente espressione corrisponde alle richieste con un'impronta JA4 uguale a t13d1516h2_8daaf6152771_b186095e22b6:
```
origin.tls_ja4_fingerprint == 't13d1516h2_8daaf6152771_b186095e22b6'
```

Consenti o nega il traffico in base a un elenco di impronte JA4

La seguente espressione corrisponde alle richieste con un'impronta JA4 uguale a una delle seguenti impronte JA4:
- t00d0000h0_000000000000_000000000000
- t13d1516h2_8daaf6152771_b186095e22b6
```
origin.tls_ja4_fingerprint == 't00d0000h0_000000000000_000000000000' || origin.tls_ja4_fingerprint == 't13d1516h2_8daaf6152771_b186095e22b6'
```

Regole WAF preconfigurate

Le regole WAF preconfigurate utilizzano firme statiche, espressioni regolari o entrambe preconfigurate per trovare corrispondenze nel corpo POST HTTP, nelle intestazioni delle richieste HTTP e parametri di ricerca. Le regole WAF preconfigurate disponibili si basano sulla versione 3.3 del set di regole di base OWASP. Google Cloud Armor fornisce diverse regole WAF preconfigurate predefinite. Per un elenco completo delle regole WAF preconfigurate, consulta la panoramica delle regole WAF preconfigurate di Google Cloud Armor.

Per elencare tutte le regole WAF preconfigurate disponibili, consulta Elenca le regole WAF preconfigurate disponibili.

Per saperne di più sulle regole WAF preconfigurate, consulta il caso d'uso Mitigare gli attacchi a livello di applicazione utilizzando le regole WAF preconfigurate.

Nomi delle regole WAF preconfigurate

I nomi delle regole WAF preconfigurate hanno il formato <attack category>-<OWASP CRS version>-<version field>. La categoria di attacco specifica il tipo di attacchi da cui vuoi proteggerti, come xss (cross-site scripting) o sqli (SQL injection).

I campi della versione supportati sono stable e canary. Le aggiunte e le modifiche alle regole vengono rilasciate prima nella versione canary. Quando le aggiunte e le modifiche sono considerate sicure e stabili, vengono promosse alla versione stable.

ID membri delle regole WAF preconfigurate

Una regola WAF preconfigurata contiene diverse espressioni, ognuna con la propria firma. Ad esempio, la regola WAF preconfigurata xss-v33-stable include un'espressione denominata owasp-crs-v030301-id941100-xss, che corrisponde all'ID regola id941100 per la versione 3.3. Puoi utilizzare le firme per escludere espressioni specifiche, il che è utile se una determinata espressione attiva costantemente un falso positivo. Per ulteriori informazioni, consulta la sezione Falsi positivi per la risoluzione dei problemi.

Per informazioni sul set di regole di base e sull'ottimizzazione a diversi livelli di sensibilità, consulta Ottimizzazione delle regole WAF di Google Cloud Armor.

Operatore per le regole WAF preconfigurate

Espressioni Descrizione

Espressioni	Descrizione
`evaluatePreconfiguredWaf(string, MAP<string, dyn>)`	Restituisce true se una delle firme WAF all'interno del set di regole WAF specificato restituisce true. Il primo argomento è il nome del set di regole WAF, ad esempio `xss-v33-stable`. Il secondo argomento (facoltativo) è una mappa in cui la chiave è una stringa e il valore è tipizzato in modo dinamico a seconda della chiave. Lo scopo di questo argomento è ottimizzare le firme WAF valutate. Le chiavi accettate includono le seguenti: "sensitivity": corrisponde al livello di paranoia dell'OWASP Core Rule Set, che ha 4 livelli, da 1 a 4. Il suo valore è un numero intero con un intervallo valido da 0 a 4. Tieni presente che 0 è riservato come valore valido se utilizzato in combinazione con "opt_in_rule_ids" (descritto in seguito). Quando specifichi una sensibilità pari a x (x >= 1), vengono valutate tutte le firme WAF associate con un valore di sensibilità compreso tra 1 e x. Se omesso, viene utilizzato 4 come valore di sensibilità. "opt_out_rule_ids": firme WAF (rappresentate dagli ID regola) da escludere dalla valutazione, dove il set di base è determinato dal valore di sensibilità. Il suo valore è un elenco di stringhe. Il numero massimo di ID regola consentiti è `128`. "opt_in_rule_ids": firme WAF (rappresentate dagli ID regola) da attivare per la valutazione, dove il set di base è vuoto. Il suo valore è un elenco di stringhe. Il numero massimo di ID regola consentiti è `128`. Quando lo utilizzi, devi specificare una "sensibilità" di `0`. Le chiavi "opt_out_rule_ids" e "opt_in_rule_ids" si escludono a vicenda. Puoi scegliere di utilizzare "opt_in_rule_ids" se vuoi esaminare e attivare manualmente le nuove firme WAF che vengono aggiunte in un secondo momento a un insieme di regole esistente.
`evaluatePreconfiguredExpr(string, LIST)`	Attenzione: `evaluatePreconfiguredExpr()` è deprecato. Ti consigliamo di utilizzare `evaluatePreconfiguredWaf()` in alternativa. Restituisce true se una delle espressioni all'interno della regola WAF preconfigurata specificata restituisce true. Il primo argomento è il nome della regola WAF preconfigurata, ad esempio `xss-stable`. Il secondo argomento (facoltativo) è un elenco di stringhe separate da virgole di ID da escludere dalla valutazione. L'elenco di esclusione è utile quando un determinato membro della regola WAF preconfigurata genera un falso positivo.

evaluatePreconfiguredWaf(string, MAP<string, dyn>)

Restituisce true se una delle firme WAF all'interno del set di regole WAF specificato restituisce true. Il primo argomento è il nome del set di regole WAF, ad esempio xss-v33-stable. Il secondo argomento (facoltativo) è una mappa in cui la chiave è una stringa e il valore è tipizzato in modo dinamico a seconda della chiave. Lo scopo di questo argomento è ottimizzare le firme WAF valutate. Le chiavi accettate includono le seguenti:

"sensitivity": corrisponde al livello di paranoia dell'OWASP Core Rule Set, che ha 4 livelli, da 1 a 4. Il suo valore è un numero intero con un intervallo valido da 0 a 4. Tieni presente che 0 è riservato come valore valido se utilizzato in combinazione con "opt_in_rule_ids" (descritto in seguito). Quando specifichi una sensibilità pari a x (x >= 1), vengono valutate tutte le firme WAF associate con un valore di sensibilità compreso tra 1 e x. Se omesso, viene utilizzato 4 come valore di sensibilità.
"opt_out_rule_ids": firme WAF (rappresentate dagli ID regola) da escludere dalla valutazione, dove il set di base è determinato dal valore di sensibilità. Il suo valore è un elenco di stringhe. Il numero massimo di ID regola consentiti è 128.
"opt_in_rule_ids": firme WAF (rappresentate dagli ID regola) da attivare per la valutazione, dove il set di base è vuoto. Il suo valore è un elenco di stringhe. Il numero massimo di ID regola consentiti è 128. Quando lo utilizzi, devi specificare una "sensibilità" di 0.

Le chiavi "opt_out_rule_ids" e "opt_in_rule_ids" si escludono a vicenda. Puoi scegliere di utilizzare "opt_in_rule_ids" se vuoi esaminare e attivare manualmente le nuove firme WAF che vengono aggiunte in un secondo momento a un insieme di regole esistente.

evaluatePreconfiguredExpr(string, LIST)

Attenzione: evaluatePreconfiguredExpr() è deprecato. Ti consigliamo di utilizzare evaluatePreconfiguredWaf() in alternativa.

Restituisce true se una delle espressioni all'interno della regola WAF preconfigurata specificata restituisce true.

Il primo argomento è il nome della regola WAF preconfigurata, ad esempio xss-stable. Il secondo argomento (facoltativo) è un elenco di stringhe separate da virgole di ID da escludere dalla valutazione. L'elenco di esclusione è utile quando un determinato membro della regola WAF preconfigurata genera un falso positivo.

Esempi di regole WAF preconfigurate

La seguente espressione utilizza la regola WAF preconfigurata xss-v33-stable per mitigare gli attacchi XSS:
```
evaluatePreconfiguredWaf('xss-v33-stable')
```

La seguente espressione utilizza tutte le espressioni della regola WAF preconfigurata xss-v33-stable, tranne gli ID membro 941100 e 941110:

evaluatePreconfiguredWaf('xss-v33-stable', {'opt_out_rule_ids': ['owasp-crs-v030301-id941100-xss',
'owasp-crs-v030301-id941110-xss']})

La seguente espressione utilizza una regola WAF preconfigurata per mitigare gli attacchi SQLi dall'intervallo di indirizzi IP 198.51.100.0/24:
```
inIpRange(origin.ip, '198.51.100.0/24') && evaluatePreconfiguredWaf('sqli-v33-stable')
```