Atténuation manuelle de la politique réseau ArgoCD

Solutions pour un accès réseau non authentifié au serveur de référentiel ArgoCD et à Redis dans Automation Suite, avec une procédure d'atténuation NetworkPolicy manuelle.

Description

Une vulnérabilité affectant le composant ArgoCD repo-server a été récemment publiée et n'est pas corrigée par ArgoCD pour le moment.

Les ArgoCD repo-server et ArgoCD Redis sont accessibles depuis n'importe quel pod du réseau du cluster, car aucune PolitiqueRéseau ne restreint l'entrée à ces composants par défaut. Par conséquent, n'importe quel pod au sein du réseau de cluster peut s'y connecter directement, car ArgoCD ne nécessite pas d'authentification pour ces composants internes. Pour plus de détails, reportez-vous à ghSA-47m3-95c7-g2g8.

Pour atténuer le problème, vous devez appliquer manuellement la stratégie réseau décrite dans la section Solution de cette page.

Prérequis

• Exécutez cette procédure à partir d’un hôte disposant d’un accès kubectl au cluster.
• La procédure détecte automatiquement l'espace de noms ArgoCD. Si la détection automatique ne convient pas, définissez ARGOCD_NS avant d’exécuter le script.
• Cette atténuation repose sur l'application de la PolitiqueRéseau Kubernetes. Les clusters pris en charge par Automation Suite utilisent une configuration CNI compatible.

Solution

1. Exécutez le script suivant. Il détecte votre espace de noms ArgoCD et le mode Redis (autonome ou haute disponibilité, haute disponibilité) et applique automatiquement la stratégie réseau correspondante:

   export ARGOCD_NS="${ARGOCD_NS:-$(kubectl get pod -A -l app.kubernetes.io/name=argocd-repo-server -o jsonpath='{.items[0].metadata.namespace}')}"
   
   test -n "$ARGOCD_NS" || { echo "Cannot detect Argo CD namespace"; exit 1; }
   
   if kubectl -n "$ARGOCD_NS" get pod -l app=redis-ha-haproxy --no-headers 2>/dev/null | grep -q .; then
     REDIS_MODE=ha
   else
     REDIS_MODE=standalone
   fi
   
   echo "Argo CD namespace: $ARGOCD_NS"
   echo "Redis mode: $REDIS_MODE"
   
   cat <<EOF | kubectl apply -f -
   apiVersion: networking.k8s.io/v1
   kind: NetworkPolicy
   metadata:
     name: argocd-repo-server-manual-mitigation
     namespace: ${ARGOCD_NS}
   spec:
     podSelector:
       matchLabels:
         app.kubernetes.io/name: argocd-repo-server
     policyTypes:
       - Ingress
     ingress:
       - from:
           - podSelector:
               matchLabels:
                 app.kubernetes.io/name: argocd-server
           - podSelector:
               matchLabels:
                 app.kubernetes.io/name: argocd-application-controller
           - podSelector:
               matchLabels:
                 app.kubernetes.io/name: argocd-applicationset-controller
           - podSelector:
               matchLabels:
                 app.kubernetes.io/name: argocd-notifications-controller
         ports:
           - protocol: TCP
             port: 8081
       - from:
           - namespaceSelector: {}
         ports:
           - protocol: TCP
             port: 8084
   EOF
   
   if [ "$REDIS_MODE" = "ha" ]; then
     cat <<EOF | kubectl apply -f -
   apiVersion: networking.k8s.io/v1
   kind: NetworkPolicy
   metadata:
     name: argocd-redis-ha-server-manual-mitigation
     namespace: ${ARGOCD_NS}
   spec:
     podSelector:
       matchLabels:
         app: redis-ha
     policyTypes:
       - Ingress
     ingress:
       - from:
           - podSelector:
               matchLabels:
                 app: redis-ha
           - podSelector:
               matchLabels:
                 app: redis-ha-haproxy
         ports:
           - protocol: TCP
             port: 6379
           - protocol: TCP
             port: 26379
   ---
   apiVersion: networking.k8s.io/v1
   kind: NetworkPolicy
   metadata:
     name: argocd-redis-ha-haproxy-manual-mitigation
     namespace: ${ARGOCD_NS}
   spec:
     podSelector:
       matchLabels:
         app: redis-ha-haproxy
     policyTypes:
       - Ingress
     ingress:
       - from:
           - podSelector:
               matchLabels:
                 app.kubernetes.io/name: argocd-server
           - podSelector:
               matchLabels:
                 app.kubernetes.io/name: argocd-repo-server
           - podSelector:
               matchLabels:
                 app.kubernetes.io/name: argocd-application-controller
         ports:
           - protocol: TCP
             port: 6379
   EOF
   else
     cat <<EOF | kubectl apply -f -
   apiVersion: networking.k8s.io/v1
   kind: NetworkPolicy
   metadata:
     name: argocd-redis-manual-mitigation
     namespace: ${ARGOCD_NS}
   spec:
     podSelector:
       matchLabels:
         app.kubernetes.io/name: argocd-redis
     policyTypes:
       - Ingress
     ingress:
       - from:
           - podSelector:
               matchLabels:
                 app.kubernetes.io/name: argocd-server
           - podSelector:
               matchLabels:
                 app.kubernetes.io/name: argocd-repo-server
           - podSelector:
               matchLabels:
                 app.kubernetes.io/name: argocd-application-controller
         ports:
           - protocol: TCP
             port: 6379
       - from:
           - namespaceSelector: {}
         ports:
           - protocol: TCP
             port: 9121
   EOF
   fi
   

