Usare l'agente di ricognizione in Project percezione

Si applica a: Project Perception

Important

Alcune informazioni in questo articolo fanno riferimento alle caratteristiche di un prodotto prima del rilascio, che possono essere modificate sostanzialmente prima della distribuzione al pubblico. Microsoft non fornisce alcuna garanzia, espressa o implicita, rispetto alle informazioni fornite qui. Project Perception è attualmente disponibile in anteprima pubblica limitata. Programma di anteprima pubblica limitata indica che Perception è disponibile per un ristretto gruppo di clienti solo su invito per un periodo di anteprima definito prima della più ampia disponibilità pubblica.

Recon Agent in Project Perception fornisce ai team di sicurezza e agli operatori del red team una vista dal punto di vista di un attaccante di un ambiente Azure. Correla asset, identità, autorizzazioni ed esposizione alla rete per identificare percorsi di attacco realistici, problemi di configurazione ed esposizione senza modificare le risorse.

Usare questo articolo per comprendere le funzionalità di Recon Agent, esaminare i prerequisiti e le autorizzazioni, configurarlo, avviare una sessione e interpretarne il report.

Funzionalità principali

L'agente di ricognizione esegue una ricognizione orchestrata in più passaggi nell'ambiente di Azure.

Valutazione di sola lettura: fornisce una valutazione dei rischi basata su prove senza modificare le risorse.
Input per altri agenti: fornisce risultati ad altri agenti, inclusi gli agenti di indagine.
Analisi a terra dell'ambiente: analizza solo i dati dell'ambiente Azure.

Note

Recon Agent crea una valutazione in sola lettura. Non sfrutta vulnerabilità, esegue payload, modifica risorse, distribuisce rilevamenti, salva in modo persistente i grafici di attacco né opera al di fuori della tua organizzazione. L'agente analizza l'ambiente tramite chiamate API di sola lettura. I risultati sono uno snapshot temporizzato e non sostituiscono sistemi di monitoraggio continuo.

Perché usare l'agente di riconciliazione?

Microsoft Security Exposure Management identifica continuamente i percorsi di attacco originati da asset esposti da Internet, risorse critiche e identità sensibili. Monitora questi asset e identità contrassegnati, ma non genera percorsi di attacco da punti di partenza arbitrari che non soddisfano questi criteri.

L'agente di ricognizione integra la gestione dell'esposizione con l'analisi presunta delle violazioni. Gli analisti possono iniziare con qualsiasi asset o identità in una sottoscrizione Azure. Non è necessario designare gli asset come critici o esposti a Internet e non è necessario contrassegnare le identità come sensibili. L'analisi risponde alla domanda "Se un utente malintenzionato ha già controllato questo asset o identità, dove potrebbero andare avanti?"

Ad esempio, un attacco di phishing potrebbe compromettere un utente che non è contrassegnato come identità sensibile in Defender. La gestione dell'esposizione in genere non genera un percorso di attacco da tale utente, a meno che il percorso non includa un altro asset contrassegnato. Il Recon Agent può usare l'utente come punto di partenza per identificare potenziali percorsi di spostamento laterale di un attaccante. I team possono quindi identificare punti di choke efficaci prima che questi percorsi portino a eventi imprevisti che coinvolgono risorse critiche o identità sensibili.

Questa copertura più ampia del punto di partenza consente ai team di identificare i percorsi di attacco nell'ambiente Azure e di classificare in ordine di priorità i percorsi critici nel tempo per ridurre il volume degli eventi imprevisti del Centro operazioni di sicurezza (SOC).

