Utilice el Recon Agent en Project Perception

  • Se aplica a: Project Perception

Importante

Parte de la información contenida en este artículo se refiere a un producto preliminar que puede sufrir modificaciones sustanciales antes de su lanzamiento comercial. Microsoft no ofrece ninguna garantía, expresada o implícita, con respecto a la información proporcionada aquí. Project Perception está actualmente en versión preliminar pública limitada. El Programa de versión preliminar pública limitada significa que Perception está disponible para un pequeño conjunto de clientes de solo invitación para una ventana de vista previa definida antes de una disponibilidad pública más amplia.

El agente de reconocimiento de Project Perception ofrece a los equipos de seguridad y a los operadores de red team una visión del entorno de Azure desde la perspectiva de un atacante. Correlaciona recursos, identidades, permisos y exposición a la red para identificar rutas de acceso de ataque realistas, problemas de configuración y riesgos de exposición sin cambiar los recursos.

Use este artículo para comprender las funcionalidades del Agente de Recon, revisar sus requisitos previos y permisos, configurarlo, iniciar una sesión e interpretar su informe.

Principales funcionalidades

El agente Recon realiza un reconocimiento de varios pasos orquestado por IA en su entorno de Azure.

  • Evaluación de solo lectura: proporciona una evaluación de riesgos respaldada por pruebas sin cambiar los recursos.
  • Entrada para otros agentes: proporciona resultados a otros agentes, incluidos los agentes de investigación.
  • Análisis basado en el entorno: analiza solo los datos del entorno de Azure.

Nota

El Agente Recon crea una evaluación en modo de solo lectura. No aprovecha vulnerabilidades, ejecuta cargas, modifica recursos, implementa detecciones, gráficos de ataques persistentes ni funciona fuera de la organización. El agente analiza tu entorno mediante llamadas a la API de solo lectura. Los resultados son una instantánea a un momento dado y no reemplazan los sistemas de supervisión continua.

¿Por qué usar el Agente de Recon?

Seguridad de Microsoft Exposure Management identifica continuamente rutas de ataque que se originan en activos expuestos a Internet, recursos críticos e identidades confidenciales. Supervisa estos activos e identidades marcados, pero no genera rutas de acceso de ataque a partir de puntos de partida arbitrarios que no cumplen estos criterios.

El agente Recon complementa la Gestión de la Exposición con análisis de brecha asumida. Los analistas pueden empezar con cualquier recurso o identidad en una suscripción de Azure. No es necesario que los recursos se designen como críticos o expuestos a Internet, y las identidades no necesitan marcarse como confidenciales. El análisis responde a la pregunta: "Si un atacante ya controló este recurso o identidad, ¿dónde podría ir a continuación?"

Por ejemplo, un ataque de suplantación de identidad podría poner en peligro a un usuario que no está marcado como una identidad confidencial en Defender. La gestión de la exposición normalmente no genera una ruta de ataque desde ese usuario, a menos que la ruta incluya otro recurso marcado. El Recon Agent puede utilizar al usuario como punto de partida para revelar posibles puntos de pivote de los atacantes. Después, Teams puede identificar puntos de ahogamiento efectivos antes de que esas rutas de acceso lleven a incidentes que implican recursos críticos o identidades confidenciales.

Esta cobertura de punto de partida más amplia ayuda a los equipos a identificar rutas de acceso a ataques en su entorno de Azure y priorizar rutas críticas a tiempo para reducir el volumen de incidentes del Centro de operaciones de seguridad (SOC).

Caso de uso Agente de reconocimiento
Rutas de ataque desde recursos e identidades no marcados Genera rutas de ataque ante una brecha asumida a partir de cualquier recurso o identidad de una suscripción de Azure, incluidos los recursos que no están designados como críticos ni expuestos a Internet y las identidades que no están marcadas como sensibles.
Visibilidad de la postura y la exposición Interpreta esas señales en contexto y explica qué combinaciones de identidad, permiso, recurso y exposición de red crean rutas de acceso de ataque realistas.
Investigación de alertas Explica si una alerta o hallazgo forma parte de un itinerario de ataque más amplio y qué activos posteriores podrían alcanzarse.
Análisis de ruta de ataque Ejecuta análisis dirigidos y basados en sesiones, limitados a una suscripción, un grupo de recursos o un recurso crítico, y puede razonar a partir de datos ausentes, pasos fallidos y rutas inferidas.
Cobertura de detección Asigna los pasos de las rutas de ataque a las alertas existentes de Defender y a la cobertura de búsqueda de amenazas, y luego destaca aquellos puntos en los que el SOC podría carecer de visibilidad.
Priorización Prioriza las rutas y correcciones con mayor probabilidad de reducir la explotabilidad, el alcance del impacto y el impacto empresarial en el entorno seleccionado.
Planeamiento de corrección Identifica el conjunto más pequeño de cambios de alto impacto que bloquearían el mayor número de rutas de ataque y muestra qué rutas elimina cada corrección.
Facilidad de uso del analista Genera explicaciones en lenguaje claro, razonamientos fundamentados en evidencias y diagramas de rutas de ataque que son más fáciles de revisar para analistas, red teams y partes interesadas.

