ARTEX Is Already Knocking on Your Door: What's Documented and How to Defend Against It

ARTEX AI Cyber Attacks: What’s Happening and How to Defend Against Them

👁35views

ARTEX is an AI pentest framework that reporting from CrowdStrike, Microsoft and Check Point says has been used in live intrusions. It automates reconnaissance, exploitation and credential attacks cheaply and at scale. The reports confirm real attacks but not universal use, so teams should plan for it and check their own exposure.

ARTEX AI Cyber Attacks: What’s Happening and How to Defend Against ThemAndrew Baker's Technology Blog Posts, 17/Nov/2026
https://andrewbaker.ninja/2026/11/17/artex-ai-cyber-attacks-whats-happening-and-how-to-defend-against-them/

Article Summary
  • 1.
    What it is
    ARTEX attacks are documented in reporting from CrowdStrike, Microsoft and Check Point, including VAPOR PANDA targeting more than 200 organisations in at least 14 countries. The article separates confirmed activity from uncertain attribution and single source figures.
  • 2.
    Why it matters
    Treating ARTEX as active and widespread enough to plan for lets security teams check their own exposure instead of assuming safety. The article argues that hardening the basics remains the best defence, because the automation chains familiar weaknesses quickly.
  • 3.
    Key takeaway
    ARTEX does not invent new weaknesses, it chains known ones in minutes at a reported campaign cost of about $145 to $1,500, so basic hardening still works.
3,881 words · ~20 min read
Listen to this article0 plays

AI pentest frameworks were built to help red teams move faster, and ARTEX is what happens when that same automation ends up in the hands of intruders. In the space of two months, CrowdStrike, Microsoft, Check Point and SentinelOne have documented it in live intrusions by China nexus espionage groups and by criminal crews, against hundreds of organisations across at least 14 countries, and on November 13 the FBI issued a flash alert warning that multiple threat actors have been using it since at least August 2026.

My message to every security team is simple: plan as though ARTEX style automation is already probing you. Nobody can prove that you specifically have been touched, but this tooling exists so that one operator can sweep hundreds of targets at once for the price of a decent dinner, and internet facing systems get swept whether anyone chose them or not. The rest of this post explains what ARTEX is, what has actually been documented, and how to defend against it, with all of the configuration and scripts collected in a technical appendix at the end.

1. What ARTEX Is

ARTEX is an open source, multi agent penetration testing framework published on GitHub on July 26 2026 by an independent developer using the handle Autumn-27, under the AGPL-3.0 licence. It was built as a legitimate tool for testing systems you own or are authorised to test, and the same developer’s asset discovery platform, ScopeSentry, provides its reconnaissance foundation. As far as I can find, the project has never publicly explained what the name stands for.

Technically, it’s a single Go binary with an embedded Next.js web interface, PostgreSQL for state, and mitmproxy recording every HTTP request the agents make. You give it a goal in plain language; a planner agent breaks that goal into tasks and dispatches them to worker agents (three per task by default) that run real tools in parallel and record what they find in a shared graph of assets and findings. It works with Anthropic, OpenAI and local Ollama models out of the box, and attackers have been seen configuring it with DeepSeek, GLM and Grok through OpenAI compatible gateways.

It spread fast. Trade press reported more than 12,000 GitHub forks within weeks, and after reporting of its criminal use, the developer made the project closed source on October 8. That didn’t slow adoption: maintained forks such as ScopeWeaver and ARTEX PRO, archived copies and a commercial version remain available, and SentinelOne notes that creation of new ARTEX command servers actually spiked in mid October as the reporting peaked. In other words, the tool is out and it isn’t going back in the box.

2. What’s Been Documented

CrowdStrike’s October 29 report says VAPOR PANDA, a China nexus espionage group it has tracked since 2021, used ARTEX against more than 200 organisations in at least 14 countries over an eleven day window from October 17. CrowdStrike presents the link to VAPOR PANDA as an assessment rather than a certainty, and it separates targeting from compromise: post exploitation was confirmed at nine organisations, including deployment of the BLOODALCHEMY backdoor. None of the intrusion paths it describes needed a novel exploit. At one US pharmaceutical company the agent chained an unsigned SAML assertion with an XML external entity flaw to reach the cloud instance metadata service, obtained a role that could issue administration commands to thousands of instances, and escalated to an enterprise administrator account. At a Greek government entity, the path reportedly turned on authentication keys from an old mail server export that had never been rotated.

Microsoft attributes the October 2026 ConnectWise Cloud Backup supply chain compromise to Storm-0940, a China state aligned actor. Using credentials for the multitenant ConnectWise applications, the attackers used ARTEX to attempt sign ins to more than 2,250 downstream Microsoft 365 tenants at up to 2,900 attempts per minute, and in some environments went on to modify application credentials for persistence. CrowdStrike assesses this as a separate campaign from VAPOR PANDA, which suggests the framework is spreading across multiple actors.

