Usa las restricciones de la política de seguridad de Anthos Service Mesh

El controlador de políticas viene con una biblioteca predeterminada de plantillas de restricciones que se pueden usar con el paquete de seguridad de Anthos Service Mesh para auditar el cumplimiento de las vulnerabilidades de seguridad de tu malla y las prácticas recomendadas.

Este conjunto de restricciones aborda las políticas y las aplica en los siguientes dominios:

• Anthos Service Mesh aplica el tráfico mTLS
• Prácticas recomendadas para la política de autorización de Anthos Service Mesh
• Aplicación de seguridad de cargas de trabajo de Anthos Service Mesh

Restricciones del paquete de políticas de Anthos Service Mesh

Nombre de la restricción	Descripción de la restricción	ID de control
asm-policy-v0.0.1-asm-ingressgateway-label	Aplica el uso de etiquetas de Ingressgateway de Istio solo en los Pods de Ingressgateway	1.1.1
asm-policy-v0.0.1-asm-sidecar-injection	Aplica el sidecar del proxy de Istio que siempre se inyectó en los Pods de carga de trabajo	1.1.2
asm-policy-v0.0.1-asm-authz-policy-mesh-default-deny	Aplica la denegación predeterminada a nivel de malla de AuthorizationPolicy	1.2.1
asm-policy-v0.0.1-asm-authz-policy-normalization	Aplica la normalización de AuthorizationPolicy	1.2.2
asm-policy-v0.0.1-asm-authz-policy-safe-pattern	Aplica los patrones seguros de AuthorizationPolicy	1.2.3
asm-policy-v0.0.1-asm-peer-authn-mesh-strict-mtls	Aplica la mTLS estricta a nivel de malla de PeerAuthentication	1.3.1
asm-policy-v0.0.1-asm-peer-authn-strict-mtls	Aplica todos los PeerAuthentications no puede reemplazar la mTLS estricta	1.3.2
asm-policy-v0.0.1-asm-request-authn-prohibited-output-headers	Aplicar de manera forzosa jwtRules outputPayloadToHeader para que no contenga encabezados de solicitud HTTP conocidos	1.4.1

Perfiles de paquetes

En el paquete de políticas de seguridad de Anthos Service Mesh, puedes usar dos perfiles basados en el nivel de rigurosidad. El nivel de rigurosidad bajo tiene menos restricciones aplicadas, lo que proporciona más flexibilidad. El nivel de rigurosidad alto tiene más restricciones aplicadas, lo que proporciona un control de política más seguro.

Nivel de rigurosidad bajo

El perfil de nivel de rigurosidad bajo tiene las siguientes restricciones de política:

• Solo los Pods de puerta de enlace de entrada de Istio pueden usar la etiqueta istio:ingressgateway.

• En AuthorizationPolicy, los campos hosts o notHosts solo se pueden usar si seleccionas la puerta de enlace de entrada de Istio que tiene la etiqueta istio:ingressgateway.

• En AuthorizationPolicy, cuando se usan los campos methods o notMethods, los valores deben estar en mayúsculas.

• En AuthorizationPolicy, cuando se usa el campo request.headers, los valores no pueden contener espacios en blanco.

• En AuthorizationPolicy, cuando se usan los campos paths o notPaths, los valores deben ser valores normalizados.

Nivel de rigurosidad alto

Este nivel incluye todas las restricciones del nivel de este tipo, además de las siguientes restricciones:

• En todos los Pods de cargas de trabajo, la anotación sidecar.istio.io/inject: false no se puede aplicar para omitir la inserción del proxy.

• Se aplica un nivel de malla AuthorizationPolicy que defina una regla de denegación predeterminada.

• El AuthorizationPolicy debe seguir ALLOW-with-positive-matching o DENY-with-Negative-match.

• En AuthorizationPolicy, cuando se usan los campos hosts o notHosts, los valores deben ser pares de <host-name> y <host-name>:*.

• Se aplica un nivel de malla PeerAuthentication que defina una mTLS estricta.

• Para todas las PeerAuthentication en la malla, el modo mTLS solo puede ser UNSET o STRICT, a fin de seguir la mTLS estricta.