Caso di utilizzo	Agente di riconciliazione
Percorsi di attacco da asset e identità non contrassegnati	Genera percorsi di attacco in uno scenario di violazione presunta a partire da qualsiasi risorsa o identità in una sottoscrizione Azure, incluse le risorse che non sono designate come critiche o esposte a Internet e le identità che non sono contrassegnate come sensibili.
Posizione e visibilità dell'esposizione	Interpreta questi segnali nel contesto e spiega quali combinazioni di identità, autorizzazione, asset e esposizione di rete creano percorsi di attacco realistici.
Analisi degli alert	Spiega se un avviso o un rilevamento fa parte di un percorso più ampio di un attaccante e quali risorse a valle potrebbero essere raggiunte.
Analisi del percorso di attacco	Esegue una ricognizione mirata basata sulla sessione nell'ambito di una sottoscrizione, un gruppo di risorse o una risorsa critica ed è in grado di ragionare su dati mancanti, passaggi non riusciti e percorsi dedotti.
Copertura del rilevamento	Mappa i passaggi del percorso di attacco agli avvisi di Defender esistenti e alla copertura di hunting, quindi evidenzia i punti in cui il SOC potrebbe non avere visibilità.
Definizione delle priorità	Assegna priorità ai percorsi e alle correzioni più probabili per ridurre l'exploitbilità, il raggio di esplosione e l'impatto aziendale per l'ambiente selezionato.
Pianificazione della correzione	Identifica il set più piccolo di modifiche ad impatto elevato che interrompe il maggior numero di percorsi di attacco e mostra i percorsi eliminati da ogni correzione.
Usabilità degli analisti	Produce spiegazioni in linguaggio normale, ragionamenti basati su prove e diagrammi di percorso di attacco che sono più facili da esaminare per analisti, team rossi e stakeholder.

In breve: Microsoft Defender prodotti aiutano a rilevare, proteggere e gestire l'esposizione. Recon Agent spiega come un utente malintenzionato potrebbe sfruttare tale esposizione in uno specifico ambiente Azure e quali azioni ridurrebbero il rischio nel modo più efficace.

Prima di iniziare

Prima di configurare l'agente di riconciliazione, esaminare i requisiti di prodotto e autorizzazione seguenti.

Prerequisiti

Per usare l'agente di riconciliazione, è necessario:

Microsoft Entra ID P2
Microsoft Defender XDR
Microsoft Defender per Cloud con il piano CSPM di Defender
Una sottoscrizione di Azure

Autorizzazioni necessarie

Livello di autorizzazione	Cosa puoi fare
Amministrazione di sicurezza	Installare e configurare gli agenti: configurare le identità e le autorizzazioni dell'agente e rimuovere gli agenti. Almeno un utente dell'organizzazione deve avere questo ruolo.
Analista della Sicurezza	Usare gli agenti: visualizzare e interagire con le sessioni dell'agente, avviare sessioni e visualizzare i dettagli della sessione.

Tip

Per delegare l'installazione dell'agente ad altri utenti, assegnare il ruolo amministratore della sicurezza . Se sono necessarie assegnazioni di ruolo, contattare l'amministratore Microsoft Entra.

Autorizzazioni aggiuntive necessarie

L'agente di ricognizione richiede due altri set di autorizzazioni per eseguire la ricognizione. L'utente che concede ogni set di autorizzazioni deve avere il ruolo corrispondente nella tabella seguente.

Ruolo necessario per concedere le autorizzazioni	Autorizzazioni da concedere al Recon Agent
Amministratore dei ruoli con privilegi (ruolo Microsoft Entra)	Autorizzazioni di Microsoft API Graph: - `User.Read.All` - `Organization.Read.All` - `GroupMember.Read.All` - `Application.Read.All` - `DelegatedPermissionGrant.Read.All` - `Policy.Read.All` - `RoleManagement.Read.Directory` - `AuditLog.Read.All`
Amministratore del controllo degli accessi basato sui ruoli nella sottoscrizione che costituisce l'ambiente di destinazione per il Recon Agent	Ruoli del controllo degli accessi in base al ruolo (RBAC) di Azure (assegnare a livello di sottoscrizione): - Lettore - Lettore Key Vault - Lettore di Log Analytics - Lettore di sicurezza

Configurare l'agente di riconciliazione

Per configurare l'agente, seguire la procedura descritta in Configurare un agente.

Note

Recon Agent usa un'identità dell'agente anziché un'identità utente dell'agente. A causa delle limitazioni tecniche correnti, le identità utente dell'agente non supportano le operazioni di sola lettura di Recon Agent.

Dopo aver creato l'ID agente di Recon Agent, usare lo script seguente per assegnare le autorizzazioni elencate in Autorizzazioni aggiuntive necessarie. I parametri dello script sono elencati di seguito.

Concedi le autorizzazioni per Microsoft API Graph e Azure RBAC:

Eseguire questo script per concedere le autorizzazioni dell'applicazione Microsoft Graph e le autorizzazioni RBAC di Azure necessarie per Recon Agent. È possibile concedere Graph, Azure o entrambe le autorizzazioni tramite i parametri.

<#
.SYNOPSIS
    Assigns the Graph API permissions and Azure RBAC roles required by Recon.

.DESCRIPTION
    Assigns the following Graph API application permissions:
      - User.Read.All
      - Organization.Read.All
      - GroupMember.Read.All
      - Application.Read.All
      - DelegatedPermissionGrant.Read.All
      - Policy.Read.All
      - RoleManagement.Read.Directory
      - AuditLog.Read.All

        Assigns the following Azure RBAC roles at subscription scope:
            - Reader
            - Key Vault Reader
            - Log Analytics Reader
            - Security Reader

.PARAMETER TenantId
    The Tenant Id.

.PARAMETER AgentId
    The Entra ID Object ID (principal ID) of the Agent Identity to assign roles to. To get this value,
    1. Go to the Microsoft Defender portal at https://security.microsoft.com/ -> Perception -> Agents
    2. Search for the Recon Agent and click on it to open the agent details page
    3. Copy the value under the "Identity" section

.PARAMETER Permissions
    Permission sets to assign: All, Azure, or Graph. Defaults to All.

.PARAMETER SubscriptionId
    One or more Azure subscriptions to receive the Recon RBAC assignments.
    Values can be comma-delimited, space-delimited, or supplied as an array.
    Required when Permissions is All or Azure.

Example: .\ReconAgent-Permissions.ps1 -TenantId <TenandId> -AgentId <AgentId> -Permissions All -SubscriptionId <SubscriptionId>
Example: .\ReconAgent-Permissions.ps1 -TenantId <TenandId> -AgentId <AgentId> -Permissions Azure -SubscriptionId <SubscriptionId1>, <SubscriptionId2>

#>

[CmdletBinding()]
param(
    [Parameter(Mandatory = $true)]
    [ValidatePattern('^[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}$')]
    [string]$TenantId,

    [Parameter(Mandatory = $true)]
    [ValidatePattern('^[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}$')]
    [string]$AgentId,

    [ValidateSet('All', 'Azure', 'Graph')]
    [string]$Permissions = 'All',

    [string[]]$SubscriptionId,

    [Parameter(ValueFromRemainingArguments = $true, DontShow = $true)]
    [string[]]$AdditionalSubscriptionId
)

$ErrorActionPreference = 'Stop'

$subscriptionIds = @(@($SubscriptionId) + @($AdditionalSubscriptionId) |
    ForEach-Object { $_ -split '[,\s]+' } |
    Where-Object { -not [string]::IsNullOrWhiteSpace($_) } |
    ForEach-Object { $_.Trim() } |
    Sort-Object -Unique)

if ($Permissions -in @('All', 'Azure') -and $subscriptionIds.Count -eq 0) {
    throw '-SubscriptionId requires at least one subscription GUID when -Permissions is All or Azure.'
}

foreach ($id in $subscriptionIds) {
    if ($id -notmatch '^[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}$') {
        throw "Invalid subscription ID '$id'. Supply one or more GUIDs separated by commas or spaces."
    }
}

function Invoke-AzJson {
    param(
        [Parameter(Mandatory)]
        [string[]]$Arguments
    )

    $output = & az @Arguments 2>&1
    if ($LASTEXITCODE -ne 0) {
        throw "az $($Arguments -join ' ') failed: $($output -join [Environment]::NewLine)"
    }

    if (-not $output) {
        return $null
    }

    return ($output -join [Environment]::NewLine) | ConvertFrom-Json
}

function Test-AzureActionAllowed {
    param(
        [Parameter(Mandatory)]
        [string]$Scope,

        [Parameter(Mandatory)]
        [string]$Action
    )

    $permissionsResponse = Invoke-AzJson -Arguments @(
        'rest', '--method', 'GET',
        '--url', "https://management.azure.com$Scope/providers/Microsoft.Authorization/permissions?api-version=2022-04-01",
        '--output', 'json'
    )

    foreach ($permission in @($permissionsResponse.value)) {
        $isAllowed = @($permission.actions | Where-Object {
            $Action -like [string]$_
        }).Count -gt 0
        $isExcluded = @($permission.notActions | Where-Object {
            $Action -like [string]$_
        }).Count -gt 0

        if ($isAllowed -and -not $isExcluded) {
            return $true
        }
    }

    return $false
}