In South Korea, CrowdStrike’s October 7 report describes an as yet unattributed actor using ARTEX alongside several language models against South Korean financial organisations between late September and early October 2026, resulting in exfiltrated data. Check Point’s research covers criminal crews using it against iOS app signing providers, cryptocurrency services and gaming account marketplaces, and counted more than 1,600 live, publicly reachable ARTEX control panels. Censys separately counts roughly 1,465 exposed ARTEX consoles, 32 of them with open directories of attack tooling.

Sources do disagree on some figures. One “140 compromises” number appears only in a single write up and doesn’t match CrowdStrike’s own count of nine confirmed, so I wouldn’t lean on it.

3. Why It Changes the Economics, and What It Doesn’t Change

Check Point read the databases of ten misconfigured ARTEX servers and estimated that the individual campaigns it observed cost roughly $145 to $1,500 each in model time. Those are estimates for specific campaigns, not a price for compromising hundreds of organisations, but they tell you the marginal cost of pointing this tooling at one more target is close to nothing. The skill floor drops too: in several campaigns nobody prompted the agents again after the operator set the initial goals, and Microsoft reports that in some Storm-0940 cases the attackers went from initial targeting to privileged cloud access in under three hours, far inside most organisations’ response times.

It’s equally important not to overstate this. Check Point documented a campaign aimed at direct financial profit that produced nothing the attacker could actually spend, and agents whose confident progress reports didn’t survive contact with reality. ARTEX makes attackers faster and broader, not infallible, and almost everything it exploits is a familiar weakness that defenders already know how to fix.

4. If You Can’t See It, Prove That You Could

This is the point most teams will get wrong. Automated reconnaissance is noisy at scale but quiet per target: a few requests against your admin panels, a handful of failed logins spread thinly across many accounts, some oddly encoded URLs your WAF waved through. None of that trips a traditional alert on its own. CrowdStrike’s reporting makes the point sharply, because the VAPOR PANDA operator told the agents to go looking for Windows hosts that had no EDR sensor installed. Attackers are deliberately hunting for the places you can’t see.

So before you conclude that you haven’t been targeted, test whether you would know. Can you list every internet facing asset you own? Can you say how many failed logins hit your directory last week, from where, and across how many accounts? Can you see one internal machine connecting to fifty others? Can you name every Windows host without an EDR sensor? A quiet dashboard only means something if you can show it would have caught this activity in the first place; if you can’t, the honest conclusion isn’t “we’re not a target”, it’s “we wouldn’t know”.

5. The Attack Chain and How to Break It

The documented intrusions follow a familiar shape, just executed faster and across more targets at once. The diagram maps each stage to the defence subsection that breaks it.

flowchart LR
    A["Reconnaissance<br/>exposed apps, admin panels,<br/>leaked secrets"]:::attack --> B["Initial access<br/>known CVEs, WAF evasion,<br/>password spraying,<br/>vendor app, unsigned SAML"]:::attack
    B --> C["Cloud escalation<br/>instance metadata,<br/>over privileged roles"]:::attack
    B --> D["Internal discovery<br/>network scanning,<br/>hosts without EDR"]:::attack
    C --> E["Credential harvest<br/>LAPS passwords,<br/>old unrotated keys"]:::attack
    D --> E
    E --> F["Persistence<br/>BLOODALCHEMY,<br/>new app credentials"]:::attack
    F --> G["C2 and exfiltration"]:::attack

    A -.- DA["5.1 Patch KEV,<br/>remove admin panels"]:::defend
    B -.- DB["5.2 WAF normalisation<br/>5.3 MFA, spray detection<br/>5.7 Vendor access"]:::defend
    C -.- DC["5.6 SAML validation,<br/>IMDSv2, scoped roles"]:::defend
    D -.- DD["5.4 Segmentation,<br/>scan detection"]:::defend
    E -.- DE["5.6 Key rotation,<br/>LAPS auditing"]:::defend
    F -.- DF["5.5 EDR coverage,<br/>persistence audits"]:::defend
    G -.- DG["5.8 Automated containment,<br/>6 IOC hunting"]:::defend

    classDef attack fill:#7f1d1d,stroke:#fecaca,stroke-width:2px,color:#ffffff
    classDef defend fill:#14532d,stroke:#bbf7d0,stroke-width:2px,color:#ffffff
    linkStyle default stroke:#94a3b8,stroke-width:2px

Product field names and menu labels drift between versions, and none of the appendix material has been tested in your environment, so treat it as a starting point to validate rather than something to paste into production. Everything in the appendix starts in log, count or report only mode, with enforcement shown as a separate step.

5.1 Exposed and unpatched internet facing applications