Configuración del paquete

Método set de KPT	Descripción
strictness-level	Perfil del nivel de rigurosidad del paquete de Anthos Service Mesh; las opciones son "Baja" o "Alta" (predeterminado)

Antes de comenzar

1. Instala y, luego, inicializa Google Cloud CLI, que proporciona los comandos gcloud y kubectl que se usan en estas instrucciones. Si usas Cloud Shell, Google Cloud CLI viene preinstalada.
2. Instala el controlador de políticas v.1.11.2 o superior en tu clúster con la biblioteca predeterminada de plantillas de restricciones. También debes habilitar la compatibilidad con restricciones referenciales, ya que este paquete contiene restricciones referenciales.
3. Asegúrate de que Anthos Service Mesh esté instalado en el clúster.

Configura el controlador de políticas para restricciones referenciales

Advertencia: Puedes reemplazar los cambios. Si ya tienes un Config existente en el espacio de nombres gatekeeper-system, debes incluir toda la configuración de personalización anterior para conservar los cambios.

1. Guarda el siguiente manifiesto YAML como policycontroller-config.yaml:

   apiVersion: config.gatekeeper.sh/v1alpha1
   kind: Config
   metadata:
     name: config
     namespace: "gatekeeper-system"
   spec:
     sync:
       syncOnly:
         - group: ""
           version: "v1"
           kind: "Namespace"
         - group: "security.istio.io"
           version: "v1beta1"
           kind: "AuthorizationPolicy"
         - group: "security.istio.io"
           version: "v1beta1"
           kind: "PeerAuthentication"
   

   Este manifiesto configura Policy Controller para observar tipos específicos de objetos.

2. Aplica el manifiesto policycontroller-config.yaml:

   kubectl apply -f policycontroller-config.yaml
   

Audita el paquete de políticas de Anthos Service Mesh

El Controlador de políticas te permite aplicar políticas a tu clúster de Kubernetes. Para ayudar a probar tus cargas de trabajo y su cumplimiento con respecto a las políticas de Anthos Service Mesh que se describen en la tabla anterior, puedes implementar estas restricciones en modo de “auditoría” para revelar infracciones y, lo que es más importante, tener la oportunidad corregirlos antes de aplicarlos en tu clúster de Kubernetes.

Puedes aplicar estas políticas con spec.enforcementAction configurado como dryrun mediante kubectl, kpt o el Sincronizador de configuración.

kubectl

1. (Opcional) Obtén una vista previa de las restricciones de la política con kubectl:

   kubectl kustomize https://github.com/GoogleCloudPlatform/gke-policy-library.git/bundles/asm-policy-v0.0.1
   

2. Aplica las restricciones de la política con kubectl:

   kubectl apply -k https://github.com/GoogleCloudPlatform/gke-policy-library.git/bundles/asm-policy-v0.0.1
   

   Esta es la salida:

   asmauthzpolicydefaultdeny.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-authz-policy-mesh-default-deny created
   asmauthzpolicynormalization.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-authz-policy-normalization created
   asmauthzpolicysafepattern.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-authz-policy-safe-pattern created
   asmingressgatewaylabel.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-ingressgateway-label created
   asmpeerauthnmeshstrictmtls.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-peer-authn-mesh-strict-mtls created
   asmpeerauthnstrictmtls.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-peer-authn-strict-mtls created
   asmrequestauthnprohibitedoutputheaders.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-request-authn-prohibited-output-headers created
   asmsidecarinjection.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-sidecar-injection created
   

