wallarm/gotestwafUn progetto open-source in Golang per valutare diversi strumenti di sicurezza API e WAF per la logica di rilevamento e i bypass.
GoTestWAF è uno strumento per la simulazione di attacchi API e OWASP che supporta un'ampia gamma di protocolli API tra cui REST, GraphQL, gRPC, SOAP, XMLRPC e altri.
È stato progettato per valutare soluzioni di sicurezza per applicazioni web, come proxy di sicurezza API, Web Application Firewall, IPS, gateway API e altri.
GoTestWAF genera richieste malevole utilizzando payload codificati inseriti in diverse parti delle richieste HTTP: il corpo, gli header, i parametri URL, ecc. Le richieste generate vengono inviate all'URL della soluzione di sicurezza applicativa specificato durante l'avvio di GoTestWAF. I risultati della valutazione della soluzione di sicurezza vengono registrati nel file di report creato sulla tua macchina.
Le condizioni predefinite per la generazione delle richieste sono definite nella cartella testcases nei file YAML del seguente formato:```yaml
payload:
* `payload` è un campione di attacco malevolo (ad esempio un payload XSS come ```<script>alert(111)</script>``` o qualcosa di più sofisticato).
Poiché il formato della stringa YAML è richiesto per i payload, questi devono essere [codificati come dati binari](https://yaml.org/type/binary.html).
* `encoder` è un encoder da applicare al payload prima di inserirlo nella richiesta HTTP. Gli encoder possibili sono:
* Base64
* Base64Flat
* JSUnicode
* URL
* Plain (per mantenere la stringa del payload così com'è)
* XML Entity
* `placeholder` è un punto all'interno della richiesta HTTP in cui deve essere inserito il payload codificato. I placeholder possibili sono:
* gRPC
* Header
* UserAgent
* RequestBody
* JSONRequest
* JSONBody
* HTMLForm
* HTMLMultipartForm
* SOAPBody
* XMLBody
* URLParam
* URLPath
* RawRequest
Il placeholder `RawRequest` ti consente di effettuare una richiesta HTTP arbitraria. Il payload viene sostituito rimpiazzando la stringa `{{payload}}` nel percorso URL, negli header o nel body. Campi del placeholder `RawRequest`:
* `method`
* `path`
* `headers`
* `body`
Campi obbligatori per il placeholder `RawRequest`:
* campo `method`
Esempio:
```yaml
payload:
- test
encoder:
- Plain
placeholder:
- RawRequest:
method: "POST"
path: "/"
headers:
Content-Type: "multipart/form-data; boundary=boundary"
body: |
--boundary
Content-disposition: form-data; name="field1"
Test
--boundary
Content-disposition: form-data; name="field2"
Content-Type: text/plain; charset=utf-7
Knock knock.
{{payload}}
--boundary--
type: RawRequest test
```
* `type` è il nome dell'intero gruppo di payload nel file. Può essere arbitrario, ma dovrebbe riflettere il tipo di attacchi presenti nel file.
La generazione delle richieste è un processo in tre fasi che prevede la moltiplicazione della quantità di payload per le quantità di encoder e placeholder.
Supponiamo che tu abbia definito 2 **payload**, 3 **encoder** (Base64, JSUnicode e URL) e 1 **placeholder** (URLParameter - parametro HTTP GET).
In questo caso, GoTestWAF invierà 2x3x1 = 6 richieste in un caso di test.
Durante l'avvio di GoTestWAF, puoi anche scegliere i casi di test tra due embedded: OWASP Top-10, OWASP-API,
oppure i tuoi (utilizzando l'[opzione di configurazione](#configuration-options) `testCasePath`).
## Requisiti
* GoTestwaf supporta tutti i sistemi operativi più diffusi (Linux, Windows, macOS) e può essere compilato nativamente
se [Go](https://golang.org/doc/install) è installato nel sistema. Se vuoi eseguire GoTestWaf nativamente,
assicurati di avere il browser web Chrome per poter generare report PDF. Nel caso in cui non hai Chrome,
puoi creare un report in formato HTML.
* Se esegui GoTestWAF come container Docker, assicurati di avere [installato e configurato Docker](https://docs.docker.com/get-docker/),
e che GoTestWAF e la soluzione di sicurezza applicativa valutata siano connessi alla stessa [rete Docker](https://docs.docker.com/network/).
* Affinché GoTestWAF si avvii correttamente, assicurati che l'indirizzo IP della macchina che esegue GoTestWAF sia inserito nella whitelist
sulla macchina che esegue la soluzione di sicurezza applicativa.
## Avvio rapido con Docker
I passaggi seguenti illustrano come scaricare e avviare GoTestWAF con una configurazione minima su Docker.
1. Scarica l'[immagine GoTestWAF](https://hub.docker.com/r/wallarm/gotestwaf) da Docker Hub:
```
docker pull wallarm/gotestwaf
```
2. Avvia l'immagine GoTestWAF:
```sh
docker run --rm --network="host" -it -v ${PWD}/reports:/app/reports \
wallarm/gotestwaf --url=<EVALUATED_SECURITY_SOLUTION_URL>
```
Se necessario, puoi sostituire `${PWD}/reports` con il percorso di un'altra cartella utilizzata per inserire il report di valutazione.
Se non vuoi inviare opzionalmente il report via email, premi semplicemente Invio dopo che appare il messaggio di richiesta email, oppure puoi usare --noEmailReport per saltare il messaggio:
```sh
docker run --rm --network="host" -v ${PWD}/reports:/app/reports \
wallarm/gotestwaf --url=<EVALUATED_SECURITY_SOLUTION_URL> --noEmailReport
```
Se lo strumento di sicurezza valutato è disponibile esternamente, puoi saltare l'opzione `--network="host"`. Questa opzione abilita l'interazione dei container Docker in esecuzione su 127.0.0.1.
Per eseguire i test gRPC devi avere un endpoint funzionante e usare l'opzione cli --grpcPort <port>.
```sh
docker run --rm --network="host" -it -v ${PWD}/reports:/app/reports \
wallarm/gotestwaf --grpcPort 9000 --url=http://my.grpc.endpoint
```
3. Controlla la tua email per il report.
Hai valutato con successo la tua soluzione di sicurezza applicativa utilizzando GoTestWAF con una configurazione minima.
Per conoscere le opzioni di configurazione avanzate, utilizza questo [link](#configuration-options).
## Verifica dei risultati della valutazione