Keep a live inventory of everything that faces the internet, and patch known exploited vulnerabilities first, using CISA’s Known Exploited Vulnerabilities catalog to prioritise rather than working through CVSS scores in order. I made the broader case for this in The CVE Wave Is Coming and Most Organisations Are Not Prepared: with tens of thousands of CVEs a year and the time to exploit collapsing, monthly patch cycles can’t keep up, so you have to prioritise by real exposure and active exploitation and be allowed to patch critical systems outside maintenance windows. Appendix 9.1 matches the whole KEV catalogue against the products you run; its output is a list of candidates that each need a version and exposure check, and the old entries matter as much as the new ones.

Admin interfaces should sit behind a VPN or an IP allowlist, or be removed if nobody needs them from outside. Appendix 9.2 checks hosts you own for exposed admin paths and open directory listings. A 401 or 403 is still a finding, because it means the panel is reachable and the next scanner along will try credentials against it.

5.2 Web application filter evasion

Attackers encode or reshape requests so that WAF rules no longer match, while the application behind the WAF still decodes them into something malicious. The fix is to normalise input before inspection, so the rules see exactly what the application sees, and to back that with input validation and parameterised queries in the application itself. With the OWASP Core Rule Set v4 you can run the stricter paranoia level 2 rules for detection while only level 1 matches count towards a block, which gives you evidence about what PL2 would catch before users feel anything. Appendix 9.3 has that configuration plus rules that log double and mixed encoding and decoded admin path access, and appendix 9.4 has the AWS WAF equivalent. Whichever WAF you use, send the same test payload plain, encoded, double encoded and in mixed case, and confirm all four are logged.

5.3 Credential spraying and weak authentication

Low and slow password attempts spread across many accounts slip past lockout policies designed for an attacker hammering one account. Enforce MFA on all remote, admin and cloud access, and block the legacy authentication protocols that skip it; appendix 9.5 creates that Entra ID Conditional Access policy in report only mode. Alert on many failed logins across many accounts from one source, which appendix 9.6 does for Entra (Sentinel) and on premises Active Directory (Falcon), and use sign in risk and named locations so a sprayed password from an unfamiliar place is challenged even when it’s correct.

5.4 Reconnaissance and network scanning

Once an agent has a foothold, it maps the internal network patiently and thoroughly. Segmentation limits how much one compromised host can see, and the quickest win is usually stopping workstations from talking SMB, RDP and WinRM to each other, which almost no business process needs. Monitor east west traffic, not just the perimeter: appendix 9.7 flags any machine reaching more than 50 internal hosts or 100 ports in an hour, and you’ll need to exclude your scanners, patch servers and domain controllers after the first run.

5.5 Backdoors, persistence and EDR coverage

Implants like BLOODALCHEMY are built for long term access. The first control is EDR on every host, because the attackers are explicitly looking for machines without it; in Falcon, the unmanaged assets view in Exposure Management lists hosts seen on the network with no sensor, and that list should be driven to zero or every entry should have an owner and an exception. The second is the policy itself, since a sensor in detect only mode will watch the implant load and do nothing; appendix 9.8 lists the prevention settings to check. Then audit scheduled tasks, services, startup items and new accounts on a regular cadence and diff the results week to week. Appendix 9.9 does this, and reports “unknown” rather than false reassurance when the Security log or auditing can’t prove an account wasn’t recently created.

5.6 Cloud identity, metadata and old keys

This subsection comes straight from CrowdStrike’s recommendations, because it maps directly to the documented intrusion paths. Enforce SAML signature validation on every application that accepts SAML, and test it by sending an unsigned assertion to a test instance; this is usually a setting in the application or its SSO library, so it needs checking per application. Require IMDSv2 on all cloud instances, which defeats the request forgery tricks used to steal instance credentials, and restrict which roles can execute commands on instances to the minimum set they need. Appendix 9.10 has the AWS commands and an example scoped policy. Finally, rotate signing keys, preauthentication keys and service credentials after any suspected exposure, including keys sitting in historical backups and directory exports, and turn on auditing for reads of the LAPS password attribute.

5.7 Supply chain and vendor access

Storm-0940 didn’t need to break into each downstream tenant, because the vendor’s application already had access. Build an inventory of every third party application with access to your tenant; appendix 9.11 exports every delegated and application permission in Entra ID. Focus on application permissions such as Mail.Read, Files.ReadWrite.All or Directory.ReadWrite.All, which work with no user present, and watch for changes to application credentials, which is exactly the persistence technique Microsoft observed. Then apply least privilege, require breach notification in contracts, and revoke integrations nobody can explain.

5.8 Slow response

Automated attacks outpace manual response, so playbooks need to exist before the alert fires. Automated containment helps, but isolating the wrong machine can take down a service, so start with a pilot group of hosts whose owners have approved it, chosen by business impact and how easily each one can be recovered, and trigger only on narrow, high confidence detections such as the published BLOODALCHEMY indicators, never on severity alone. Appendix 9.12 describes a Falcon Fusion workflow built that way.