3. Verifica que se hayan instalado las restricciones de políticas y verifica si las infracciones existen en el clúster:

   kubectl get -k https://github.com/GoogleCloudPlatform/gke-policy-library.git/bundles/asm-policy-v0.0.1
   

   El resultado es similar al siguiente:

   NAME                                                                                                       ENFORCEMENT-ACTION   TOTAL-VIOLATIONS
   asmauthzpolicydefaultdeny.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-authz-policy-mesh-default-deny   dryrun               0
   
   NAME                                                                                                     ENFORCEMENT-ACTION   TOTAL-VIOLATIONS
   asmauthzpolicynormalization.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-authz-policy-normalization   dryrun               0
   
   NAME                                                                                                  ENFORCEMENT-ACTION   TOTAL-VIOLATIONS
   asmauthzpolicysafepattern.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-authz-policy-safe-pattern   dryrun               0
   
   NAME                                                                                          ENFORCEMENT-ACTION   TOTAL-VIOLATIONS
   asmingressgatewaylabel.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-ingressgateway-label   dryrun               0
   
   NAME                                                                                                     ENFORCEMENT-ACTION   TOTAL-VIOLATIONS
   asmpeerauthnmeshstrictmtls.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-peer-authn-mesh-strict-mtls   dryrun               0
   
   NAME                                                                                            ENFORCEMENT-ACTION   TOTAL-VIOLATIONS
   asmpeerauthnstrictmtls.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-peer-authn-strict-mtls   dryrun               0
   
   NAME                                                                                                                             ENFORCEMENT-ACTION   TOTAL-VIOLATIONS
   asmrequestauthnprohibitedoutputheaders.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-request-authn-prohibited-output-headers   dryrun               0
   
   NAME                                                                                    ENFORCEMENT-ACTION   TOTAL-VIOLATIONS
   asmsidecarinjection.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-sidecar-injection   dryrun               0
   

kpt

1. Instala y configura kpt. En estas instrucciones, se usa kpt para personalizar e implementar los recursos de Kubernetes.

2. Descarga el paquete de políticas de seguridad de Anthos Service Mesh desde GitHub mediante kpt:

   kpt pkg get https://github.com/GoogleCloudPlatform/gke-policy-library.git/bundles/asm-policy-v0.0.1
   

3. Ejecuta la función kpt set-enforcement-action para establecer la acción de aplicación de las políticas en dryrun:

   kpt fn eval asm-policy-v0.0.1 -i gcr.io/kpt-fn/set-enforcement-action:v0.1 \
     -- enforcementAction=dryrun
   

4. Ejecuta la función método set de kpt para configurar campos específicos de las políticas de seguridad de Anthos Service Mesh:

   kpt fn eval asm-policy-v0.0.1 --image gcr.io/kpt-fn/apply-setters:v0.2.0 -- \
   strictness-level="Low"
   

5. Inicializa el directorio de trabajo con kpt, que crea un recurso para realizar un seguimiento de los cambios:

   cd asm-policy-v0.0.1
   kpt live init
   

6. Aplica las restricciones de políticas con kpt:

   kpt live apply
   

   Este es el resultado:

   asmauthzpolicydefaultdeny.constraints.gatekeeper.sh/asm-authz-policy-mesh-default-deny created
   asmauthzpolicynormalization.constraints.gatekeeper.sh/asm-authz-policy-normalization created
   asmauthzpolicysafepattern.constraints.gatekeeper.sh/asm-authz-policy-safe-pattern created
   asmingressgatewaylabel.constraints.gatekeeper.sh/asm-ingressgateway-label created
   asmpeerauthnmeshstrictmtls.constraints.gatekeeper.sh/asm-peer-authn-mesh-strict-mtls created
   asmpeerauthnstrictmtls.constraints.gatekeeper.sh/asm-peer-authn-strict-mtls created
   asmsidecarinjection.constraints.gatekeeper.sh/asm-sidecar-injection created
   7 resource(s) applied. 7 created, 0 unchanged, 0 configured, 0 failed
   

7. Verifica que se hayan instalado las restricciones de políticas y verifica si las infracciones existen en el clúster:

   kpt live status --output table --poll-until current
   

   Un estado CURRENT confirma que la instalación de las restricciones se realizó de forma correcta.

Sincronizador de configuración

1. Instala y configura kpt. En estas instrucciones, se usa kpt para personalizar e implementar los recursos de Kubernetes.

Los operadores que usan el Sincronizador de configuración para implementar políticas en sus clústeres pueden usar las siguientes instrucciones:

