Masquer des résultats dans Security Command Center

Cette page explique comment réduire le volume de résultats que vous recevez dans Security Command Center en masquant les résultats.

Si vous désactivez un résultat, il ne s'affiche pas dans la vue par défaut de vos résultats dans la console Google Cloud. Vous pouvez désactiver manuellement ou automatiquement les résultats, et créer des filtres pour désactiver automatiquement les résultats existants et futurs en fonction des critères que vous spécifiez.

Les services de détection de Security Command Center fournissent des évaluations de sécurité générales de votre déploiement Google Cloud, mais vous pouvez constater que certains résultats ne sont pas appropriés ou pertinents pour votre organisation ou vos projets. Un grand nombre de résultats peut également compliquer l'identification et la résolution des risques les plus critiques pour vos analystes de sécurité. Ignorer les résultats vous fait gagner du temps lors de l'examen ou de la réponse aux résultats de sécurité des éléments isolés ou relevant des paramètres d'entreprise acceptables.

Ignorer les résultats présente plusieurs avantages par rapport à la désactivation des détecteurs:

• Vous pouvez créer des filtres personnalisés pour affiner les résultats à désactiver.
• Vous pouvez utiliser des règles d'exclusion pour ignorer temporairement ou définitivement des résultats.
• La désactivation des résultats n'empêche pas l'analyse des éléments sous-jacents. Les résultats sont toujours générés, mais restent masqués jusqu'à ce que vous décidiez de les afficher.

Autorisations

Pour désactiver les résultats, vous devez disposer de l'un des rôles IAM (Identity and Access Management) suivants au niveau de l'organisation, du dossier ou du projet:

• Afficher les règles de blocage :
  • Lecteur administrateur du centre de sécurité (roles/securitycenter.adminViewer)
  • Lecteur de paramètres du centre de sécurité (roles/securitycenter.settingsViewer)
  • Lecteur des configurations de mise en sourdine du centre de sécurité (roles/securitycenter.muteConfigsViewer)
• Affichez, créez, mettez à jour et supprimez des règles de blocage :
  • Administrateur du centre de sécurité (roles/securitycenter.admin)
  • Éditeur administrateur du centre de sécurité (roles/securitycenter.adminEditor)
  • Éditeur de paramètres du centre de sécurité (roles/securitycenter.settingsEditor)
  • Éditeur des configurations de mise en sourdine du centre de sécurité (roles/securitycenter.muteConfigsEditor)
• Désactiver manuellement les résultats :
  • Éditeur de données du centre de sécurité (roles/securitycenter.findingsEditor)

Vous pouvez également créer et attribuer des rôles personnalisés avec tout ou partie des autorisations suivantes :

• Ignorer les autorisations de lecture des règles
  • securitycenter.muteconfigs.get
  • securitycenter.muteconfigs.list
• Ignorer les autorisations d'écriture des règles
  • securitycenter.muteconfigs.create
  • securitycenter.muteconfigs.update
  • securitycenter.muteconfigs.delete
• Rechercher des autorisations en écriture
  • securitycenter.findings.setMute
  • securitycenter.findings.bulkMuteUpdate

Vous pouvez ignorer les résultats conformément aux rôles attribués au niveau de l'organisation, du dossier ou du projet. Vous pouvez ignorer les résultats de dossiers ou de projets spécifiques, et limiter la capacité d'autres personnes à ignorer les résultats en fonction de l'accès qui leur est accordé. Par exemple, si vous avez accès à un seul projet, vous ne pouvez ignorer les résultats que dans ce projet. Si vous avez accès à un dossier, vous pouvez ignorer les résultats de n'importe quel sous-dossier ou projet dans ce dossier.

Pour en savoir plus sur les rôles Security Command Center, consultez la page Contrôle des accès.

Créer et gérer des règles de blocage

Les règles de blocage sont des configurations Security Command Center qui utilisent des filtres que vous créez pour ignorer automatiquement les résultats futurs et existants en fonction des critères que vous spécifiez. Vous pouvez créer des filtres avec des règles Ignorer statiques ou dynamiques.

Les règles Ignorer statiques ignorent les futurs résultats indéfiniment. Les règles de masquage dynamique masquent temporairement les résultats futurs et existants jusqu'à une date spécifiée ou indéfiniment jusqu'à ce qu'un résultat ne corresponde plus à la configuration.

Types de règles de blocage

Security Command Center est compatible avec les configurations de règles Ignorer statiques et dynamiques. Bien que vous puissiez utiliser simultanément des règles de masquage statiques et dynamiques, nous vous déconseillons de le faire. Les règles Ignorer statiques remplacent les règles Ignorer dynamiques lorsqu'elles sont appliquées au même résultat. Par conséquent, les règles Ignorer dynamique ne fonctionneront pas comme prévu, ce qui peut prêter à confusion lorsque vous gérez vos résultats. Par conséquent, nous vous recommandons d'utiliser un seul type de règle de masquage.

Sauf si vous utilisez déjà des règles de masquage statiques, nous vous recommandons d'utiliser exclusivement des règles de masquage dynamiques, car elles offrent plus de flexibilité.

Le tableau suivant présente une comparaison générale des deux types de règles de masquage. Pour en savoir plus, consultez les sections Règles de masquage statiques et Règles de masquage dynamiques.

Règles Ignorer statiques	Règles Ignorer dynamiques
Intervenir indéfiniment en fonction des résultats.	Peut agir sur une découverte de manière temporaire avec un délai d'expiration ou indéfiniment si aucun délai d'expiration n'est défini.
Ne s'appliquent pas aux résultats existants.	S'applique aux résultats existants et nouveaux.
Elles prévalent sur les règles Ignorer dynamiques.	Elles ont une priorité inférieure et sont remplacées par les règles de masquage statiques lorsque les deux types s'appliquent à une observation.

Règles Ignorer statiques

• Les règles Ignorer statiques s'appliquent indéfiniment. Lorsqu'un résultat correspond à votre configuration de masquage statique, Security Command Center définit automatiquement la propriété mute du résultat sur MUTED jusqu'à ce que vous la modifiiez manuellement.
• Les règles Ignorer statiques n'ont aucun effet sur les résultats existants. Elles ne s'appliquent qu'aux résultats nouvellement créés ou mis à jour après la définition de la règle. Si vous souhaitez également ignorer des résultats existants, utilisez les mêmes filtres pour ignorer des résultats de manière groupée.
• Les règles Ignorer statiques sont prioritaires sur les règles Ignorer dynamiques. Par conséquent, toutes les nouvelles découvertes qui correspondent à une règle de masquage statique définie sont considérées comme masquées, même si elles correspondent également à une règle de masquage dynamique définie.

Règles Ignorer dynamiques

• Les règles d'ignorer dynamique peuvent agir sur un résultat de façon temporaire avec une date d'expiration ou indéfiniment si aucune date d'expiration n'est définie. Lorsqu'un résultat existant ou nouvellement créé correspond à votre configuration de masquage dynamique, Security Command Center définit automatiquement la propriété mute du résultat sur MUTED jusqu'à la date d'expiration spécifiée ou jusqu'à ce que le résultat ou la configuration elle-même changent. Lorsqu'une règle Ignorer dynamique expire, Security Command Center la supprime du résultat. Si le résultat ne correspond à aucune autre règle de blocage dynamique, la propriété mute est automatiquement réinitialisée sur UNDEFINED.
• Les règles de masquage dynamique s'appliquent automatiquement aux résultats existants qui correspondent à votre configuration, ainsi qu'aux résultats nouvellement créés ou mis à jour.
• Les règles de masquage dynamique ont une priorité inférieure et sont remplacées par les règles de masquage statique lorsque les deux types s'appliquent à une infraction.

Nous vous recommandons d'utiliser exclusivement des règles de masquage dynamique. La possibilité de désactiver temporairement et de réactiver automatiquement les résultats rend les règles Ignorer dynamiques plus flexibles que les règles Ignorer statiques.

Si vous utilisez des règles Ignorer statiques pour réduire le nombre de résultats que vous examinez manuellement et que vous souhaitez passer aux règles Ignorer dynamiques, consultez Passer des règles Ignorer statiques aux règles Ignorer dynamiques.

Portée des règles Ignorer

Tenez compte du champ d'application d'une règle de blocage lors de la création de filtres.

Par exemple, si un filtre est écrit pour ignorer des résultats dans Project A, mais qu'il est créé sous Project B, il peut ne correspondre à aucun résultat.

De même, si la résidence des données est activée, le champ d'application d'une règle de masquage est limité à l'emplacement Security Command Center dans lequel la règle de masquage est créée. Par exemple, si vous créez une règle de masquage dans l'emplacement États-Unis (us), elle ne masque pas les résultats stockés dans les emplacements Union européenne (eu) ou Monde (global). Pour en savoir plus sur la résidence des données et les règles de blocage, consultez la section Règles de blocage, exportations continues et résidence des données.

Pour en savoir plus sur la création de filtres, consultez la section Filtrer les notifications.

Restrictions des règles Ignorer

Les règles de blocage ne sont pas compatibles avec toutes les propriétés de résultats. Pour obtenir la liste des propriétés non compatibles avec les règles de blocage, consultez la section Propriétés de résultats non compatibles avec les règles de blocage.

Remarque :Les résultats appartenant à la classe de résultats SCC errors signalent les problèmes qui empêchent Security Command Center de fonctionner comme prévu. Par conséquent, les résultats d'erreurs ne peuvent pas être ignorés. Pour en savoir plus, consultez la page Présentation des erreurs Security Command Center.

Vous pouvez créer, afficher, mettre à jour et supprimer des règles de blocage en fonction du champ d'application de vos rôles IAM. Les rôles au niveau de l'organisation s'affichent pour tous les dossiers et projets de l'organisation. Si vous disposez de rôles au niveau des dossiers, vous pouvez accéder aux règles de blocage pour des dossiers spécifiques, ainsi que tous les sous-dossiers et projets de ces dossiers, et les gérer. Les rôles au niveau du projet vous permettent de gérer les règles de blocage dans des projets spécifiques.

Security Command Center Premium permet d'accorder des rôles au niveau de l'organisation, du dossier et du projet. Security Command Center Standard n'accepte que l'attribution de rôles au niveau de l'organisation. Pour plus d'informations, consultez la section Contrôle des accès.

Résidence des données et règles de masquage

Preview — Data residency

Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Si la résidence des données est activée, les configurations qui définissent les règles de masquage (ressources muteConfig) sont soumises au contrôle de la résidence des données et sont stockées dans un emplacement Security Command Center que vous sélectionnez.