For identity, appendix 9.13 disables an account and revokes its sessions, but be clear about the limits: access tokens already issued can stay valid until they expire, typically up to an hour or so, unless the application supports Continuous Access Evaluation, and SaaS applications with their own sessions need revoking separately. A complete containment step also resets the password, removes any MFA methods or app credentials the attacker added, and checks mailbox rules and OAuth consents. Tabletop exercises that assume hours rather than weeks will tell you whether your team can keep up.

6. Detection Markers to Hunt For

CrowdStrike’s VAPOR PANDA report is the primary source for these markers and also publishes BLOODALCHEMY hashes, so verify everything here against it before you block on anything. CrowdStrike warns the markers may change quickly, so treat them as hunting leads rather than durable detections. Appendix 9.14 turns them into Falcon queries and custom IOA rules.

TypeIndicatorNotes
Command lineartx, artexHunting lead; may change
Cloud role nameprefix artxCheck IAM and Entra role names
Admin command commentart18-Seen in comments on admin commands
FolderC:\ProgramData\artx5v\Host artefact
Processsvchost.exe outside \Windows\System32 or \SysWOW64Renamed legitimate GameHook binary
Loader DLLgraphics-hook-filter64.dllLoaded by the renamed svchost.exe
Encrypted payloadgraphics-hook_config.binDecrypted by the loader DLL
Sideloading hostBrDifxapi.exeDLL sideloading reported
C2 domainnginxmysql[.]comDefanged; block at DNS or proxy
C2 domainsqlserver-sqlite[.]comDefanged; block at DNS or proxy
C2 domainwww[.]ddduuuppp[.]comDefanged; block at DNS or proxy
BehaviourReads of ms-mcs-admpwd (LAPS)Needs an audit SACL on the attribute

There is also a third party ARTEX hunting pack on GitHub, but it hasn’t been verified, and one of its feeds is explicitly marked hunt only rather than suitable for blocking.

7. This Week’s Checklist

Adjust the owners to your own organisation, but keep the completion test, because “we looked at it” isn’t done.

#ActionOwnerDone whenAppendix
1Patch known exploited vulnerabilities on internet facing systemsVulnerability management leadCandidates version checked; every confirmed exposure patched or has a dated, risk accepted exception; script scheduled9.1
2Remove or restrict exposed admin interfacesNetwork or platform leadNo admin path reachable outside the allowlist; no open directory listings9.2
3Close MFA and legacy authentication gapsIdentity leadPolicy run in report only for a week, affected accounts fixed, policy enforced, MFA confirmed on all remote, admin and cloud access9.5
4Turn on credential spraying detectionSOC leadQueries run as scheduled alerts; a controlled test spray raises an alert someone acts on9.6
5Close EDR coverage gapsEndpoint leadUnmanaged assets list empty or every entry owned and excepted; prevention settings confirmed on every host group9.8
6Enforce SAML signature validation and IMDSv2Cloud and application security leadsEvery SAML app rejects an unsigned test assertion; no instances allow IMDSv1; IMDSv2 is the account default9.10
7Rotate historically exposed keysIdentity and cloud leadsEvery key or service credential past policy, or present in an unaccounted backup or export, rotated5.6
8Review vendor and application accessIdentity lead with procurementEvery application permission has a named business owner; anything unrecognised or unused revoked9.11
9Hunt for the published ARTEX markersThreat hunting or SOC leadQueries run across full retention, results triaged, domains blocked at DNS or proxy9.14
10Validate WAF normalisationApplication security leadPlain, encoded, double encoded and mixed case payloads all logged in staging; PL2 detection results reviewed9.3, 9.4
11Prepare containmentIncident response leadPilot group approved by owners, workflow live for it, account containment script tested, tabletop has measured alert to containment time9.12, 9.13

8. Conclusion

None of this is new advice. ARTEX doesn’t use exotic exploits; it finds the unpatched appliance, the sprayable account, the unsigned SAML assertion, the forgotten key and the host without a sensor, and it does so faster and across more organisations than a human team ever could. What it changes is the cost of leaving those gaps open, because the attacker no longer needs to be patient or skilled to find them.

So work through the checklist, and then come back to the uncomfortable question from section 4. If you still see no sign of anyone probing you, make sure that’s because there’s nothing there, and not because you can’t see it.

9. Technical Appendix

Everything below is a starting point to adapt and test, not a production change to paste in. Field names in Falcon and Graph can vary by tenant and version, so check each one against your own environment, and run anything that can block or isolate in log, count or report only mode first.

9.1 KEV candidate list

This matches the full CISA KEV catalogue against a simple list of the vendors and products you run. Pass a number of days as the second argument if you also want a “recently added” view, but don’t use that as your only view, because older entries are still exploited.