1. Cambia al directorio del Sincronizador de configuración:

   cd SYNC_ROOT_DIR
   

   Nota: Kpt v1.0.0-beta.17 y las versiones posteriores crean automáticamente un archivo resourcegroup.yaml durante live init que no se debe registrar en el repositorio del Sincronizador de configuración. Si aún no está presente, agrega resourcegroup.yaml al archivo .gitignore del repositorio.

   Para crear o agregar .gitignore con resourcegroup.yaml, haz lo siguiente:

   echo resourcegroup.yaml >> .gitignore
   

2. Crea un directorio policies dedicado:

   mkdir -p policies
   

3. Descarga el paquete de políticas de seguridad de Anthos Service Mesh desde GitHub mediante kpt:

   kpt pkg get https://github.com/GoogleCloudPlatform/gke-policy-library.git/bundles/asm-policy-v0.0.1 policies/asm-policy-v0.0.1
   

4. Ejecuta la función kpt set-enforcement-action para establecer la acción de aplicación de las políticas en dryrun:

   kpt fn eval policies/asm-policy-v0.0.1 -i gcr.io/kpt-fn/set-enforcement-action:v0.1 -- enforcementAction=dryrun
   

5. Ejecuta la función método set de kpt para configurar campos específicos de las políticas de seguridad de Anthos Service Mesh:

   kpt fn eval policies/asm-policy-v0.0.1 --image gcr.io/kpt-fn/apply-setters:v0.2.0 -- \
   strictness-level="Low"
   

6. (Opcional) Obtén una vista previa de las restricciones de la política que se crearán:

   kpt live init policies/asm-policy-v0.0.1
   kpt live apply --dry-run policies/asm-policy-v0.0.1
   

   Esta es la salida:

   Dry-run strategy: client
   inventory update started
   inventory update finished
   apply phase started
   asmauthzpolicydefaultdeny.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-authz-policy-mesh-default-deny apply successful
   asmauthzpolicynormalization.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-authz-policy-normalization apply successful
   asmauthzpolicysafepattern.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-authz-policy-safe-pattern apply successful
   asmingressgatewaylabel.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-ingressgateway-label apply successful
   asmpeerauthnmeshstrictmtls.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-peer-authn-mesh-strict-mtls apply successful
   asmpeerauthnstrictmtls.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-peer-authn-strict-mtls apply successful
   asmrequestauthnprohibitedoutputheaders.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-request-authn-prohibited-output-headers apply successful
   asmsidecarinjection.constraints.gatekeeper.sh/asm-policy-v0.0.1-asm-sidecar-injection apply successful
   apply phase finished
   inventory update started
   inventory update finished
   apply result: 8 attempted, 8 successful, 0 skipped, 0 failed
   

7. Si tu directorio de sincronización para el Sincronizador de configuración usa Kustomize, agrega policies/asm-policy-v0.0.1 a tu kustomization.yaml raíz. De lo contrario, quita el archivo policies/asm-policy-v0.0.1/kustomization.yaml:

   rm SYNC_ROOT_DIR/policies/asm-policy-v0.0.1/kustomization.yaml
   

8. Envía los cambios al repositorio del Sincronizador de configuración:

   git add SYNC_ROOT_DIR/policies/asm-policy-v0.0.1
   git commit -m 'Adding ASM security policy audit enforcement'
   git push
   

9. Verifica el estado de la instalación:

   watch gcloud beta container fleet config-management status --project PROJECT_ID
   

   Un estado de SYNCED confirma la instalación de las políticas.

Visualiza incumplimientos de políticas

Una vez que se instalan las restricciones de políticas en el modo de auditoría, los incumplimientos del clúster se pueden ver en la IU mediante el Panel de Policy Controller.

También puedes usar kubectl para ver los incumplimientos en el clúster mediante el siguiente comando:

kubectl get constraint -l policycontroller.gke.io/bundleName=asm-policy-v0.0.1 -o json | jq -cC '.items[]| [.metadata.name,.status.totalViolations]'

Si hay incumplimientos, se puede ver una lista de los mensajes de incumplimiento por restricción con lo siguiente:

kubectl get constraint -l policycontroller.gke.io/bundleName=asm-policy-v0.0.1 -o json | jq -C '.items[]| select(.status.totalViolations>0)| [.metadata.name,.status.violations[]?]'

Cambiar la acción de aplicación del paquete de políticas de Anthos Service Mesh

