Trasmetti i risultati in BigQuery per l'analisi

Questa pagina descrive come trasmettere in streaming i risultati nuovi e aggiornati a un set di dati BigQuery utilizzando la funzione di esportazione di Security Command Center per BigQuery. I risultati esistenti non vengono inviati a BigQuery a meno che non vengano aggiornati.

BigQuery è il data warehouse di analisi di Google Cloudcompletamente gestito, su scala petabyte e dai costi contenuti, che ti consente di eseguire analisi su vaste quantità di dati quasi in tempo reale. Puoi utilizzare BigQuery per eseguire query sui risultati nuovi e aggiornati, filtrare i dati per trovare ciò che ti serve e generare report personalizzati. Per scoprire di più su BigQuery, consulta la documentazione di BigQuery.

Panoramica

Quando abiliti questa funzionalità, i nuovi risultati scritti in Security Command Center vengono esportati in una tabella BigQuery quasi in tempo reale. Puoi quindi integrare i dati nei flussi di lavoro esistenti e creare analisi personalizzate. Puoi attivare questa funzionalità a livello di organizzazione, cartella e progetto per esportare i risultati in base ai tuoi requisiti.

Questa funzionalità è il modo consigliato per esportare i risultati di Security Command Center in BigQuery, perché è completamente gestita e non richiede l'esecuzione di operazioni manuali o la scrittura di codice personalizzato.

Struttura del set di dati

Questa funzionalità aggiunge ogni nuovo risultato e i relativi aggiornamenti come nuove righe nella tabella findings, raggruppate per source_id, finding_id, e event_time.

Quando un risultato viene aggiornato, questa funzionalità crea più record di risultati con gli stessi valori source_id e finding_id, ma con valori event_time diversi. Questa struttura del set di dati ti consente di visualizzare la variazione dello stato di ogni risultato nel tempo.

Tieni presente che nel set di dati potrebbero esistere voci duplicate. Per analizzarli, puoi utilizzare la clausola DISTINCT, come mostrato nella prima query di esempio.

Ogni set di dati contiene una tabella findings, che ha i seguenti campi:

Costo

Ti vengono addebitati costi di BigQuery correlati a questa funzionalità. Per ulteriori informazioni, consulta la pagina Prezzi di BigQuery.

Prima di iniziare

Devi completare questi passaggi prima di attivare questa funzionalità.

Configurare le autorizzazioni

Per completare questa guida, devi disporre dei seguenti ruoli IAM (Identity and Access Management):

• Nell'organizzazione, nella cartella o nel progetto da cui vuoi esportare i risultati, esegui una delle seguenti operazioni:

  • Security Center BigQuery Exports Editor (roles/securitycenter.bigQueryExportsEditor).
  • Amministratore Centro sicurezza (roles/securitycenter.admin).

  Per scoprire di più sui ruoli di Security Command Center, consulta la sezione Controllo dell'accesso.

• Nel set di dati BigQuery, BigQuery Data Owner (roles/bigquery.dataOwner).

Crea un set di dati BigQuery

Creare un set di dati BigQuery. Per saperne di più, consulta la sezione Creazione di set di dati.

Pianificare la residenza dei dati

Se la residenza dei dati è abilitata per Security Command Center, le configurazioni che definiscono le esportazioni in streaming in BigQuery, ovvero le risorse BigQueryExport, sono soggette al controllo della residenza dei dati e vengono archiviate in una posizione di Security Command Center che selezioni.

Per esportare i risultati in una posizione di Security Command Center in BigQuery, devi configurare l'esportazione BigQuery nella stessa posizione di Security Command Center dei risultati.

Poiché i filtri utilizzati nelle esportazioni BigQuery possono contenere dati soggetti a controlli di residenza, assicurati di specificare la posizione corretta prima di crearli. Security Command Center non limita la località in cui creare le esportazioni.

Le esportazioni BigQuery vengono archiviate solo nella località in cui vengono create e non possono essere visualizzate o modificate in altre località.

Una volta creato un BigQuery Export, non puoi modificarne la posizione. Per modificare la posizione, devi eliminare l'esportazione BigQuery e ricrearla nella nuova posizione.