cat > kev_candidates.sh << 'EOF'
#!/usr/bin/env bash
# Usage: ./kev_candidates.sh inventory.txt [days]
# inventory.txt: one vendor or product name per line, e.g. "Fortinet", "Ivanti", "Citrix"
# Output: KEV CANDIDATES. Each needs a version check and an exposure check before it is a finding.
set -euo pipefail
INVENTORY="${1:?inventory file required}"
DAYS="${2:-0}"   # 0 = whole catalogue (default)
FEED="https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json"
SINCE="0000-00-00"
[ "$DAYS" -gt 0 ] && SINCE=$(date -u -d "-${DAYS} days" +%Y-%m-%d)

curl -fsSL "$FEED" -o /tmp/kev.json

printf 'ransomware\tdateAdded\tcveID\tvendor\tproduct\tcisaDueDate\n'
while IFS= read -r term; do
  [ -z "$term" ] && continue
  jq -r --arg t "$term" --arg since "$SINCE" '
    .vulnerabilities[]
    | select((.vendorProject + " " + .product) | test($t; "i"))
    | select(.dateAdded >= $since)
    | [.knownRansomwareCampaignUse, .dateAdded, .cveID, .vendorProject, .product, .dueDate]
    | @tsv' /tmp/kev.json
done < "$INVENTORY" | sort -u | sort -t$'\t' -k1,1r -k2,2r
EOF
chmod +x kev_candidates.sh

Entries with known ransomware use are listed first because they’re a reasonable tiebreaker, but this is sorting, not risk ranking; real priority comes from whether the affected version is installed and reachable.

9.2 External exposure check

Only run this against hosts you own or are authorised to test.

cat > exposure_check.sh << 'EOF'
#!/usr/bin/env bash
# Usage: ./exposure_check.sh hosts.txt
set -uo pipefail
HOSTS="${1:?hosts file required}"
PATHS=(/admin /administrator /wp-admin /wp-login.php /manager/html /phpmyadmin /console /actuator /jenkins /.git/HEAD /server-status /backup /uploads)

while IFS= read -r host; do
  [ -z "$host" ] && continue
  for p in "${PATHS[@]}"; do
    url="https://${host}${p}"
    body=$(curl -sk -m 8 -o - -w '\n%{http_code}' "$url") || continue
    code=$(tail -n1 <<< "$body")
    if [[ "$code" =~ ^(200|401|403)$ ]]; then
      flag=""
      grep -qi "<title>Index of" <<< "$body" && flag="OPEN_DIRECTORY"
      printf '%s\t%s\t%s\n' "$code" "$url" "$flag"
    fi
  done
done < "$HOSTS"
EOF
chmod +x exposure_check.sh

9.3 ModSecurity and OWASP CRS v4

Step one is detection only. Paranoia level 2 rules run and log, but only paranoia level 1 matches count towards blocking, and the custom rules all pass.

cat > /etc/modsecurity/custom/artex-detect.conf << 'EOF'
# CRS v4: block at PL1, but run and log PL2 rules for evaluation
SecAction "id:900000,phase:1,pass,nolog,t:none,setvar:tx.blocking_paranoia_level=1"
SecAction "id:900001,phase:1,pass,nolog,t:none,setvar:tx.detection_paranoia_level=2"

# Log double URL encoding (%25xx) in the raw URI: rarely legitimate, common in evasion
SecRule REQUEST_URI_RAW "@rx (?i)%25[0-9a-f]{2}" \
  "id:1009001,phase:1,pass,log,t:none,severity:'WARNING',tag:'artex/hunt',msg:'Double URL encoding in URI'"

# Log IIS style %u encoding and overlong UTF-8 sequences
SecRule REQUEST_URI_RAW "@rx (?i)(%u[0-9a-f]{4}|%c0%a[ef]|%e0%80%af)" \
  "id:1009002,phase:1,pass,log,t:none,severity:'WARNING',tag:'artex/hunt',msg:'Mixed or overlong encoding in URI'"

# Log admin path access from non allowlisted sources, matched AFTER decoding and normalisation
SecRule REQUEST_FILENAME "@rx ^/(admin|administrator|wp-admin|manager/html|phpmyadmin|actuator|console)(/|$)" \
  "id:1009003,phase:1,pass,log,t:none,t:urlDecodeUni,t:urlDecodeUni,t:lowercase,t:normalizePath,msg:'Admin path from non allowlisted IP',chain"
  SecRule REMOTE_ADDR "!@ipMatch 10.0.0.0/8,192.0.2.10"
EOF

Step two, once you’ve reviewed a week or more of logs and tuned out false positives, is enforcement. Raise tx.blocking_paranoia_level to 2 only if the PL2 results were clean enough, and change rule 1009003 from pass to deny,status:403:

cat > /etc/modsecurity/custom/artex-enforce.conf << 'EOF'
SecAction "id:900000,phase:1,pass,nolog,t:none,setvar:tx.blocking_paranoia_level=2"