Vérifier

Exécutez les commandes suivantes pour confirmer que l'atténuation a été appliquée avec succès:

kubectl -n "$ARGOCD_NS" get networkpolicy
kubectl -n "$ARGOCD_NS" get pods
kubectl get applications.argoproj.io -A

Confirmez les éléments suivants:

• argocd-repo-server-manual-mitigation existe.
• Pour Redis haute disponibilité, il existe argocd-redis-ha-server-manual-mitigation et argocd-redis-ha-haproxy-manual-mitigation .
• Pour le Redis autonome, argocd-redis-manual-mitigation existe.
• Les pods ArgoCD sont Running ou Completed.
• Les applications ArgoCD restent Synced et Healthy.

Confirmer l’atténuation

Effectuez ces vérifications après avoir appliqué les politiques. Ils vérifient que le trafic ArgoCD requis fonctionne toujours et que le trafic interdit est bloqué.

1. Exécutez le script suivant :

   export ARGOCD_NS="${ARGOCD_NS:-$(kubectl get pod -A -l app.kubernetes.io/name=argocd-repo-server -o jsonpath='{.items[0].metadata.namespace}')}"
   test -n "$ARGOCD_NS" || { echo "Cannot detect Argo CD namespace"; exit 1; }
   
   if kubectl -n "$ARGOCD_NS" get pod -l app=redis-ha-haproxy --no-headers 2>/dev/null | grep -q .; then
     REDIS_MODE=ha
   else
     REDIS_MODE=standalone
   fi
   
   SERVER_POD="$(kubectl -n "$ARGOCD_NS" get pod -l app.kubernetes.io/name=argocd-server -o jsonpath='{.items[0].metadata.name}')"
   APPSET_POD="$(kubectl -n "$ARGOCD_NS" get pod -l app.kubernetes.io/name=argocd-applicationset-controller -o jsonpath='{.items[0].metadata.name}' 2>/dev/null || true)"
   FAILED_CHECKS=""
   
   tcp_check() {
     pod="$1"
     host="$2"
     port="$3"
     expected="$4"
     name="$5"
   
     code="$(kubectl -n "$ARGOCD_NS" exec "$pod" -- sh -c '
       host="$1"
       port="$2"
       if command -v nc >/dev/null 2>&1; then
         timeout 5 nc -z -w 3 "$host" "$port" >/dev/null 2>&1
         printf "%s\n" "$?"
       elif command -v bash >/dev/null 2>&1; then
         timeout 5 bash -c "</dev/tcp/${host}/${port}" >/dev/null 2>&1
         printf "%s\n" "$?"
       else
         printf "%s\n" "NO_TCP_TOOL"
       fi
     ' sh "$host" "$port" 2>/dev/null | tail -n 1)"
   
     if [ "$expected" = "allow" ] && [ "$code" = "0" ]; then
       return
     elif [ "$expected" = "deny" ] && [ "$code" != "0" ] && [ "$code" != "NO_TCP_TOOL" ] && [ -n "$code" ]; then
       return
     else
       FAILED_CHECKS="${FAILED_CHECKS}
   - ${name}: expected ${expected}, got exit code ${code}"
     fi
   }
   
   tcp_check "$SERVER_POD" argocd-repo-server 8081 allow "argocd-server to repo-server:8081"
   
   if [ "$REDIS_MODE" = "ha" ]; then
     HAPROXY_POD="$(kubectl -n "$ARGOCD_NS" get pod -l app=redis-ha-haproxy -o jsonpath='{.items[0].metadata.name}')"
   
     tcp_check "$SERVER_POD" argocd-redis-ha-haproxy 6379 allow "argocd-server to redis-ha-haproxy:6379"
     tcp_check "$HAPROXY_POD" argocd-redis-ha 6379 allow "redis-ha-haproxy to redis-ha:6379"
     tcp_check "$HAPROXY_POD" argocd-repo-server 8081 deny "redis-ha-haproxy to repo-server:8081"
   
     if [ -n "$APPSET_POD" ]; then
       tcp_check "$APPSET_POD" argocd-redis-ha-haproxy 6379 deny "applicationset-controller to redis-ha-haproxy:6379"
     fi
   else
     REDIS_POD="$(kubectl -n "$ARGOCD_NS" get pod -l app.kubernetes.io/name=argocd-redis -o jsonpath='{.items[0].metadata.name}')"
   
     tcp_check "$SERVER_POD" argocd-redis 6379 allow "argocd-server to redis:6379"
     tcp_check "$REDIS_POD" argocd-repo-server 8081 deny "redis to repo-server:8081"
   
     if [ -n "$APPSET_POD" ]; then
       tcp_check "$APPSET_POD" argocd-redis 6379 deny "applicationset-controller to redis:6379"
     fi
   fi
   
   if [ -z "$FAILED_CHECKS" ]; then
     echo "MITIGATION CHECK: PASS"
   else
     echo "MITIGATION CHECK: FAIL"
     echo "$FAILED_CHECKS"
     exit 1
   fi
   

   Résultat attendu: MITIGATION CHECK: PASS

Restaurer (Rollback)

Si nécessaire, procédez comme suit pour supprimer l'atténuation:

1. Supprimez les politiques d'atténuation manuelles:

   export ARGOCD_NS="${ARGOCD_NS:-$(kubectl get pod -A -l app.kubernetes.io/name=argocd-repo-server -o jsonpath='{.items[0].metadata.namespace}')}"
   test -n "$ARGOCD_NS" || { echo "Cannot detect Argo CD namespace"; exit 1; }
   
   kubectl -n "$ARGOCD_NS" delete networkpolicy \
     argocd-repo-server-manual-mitigation \
     argocd-redis-manual-mitigation \
     argocd-redis-ha-server-manual-mitigation \
     argocd-redis-ha-haproxy-manual-mitigation \
     --ignore-not-found
   

2. Confirmez que la restauration s’est terminée avec succès:

   kubectl -n "$ARGOCD_NS" get networkpolicy
   kubectl -n "$ARGOCD_NS" get pods
   kubectl get applications.argoproj.io -A
   

   Confirmez les éléments suivants:

   • Les politiques d’atténuation manuelle sont supprimées.
   • Les pods ArgoCD restent Running ou Completed.
   • Les applications ArgoCD restent Synced et Healthy.