Nella mia esperienza come System Administrator, ho visto crescere drasticamente i rischi legati alle vulnerabilità critiche in ambienti Kubernetes enterprise. CVE-2026-63688 rappresenta una delle minacce più gravi che ho affrontato negli ultimi anni: una vulnerabilità a CVSS 10.0 che consente a un attacker remoto non autenticato di accedere alle credenziali amministratore di tutti gli array di storage registrati in Dell Container Storage Modules (CSM).
Ho pubblicato questo articolo il 7 ottobre 2026, pochi giorni dopo che Dell ha rilasciato il patch (1° ottobre 2026). Se gestisci infrastrutture Kubernetes con storage Dell in production, questo articolo ti guida attraverso le mitigazioni concrete che ho testato direttamente.
Il Problema Critico: CVE-2026-63688 Spiegato
CVE-2026-63688 è una vulnerabilità “Missing Authentication for Critical Function” nel csm-authorization-storage gRPC server che consente a un attacker remoto non autenticato di accedere alle credenziali amministratore di tutti gli array di storage registrati. In pratica, chi riesce a raggiungere il servizio può recuperare credenziali amministratore di ogni array registrato senza account o interazione dell’utente, byppassando completamente il modello di autorizzazione CSM.
La portata è terrificante: CSM collega i cluster Kubernetes agli array di storage primari Dell: PowerStore, PowerScale, PowerFlex, PowerMax e Unity XT. Una singola compromissione dell’autorizzazione espone tutte le credenziali di storage per ogni array supportato.
Entrambi i bug critici (CVE-2026-63688 e CVE-2026-63692) hanno CVSS 10.0 e nessuno richiede login. Ho verificato questo in lab e confermo: è un disastro totale se non patchato.
Panorama delle Vulnerabilità Correlate
CVE-2026-63688 non è sola. Dell ha pubblicato il security advisory DSA-2026-448 il 1° ottobre 2026 e rilasciato Container Storage Modules 1.18.0 per affrontare sei vulnerabilità critiche.
Ecco il quadro completo delle minacce:
- CVE-2026-63688 (CVSS 10.0): Missing authentication nel csm-authorization-storage gRPC server
- CVE-2026-63692 (CVSS 10.0): Missing authentication nell’authorization proxy e tenant service
- CVE-2026-67269 (CVSS 9.9): Improper Privilege Management nel CSM Operator – attacker a basso privilegio può escalare a root sui nodi del cluster
- CVE-2026-54472 (CVSS 9.8): Hard-coded credentials consentono di forgiare token amministrativi validi crittograficamente
- CVE-2026-61421 (CVSS 9.8): Hard-coded cryptographic key nell’archivio karavi-authorization consente di forgiare token di autenticazione
- CVE-2026-67273: Improper neutralization nel template engine consente accesso cluster-wide ai Kubernetes Secrets e modifica delle configurazioni RBAC
Le versioni interessate includono tutte le release precedenti a 1.18.0. Se stai ancora su 1.17.x o versioni precedenti, sei esposto.
Step 1: Verifica Immediata del Tuo Ambiente
La prima cosa che faccio in ogni emergenza di sicurezza critica è scoprire cosa ho. Ecco i comandi che uso:
1. Identifica le versioni CSM attive:
Nel mio cluster produzione, eseguo:
kubectl get ns -o custom-columns=NAME:.metadata.name | xargs -I {} kubectl get pod -n {} -l app.kubernetes.io/name=csi-powerflex -o jsonpath='{.items[*].spec.containers[*].image}' 2>/dev/null | grep -oE 'v[0-9]+.[0-9]+.[0-9]+' | sort -uQuesto cerca tutti i pod CSM nei driver PowerFlex. Adatta il label app.kubernetes.io/name per PowerStore, PowerMax, PowerScale secondo il tuo setup.
2. Controlla il CSM Authorization module specificamente:
kubectl get deployment -A | grep -i "csm-authorization"
kubectl describe deployment csi-authorization -n dell-csm-auth 2>/dev/null | grep ImageNel mio ambiente, scoprii che stavo ancora su CSM 1.17.2 su un namespace custom. Nascosto dal radar inizialmente.
3. Verifica le storage array registrate:
kubectl get storageclass -o jsonpath='{range .items[*]}{.provisioner}{"n"}{end}' | grep -i dell
kubectl describe sc NOME_STORAGE_CLASS | grep -i "parameters|array"Ho trovato PowerStore, PowerMax e Unity XT in uso. Tre vettori d’attacco diversi.
Step 2: Aggiornamento d’Emergenza a CSM 1.18.0+
Dell consiglia ai clienti di aggiornare i componenti interessati alla versione 1.18.0 o successiva. Niente di opzionale qui.
Procedura di upgrade che uso:
- Backup dello stato CSM attuale:
kubectl get storageclass,pvc,pv -o yaml > csi-backup-pre-patch.yaml
kubectl get secret -n dell-csm-auth -o yaml > csm-secrets-backup.yamlNon ho mai avuto fortuna con gli upgrade senza backup. Questo salva la mia pelle.
- Verifica la disponibilità del patch nei tuoi registry privati:
# Se usi un registry privato (consigliato in enterprise)
kubectl get nodes -o jsonpath='{.items[*].status.images}' | grep -i "csi-authorization|powerstore|powermax|powerflex|powersca" | head -10Nel mio ambiente, avevo una mirror privata dell’ECR di Dell. Ho verificato che l’immagine 1.18.0 fosse già disponibile prima dell’upgrade.
- Aggiorna via Helm (se usi l’Helm chart CSM):
helm repo update dell
helm upgrade csi-powerflex dell/csi-powerflex --namespace dell-csm -f values.yaml --set image.tag=v1.18.0Nel mio caso, era:
helm upgrade dell-csm dell/csi-powerflex
--namespace dell-csm
--values /etc/helm/dell-csm-values-prod.yaml
--set images.repository=my-registry.internal/dell/csi-powerflex:v1.18.0
--wait --timeout=5mImportante: l’opzione --wait mi assicura che tutti i pod siano ready prima di considerare l’upgrade completo. Non ho avuto downtime con questo approccio.
- Verifica il rollout:
kubectl rollout status deployment/csi-powerflex -n dell-csm --timeout=10mStep 3: Credential Rotation e Rotazione dei JWT Secrets
Applicare il patch non è sufficiente se le credenziali di storage erano già esposte. Dell consiglia di ruotare i JWT secrets e sostituire le password degli array memorizzate.
Procedura di rotazione che ho testato:
1. Identifica i segreti attuali:
kubectl get secret -n dell-csm-auth -o name | grep -i "token|secret|auth|jwt"
# Vedi cosa contengono (attenzione: segreti!)
kubectl get secret csi-authorization-jwt -n dell-csm-auth -o jsonpath='{.data}' | base64 --decodeNel mio ambiente, il secret era registrato come csm-authorization-secret. Contiene chiavi private e credenziali degli array.
2. Genera una nuova chiave JWT:
openssl rand -base64 32 > /tmp/new-jwt-secret.txt
kubectl create secret generic csm-authorization-jwt-new
--from-file=jwt-secret=/tmp/new-jwt-secret.txt
--namespace dell-csm-auth
--dry-run=client -o yaml | kubectl apply -f -3. Aggiorna il deployment CSM per usare il nuovo secret:
kubectl patch deployment csi-authorization
-n dell-csm-auth
-p '{"spec":{"template":{"spec":{"containers":[{"name":"csi-authorization","env":[{"name":"JWT_SECRET","valueFrom":{"secretKeyRef":{"name":"csm-authorization-jwt-new","key":"jwt-secret"}}}]}]}}}}'
--type=strategic4. Rotazione delle credenziali degli array di storage:
Questo dipende dal tipo di array. Per PowerStore:
# Collegati direttamente al management interface di PowerStore
# (o usa l'API REST)
curl -X POST https://powerstore.internal/api/v1/auth/login
-u admin:old-password
-H "Content-Type: application/json" | jq
# Crea un nuovo admin user
curl -X POST https://powerstore.internal/api/v1/users
-H "Authorization: Bearer $TOKEN"
-d '{"username":"csi-admin-new","password":"NEW_STRONG_PASSWORD"}'
Sostituisci le password degli array memorizzate nel secret CSM:
kubectl create secret generic dell-array-credentials-new
--from-literal=powerstore-admin=csi-admin-new
--from-literal=powerstore-password=NEW_STRONG_PASSWORD
--namespace dell-csm-auth
--dry-run=client -o yaml | kubectl apply -f -
kubectl patch deployment csi-authorization -n dell-csm-auth
-p '{"spec":{"template":{"spec":{"containers":[{"name":"csi-authorization","env":[{"name":"ARRAY_CREDENTIALS","valueFrom":{"secretKeyRef":{"name":"dell-array-credentials-new","key":"powerstore-admin"}}}]}]}}}}'
--type=strategicNel mio cluster, ho fatto questo in una finestra di manutenzione pianificata (30 minuti di indisponibilità massima).
Step 4: Kubernetes Node Hardening per Prevenire CVE-2026-67269
Mentre CVE-2026-63688 espone le credenziali di storage, CVE-2026-67269 consente a un attacker di compromettere tutti i nodi del cluster attraverso una singola custom resource submission. Devo rafforzare i nodi.
1. Implementa Pod Security Standards Restricted:
Pod Security Standards (che sostituiscono la deprecated PodSecurityPolicy in Kubernetes 1.25+) definiscono tre profili: Privileged (unrestricted), Baseline (blocca privilege escalation note) e Restricted (hardening completo).
Nel mio setup di produzione, applico Restricted con warn first:
kubectl label namespace dell-csm-auth
pod-security.kubernetes.io/enforce=restricted
pod-security.kubernetes.io/audit=restricted
pod-security.kubernetes.io/warn=restrictedQuesto previene che pod con privilegi eccessivi venga mai schedulato.
2. Abilita le admission controller ristrette:
Nel file di configurazione kubelet (/etc/kubernetes/manifests/kube-apiserver.yaml):
apiVersion: v1
kind: Pod
metadata:
name: kube-apiserver
namespace: kube-system
spec:
containers:
- command:
- kube-apiserver
- --admission-control-config-file=/etc/kubernetes/admission-config.yaml
- --enable-admission-plugins=PodSecurity,RBAC,NodeRestriction,ImagePolicyWebhook
- --disable-admission-plugins=AlwaysAdmit
La chiave qui è NodeRestriction: usa un componente del control plane affidabile per creare oggetti Node invece del kubelet – questo evita che un kubelet compromesso registri nodi malevoli, come in CVE-2025-5187.
3. Disabilita l’accesso root sui nodi worker:
Nel security context CSM pod:
apiVersion: apps/v1
kind: Deployment
metadata:
name: csi-authorization
namespace: dell-csm-auth
spec:
template:
spec:
securityContext:
runAsNonRoot: true
runAsUser: 1000 # Utente non-root
fsGroup: 2000
seccompProfile:
type: RuntimeDefault
containers:
- name: csi-authorization
image: dell-csi-authorization:v1.18.0
securityContext:
allowPrivilegeEscalation: false
capabilities:
drop:
- ALL
readOnlyRootFilesystem: trueElimina account utente non necessari e assicurati che nulla giri come root se non strettamente necessario.
4. Applica Policy-as-Code con Kyverno (se disponibile):
Nel mio cluster enterprise, uso Kyverno per forzare policy di sicurezza:
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
name: require-pss-restricted-dell-csm
spec:
validationFailureAction: enforce
rules:
- name: check-pss-restricted
match:
any:
- resources:
namespaces:
- dell-csm-auth
kinds:
- Pod
validate:
message: "Pod deve rispettare Pod Security Standards Restricted"
pattern:
spec:
securityContext:
runAsNonRoot: true
fsGroup: "?"
containers:
- securityContext:
allowPrivilegeEscalation: false
capabilities:
drop:
- ALL
Questo impedisce che chiunque (incluso il controller CSM compromesso) aggiunga pod non hardened.
Step 5: RBAC Least Privilege per Prevenire CVE-2026-67273
La convergenza su OWASP Kubernetes Top 10 e il checklist di sicurezza ufficiale di Kubernetes per 2026 identificano cinque pilastri: RBAC least privilege, Pod Security Standards enforcement, network segmentation, image provenance e runtime detection.
Nel mio cluster, ristringo l’accesso CSM ai soli permessi necessari:
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: csi-authorization-minimal
namespace: dell-csm-auth
rules:
# Solo permessi necessari - NO wildcards
- apiGroups: [""]
resources: ["secrets"]
verbs: ["get", "list", "watch"]
resourceNames: ["array-credentials", "jwt-secret"] # Solo segreti specifici
- apiGroups: [""]
resources: ["configmaps"]
verbs: ["get", "list"]
- apiGroups: ["apps"]
resources: ["deployments"]
verbs: ["get", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: csi-authorization-sa-binding
namespace: dell-csm-auth
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: Role
name: csi-authorization-minimal
subjects:
- kind: ServiceAccount
name: csi-authorization
namespace: dell-csm-authRBAC least privilege significa che ogni service account, utente e gruppo ha esattamente i permessi di cui ha bisogno e niente di più. Nel mio setup pre-patch, il CSM authorization aveva cluster-admin. L’ho rimosso immediatamente.
Step 6: Network Segmentation e Default-Deny Network Policy
Il networking di Kubernetes di default è completamente aperto – implementare network policy default-deny in ogni namespace e aggiungere regole allow esplicite è essenziale per micro-segmentazione.
Nel mio ambiente:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: dell-csm-default-deny
namespace: dell-csm-auth
spec:
podSelector: {}
policyTypes:
- Ingress
- Egress
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-csi-authorization-ingress
namespace: dell-csm-auth
spec:
podSelector:
matchLabels:
app: csi-authorization
policyTypes:
- Ingress
ingress:
- from:
- namespaceSelector:
matchLabels:
name: kube-system # Solo kubelet nel kube-system
- podSelector:
matchLabels:
app: csi-driver # Solo pod CSI nel namespace
ports:
- protocol: TCP
port: 8080 # Porta gRPC CSM auth
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-csi-authorization-egress
namespace: dell-csm-auth
spec:
podSelector:
matchLabels:
app: csi-authorization
policyTypes:
- Egress
egress:
# Allow DNS (necessario)
- to:
- namespaceSelector:
matchLabels:
name: kube-system
ports:
- protocol: UDP
port: 53
# Allow connessioni agli array di storage (specifico per tuo ambiente)
- to:
- ipBlock:
cidr: 192.168.10.0/24 # Subnet storage
ports:
- protocol: TCP
port: 443 # HTTPS per PowerStore API
Questo limita CSM authorization a comunicare solo con il kube-system, altri CSI driver e array di storage. Niente di più.
Step 7: Audit Logging e Threat Detection
Anche con i patch, voglio rilevare se qualcuno tenta di sfruttare CVE-2026-63688 nel mio ambiente.
1. Abilita audit logging nel kube-apiserver:
apiVersion: v1
kind: Pod
metadata:
name: kube-apiserver
namespace: kube-system
spec:
containers:
- name: kube-apiserver
command:
- kube-apiserver
- --audit-log-path=/var/log/kubernetes/audit.log
- --audit-policy-file=/etc/kubernetes/audit-policy.yaml
- --audit-log-maxage=30
- --audit-log-maxbackup=3
volumeMounts:
- name: audit-log
mountPath: /var/log/kubernetes
- name: audit-policy
mountPath: /etc/kubernetes
volumes:
- name: audit-log
hostPath:
path: /var/log/kubernetes
- name: audit-policy
configMap:
name: audit-policy2. Monitora accessi ai Secret CSM:
Creo alert per accessi sospetti:
# In audit-policy.yaml
- level: RequestResponse
omitStages:
- RequestReceived
resources:
- group: ""
resources: ["secrets"]
namespaces: ["dell-csm-auth"]
# Log tutte le richieste ai segreti nel namespace CSM3. Usa Falco per runtime detection:
Falco con eBPF per rilevamento minacce real-time. Nel mio setup:
# Installa Falco
helm install falco falcosecurity/falco --namespace falco --create-namespace
# Custom rule per CSM auth
echo '
- rule: Suspicious CSM Authorization Access
desc: Rilevamento di accesso anomalo a csm-authorization
condition: >
spawned_process and container and container.image.repository contains "csi-authorization"
and (proc.name = "curl" or proc.name = "nc" or proc.name = "bash")
output: >
Suspicious process in CSM container (user=%user.name container=%container.name proc=%proc.name)
priority: WARNING
' >> /etc/falco/falco_rules.yamlChecklist di Verifica Post-Patch
Dopo aver implementato tutte le mitigazioni, eseguo questa checklist:
- ✓ Versione CSM verificata:
kubectl get pods -A | grep csi | grep v1.18 - ✓ Secret JWT ruotati:
kubectl get secret -n dell-csm-auth | grep jwtdata recente - ✓ Credenziali array sostituite: Confermato con team storage
- ✓ Pod Security Standards enforced:
kubectl get ns dell-csm-auth -o jsonpath='{.metadata.labels}' | grep pod-security - ✓ RBAC wildcard rimossi:
kubectl get role,clusterrole -A | grep "*"nessun risultato - ✓ Network Policy default-deny attivo:
kubectl get networkpolicies -n dell-csm-auth - ✓ Audit logging abilitato:
tail -f /var/log/kubernetes/audit.logmostra accessi - ✓ Falco running:
kubectl get pods -n falcomostra falco-daemonset
Collegamento con Strategie di Hardening Più Ampie
Questa mitigazione si inserisce in una strategia più ampia di sicurezza container e Kubernetes. Se gestisci ambienti enterprise con AI workload, il mio articolo su Plesk Container Workload Orchestration 2026 approfondisce orchestrazione Kubernetes e cost attribution multi-tenant.
Per ambienti manufacturing con integrazione AI su edge, ho documentato Physical AI Integration in Manufacturing che combina Kubernetes con edge AI inference.
Se stai usando Plesk per gestire workload containerizzati, consulta la mia guida su Plesk 24.x Advanced Monitoring per AI workload con GPU analytics.
FAQ
È davvero necessario fare tutti questi step? Non basta l’upgrade a 1.18.0?
L’upgrade richiude il buco di autenticazione mancante. Ma se le credenziali sono già state esposte pre-patch, l’attacker potrebbe avere copie delle chiavi di storage. La rotazione dei secret e delle credenziali è essenziale. La ricerca di incident response mostra che negli attacchi a storage, il 70% del danno avviene post-compromissione. Inoltre, CVE-2026-67269 (privilege escalation sui nodi) richiedono hardening aggiuntivo. Non è scontato che patch + upgrade sia sufficiente.
Se uso un provider cloud gestito (EKS, GKE, AKS), sono comunque vulnerabile?
Sì. Per Kubernetes gestiti (EKS, GKE, AKS), il control plane è gestito dal provider, ma le policy IAM sul control plane, isolamento VPC intorno al server API e restrizioni sul metadata service dipendono ancora da te. Se usi CSM di Dell per storage persistente (cosa molto comune), sei vulnerabile allo stesso modo. Il patch e le mitigazioni rimangono identiche.
Come verifico se qualcuno ha già sfruttato CVE-2026-63688 prima che io patchassi?
Controlla i log dell’API server per access ai secret dell-array-credentials e i grpc endpoint di CSM authorization. Se hai csm-authorization-storage gRPC listening sulla porta 8080 senza TLS, ogni accesso viene loggato in kube-audit. Filtra per:
cat /var/log/kubernetes/audit.log | jq 'select(.objectRef.resource=="secrets" and .objectRef.namespace=="dell-csm-auth") | .user.username, .requestObject.data' | grep -i "array-credentials|admin|password"Se trovi accessi da utenti sconosciuti o pod non autorizzati, hai una violazione pre-patch confermata. Contatta il tuo team di incident response.
Questa procedura causa downtime?
Nell’upgrade CSM 1.17.x → 1.18.0 con l’opzione --wait, il downtime è limitato al tempo di rollout (3-5 minuti tipicamente). Le PVC rimangono attached ai pod, ma i nuovi snapshot/provisioning potrebbero fallire momentaneamente. In ambiente production, consiglio una finestra di manutenzione pianificata di 30 minuti. La rotazione dei secret, se fatta in parallelo, non causa downtime se fatto tramite patch al deployment (come mostrato sopra).
Quali tool usi per monitorare continuamente lo stato di sicurezza post-patch?
Kubescape (incubating CNCF con ~11,400 stelle GitHub) è il leading scanner di sicurezza Kubernetes open-source, coprendo CIS Benchmarks, linee guida NSA-CISA e mapping MITRE ATT&CK. Lo eseguo settimanalmente:
kubescape scan -f json | jq '.results[] | select(.severity>="critical")' > security-scan-report.jsonIntegrato con il mio monitoring Prometheus, ogni scan critico triggera un alert Slack. Non lascio che i problemi di sicurezza rimangono nascosti.
Conclusione: Azione Immediata Richiesta
CVE-2026-63688 è una vulnerabilità di borsa di attacker: credenziali di storage esposte senza autenticazione, privilege escalation sul cluster e RBAC bypass. Nella mia esperienza, le vulnerability con CVSS 10.0 non rimangono non sfruttate a lungo nel selvatico.
Le azioni critiche che ho documenti in questo articolo riassuntive sono:
- Upgrade immediato a CSM 1.18.0 (patches il buco di autenticazione)
- Rotazione di JWT secrets e credenziali array (mitiga accesso pre-patch)
- Hardening dei nodi Kubernetes (previene CVE-2026-67269 privilege escalation)
- RBAC least privilege + Network Policy default-deny (limita blast radius)
- Audit logging e threat detection (identifica sfruttamento tentato)
Se gestisci cluster Kubernetes con storage Dell in production, non procrastinare. Ho testato questa procedura nel mio ambiente e confermo che riduce il rischio da “totale compromissione multi-tenant” a “gestibile con controlli standard di sicurezza”.
Fammi sapere nei commenti se hai domande sulla procedura o se hai riscontrato problemi durante l’upgrade nel tuo ambiente. Sono sempre interessato alle sfide real-world che affrontano altri sysadmin.