En resumen: Microsoft Defender productos ayudan a detectar, proteger y administrar la exposición. El Agente de Recon explica cómo un atacante podría usar esa exposición en un entorno de Azure específico y qué acciones reducirían de forma más eficaz el riesgo.

Antes de empezar

Revise los siguientes requisitos del producto y de permisos antes de configurar el Recon Agent.

Prerequisites

Para usar Recon Agent, necesitas:

  • Microsoft Entra ID P2
  • Microsoft Defender XDR
  • Microsoft Defender para la nube con el plan de Defender CSPM
  • Una suscripción de Azure

Permisos necesarios

Nivel de autorización Qué puede hacer
Administración de seguridad Instalar y configurar agentes: configure identidades y permisos de agente y quite agentes. Al menos un usuario de su organización debe tener este rol.
Lector de seguridad Uso de agentes: ver e interactuar con las sesiones de los agentes, iniciar sesiones y ver los detalles de las sesiones.

Tip

Para delegar la configuración del agente a otros usuarios, asigne el rol Administrador de seguridad. Póngase en contacto con el administrador de Microsoft Entra si necesita asignaciones de roles.

Permisos adicionales necesarios

El agente de reconocimiento requiere otros dos conjuntos de permisos para realizar tareas de reconocimiento. El usuario que concede cada conjunto de permisos necesita el rol correspondiente en la tabla siguiente.

Rol necesario para conceder permisos Permisos que conceder al agente Recon
Administrador de roles con privilegios (rol de Microsoft Entra) Permisos de Microsoft Graph API:

- User.Read.All
- Organization.Read.All
- GroupMember.Read.All
- Application.Read.All
- DelegatedPermissionGrant.Read.All
- Policy.Read.All
- RoleManagement.Read.Directory
- AuditLog.Read.All
Administrador de control de acceso basado en roles en la suscripción que constituye el entorno de destino para el agente Recon Roles del control de acceso basado en roles (RBAC) de Azure (asignados en el ámbito de la suscripción):

- Lector
- lector de Key Vault
- lector de Log Analytics
- Lector de seguridad

Configurar el agente Recon

Para configurar este agente, siga los pasos descritos en Configuración de un agente.

Nota

El Agente de Recon usa una identidad de agente en lugar de una identidad de usuario del agente. Debido a las limitaciones técnicas actuales, las identidades de usuario de agente no son compatibles con las operaciones de solo lectura de Recon Agent.

Después de crear el identificador del agente de Recon Agent, use el siguiente script para asignar los permisos enumerados en Permisos adicionales necesarios. Los parámetros de script se enumeran a continuación.

Conceder permisos de la API de Microsoft Graph y de RBAC de Azure:

Ejecute este script para conceder los permisos de aplicación de Microsoft Graph y los permisos de RBAC de Azure que necesita el agente Recon. Puede conceder a Graph, Azure o ambos permisos a través de los parámetros.

<#
.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

Permitir que otros usuarios accedan

El acceso a los agentes se controla mediante roles de seguridad existentes en Microsoft Defender. Los usuarios con el rol Lector de seguridad o Administrador de seguridad pueden ver e interactuar con las sesiones del agente una vez configurado el agente.

Iniciar una sesión de Recon Agent

Para obtener información sobre los puntos de entrada de sesión disponibles, consulte Iniciar una nueva sesión.

El Recon Agent participa en los siguientes guiones:

Playbook Entrada necesaria
Evaluación de los riesgos de identidad Una suscripción Azure e identidad administrada.
Identificación de rutas de acceso de ataque Una suscripción a Azure.
Protección contra una amenaza Un artículo de inteligencia sobre amenazas.