Pour appliquer une règle de masquage aux résultats d'un emplacement Security Command Center, vous devez créer la règle de masquage au même emplacement que les résultats auxquels elle s'applique.

Étant donné que les filtres utilisés dans les règles Ignorer peuvent contenir des données soumises à des contrôles de résidence, assurez-vous de spécifier l'emplacement correct avant de les créer. Security Command Center ne limite pas l'emplacement dans lequel vous créez des règles de masquage ou des exportations de streaming.

Les règles Ignorer ne sont stockées que dans l'emplacement où elles sont créées et ne peuvent pas être consultées ni modifiées dans d'autres emplacements.

Une fois que vous avez créé une règle de masquage, vous ne pouvez plus modifier son emplacement. Pour modifier l'emplacement, vous devez supprimer la règle de blocage et la recréer au nouvel emplacement.

Pour afficher les règles de masquage dans la console Google Cloud, vous devez d'abord définir la vue de la console Google Cloud sur l'emplacement où elles ont été créées.

Les mêmes règles s'appliquent à la représentation de l'API d'une règle de masquage, MuteConfig.

Pour récupérer un MuteConfig à l'aide d'appels d'API, vous devez spécifier l'emplacement dans le nom de ressource complet de l'MuteConfig. Exemple :

GET https://securitycenter.googleapis.com/v2/organizations/123/locations/eu/muteConfigs/my-mute-rule-01

De même, pour récupérer un muteConfig à l'aide de gcloud CLI, vous pouvez spécifier l'emplacement à l'aide de l'option --location. Exemple :

gcloud scc muteconfigs list --organization=123 --location=us

Créer une règle de mise en sourdine

Votre organisation peut créer jusqu'à 1 000 règles de blocage.

Vous pouvez créer des règles de masquage statiques ou dynamiques à l'aide de la console Google Cloud, de la gcloud CLI ou de l'API Security Command Center. Nous vous recommandons d'utiliser exclusivement des règles Ignorer dynamiques dans vos configurations de règles Ignorer, car elles sont plus flexibles que les règles Ignorer statiques. Pour comparer les types de règles de masquage, consultez Types de règles de masquage.

Pour obtenir un exemple de code qui crée une règle de blocage, consultez la section Créer une règle de blocage.

Pour créer une règle de masquage, cliquez sur l'onglet de la procédure que vous souhaitez utiliser:

Console

1. Dans la console Google Cloud, accédez à la page Résultats de Security Command Center.

   Accéder

2. Si nécessaire, sélectionnez votre projet ou votre organisation GooglenCloud.

3. Facultatif: Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'établissements s'affiche. Sélectionnez le nouvel emplacement.

4. Cliquez sur Ignorer les options, puis sélectionnez Gérer les règles de blocage.

5. Cliquez sur Créer une règle de blocage, puis sélectionnez Règle de blocage dynamique ou Règle de blocage statique. Pour en savoir plus sur les types de règles de blocage, consultez la section Types de règles de blocage.

6. Saisissez un ID de règle de blocage. Veuillez indiquer une valeur.

7. Saisissez une description de la règle de blocage qui fournit des informations sur la raison pour laquelle les résultats sont ignorés. Cette valeur est facultative, mais recommandée.

   La ressource parente indique le champ d'application auquel la règle de blocage sera créée et appliquée.

8. Si vous créez une règle de blocage statique ou une règle de blocage dynamique sans expiration, passez à l'étape suivante. Si vous créez une règle de masquage dynamique pour désactiver temporairement les résultats, procédez comme suit:

   1. Cochez la case Ignorer temporairement les résultats correspondants.
   2. Sélectionnez ou saisissez la date d'expiration de la règle de masquage dynamique. Cette valeur indique la durée pendant laquelle la règle ignorera les résultats correspondants.

9. Dans le champ Requête de résultats, créez vos instructions de requête en cliquant sur Ajouter un filtre. Vous pouvez également saisir manuellement les instructions de requête.

   La boîte de dialogue Sélectionner un filtre vous permet de choisir les attributs et les valeurs de résultats compatibles.

   1. Sélectionnez un attribut de résultat ou saisissez son nom dans la zone Rechercher des attributs de résultats. La liste des sous-attributs disponibles s'affiche.
   2. Sélectionnez un sous-attribut. Un champ de sélection s'affiche, dans lequel vous pouvez créer l'instruction de requête à l'aide du sous-attribut que vous avez sélectionné, d'un opérateur de requête et d'une ou plusieurs valeurs pour le sous-attribut.
   3. Sélectionnez l'opérateur et une ou plusieurs valeurs pour le sous-attribut dans le panneau. Pour en savoir plus sur les opérateurs de requête et les fonctions qu'ils utilisent, consultez la section Opérateurs de requête dans le menu "Ajouter des filtres".
   4. Cliquez sur Appliquer.

      La boîte de dialogue se ferme et votre requête est mise à jour.

   5. Répétez l'opération jusqu'à ce que la requête de résultats contienne tous les attributs souhaités.

10. Vérifiez l'exactitude du filtre. Pour apporter des modifications, supprimez ou ajoutez des propriétés et filtrez les valeurs si nécessaire.

11. Cliquez sur Prévisualiser les résultats correspondants.

    Une table affiche les résultats correspondant à votre requête.

12. Cliquez sur Enregistrer.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour créer des règles de blocage, exécutez la commande gcloud scc muteconfigs create:

   gcloud scc muteconfigs create CONFIG_ID \
     --PARENT=PARENT_ID \
     --location=LOCATION
     --description="RULE_DESCRIPTION" \
     --filter="FILTER" \
     --type=MUTE_TYPE \
     --expiry-time=TIMESTAMP

   Remplacez les éléments suivants :

   • CONFIG_ID: nom de la règle de masquage. L'ID doit comporter entre 1 et 63 caractères, et être composé de caractères alphanumériques et de traits d'union.
   • PARENT: champ d'application dans la hiérarchie des ressources auquel la règle de masquage s'applique, organization, folder ou project.
   • PARENT_ID: ID numérique de l'organisation, du dossier ou du projet parent, ou ID alphanumérique du projet parent.
   • LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel créer une règle de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.
   • RULE_DESCRIPTION: description de la règle de masquage ne dépassant pas 1 024 caractères.
   • FILTER: expression que vous définissez pour filtrer les résultats. Par exemple, pour ignorer les résultats OPEN_FIREWALL, votre filtre peut être FILTER="category=\"OPEN_FIREWALL\"".
   • MUTE_TYPE: type de règle de blocage que vous souhaitez créer. Les types de règles de masquage valides sont DYNAMIC et STATIC. Le type de règle de masquage est défini sur STATIC par défaut. Vous ne pouvez pas modifier le type d'une règle de masquage une fois qu'elle a été créée.
   • TIMESTAMP: ne s'applique que si vous créez une règle de blocage dynamique. Chaîne de date/heure qui indique quand la règle de masquage dynamique expire. La valeur doit être définie sur au moins un jour à l'avance, sinon la demande sera refusée. Pour en savoir plus sur les formats de date et d'heure, consultez gcloud topic datetimes. Lorsqu'une règle de masquage dynamique expire, elle est supprimée de toutes les correspondances. Si vous souhaitez que la règle Ignorer dynamique agisse indéfiniment sur les résultats correspondants, omettez ce champ.

   La réponse inclut l'ID de la règle de blocage, que vous pouvez utiliser pour afficher, mettre à jour et supprimer des règles de blocage, comme décrit dans la section Gérer les règles de blocage.

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv2"
	"cloud.google.com/go/securitycenter/apiv2/securitycenterpb"
)

// createMuteRule: Creates a mute configuration under a given scope that will mute
// all new findings that match a given filter.
// Existing findings will not be muted.
func createMuteRule(w io.Writer, parent string, muteConfigId string) error {
	// parent: Use any one of the following options:
	//             - organizations/{organization_id}
	//             - folders/{folder_id}
	//             - projects/{project_id}
	// parent := fmt.Sprintf("projects/%s", "your-google-cloud-project-id")
	// muteConfigId: Set a random id; max of 63 chars.
	// muteConfigId := "random-mute-id-" + uuid.New().String()
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	muteConfig := &securitycenterpb.MuteConfig{
		Description: "Mute low-medium IAM grants excluding 'compute' ",
		// Set mute rule(s).
		// To construct mute rules and for supported properties, see:
		// https://cloud.google.com/security-command-center/docs/how-to-mute-findings#create_mute_rules
		Filter: "severity=\"LOW\" OR severity=\"MEDIUM\" AND " +
			"category=\"Persistence: IAM Anomalous Grant\" AND " +
			"-resource.type:\"compute\"",
		Type: securitycenterpb.MuteConfig_STATIC,
	}

	req := &securitycenterpb.CreateMuteConfigRequest{
		Parent:       parent,
		MuteConfigId: muteConfigId,
		MuteConfig:   muteConfig,
	}

	response, err := client.CreateMuteConfig(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to create mute rule: %w", err)
	}
	fmt.Fprintf(w, "Mute rule created successfully: %s", response.Name)
	return nil
}

Java

import com.google.cloud.securitycenter.v2.LocationName;
import com.google.cloud.securitycenter.v2.MuteConfig;
import com.google.cloud.securitycenter.v2.MuteConfig.MuteConfigType;
import com.google.cloud.securitycenter.v2.SecurityCenterClient;
import java.io.IOException;
import java.util.UUID;

public class CreateMuteRule {

  public static void main(String[] args) throws IOException {
    // TODO: Replace the following variables.
    // projectId: Google Cloud Project id.
    String projectId = "google-cloud-project-id";

    // Specify the location of the mute config.
    String location = "global";

    // muteConfigId: Set a random id; max of 63 chars.
    String muteConfigId = "random-mute-id-" + UUID.randomUUID();

    createMuteRule(projectId, location, muteConfigId);
  }

  // Creates a mute configuration in a project under a given location.
  public static void createMuteRule(String projectId, String location, String muteConfigId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      MuteConfig muteConfig =
          MuteConfig.newBuilder()
              .setDescription("Mute low-medium IAM grants excluding 'compute' ")
              // Set mute rule(s).
              // To construct mute rules and for supported properties, see:
              // https://cloud.google.com/security-command-center/docs/how-to-mute-findings#create_mute_rules
              .setFilter(
                  "severity=\"LOW\" OR severity=\"MEDIUM\" AND "
                      + "category=\"Persistence: IAM Anomalous Grant\" AND "
                      + "-resource.type:\"compute\"")
              .setType(MuteConfigType.STATIC)
              .build();

      // You can also create mute rules in an organization/ folder.
      // Construct the parameters according to the parent resource.
      //  * Organization -> client.createMuteConfig(OrganizationLocationName.of(...
      //  * Folder -> client.createMuteConfig(FolderLocationName.of(...
      MuteConfig response = client.createMuteConfig(
          LocationName.of(projectId, location), muteConfig, muteConfigId);
      System.out.println("Mute rule created successfully: " + response.getName());
    }
  }
}