Per scoprire come utilizzare Security Command Center quando la residenza dei dati è abilitata, consulta Endpoint regionali di Security Command Center.

Esportare i risultati da Security Command Center a BigQuery

Per esportare i risultati, abilita prima l'API Security Command Center.

Abilitazione dell'API Security Command Center

Per abilitare l'API Security Command Center:

1. Vai alla pagina Libreria API nella console Google Cloud .

   Vai alla libreria API

2. Seleziona il progetto per cui vuoi abilitare l'API Security Command Center.

3. Nella casella Cerca, inserisci Security Command Center e poi fai clic su Security Command Center nei risultati di ricerca.

4. Nella pagina dell'API visualizzata, fai clic su Abilita.

L'API Security Command Center è abilitata per il tuo progetto. Successivamente, utilizzerai gcloud CLI per creare una nuova configurazione di esportazione in BigQuery.

Concessione dell'accesso al perimetro nei Controlli di servizio VPC

Se utilizzi i controlli di servizio VPC e il tuo set di dati BigQuery fa parte di un progetto all'interno di un perimetro di servizio, devi concedere l'accesso ai progetti per esportare i risultati.

Per concedere l'accesso ai progetti, crea regole in entrata e in uscita per i principal e i progetti da cui esporti i risultati. Le regole consentono l'accesso alle risorse protette e consentono a BigQuery di verificare che gli utenti dispongano dell'autorizzazione setIamPolicy sul set di dati BigQuery.

Prima di configurare una nuova esportazione in BigQuery

Configurare una nuova esportazione in BigQuery

In questo passaggio, crei una configurazione di esportazione per esportare i risultati in un'istanza BigQuery. Puoi creare configurazioni di esportazione a livello di progetto, cartella o organizzazione. Ad esempio, se vuoi esportare i risultati di un progetto in un set di dati BigQuery, crea una configurazione di esportazione a livello di progetto per esportare solo i risultati correlati a quel progetto. (Facoltativo) Puoi specificare filtri per esportare solo determinati risultati.

Assicurati di creare le configurazioni di esportazione al livello appropriato. Ad esempio, se crei una configurazione di esportazione nel progetto B per esportare i risultati dal progetto A e definisci filtri come resource.project_display_name: project-a-id, la configurazione non esporta alcun risultato.

Puoi creare un massimo di 500 configurazioni di esportazione in BigQuery per la tua organizzazione. Puoi utilizzare lo stesso set di dati per più configurazioni di esportazione. Se utilizzi lo stesso set di dati, tutti gli aggiornamenti verranno apportati alla stessa tabella dei risultati.

Quando crei la prima configurazione di esportazione, viene creato automaticamente un account di servizio. Questo account di servizio è necessario per creare o aggiornare la tabella dei risultati all'interno di un set di dati ed esportare i risultati nella tabella. Ha il formato service-org-ORGANIZATION_ID@gcp-sa-scc-notification.iam.gservicaccount.com e gli viene concesso il ruolo Editor dati BigQuery (roles/bigquery.dataEditor) a livello di set di dati BigQuery.

Nella console Google Cloud , alcune risorse BigQueryExport potrebbero avere un'etichetta Legacy, che indica che sono state create con l'API Security Command Center v1. Puoi gestire queste risorse BigQueryExport con la console Google Cloud , gcloud CLI, l'API Security Command Center v1 o le librerie client v1 per Security Command Center.

Per gestire queste risorse BigQueryExport con gcloud CLI, non devi specificare una località quando esegui il comando gcloud CLI.

resource "google_bigquery_dataset" "default" {
  dataset_id                  = "my-dataset"
  friendly_name               = "test"
  description                 = "This is a test description"
  location                    = "US"
  default_table_expiration_ms = 3600000
  default_partition_expiration_ms = null

  labels = {
    env = "default"
  }

  lifecycle {
    ignore_changes = [default_partition_expiration_ms]
  }
}

resource "google_scc_v2_organization_scc_big_query_export" "custom_big_query_export_config" {
  name         = "my-export"
  big_query_export_id    = "my-export"
  organization = "123456789"
  dataset      = google_bigquery_dataset.default.id
  location     = "global"
  description  = "Cloud Security Command Center Findings Big Query Export Config"
  filter       = "state=\"ACTIVE\" AND NOT mute=\"MUTED\""
}

