Contrôleur d'entrée Citrix ADC

Configurer les stratégies de pare-feu des applications Web avec le Citrix ingress controller

Citrix fournit une définition de ressource personnalisée (CRD) appelée CRD WAF pour Kubernetes. Vous pouvez utiliser le CRD WAF pour configurer les stratégies de pare-feu d’application Web avec le Citrix ingress controller sur Citrix ADC VPX, MPX, SDX et CPX. Le CRD WAF permet la communication entre le Citrix ingress controller et Citrix ADC pour appliquer les stratégies de pare-feu des applications 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 du CRD WAF. Pour plus d’informations sur le pare-feu des applications Web, consultez la section Sécurité des applications Web.

Avec le CRD WAF, 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.

Protections communes

  • débordement de tampon
  • Type de contenu
  • Autoriser l’URL
  • URL de bloc
  • Cohérence des cookies
  • Carte de crédit

Protections HTML

  • Marquage de formulaire CSRF (Cross Side Request Forgery)
  • Formats de champs
  • Cohérence des champs
  • Types de téléchargement de fichiers
  • Script intersite HTML
  • Injection HTML SQL

Protections JSON

  • Déni de service JSON
  • Injection SQL JSON
  • Script inter-sites 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 XML SOAP
  • 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 stratégie WAF.

Définition de la CRD WAF

Le CRD WAF est disponible dans le référentiel GitHub du Citrix ingress controller à l’adresse waf-crd.yaml. Le CRD WAF fournit des attributs pour les différentes options requises pour définir les stratégies de pare-feu d’application Web sur Citrix ADC.

Attributs WAF CRD

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 le débordement 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 Empêche les attaques par script intersite.
sql_injection Prévient les attaques par injection SQL.
form_field_consistency Empêche la falsification du formulaire.
csrf Empêche les attaques de contrefaçon de requête croisée (CSRF).
cookie_consistency Empêche la falsification des cookie ou la prise de contrôle de session.
field_format Valide l’envoi 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 stratégies 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 à laquelle répondre en cas de tentative de violation du code HTML ou des violations courantes.
xml_error_object Spécifie l’emplacement de la page d’erreur personnalisée à laquelle répondre en cas de tentative de violation XML.
json_error_object Spécifie l’emplacement de la page d’erreur personnalisée à laquelle répondre en cas de tentative de violation JSON.
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.
paths Spécifie la liste des URL HTTP à inspecter.
method Spécifie la liste des méthodes HTTP à inspecter.
header Spécifie la liste des en-têtes HTTP à inspecter.

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
    <!--NeedCopy-->
    

Comment écrire une configuration WAF

Après avoir déployé le CRD WAF fourni par Citrix dans le cluster Kubernetes, vous pouvez définir la configuration de la stratégie de pare-feu d’application Web dans un fichier .yaml. Dans le fichier .yaml, utilisez waf dans le champ type. Dans la section Spécification, ajoutez les attributs CRD WAF en fonction de vos exigences pour la configuration de la stratégie.

Après avoir déployé le fichier .yaml, le Citrix ingress controller applique la configuration WAF sur l’appareil Citrix ADC d’entrée.

Voici quelques exemples d’écriture de stratégies de pare-feu d’application Web.

Protection contre les attaques par script intersite et par injection SQL**

Imaginez un scénario dans lequel vous souhaitez définir et spécifier une stratégie de pare-feu d’application Web dans Citrix ADC pour activer la protection contre les attaques par script intersite et par injection SQL. Vous pouvez créer un fichier .yaml appelé wafhtmlxsssql.yaml et utiliser les attributs CRD appropriés pour définir la stratégie WAF comme suit :

apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafhtmlxsssql
spec:
    servicenames:
        - frontend
    application_type: HTML
    html_page_url: "http://x.x.x.x/crd/error_page.html"
    security_checks:
        html:
          cross_site_scripting: "on"
          sql_injection: "on"
<!--NeedCopy-->

Appliquer des règles pour n’autoriser que les types de contenu connus

Imaginez un scénario dans lequel vous souhaitez définir une stratégie 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 stratégie 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

<!--NeedCopy-->

Protection contre les attaques connues

Voici un exemple de configuration CRD WAF pour appliquer des signatures externes. Vous pouvez copier les dernières signatures WAF depuis l’ emplacement de la signature vers le serveur Web local et fournir l’emplacement du fichier copié sous la forme 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"

<!--NeedCopy-->

Protégez-vous contre les attaques par débordement de tampon d’en-tête et bloquez plusieurs

Voici un exemple de configuration de CRD WAF pour protéger le débordement 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

<!--NeedCopy-->

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

Voici un exemple de configuration de CRD WAF pour fournir des 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.


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:
            - /
    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)([.][^/?]\*)?([~])?([?].\*)?$"
<!--NeedCopy-->

Prévenir les fuites de données sensibles

Les violations de données impliquent la fuite de données sensibles telles que la carte de crédit et le numéro 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"]
<!--NeedCopy-->

Protégez les formulaires HTML contre les attaques CSRF et les formulaires

Voici un exemple de configuration CRD WAF pour protéger les formulaires HTML contre les attaques CSRF et les formulaires.

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"

<!--NeedCopy-->

Protection des formulaires et des 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


<!--NeedCopy-->

Activer les contrôles de sécurité WAF de base

Les contrôles de sécurité de base sont nécessaires pour protéger toute application avec un impact minimal sur les performances. Il ne nécessite aucune session. Voici un exemple de configuration de CRD WAF pour activer les contrôles 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:
                - "^[^?]+[.](html?|shtml|js|gif|jpg|jpeg|png|swf|pif|pdf|css|csv)$"
                - "^[^?]+[.](cgi|aspx?|jsp|php|pl)([?].*)?$"

<!--NeedCopy-->

Activer le contrôle de sécurité avancé WAF

Les contrôles de sécurité avancés tels que la cohérence des cookie, l’autorisation de fermeture d’URL, la cohérence des champs et le CSRF consomment beaucoup de ressources (processeur et mémoire) car ils nécessitent une session WAF. Par exemple, lorsqu’un formulaire est protégé par le WAF, les informations de champ de formulaire dans la réponse sont conservées dans la mémoire système. Lorsque le client soumet le formulaire dans la demande suivante, il est vérifié pour les incohérences avant que les informations ne soient envoyées au serveur Web. Ce processus est connu sous le nom de sessionisation. Voici un exemple de configuration de CRD WAF pour activer les contrôles de sécurité avancés WAF.

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"
<!--NeedCopy-->

Activer la réputation IP

Voici un exemple de configuration CRD WAF pour permettre à la réputation IP de rejeter les demandes provenant d’adresses IP de mauvaise réputation.

apiVersion: citrix.com/v1
kind: waf
metadata:
    name: wafiprep
spec:
    application_type: html
    servicenames:
        - frontend
    ip_reputation: "on"

<!--NeedCopy-->

Permettre à la réputation IP de rejeter les demandes d’une catégorie particulière

Voici un exemple de configuration CRD WAF permettant à la réputation IP de rejeter les demandes 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

<!--NeedCopy-->

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

Voici un exemple de configuration de 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


<!--NeedCopy-->

Protégez les API RESTful

Voici un exemple de configuration CRD WAF pour protéger les API RESTful contre l’injection SQL, les scripts intersites et les attaques par déni de service. Ici, l’application ou le service back-end est uniquement 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

<!--NeedCopy-->

Protection des 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

<!--NeedCopy-->

Protégez 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
  • Scriptage 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"

<!--NeedCopy-->
Configurer les stratégies de pare-feu des applications Web avec le Citrix ingress controller