Python

def create_mute_rule(parent_path: str, location_id: str, mute_config_id: str) -> Dict:
    """
    Creates a mute configuration under a given scope that will mute
    all new findings that match a given filter.
    Existing findings will NOT BE muted.
    Args:
        parent_path: use any one of the following options:
                     - organizations/{organization_id}
                     - folders/{folder_id}
                     - projects/{project_id}
        location_id: Gcp location id; example: 'global'
        mute_config_id: Set a unique id; max of 63 chars.
    Returns:
        Dict: returns the mute rule details
    """

    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

    mute_config = securitycenter_v2.MuteConfig()
    mute_config.description = "Mute low-medium IAM grants excluding 'compute' "
    # Set mute rule(s).
    # To construct mute rules and for supported properties, see:
    # https://cloud.google.com/security-command-center/docs/how-to-mute-findings#create_mute_rules
    mute_config.filter = (
        'severity="LOW" OR severity="MEDIUM" AND '
        'category="Persistence: IAM Anomalous Grant" AND '
        '-resource.type:"compute"'
    )
    mute_config.type = "STATIC"

    request = securitycenter_v2.CreateMuteConfigRequest()
    request.parent = parent_path + "/locations/" + location_id
    request.mute_config_id = mute_config_id
    request.mute_config = mute_config

    mute_config = client.create_mute_config(request=request)
    print(f"Mute rule created successfully: {mute_config.name}")
    return mute_config

REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs.create pour créer une règle de masquage. Le corps de la requête est une instance de MuteConfig:

POST https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/locations/LOCATION/muteConfigs?muteConfigId=MUTE_CONFIG_ID -d

  {
    "description": "RULE_DESCRIPTION",
    "filter": "FILTER",
    "type": "MUTE_TYPE",
    "expiryTime": "TIMESTAMP"
  }

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation, du dossier ou du projet parent
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel créer une règle de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.
• MUTE_CONFIG_ID: nom de la règle de blocage (entre 1 et 63 caractères)
• RULE_DESCRIPTION : description de la règle de masquage (1 024 caractères au plus)

• FILTER: expression que vous définissez pour filtrer les résultats

  Par exemple, pour ignorer les résultats OPEN_FIREWALL, votre filtre peut être "category=\"OPEN_FIREWALL\"".

• MUTE_TYPE: type de règle de blocage que vous souhaitez créer. Les types de règles de masquage valides sont DYNAMIC et STATIC. Vous ne pouvez pas modifier le type d'une règle de masquage une fois qu'elle a été créée.

• TIMESTAMP: ne s'applique que si vous créez une règle de blocage dynamique. Chaîne de date/heure qui indique quand la règle de masquage dynamique expire. La valeur doit être définie sur au moins un jour à l'avance, sinon la demande sera refusée. Pour en savoir plus sur les formats de date et d'heure, consultez gcloud topic datetimes. Lorsqu'une règle de masquage dynamique expire, elle est supprimée de toutes les correspondances. Si vous souhaitez que la règle Ignorer dynamique agisse indéfiniment sur les résultats correspondants, omettez ce champ.

La réponse inclut un ID de configuration de blocage, que vous pouvez utiliser pour afficher, mettre à jour et supprimer des règles de blocage, comme décrit dans la section Gérer les règles de blocage.

Les nouveaux résultats qui correspondent exactement au filtre sont masqués et l'attribut mute des résultats est défini sur MUTED.

Propriétés de résultats non compatibles avec les règles de blocage

Les règles de blocage ne sont pas compatibles avec toutes les propriétés de résultat dans les filtres. Les propriétés suivantes ne sont pas compatibles avec les filtres de règle de blocage.

• createTime
• eventTime
• mute
• mute_initiator
• mute_update_time
• name
• parent
• security_marks
• source_properties
• state

Répertorier les règles de blocage

Vous pouvez lister les règles de masquage dans une organisation, un dossier ou un projet à l'aide de la console Google Cloud, de la gcloud CLI ou de l'API Security Command Center.

La possibilité d'afficher la liste des règles de blocage pour un champ d'application donné dépend des autorisations accordées à vos rôles IAM.

Si la résidence des données est activée pour Security Command Center, la portée de la commande de liste est également limitée à l'emplacement Security Command Center sélectionné.

Pour obtenir un exemple de code qui liste les règles de blocage, consultez la section Liste des règles de blocage.

Pour afficher les règles de masquage d'une organisation, d'un dossier ou d'un projet, cliquez sur l'onglet correspondant à la procédure que vous souhaitez suivre:

Console

1. Dans Google Cloud Console, accédez à l'onglet Règles de blocage de la page Paramètres de Security Command Center.

   Accéder à la page "Règles de masquage"

2. Si nécessaire, sélectionnez votre projet ou votre organisation GooglenCloud.

3. Facultatif: Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'établissements s'affiche. Sélectionnez le nouvel emplacement.

4. La section Règles de blocage affiche les détails des règles de blocage actives, y compris les suivantes:

   • Nom : ID de la règle de blocage
   • Ressource parente : ressource où réside la règle de blocage
   • Description : description de la règle de blocage, si disponible
   • Dernière mise à jour par : compte principal qui a mis à jour la règle pour la dernière fois.
   • Dernière mise à jour : date et heure de la dernière mise à jour de la règle.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour répertorier les règles de blocage, exécutez la commande gcloud scc muteconfigs list:

   gcloud scc muteconfigs list --PARENT=PARENT_ID \
     --location=LOCATION

   Remplacez les éléments suivants :

   • PARENT: organization, folder ou project parent pour lequel lister les règles de blocage
   • PARENT_ID: ID de l'organisation, du dossier ou du projet parent
   • LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel lister les règles de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv2"
	"cloud.google.com/go/securitycenter/apiv2/securitycenterpb"
	"google.golang.org/api/iterator"
)

// listMuteRules lists mute configs at the organization level will return all the configs
// at the org, folder, and project levels.
// Similarly, listing configs at folder level will list all the configs
// at the folder and project levels.
func listMuteRules(w io.Writer, parent string) error {
	// Use any one of the following resource paths to list mute configurations:
	//         - organizations/{organization_id}
	//         - folders/{folder_id}
	//         - projects/{project_id}
	// parent := fmt.Sprintf("projects/%s", "your-google-cloud-project-id")
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.ListMuteConfigsRequest{Parent: parent}

	// List all mute configs present in the resource.
	it := client.ListMuteConfigs(ctx, req)
	for {
		muteconfig, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("it.Next: %w", err)
		}
		fmt.Fprintf(w, "Muteconfig Name: %s, ", muteconfig.Name)
	}
	return nil
}

Java

import com.google.cloud.securitycenter.v2.ListMuteConfigsRequest;
import com.google.cloud.securitycenter.v2.MuteConfig;
import com.google.cloud.securitycenter.v2.SecurityCenterClient;
import java.io.IOException;

public class ListMuteRules {

  public static void main(String[] args) throws IOException {
    // TODO: Replace variables enclosed within {}
    // projectId: Google Cloud Project id.
    String projectId = "google-cloud-project-id";

    // Specify the location to list mute configs.
    String location = "global";

    listMuteRules(projectId, location);
  }

  // Lists all mute rules present under the resource type in the given location.
  public static void listMuteRules(String projectId, String location) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      // Parent can also be one of:
      //  * "organizations/{org_id}/locations/{location}"
      //  * "folders/{folder_id}/locations/{location}"
      ListMuteConfigsRequest listMuteConfigsRequest = ListMuteConfigsRequest.newBuilder()
          .setParent(String.format("projects/%s/locations/%s", projectId, location))
          .build();

      // List all mute configs present in the resource.
      for (MuteConfig muteConfig : client.listMuteConfigs(listMuteConfigsRequest).iterateAll()) {
        System.out.println(muteConfig.getName());
      }
    }
  }
}

Python

def list_mute_rules(parent: str, location_id: str) -> Dict:
    """
    Listing mute configs at organization level will return all the configs
    at the org, folder and project levels.
    Similarly, listing configs at folder level will list all the configs
    at the folder and project levels.
    Args:
        parent: Use any one of the following resource paths to list mute configurations:
                - organizations/{organization_id}
                - folders/{folder_id}
                - projects/{project_id}
        location_id: Gcp location id; example: 'global'
    Returns:
         Dict: returns the mute rule details
    """
    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

    request = securitycenter_v2.ListMuteConfigsRequest()
    request.parent = parent + "/locations/" + location_id
    response = client.list_mute_configs(request)
    # List all Mute Configs present in the resource.
    for mute_config in response:
        print(mute_config.name)
    return response

REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs.list pour lister les règles de masquage:

GET https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/locations/LOCATION/muteConfigs

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation, du dossier ou du projet parent
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel lister les règles de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.

La réponse inclut les noms, les descriptions et les ID de configuration de blocage pour vos règles de blocage.

Afficher la configuration d'une règle de blocage

Vous pouvez afficher la configuration d'une règle de masquage à l'aide de la console Google Cloud, de gcloud CLI ou de l'API Security Command Center.

Pour obtenir un exemple de code qui récupère une configuration de règle de blocage, consultez la section Afficher une règle de blocage.

Pour afficher la configuration d'une règle de masquage, cliquez sur l'onglet correspondant à la procédure que vous souhaitez utiliser:

Console

1. Dans Google Cloud Console, accédez à l'onglet Règles de blocage de la page Paramètres de Security Command Center.

   Accéder à la page "Règles de masquage"

2. Si nécessaire, sélectionnez votre projet ou votre organisation GooglenCloud.

3. Facultatif: Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'établissements s'affiche. Sélectionnez le nouvel emplacement.

4. La section Règles de blocage s'affiche dans la section.