resource "google_folder" "folder" {
  parent       = "organizations/123456789"
  display_name = "folder-name"

  deletion_protection = false
}

resource "google_bigquery_dataset" "default" {
  dataset_id                  = "my_dataset_id"
  friendly_name               = "test"
  description                 = "This is a test description"
  location                    = "US"
  default_table_expiration_ms = 3600000
  default_partition_expiration_ms = null

  labels = {
    env = "default"
  }

  lifecycle {
    ignore_changes = [default_partition_expiration_ms]
  }
}

resource "google_scc_v2_folder_scc_big_query_export" "custom_big_query_export_config" {
  big_query_export_id    = "my-export"
  folder       = google_folder.folder.folder_id
  dataset      = google_bigquery_dataset.default.id
  location     = "global"
  description  = "Cloud Security Command Center Findings Big Query Export Config"
  filter       = "state=\"ACTIVE\" AND NOT mute=\"MUTED\""
}

resource "google_bigquery_dataset" "default" {
  dataset_id                  = "my_dataset_id"
  friendly_name               = "test"
  description                 = "This is a test description"
  location                    = "US"
  default_table_expiration_ms = 3600000
  default_partition_expiration_ms = null

  labels = {
    env = "default"
  }

  lifecycle {
    ignore_changes = [default_partition_expiration_ms]
  }
}

resource "google_scc_v2_project_scc_big_query_export" "custom_big_query_export_config" {
  name         = "my-export"
  big_query_export_id    = "my-export"
  project      = "my-project-name"
  dataset      = google_bigquery_dataset.default.id
  location     = "global"
  description  = "Cloud Security Command Center Findings Big Query Export Config"
  filter       = "state=\"ACTIVE\" AND NOT mute=\"MUTED\""
}

import com.google.cloud.securitycenter.v2.BigQueryExport;
import com.google.cloud.securitycenter.v2.CreateBigQueryExportRequest;
import com.google.cloud.securitycenter.v2.OrganizationLocationName;
import com.google.cloud.securitycenter.v2.SecurityCenterClient;
import java.io.IOException;
import java.util.UUID;

public class CreateBigQueryExport {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Modify the following variable values.
    // organizationId: Google Cloud Organization id.
    String organizationId = "{google-cloud-organization-id}";

    // projectId: Google Cloud Project id.
    String projectId = "{your-project}";

    // Specify the location.
    String location = "global";

    // filter: Expression that defines the filter to apply across create/update events of findings.
    String filter = "severity=\"LOW\" OR severity=\"MEDIUM\"";

    // bigQueryDatasetId: The BigQuery dataset to write findings' updates to.
    String bigQueryDatasetId = "{bigquery-dataset-id}";

    // bigQueryExportId: Unique identifier provided by the client.
    // For more info, see:
    // https://cloud.google.com/security-command-center/docs/how-to-analyze-findings-in-big-query#export_findings_from_to
    String bigQueryExportId = "default-" + UUID.randomUUID().toString().split("-")[0];

    createBigQueryExport(organizationId, location, projectId, filter, bigQueryDatasetId,
        bigQueryExportId);
  }

  // Create export configuration to export findings from a project to a BigQuery dataset.
  // Optionally specify filter to export certain findings only.
  public static BigQueryExport createBigQueryExport(String organizationId, String location,
      String projectId, String filter, String bigQueryDatasetId, String bigQueryExportId)
      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()) {
      OrganizationLocationName organizationName = OrganizationLocationName.of(organizationId,
          location);
      // Create the BigQuery export configuration.
      BigQueryExport bigQueryExport =
          BigQueryExport.newBuilder()
              .setDescription(
                  "Export low and medium findings if the compute resource "
                      + "has an IAM anomalous grant")
              .setFilter(filter)
              .setDataset(String.format("projects/%s/datasets/%s", projectId, bigQueryDatasetId))
              .build();

      CreateBigQueryExportRequest bigQueryExportRequest =
          CreateBigQueryExportRequest.newBuilder()
              .setParent(organizationName.toString())
              .setBigQueryExport(bigQueryExport)
              .setBigQueryExportId(bigQueryExportId)
              .build();

      // Create the export request.
      BigQueryExport response = client.createBigQueryExport(bigQueryExportRequest);

      System.out.printf("BigQuery export request created successfully: %s\n", response.getName());
      return response;
    }
  }
}

