← All hunts medium TLP:CLEAR

Managed Access and Tenant Integrity

An adversary has established persistence via cross-tenant delegated administration or unattended remote support, subsequently deploying autonomous agents that communicate through multi-hop proxies.

Based on research by Microsoft 2026-09-20 12 steps · 5 queries T1059 T1078.004 T1090.003 T1219

Brief

Why this hunt

Cloud tenant boundaries often rely on the integrity of delegated administration and remote support features. Recent updates in What’s new in Microsoft Security: August 2026 highlight the evolving ways adversaries exploit these features. Traditional detections often miss the slow transition from a legitimate cross-tenant login to the deployment of autonomous automation agents. This hunt provides a structured way to validate those boundaries.

How the Hunt Flows

The hunt begins by narrowing the focus to endpoints with specific management software. An analyst first queries the software inventory for Microsoft Intune or Remote Help installations. This ensures subsequent behavioral checks target the most relevant assets where unattended support is most likely to be active.

Next, the hunt enters a parallel phase to evaluate access and persistence. One branch looks for rare sign-ins from external identity providers, specifically focusing on providers where an adversary might operate a shadow tenant. Simultaneously, the hunt examines process activity for remote support binaries like Quick Assist or Remote Help. An automated agent then triages these findings to find hosts where a new external login correlates with the execution of a support tool.

Following the identification of suspicious persistence, the hunt shifts to behavioral analysis. It scans script activity logs for keywords associated with autonomous agent frameworks, such as LangChain or AutoGen. In parallel, it inspects DNS activity for lookups involving .onion domains or public web-to-Tor proxy relays. These indicators suggest the presence of a C2 channel that attempts to obfuscate its destination via multi-hop routing.

Finally, a synthesis step combines the persistence evidence with the observed execution and network patterns. If the results show a clear chain from external access to autonomous script behavior, the analyst moves to isolate the host and revoke involved identity sessions.

Blind Spots and Limitations

Analysts must account for potential gaps in visibility. Script activity logs may suffer from session truncation, which can hide the full parameters of an agent script or its final exfiltration targets. Additionally, this hunt focuses on the activity following a configuration change. It does not audit the Entra ID configuration logs themselves to determine which specific policy change enabled the initial cross-tenant access. This hunt detects the aftermath, not the administrative setup.

Run the Hunt

This hunt is available as an open hunt.md playbook. You can import it directly into Huntbase or any runtime that supports the hunt.md specification. Because this process correlates data across identity, process, and network surfaces, it functions as a hunt rather than a single detection rule. It builds the necessary behavioral context to confirm a sophisticated persistence chain.