5. Cliquez sur le nom de la règle que vous souhaitez afficher.

   La page qui s'ouvre affiche la configuration de la règle de blocage.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour afficher la configuration d'une règle de blocage, exécutez la commande gcloud scc muteconfigs get:

   gcloud scc muteconfigs get MUTE_CONFIG_ID \
     --PARENT=PARENT_ID --location=LOCATION

   Remplacez les éléments suivants :

   • MUTE_CONFIG_ID: ID de la règle de blocage
   • PARENT : ressource parente de votre règle de blocage (organization, folder ou project)
   • PARENT_ID: ID de l'organisation, du dossier ou du projet
   • LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel afficher la configuration de la règle de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv2"
	"cloud.google.com/go/securitycenter/apiv2/securitycenterpb"
)

// getMuteRule retrieves a mute configuration given its resource name.
func getMuteRule(w io.Writer, parent string, muteConfigId string) error {
	// Use any one of the following resource paths to get mute configuration:
	//         - organizations/{organization_id}
	//         - folders/{folder_id}
	//         - projects/{project_id}
	// parent := fmt.Sprintf("projects/%s", "your-google-cloud-project-id")
	//
	// Name of the mute config to retrieve.
	// muteConfigId := "mute-config-id"
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.GetMuteConfigRequest{
		Name: fmt.Sprintf("%s/muteConfigs/%s", parent, muteConfigId),
	}

	muteconfig, err := client.GetMuteConfig(ctx, req)
	if err != nil {
		return fmt.Errorf("Failed to retrieve Muteconfig: %w", err)
	}
	fmt.Fprintf(w, "Muteconfig Name: %s ", muteconfig.Name)
	return nil
}

Java

import com.google.cloud.securitycenter.v2.MuteConfig;
import com.google.cloud.securitycenter.v2.MuteConfigName;
import com.google.cloud.securitycenter.v2.SecurityCenterClient;
import java.io.IOException;

public class GetMuteRule {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Replace the following variables
    // projectId: Google Cloud Project id.
    String projectId = "google-cloud-project-id";

    // Specify the location of the mute config. If the mute config was
    // created with v1 API, it can be accessed with "global".
    String location = "global";

    // muteConfigId: Name of the mute config to retrieve.
    String muteConfigId = "mute-config-id";

    getMuteRule(projectId, location, muteConfigId);
  }

  // Retrieves a mute configuration given its resource name.
  public static MuteConfig getMuteRule(String projectId, String location, String muteConfigId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {
      // Use appropriate `MuteConfigName` methods depending on the parent type.
      //  * organization -> MuteConfigName.ofOrganizationLocationMuteConfigName()
      //  * folder -> MuteConfigName.ofFolderLocationMuteConfigName()

      MuteConfigName muteConfigName = MuteConfigName.ofProjectLocationMuteConfigName(projectId,
          location, muteConfigId);
      return client.getMuteConfig(muteConfigName);
    }
  }
}

Python

def get_mute_rule(parent_path: str, location_id: str, mute_config_id: str) -> Dict:
    """
    Retrieves a mute configuration given its resource name.
    Args:
        parent_path: use any one of the following options:
                     - organizations/{organization_id}
                     - folders/{folder_id}
                     - projects/{project_id}
        location_id: Gcp location id; example: 'global'
        mute_config_id: Set a unique id; max of 63 chars.
    Returns:
         Dict: returns the mute rule details
    """
    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

    request = securitycenter_v2.GetMuteConfigRequest()
    request.name = (
        parent_path + "/locations/" + location_id + "/muteConfigs/" + mute_config_id
    )

    mute_config = client.get_mute_config(request)
    print(f"Retrieved the mute rule: {mute_config.name}")
    return mute_config

REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs.get pour renvoyer la configuration d'une règle de masquage:

GET https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/locations/LOCATION/muteConfigs/CONFIG_ID

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation, du dossier ou du projet
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel afficher la configuration de la règle de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.
• CONFIG_ID : ID numérique de la règle de blocage

Mettre à jour les règles de blocage

Vous pouvez modifier la description ou le filtre de recherche d'une règle de masquage à l'aide de la console Google Cloud, de gcloud CLI ou de l'API Security Command Center.

Vous ne pouvez pas modifier l'ID, l'organisation, le dossier ou le projet parent, ni l'emplacement d'une règle de masquage. Pour modifier l'une de ces valeurs, vous devez créer une règle de blocage.

Si vous avez précédemment réactivé les résultats, ils seront de nouveau ignorés s'ils sont mis en correspondance par une règle de blocage mise à jour dans la console Google Cloud. Pour en savoir plus, consultez la section Réactiver des résultats individuels.

Remarque :Les résultats appartenant à la classe de résultats SCC errors signalent les problèmes qui empêchent Security Command Center de fonctionner comme prévu. Par conséquent, les résultats d'erreurs ne peuvent pas être ignorés. Pour en savoir plus, consultez la page Présentation des erreurs Security Command Center.

Pour obtenir un exemple de code qui met à jour une règle de blocage, consultez la section Mettre à jour une règle de blocage.

Pour mettre à jour une règle de blocage, cliquez sur l'onglet de la procédure que vous souhaitez utiliser:

Console

1. Dans Google Cloud Console, accédez à l'onglet Règles de blocage de la page Paramètres de Security Command Center.

   Accéder à la page "Règles de masquage"

2. Sélectionnez le projet ou l'organisation Google Cloud qui est la ressource parente de la règle de blocage que vous souhaitez modifier.

3. Facultatif: Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'établissements s'affiche. Sélectionnez le nouvel emplacement.

4. Cliquez sur le nom de la règle de blocage que vous souhaitez modifier.

   Si vous n'avez pas sélectionné le projet ou l'organisation appropriés, une note peut vous informer que vous n'êtes pas autorisé à modifier la règle de blocage.

5. Saisissez une nouvelle description, puis cliquez sur Enregistrer.

6. Pour les règles de masquage dynamiques, mettez à jour ou modifiez la date/heure d'expiration de la règle.

7. Mettez à jour le filtre.

   Pour obtenir des instructions, consultez l'article Créer des règles de blocage.

8. Pour afficher les résultats correspondant au filtre mis à jour, cliquez sur Prévisualiser les résultats correspondants.

   Une table se charge avec les résultats correspondant à la nouvelle requête.

9. Cliquez sur Enregistrer.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour mettre à jour les règles de blocage, exécutez la commande gcloud scc muteconfigs update:

   gcloud scc muteconfigs update MUTE_CONFIG_ID \
       --PARENT=PARENT_ID \
       --location=LOCATION
       --description=RULE_DESCRIPTION \
       --filter=FILTER
       --type=MUTE_TYPE \
       --expiry-time=TIMESTAMP
   

   Remplacez les éléments suivants :

   • MUTE_CONFIG_ID: ID de la règle de blocage.
   • PARENT: ressource parente de votre règle de blocage (organization, folder ou project)
   • PARENT_ID: ID de l'organisation, du dossier ou du projet.
   • LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel mettre à jour la règle de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.
   • RULE_DESCRIPTION : description de la règle de blocage (1 024 caractères au plus)

   • FILTER: expression que vous définissez pour filtrer les résultats.

     Par exemple, pour ignorer les résultats OPEN_FIREWALL, votre filtre peut être FILTER="category=\"OPEN_FIREWALL\"".

   • MUTE_TYPE: type de règle de blocage que vous mettez à jour. Les types de règles de masquage valides sont DYNAMIC et STATIC. Une fois la règle de masquage créée, vous ne pouvez plus en modifier le type.

   • TIMESTAMP: ne s'applique que si vous mettez à jour une règle de blocage dynamique. Chaîne de date/heure qui indique quand la règle de mise en sourdine dynamique expire. La valeur doit être définie sur au moins un jour à l'avance, sinon la demande sera refusée. Pour en savoir plus sur les formats de date et d'heure, consultez gcloud topic datetimes. Lorsqu'une règle de masquage dynamique expire, elle est supprimée de toutes les correspondances. Si vous souhaitez que la règle Ignorer dynamique agisse indéfiniment sur les résultats correspondants, omettez ce champ.

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv2"
	"cloud.google.com/go/securitycenter/apiv2/securitycenterpb"
	"google.golang.org/protobuf/types/known/fieldmaskpb"
)

// updateMuteRule Updates an existing mute configuration.
// The following can be updated in a mute config: description and filter.
func updateMuteRule(w io.Writer, muteConfigName string) error {
	// Specify the name of the mute config to delete.
	// muteConfigName: Use any one of the following formats:
	//                 - organizations/{organization}/muteConfigs/{config_id}
	//                 - folders/{folder}/muteConfigs/{config_id}
	//                 - projects/{project}/muteConfigs/{config_id}
	// muteConfigName := fmt.Sprintf("projects/%s/muteConfigs/%s", "project-id", "mute-config")
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	updateMuteConfig := &securitycenterpb.MuteConfig{
		Name:        muteConfigName,
		Description: "Updated mute config description",
	}

	req := &securitycenterpb.UpdateMuteConfigRequest{
		MuteConfig: updateMuteConfig,
		// Set the update mask to specify which properties of the mute config should be
		// updated.
		// If empty, all mutable fields will be updated.
		// Make sure that the mask fields match the properties changed in 'updateMuteConfig'.
		// For more info on constructing update mask path, see the proto or:
		// https://cloud.google.com/security-command-center/docs/reference/rest/v1/folders.muteConfigs/patch?hl=en#query-parameters
		UpdateMask: &fieldmaskpb.FieldMask{
			Paths: []string{
				"description",
			},
		},
	}

	response, err := client.UpdateMuteConfig(ctx, req)
	if err != nil {
		return fmt.Errorf("mute rule update failed! %w", err)
	}
	fmt.Fprintf(w, "Mute rule updated %s", response.Name)
	return nil
}

Java

import com.google.cloud.securitycenter.v2.MuteConfig;
import com.google.cloud.securitycenter.v2.SecurityCenterClient;
import com.google.cloud.securitycenter.v2.UpdateMuteConfigRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;

public class UpdateMuteRule {

  public static void main(String[] args) throws IOException {
    // TODO: Replace the variables within {}
    // projectId: Google Cloud Project id.
    String projectId = "google-cloud-project-id";

    // Specify the location of the mute config to update. If the mute config was
    // created with v1 API, it can be accessed with "global".
    String location = "global";

    // muteConfigId: Name of the mute config to update.
    String muteConfigId = "mute-config-id";

    updateMuteRule(projectId, location, muteConfigId);
  }