SecRule REQUEST_FILENAME "@rx ^/(admin|administrator|wp-admin|manager/html|phpmyadmin|actuator|console)(/|$)" \
  "id:1009003,phase:1,deny,status:403,log,t:none,t:urlDecodeUni,t:urlDecodeUni,t:lowercase,t:normalizePath,msg:'Admin path from non allowlisted IP',chain"
  SecRule REMOTE_ADDR "!@ipMatch 10.0.0.0/8,192.0.2.10"
EOF

Load one file or the other, not both, since they reuse the same rule IDs.

9.4 AWS WAF

Start with the managed rule groups AWSManagedRulesCommonRuleSet, AWSManagedRulesKnownBadInputsRuleSet, AWSManagedRulesSQLiRuleSet and AWSManagedRulesAdminProtectionRuleSet, using rule action overrides set to Count until you’ve reviewed what they match. Then add these two custom rules, also in Count mode:

[
  {
    "Name": "count-double-encoding",
    "Priority": 10,
    "Action": { "Count": {} },
    "Statement": {
      "RegexMatchStatement": {
        "RegexString": "(?i)%25[0-9a-f]{2}",
        "FieldToMatch": { "UriPath": {} },
        "TextTransformations": [{ "Priority": 0, "Type": "NONE" }]
      }
    },
    "VisibilityConfig": { "SampledRequestsEnabled": true, "CloudWatchMetricsEnabled": true, "MetricName": "count-double-encoding" }
  },
  {
    "Name": "rate-limit-login",
    "Priority": 20,
    "Action": { "Count": {} },
    "Statement": {
      "RateBasedStatement": {
        "Limit": 100,
        "AggregateKeyType": "IP",
        "ScopeDownStatement": {
          "ByteMatchStatement": {
            "SearchString": "/login",
            "FieldToMatch": { "UriPath": {} },
            "PositionalConstraint": "STARTS_WITH",
            "TextTransformations": [{ "Priority": 0, "Type": "LOWERCASE" }]
          }
        }
      }
    },
    "VisibilityConfig": { "SampledRequestsEnabled": true, "CloudWatchMetricsEnabled": true, "MetricName": "rate-limit-login" }
  }
]

Once the CloudWatch metrics and sampled requests show the rate limit only catching traffic you’re happy to lose, change rate-limit-login from "Count": {} to "Block": {}. The double encoding rule can usually stay in Count permanently as a hunting signal.

9.5 Entra ID: block legacy authentication (report only)

Replace the placeholder with the object ID of your break glass account so you can’t lock yourself out. Change state to enabled only after reviewing a week of report only results in the sign in logs.

cat > block_legacy_auth.ps1 << 'EOF'
# Requires: Install-Module Microsoft.Graph -Scope CurrentUser
Connect-MgGraph -Scopes "Policy.ReadWrite.ConditionalAccess","Policy.Read.All"

$policy = @{
  displayName = "Block legacy authentication"
  state       = "enabledForReportingButNotEnforced"
  conditions  = @{
    users          = @{ includeUsers = @("All"); excludeUsers = @("<BREAK-GLASS-OBJECT-ID>") }
    applications   = @{ includeApplications = @("All") }
    clientAppTypes = @("exchangeActiveSync","other")
  }
  grantControls = @{ operator = "OR"; builtInControls = @("block") }
}

New-MgIdentityConditionalAccessPolicy -BodyParameter $policy
EOF
chmod +x block_legacy_auth.ps1

9.6 Credential spraying detection

For Entra sign in logs in Microsoft Sentinel or Log Analytics, this finds sources that failed against more than ten distinct accounts in any ten minute window. Error 50126 is a bad password and 50053 is a locked or smart locked account.

SigninLogs
| where TimeGenerated > ago(24h)
| where ResultType in ("50126", "50053")
| summarize Accounts = dcount(UserPrincipalName),
            Attempts = count(),
            SampleUsers = make_set(UserPrincipalName, 10)
            by IPAddress, bin(TimeGenerated, 10m)
| where Accounts > 10
| order by Accounts desc

For on premises Active Directory, Falcon records failed logons as UserLogonFailed2 events (LogScale syntax; confirm the field names in your tenant):

#event_simpleName=UserLogonFailed2
| groupBy([RemoteAddressIP4], function=[count(UserName, distinct=true, as=Accounts), count(as=Attempts)])
| test(Accounts > 20)
| sort(Accounts, order=desc)

9.7 Internal scanning detection (Falcon)

#event_simpleName=NetworkConnectIP4
| cidr(RemoteAddressIP4, subnet=["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"])
| groupBy([aid, ComputerName], function=[
    count(RemoteAddressIP4, distinct=true, as=Hosts),
    count(RemotePort, distinct=true, as=Ports)
  ])
| test(Hosts > 50 or Ports > 100)
| sort(Hosts, order=desc)

9.8 Falcon prevention policy settings to check

