CVE-2026-118737: Audit NTLM Signing Before Enforcement

Cryptographic signing gate validating NTLM authentication traffic between Windows server nodes

Microsoft began a phased change to NTLM behavior on November 10, 2026, as part of the response to CVE-2026-118737. The first phase does not immediately block unsigned NTLM sessions. Instead, updated Windows clients offer real NTLM signing by default, servers continue accepting both signed and unsigned connections, and new audit data helps administrators find dependencies that will break when enforcement arrives.

This is an infrastructure migration, not a single checkbox. Security teams need to distinguish cryptographically signed sessions from the older “always sign” placeholder, collect the right client and server events, remediate legacy applications, and pilot enforcement before Microsoft’s planned second phase in May 2027.

What changed on November 10, 2026?

Microsoft’s NTLM signing security-improvements guidance describes a two-phase rollout across supported Windows clients and Windows Server releases.

  • Phase 1 — November 10, 2026: updated clients offer NTLM signing on non-anonymous connections. Servers accept signed and unsigned sessions while producing audit evidence.
  • Phase 2 — planned for May 2027: servers require signing by default and reject clients that do not negotiate it.

Kerberos authentication is unaffected. Anonymous or null sessions and guest authentication are also exempt from the new signing requirement. That does not make those paths low risk; it means they must be inventoried and governed separately.

Why NTLM signing matters

NTLM signing protects the integrity of messages after authentication. A properly negotiated session uses the session key to calculate a signature for protected messages, making silent modification and common relay-style manipulation substantially harder.

The important word is properly. NTLM has two similarly named negotiation flags that are not equivalent:

  • NTLMSSP_NEGOTIATE_SIGN (0x00000010) requests real message signing.
  • NTLMSSP_NEGOTIATE_ALWAYS_SIGN (0x00008000) is a legacy compatibility flag. By itself, it does not provide cryptographic message integrity.

For a session to be ready for enforcement, Microsoft says the negotiation should include both NTLMSSP_NEGOTIATE_SIGN and NTLMSSP_NEGOTIATE_KEY_EXCH (0x40000000), and the audit record should show that a session key is present. Treat “ALWAYS_SIGN only” as unsigned for migration purposes.

Affected Windows Server updates

Install the November 2026 cumulative security update appropriate to each server release before relying on the new behavior. The relevant initial releases are:

PlatformNovember updateOS build
Windows Server 2025KB513108026100.33822
Windows Server 2022KB513109020348.5870
Windows Server 2019KB513108517763.9487
Windows Server 2016KB513129114393.9688

Use your normal servicing rings and verify the final build after installation. Microsoft can revise update prerequisites and known-issue guidance, so recheck the release note for each operating system before broad deployment.

Audit before you enforce

The most useful evidence lives in the Microsoft-Windows-NTLM/Operational log. Microsoft documents enhanced events for both sides of the connection:

  • Event 4022: client-side NTLM negotiation detail.
  • Event 4023: server-side negotiation detail and the best starting point for finding incoming unsigned sessions.

Do not filter only on the event level. Microsoft notes that both signed and unsigned records can appear as Warning. Parse the negotiated flags and session-key status instead. Event availability and field detail depend on the installed Windows release and cumulative update, so validate the schema on each supported build before committing a SIEM parser.

PowerShell: collect recent NTLM audit events

Run this from an elevated PowerShell session on a patched test server. It reads events only; it does not change authentication settings.

$log = 'Microsoft-Windows-NTLM/Operational'
$since = (Get-Date).AddHours(-24)

Get-WinEvent -FilterHashtable @{
    LogName   = $log
    Id        = 4022, 4023
    StartTime = $since
} -ErrorAction Stop |
Select-Object TimeCreated, Id, LevelDisplayName, MachineName, Message |
Export-Csv -NoTypeInformation -Encoding UTF8 .ntlm-signing-audit.csv

Write-Host "Saved $((Import-Csv .ntlm-signing-audit.csv).Count) records"

If the channel is disabled, enable it through Event Viewer under Applications and Services Logs → Microsoft → Windows → NTLM → Operational, or manage it through your existing event-log policy. Forward the events to the same workspace that receives domain-controller and server authentication telemetry.

How to classify each connection

A useful readiness rule should evaluate all three conditions, not just the presence of a word such as “sign” in the message:

  1. The SIGN bit (0x00000010) is set.
  2. The KEY_EXCH bit (0x40000000) is set.
  3. The session-key status is Present.

Classify anything else for investigation. A missing SIGN bit indicates an unsigned client. SIGN without key exchange is incomplete. Both flags with a missing session key require validation because the expected cryptographic material was not established.

Hands-on lab: test a readiness classifier safely

This isolated lab uses synthetic records, so it is safe to run on a workstation and does not probe a domain. It demonstrates the logic your SIEM query or enrichment pipeline should implement. The sample is intentionally small; production parsers must map fields from the actual XML schema emitted by your patched Windows builds.

Prerequisites

  • Python 3.9 or later.
  • An empty working directory.
  • No administrative privileges or network access.

1. Create synthetic input