  // Updates an existing mute configuration.
  // The following can be updated in a mute config: description and filter.
  public static void updateMuteRule(String projectId, String location, String muteConfigId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient securityCenterClient = SecurityCenterClient.create()) {

      MuteConfig updateMuteConfig =
          MuteConfig.newBuilder()
              // Construct the name according to the parent type of the mute rule.
              // Parent can also be one of:
              //  * "organizations/{org_id}/locations/{location}/muteConfigs/{muteConfig_id}"
              //  * "folders/{folder_id}/locations/{location}/muteConfigs/{muteConfig_id}"
              .setName(String.format("projects/%s/locations/%s/muteConfigs/%s", projectId, location,
                  muteConfigId))
              .setDescription("Updated mute config description")
              .build();

      UpdateMuteConfigRequest updateMuteConfigRequest =
          UpdateMuteConfigRequest.newBuilder()
              .setMuteConfig(updateMuteConfig)
              // Make sure that the mask fields match the properties changed in
              // 'updateMuteConfig' object.
              // For more info on constructing update mask path, see the proto or:
              // https://cloud.google.com/security-command-center/docs/reference/rest/v2/folders.muteConfigs/patch?hl=en#query-parameters
              .setUpdateMask(FieldMask.newBuilder().addPaths("description").build())
              .build();

      MuteConfig response = securityCenterClient.updateMuteConfig(updateMuteConfigRequest);
      System.out.println(response);
    }
  }
}

Python

def update_mute_rule(parent_path: str, location_id: str, mute_config_id: str) -> Dict:
    """
    Updates an existing mute configuration.
    The following can be updated in a mute config: description, and filter/ mute rule.
    Args:
        parent: Use any one of the following resource paths to list mute configurations:
                - organizations/{organization_id}
                - folders/{folder_id}
                - projects/{project_id}
        location_id: Gcp location id; example: 'global'
        mute_config_id: Set a unique id; max of 63 chars.
    Returns:
         Dict: returns the mute rule details
    """
    from google.cloud import securitycenter_v2
    from google.protobuf import field_mask_pb2

    client = securitycenter_v2.SecurityCenterClient()

    update_mute_config = securitycenter_v2.MuteConfig()
    update_mute_config.name = (
        parent_path + "/locations/" + location_id + "/muteConfigs/" + mute_config_id
    )
    update_mute_config.description = "Updated mute config description"

    field_mask = field_mask_pb2.FieldMask(paths=["description"])

    request = securitycenter_v2.UpdateMuteConfigRequest()
    request.mute_config = update_mute_config
    # Set the update mask to specify which properties of the Mute Config should be updated.
    # If empty, all mutable fields will be updated.
    # Make sure that the mask fields match the properties changed in 'update_mute_config'.
    # For more info on constructing update mask path, see the proto or:
    # https://cloud.google.com/security-command-center/docs/reference/rest/v1/folders.muteConfigs/patch?hl=en#query-parameters
    request.update_mask = field_mask

    mute_config = client.update_mute_config(request)
    print(f"Updated mute rule : {mute_config}")
    return mute_config

REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs.patch pour mettre à jour une règle de masquage. Le corps de la requête est une instance de MuteConfig:

PATCH https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/locations/LOCATION/muteConfigs/CONFIG_ID

  {
    "description": "RULE_DESCRIPTION",
    "filter": "FILTER",
    "type": "MUTE_TYPE",
    "expiryTime": "TIMESTAMP"
  }

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation, du dossier ou du projet
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel mettre à jour la règle de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.
• CONFIG_ID : ID numérique de la règle de blocage
• RULE_DESCRIPTION: description de la règle de blocage (max. : 1 024 caractères)

• FILTER : expression que vous définissez pour filtrer les résultats

  Par exemple, pour ignorer les résultats OPEN_FIREWALL, votre filtre peut être "category=\"OPEN_FIREWALL\"".

• MUTE_TYPE: type de règle de blocage que vous mettez à jour. Les types de règles de masquage valides sont DYNAMIC et STATIC. Une fois la règle de masquage créée, vous ne pouvez plus en modifier le type.

• TIMESTAMP: ne s'applique que si vous mettez à jour une règle de blocage dynamique. Chaîne de date/heure indiquant quand la règle de masquage dynamique expire. La valeur doit être définie sur au moins un jour à venir, sinon la requête sera refusée. Pour en savoir plus sur les formats de date et d'heure, consultez gcloud topic datetimes. Lorsqu'une règle Ignorer dynamique expire, elle est supprimée de tous les résultats correspondants. Si vous souhaitez que la règle Ignorer dynamique agisse indéfiniment sur les résultats correspondants, omettez ce champ.

Les nouveaux résultats qui correspondent exactement au filtre sont masqués et l'attribut mute des résultats est défini sur MUTED.

Supprimer les règles de blocage

Vous pouvez supprimer une règle de masquage à l'aide de la console Google Cloud, de gcloud CLI ou de l'API Security Command Center.

Avant de supprimer les règles de blocage, prenez en compte les points suivants :

• Vous ne pouvez pas récupérer les règles de blocage supprimées.
• La suppression des règles Ignorer statiques ne réactive pas automatiquement les résultats ignorés. Vous devez réactiver les résultats manuellement ou de manière automatisée.
• La suppression des règles de blocage dynamiques supprime automatiquement la règle de tous les résultats précédemment correspondants et les réactive s'ils ne correspondent à aucune règle supplémentaire.
• Les futurs résultats qui correspondent aux filtres dans les règles de blocage supprimées ne sont pas ignorés.

Pour obtenir un exemple de code qui supprime une règle de masquage, consultez la section Supprimer une règle de masquage.

Pour supprimer une règle de blocage, cliquez sur l'onglet correspondant à la procédure que vous souhaitez suivre:

Console

1. Dans Google Cloud Console, accédez à l'onglet Règles de blocage de la page Paramètres de Security Command Center.

   Accéder à la page "Règles de masquage"

2. Si nécessaire, sélectionnez votre projet ou votre organisation GooglenCloud.

3. Facultatif: Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'établissements s'affiche. Sélectionnez le nouvel emplacement.

4. Cliquez sur le nom de la règle de blocage que vous souhaitez supprimer.

5. Cliquez sur Supprimer.

6. Lisez la boîte de dialogue et, si vous êtes satisfait, cliquez sur Supprimer.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour supprimer les règles de blocage, exécutez la commande gcloud scc muteconfigs delete:

   gcloud scc muteconfigs delete MUTE_CONFIG_ID \
     --PARENT=PARENT_ID --location=LOCATION

   Remplacez les éléments suivants :

   • MUTE_CONFIG_ID : ID de la configuration de blocage
   • PARENT : ressource parente de votre règle de blocage (organization, folder ou project)
   • PARENT_ID: ID de l'organisation, du dossier ou du projet
   • LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel supprimer la règle de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.

3. Confirmez votre demande de suppression de la règle de blocage.

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv2"
	"cloud.google.com/go/securitycenter/apiv2/securitycenterpb"
)

// deleteMuteRule deletes a mute configuration given its resource name.
// Note: Previously muted findings are not affected when a mute config is deleted.
func deleteMuteRule(w io.Writer, parent string, muteConfigId string) error {
	// parent: Use any one of the following options:
	//             - organizations/{organization_id}
	//             - folders/{folder_id}
	//             - projects/{project_id}
	// parent := fmt.Sprintf("projects/%s", "your-google-cloud-project-id")
	//
	// muteConfigId: Specify the name of the mute config to delete.
	// muteConfigId := "mute-config-id"
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.DeleteMuteConfigRequest{
		Name: fmt.Sprintf("%s/muteConfigs/%s", parent, muteConfigId),
	}

	if err := client.DeleteMuteConfig(ctx, req); err != nil {
		return fmt.Errorf("failed to delete Muteconfig: %w", err)
	}
	fmt.Fprintf(w, "Mute rule deleted successfully: %s", muteConfigId)
	return nil
}

Java

import com.google.cloud.securitycenter.v2.MuteConfigName;
import com.google.cloud.securitycenter.v2.SecurityCenterClient;
import java.io.IOException;

public class DeleteMuteRule {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Replace the following variables
    // projectId: Google Cloud Project id.
    String projectId = "google-cloud-project-id";

    // Specify the location of the mute config. If the mute config was
    // created with v1 API, it can be accessed with "global".
    String location = "global";

    // muteConfigId: Specify the name of the mute config to delete.
    String muteConfigId = "mute-config-id";

    deleteMuteRule(projectId, location, muteConfigId);
  }

  // Deletes a mute configuration given its resource name.
  // Note: Previously muted findings are not affected when a mute config is deleted.
  public static void deleteMuteRule(String projectId, String location, String muteConfigId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {
      // Use appropriate `MuteConfigName` methods depending on the parent type.
      // folder -> MuteConfigName.ofFolderLocationMuteConfigName()
      // organization -> MuteConfigName.ofOrganizationLocationMuteConfigName()
      client.deleteMuteConfig(
          MuteConfigName.ofProjectLocationMuteConfigName(projectId, location, muteConfigId));

      System.out.println("Mute rule deleted successfully: " + muteConfigId);
    }
  }
}

Python

def delete_mute_rule(parent_path: str, location_id: str, mute_config_id: str) -> None:
    """
    Deletes a mute configuration given its resource name.
    Note: Previously muted findings are not affected when a mute config is deleted.
    Args:
         parent_path: use any one of the following options:
                     - organizations/{organization_id}
                     - folders/{folder_id}
                     - projects/{project_id}
        location_id: Gcp location id; example: 'global'
        mute_config_id: Set a unique id; max of 63 chars.
    Returns:
         None: returns none mute rule is deleted
    """
    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

    request = securitycenter_v2.DeleteMuteConfigRequest()
    request.name = (
        parent_path + "/locations/" + location_id + "/muteConfigs/" + mute_config_id
    )

    client.delete_mute_config(request)
    print(f"Mute rule deleted successfully: {mute_config_id}")

REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs.delete pour supprimer une règle de masquage:

DELETE https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/locations/LOCATION/muteConfigs/CONFIG_ID

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation, du dossier ou du projet
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel supprimer la règle de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.
• CONFIG_ID : ID numérique de la règle de blocage

Ignorer un résultat individuel

Vous pouvez statiquement désactiver un résultat individuel à l'aide de la console Google Cloud, de gcloud CLI ou de l'API Security Command Center.

Le fait de désactiver statiquement un résultat n'a aucune incidence sur son état (actif ou non). Si un résultat actif est masqué, l'attribut state reste inchangé : state="ACTIVE". Le résultat est masqué, mais reste actif jusqu'à ce que la faille, la configuration incorrecte ou la menace sous-jacente soient résolues. En outre, en ignorant de manière statique un résultat, vous remplacez toutes les règles de blocage dynamiques qui s'appliquent à ce résultat.

Si vous désactivez une combinaison toxique, la demande correspondante est clôturée.

