Użyj agenta Recon w projekcie Project Perception

Agent Recon w Project Perception zapewnia zespołom ds. zabezpieczeń i operatorom red teamu widok środowiska Azure z perspektywy atakującego. Koreluje zasoby, tożsamości, uprawnienia i narażenie sieci na identyfikowanie realistycznych ścieżek ataków, problemów z konfiguracją i zagrożeń związanych z ekspozycją bez zmieniania zasobów.

Skorzystaj z tego artykułu, aby zrozumieć możliwości agenta Recon, zapoznać się z jego wymaganiami wstępnymi i uprawnieniami, skonfigurować go, rozpocząć sesję i zinterpretować jego raport.

Kluczowe możliwości

Agent Recon przeprowadza wieloetapowe rozpoznanie koordynowane przez SI w Twoim środowisku Azure.

• Ocena w trybie tylko do odczytu: zapewnia opartą na dowodach ocenę ryzyka bez wprowadzania zmian w zasobach.
• Dane wejściowe dla innych agentów: udostępnia wyniki innym agentom, w tym agentom badania.
• Analiza środowiskowa: analizuje tylko dane ze środowiska Azure.

Dlaczego warto używać agenta recon?

rozwiązania zabezpieczające firmy Microsoft Exposure Management stale identyfikuje ścieżki ataków pochodzące z zasobów uwidocznionych w Internecie, krytycznych zasobów i poufnych tożsamości. Monitoruje te oznaczone zasoby i tożsamości, ale nie generuje ścieżek ataków z dowolnych punktów początkowych, które nie spełniają tych kryteriów.

Agent Recon uzupełnia zarządzanie ekspozycją o analizę pod kątem założonego naruszenia. Analitycy mogą zacząć od dowolnego zasobu lub tożsamości w subskrypcji Azure. Zasoby nie muszą być wyznaczone jako krytyczne ani uwidocznione w Internecie, a tożsamości nie muszą być oznaczone jako poufne. Analiza odpowiada na pytanie: „Jeśli atakujący przejął już kontrolę nad tym zasobem lub tą tożsamością, dokąd mógłby przenieść się dalej?”

Na przykład atak wyłudzający informacje może naruszyć bezpieczeństwo użytkownika, który nie jest oznaczony jako tożsamość wrażliwa w Defender. Zarządzanie ekspozycjami zwykle nie generuje ścieżki ataku od tego użytkownika, chyba że ścieżka zawiera inny oznaczony zasób. Agent Recon może wykorzystać użytkownika jako punkt wyjścia do wykrywania potencjalnych ścieżek dalszego przemieszczania się atakującego. Zespoły mogą następnie identyfikować newralgiczne punkty, zanim ścieżki te doprowadzą do incydentów związanych z krytycznymi zasobami lub wrażliwymi tożsamościami.

Szerszy zakres punktów początkowych pomaga zespołom identyfikować ścieżki ataku w całym środowisku Azure i odpowiednio wcześnie nadawać priorytet ścieżkom krytycznym, aby zmniejszyć liczbę incydentów obsługiwanych przez centrum operacji zabezpieczeń (SOC).

Krótko mówiąc: Microsoft Defender produkty pomagają wykrywać, chronić i zarządzać ekspozycją. Agent recon wyjaśnia, w jaki sposób osoba atakująca może użyć tej ekspozycji w określonym środowisku Azure i które działania najbardziej skutecznie zmniejszyłyby ryzyko.

Zanim rozpoczniesz

Przed skonfigurowaniem agenta recon zapoznaj się z następującymi wymaganiami dotyczącymi produktu i uprawnień.

Wymagania wstępne

Aby korzystać z agenta Recon, potrzebujesz:

• Tożsamość Microsoft Entra P2
• Microsoft Defender XDR
• Microsoft Defender dla Chmury z planem CSPM w usłudze Defender
• Subskrypcja platformy Azure

Wymagane uprawnienia

Wymagane dodatkowe uprawnienia

Agent Recon wymaga jeszcze dwóch zestawów uprawnień do przeprowadzenia rekonesansu. Użytkownik, który przyznaje każdemu zestawowi uprawnień, potrzebuje odpowiedniej roli w poniższej tabeli.

Skonfiguruj agenta Recon

Aby skonfigurować tego agenta, wykonaj kroki opisane w temacie Konfigurowanie agenta.

Po utworzeniu identyfikatora agenta Recon Agent użyj poniższego skryptu, aby przypisać uprawnienia wymienione w Wymagane dodatkowe uprawnienia. Poniżej wymieniono parametry skryptu.

Przyznaj uprawnienia Microsoft interfejs Graph API i Azure RBAC:

Uruchom ten skrypt, aby nadać uprawnienia aplikacji Microsoft Graph oraz uprawnienia RBAC platformy Azure wymagane przez agenta Recon. Za pomocą parametrów możesz nadać uprawnienia do usługi Graph, platformy Azure lub obu.

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

Zezwalaj innym użytkownikom na dostęp

