Configurer les stratégies de pare-feu d'application web avec le NetScaler Ingress Controller

Dernière publication : Oct 02, 2026
NetScaler fournit une définition de ressource personnalisée (CRD) appelée WAF CRD pour Kubernetes. Vous pouvez utiliser la WAF CRD pour configurer les stratégies de pare-feu d'application web avec le NetScaler Ingress Controller sur les NetScaler VPX, MPX, SDX et CPX. La WAF CRD permet la communication entre le NetScaler Ingress Controller et NetScaler pour l'application des stratégies de pare-feu d'application web.
Dans un déploiement Kubernetes, vous pouvez appliquer une stratégie de pare-feu d'application web pour protéger le serveur à l'aide de la WAF CRD. Pour plus d'informations sur le pare-feu d'application web, consultez Sécurité des applications web.
Avec la WAF CRD, vous pouvez configurer la stratégie de sécurité du pare-feu pour appliquer les types de contrôles de sécurité suivants pour les applications natives Kubernetes.
Related information
CRD

Protections courantes

  • Dépassement de tampon
  • Type de contenu
  • Autoriser l'URL
  • Bloquer l'URL
  • Cohérence des cookies
  • Carte de crédit

Protections HTML

  • Marquage de formulaire CSRF (cross-site request forgery)
  • Formats de champ
  • Cohérence des champs de formulaire
  • Types de téléchargement de fichiers
  • Script intersite HTML
  • Injection SQL HTML

Protections JSON

  • Déni de service JSON
  • Injection SQL JSON
  • Script intersite JSON

Protections XML

  • Interopérabilité des services web XML
  • Pièce jointe XML
  • Script intersite XML
  • Déni de service XML
  • Format XML
  • Validation des messages XML
  • Filtrage des erreurs SOAP XML
  • Injection SQL XML
En fonction du type de contrôles de sécurité, vous pouvez spécifier les métadonnées et utiliser les attributs CRD dans le fichier .yaml du CRD WAF pour définir la politique WAF.

Définition du CRD WAF

Le CRD WAF est disponible dans le référentiel GitHub de NetScaler Ingress Controller à l'adresse waf-crd.yaml. Le CRD WAF fournit des attributs pour les différentes options nécessaires à la définition des politiques de pare-feu d'applications web sur NetScaler.

Attributs du CRD WAF

Le tableau suivant répertorie les différents attributs fournis dans le CRD WAF :
Attribut CRD Description
commonchecks Spécifie une liste de contrôles de sécurité courants, qui sont appliqués quel que soit le type de contenu.
block_urls Protège les URL.
buffer_overflow Protège contre le dépassement de tampon.
content_type Protège le type de contenu.
htmlchecks Spécifie une liste de contrôles de sécurité à appliquer pour les types de contenu HTML.
cross_site_scripting Prévient les attaques de script intersite.
sql_injection Prévient les attaques par injection SQL.
form_field_consistency Prévient la falsification de formulaires.
csrf Prévient les attaques de falsification de requêtes intersites (CSRF).
cookie_consistency Prévient la falsification de cookies ou la prise de contrôle de session.
field_format Valide la soumission du formulaire.
fileupload_type Empêche les téléchargements de fichiers malveillants.
jsonchecks Spécifie les contrôles de sécurité pour les types de contenu JSON.
xmlchecks Spécifie les contrôles de sécurité pour les types de contenu XML.
wsi Protège l'interopérabilité des services web.
redirect_url Redirige l'URL lorsque le blocage est activé sur la protection.
servicenames Spécifie les services auxquels les politiques WAF sont appliquées.
application_type Protège les types d'applications.
signatures Spécifie l'emplacement du fichier de signature externe.
html_error_object Spécifie l'emplacement de la page d'erreur personnalisée à afficher lorsque des tentatives de violations HTML ou courantes sont détectées.
xml_error_object Spécifie l'emplacement de la page d'erreur personnalisée à afficher lorsque des tentatives de violations XML sont détectées.
json_error_object Spécifie l'emplacement de la page d'erreur personnalisée à afficher lorsque des tentatives de violations JSON sont détectées.
ip_reputation Active la fonctionnalité de réputation IP.
target Détermine le trafic à inspecter par le WAF. Si vous ne spécifiez pas le trafic ciblé, tout le trafic est inspecté par défaut.
target.path Spécifie la liste des URL HTTP à inspecter.
target.method Spécifie la liste des méthodes HTTP à inspecter.
target.header Spécifie la liste des en-têtes HTTP à inspecter.
exclude Détermine le trafic à exclure par le WAF. Si vous ne spécifiez pas le trafic à exclure, tout le trafic est inspecté par défaut.
exclude.path Spécifie la liste des URL HTTP à exclure.
exclude.method Spécifie la liste des méthodes HTTP à exclure.
exclude.header Spécifie la liste des en-têtes HTTP à exclure.