Pour ignorer tous les résultats futurs correspondant aux critères que vous spécifiez, consultez la section Créer des règles de blocage.

Pour obtenir un exemple de code permettant de désactiver un résultat, consultez Désactiver un résultat.

Pour ignorer de manière statique un résultat individuel, cliquez sur l'onglet de la procédure que vous souhaitez utiliser:

Console

1. Dans la console Google Cloud, accédez à la page Résultats de Security Command Center.

   Accéder

2. Si nécessaire, sélectionnez votre projet ou votre organisation GooglenCloud.

3. Facultatif: Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'emplacements s'affiche. Sélectionnez le nouvel emplacement.

4. Si le résultat que vous devez désactiver ne s'affiche pas dans le panneau Résultats de la requête de résultats, sélectionnez la catégorie du résultat dans la section Catégorie du panneau Filtres rapides.

5. Cochez la case à côté du résultat que vous devez ignorer. Vous pouvez sélectionner un ou plusieurs résultats.

6. Dans la barre d'action Résultats de la requête "Résultats", cliquez sur Options de blocage, puis sélectionnez Appliquer le forçage de la désactivation du son.

   L'attribut mute des résultats sélectionnés est défini sur MUTED, et le résultat est supprimé du panneau Résultats de la requête "Résultats".

Vous pouvez également ignorer un résultat depuis son panneau d'informations:

1. Dans le panneau Résultats de la requête de résultats de la page Résultats, dans la colonne Catégorie, cliquez sur le nom d'un résultat. Le volet d'informations du résultat s'ouvre.
2. Cliquez sur Prendre des mesures.

3. Dans le menu Prendre des mesures, sélectionnez Appliquer le forçage de la désactivation du son.

   Si vous sélectionnez plutôt Ignorer les résultats comme celui-ci, la page Créer une règle de blocage s'ouvre. Vous pouvez y créer une règle de blocage des résultats du même type ou qui incluent le même attribut Indicator.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour définir l'état de blocage d'un résultat sur MUTED, utilisez la commande set-mute dans gcloud CLI  :

   gcloud scc findings set-mute FINDING_ID \
     --PARENT=PARENT_ID \
     --location=LOCATION \
     --source=SOURCE_ID \
     --mute=MUTED

   Remplacez les éléments suivants :

   • FINDING_ID : ID du résultat que vous souhaitez ignorer.

     Pour récupérer les ID de résultats, utilisez l'API Security Command Center afin de répertorier les résultats. L'ID de résultat est la dernière partie de l'attribut canonicalName, par exemple projects/123456789012/sources/1234567890123456789/findings`/5ee30aa342e799e4e1700826de053aa9.

   • PARENT: ressource parente (project, folder ou organization), sensible à la casse

   • PARENT_ID: ID de l'organisation, du dossier ou du projet parent

   • LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel couper le son du résultat. Si la résidence des données n'est pas activée, utilisez la valeur global.

   • SOURCE_ID : ID de la source

     Pour obtenir des instructions sur la manière de récupérer l'ID d'une source, consultez la section Obtenir l'ID d'une source.

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv2"
	"cloud.google.com/go/securitycenter/apiv2/securitycenterpb"
)

// setMute mutes an individual finding.
// If a finding is already muted, muting it again has no effect.
// Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
func setMute(w io.Writer, findingPath string) error {
	// findingPath: The relative resource name of the finding. See:
	// https://cloud.google.com/apis/design/resource_names#relative_resource_name
	// Use any one of the following formats:
	//  - organizations/{organization_id}/sources/{source_id}/finding/{finding_id}
	//  - folders/{folder_id}/sources/{source_id}/finding/{finding_id}
	//  - projects/{project_id}/sources/{source_id}/finding/{finding_id}
	// findingPath := fmt.Sprintf("projects/%s/sources/%s/finding/%s", "your-google-cloud-project-id", "source", "finding-id")
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.SetMuteRequest{
		Name: findingPath,
		Mute: securitycenterpb.Finding_MUTED}

	finding, err := client.SetMute(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to set the specified mute value: %w", err)
	}
	fmt.Fprintf(w, "Mute value for the finding: %s is %s", finding.Name, finding.Mute)
	return nil
}

Java

import com.google.cloud.securitycenter.v2.Finding;
import com.google.cloud.securitycenter.v2.Finding.Mute;
import com.google.cloud.securitycenter.v2.SecurityCenterClient;
import com.google.cloud.securitycenter.v2.SetMuteRequest;
import java.io.IOException;

public class SetMuteFinding {

  public static void main(String[] args) throws IOException {
    // TODO: Replace the variables within {}
    // findingPath: The relative resource name of the finding. See:
    // https://cloud.google.com/apis/design/resource_names#relative_resource_name
    // Use any one of the following formats:
    //  - organizations/{org_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //  - folders/{folder_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //  - projects/{project_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //
    String findingPath = "{path-to-the-finding}";

    setMute(findingPath);
  }

  // Mute an individual finding.
  // If a finding is already muted, muting it again has no effect.
  // Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
  public static Finding setMute(String findingPath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      SetMuteRequest setMuteRequest =
          SetMuteRequest.newBuilder()
              // Relative path for the finding.
              .setName(findingPath)
              .setMute(Mute.MUTED)
              .build();

      Finding finding = client.setMute(setMuteRequest);
      System.out.println(
          "Mute value for the finding " + finding.getName() + " is: " + finding.getMute());
      return finding;
    }
  }
}

Python

def set_mute_finding(finding_path: str) -> None:
    """
      Mute an individual finding.
      If a finding is already muted, muting it again has no effect.
      Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
    Args:
        finding_path: The relative resource name of the finding. See:
        https://cloud.google.com/apis/design/resource_names#relative_resource_name
        Use any one of the following formats:
        - organizations/{organization_id}/sources/{source_id}/finding/{finding_id},
        - folders/{folder_id}/sources/{source_id}/finding/{finding_id},
        - projects/{project_id}/sources/{source_id}/finding/{finding_id}.
    """
    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

    request = securitycenter_v2.SetMuteRequest()
    request.name = finding_path
    request.mute = securitycenter_v2.Finding.Mute.MUTED

    finding = client.set_mute(request)
    print(f"Mute value for the finding: {finding.mute.name}")
    return finding

REST

Dans l'API Security Command Center, utilisez la méthode findings.setMute pour désactiver un résultat. Le corps de la requête est une énumération qui indique l'état de blocage résultant:

POST https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/sources/SOURCE_ID/locations/LOCATION/findings/FINDING_ID:setMute

{
  "mute": "MUTED"
}

Remplacez les éléments suivants :

• PARENT: ressource parente (organizations, folders ou projects).
• PARENT_ID: ID de l'organisation, du dossier ou du projet parent.
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel couper le son du résultat. Si la résidence des données n'est pas activée, utilisez la valeur global.

• SOURCE_ID: ID numérique de la source.

  Pour obtenir des instructions sur la manière de récupérer l'ID d'une source, consultez la section Obtenir l'ID d'une source.

• FINDING_ID: ID du résultat que vous souhaitez ignorer.

  Pour récupérer les ID de résultats, utilisez l'API Security Command Center afin de répertorier les résultats. L'ID de résultat est la dernière partie de l'attribut canonicalName, par exemple projects/123456789012/sources/1234567890123456789/findings/5ee30aa342e799e4e1700826de053aa9.

Une fois que vous avez désactivé un résultat, son attribut mute est défini sur MUTED.

Réactiver les résultats individuels

Vous pouvez statiquement réactiver un résultat individuel à l'aide de la console Google Cloud, de gcloud CLI ou de l'API Security Command Center.

Désactiver le masquage d'un résultat est utile lorsque vous devez empêcher un résultat d'être masqué par une règle de masquage trop large ou par une règle qui pourrait être trop complexe à modifier pour exclure les résultats que vous jugez importants.

Pour obtenir un exemple de code permettant de réactiver un résultat, consultez la section Réactiver un résultat.

Les résultats ignorés ne sont à nouveau ignorés que si vous les désactivez manuellement. Les règles de blocage créées avec gcloud CLI ou l'API Security Command Center n'affectent pas les résultats obtenus par les utilisateurs.

Pour obtenir un exemple de code permettant de réactiver un résultat, consultez Réactiver un résultat.

Console

1. Dans la console Google Cloud, accédez à la page Résultats de Security Command Center.

   Accéder

2. Si nécessaire, sélectionnez votre projet ou votre organisation GooglenCloud.

   La page Résultats s'ouvre, et la requête par défaut s'affiche dans la section Aperçu de la requête. La requête par défaut filtre les résultats masqués. Vous devez donc modifier la requête avant que les résultats masqués ne s'affichent dans le panneau Résultats de la requête de résultats.

3. Facultatif: Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'établissements s'affiche. Sélectionnez le nouvel emplacement.

4. À droite de la section Aperçu de la requête, cliquez sur Modifier la requête pour ouvrir l'éditeur de requête.

5. Dans le champ Éditeur de requête, remplacez l'instruction de masquage existante par la suivante:

   mute="MUTED"

6. Cliquez sur Appliquer. Les résultats du panneau Résultats de la requête "Résultats" sont mis à jour pour n'inclure que les résultats ignorés.

7. Si nécessaire, filtrez les autres résultats masqués. Par exemple, dans le panneau Filtres rapides, sous Catégorie, sélectionnez le nom de l'anomalie que vous devez réactiver pour filtrer toutes les autres catégories d'anomalies.

8. Cochez la case à côté du résultat que vous souhaitez réactiver. Vous pouvez sélectionner un ou plusieurs résultats.

9. Dans la barre d'action Résultats de la requête de résultats, cliquez sur Options de blocage, puis sélectionnez Appliquer le forçage de la réactivation.

   L'attribut mute des résultats sélectionnés est défini sur UNMUTED, et le résultat est supprimé du panneau Résultats de la requête "Résultats".

Vous pouvez également réactiver un résultat depuis son panneau d'informations:

1. Dans le panneau Résultats de la requête de résultats de la page Résultats, dans la colonne Catégorie, cliquez sur le nom d'un résultat. Le volet d'informations du résultat s'ouvre.
2. Cliquez sur Prendre des mesures.
3. Dans le menu Prendre une mesure, sélectionnez Appliquer le forçage de la désactivation du masquage du son.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour définir l'état de blocage d'un résultat sur UNMUTED, utilisez la commande set-mute dans gcloud CLI  :

   gcloud scc findings set-mute FINDING_ID \
     --PARENT=PARENT_ID \
     --location=LOCATION \
     --source=SOURCE_ID \
     --mute=UNMUTED

   Remplacez les éléments suivants :

   • FINDING_ID : ID du résultat que vous souhaitez ignorer.

     Pour récupérer les ID de résultats, utilisez l'API Security Command Center afin de répertorier les résultats. L'ID de résultat est la dernière partie de l'attribut canonicalName, par exemple projects/123456789012/sources/1234567890123456789/findings/5ee30aa342e799e4e1700826de053aa9.

   • PARENT: ressource parente (project, folder ou organization) sensible à la casse

   • PARENT_ID: ID de l'organisation, du dossier ou du projet parent

   • LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel rétablir le son du résultat. Si la résidence des données n'est pas activée, utilisez la valeur global.

   • SOURCE_ID : ID de la source

     Pour obtenir des instructions sur la manière de récupérer l'ID d'une source, consultez la section Obtenir l'ID d'une source.

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv2"
	"cloud.google.com/go/securitycenter/apiv2/securitycenterpb"
)

// setUnmute unmutes an individual finding.
// Unmuting a finding that isn't muted has no effect.
// Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
func setUnmute(w io.Writer, findingPath string) error {
	// findingPath: The relative resource name of the finding. See:
	// https://cloud.google.com/apis/design/resource_names#relative_resource_name
	// Use any one of the following formats:
	//  - organizations/{organization_id}/sources/{source_id}/finding/{finding_id}
	//  - folders/{folder_id}/sources/{source_id}/finding/{finding_id}
	//  - projects/{project_id}/sources/{source_id}/finding/{finding_id}
	// findingPath := fmt.Sprintf("projects/%s/sources/%s/finding/%s", "your-google-cloud-project-id", "source", "finding-id")
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.SetMuteRequest{
		Name: findingPath,
		Mute: securitycenterpb.Finding_UNMUTED}

	finding, err := client.SetMute(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to set the specified mute value: %w", err)
	}
	fmt.Fprintf(w, "Mute value for the finding: %s is %s", finding.Name, finding.Mute)
	return nil
}

Java

import com.google.cloud.securitycenter.v2.Finding;
import com.google.cloud.securitycenter.v2.Finding.Mute;
import com.google.cloud.securitycenter.v2.SecurityCenterClient;
import com.google.cloud.securitycenter.v2.SetMuteRequest;
import java.io.IOException;

public class SetUnmuteFinding {

  public static void main(String[] args) throws IOException {
    // TODO: Replace the variables within {}
    // findingPath: The relative resource name of the finding. See:
    // https://cloud.google.com/apis/design/resource_names#relative_resource_name
    // Use any one of the following formats:
    //  - organizations/{org_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //  - folders/{folder_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //  - projects/{project_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //
    String findingPath = "{path-to-the-finding}";

    setUnmute(findingPath);
  }

  // Unmute an individual finding.
  // Unmuting a finding that isn't muted has no effect.
  // Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
  public static Finding setUnmute(String findingPath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      SetMuteRequest setMuteRequest =
          SetMuteRequest.newBuilder()
              .setName(findingPath)
              .setMute(Mute.UNMUTED)
              .build();

      Finding finding = client.setMute(setMuteRequest);
      System.out.println(
          "Mute value for the finding " + finding.getName() + " is: " + finding.getMute());
      return finding;
    }
  }
}

Python

def set_unmute_finding(finding_path: str) -> None:
    """
      Unmute an individual finding.
      Unmuting a finding that isn't muted has no effect.
      Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
    Args:
        finding_path: The relative resource name of the finding. See:
        https://cloud.google.com/apis/design/resource_names#relative_resource_name
        Use any one of the following formats:
        - organizations/{organization_id}/sources/{source_id}/finding/{finding_id},
        - folders/{folder_id}/sources/{source_id}/finding/{finding_id},
        - projects/{project_id}/sources/{source_id}/finding/{finding_id}.
    """
    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

    request = securitycenter_v2.SetMuteRequest()
    request.name = finding_path
    request.mute = securitycenter_v2.Finding.Mute.UNMUTED

    finding = client.set_mute(request)
    print(f"Mute value for the finding: {finding.mute.name}")
    return finding

REST

Dans l'API Security Command Center, utilisez la méthode findings.setMute pour réactiver un résultat. Le corps de la requête est une énumération qui indique l'état de blocage résultant:

POST https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/sources/SOURCE_ID/locations/LOCATION/findings/FINDING_ID:setMute

{
  "mute": "UNMUTED"
}

Remplacez les éléments suivants :