def create_bigquery_export(
    parent: str, export_filter: str, bigquery_dataset_id: str, bigquery_export_id: str
):
    from google.cloud import securitycenter_v2

    """
    Create export configuration to export findings from a project to a BigQuery dataset.
    Optionally specify filter to export certain findings only.

    Args:
        parent: Use any one of the following resource paths:
             - organizations/{organization_id}/locations/{location_id}
             - folders/{folder_id}/locations/{location_id}
             - projects/{project_id}/locations/{location_id}
        export_filter: Expression that defines the filter to apply across create/update events of findings.
        bigquery_dataset_id: The BigQuery dataset to write findings' updates to.
             - projects/{PROJECT_ID}/datasets/{BIGQUERY_DATASET_ID}
        bigquery_export_id: Unique identifier provided by the client.
             - example id: f"default-{str(uuid.uuid4()).split('-')[0]}"
        For more info, see:
        https://cloud.google.com/security-command-center/docs/how-to-analyze-findings-in-big-query#export_findings_from_to
    """
    client = securitycenter_v2.SecurityCenterClient()

    # Create the BigQuery export configuration.
    bigquery_export = securitycenter_v2.BigQueryExport()
    bigquery_export.description = "Export low and medium findings if the compute resource has an IAM anomalous grant"
    bigquery_export.filter = export_filter
    bigquery_export.dataset = bigquery_dataset_id

    request = securitycenter_v2.CreateBigQueryExportRequest()
    request.parent = parent
    request.big_query_export = bigquery_export
    request.big_query_export_id = bigquery_export_id

    # Create the export request.
    response = client.create_big_query_export(request)

    print(f"BigQuery export request created successfully: {response.name}\n")
    return response

Dovresti visualizzare i risultati nel set di dati BigQuery entro circa 15 minuti dalla creazione della configurazione di esportazione. Una volta creata la tabella BigQuery, i nuovi risultati e quelli aggiornati che corrispondono al filtro e all'ambito verranno visualizzati nella tabella quasi in tempo reale.

Per esaminare i risultati, consulta Esaminare i risultati.

Crea una regola di ingresso per la nuova esportazione in BigQuery

Se utilizzi i controlli di servizio VPC e il tuo set di dati BigQuery fa parte di un progetto all'interno di un perimetro di servizio, devi creare una regola di ingresso per una nuova esportazione in BigQuery.

I progetti, gli utenti e i service account selezionati ora possono accedere alle risorse protette ed esportare i risultati.

Se hai seguito tutti i passaggi di questa guida e le esportazioni funzionano correttamente, ora puoi eliminare quanto segue:

• La regola in entrata per l'entità
• La regola in uscita per l'entità

Queste regole erano necessarie solo per configurare la configurazione di esportazione. Tuttavia, affinché le configurazioni di esportazione continuino a funzionare, devi mantenere la regola di ingresso che hai creato in precedenza, che consente a Security Command Center di esportare i risultati nel tuo set di dati BigQuery dietro il perimetro di servizio.

Visualizzare i dettagli di una configurazione di esportazione

Aggiornare una configurazione di esportazione

Se necessario, puoi modificare il filtro, il set di dati e la descrizione di una configurazione di esportazione esistente. Non puoi modificare il nome della configurazione di esportazione.

Visualizza tutte le configurazioni di esportazione

Puoi visualizzare tutte le configurazioni di esportazione all'interno dell'organizzazione, della cartella o del progetto.

import com.google.cloud.securitycenter.v2.BigQueryExport;
import com.google.cloud.securitycenter.v2.ListBigQueryExportsRequest;
import com.google.cloud.securitycenter.v2.OrganizationLocationName;
import com.google.cloud.securitycenter.v2.SecurityCenterClient;
import com.google.cloud.securitycenter.v2.SecurityCenterClient.ListBigQueryExportsPagedResponse;
import java.io.IOException;