cat > ntlm-events.csv <<'CSV'
server,client,event_id,flags,session_key,status
filesrv01,win11-01,4023,0x40000010,Present,Success
legacyapp01,old-scanner,4023,0x00008000,Missing,Success
websrv02,app-node-03,4023,0x00000010,Present,Success
sqlsrv01,batch-node-02,4023,0x40000010,Missing,Success
filesrv02,old-nas,4023,0x00008000,Missing,0x80090302
CSV

2. Run the classifier

#!/usr/bin/env python3
import csv

SIGN = 0x00000010
KEY_EXCH = 0x40000000

def classify(row):
    flags = int(row["flags"], 16)
    if row["status"].lower() == "0x80090302":
        return "REJECTED"
    if not flags & SIGN:
        return "UNSIGNED"
    if not flags & KEY_EXCH:
        return "KEY_EXCHANGE_MISSING"
    if row["session_key"].lower() != "present":
        return "SESSION_KEY_MISSING"
    return "READY"

with open("ntlm-events.csv", newline="", encoding="utf-8") as source:
    for event in csv.DictReader(source):
        print(f'{event["client"]:16} -> {event["server"]:12} {classify(event)}')

Save the script as classify-ntlm.py, then execute:

python3 classify-ntlm.py

Expected output:

win11-01         -> filesrv01    READY
old-scanner      -> legacyapp01  UNSIGNED
app-node-03      -> websrv02     KEY_EXCHANGE_MISSING
batch-node-02    -> sqlsrv01     SESSION_KEY_MISSING
old-nas          -> filesrv02    REJECTED

Troubleshooting and cleanup

  • If Python reports ValueError, confirm that every flag begins with 0x and contains only hexadecimal digits.
  • If a column is missing, keep the CSV header exactly as shown.
  • On Windows PowerShell, create the CSV with a here-string or save it from a text editor; the classification logic is unchanged.
rm -f ntlm-events.csv classify-ntlm.py

A phased deployment plan

1. Patch clients and servers first

Signing can only be negotiated consistently when both endpoints have current behavior. Start with representative Windows clients and application servers, confirm the builds, then expand through normal servicing rings.

2. Build an unsigned-connection inventory

Group Event 4023 data by destination server, source device, application owner, account, and frequency. A single high-volume legacy scanner may produce more noise than a rarely used but business-critical line-of-business application. Count both connections and distinct dependencies.

3. Prefer Kerberos where it should already work

NTLM often appears because a service is reached by IP address, DNS aliases lack matching SPNs, time or name resolution is unhealthy, or a service account is misconfigured. Correcting those foundations reduces NTLM exposure instead of merely signing it. For broader architecture guidance, see our NIST zero-trust implementation analysis.

4. Pilot server enforcement

After the audit shows that a test server’s clients negotiate signing correctly, enable the server-side requirement:

$path = 'HKLM:SYSTEMCurrentControlSetControlLsaMSV1_0'

New-ItemProperty -Path $path `
  -Name 'ServerRequireNtlmSign' `
  -PropertyType DWord `
  -Value 1 `
  -Force

Get-ItemProperty -Path $path -Name 'ServerRequireNtlmSign'

Microsoft states that this setting does not require a restart. Even so, use a maintenance window for the first pilot because incompatible clients can lose access immediately. Monitor both authentication failures and application health.

If an updated client has a documented compatibility issue, ClientAllowUnsignedNtlm=1 under the same registry path can provide temporary relief. Record an owner and expiry date for every exception. Leaving it in place defeats the purpose of the migration.

5. Prepare failure detection

Once server enforcement is active, unsigned attempts can fail with SEC_E_UNSUPPORTED_FUNCTION (0x80090302). Alerting should connect that status to the source host, target service, user or service account, and the most recent successful unsigned audit record. That context turns an outage ticket into an actionable remediation task.

Operational safeguards

  • Do not enable enforcement everywhere at once. Start with low-dependency servers, then move to file services, application tiers, and critical infrastructure.
  • Do not treat warnings as failures. Read the negotiation flags and session-key state.
  • Do not make compatibility exceptions permanent. Track them like any other risk acceptance.
  • Do not confuse signing with NTLM retirement. Signing improves integrity, while Kerberos migration and NTLM restriction reduce the protocol’s overall attack surface.
  • Keep patch governance in the loop. The NTLM change ships through cumulative Windows updates; review release notes and deployment health together. Our Windows Server patch validation guide provides a complementary rollout checklist.

Conclusion

CVE-2026-118737 turns NTLM signing into a migration deadline. The November 2026 phase gives defenders a valuable observation window: patched clients begin offering real signing, servers expose compatibility evidence, and administrators can fix dependencies before default enforcement.

Use that window deliberately. Patch first, centralize Events 4022 and 4023, verify SIGN plus KEY_EXCH plus a present session key, move eligible services to Kerberos, and enforce signing in controlled rings. The goal is not merely to survive the May 2027 default change; it is to leave the environment with fewer opaque NTLM dependencies and a clearer path toward stronger authentication.

Official references

Similar Posts