Una vez que hayas revisado los incumplimientos de políticas en tu clúster, puedes cambiar el modo de aplicación para que el controlador de admisión warn en o incluso deny bloquee la aplicación del recurso que no cumple con las políticas en el clúster.

Advertencia: La acción de aplicación deny debe usarse con cuidado, ya que podría bloquear los cambios necesarios y provocar una interrupción en las cargas de trabajo críticas o en el clúster. Se recomienda que solo se usen las acciones de aplicación warn o dryrun en clústeres con cargas de trabajo de producción, cuando se prueben restricciones nuevas o se realicen migraciones, como actualizar plataformas. Para obtener más información sobre las acciones de aplicación, consulta Audita mediante restricciones.

kubectl

1. Usa kubectl para establecer la acción de aplicación de las políticas en warn:

   kubectl get constraint -l policycontroller.gke.io/bundleName=asm-policy-v0.0.1 -o name | xargs -I {} kubectl patch {} --type='json' -p='[{"op":"replace","path":"/spec/enforcementAction","value":"warn"}]'
   

2. Verifica que se haya actualizado la acción de aplicación de restricciones de la política:

   kubectl get constraint -l policycontroller.gke.io/bundleName=asm-policy-v0.0.1
   

kpt

1. Ejecuta la función kpt set-enforcement-action para establecer la acción de aplicación de las políticas en warn:

   kpt fn eval -i gcr.io/kpt-fn/set-enforcement-action:v0.1 -- enforcementAction=warn
   

2. Aplica las restricciones de la política:

   kpt live apply
   

Sincronizador de configuración

Los operadores que usan el Sincronizador de configuración para implementar políticas en sus clústeres pueden usar las siguientes instrucciones:

1. Cambia al directorio del Sincronizador de configuración:

   cd SYNC_ROOT_DIR
   

2. Ejecuta la función kpt set-enforcement-action para establecer la acción de aplicación de las políticas en warn:

   kpt fn eval policies/asm-policy-v0.0.1 -i gcr.io/kpt-fn/set-enforcement-action:v0.1 -- enforcementAction=warn
   

3. Envía los cambios al repositorio del Sincronizador de configuración:

   git add SYNC_ROOT_DIR/policies/asm-policy-v0.0.1
   git commit -m 'Adding ASM security policy bundle warn enforcement'
   git push
   

4. Verifica el estado de la instalación:

   gcloud alpha anthos config sync repo list --project PROJECT_ID
   

   El repositorio que aparece en la columna SYNCED confirma la instalación de las políticas.

Aplicación de la política de prueba

Crea un recurso que no cumpla con las políticas en el clúster con el siguiente comando:

cat <<EOF | kubectl apply -f -
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: non-compliant-authz-policy
spec:
  action: ALLOW
  rules:
  - to:
    - operation:
        methods: ["get"]
EOF

El controlador de admisión debe producir una advertencia en la que se enumeren los incumplimientos de política que infringe este recurso, como se muestra en el siguiente ejemplo:

Warning: [asm-policy-v0.0.1-asm-authz-policy-normalization] in rules-to-operation, methods or notMethods must be uppercase
authorizationpolicy.security.istio.io/non-compliant-authz-policy created

Quitar el paquete de políticas de Anthos Service Mesh

Si es necesario, se puede quitar el paquete de políticas de Anthos Service Mesh del clúster.

kubectl

• Usa kubectl para quitar las políticas:

  kubectl delete constraint -l policycontroller.gke.io/bundleName=asm-policy-v0.0.1
  

kpt

• Quita las políticas:

  kpt live destroy
  

Sincronizador de configuración

Los operadores que usan el Sincronizador de configuración para implementar políticas en sus clústeres pueden usar las siguientes instrucciones:

1. Envía los cambios al repositorio del Sincronizador de configuración:

   git rm -r SYNC_ROOT_DIR/policies/asm-policy-v0.0.1
   git commit -m 'Removing Anthos Service Mesh  policies'
   git push
   

2. Verifica el estado:

   gcloud alpha anthos config sync repo list --project PROJECT_ID
   

   El repositorio que aparece en la columna SYNCED confirma la eliminación de las políticas.