Siga estos pasos para iniciar una sesión de evaluación de riesgos de identidad :

  1. En el panel de navegación, seleccione Sesiones de percepción>.

  2. Seleccione Nueva sesión.

  3. Seleccione la guía Evaluar riesgos de identidad.

    Captura de pantalla de las opciones de la guía de procedimientos de Project Perception para iniciar una nueva sesión.

    Se abre el panel Entradas adicionales necesarias . Se requieren dos entradas:

    Campo Description
    Suscripción a Azure El ID o el nombre de la suscripción de Azure en la que se delimita la sesión. Cada sesión está limitada a una suscripción. El administrador preconfigura esta lista durante la instalación del Agente de recon y solo puede usar suscripciones preconfiguradas.
    Identidad administrada Seleccione la identidad administrada .

    Captura de pantalla del guion Evaluar riesgos de identidad con los datos de entrada necesarios para la sesión.

    Nota

    Al configurar la guía de estrategias Identificar rutas de ataque, aparece un selector de suscripciones para definir el ámbito de la sesión. El selector enumera las suscripciones disponibles para el usuario que ha iniciado sesión, no la aplicación Recon Agent. Para iniciar el manual de procedimientos, el usuario que ha iniciado sesión necesita acceso de lectura a la suscripción completa. Esta limitación solo se aplica cuando se inicia la sesión. Después de que se inicie la sesión, el agente Recon usa su propia identidad para el reconocimiento.

  4. Rellene ambos campos y seleccione Iniciar sesión.

La sesión se abre con un estado En ejecución . El agente muestra su progreso a medida que redacta una lista de tareas e inicia su trabajo.

Supervisión del progreso de la sesión

Mientras se ejecuta la sesión, el panel de la derecha muestra:

  • Información general: muestra el resumen de la sesión y el estado actual.
  • Progreso: realiza un seguimiento de los pasos completados. Por ejemplo, el valor cambia de 0/1 a 1/1 cuando se completa la tarea.
  • Agente Recon: identifica el agente activo de la sesión.
  • Entradas: muestra el entorno de destino y el caso de uso que proporcionó.
  • Salidas: enumera los archivos generados hasta el momento y las actualizaciones a medida que avanza la sesión.

Descripción del informe

El informe contiene las secciones siguientes:

  • Conclusiones clave: resume los riesgos e indicadores más significativos con evidencia de apoyo, como direcciones IP que hospedan contenido malintencionado y su historial de resolución de DNS. Cada hallazgo se etiqueta como confirmado, probable o inferido para indicar la fuerza de la evidencia.
  • Tabla de inventario de activos: enumera los recursos detectados con las columnas Indicador, Tipo, Veredicto de amenazas, Confianza y Primera vista.
  • Gráfico de ruta de acceso a ataques: muestra rutas de acceso realistas que un atacante podría usar y las relaciones entre los recursos, las identidades y el acceso. Por ejemplo, una ruta podría conectar una organización, el token en nombre de de un usuario con privilegios y un activo de producción. Si procede, el gráfico identifica las rutas más rápidas, sigilosas y más anchas.
  • Mapeo de MITRE ATT&CK: Asocia cada hallazgo relevante con las técnicas de MITRE ATT&CK. El informe clasifica las técnicas como aplicables, no aplicables o datos insuficientes para que pueda evaluar qué parte de la superficie de ataque cubren sus detecciones actuales.
  • Lagunas en la cobertura de detección: identifica rutas de ataque que las detecciones existentes de Defender no cubren. Cuando existe cobertura, el informe incluye las alertas de Defender pertinentes y las consultas de búsqueda del lenguaje de consulta de Kusto (KQL).

Importante

Los resultados de Recon Agent son generados por IA y se basan en los datos disponibles mediante acceso de solo lectura a la API. Revise los resultados de precisión antes de usarlos para planear la corrección o comunicar el riesgo. El informe incluye el banner "El contenido generado por IA puede ser incorrecto. Compruebe si hay precisión".

Ver la salida de Recon Agent

La sesión muestra la salida de Recon Agent como archivos Markdown.

Captura de pantalla del resultado de Recon Agent mostrado en forma de archivos Markdown en una sesión de Project Perception.

Contenido relacionado

  • Last updated on