Setting names vary slightly by sensor version and operating system, so use these as a checklist against your console:

  1. Cloud machine learning and sensor machine learning set to at least Moderate for both detection and prevention, and Aggressive on servers once you’ve tested it.
  2. Suspicious Processes, Suspicious Registry Operations, Suspicious Scripts and Commands, and Intelligence Sourced Threats all enabled, since these behavioural preventions catch implants that signatures miss.
  3. Script Based Execution Monitoring and Interpreter Only protection enabled, along with Quarantine so detected files are actually removed.
  4. Sensor tamper protection and uninstall protection enabled in the sensor update policy, because the first thing a competent intruder does is try to switch the sensor off.

9.9 Windows persistence audit

Run as administrator. The local account section captures each user before matching, reads event 4720 once, matches on the structured TargetSid field, and reports “unknown” when it can’t prove an account wasn’t recently created.

cat > persistence_audit.ps1 << 'EOF'
# Run as administrator. Outputs CSVs to the current folder.
$since = (Get-Date).AddDays(-30)

Get-ScheduledTask |
  Where-Object { $_.TaskPath -notlike '\Microsoft\*' } |
  Select-Object TaskName, TaskPath, State, Author,
    @{n='Execute';e={($_.Actions | ForEach-Object Execute) -join '; '}},
    @{n='Arguments';e={($_.Actions | ForEach-Object Arguments) -join '; '}} |
  Export-Csv scheduled_tasks.csv -NoTypeInformation

Get-CimInstance Win32_Service |
  Where-Object { $_.StartMode -eq 'Auto' -and $_.PathName -notmatch '(?i)\\Windows\\' } |
  Select-Object Name, DisplayName, State, StartName, PathName |
  Export-Csv services_non_windows.csv -NoTypeInformation

Get-CimInstance Win32_StartupCommand |
  Select-Object Name, Command, Location, User |
  Export-Csv startup_items.csv -NoTypeInformation

# --- Local accounts created recently ---
# Is account creation being audited? (output text is locale dependent; English shown)
$auditOn = (auditpol /get /subcategory:"User Account Management") -match 'Success'

# Does the Security log reach back far enough?
$oldest   = (Get-WinEvent -LogName Security -MaxEvents 1 -Oldest).TimeCreated
$covered  = $auditOn -and ($oldest -le $since)

# Read event 4720 once and index creations by the new account's SID
$created = @{}
try {
  Get-WinEvent -FilterHashtable @{ LogName='Security'; Id=4720; StartTime=$since } -ErrorAction Stop |
    ForEach-Object {
      $evt = $_
      $xml = [xml]$evt.ToXml()
      $sid = ($xml.Event.EventData.Data | Where-Object { $_.Name -eq 'TargetSid' }).'#text'
      if ($sid) { $created[$sid] = $evt.TimeCreated }
    }
} catch {
  if ($_.FullyQualifiedErrorId -notlike 'NoMatchingEventsFound*') { throw }
}

Get-LocalUser | Where-Object { $_.Enabled } | ForEach-Object {
  $user = $_
  $sid  = $user.SID.Value
  $status =
    if ($created.ContainsKey($sid)) { "Created $($created[$sid])" }
    elseif ($covered)               { "Not created in the last 30 days" }
    else                            { "Unknown: auditing off or Security log only reaches back to $oldest" }
  [pscustomobject]@{ Name = $user.Name; SID = $sid; LastLogon = $user.LastLogon; CreationCheck = $status }
} | Export-Csv local_accounts.csv -NoTypeInformation
EOF
chmod +x persistence_audit.ps1

9.10 AWS: IMDSv2 and command execution scope

Find instances that still allow IMDSv1, enforce IMDSv2 on one instance, and make IMDSv2 the default for new instances in a region:

cat > imdsv2_enforce.sh << 'EOF'
#!/usr/bin/env bash
# Usage: ./imdsv2_enforce.sh <region> [instance-id]
set -euo pipefail
REGION="${1:?region required}"
INSTANCE="${2:-}"

echo "Instances still allowing IMDSv1 in $REGION:"
aws ec2 describe-instances --region "$REGION" \
  --query "Reservations[].Instances[?MetadataOptions.HttpTokens=='optional'].[InstanceId,Tags[?Key=='Name']|[0].Value]" \
  --output text

if [ -n "$INSTANCE" ]; then
  # Test the workload first: very old SDKs and agents may not support IMDSv2
  aws ec2 modify-instance-metadata-options --region "$REGION" \
    --instance-id "$INSTANCE" --http-tokens required --http-endpoint enabled
fi

# Default for new instances launched in this region
aws ec2 modify-instance-metadata-defaults --region "$REGION" --http-tokens required
EOF
chmod +x imdsv2_enforce.sh