• PARENT : ressource parente (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation, du dossier ou du projet parent
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel rétablir le son du résultat. Si la résidence des données n'est pas activée, utilisez la valeur global.

• SOURCE_ID : ID numérique de la source

  Pour obtenir des instructions sur la manière de récupérer l'ID d'une source, consultez la section Obtenir l'ID d'une source.

• FINDING_ID: ID du résultat que vous souhaitez ignorer.

  Pour récupérer les ID de résultats, utilisez l'API Security Command Center afin de répertorier les résultats. L'ID de résultat est la dernière partie de l'attribut canonicalName, par exemple projects/123456789012/sources/1234567890123456789/findings/5ee30aa342e799e4e1700826de053aa9.

Les résultats sélectionnés ne sont plus masqués et l'attribut mute des résultats est défini sur UNMUTED.

Supprimer un forçage de l'état de masquage pour des résultats individuels

Vous appliquez un dépassement de l'état de désactivation lorsque vous modifiez intentionnellement l'état de désactivation d'un résultat pour le désactiver ou l'activer de manière statique. Par exemple, vous pouvez appliquer un forçage de l'état de masquage pour masquer un résultat de faible gravité pour lequel il n'est pas nécessaire de créer une règle de masquage dynamique.

Vous pouvez supprimer un forçage de l'état de masquage d'un résultat spécifique à l'aide de la console Google Cloud, de gcloud CLI ou de l'API Security Command Center.

Avant de supprimer le forçage de l'état de masquage d'un résultat, tenez compte des points suivants:

• Un résultat est masqué ou non masqué de manière statique. Vous pouvez appliquer un forçage de l'état de masquage à n'importe quel résultat manuellement ou automatiquement à l'aide de règles de masquage statiques.
• Un forçage de l'état de masquage s'applique indéfiniment à un résultat et prévaut sur toutes les règles de masquage correspondantes.
• Si vous supprimez le forçage de l'état de blocage d'un résultat, son état de blocage est réinitialisé afin qu'il puisse être traité par des règles de blocage statiques ou dynamiques.
• La suppression du forçage de l'état de désactivation d'un résultat n'a pas le même effet que la réactivation d'un résultat. Lorsque vous réactivez un résultat (appliquez un forçage de réactivation), les règles de blocage ne peuvent pas le désactiver tant que vous n'avez pas supprimé manuellement le forçage de l'état de désactivation.

Pour supprimer le forçage de la désactivation du son d'un résultat individuel, procédez comme suit:

Console

1. Dans la console Google Cloud, accédez à la page Résultats de Security Command Center.

   Accéder

2. Sélectionnez votre projet ou votre organisation Google Cloud.

3. Facultatif: Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'établissements s'affiche. Sélectionnez le nouvel emplacement.

4. À droite de la section Aperçu de la requête, cliquez sur Modifier la requête pour ouvrir l'éditeur de requête.

5. Dans le champ Éditeur de requête, remplacez l'instruction de masquage existante par la suivante:

   mute="MUTED" OR mute="UNMUTED"

6. Cliquez sur Appliquer. Les résultats du panneau Résultats de la requête sur les résultats sont mis à jour pour inclure les résultats ignorés de manière statique et ceux qui ne le sont pas.

7. Si nécessaire, filtrez les autres résultats. Par exemple, dans le panneau Filtres rapides, sous Catégorie, sélectionnez le nom de l'anomalie que vous devez réinitialiser pour filtrer toutes les autres catégories d'anomalies.

8. Cochez la case à côté du résultat que vous souhaitez réinitialiser. Vous pouvez sélectionner un ou plusieurs résultats.

9. Dans la barre d'action Résultats de la requête "Résultats", cliquez sur Options de blocage, puis sélectionnez Supprimer les forçages de blocage.

   L'attribut mute des résultats sélectionnés est défini sur UNDEFINED, et le résultat est supprimé du panneau Résultats de la requête "Résultats".

Vous pouvez également réactiver un résultat depuis son panneau d'informations:

1. Dans le panneau Résultats de la requête de résultats de la page Résultats, dans la colonne Catégorie, cliquez sur le nom d'un résultat. Le volet d'informations du résultat s'ouvre.
2. Cliquez sur Prendre des mesures.
3. Dans le menu Prendre une mesure, sélectionnez Supprimer les forçages de mise en sourdine.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour définir l'état de blocage d'un résultat sur UNDEFINED, utilisez la commande set-mute dans gcloud CLI  :

   gcloud scc findings set-mute FINDING_ID \
     --PARENT=PARENT_ID \
     --location=LOCATION \
     --source=SOURCE_ID \
     --mute=UNDEFINED

   Remplacez les éléments suivants :

   • FINDING_ID: ID du résultat que vous souhaitez réinitialiser.

     Pour récupérer les ID de résultats, utilisez l'API Security Command Center afin de répertorier les résultats. L'ID de résultat est la dernière partie de l'attribut canonicalName, par exemple projects/123456789012/sources/1234567890123456789/findings/5ee30aa342e799e4e1700826de053aa9.

   • PARENT: ressource parente (project, folder ou organization) sensible à la casse

   • PARENT_ID: ID de l'organisation, du dossier ou du projet parent

   • LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel supprimer le forçage de l'état de masquage d'un résultat. Si la résidence des données n'est pas activée, utilisez la valeur global.

   • SOURCE_ID : ID de la source

     Pour obtenir des instructions sur la manière de récupérer l'ID d'une source, consultez la section Obtenir l'ID d'une source.

REST

Dans l'API Security Command Center, utilisez la méthode findings.setMute pour réinitialiser l'état de désactivation d'un résultat. Le corps de la requête est une énumération qui indique l'état de blocage obtenu:

POST https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/sources/SOURCE_ID/locations/LOCATION/findings/FINDING_ID:setMute

{
  "mute": "UNDEFINED"
}

Remplacez les éléments suivants :

• PARENT : ressource parente (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation, du dossier ou du projet parent
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel supprimer le forçage de l'état de masquage d'un résultat. Si la résidence des données n'est pas activée, utilisez la valeur global.
• SOURCE_ID : ID numérique de la source

Ignorer ou réinitialiser plusieurs résultats existants

Vous pouvez effectuer les opérations de masquage groupé suivantes pour plusieurs résultats existants à l'aide de la commande gcloud scc findings bulk-mute de gcloud CLI ou de la méthode bulkMute de l'API Security Command Center:

• Ignorez plusieurs résultats existants. Ignorer les résultats existants de manière groupée les ignore statiquement et remplace toutes les règles Ignorer dynamiques qui s'appliquent au résultat. Si vous devez ignorer des résultats futurs similaires, créez une règle de blocage.

• Supprimez le forçage de l'état d'ignorer pour plusieurs résultats existants. En supprimant le forçage de l'état de masquage d'un résultat, vous réinitialisez l'état de masquage de MUTED (masqué de manière statique) ou UNMUTED (démasqué de manière statique) à UNDEFINED. Cette fonctionnalité peut être utile si vous passez de règles de masquage statiques à des règles de masquage dynamiques.

Spécifiez l'ensemble de résultats que vous devez ignorer en définissant un filtre de résultats. Les filtres de désactivation groupée ne sont pas compatibles avec toutes les propriétés de résultats. Pour obtenir la liste des propriétés non compatibles, consultez la section Propriétés de résultats non compatibles avec les règles de blocage.

Si la résidence des données est activée pour Security Command Center, la portée des opérations de masquage groupé est limitée à l'emplacement Security Command Center dans lequel elles sont exécutées.

Attention :Les opérations de masquage groupé peuvent expirer si vous essayez de masquer plus de 4 000 000 résultats existants ou si l'opération prend plus de six heures. Si vous devez masquer des millions de résultats existants, envisagez de diviser l'opération de masquage en utilisant plusieurs requêtes de résultats correspondant à des nombres plus faibles de résultats.

Remarque :Les résultats appartenant à la classe de résultats SCC errors signalent des problèmes qui empêchent Security Command Center de fonctionner comme prévu. Par conséquent, les résultats d'erreurs ne peuvent pas être ignorés. Pour en savoir plus, consultez la page Présentation des erreurs Security Command Center.

Pour obtenir un exemple de code qui permet d'ignorer les résultats de manière groupée, consultez la section Ignorer les résultats de manière groupée.

Pour désactiver ou réinitialiser des résultats de manière groupée, cliquez sur l'onglet correspondant à la procédure que vous souhaitez utiliser:

Console

Dans la console Google Cloud, vous ne pouvez ignorer les résultats de manière groupée qu'en créant des règles de blocage. Dans la console Google Cloud, la création de règles de blocage désactive les résultats existants et futurs.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour désactiver ou réinitialiser plusieurs résultats de manière groupée, exécutez la commande gcloud scc findings bulk-mute:

   gcloud scc findings bulk-mute \
     --PARENT=PARENT_ID \
     --location=LOCATION \
     --filter="FILTER" \
     --mute-state=MUTE_STATE

   Remplacez les éléments suivants :

   • PARENT: champ d'application dans la hiérarchie des ressources auquel la règle de masquage s'applique, organization, folder ou project.
   • PARENT_ID: ID numérique de l'organisation, du dossier ou du projet parent, ou ID alphanumérique du projet parent.
   • LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel couper le son ou réinitialiser les résultats de manière groupée. Si la résidence des données n'est pas activée, utilisez la valeur global.

   • FILTER: expression que vous définissez pour filtrer les résultats.

     Par exemple, pour ignorer tous les résultats OPEN_FIREWALL et PUBLIC_IP_ADDRESS existants de faible gravité dans le projet internal-test, votre filtre peut être "category=\"OPEN_FIREWALL\" OR category=\"PUBLIC_IP_ADDRESS\" AND severity=\"LOW\" AND resource.projectDisplayName=\"internal-test\"".

   • MUTE_STATE: valeur qui indique si le résultat est masqué de manière statique ou non. Les valeurs valides sont MUTED et UNDEFINED. La valeur est définie sur MUTED par défaut. Ne définissez cette valeur sur UNDEFINED que si vous réinitialisez l'état de masquage de plusieurs résultats existants.

REST

Dans l'API Security Command Center, utilisez la méthode findings.bulkMute pour désactiver ou réinitialiser l'état de désactivation de plusieurs résultats existants. Le corps de la requête contient l'expression utilisée pour filtrer les résultats:

POST https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/locations/LOCATION/findings:bulkMute

{
  "filter": "FILTER",
  "muteState": "MUTE_STATE"
}

Remplacez les éléments suivants :

• PARENT: ressource parente (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation, du dossier ou du projet parent.
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel couper le son ou réinitialiser les résultats de manière groupée. Si la résidence des données n'est pas activée, utilisez la valeur global.

• FILTER: expression que vous définissez pour filtrer les résultats.

  Par exemple, pour ignorer tous les résultats OPEN_FIREWALL et PUBLIC_IP_ADDRESS existants de faible gravité dans le projet internal-test, votre filtre peut être "category=\"OPEN_FIREWALL\" OR category=\"PUBLIC_IP_ADDRESS\" AND severity=\"LOW\" AND resource.projectDisplayName=\"internal-test\"".

• MUTE_STATE: valeur qui indique si le résultat est ignoré ou non. Les valeurs valides sont MUTED ou UNDEFINED. La valeur est définie sur MUTED par défaut. Ne définissez cette valeur sur UNDEFINED que si vous réinitialisez l'état de masquage de plusieurs résultats existants.

Tous les résultats existants de la ressource que vous sélectionnez et qui correspondent exactement au filtre sont masqués. L'attribut mute des résultats est défini sur MUTED.

La désactivation de résultats ne modifie pas leur état. Si les résultats actifs sont ignorés, ils sont masqués, mais restent actifs jusqu'à ce que les failles sous-jacentes, les erreurs de configuration ou les menaces soient résolues.

Afficher les résultats masqués dans la console Google Cloud

Pour afficher les résultats masqués dans la console Google Cloud, modifiez la requête de résultats afin de sélectionner les résultats qui incluent la valeur de propriété mute="MUTED".

Par exemple, la requête de résultats suivante n'affiche que les résultats actifs qui sont ignorés:

state="ACTIVE"
AND mute="MUTED"

Pour afficher tous les résultats actifs, masqués et non masqués, omettez complètement l'attribut mute de la requête:

state="ACTIVE"

Par défaut, la requête de résultats dans la console Google Cloud n'affiche que les résultats qui ne sont pas masqués.

Afficher les résultats ignorés par type de règle de blocage

Les sections suivantes expliquent comment interroger les résultats actifs par type de règle de blocage.

Pour en savoir plus sur la liste de résultats spécifiques, consultez la section Filtrer les résultats.

Résultats de requête ignorés par des règles Ignorer statiques

Pour afficher les résultats actifs qui ont été masqués par une règle de masquage statique après un délai spécifié, utilisez la requête suivante et inspectez l'attribut muteInitiator pour déterminer si le résultat a été masqué par une règle de masquage statique.

state="ACTIVE" AND
muteInfo.staticMute.applyTime>=TIMESTAMP AND
muteInfo.staticMute.state="MUTED"

Remplacez TIMESTAMP par la chaîne de date/heure qui indique le début de la période que vous souhaitez interroger. Pour en savoir plus sur les formats de date et d'heure, consultez gcloud topic datetimes.

Résultats de requête ignorés par des règles Ignorer dynamiques

Pour afficher les résultats actifs qui ont été ignorés par une règle de blocage dynamique après un délai spécifié, utilisez la requête suivante:

state="ACTIVE" AND
muteUpdateTime>=TIMESTAMP AND
contains(muteInfo.dynamicMuteRecords, muteConfig="PARENT_ID/muteConfigs/CONFIG_ID")

Remplacez les éléments suivants :

• TIMESTAMP: chaîne de date/heure indiquant le début de la période que vous souhaitez interroger. Pour en savoir plus sur les formats de date et d'heure, consultez gcloud topic datetimes.
• PARENT_ID: ID de l'organisation, du dossier ou du projet parent, spécifié au format organizations/123, folders/456 ou projects/789.
• CONFIG_ID: nom de la règle de masquage. L'ID doit comporter entre 1 et 63 caractères alphanumériques et des traits d'union.

Pour en savoir plus sur la modification des requêtes de résultats, consultez la section Créer ou modifier une requête de résultats dans le tableau de bord.

Propriétés de résultats liées au masquage

Cette section répertorie les propriétés de résultat associées à l'état de masquage d'un résultat et décrit leur impact sur les opérations de masquage:

• mute : défini sur UNDEFINED lorsque des résultats sont créés et changent dans les scénarios suivants :
  • MUTED : le résultat est ignoré manuellement ou par une règle de blocage
  • UNMUTED : un utilisateur réactive le résultat
• muteUpdateTime: heure à laquelle un résultat est ignoré ou réactivé.
• muteInitiator: identifiant de la règle principale ou de blocage qui a ignoré un résultat.
• muteInfo: informations de blocage sur le résultat, telles que le type de règle de blocage (statique ou dynamique) et les règles de blocage auxquelles le résultat correspond.
• muteInfo.staticMute: un état de masquage statique remplace toutes les règles de masquage dynamique qui s'appliquent à ce résultat.
  • state: état de blocage statique qui peut être défini en bloquant directement le résultat ou par une règle de blocage statique.
  • applyTime: heure à laquelle l'état d'inactivation statique a été appliqué au résultat.
• muteInfo.dynamicMuteRecords: enregistrement d'une règle de blocage dynamique correspondant au résultat.
  • muteConfig: : nom de ressource relatif de la règle de masquage, représenté par la configuration de masquage ayant créé l'enregistrement. Exemple : organizations/123/muteConfigs/examplemuteconfig.
  • matchTime: heure à laquelle une règle de blocage dynamique a correspondu au résultat.

Arrêter les notifications et les exportations des résultats ignorés

Si vous activez les notifications de résultats, les résultats ignorés nouveaux ou mis à jour qui correspondent à vos filtres de notification sont toujours exportés vers Pub/Sub.

Pour arrêter les exportations et les notifications concernant les résultats ignorés, utilisez l'attribut mute afin d'exclure les résultats ignorés dans votre filtre NotificationConfig. Par exemple, le filtre suivant n'envoie de notification que pour les résultats actifs qui ne sont pas ignorés ou pour lesquels l'attribut de désactivation n'a pas été défini :

FILTER="state=\"ACTIVE\" AND -mute=\"MUTED\""

Étape suivante

Découvrez comment filtrer les notifications de résultats.

Consultez d'autres exemples de filtres que vous pouvez utiliser.