function Write-Section {
    param([string]$Title)

    Write-Host ''
    Write-Host $Title -ForegroundColor Cyan
    Write-Host ('-' * $Title.Length) -ForegroundColor DarkGray
}

function Write-Step {
    param(
        [string]$Message,
        [ValidateSet('Info', 'OK', 'Warn', 'Err', 'Step')]
        [string]$Level = 'Info'
    )

    $color = switch ($Level) {
        'OK' { 'Green' }
        'Warn' { 'Yellow' }
        'Err' { 'Red' }
        'Step' { 'Cyan' }
        default { 'Gray' }
    }
    $prefix = switch ($Level) {
        'OK' { '[ OK ]' }
        'Warn' { '[WARN]' }
        'Err' { '[FAIL]' }
        'Step' { '[STEP]' }
        default { '[ -- ]' }
    }

    if ($Level -eq 'Step') {
        Write-Host ''
    }

    Write-Host (
        '{0} {1} {2}' -f
        (Get-Date -Format 'HH:mm:ss'), $prefix, $Message
    ) -ForegroundColor $color
}

function Write-ConsoleResults {
    param([object[]]$Results)

    Write-Section 'Granular Recon permission assignment'
    Write-Step `
        -Message "Agent: Recon, EntraObjectId: $AgentId" `
        -Level Step

    foreach ($result in @($Results |
        Sort-Object PermissionSet, SubscriptionId, Role)) {
        $category = if ($result.PermissionSet -eq 'Graph') {
            'Microsoft Graph permission'
        }
        else {
            'Azure RBAC'
        }
        $value = if ($result.PermissionSet -eq 'Azure') {
            "{0} ({1})" -f $result.Role, $result.Scope
        }
        else {
            "Graph $($result.Role)"
        }
        $assignmentResult = switch ($result.Status) {
            'Already assigned' { 'Already existed' }
            'Assigned' { 'Added' }
            default { $result.Status }
        }
        $level = if ($result.Status -eq 'Failed') { 'Err' } else { 'OK' }

        Write-Step `
            -Message "$category`: $value - $assignmentResult" `
            -Level $level
        if ($result.Status -eq 'Failed' -and
            -not [string]::IsNullOrWhiteSpace([string]$result.Details)) {
            Write-Host ("       Details:  {0}" -f $result.Details) `
                -ForegroundColor DarkGray
        }
    }
}

if (-not (Get-Command az -ErrorAction SilentlyContinue)) {
    throw 'Azure CLI is required but the az command was not found.'
}

Write-Host ''
Write-Host 'Recon Agent Permission Assignment' -ForegroundColor Cyan
Write-Host 'Assigns required Microsoft Graph and Azure RBAC permissions' `
    -ForegroundColor DarkGray
Write-Host "Permission set: $Permissions"
Write-Host "Tenant: $TenantId"

# Ensure Azure CLI is signed in to the requested tenant.
$account = $null
try {
    $account = Invoke-AzJson -Arguments @('account', 'show', '--output', 'json')
}
catch {
    # No usable cached Azure CLI session.
}

if (-not $account -or [string]$account.tenantId -ne $TenantId) {
    & az login --tenant $TenantId --allow-no-subscriptions | Out-Null
    if ($LASTEXITCODE -ne 0) {
        throw "Azure CLI sign-in to tenant $TenantId failed."
    }
}

$agentServicePrincipal = Invoke-AzJson -Arguments @(
    'rest', '--method', 'GET',
    '--url', "https://graph.microsoft.com/v1.0/servicePrincipals/$AgentId",
    '--output', 'json'
)
if ([string]$agentServicePrincipal.id -ne $AgentId) {
    throw "Agent service principal $AgentId could not be resolved in tenant $TenantId."
}

$results = @()

if ($Permissions -in @('All', 'Graph')) {
    $graphToken = & az account get-access-token `
        --tenant $TenantId `
        --resource-type ms-graph `
        --query accessToken `
        --output tsv 2>&1
    if ($LASTEXITCODE -ne 0 -or [string]::IsNullOrWhiteSpace([string]$graphToken)) {
        throw "Unable to acquire a Microsoft Graph token: $($graphToken -join [Environment]::NewLine)"
    }
    $graphHeaders = @{
        Authorization = "Bearer $([string]$graphToken)"
        Accept = 'application/json'
    }

    # Graph API roles (AppRoleId -> Role Name)
    $graphRoleIds = @{
        'df021288-bdef-4463-88db-98f22de89214' = 'User.Read.All'
        '498476ce-e0fe-48b0-b801-37ba7e2685c6' = 'Organization.Read.All'
        '98830695-27a2-44f7-8c18-0c3ebc9698f6' = 'GroupMember.Read.All'
        '9a5d68dd-52b0-4cc2-bd40-abcf44ac3a30' = 'Application.Read.All'
        '81b4724a-58aa-41c1-8a55-84ef97466587' = 'DelegatedPermissionGrant.Read.All'
        '246dd0d5-5bd0-4def-940b-0421030a5b68' = 'Policy.Read.All'
        '483bed4a-2ad3-4361-a73b-c83ccdbdc53c' = 'RoleManagement.Read.Directory'
        'b0afded3-3588-46d8-8b3d-9842eff778da' = 'AuditLog.Read.All'
    }

    $graphServicePrincipal = Invoke-AzJson -Arguments @(
        'ad', 'sp', 'show',
        '--id', '00000003-0000-0000-c000-000000000000',
        '--output', 'json'
    )
    $GraphObjectId = [string]$graphServicePrincipal.id
    if ([string]::IsNullOrWhiteSpace($GraphObjectId)) {
        throw "Microsoft Graph service principal could not be resolved in tenant $TenantId."
    }

    $existingAssignmentsResponse = Invoke-AzJson -Arguments @(
        'rest', '--method', 'GET',
        '--url', "https://graph.microsoft.com/v1.0/servicePrincipals/$AgentId/appRoleAssignments",
        '--output', 'json'
    )
    $existingAssignments = @($existingAssignmentsResponse.value)

    foreach ($rid in $graphRoleIds.Keys) {
        $roleName = $graphRoleIds[$rid]
        $existingAssignment = $existingAssignments |
            Where-Object {
                [string]$_.resourceId -eq $GraphObjectId -and
                [string]$_.appRoleId -eq $rid
            } |
            Select-Object -First 1

        if ($existingAssignment) {
            $results += [pscustomobject]@{
                PermissionSet = 'Graph'
                Role = $roleName
                Status = 'Already assigned'
                Details = ''
            }
            continue
        }

        $body = @{
            principalId = $AgentId
            resourceId = $GraphObjectId
            appRoleId = $rid
        } | ConvertTo-Json -Compress

        try {
            Invoke-RestMethod `
                -Method Post `
                -Uri "https://graph.microsoft.com/v1.0/servicePrincipals/$AgentId/appRoleAssignments" `
                -Headers $graphHeaders `
                -ContentType 'application/json' `
                -Body $body | Out-Null
            $results += [pscustomobject]@{
                PermissionSet = 'Graph'
                Role = $roleName
                Status = 'Assigned'
                Details = ''
            }
        }
        catch {
            $details = if ($_.ErrorDetails.Message) {
                $_.ErrorDetails.Message
            }
            else {
                $_.Exception.Message
            }
            $results += [pscustomobject]@{
                PermissionSet = 'Graph'
                Role = $roleName
                Status = 'Failed'
                Details = $details
            }
        }
    }
}

if ($Permissions -in @('All', 'Azure')) {
    $azureRoles = @(
        'Reader'
        'Key Vault Reader'
        'Log Analytics Reader'
        'Security Reader'
    )

    foreach ($currentSubscriptionId in $subscriptionIds) {
        $subscription = Invoke-AzJson -Arguments @(
            'account', 'show',
            '--subscription', $currentSubscriptionId,
            '--output', 'json'
        )
        if ([string]$subscription.tenantId -ne $TenantId) {
            throw "Subscription $currentSubscriptionId belongs to tenant $($subscription.tenantId), not requested tenant $TenantId."
        }

        & az account set --subscription $currentSubscriptionId
        if ($LASTEXITCODE -ne 0) {
            throw "Unable to select Azure subscription $currentSubscriptionId."
        }

        $scope = "/subscriptions/$currentSubscriptionId"
        try {
            $canWriteRoleAssignments = Test-AzureActionAllowed `
                -Scope $scope `
                -Action 'Microsoft.Authorization/roleAssignments/write'
            if (-not $canWriteRoleAssignments) {
                throw "The signed-in account does not have Microsoft.Authorization/roleAssignments/write at $scope. Assign Owner, User Access Administrator, or Role Based Access Control Administrator at this scope or a parent scope."
            }
        }
        catch {
            $results += [pscustomobject]@{
                PermissionSet = 'Azure'
                SubscriptionId = $currentSubscriptionId
                Scope = $scope
                Role = 'Role assignment preflight'
                Status = 'Failed'
                Details = $_.Exception.Message
            }
            continue
        }

        foreach ($roleName in $azureRoles) {
            try {
                $existingRoleAssignments = @(Invoke-AzJson -Arguments @(
                    'role', 'assignment', 'list',
                    '--assignee-object-id', $AgentId,
                    '--role', $roleName,
                    '--scope', $scope,
                    '--output', 'json'
                ))

                if ($existingRoleAssignments.Count -gt 0) {
                    $results += [pscustomobject]@{
                        PermissionSet = 'Azure'
                        SubscriptionId = $currentSubscriptionId
                        Scope = $scope
                        Role = $roleName
                        Status = 'Already assigned'
                        Details = ''
                    }
                    continue
                }

                Invoke-AzJson -Arguments @(
                    'role', 'assignment', 'create',
                    '--assignee-object-id', $AgentId,
                    '--assignee-principal-type', 'ServicePrincipal',
                    '--role', $roleName,
                    '--scope', $scope,
                    '--output', 'json'
                ) | Out-Null

                $results += [pscustomobject]@{
                    PermissionSet = 'Azure'
                    SubscriptionId = $currentSubscriptionId
                    Scope = $scope
                    Role = $roleName
                    Status = 'Assigned'
                    Details = ''
                }
            }
            catch {
                $results += [pscustomobject]@{
                    PermissionSet = 'Azure'
                    SubscriptionId = $currentSubscriptionId
                    Scope = $scope
                    Role = $roleName
                    Status = 'Failed'
                    Details = $_.Exception.Message
                }
            }
        }
    }
}

Write-ConsoleResults -Results $results
Write-Host

if ($results.Status -contains 'Failed') {
    exit 1
}

exit 0

Consenti l'accesso ad altri utenti

L'accesso agli agenti è controllato dai ruoli di sicurezza esistenti in Microsoft Defender. Gli utenti con ruolo con autorizzazioni di lettura per la sicurezza o amministratore della sicurezza possono visualizzare e interagire con le sessioni dell'agente dopo la configurazione dell'agente.

Avvia una sessione di Recon Agent

Per informazioni sui punti di ingresso della sessione disponibili, vedere Avviare una nuova sessione.

L'agente Recon partecipa ai seguenti playbook:

Studio	Input obbligatorio
Valutare i rischi legati all'identità	Una sottoscrizione Azure e un'identità gestita.
Identificare i percorsi di attacco	Una sottoscrizione di Azure.
Proteggere da una minaccia	Un articolo di intelligence sulle minacce.

Seguire questa procedura per avviare una sessione Di valutazione dei rischi di identità :

Nel riquadro di spostamento selezionare Sessioni di percezione>.
Selezionare Nuova sessione.

Selezionare il playbook Valutazione dei rischi di identità.

Schermata delle opzioni del playbook Project Perception per avviare una nuova sessione.

Verrà visualizzato il pannello Input aggiuntivi necessari . Sono necessari due input:

Campo	Description
Sottoscrizione di Azure	ID o nome della sottoscrizione di Azure a cui applicare la sessione. Ogni sessione è limitata a una sottoscrizione. L'amministratore preconfigura questo elenco durante l'installazione di Recon Agent ed è possibile usare solo sottoscrizioni preconfigurate.
Identità gestita	Selezionare l'identità gestita.

Schermata del playbook Valuta i rischi di identità con i relativi input di sessione richiesti.

Note

Quando configuri il playbook Identificare i percorsi di attacco, viene visualizzato un selettore di sottoscrizione per definire l'ambito della sessione. Il selettore elenca le sottoscrizioni disponibili per l'utente che ha effettuato l'accesso, non per l'applicazione Recon Agent. Per avviare il playbook, l'utente che ha effettuato l'accesso deve disporre dell'accesso in lettura all'intera sottoscrizione. Questa limitazione si applica solo all'avvio della sessione. Dopo l'avvio della sessione, l'agente di ricognizione usa la propria identità per la ricognizione.

Compilare entrambi i campi e selezionare Avvia sessione.

La sessione viene aperta con lo stato In esecuzione . L'agente mostra i suoi progressi mentre redige un elenco di attività e inizia il lavoro.

Monitorare lo stato della sessione

Durante l'esecuzione della sessione, il pannello a destra mostra:

Panoramica: mostra il riepilogo della sessione e lo stato corrente.
Avanzamento: tiene traccia dei passaggi completati. Ad esempio, il valore passa da 0/1 a 1/1 al termine dell'attività.
Recon Agent: identifica l'agente attivo per la sessione.
Input: mostra l'ambiente di destinazione e il caso d'uso specificato.
Output: elenca i file generati finora e gli aggiornamenti man mano che la sessione avanza.

Comprendere il report

Il report contiene le sezioni seguenti:

Risultati chiave: riepiloga i rischi e gli indicatori più significativi con prove di supporto, ad esempio gli indirizzi IP che ospitano contenuto dannoso e la cronologia di risoluzione DNS. Ogni ricerca viene etichettata come confermata, probabile o dedotta per indicare la forza delle prove.
Tabella dell’inventario degli asset: elenca gli asset individuati con le colonne Indicatore, Tipo, Verdetto della minaccia, Attendibilità e Primo rilevamento.
Grafico del percorso di attacco: mostra percorsi realistici che un utente malintenzionato potrebbe usare e le relazioni tra asset, identità e accesso. Ad esempio, un percorso potrebbe collegare un'organizzazione, un token di delega di un utente privilegiato e una risorsa di produzione. Se applicabile, il grafico identifica i percorsi più veloci, furtivi e più ampi.
Mappatura MITRE ATT&CK: mappa ogni risultato pertinente alle tecniche del MITRE ATT&CK. Il report classifica le tecniche applicabili, non applicabili o dati insufficienti , in modo da poter valutare la quantità di attacco coperta dai rilevamenti correnti.
Gap di copertura del rilevamento: identifica i percorsi di attacco che i rilevamenti di Defender esistenti non coprono. Laddove la copertura sia disponibile, il report comprende gli avvisi di Defender pertinenti e le query di ricerca in Kusto Query Language (KQL).

Important

Gli output di Recon Agent sono generati dall’IA e si basano sui dati disponibili tramite l’accesso in sola lettura alle API. Esaminare i risultati per verificare l'accuratezza prima di usarli per pianificare la correzione o comunicare i rischi. Il report include il banner "Il contenuto generato dall'intelligenza artificiale potrebbe non essere corretto. Verificarne l'accuratezza."

Visualizzare l'output dell'agente di riconciliazione

La sessione visualizza l'output di Recon Agent come file Markdown.

Schermata dell'output di Recon Agent visualizzato sotto forma di file Markdown in una sessione di Project Perception.

Commenti e suggerimenti

Questa pagina è stata utile?

Ultimo aggiornamento: 2026-09-11

Usare l'agente di ricognizione in Project percezione

Funzionalità principali

Perché usare l'agente di riconciliazione?

Prima di iniziare

Prerequisiti

Autorizzazioni necessarie

Autorizzazioni aggiuntive necessarie

Configurare l'agente di riconciliazione

Consenti l'accesso ad altri utenti

Avvia una sessione di Recon Agent

Monitorare lo stato della sessione

Comprendere il report

Visualizzare l'output dell'agente di riconciliazione

Contenuti correlati

Commenti e suggerimenti

Risorse aggiuntive