Dostęp do agentów jest kontrolowany przez istniejące role zabezpieczeń w Microsoft Defender. Użytkownicy z rolą Czytelnik zabezpieczeń lub Administrator zabezpieczeń mogą wyświetlać sesje agentów i korzystać z nich po skonfigurowaniu agenta.

Uruchom sesję agenta Recon

Aby uzyskać informacje o dostępnych punktach wejścia sesji, zobacz Rozpoczynanie nowej sesji.

Agent Recon uczestniczy w następujących playbookach:

Wykonaj następujące kroki, aby rozpocząć sesję Ocenianie ryzyka tożsamości :

1. W panelu nawigacji wybierz pozycję Percepcja>Sesje.

2. Wybierz pozycję Nowa sesja.

3. Wybierz podręcznik Ocenianie zagrożeń związanych z tożsamością .

   

   Zostanie otwarty panel Wymagane dodatkowe dane wejściowe. Wymagane są dwa dane wejściowe:

   Pole	Description
   Subskrypcja platformy Azure	Identyfikator lub nazwa subskrypcji Azure do ograniczenia zakresu sesji. Każda sesja jest ograniczona do jednej subskrypcji. Administrator wstępnie konfiguruje tę listę podczas konfigurowania agenta recon i można używać tylko wstępnie skonfigurowanych subskrypcji.
   Tożsamość zarządzana	Wybierz tożsamość zarządzaną.

   

   Note

   Po skonfigurowaniu podręcznika Identyfikowanie ścieżek ataków zostanie wyświetlony selektor subskrypcji definiujący zakres sesji. Selektor wyświetla subskrypcje dostępne dla zalogowanego użytkownika, a nie dla aplikacji Recon Agent. Aby uruchomić podręcznik, zalogowany użytkownik musi mieć dostęp do odczytu do całej subskrypcji. To ograniczenie ma zastosowanie tylko wtedy, gdy rozpoczyna się sesja. Po rozpoczęciu sesji agent Recon używa własnej tożsamości do rozpoznania.

4. Wypełnij pola i wybierz pozycję Rozpocznij sesję.

Sesja otwiera się w stanie Uruchomiona. Agent pokazuje postęp, gdy projektuje listę zadań i rozpoczyna pracę.

Monitorowanie postępu sesji

Gdy sesja jest uruchomiona, panel po prawej stronie pokazuje:

• Przegląd: pokazuje podsumowanie sesji i bieżący stan.
• Postęp: śledzi ukończone kroki. Na przykład wartość zmienia się z 0/1 na 1/1 po zakończeniu zadania.
• Agent rozpoznawczy: Identyfikuje aktywnego agenta w sesji.
• Dane wejściowe: przedstawia podane środowisko docelowe i przypadek użycia.
• Dane wyjściowe: wyświetla listę plików wygenerowanych do tej pory i aktualizacje w miarę postępu sesji.

Omówienie raportu

Raport zawiera następujące sekcje:

• Kluczowe ustalenia: podsumowuje najważniejsze czynniki ryzyka i wskaźniki z dowodami pomocniczymi, takimi jak adresy IP hostujące złośliwą zawartość i historię rozpoznawania nazw DNS. Każde stwierdzenie jest oznaczone etykietą potwierdzoną, prawdopodobną lub wywnioskowaną , aby wskazać siłę dowodów.
• Tabela zasobów: zawiera listę wykrytych zasobów z kolumnami Wskaźnik, Typ, Werdykt zagrożenia, Poziom pewności i Po raz pierwszy zaobserwowany.
• Wykres ścieżki podatnej na ataki: przedstawia realistyczne ścieżki, których osoba atakująca może użyć, oraz relacje między elementami zawartości, tożsamościami i dostępem. Na przykład ścieżka może łączyć organizację, token dostępu działający w imieniu uprzywilejowanego użytkownika oraz zasób produkcyjny. W stosownych przypadkach wykres identyfikuje najszybsze, niewidzialne i najszersze trasy.
• Mapowanie MITRE ATT&CK: przypisuje każde istotne ustalenie do technik MITRE ATT&CK. Raport klasyfikuje techniki, które mają zastosowanie, nie dotyczy lub niewystarczających danych , dzięki czemu można ocenić, jaka część ataku obejmuje bieżące wykrycia.
• Luki w pokryciu wykrywania: Identyfikuje ścieżki ataku, które nie są objęte przez istniejące mechanizmy wykrywania w Defenderze. Tam, gdzie jest to obsługiwane, raport zawiera odpowiednie alerty usługi Defender oraz zapytania języka Kusto Query Language (KQL) do wyszukiwania zagrożeń.

Wyświetl wynik agenta Recon

Sesja wyświetla dane wyjściowe agenta recon jako pliki Markdown.

Treści powiązane

• Co to jest Project Perception?
• Poznaj kluczowe pojęcia w Project Perception
• Praca z agentami
• Monitorowanie sesji agentów i zarządzanie nimi
• Agent analizy ataków
• Agent klasyfikacji