Déployer le CRD WAF

Effectuez les étapes suivantes pour déployer le CRD WAF :
  1. Téléchargez le CRD (waf-crd.yaml).
  2. Déployez le CRD WAF à l'aide de la commande suivante :
    kubectl create -f waf-crd.yaml
    Par exemple,
    root@master:~# kubectl create -f waf-crd.yaml
    customresourcedefinition.apiextensions.k8s.io/wafpolicies.citrix.com created

Comment écrire une configuration WAF

Après avoir déployé le CRD WAF fourni par NetScaler® dans le cluster Kubernetes, vous pouvez définir la configuration de la politique de pare-feu d'application web dans un fichier .yaml. Dans le fichier .yaml, utilisez waf dans le champ kind. Dans la section spec, ajoutez les attributs du CRD WAF en fonction de vos exigences pour la configuration de la politique.
Après avoir déployé le fichier .yaml, le NetScaler Ingress Controller applique la configuration WAF sur le dispositif Ingress NetScaler.
Voici quelques exemples de rédaction de politiques de pare-feu d'application web.

Activer la protection contre les attaques de script intersites et d'injection SQL

Considérez un scénario dans lequel vous souhaitez définir et spécifier une politique de pare-feu d'application web dans le NetScaler pour activer la protection contre les attaques de script intersites et d'injection SQL. Vous pouvez créer un fichier .yaml appelé wafhtmlxsssql.yaml et utiliser les attributs CRD appropriés pour définir la politique WAF comme suit :
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafhtmlxsssql
spec:
    servicenames:
        - frontend
    application_type:
        - "HTML"
    html_error_object: "http://x.x.x.x/crd/error_page.html"
    security_checks:
        html:
          cross_site_scripting: "on"
          sql_injection: "on"

Appliquer des règles pour autoriser uniquement les types de contenu connus

Considérez un scénario dans lequel vous souhaitez définir une politique de pare-feu d'application web qui spécifie des règles pour autoriser uniquement les types de contenu connus et bloquer les types de contenu inconnus. Créez un fichier .yaml appelé waf-contenttype.yaml et utilisez les attributs CRD appropriés pour définir la politique WAF comme suit :
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafcontenttype
spec:
    servicenames:
        - frontend
    application_type:
        - "HTML"
    html_error_object: "http://x.x.x.x/crd/error_page.html"
    security_checks:
        common:
          content_type: "on"
    relaxations:
        common:
          content_type:
            types:
                - custom_cnt_type
                - image/crd

Protéger contre les attaques connues

Voici un exemple de configuration CRD WAF pour l'application de signatures externes. Vous pouvez copier les dernières signatures WAF de Emplacement des signatures vers le serveur web local et fournir l'emplacement du fichier copié comme signature_url.
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafhtmlsigxsssql
spec:
    servicenames:
        - frontend
    application_type:
        - "HTML"
    signatures: "http://x.x.x.x/crd/sig.xml"
    html_error_object: "http://x.x.x.x/crd/error_page.html"
    security_checks:
        html:
          cross_site_scripting: "on"
          sql_injection: "on"

Protéger contre les attaques de dépassement de tampon d'en-tête et bloquer plusieurs en-têtes

Voici un exemple de configuration CRD WAF pour la protection contre le dépassement de tampon.
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafhdrbufferoverflow
spec:
    servicenames:
        - frontend
    application_type:
        - "HTML"
    html_error_object: "http://x.x.x.x/crd/error_page.html"
    security_checks:
        common:
          buffer_overflow: "on"
          multiple_headers:
            action: ["block", "log"]
    settings:
        common:
          buffer_overflow:
            max_cookie_len: 409
            max_header_len: 4096
            max_url_len: 1024

Empêcher les tentatives répétées d'accès à des URL aléatoires sur un site web

Voici un exemple de configuration CRD WAF pour la fourniture de règles de filtrage d'URL. Vous pouvez ajouter des URL à autoriser sous allow_url et des URL à refuser sous block_url. L'URL peut également être une expression régulière. Les options target et exclude vous permettent de spécifier quelles URL, en-têtes et méthodes la politique WAF doit inspecter ou ignorer. Si vous ne définissez pas target ou exclude, le WAF inspecte toutes les URL par défaut.

apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafurlchecks
spec:
    servicenames:
        - frontend
    application_type:
        - "HTML"
    html_error_object: "http://x.x.x.x/crd/error_page.html"
    target:
        path:
            - /
        method:
            - GET
            - POST
        header:
            - Host
    exclude:
        path:
            - index.html
          method:
            - GET
    security_checks:
        common:
          allow_url: "on"
          block_url: "on"
    relaxations:
        common:
          allow_url:
            urls:
                - payment.php
                - cover.php
    enforcements:
        common:
          block_url:
            urls:
                - "^[^?]*(passwd|passwords?)([.][^/?]*)?([?].*)?$"
                - "^[^?]*(htaccess|access_log)([.][^/?]*)?([~])?([?].*)?$"