Steps

  1. Identify managed support assets

    Query · scoping

    Find hosts where Intune or remote-support tools are installed to scope the behavior hunt.

    reads hb_software_inventorysql
    SELECT device_hostname, package_name, package_version FROM hb_software_inventory WHERE (LOWER(package_name) LIKE '%intune%' OR LOWER(package_name) LIKE '%remote help%') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0)

    What a hit looks like. A list of hosts running managed support software. Silence means no such software is inventoried.

  2. Unusual cross-tenant sign-ins

    Query · baseline

    Find rare sign-ins from integrated third-party providers where an adversary may operate shadow tenants.

    reads hb_auth_signinsql
    SELECT actor_user_name, provider, COUNT(DISTINCT dst_endpoint_name) AS host_count, MIN(time) AS first_seen, MAX(time) AS last_seen FROM hb_auth_signin WHERE instr(',' || '{{third_party_providers}}' || ',', ',' || LOWER(provider) || ',') > 0 AND time >= datetime('now', '-{{lookback_days}} days') GROUP BY actor_user_name, provider HAVING host_count <= 3

    What a hit looks like. Rare sign-ins to specific hosts from external providers. Silence means no such sign-ins were recorded.

  3. Unattended remote support activity

    Query · detection candidate

    Identify remote support sessions launched on endpoints, focusing on those that bypass user confirmation.

    reads hb_process_activitysql
    SELECT device_hostname, process_name, process_cmd_line, user_name, time FROM hb_process_activity WHERE (LOWER(process_name) LIKE '%remotehelp%' OR LOWER(process_name) LIKE '%quickassist%' OR LOWER(process_name) LIKE '%remotesignin%') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')

    What a hit looks like. Process logs for remote support binaries. Silence suggests no such sessions occurred on the scoped hosts.

  4. Triage early access evidence

    Agent triage

    Determine if third-party sign-ins correlate with unattended support activity.

  5. Autonomous agent script execution

    Query · triage

    Identify AI-agent framework keywords in script blocks executed after the suspected access events.

    reads hb_script_activitysql
    SELECT device_hostname, script_content, actor_user_name, time FROM hb_script_activity WHERE (LOWER(script_content) LIKE '%langchain%' OR LOWER(script_content) LIKE '%autogen%' OR LOWER(script_content) LIKE '%openai%' OR LOWER(script_content) LIKE '%agent%') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')

    What a hit looks like. Script contents suggesting autonomous automation or agent-driven logic. Silence means no matching keywords were captured.

  6. Multi-hop proxy DNS lookups

    Query · enrichment

    Identify DNS lookups for .onion domains or known public web-to-Tor proxy relays.

    reads hb_dns_activitysql
    SELECT device_hostname, query_hostname, time FROM hb_dns_activity WHERE (LOWER(query_hostname) LIKE '%.onion' OR instr(',' || '{{proxy_relay_suffixes}}' || ',', ',' || LOWER(query_hostname) || ',') > 0) AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')

    What a hit looks like. DNS queries targeting obfuscation infrastructure. Silence provides evidence of absence for these specific domains.

  7. Final synthesis of agent behavior

    Agent triage

    Synthesize early access findings with follow-on execution and network activity.

  8. Route on verdict

    Decision

    Determine whether to contain the host based on the synthesized agent verdict.

  9. Isolate host

    Response action

    Contain the threat by isolating the affected endpoint.

  10. Analyst review

    Analyst task

    Provide human oversight to confirm the autonomous behavior is unauthorized.

  11. Close out

    Analyst task

    Document the hunt outcome and record false positives.

Coverage

Scenario coverage

StageCoveredHow, or why not
Cross-Tenant Identity Manipulation
T1078.004
Yes unusual-cross-tenant-signins
Unattended Support Session Abuse
T1219
Yes unattended-remote-support
Unauthorized AI Agent Activity
T1059
Yes autonomous-agent-scripts
Obfuscated C2 via Multi-hop Proxy
T1090.003
Yes multi-hop-proxy-dns

Blind spots

  • Needs untruncated hb_script_activity logs. Large scripts may be truncated, hiding the final C2 destinations or specific data exfiltration targets. It would answer What were the full operational parameters of the agent script?.
  • Needs Entra ID configuration audit logs. We see the sign-in (aftermath) but not the initial policy manipulation that enabled the persistent access. It would answer Which specific configuration change enabled the unauthorized cross-tenant sign-in?.

Parameters & data

Parameters

ParameterTypeDefaultWhat it is
lookback_daysnumber14Days of history to examine.
proxy_relay_suffixeslist[domain]tor2web.org, onion.pet, onion.ws, onion.linkKnown public web-to-Tor proxy relay suffixes.
scope_hostslist[host]Optional list of hostnames to focus the hunt; leave empty to scan the entire estate.
third_party_providerslist[string]aws, okta, palo altoIdentity or security providers expected to show external actor activity.

Telemetry

SourceCategoryTelemetry
Endpoint telemetry (hb_ surfaces)endpointendpoint
Identity / sign-in telemetryidentityidentity

Source

Download hunt.md Definition (JSON) An open hunt.md file; it runs anywhere that reads the format.
---
analysis: A single rule cannot correlate a third-party sign-in, an unattended remote
  support session, and autonomous script behavior. This hunt uses a phased flow to
  build behavioral context across identity, process, and script surfaces.
blind_spots:
- id: session-truncation
  question: What were the full operational parameters of the agent script?
  requires: untruncated hb_script_activity logs
  risk: Large scripts may be truncated, hiding the final C2 destinations or specific
    data exfiltration targets.
  stage: autonomous-agent-execution
- id: no-policy-audit
  question: Which specific configuration change enabled the unauthorized cross-tenant
    sign-in?
  requires: Entra ID configuration audit logs
  risk: We see the sign-in (aftermath) but not the initial policy manipulation that
    enabled the persistent access.
  stage: tenant-governance-abuse