public class ListBigQueryExports {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Modify the following variable values.
    // organizationId: Google Cloud Organization id.
    String organizationId = "{google-cloud-organization-id}";

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

    listBigQueryExports(organizationId, location);
  }

  // List BigQuery exports in the given parent.
  public static ListBigQueryExportsPagedResponse listBigQueryExports(String organizationId,
      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()) {
      OrganizationLocationName organizationName = OrganizationLocationName.of(organizationId,
          location);

      ListBigQueryExportsRequest request = ListBigQueryExportsRequest.newBuilder()
          .setParent(organizationName.toString())
          .build();

      ListBigQueryExportsPagedResponse response = client.listBigQueryExports(request);

      System.out.println("Listing BigQuery exports:");
      for (BigQueryExport bigQueryExport : response.iterateAll()) {
        System.out.println(bigQueryExport.getName());
      }
      return response;
    }
  }
}

def list_bigquery_exports(parent: str):
    from google.cloud import securitycenter_v2

    """
    List BigQuery exports in the given parent.
    Args:
         parent: The parent which owns the collection of BigQuery exports.
             Use any one of the following resource paths:
                 - organizations/{organization_id}/locations/{location_id}
                 - folders/{folder_id}/locations/{location_id}
                 - projects/{project_id}/locations/{location_id}
    """

    client = securitycenter_v2.SecurityCenterClient()

    request = securitycenter_v2.ListBigQueryExportsRequest()
    request.parent = parent

    response = client.list_big_query_exports(request)

    print("Listing BigQuery exports:")
    for bigquery_export in response:
        print(bigquery_export.name)
    return response

Eliminare una configurazione di esportazione

Se non hai più bisogno di una configurazione di esportazione, puoi eliminarla.

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

public class DeleteBigQueryExport {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Modify the following variable values.
    // organizationId: Google Cloud Organization id.
    String organizationId = "{google-cloud-organization-id}";

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

    // bigQueryExportId: Unique identifier that is used to identify the export.
    String bigQueryExportId = "{bigquery-export-id}";

    deleteBigQueryExport(organizationId, location, bigQueryExportId);
  }

  // Delete an existing BigQuery export.
  public static void deleteBigQueryExport(String organizationId, String location,
      String bigQueryExportId)
      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()) {
      // Optionally BigQueryExportName or String can be used
      // String bigQueryExportName = String.format("organizations/%s/locations/%s
      // /bigQueryExports/%s",organizationId,location, bigQueryExportId);
      BigQueryExportName bigQueryExportName = BigQueryExportName.of(organizationId, location,
          bigQueryExportId);

      DeleteBigQueryExportRequest bigQueryExportRequest =
          DeleteBigQueryExportRequest.newBuilder()
              .setName(bigQueryExportName.toString())
              .build();

      client.deleteBigQueryExport(bigQueryExportRequest);
      System.out.printf("BigQuery export request deleted successfully: %s", bigQueryExportId);
    }
  }
}

def delete_bigquery_export(parent: str, bigquery_export_id: str):
    """
    Delete an existing BigQuery export.
    Args:
        parent: Use any one of the following resource paths:
                 - organizations/{organization_id}/locations/{location_id}
                 - folders/{folder_id}/locations/{location_id}
                 - projects/{project_id}/locations/{location_id}
        bigquery_export_id: Unique identifier that is used to identify the export.
    """
    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

    request = securitycenter_v2.DeleteBigQueryExportRequest()
    request.name = f"{parent}/bigQueryExports/{bigquery_export_id}"

    client.delete_big_query_export(request)
    print(f"BigQuery export request deleted successfully: {bigquery_export_id}")

Dopo aver eliminato la configurazione di esportazione, puoi rimuovere i dati da Looker Studio. Per saperne di più, consulta la sezione Rimuovere, eliminare e ripristinare un'origine dati.

Esamina i risultati in BigQuery

Dopo aver creato una configurazione di esportazione, i nuovi risultati vengono esportati nel set di dati BigQuery del progetto specificato.

Per esaminare i risultati in BigQuery:

1. Vai al progetto in BigQuery.

   Vai a BigQuery

2. Seleziona un progetto.