Empêcher la fuite de données sensibles

Les violations de données impliquent la fuite de données sensibles telles que les numéros de carte de crédit et de sécurité sociale (SSN). Vous pouvez ajouter des expressions régulières personnalisées pour les données sensibles dans la section Enforcements safe objects.
Voici un exemple de configuration CRD WAF pour empêcher la fuite de données sensibles.
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafdataleak
spec:
    servicenames:
        - frontend
   application_type:
        - "HTML"
    html_error_object: "http://x.x.x.x/crd/error_page.html"
    security_checks:
        common:
          credit_card: "on"
    settings:
        common:
          credit_card:
            card_type: ["visa","amex"]
            max_allowed: 1
            card_xout: "on"
            secure_logging: "on"
    enforcements:
        common:
          safe_object:
            - rule:
                name: aadhar
                expression: "[1-9]{4,4}\s[1-9]{4,4}\s[1-9]{4,4}"
                max_match_len: 19
                action: ["log","block"]

Protéger les formulaires HTML contre les attaques CSRF et les attaques de formulaire

Voici un exemple de configuration CRD WAF pour protéger les formulaires HTML contre les attaques CSRF et les attaques de formulaire.
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafforms
spec:
    servicenames:
        - frontend
    application_type:
        - "HTML"
    html_error_object: "http://x.x.x.x/crd/error_page.html"
    security_checks:
        html:
          cross_site_scripting: "on"
          sql_injection: "on"
          form_field_consistency:
            action: ["log","block"]
          csrf: "on"

Protéger les formulaires et les en-têtes

Voici un exemple de configuration CRD WAF pour protéger à la fois les formulaires et les en-têtes.
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafhdrforms
spec:
    servicenames:
        - frontend
   application_type:
        - "HTML"
    html_page_url: "http://x.x.x.x/crd/error_page.html"
    security_checks:
        common:
          buffer_overflow: "on"
          multiple_headers:
            action: ["block", "log"]
        html:
          cross_site_scripting: "on"
          sql_injection: "on"
          form_field_consistency:
            action: ["log","block"]
          csrf: "on"
    settings:
        common:
          buffer_overflow:
            max_cookie_len: 409
            max_header_len: 4096
            max_url_len: 1024
    ip_reputation: on

Activer les vérifications de sécurité WAF de base

Les vérifications de sécurité de base sont nécessaires pour protéger toute application avec un effet minimal sur les performances. Elles ne nécessitent aucune sessionisation. Voici un exemple de configuration CRD WAF pour activer les vérifications de sécurité WAF de base.
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafbasic
spec:
    servicenames:
        - frontend
    security_checks:
        common:
          allow_url: "on"
          block_url: "on
          buffer_overflow: "on"
          multiple_headers:
            action: ["block", "log"]
        html:
          cross_site_scripting: "on"
          field_format: "on"
          sql_injection: "on"
          fileupload_type: "on"
        json:
          dos: "on"
          sql_injection: "on"
          cross_site_scripting: "on"
        xml:
          dos: "on"
          wsi: "on"
          attachment: "on"
          format: "on"
    relaxations:
        common:
          allow_url:
            urls:
                - "^[^?]+.$"
                - "^[^?]+.([?].*)?$"

Activer la vérification de sécurité WAF avancée

Les vérifications de sécurité avancées telles que la cohérence des cookies, la fermeture d'URL autorisée, la cohérence des champs et le CSRF sont gourmandes en ressources (CPU et mémoire) car elles nécessitent une sessionisation WAF. Par exemple, lorsqu'un formulaire est protégé par le WAF, les informations des champs du formulaire dans la réponse sont conservées dans la mémoire système. Lorsque le client soumet le formulaire dans la requête suivante, il est vérifié pour détecter les incohérences avant que les informations ne soient envoyées au serveur web. Ce processus est appelé sessionisation. Voici un exemple de configuration CRD WAF pour activer les vérifications de sécurité WAF avancées.
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafadvanced
spec:
    servicenames:
        - frontend
    security_checks:
        common:
          allow_url: "on"
          block_url: "on"
          buffer_overflow: "on"
          content_type: "on"
          cookie_consistency: "on"
          multiple_headers:
            action: ["log"]
        html:
          cross_site_scripting: "on"
          field_format: "on"
          sql_injection: "on"
          form_field_consistency: "on"
          csrf: "on"
          fileupload_type: "on"
        json:
          dos: "on"
          sql_injection: "on"
          cross_site_scripting: "on"
        xml:
          dos: "on"
          wsi: "on"
          validation: "on"
          attachment: "on"
          format: "on"
    settings:
        common:
          allow_url:
            closure: "on"