To scope command execution, give the roles that run Systems Manager commands a policy that only allows ssm:SendCommand against instances carrying a specific tag, rather than "Resource": "*":

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "ssm:SendCommand",
      "Resource": "arn:aws:ec2:*:*:instance/*",
      "Condition": { "StringEquals": { "ssm:resourceTag/CommandScope": "app-team-a" } }
    },
    {
      "Effect": "Allow",
      "Action": "ssm:SendCommand",
      "Resource": "arn:aws:ssm:*:*:document/AWS-RunShellScript"
    }
  ]
}

9.11 Entra ID vendor access audit

cat > vendor_access_audit.ps1 << 'EOF'
Connect-MgGraph -Scopes "Application.Read.All","Directory.Read.All"

# Delegated (user consented or admin consented) permissions
Get-MgOauth2PermissionGrant -All |
  ForEach-Object {
    $grant = $_
    $sp = Get-MgServicePrincipal -ServicePrincipalId $grant.ClientId
    [pscustomobject]@{ App=$sp.DisplayName; AppId=$sp.AppId; ConsentType=$grant.ConsentType; Scope=$grant.Scope }
  } | Export-Csv delegated_grants.csv -NoTypeInformation

# Application permissions (no user in the loop: the highest risk)
Get-MgServicePrincipal -All -Filter "servicePrincipalType eq 'Application'" |
  ForEach-Object {
    $sp = $_
    Get-MgServicePrincipalAppRoleAssignment -ServicePrincipalId $sp.Id |
      Select-Object @{n='App';e={$sp.DisplayName}}, @{n='Publisher';e={$sp.PublisherName}},
                    ResourceDisplayName, AppRoleId, CreatedDateTime
  } | Export-Csv application_permissions.csv -NoTypeInformation
EOF
chmod +x vendor_access_audit.ps1

9.12 Falcon Fusion containment workflow (pilot)

Build the workflow so that it only ever acts on the approved pilot group, and only on narrow detections:

  1. Create a host group containing only the pilot hosts agreed with their owners.
  2. Create a Fusion workflow triggered by a new endpoint detection, with conditions that the host is in the pilot group and that the detection matches one of your specific high confidence rules, such as the custom IOAs in appendix 9.14 or a match on CrowdStrike’s published BLOODALCHEMY indicators. Don’t use severity and tactic on their own as the trigger.
  3. Add the action to network contain the host, which keeps it talking to the Falcon cloud so you can still investigate remotely, followed by a notification to the SOC channel and the system owner.
  4. Run it for a few weeks, review every containment, and only then widen the host group.

9.13 Disable an account and revoke sessions

cat > contain_user.ps1 << 'EOF'
param([Parameter(Mandatory)][string]$UserPrincipalName)
Connect-MgGraph -Scopes "User.ReadWrite.All","User.RevokeSessions.All"

Update-MgUser -UserId $UserPrincipalName -AccountEnabled:$false
Revoke-MgUserSignInSession -UserId $UserPrincipalName
Write-Host "Disabled $UserPrincipalName and revoked refresh tokens at $(Get-Date -Format o)"
Write-Host "Already issued access tokens may stay valid until expiry unless the app supports CAE."
Write-Host "Next: reset password, remove attacker added MFA methods and app credentials,"
Write-Host "      check mailbox rules and OAuth consents, revoke sessions in SaaS apps with their own sessions."
EOF
chmod +x contain_user.ps1

9.14 ARTEX marker hunting (Falcon)

Any svchost.exe running from somewhere other than the Windows system folders, which is suspicious regardless of ARTEX:

#event_simpleName=ProcessRollup2
| ImageFileName=/\\svchost\.exe$/i
| ImageFileName!=/\\Windows\\(System32|SysWOW64)\\svchost\.exe$/i
| table([@timestamp, ComputerName, UserName, ImageFileName, CommandLine, ParentBaseFileName])

File names, folder and command line strings from the loader chain:

(CommandLine=/artx|artex|art18-|artx5v/i) or (FileName=/^(graphics-hook-filter64\.dll|graphics-hook_config\.bin|BrDifxapi\.exe)$/i) or (TargetFileName=/\\ProgramData\\artx5v\\/i)
| table([@timestamp, #event_simpleName, ComputerName, FileName, TargetFileName, CommandLine])

DNS lookups of the reported domains and their subdomains (the query needs the real domains, so they aren’t defanged here):

#event_simpleName=DnsRequest
| DomainName=/(^|\.)(nginxmysql\.com|sqlserver-sqlite\.com|ddduuuppp\.com)$/i
| table([@timestamp, ComputerName, DomainName, ContextBaseFileName])

For custom IOAs, create a process creation rule in Falcon’s Custom IOA Rule Groups with an image file name regex such as .*\\(ProgramData|Users|Temp)\\.*\\svchost\.exe, and a second with a command line regex such as .*artx5v.*. Set both to Detect first, and move them to Kill Process only once they’ve run clean for a week.

Sources

Leave a comment

Your email address will not be published. Your first comment is held for approval.