3. Nel riquadro Explorer, espandi il nodo per il tuo progetto.

4. Espandi il set di dati.

5. Fai clic sulla tabella Risultati.

6. Nella scheda che si apre, fai clic su Anteprima. Viene visualizzato un set di dati di esempio.

Query utili

Questa sezione fornisce query di esempio per l'analisi dei dati dei risultati. Negli esempi riportati di seguito, sostituisci DATASET con il nome assegnato al tuo set di dati e PROJECT_ID con il nome del progetto per il tuo set di dati.

Per risolvere eventuali errori riscontrati, consulta Messaggi di errore.

Il numero di nuovi risultati creati e aggiornati ogni giorno

SELECT
    FORMAT_DATETIME("%Y-%m-%d", event_time) AS date,
    count(DISTINCT finding_id)
FROM `PROJECT_ID.DATASET.findings`
GROUP BY date
ORDER BY date DESC

L'ultimo record del risultato per ogni risultato

SELECT
    * EXCEPT(row)
FROM (
    SELECT *, ROW_NUMBER() OVER(
        PARTITION BY finding_id
        ORDER BY event_time DESC, finding.mute_update_time DESC
    ) AS row
    FROM `PROJECT_ID.DATASET.findings`
)
WHERE row = 1

Risultati attivi attuali, ordinati per ora

WITH latestFindings AS (
    SELECT * EXCEPT(row)
    FROM (
        SELECT *, ROW_NUMBER() OVER(
            PARTITION BY finding_id
            ORDER BY event_time DESC, finding.mute_update_time DESC
        ) AS row
        FROM `PROJECT_ID.DATASET.findings`
    ) WHERE row = 1
)
SELECT finding_id, event_time, finding
FROM latestFindings
WHERE finding.state = "ACTIVE"
ORDER BY event_time DESC

Risultati attuali che si trovano in un progetto

WITH latestFindings AS (
    SELECT * EXCEPT(row)
    FROM (
        SELECT *, ROW_NUMBER() OVER(
            PARTITION BY finding_id
            ORDER BY event_time DESC, finding.mute_update_time DESC
        ) AS row
        FROM `PROJECT_ID.DATASET.findings`
    ) WHERE row = 1
)
SELECT finding_id, event_time, finding, resource
FROM latestFindings
WHERE resource.project_display_name = 'PROJECT'

Sostituisci PROJECT con il nome del progetto.

Risultati attuali che si trovano in una cartella

WITH latestFindings AS(
    SELECT * EXCEPT(row)
    FROM (
        SELECT *, ROW_NUMBER() OVER(
            PARTITION BY finding_id
            ORDER BY event_time DESC, finding.mute_update_time DESC
        ) AS row
        FROM `PROJECT_ID.DATASET.findings`
    ) WHERE row = 1
)
SELECT finding_id, event_time, finding, resource
FROM latestFindings
CROSS JOIN UNNEST(resource.folders) AS folder
WHERE folder.resource_folder_display_name = 'FOLDER'

Sostituisci FOLDER con il nome della cartella.

Risultati attuali dello scanner Logging Scanner

WITH latestFindings AS (
    SELECT * EXCEPT(row)
    FROM (
        SELECT *, ROW_NUMBER() OVER(
            PARTITION BY finding_id
            ORDER BY event_time DESC, finding.mute_update_time DESC
        ) AS row
        FROM `PROJECT_ID.DATASET.findings`
    ) WHERE row = 1
)
SELECT finding_id, event_time, finding
FROM latestFindings
CROSS JOIN UNNEST(finding.source_properties) AS source_property
WHERE source_property.key = "ScannerName"
  AND source_property.value = "LOGGING_SCANNER"

Risultati attivi correnti di tipo Persistence: IAM Anomalous Grant

WITH latestFindings AS(
    SELECT * EXCEPT(row)
    FROM (
        SELECT *, ROW_NUMBER() OVER(
            PARTITION BY finding_id
            ORDER BY event_time DESC, finding.mute_update_time DESC
        ) AS row
        FROM `PROJECT_ID.DATASET.findings`
    ) WHERE row = 1
)
SELECT finding_id, event_time, finding
FROM latestFindings
WHERE finding.state = "ACTIVE"
  AND finding.category = "Persistence: IAM Anomalous Grant"