coverage:
- stage: tenant-governance-abuse
  status: covered
  steps:
  - unusual-cross-tenant-signins
- stage: remote-support-persistence
  status: covered
  steps:
  - unattended-remote-support
- stage: autonomous-agent-execution
  status: covered
  steps:
  - autonomous-agent-scripts
- stage: multi-hop-proxy-c2
  status: covered
  steps:
  - multi-hop-proxy-dns
guardrails:
  claims: no_unsupported
  evidence: citation_required
  missing_data: not_benign
  telemetry: untrusted
hunt:
  applicability: campaign-specific
  handoff: promote-to-detection
  justification: Protecting tenant boundaries and ensuring remote support tools are
    not abused is a critical security obligation as organizations adopt autonomous
    AI agents.
  methodology: model-assisted
  trigger: intel-report
hypothesis: An adversary has established persistence via cross-tenant delegated administration
  or unattended remote support, subsequently deploying autonomous agents that communicate
  through multi-hop proxies.
labels:
- hunt
- attack.t1078.004
- attack.t1219
- attack.t1059
- attack.t1090.003
name: Managed Access and Tenant Integrity
parameters:
  lookback_days:
    default: '14'
    description: Days of history to examine.
    from:
      kind: manual
      observed: '2026-08-27'
      ref: standard-retention
    type: number
  proxy_relay_suffixes:
    default:
    - tor2web.org
    - onion.pet
    - onion.ws
    - onion.link
    description: Known public web-to-Tor proxy relay suffixes.
    from:
      kind: manual
      observed: '2026-08-27'
      ref: known-tor-relays
    type: list[domain]
  scope_hosts:
    default: []
    description: Optional list of hostnames to focus the hunt; leave empty to scan
      the entire estate.
    from:
      kind: manual
      observed: '2026-08-27'
      ref: analyst-scoping
    type: list[host]
  third_party_providers:
    default:
    - aws
    - okta
    - palo alto
    description: Identity or security providers expected to show external actor activity.
    from:
      kind: article
      observed: '2026-08-27'
      ref: msrc-blog-aug-2026
    type: list[string]
provenance:
  authors:
  - name: Huntbase hunt generation
    org: huntbase.io
  generated:
    by: huntbase-hunt-generation
    from: https://www.microsoft.com/en-us/security/blog/2026/08/27/whats-new-in-microsoft-security-august-2026/
    gates:
    - dry-run
    - lint
    model: hb_google/gemini-3-flash-preview
rationale: The hunt begins by identifying hosts with Intune-managed support software
  to narrow the behavioral scope, then pivots to global identity logs.
references:
- name: "What\u2019s new in Microsoft Security: August 2026"
  url: https://www.microsoft.com/en-us/security/blog/2026/08/27/whats-new-in-microsoft-security-august-2026/
related:
- hunt: shadow-tenant-discovery
  reason: This hunt focuses on the abuse of existing cross-tenant access, not the
    initial creation of shadow tenants.
  relation: out-of-scope-alternative
scenario:
  stages:
  - name: Cross-Tenant Identity Manipulation
    observables:
    - Shadow-tenant creation or discovery
    - Unauthorized cross-tenant delegated administration
    - Identity policy configuration drift in Entra ID
    - Sign-ins from unmanaged or third-party tenants
    slug: tenant-governance-abuse
    tactic: persistence
    techniques:
    - T1078.004
  - name: Unattended Support Session Abuse
    observables:
    - Windows Unattended Support with Remote Sign-In sessions without user interaction
    - Unauthorized device renames via Windows Autopilot device association
    - Remote sessions bypassing compliance checks
    - Intune-initiated remote support binary execution
    slug: remote-support-persistence
    tactic: persistence
    techniques:
    - T1219
  - name: Unauthorized AI Agent Activity
    observables:
    - AI agent-initiated actions without explicit user approval
    - Autonomous agent script execution
    - Usage of high-privilege permissions by agentic identities
    - Agent-driven process launches on endpoints
    slug: autonomous-agent-execution
    tactic: execution
    techniques:
    - T1059
  - name: Obfuscated C2 via Multi-hop Proxy
    observables:
    - DNS queries for .onion domains
    - Network connections to Tor onion routing nodes
    - Chained proxy traffic originating from autonomous processes
    - Traffic to known multi-hop proxy exit points
    slug: multi-hop-proxy-c2
    tactic: command-and-control
    techniques:
    - T1090.003
  summary: This campaign involves the compromise of cloud identity foundations and
    the abuse of administrative remote management features to maintain persistence.
    Adversaries leverage autonomous AI agents to execute unauthorized actions and
    employ multi-hop proxies to obfuscate command-and-control traffic across hybrid
    environments.
