wallarm/gotestwafUn projet open-source en Golang pour évaluer différents outils de sécurité API et WAF pour la logique de détection et les contournements.
GoTestWAF est un outil de simulation d'attaques API et OWASP qui prend en charge un large éventail de protocoles API, notamment REST, GraphQL, gRPC, SOAP, XMLRPC et d'autres.
Il a été conçu pour évaluer les solutions de sécurité des applications web, telles que les proxys de sécurité API, les pare-feu d'applications web, les IPS, les passerelles API, et d'autres.
GoTestWAF génère des requêtes malveillantes en utilisant des charges utiles encodées placées dans différentes parties des requêtes HTTP : le corps, les en-têtes, les paramètres d'URL, etc. Les requêtes générées sont envoyées à l'URL de la solution de sécurité applicative spécifiée lors du lancement de GoTestWAF. Les résultats de l'évaluation de la solution de sécurité sont enregistrés dans le fichier de rapport créé sur votre machine.
Les conditions par défaut pour la génération de requêtes sont définies dans le dossier testcases dans des fichiers YAML au format suivant :```yaml
payload:
* `payload` est un échantillon d'attaque malveillant (par exemple une charge utile XSS comme ```<script>alert(111)</script>``` ou quelque chose de plus sophistiqué).
Étant donné que le format de la chaîne YAML est requis pour les charges utiles, elles doivent être [encodées en données binaires](https://yaml.org/type/binary.html).
* `encoder` est un encodeur à appliquer à la charge utile avant de la placer dans la requête HTTP. Les encodeurs possibles sont :
* Base64
* Base64Flat
* JSUnicode
* URL
* Plain (pour conserver la chaîne de charge utile telle quelle)
* XML Entity
* `placeholder` est un emplacement dans la requête HTTP où la charge utile encodée doit être placée. Les emplacements possibles sont :
* gRPC
* Header
* UserAgent
* RequestBody
* JSONRequest
* JSONBody
* HTMLForm
* HTMLMultipartForm
* SOAPBody
* XMLBody
* URLParam
* URLPath
* RawRequest
Le placeholder `RawRequest` vous permettra d'effectuer une requête HTTP arbitraire. La charge utile est substituée en remplaçant la chaîne `{{payload}}` dans le chemin URL, les en-têtes ou le corps. Champs du placeholder `RawRequest` :
* `method`
* `path`
* `headers`
* `body`
Champs requis pour le placeholder `RawRequest` :
* le champ `method`
Exemple :
```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` est le nom de l'ensemble du groupe de charges utiles dans le fichier. Il peut être arbitraire, mais doit refléter le type d'attaques dans le fichier.
La génération de requêtes est un processus en trois étapes qui implique la multiplication du nombre de charges utiles par le nombre d'encodeurs et de placeholders. Disons que vous avez défini 2 **charges utiles**, 3 **encodeurs** (Base64, JSUnicode et URL) et 1 **placeholder** (URLParameter - paramètre HTTP GET). Dans ce cas, GoTestWAF enverra 2x3x1 = 6 requêtes dans un cas de test.
Lors du lancement de GoTestWAF, vous pouvez également choisir des cas de test parmi deux intégrés : OWASP Top-10, OWASP-API, ou les vôtres (en utilisant l'[option de configuration](#configuration-options) `testCasePath`).
## Requirements
* GoTestwaf prend en charge tous les systèmes d'exploitation populaires (Linux, Windows, macOS) et peut être construit nativement si [Go](https://golang.org/doc/install) est installé sur le système. Si vous souhaitez exécuter GoTestWaf nativement, assurez-vous de disposer du navigateur Web Chrome pour pouvoir générer des rapports PDF. Si vous n'avez pas Chrome, vous pouvez créer un rapport au format HTML.
* Si vous exécutez GoTestWAF en tant que conteneur Docker, assurez-vous d'avoir [installé et configuré Docker](https://docs.docker.com/get-docker/), et que GoTestWAF et la solution de sécurité applicative évaluée sont connectés au même [réseau Docker](https://docs.docker.com/network/).
* Pour que GoTestWAF démarre avec succès, assurez-vous que l'adresse IP de la machine exécutant GoTestWAF est autorisée sur la machine exécutant la solution de sécurité applicative.
## Quick start with Docker
Les étapes ci-dessous décrivent le téléchargement et le démarrage de GoTestWAF avec une configuration minimale sur Docker.
1. Tirez l'[image GoTestWAF](https://hub.docker.com/r/wallarm/gotestwaf) de Docker Hub :
```
docker pull wallarm/gotestwaf
```
2. Démarrez l'image GoTestWAF :
```sh
docker run --rm --network="host" -it -v ${PWD}/reports:/app/reports \
wallarm/gotestwaf --url=<EVALUATED_SECURITY_SOLUTION_URL>
```
Si nécessaire, vous pouvez remplacer `${PWD}/reports` par le chemin d'un autre dossier utilisé pour placer le rapport d'évaluation.
Si vous ne souhaitez pas envoyer le rapport par e-mail, appuyez simplement sur Entrée après l'apparition du message de demande d'e-mail, ou vous pouvez utiliser --noEmailReport pour ignorer le message :
```sh
docker run --rm --network="host" -v ${PWD}/reports:/app/reports \
wallarm/gotestwaf --url=<EVALUATED_SECURITY_SOLUTION_URL> --noEmailReport
```
Si l'outil de sécurité évalué est accessible de l'extérieur, vous pouvez ignorer l'option --network="host". Cette option permet l'interaction des conteneurs Docker s'exécutant sur 127.0.0.1.
Pour effectuer les tests gRPC, vous devez disposer d'un point de terminaison fonctionnel et utiliser l'option 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. Vérifiez votre e-mail pour le rapport.
Vous avez évalué avec succès votre solution de sécurité applicative en utilisant GoTestWAF avec une configuration minimale. Pour découvrir les options de configuration avancées, veuillez utiliser ce [lien](#configuration-options).
## Checking the evaluation results
Vérifiez les résultats d'évaluation enregistrés à l'aide des services `STDOUT` et `STDERR`. Par exemple :```
INFO[0000] GoTestWAF started version=v0.5.6-7-g48e6959
INFO[0000] Test cases loading started
INFO[0000] Test cases loading finished
INFO[0000] Test cases fingerprint fp=c6d14d6138601d19d215bb97806bcda3
INFO[0000] Try to identify WAF solution
INFO[0000] WAF was not identified
INFO[0000] gohttp is used as an HTTP client to make requests http_client=gohttp
INFO[0000] WAF pre-check url="http://host.docker.internal:8080"
INFO[0000] WAF pre-check blocked=true code=403 status=done
INFO[0000] gRPC pre-check status=started
INFO[0000] gRPC pre-check connection="not available" status=done
INFO[0000] GraphQL pre-check status=started
INFO[0000] GraphQL pre-check connection="not available" status=done
INFO[0000] Scanning started url="http://host.docker.internal:8080"
INFO[0005] Scanning finished duration=5.422700876s
True-Positive Tests:
┌────────────┬───────────────────────────┬──────────────────────┬─────────────────────┬──────────────────────┬────────────────────┬─────────────┬─────────────────┐
│ TEST SET │ TEST CASE │ PERCENTAGE , % │ BLOCKED │ BYPASSED │ UNRESOLVED │ SENT │ FAILED │
├────────────┼───────────────────────────┼──────────────────────┼─────────────────────┼──────────────────────┼────────────────────┼─────────────┼─────────────────┤
│ community │ community-128kb-rce │ 0.00 │ 0 │ 0 │ 1 │ 1 │ 0 │
│ community │ community-128kb-sqli │ 0.00 │ 0 │ 0 │ 1 │ 1 │ 0 │
│ community │ community-128kb-xss │ 0.00 │ 0 │ 0 │ 1 │ 1 │ 0 │
│ community │ community-16kb-rce │ 100.00 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ community │ community-16kb-sqli │ 100.00 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ community │ community-16kb-xss │ 100.00 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ community │ community-32kb-rce │ 100.00 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ community │ community-32kb-sqli │ 100.00 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ community │ community-32kb-xss │ 100.00 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ community │ community-64kb-rce │ 100.00 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ community │ community-64kb-sqli │ 100.00 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ community │ community-64kb-xss │ 100.00 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ community │ community-8kb-rce │ 100.00 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ community │ community-8kb-sqli │ 100.00 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ community │ community-8kb-xss │ 100.00 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ community │ community-lfi │ 100.00 │ 8 │ 0 │ 0 │ 8 │ 0 │
│ community │ community-lfi-multipart │ 0.00 │ 0 │ 0 │ 2 │ 2 │ 0 │
│ community │ community-rce │ 50.00 │ 2 │ 2 │ 0 │ 4 │ 0 │
│ community │ community-rce-rawrequests │ 100.00 │ 3 │ 0 │ 0 │ 3 │ 0 │
│ community │ community-sqli │ 100.00 │ 12 │ 0 │ 0 │ 12 │ 0 │
│ community │ community-user-agent │ 66.67 │ 6 │ 3 │ 0 │ 9 │ 0 │
│ community │ community-xss │ 88.46 │ 92 │ 12 │ 0 │ 104 │ 0 │
│ community │ community-xxe │ 0.00 │ 0 │ 1 │ 1 │ 2 │ 0 │
│ owasp │ crlf │ 85.71 │ 6 │ 1 │ 0 │ 7 │ 0 │
│ owasp │ ldap-injection │ 8.33 │ 2 │ 22 │ 0 │ 24 │ 0 │
│ owasp │ mail-injection │ 12.50 │ 3 │ 21 │ 0 │ 24 │ 0 │
│ owasp │ nosql-injection │ 24.00 │ 12 │ 38 │ 0 │ 50 │ 0 │
│ owasp │ path-traversal │ 30.00 │ 6 │ 14 │ 0 │ 20 │ 0 │
│ owasp │ rce │ 33.33 │ 2 │ 4 │ 0 │ 6 │ 0 │
│ owasp │ rce-urlparam │ 33.33 │ 3 │ 6 │ 0 │ 9 │ 0 │
│ owasp │ rce-urlpath │ 0.00 │ 0 │ 3 │ 0 │ 3 │ 0 │
│ owasp │ shell-injection │ 18.75 │ 6 │ 26 │ 0 │ 32 │ 0 │
│ owasp │ sql-injection │ 29.17 │ 14 │ 34 │ 0 │ 48 │ 0 │
│ owasp │ ss-include │ 50.00 │ 12 │ 12 │ 0 │ 24 │ 0 │
│ owasp │ sst-injection │ 29.17 │ 7 │ 17 │ 0 │ 24 │ 0 │
│ owasp │ xml-injection │ 0.00 │ 0 │ 7 │ 0 │ 7 │ 0 │
│ owasp │ xss-scripting │ 39.91 │ 89 │ 134 │ 1 │ 224 │ 0 │
│ owasp-api │ graphql │ 0.00 │ 0 │ 0 │ 0 │ 0 │ 0 │
│ owasp-api │ graphql-post │ 0.00 │ 0 │ 0 │ 0 │ 0 │ 0 │
│ owasp-api │ grpc │ 0.00 │ 0 │ 0 │ 0 │ 0 │ 0 │
│ owasp-api │ non-crud │ 100.00 │ 2 │ 0 │ 0 │ 2 │ 0 │
│ owasp-api │ rest │ 42.86 │ 3 │ 4 │ 0 │ 7 │ 0 │
│ owasp-api │ soap │ 20.00 │ 1 │ 4 │ 0 │ 5 │ 0 │
├────────────┼───────────────────────────┼──────────────────────┼─────────────────────┼──────────────────────┼────────────────────┼─────────────┼─────────────────┤
│ Date: │ Project Name: │ True-Positive Score: │ Blocked (Resolved): │ Bypassed (Resolved): │ Unresolved (Sent): │ Total Sent: │ Failed (Total): │
│ 2025-07-14 │ generic │ 45.36% │ 303/668 (45.36%) │ 365/668 (54.64%) │ 7/675 (1.04%) │ 675 │ 0/675 (0.00%) │
└────────────┴───────────────────────────┴──────────────────────┴─────────────────────┴──────────────────────┴────────────────────┴─────────────┴─────────────────┘
True-Negative Tests:
┌────────────┬───────────────┬──────────────────────┬─────────────────────┬──────────────────────┬────────────────────┬─────────────┬─────────────────┐
│ TEST SET │ TEST CASE │ PERCENTAGE , % │ BLOCKED │ BYPASSED │ UNRESOLVED │ SENT │ FAILED │
├────────────┼───────────────┼──────────────────────┼─────────────────────┼──────────────────────┼────────────────────┼─────────────┼─────────────────┤
│ false-pos │ texts │ 90.78 │ 13 │ 128 │ 0 │ 141 │ 0 │
├────────────┼───────────────┼──────────────────────┼─────────────────────┼──────────────────────┼────────────────────┼─────────────┼─────────────────┤
│ Date: │ Project Name: │ True-Negative Score: │ Blocked (Resolved): │ Bypassed (Resolved): │ Unresolved (Sent): │ Total Sent: │ Failed (Total): │
│ 2025-07-14 │ generic │ 90.78% │ 13/141 (9.22%) │ 128/141 (90.78%) │ 0/141 (0.00%) │ 141 │ 0/141 (0.00%) │
└────────────┴───────────────┴──────────────────────┴─────────────────────┴──────────────────────┴────────────────────┴─────────────┴─────────────────┘
Summary:
┌──────────────────────┬───────────────────────────────┬──────────────────────────────┬─────────┐
│ TYPE │ TRUE - POSITIVE TESTS BLOCKED │ TRUE - NEGATIVE TESTS PASSED │ AVERAGE │
├──────────────────────┼───────────────────────────────┼──────────────────────────────┼─────────┤
│ API Security │ 42.86% │ n/a │ 42.86% │
│ Application Security │ 45.41% │ 90.78% │ 68.10% │
├──────────────────────┼───────────────────────────────┼──────────────────────────────┼─────────┤
│ │ │ Score │ 55.48% │
└──────────────────────┴───────────────────────────────┴──────────────────────────────┴─────────┘
Le fichier de rapport waf-evaluation-report-<date>.pdf est disponible dans le dossier reports du répertoire utilisateur. Vous pouvez également spécifier le répertoire de sauvegarde des rapports avec le paramètre reportPath et le nom du fichier de rapport avec le paramètre reportName. Pour en savoir plus sur les options de configuration avancées, veuillez utiliser ce lien.
Vous pouvez trouver un exemple de rapport PDF ici.
Vous pouvez essayer GoTestWAF en exécutant l'environnement de démonstration qui déploie ModSecurity basé sur NGINX avec OWASP Core Rule Set et GoTestWAF évaluant ModSecurity sur Docker.
Pour exécuter l'environnement de démonstration :
Clonez ce dépôt et rendez-vous dans le répertoire cloné :
git clone https://github.com/wallarm/gotestwaf.git
cd gotestwaf
Démarrez ModSecurity à partir de l'image Docker en utilisant la commande make suivante :
make modsec
Les paramètres d'exécution du conteneur Docker ModSecurity sont définis dans la règle modsec du Makefile cloné. Il exécute le conteneur Docker ModSecurity sur le port 8080 avec une configuration minimale définie dans le fichier cloné ./resources/default.conf.template et la valeur PARANOIA définie à 1.
Si nécessaire, vous pouvez modifier ces paramètres en modifiant la règle modsec dans le Makefile cloné. Les options disponibles pour la configuration de ModSecurity sont décrites sur Docker Hub.
Pour arrêter les conteneurs ModSecurity, utilisez la commande suivante :
make modsec_down
Démarrez GoTestWAF avec une configuration minimale en utilisant l'une des méthodes suivantes :
Démarrez l'image Docker en utilisant les commandes et suivantes :
En plus d'exécuter l'image Docker GoTestWAF téléchargée depuis Docker Hub, vous pouvez exécuter GoTestWAF en utilisant les options suivantes :
Clonez ce dépôt et construisez l'image Docker GoTestWAF à partir du Dockerfile, par exemple :
git clone https://github.com/wallarm/gotestwaf.git
cd gotestwaf
DOCKER_BUILDKIT=1 docker build --force-rm -t gotestwaf .
docker run --rm --network="host" -it -v ${PWD}/reports:/app/reports \
gotestwaf --url=<EVALUATED_SECURITY_SOLUTION_URL>
Si l'outil de sécurité évalué est disponible à l'extérieur, vous pouvez sauter l'option --network="host". Cette option permet l'interaction des conteneurs Docker s'exécutant sur 127.0.0.1.
Clonez ce dépôt et exécutez GoTestWAF avec go, par exemple :
git clone https://github.com/wallarm/gotestwaf.git
cd gotestwaf
go run ./cmd --url=<EVALUATED_SECURITY_SOLUTION_URL>
Clonez ce dépôt et construisez GoTestWAF en tant que module Go :
git clone https://github.com/wallarm/gotestwaf.git
cd gotestwaf
go build -mod vendor -o gotestwaf ./cmd
Les options de configuration prises en charge de GoTestWAF sont décrites ci-dessous.
Usage: ./gotestwaf [OPTIONS] --url
Options: --addDebugHeader Add header "X-GoTestWAF-Test" with a hash of the test information in each request --addHeader string An HTTP header to add to requests --blockConnReset If present, connection resets will be considered as block --blockRegex string Regex to detect a blocking page with the same HTTP response status code as a not blocked request --blockStatusCodes ints HTTP status code that WAF uses while blocking requests (default [403]) --configPath string Path to the config file (default "config.yaml") --email string E-mail to which the report will be sent --followCookies If present, use cookies sent by the server. May work only with --maxIdleConns=1 (gohttp only) --graphqlURL string GraphQL URL to check --grpcPort uint16 gRPC port to check --hideArgsInReport If present, GoTestWAF CLI arguments will not be displayed in the report --httpClient string Which HTTP client use to send requests: chrome, gohttp (default "gohttp") --idleConnTimeout int The maximum amount of time a keep-alive connection will live (gohttp only) (default 2) --ignoreUnresolved If present, unresolved test cases will be considered as bypassed (affect score and results) --includePayloads If present, payloads will be included in HTML/PDF report --logFormat string Set logging format: text, json (default "text") --logLevel string Logging level: panic, fatal, error, warn, info, debug, trace (default "info") --maxIdleConns int The maximum number of keep-alive connections (gohttp only) (default 2) --maxRedirects int The maximum number of handling redirects (gohttp only) (default 50) --noEmailReport Save report locally --nonBlockedAsPassed If present, count requests that weren't blocked as passed. If false, requests that don't satisfy to PassStatusCodes/PassRegExp as blocked --openapiFile string Path to openAPI file --passRegex string Regex to a detect normal (not blocked) web page with the same HTTP status code as a blocked request --passStatusCodes ints HTTP response status code that WAF uses while passing requests (default [200,404]) --proxy string Proxy URL to use --quiet If present, disable verbose logging --randomDelay int Random delay in ms in addition to the delay between requests (default 400) --renewSession Renew cookies before each test. Should be used with --followCookies flag (gohttp only) --reportFormat strings Export report in the following formats: none, json, html, pdf (default [pdf]) --reportName string Report file name. Supports `time' package template format (default "waf-evaluation-report-2006-January-02-15-04-05") --reportPath string A directory to store reports (default "reports") --sendDelay int Delay in ms between requests (default 400) --skipWAFBlockCheck If present, WAF detection tests will be skipped --skipWAFIdentification Skip WAF identification --testCase string If set then only this test case will be run --testCasesPath string Path to a folder with test cases (default "testcases") --testSet string If set then only this test set's cases will be run --tlsVerify If present, the received TLS certificate will be verified --url string URL to check --version Show GoTestWAF version and exit --wafName string Name of the WAF product (default "generic") --workers int The number of workers to scan (default 5)
GoTestWAF prend en charge deux clients HTTP pour effectuer des requêtes, sélectionnables via l'option `--httpClient`. Le client par défaut est le client HTTP standard de Golang. La deuxième option est Chrome, qui peut être utilisé avec l'argument CLI `--httpClient=chrome`. Notez que sur les systèmes Linux, vous devez ajouter l'argument `--cap-add=SYS_ADMIN` aux arguments Docker pour exécuter GoTestWAF avec Chrome comme exécuteur de requêtes.
### Scan basé sur un fichier OpenAPI
Pour un meilleur scan, GTW prend en charge l'envoi de vecteurs malveillants via des requêtes applicatives valides. Au lieu de construire des requêtes de structure simple et de les envoyer à l'URL spécifiée au démarrage, GoTestWAF crée des requêtes valides basées sur la description de l'API de l'application au format OpenAPI 3.0.
Comment ça fonctionne :
1. GoTestWAF charge un fichier OpenAPI et construit des modèles de requêtes. Tous les modèles sont ensuite divisés en groupes en fonction des espaces réservés qu'ils supportent (par exemple, s'il y a un paramètre de chaîne dans le chemin de la requête, alors cette requête sera assignée à un groupe de requêtes qui supportent l'espace réservé URLPath).
2. Le prochain vecteur malveillant est sélectionné dans la file d'attente pour envoi. En fonction de l'espace réservé spécifié pour celui-ci, tous les modèles de requêtes dans lesquels ce vecteur peut être substitué sont sélectionnés. Ensuite, le vecteur est substitué dans le modèle et la requête est envoyée.
3. En fonction des réponses possibles spécifiées dans le fichier OpenAPI, il est déterminé si la requête a été bloquée par le WAF ou transmise à l'application. Si le statut du code de réponse et son schéma correspondent à ceux décrits dans le fichier OpenAPI, la requête est marquée comme contournée. Sinon, elle sera marquée comme bloquée. Il est possible que l'application réponde uniquement avec un code de statut, et que ce code de statut corresponde à la réponse du WAF. Dans ce cas, la requête sera marquée comme non résolue.
Certaines fonctionnalités OpenAPI supportées :
* paramètres numériques et de chaîne dans les en-têtes, les chemins, les paramètres de requête et le corps des requêtes ;
* les types de contenu suivants sont supportés pour le corps de la requête : `application/json`, `application/xml`, `application/x-www-form-urlencoded`, `text/plain` ;
* les modificateurs suivants sont supportés pour XML : `name`, `wrapped`, `attribute`, `prefix`, `namespace` ;
* les limites de longueur pour les chaînes sont supportées via les paramètres `minLength` et `maxLength` ;
* les restrictions de valeur pour les nombres sont supportées via `minimum`, `maximum`, `exclusiveMinimum` et `exclusiveMaximum` ;
* les restrictions sur la longueur des tableaux via `minItems` et `maxItems` sont supportées ;
* la combinaison de schémas via `oneOf`, `anyOf`, `allOf` est supportée.
Basé sur le principe de fonctionnement décrit, il est extrêmement important que le fichier OpenAPI représente correctement l'API de l'application implémentée. Par conséquent, par exemple, vous ne pouvez pas utiliser `default` pour décrire les réponses possibles aux requêtes.
Remarque : Vous devez transférer le volume avec la spécification openapi vers le conteneur GoTestWAF.```sh
-v ${PWD}/api.yaml:/app/api.yaml
Exemple Docker complet:```sh docker run --rm --network="host" -it -v ${PWD}/reports:/app/reports -v ${PWD}/api.yaml:/app/api.yaml wallarm/gotestwaf --wafName your_waf_name --url=https://example.com/v1 --openapiFile api.yaml
## Exécution avec la suite de tests de régression de l'OWASP Core Rule Set
GoTestWAF permet une intégration facile de suites de tests supplémentaires.
Dans cet exemple, nous allons montrer comment ajouter des tests de la suite de tests de régression de l'OWASP Core Rule Set.
Étant donné que les tests sont écrits dans un format différent de celui de GoTestWAF, une conversion est nécessaire. À cet effet, le script **misc/modsec_regression_testset_converter.rb** est fourni.
Pour convertir les tests, exécutez `make modsec_crs_regression_tests_convert`.
Ensuite, construisez un conteneur avec l'ensemble de tests mis à jour.
`make gotestwaf`
Notez que par défaut, les tests sont convertis pour un sous-ensemble seulement de règles. Les catégories suivantes ont été choisies :
- REQUEST-932-APPLICATION-ATTACK-RCE
- REQUEST-933-APPLICATION-ATTACK-PHP
- REQUEST-941-APPLICATION-ATTACK-XSS
- REQUEST-930-APPLICATION-ATTACK-LFI
- REQUEST-931-APPLICATION-ATTACK-RFI
- REQUEST-942-APPLICATION-ATTACK-SQLI
- REQUEST-944-APPLICATION-ATTACK-JAVA
- REQUEST-934-APPLICATION-ATTACK-GENERIC
- REQUEST-913-SCANNER-DETECTION
Si nécessaire, modifiez la variable "crs_testcases" dans misc/modsec_regression_testset_converter.rb pour ajouter ou supprimer des catégories de tests.
docker pulldocker rundocker pull wallarm/gotestwaf
docker run --rm --network="host" -v ${PWD}/reports:/app/reports \
wallarm/gotestwaf --url=http://127.0.0.1:8080 --noEmailReport
Construisez l'image Docker GoTestWAF à partir du Dockerfile et exécutez l'image en utilisant les commandes make suivantes (assurez-vous que ModSec est en cours d'exécution sur le port 8080 ; sinon, mettez à jour la valeur du port dans le Makefile) :
make gotestwaf
make scan_local_from_docker
Démarrez GoTestWAF nativement avec go en utilisant la commande make suivante :
(assurez-vous que ModSec est en cours d'exécution sur le port 8080 ; sinon, mettez à jour la valeur du port dans le Makefile) :
make scan_local
Trouvez le fichier rapport waf-evaluation-report-<date>.pdf dans
le dossier reports que vous avez mappé à /app/reports à l'intérieur du conteneur.