Activer la réputation IP

Voici un exemple de configuration CRD WAF pour activer la réputation IP afin de rejeter les requêtes provenant d'adresses IP ayant une mauvaise réputation.
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafiprep
spec:
    application_type:
        - "HTML"
    servicenames:
        - frontend
    ip_reputation: "on"

Activer la réputation IP pour rejeter les requêtes d'une catégorie particulière

Voici un exemple de configuration CRD WAF pour activer la réputation IP afin de rejeter les requêtes provenant de catégories de menaces particulières.
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafiprepcategory
spec:
    application_type:
        - "HTML"
    servicenames:
        - frontend
    ip_reputation:
        action: block
        threat-categories:
            - SPAM_SOURCES
            - WINDOWS_EXPLOITS
            - WEB_ATTACKS
            - BOTNETS
            - SCANNERS
            - DOS
            - REPUTATION
            - PHISHING
            - PROXY
            - NETWORK
            - CLOUD_PROVIDERS
            - MOBILE_THREATS

Protéger les applications JSON contre les attaques par déni de service

Voici un exemple de configuration CRD WAF pour protéger les applications JSON contre les attaques par déni de service.
metadata:
    name: wafjsondos
spec:
    servicenames:
        - frontend
    application_type: JSON
    json_error_object: "http://x.x.x.x/crd/error_page.json"
    security_checks:
        json:
          dos: "on"
    settings:
        json:
          dos:
            container:
              max_depth: 2
            document:
              max_len: 20000000
            array:
              max_len: 5
            key:
              max_count: 10000
              max_len: 12
            string:
              max_len: 1000000

Protéger les API RESTful

Voici un exemple de configuration CRD WAF pour protéger les API RESTful contre les injections SQL, les scripts intersites et les attaques par déni de service. Ici, l'application ou le service back-end est purement basé sur des API RESTful.
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafjson
spec:
    servicenames:
        - frontend
    application_type: JSON
    json_error_object: "http://x.x.x.x/crd/error_page.json"
    security_checks:
        json:
          dos: "on"
          sql_injection:
            action: ["block"]
          cross_site_scripting: "on"
    settings:
        json:
          dos:
            container:
              max_depth: 5
            document:
              max_len: 20000000
            array:
              max_len: 10000
            key:
              max_count: 10000
              max_len: 128
            string:
              max_len: 1000000

Protéger les applications XML contre les attaques par déni de service

Voici un exemple de configuration CRD WAF pour protéger les applications XML contre les attaques par déni de service.
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafxmldos
spec:
    servicenames:
        - frontend
    application_type: XML
    xml_error_object: "http://x.x.x.x/crd/error_page.xml"
    security_checks:
        xml:
          dos: "on"
    settings:
        xml:
          dos:
            attribute:
                max_attributes: 1024
                max_name_len: 128
                max_value_len: 128
            element:
                max_elements: 1024
                max_children: 128
                max_depth: 128
            file:
                max_size: 2123
                min_size: 9
            entity:
                max_expansions: 512
                max_expansions_depth: 9
            namespace:
                max_namespaces: 16
                max_uri_len: 256
            soaparray:
                max_size: 1111
            cdata:
                max_size: 65

Protéger les applications XML contre les attaques de sécurité

Cet exemple fournit une configuration CRD WAF pour protéger les applications XML contre les attaques de sécurité suivantes :
  • Injection SQL
  • Script intersite
  • Validation (schéma ou message)
  • Format
  • Déni de service
  • Interopérabilité des services Web (WSI)
apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafxml
spec:
    servicenames:
        - frontend
    application_type: XML
    xml_error_object: "http://x.x.x.x/crd/error_page.json"
    security_checks:
        xml:
          dos: "on"
          sql_injection: "on"
          cross_site_scripting: "off"
          wsi:
            action: ["block"]
          validation: "on"
          attachment: "on"
          format:
            action: ["block"]
    settings:
        xml:
          dos:
            attribute:
                max_attributes: 1024
                max_name_len: 128
                max_value_len: 128
            element:
                max_elements: 1024
                max_children: 128
                max_depth: 128
            file:
                max_size: 2123
                min_size: 9
            entity:
                max_expansions: 512
                max_expansions_depth: 9
            namespace:
                max_namespaces: 16
                max_uri_len: 256
            soaparray:
                max_size: 1111
            cdata:
                max_size: 65
          wsi:
            checks: ["R1000","R1003"]
          validation:
            soap_envelope: "on"
            validate_response: "on"
          attachment:
            url:
                max_size: 1111
            content_type:
                value: "crd_test"