severity: medium
targets:
  analyst:
    name: Tier-2 analyst
    role: analyst
  endpoint:
    category: endpoint
    name: Endpoint telemetry (hb_ surfaces)
    telemetry:
    - endpoint
  hunter:
    agent: true
    name: Hunt agent
  identity:
    category: identity
    name: Identity / sign-in telemetry
    telemetry:
    - identity
tlp: clear
type: investigation
---


# Managed Access and Tenant Integrity

This hunt validates tenant boundaries and the integrity of remote access features. It identifies unauthorized cross-tenant sign-ins, abuses of Windows Unattended Support sessions, and autonomous agent behavior that uses multi-hop proxies for command-and-control. The phased flow correlates early access and persistence indicators with follow-on execution and network obfuscation.

## scope-managed-endpoints
<!-- Identify managed support assets -->
Find hosts where Intune or remote-support tools are installed to scope the behavior hunt.

```sqlite target=endpoint role=scoping params=(scope_hosts=scope_hosts)
~~~yaml
expected: A list of hosts running managed support software. Silence means no such
  software is inventoried.
reads:
- device_hostname
- package_name
- package_version
silence: not_evidence_of_absence
source: hb_software_inventory
verified: dry-run
verified_at: '2026-09-20'
~~~
SELECT device_hostname, package_name, package_version FROM hb_software_inventory WHERE (LOWER(package_name) LIKE '%intune%' OR LOWER(package_name) LIKE '%remote help%') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0)
```

## parallel-access-persistence
<!-- Analyze early stage access and persistence -->
parallel:
- → unusual-cross-tenant-signins
- → unattended-remote-support
join: → agent-early-triage

## unusual-cross-tenant-signins
<!-- Unusual cross-tenant sign-ins -->
Find rare sign-ins from integrated third-party providers where an adversary may operate shadow tenants.

```sqlite target=identity role=baseline params=(third_party_providers=third_party_providers, lookback_days=lookback_days)
~~~yaml
baseline:
  compare: first_seen
  window: '{{lookback_days}}d'
expected: Rare sign-ins to specific hosts from external providers. Silence means no
  such sign-ins were recorded.
prevalence:
  by: dst_endpoint_name
  key:
  - actor_user_name
  - provider
  rare_below: 3
reads:
- actor_user_name
- provider
- dst_endpoint_name
- time
silence: evidence_of_absence
source: hb_auth_signin
verified: dry-run
verified_at: '2026-09-20'
~~~
SELECT actor_user_name, provider, COUNT(DISTINCT dst_endpoint_name) AS host_count, MIN(time) AS first_seen, MAX(time) AS last_seen FROM hb_auth_signin WHERE instr(',' || '{{third_party_providers}}' || ',', ',' || LOWER(provider) || ',') > 0 AND time >= datetime('now', '-{{lookback_days}} days') GROUP BY actor_user_name, provider HAVING host_count <= 3
```

## unattended-remote-support
<!-- Unattended remote support activity -->
Identify remote support sessions launched on endpoints, focusing on those that bypass user confirmation.

```sqlite target=endpoint role=detection-candidate params=(scope_hosts=scope_hosts, lookback_days=lookback_days)
~~~yaml
expected: Process logs for remote support binaries. Silence suggests no such sessions
  occurred on the scoped hosts.
reads:
- device_hostname
- process_name
- process_cmd_line
- user_name
- time
silence: not_evidence_of_absence
source: hb_process_activity
verified: dry-run
verified_at: '2026-09-20'
~~~
SELECT device_hostname, process_name, process_cmd_line, user_name, time FROM hb_process_activity WHERE (LOWER(process_name) LIKE '%remotehelp%' OR LOWER(process_name) LIKE '%quickassist%' OR LOWER(process_name) LIKE '%remotesignin%') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')
```