Correlare i risultati attivi di un determinato tipo con Cloud Audit Logs

Questa query di esempio consente di esaminare i risultati anomali di concessione IAM di Event Threat Detection utilizzando Cloud Audit Logs visualizzando la sequenza di azioni di attività amministrativa del concedente durante l'intervallo di tempo precedente e successivo all'azione anomala di concessione IAM. La seguente query correla i log dell'attività amministrativa tra 1 ora prima e 1 ora dopo il timestamp del risultato.

WITH latestFindings AS(
    SELECT * EXCEPT(row)
    FROM (
        SELECT *, ROW_NUMBER() OVER(
            PARTITION BY finding_id
            ORDER BY event_time DESC, finding.mute_update_time DESC
        ) AS row
        FROM `PROJECT_ID.DATASET.findings`
    ) WHERE row = 1
)
SELECT
  finding_id,
  ANY_VALUE(event_time) as event_time,
  ANY_VALUE(finding.access.principal_email) as grantor,
  JSON_VALUE_ARRAY(ANY_VALUE(finding.source_properties_json), '$.properties.sensitiveRoleGrant.members') as grantees,
  ARRAY_AGG(
    STRUCT(
      timestamp,
      IF(timestamp < event_time, 'before', 'after') as timeline,
      protopayload_auditlog.methodName,
      protopayload_auditlog.resourceName,
      protopayload_auditlog.serviceName
    )
    ORDER BY timestamp ASC
  ) AS recent_activity
FROM (
  SELECT
    f.*,
    a.*,
  FROM latestFindings AS f
  LEFT JOIN `PROJECT_ID.DATASET.cloudaudit_googleapis_com_activity` AS a
  ON a.protopayload_auditlog.authenticationInfo.principalEmail = f.finding.access.principal_email
  WHERE f.finding.state = "ACTIVE"
    AND f.finding.category = "Persistence: IAM Anomalous Grant"
    AND a.timestamp >= TIMESTAMP_SUB(f.event_time, INTERVAL 1 HOUR)
    AND a.timestamp <= TIMESTAMP_ADD(f.event_time, INTERVAL 1 HOUR)
  )
GROUP BY
  finding_id
ORDER BY
  event_time DESC

L'output è simile al seguente:

Creare grafici in Looker Studio

Looker Studio ti consente di creare report e dashboard interattivi.

In generale, quando accedi a BigQuery tramite Looker Studio, sostieni costi di utilizzo di BigQuery. Per ulteriori informazioni, consulta la pagina Visualizzazione dei dati BigQuery utilizzando Looker Studio.

Per creare un grafico che visualizzi i dati dei risultati per gravità e categoria:

1. Apri Looker Studio e accedi.
2. Se richiesto, fornisci ulteriori informazioni e configura altre preferenze. Leggi i Termini di servizio e, se li ritieni soddisfacenti, continua.
3. Fai clic su Report vuoto.
4. Nella scheda Connessione ai dati, fai clic sulla scheda BigQuery.
5. Se richiesto, autorizza Looker Studio ad accedere ai progetti BigQuery.

6. Connettiti ai dati dei risultati:

   1. Per Progetto, seleziona il progetto per il tuo set di dati. In alternativa, nella scheda I miei progetti, inserisci l'ID progetto per cercarlo.
   2. In Set di dati, fai clic sul nome del set di dati.
   3. In Tabella, fai clic su findings.
   4. Fai clic su Aggiungi.
   5. Nella finestra di dialogo, fai clic su Aggiungi al report.

7. Dopo aver aggiunto il report, fai clic su Aggiungi un grafico.

8. Fai clic su Grafico a colonne in pila e poi sull'area in cui vuoi posizionarlo.

   

9. Nel riquadro Grafico > A barre, nella scheda Dati, imposta i seguenti campi:

   1. Nel campo Dimensione, seleziona finding.severity.
   2. Nel campo Dimensione di distribuzione, seleziona finding.category.

   

Il report viene aggiornato per mostrare più colonne con i risultati suddivisi per gravità e categoria.

Passaggi successivi

Scopri come eseguire una query in BigQuery.