## agent-early-triage
<!-- Triage early access evidence -->
```agent target=hunter
cite: required
context:
- unusual-cross-tenant-signins
- unattended-remote-support
max_iterations: 4
objective: Identify hosts where a third-party sign-in was followed by the execution
  of a remote support binary, citing temporal and user overlap.
success_criteria: Confirm malicious or suspicious persistence indicators per host.
tools:
- endpoint
- identity
```

## parallel-follow-on
<!-- Analyze post-persistence agent behavior -->
parallel:
- → autonomous-agent-scripts
- → multi-hop-proxy-dns
join: → agent-final-synthesis

## autonomous-agent-scripts
<!-- Autonomous agent script execution -->
Identify AI-agent framework keywords in script blocks executed after the suspected access events.

```sqlite target=endpoint role=triage params=(scope_hosts=scope_hosts, lookback_days=lookback_days)
~~~yaml
expected: Script contents suggesting autonomous automation or agent-driven logic.
  Silence means no matching keywords were captured.
reads:
- device_hostname
- script_content
- actor_user_name
- time
silence: not_evidence_of_absence
source: hb_script_activity
verified: dry-run
verified_at: '2026-09-20'
~~~
SELECT device_hostname, script_content, actor_user_name, time FROM hb_script_activity WHERE (LOWER(script_content) LIKE '%langchain%' OR LOWER(script_content) LIKE '%autogen%' OR LOWER(script_content) LIKE '%openai%' OR LOWER(script_content) LIKE '%agent%') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')
```

## multi-hop-proxy-dns
<!-- Multi-hop proxy DNS lookups -->
Identify DNS lookups for .onion domains or known public web-to-Tor proxy relays.

```sqlite target=endpoint role=enrichment params=(proxy_relay_suffixes=proxy_relay_suffixes, scope_hosts=scope_hosts, lookback_days=lookback_days)
~~~yaml
expected: DNS queries targeting obfuscation infrastructure. Silence provides evidence
  of absence for these specific domains.
reads:
- device_hostname
- query_hostname
- time
silence: evidence_of_absence
source: hb_dns_activity
verified: dry-run
verified_at: '2026-09-20'
~~~
SELECT device_hostname, query_hostname, time FROM hb_dns_activity WHERE (LOWER(query_hostname) LIKE '%.onion' OR instr(',' || '{{proxy_relay_suffixes}}' || ',', ',' || LOWER(query_hostname) || ',') > 0) AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')
```

## agent-final-synthesis
<!-- Final synthesis of agent behavior -->
```agent target=hunter
cite: required
context:
- agent-early-triage
- autonomous-agent-scripts
- multi-hop-proxy-dns
max_iterations: 5
objective: Determine if any host identified as suspicious in the access phase also
  exhibits autonomous script execution or proxy-related DNS lookups.
success_criteria: A final verdict citing the correlated chain of events across all
  surfaces.
tools:
- endpoint
- identity
```

## route-on-verdict
<!-- Route on verdict -->
if~: "the final synthesis verdict is malicious for at least one host" (confidence: high, judge=hunter)
then: → isolate-host
indeterminate: → analyst-review
unavailable: → analyst-review (blind_spot: session-truncation)
else: → close-out

## isolate-host
<!-- Isolate host -->
```action target=endpoint
~~~yaml
approval: required
~~~
Isolate the host identified by the agent and revoke any active third-party provider sessions for the involved identity.
```
→ analyst-review

## analyst-review
<!-- Analyst review -->
```manual target=analyst
Review the script contents and process command lines cited by the agent. Verify if the automation matches any approved administrative scripts or AI agent deployments.
```
→ close-out

## close-out
<!-- Close out -->
```manual target=analyst
Document the identified indicators and any legitimate automation scripts to be added to the exclusions list.
```
→ end

Run it

Take this hunt into your environment.

Open it in Huntbase to run every step against your own connections, with Scout weighing the evidence and your analysts in command. Or take the open hunt.md file anywhere that reads the format.

Machine-drafted by huntbase-hunt-generation using hb_google/gemini-3-flash-preview, gated by dry-run, lint, then reviewed by a person.